hasDirective: boolean;

};

const compileDirectivePattern = (names: readonly string[], suffix = ""): RegExp => {

const namePattern = names.map(escapeRegExp).join("|");

return new RegExp(`(?:^|\\s)\\/(?:${namePattern})(?=$|\\s|:)${suffix}`, "i");

};

const THINK_DIRECTIVE_PATTERN = compileDirectivePattern(["thinking", "think", "t"]);

const VERBOSE_DIRECTIVE_PATTERN = compileDirectivePattern(["verbose", "v"]);

const TRACE_DIRECTIVE_PATTERN = compileDirectivePattern(["trace"]);

const FAST_DIRECTIVE_PATTERN = compileDirectivePattern(["fast"]);

const ELEVATED_DIRECTIVE_PATTERN = compileDirectivePattern(["elevated", "elev"]);

const REASONING_DIRECTIVE_PATTERN = compileDirectivePattern(["reasoning", "reason"]);

const STATUS_DIRECTIVE_PATTERN = compileDirectivePattern(["status"], `(?:\\s*:\\s*)?`);

const matchLevelDirective = (

body: string,

names: string[],

pattern: RegExp,

): { start: number; end: number; rawLevel?: string } | null => {

const namePattern = names.map(escapeRegExp).join("|");

const match = body.match(new RegExp(`(?:^|\\s)\\/(?:${namePattern})(?=$|\\s|:)`, "i"));

const match = body.match(pattern);

if (!match || match.index === undefined) {

return null;

}

const extractLevelDirective = <T>(

body: string,

names: string[],

pattern: RegExp,

normalize: (raw?: string) => T | undefined,

): ExtractedLevel<T> => {

const match = matchLevelDirective(body, names);

const match = matchLevelDirective(body, pattern);

if (!match) {

return { cleaned: body.trim(), hasDirective: false };

}

const extractSimpleDirective = (

body: string,

names: string[],

pattern: RegExp,

): { cleaned: string; hasDirective: boolean } => {

const namePattern = names.map(escapeRegExp).join("|");

const match = body.match(

new RegExp(`(?:^|\\s)\\/(?:${namePattern})(?=$|\\s|:)(?:\\s*:\\s*)?`, "i"),

);

const match = body.match(pattern);

const cleaned = match ? body.replace(match[0], " ").replace(/\s+/g, " ").trim() : body.trim();

return {

cleaned,

if (!body) {

return { cleaned: "", hasDirective: false };

}

const extracted = extractLevelDirective(body, ["thinking", "think", "t"], normalizeThinkLevel);

const extracted = extractLevelDirective(body, THINK_DIRECTIVE_PATTERN, normalizeThinkLevel);

return {

cleaned: extracted.cleaned,

thinkLevel: extracted.level,

if (!body) {

return { cleaned: "", hasDirective: false };

}

const extracted = extractLevelDirective(body, ["verbose", "v"], normalizeVerboseLevel);

const extracted = extractLevelDirective(body, VERBOSE_DIRECTIVE_PATTERN, normalizeVerboseLevel);

return {

cleaned: extracted.cleaned,

verboseLevel: extracted.level,

if (!body) {

return { cleaned: "", hasDirective: false };

}

const extracted = extractLevelDirective(body, ["trace"], normalizeTraceLevel);

const extracted = extractLevelDirective(body, TRACE_DIRECTIVE_PATTERN, normalizeTraceLevel);

return {

cleaned: extracted.cleaned,

traceLevel: extracted.level,

if (!body) {

return { cleaned: "", hasDirective: false };

}

const extracted = extractLevelDirective(body, ["fast"], normalizeFastMode);

const extracted = extractLevelDirective(body, FAST_DIRECTIVE_PATTERN, normalizeFastMode);

return {

cleaned: extracted.cleaned,

fastMode: extracted.level,

if (!body) {

return { cleaned: "", hasDirective: false };

}

const extracted = extractLevelDirective(body, ["elevated", "elev"], normalizeElevatedLevel);

const extracted = extractLevelDirective(body, ELEVATED_DIRECTIVE_PATTERN, normalizeElevatedLevel);

return {

cleaned: extracted.cleaned,

elevatedLevel: extracted.level,

if (!body) {

return { cleaned: "", hasDirective: false };

}

const extracted = extractLevelDirective(body, ["reasoning", "reason"], normalizeReasoningLevel);

const extracted = extractLevelDirective(

body,

REASONING_DIRECTIVE_PATTERN,

normalizeReasoningLevel,

);

return {

cleaned: extracted.cleaned,

reasoningLevel: extracted.level,

if (!body) {

return { cleaned: "", hasDirective: false };

}

return extractSimpleDirective(body, ["status"]);

return extractSimpleDirective(body, STATUS_DIRECTIVE_PATTERN);

}

export type { ElevatedLevel, NoticeLevel, ReasoningLevel, ThinkLevel, TraceLevel, VerboseLevel };