/** * Pure detectors for recognizing AI assistant action proposals and user * short replies (affirmative / negative). Used by the chat UI to render * a quick action confirmation bar instead of requiring the user to type. * * Detectors are intentionally narrow: * - A "proposal" requires both a first-person/asking phrase AND an * actionable intent verb (execute query, fetch data, investigate, etc.) * - Affirmative / negative detectors only match short replies (the user * typing a couple of words). Long replies fall through. * * Side-effect free. Safe to import from anywhere. */ /** Trim whitespace, leading/trailing punctuation (CJK + ASCII) for short-reply matching. */ function stripOuterPunctuation(input: string): string { return input .replace(/^[\s ]+/, "") .replace(/[\s ]+$/, "") .replace(/^[!?.,;:!?。,;:]+/, "") .replace(/[!?.,;:!?。,;:]+$/, ""); } /** Returns the last non-empty line/sentence-ish chunk of the assistant message. */ export function lastNonEmptyLine(content: string): string { const lines = content.split(/\r?\n/); for (let i = lines.length - 1; i >= 0; i--) { const trimmed = lines[i].trim(); if (trimmed) return trimmed; } return ""; } /** True when the string contains at least one CJK ideograph. */ export function containsChinese(input: string): boolean { return /[一-鿿]/.test(input); } // Phrases that indicate the assistant is asking permission to take an action. const ZH_ASK_PHRASES = [ /需要我/, // "do you need me to" /要不要我/, // "shall I" /是否需要/, // "is it needed" /帮我?(?:你)?/, // "shall I help" (loose) /我来/, // "let me" /我帮你/, // "let me help you" /我现在/, // "shall I now" /我可以/, // "may I" /我去/, // "shall I go" /我能/, // "may I" ]; const EN_ASK_PHRASES = [/\bshould\s+i\b/i, /\bdo\s+you\s+want\s+me\s+to\b/i, /\bwould\s+you\s+like\s+me\s+to\b/i, /\bwant\s+me\s+to\b/i, /\bshall\s+i\b/i, /\bcan\s+i\b/i, /\blet\s+me\s+know\s+if\s+you\s+want\s+me\s+to\b/i]; // Actionable intent verbs/phrases. Must co-occur with an ask phrase to count. const ZH_ACTION_PHRASES = [ /执行/, // execute /运行/, // run /查询/, // query /查看/, // view /看看/, /查一下/, // check /拉取/, // fetch /获取/, // get/fetch /读取/, // read /取出?/, // take out / extract /取数据/, /看看数据/, /看一下/, /分析/, // analyze /统计/, // count/aggregate /排查/, // investigate /调查/, // investigate /生成/, // generate /创建/, // create /列出/, // list /对比/, // compare ]; const EN_ACTION_PHRASES = [ /\bexecute\b/i, /\brun\b/i, /\bquery\b/i, /\bfetch\b/i, /\bpull\b/i, /\bretrieve\b/i, /\bread\b/i, /\bget\s+(?:the\s+)?(?:data|rows|sample|columns|results)\b/i, /\banalyze\b/i, /\binvestigate\b/i, /\bcheck\b/i, /\binspect\b/i, /\bgenerate\b/i, /\bcreate\b/i, /\blist\b/i, /\bcompare\b/i, /\bcount\b/i, /\bsample\b/i, ]; /** * Detect whether the assistant message ends with a proposal-style question * such as "Should I execute this query?" / "需要我拉取这两个表的数据吗?". * * Heuristic: * - Looks at the last non-empty line. * - Must end with a question mark (Chinese ? or English ?). * - Must contain BOTH a first-person ask phrase AND an actionable intent. * * Returns false for generic clarifying questions (no actionable verb). */ export function looksLikeActionProposal(content: string): boolean { if (!content) return false; const lastLine = lastNonEmptyLine(content); if (!lastLine) return false; // Must be a question. if (!/[??]\s*$/.test(lastLine)) return false; const isZh = containsChinese(lastLine); const askPhrases = isZh ? ZH_ASK_PHRASES : EN_ASK_PHRASES; const actionPhrases = isZh ? ZH_ACTION_PHRASES : EN_ACTION_PHRASES; const hasAsk = askPhrases.some((re) => re.test(lastLine)); if (!hasAsk) return false; const hasAction = actionPhrases.some((re) => re.test(lastLine)); return hasAction; } // Short affirmative words/phrases. Must match (after stripping punctuation / // whitespace) the entire reply for it to count — long replies fall through. const ZH_AFFIRMATIVE = [/^需要$/, /^需要的$/, /^要$/, /^要的$/, /^好$/, /^好的$/, /^可以$/, /^行$/, /^是$/, /^是的$/, /^对$/, /^对的$/, /^嗯$/, /^嗯嗯$/, /^OK$/i, /^OKK*$/i, /^没问题$/, /^请$/, /^麻烦了$/, /^来吧$/, /^继续$/]; const EN_AFFIRMATIVE = [/^yes$/i, /^yeah$/i, /^yep$/i, /^y$/i, /^ok$/i, /^okay$/i, /^k$/i, /^sure$/i, /^go$/i, /^go\s+ahead$/i, /^do\s+it$/i, /^please\s+do$/i, /^please$/i, /^proceed$/i, /^continue$/i, /^confirm(?:ed)?$/i]; const ZH_NEGATIVE = [/^不$/, /^不用$/, /^不用了$/, /^不需要$/, /^不要$/, /^别$/, /^先不$/, /^先不(?:用|要)$/, /^算了$/, /^不必$/, /^取消$/, /^停$/, /^先别$/]; const EN_NEGATIVE = [/^no$/i, /^nope$/i, /^nah$/i, /^n$/i, /^don'?t$/i, /^do\s+not$/i, /^not\s+needed$/i, /^skip$/i, /^cancel$/i, /^stop$/i, /^never\s*mind$/i, /^nvm$/i, /^hold\s+off$/i, /^not\s+now$/i]; /** * Detect "short affirmative" user replies like 需要 / 好 / 可以 / 是 / 对 / * 嗯 / yes / ok / sure / go ahead / do it. * * Long messages (multiple sentences, or words mixed with extra context) * intentionally do NOT match — those should be sent to the LLM normally. */ export function isShortAffirmative(content: string): boolean { const cleaned = stripOuterPunctuation(content); if (!cleaned) return false; // Reject when the reply has multiple words/lines unless still very short // and matches a known phrase (e.g. "go ahead" / "do it" / "好的"). if (cleaned.length > 24) return false; const all = [...ZH_AFFIRMATIVE, ...EN_AFFIRMATIVE]; return all.some((re) => re.test(cleaned)); } /** * Detect "short negative" user replies like 不用 / 不需要 / 不要 / no / * nope / don't / not needed. */ export function isShortNegative(content: string): boolean { const cleaned = stripOuterPunctuation(content); if (!cleaned) return false; if (cleaned.length > 24) return false; const all = [...ZH_NEGATIVE, ...EN_NEGATIVE]; return all.some((re) => re.test(cleaned)); } /** * Regular expression matching common SQL write/DDL keywords. * Shared between AiAssistant.vue and tests so the regex stays in one place. */ export const WRITE_SQL_KEYWORD_RE = /\b(insert|update|delete|replace|merge|create|alter|drop|truncate|rename|grant|revoke)\b/i; /** * Returns true when the text contains SQL write or DDL keywords. */ export function containsWriteSql(text: string): boolean { return WRITE_SQL_KEYWORD_RE.test(text); } /** * Returns true when the assistant message ends with an action proposal AND * the message as a whole contains write/DDL SQL keywords. * * Check order: * 1. Last non-empty line must be an action proposal (question mark + ask * phrase + action verb). * 2. The *entire message* (not just the last line) must contain at least * one write/DDL keyword (INSERT, DELETE, CREATE, etc.). * * This two-step check handles the common pattern where the model outputs * a SQL code block followed by a generic confirmation question like * "需要我执行这条 SQL 吗?" — the write keywords live in the code block, * not in the last line. * * **Safety rule**: the last line (the proposal itself) MUST explicitly * reference the write SQL or the write operation. A message where the * last line asks about a read operation but a write keyword appears * elsewhere is NOT treated as a write-SQL proposal — the assistant is * offering a read, not a write. Without this rule, confirming "need me * to query the remaining records?" could inadvertently grant write * permission because DELETE appeared earlier in the message. */ export function looksLikeWriteSqlProposal(content: string): boolean { if (!content) return false; const lastLine = lastNonEmptyLine(content); if (!lastLine) return false; // Step 1: last line must be an action proposal (ask + action + question mark). if (!/[??]\s*$/.test(lastLine)) return false; const isZh = containsChinese(lastLine); const askPhrases = isZh ? ZH_ASK_PHRASES : EN_ASK_PHRASES; const actionPhrases = isZh ? ZH_ACTION_PHRASES : EN_ACTION_PHRASES; if (!askPhrases.some((re) => re.test(lastLine))) return false; if (!actionPhrases.some((re) => re.test(lastLine))) return false; // Step 2: the full message must contain write/DDL SQL keywords somewhere // (typically in a code block or earlier sentence). if (!containsWriteSql(content)) return false; // Safety check: the last line must explicitly reference the write SQL or // the write/DDL operation itself. A last line that asks about a read // ("查询"/"query") but happens to have a write keyword elsewhere in the // message is NOT a write-SQL proposal — it is a read proposal. // We check for three signals: // a) The last line contains a write/DDL keyword directly, OR // b) The last line contains a "this SQL" / "这条 SQL" reference that // points back to the code block with the write SQL, OR // c) The content has a SQL code block AND the last line mentions // SQL / 执行 without specifying a different action (e.g. 查询). return lastLineMentionsWriteSql(lastLine, isZh, content); } /** * Returns true when the proposal line explicitly references a write/DDL * SQL operation (not a read-only action that happens to coexist with a * write keyword elsewhere in the message). */ function lastLineMentionsWriteSql(lastLine: string, isZh: boolean, fullContent: string): boolean { // Signal (a): last line contains a write/DDL keyword itself. if (containsWriteSql(lastLine)) return true; // Signal (b): last line references "this SQL" / "这条 SQL" / "这条语句" // pointing back to a code block that contains the write SQL. if (isZh) { if (/这条\s*SQL|这条\s*语句|这个\s*SQL|这段\s*SQL|上述\s*SQL|以上\s*SQL/.test(lastLine)) return true; } else { if (/this\s+SQL|the\s+SQL|this\s+statement|the\s+statement|this\s+query|the\s+query|above\s+SQL/.test(lastLine)) return true; } // Signal (c): message has a SQL code block AND the last line mentions // 执行/execute/run without specifying a different action like 查询/query. const hasCodeBlock = /```sql|```mysql|```postgresql|```sqlite|```tsql|```clickhouse|```\s*\n/.test(fullContent); if (hasCodeBlock) { if (isZh) { // Must mention 执行 or 运行 (execute/write-like), NOT 查询/查看 (read-like). if (/(?:执行|运行)/.test(lastLine) && !/(?:查询|查看|看看|看一下|读取)/.test(lastLine)) return true; } else { if (/\b(?:execute|run)\b/i.test(lastLine) && !/\b(?:query|read|fetch|retrieve|list|inspect|check|sample)\b/i.test(lastLine)) return true; } } return false; } /** Parameters for {@link shouldGrantWriteSqlOnShortAffirmative}. */ export interface WriteSqlGrantParams { mode: string; /** True when allowWriteSqlForNextRun has already been set, e.g. by the button path. */ alreadyGranted: boolean; isProduction: boolean; userText: string; /** * Conversation history BEFORE the current user text was pushed. * The function scans backward from the last message, skipping * contextSummary entries, and stops at the first user message. */ messages: Array<{ role: "user" | "assistant"; content: string; kind?: "contextSummary" }>; } /** * Pure-function extraction of the manual-confirmation gating logic used in * AiAssistant.vue send(). Returns true when the user just typed a short * affirmative reply (e.g. "可以"/"go ahead") and the most recent assistant * message before the user message is a write-SQL action proposal. * * Shared between the component and its unit tests so the two cannot drift. */ export function shouldGrantWriteSqlOnShortAffirmative(params: WriteSqlGrantParams): boolean { if (params.mode !== "agent" || params.isProduction || params.alreadyGranted) return false; if (!isShortAffirmative(params.userText)) return false; for (let i = params.messages.length - 1; i >= 0; i--) { const msg = params.messages[i]; if (msg.kind === "contextSummary") continue; if (msg.role === "assistant" && msg.content && looksLikeWriteSqlProposal(msg.content)) return true; if (msg.role === "user") return false; } return false; }