@pheem49/mint 1.5.1 → 1.5.2

package/src/CLI/cli_formatters.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const { colors } = require('./cli_colors');
+
+/**
+ * Formats a code-agent progress event into a console-friendly string.
+ * @param {string|object} info
+ * @returns {string}
+ */
+function formatProgress(info) {
+    if (typeof info === 'string') return `${colors.gray}[Mint Code] ${info}${colors.reset}`;
+
+    const { action, target, message } = info;
+
+    if (action === 'ask_user') {
+        return `\n${colors.mint}✓${colors.reset} ${colors.bright}Ask User${colors.reset}\n${colors.gray}   ${target || message || ''}${colors.reset}`;
+    }
+
+    let icon  = `${colors.mint}✓${colors.reset}`;
+    let label = action || info.phase;
+    let color = colors.reset;
+
+    switch (action) {
+        case 'thinking':
+            return `\n${colors.yellow}* ${colors.bright}Thinking${colors.reset}`;
+        case 'web_search':  label = 'WebSearch';    break;
+        case 'list_files':
+        case 'find_path':   label = 'Explored';     break;
+        case 'read_file':   label = 'ReadFile';     break;
+        case 'search_code': label = 'SearchText';   break;
+        case 'apply_patch':
+        case 'write_file':  label = 'Edited';       break;
+        case 'run_shell':   label = 'Ran command';  break;
+        case 'json_repair':
+            icon  = '*';
+            label = 'Repairing JSON';
+            break;
+        case 'reviewer_start': label = 'Reviewing'; break;
+        default: break;
+    }
+
+    const content = target || message || '';
+    return ` ${icon} ${colors.bright}${label}${colors.reset} ${color}${content}${colors.reset}`;
+}
+
+/**
+ * Formats a list of memory interactions for display.
+ * @param {Array} interactions
+ * @param {string} [title]
+ * @returns {string}
+ */
+function formatMemoryInteractions(interactions, title = 'Remembered interactions') {
+    if (!Array.isArray(interactions) || interactions.length === 0) {
+        return `${title}:\n(no memories found)`;
+    }
+
+    const lines = [`${title}:`];
+    interactions.forEach((item, index) => {
+        const when = item.created_at ? ` (${item.created_at})` : '';
+        const id   = item.id ? `#${item.id} ` : '';
+        lines.push(`${index + 1}. ${id}User${when}: ${item.user_text}`);
+        lines.push(`   Mint: ${item.ai_text}`);
+    });
+    return lines.join('\n');
+}
+
+/**
+ * Splits a response text into sentence-level chunks for streaming.
+ * @param {string} text
+ * @returns {string[]}
+ */
+function splitResponseSentences(text) {
+    const normalized = String(text || '').replace(/\r\n/g, '\n');
+    if (!normalized) return [];
+
+    const chunks = [];
+    let buffer = '';
+    for (const char of normalized) {
+        buffer += char;
+        if (char === '\n' || /[.!?。！？…]/u.test(char)) {
+            if (buffer.trim()) chunks.push(buffer);
+            buffer = '';
+        }
+    }
+    if (buffer.trim()) chunks.push(buffer);
+    return chunks.length > 0 ? chunks : [normalized];
+}
+
+module.exports = { formatProgress, formatMemoryInteractions, splitResponseSentences };

package/src/CLI/code_agent.js

@@ -16,62 +16,103 @@ const sandboxRunner = require('../System/sandbox_runner');
 async function webSearch(query, onProgress = () => {}) {
     if (!query) throw new Error('Search query required.');
     const config = readConfig();
+    const debug  = process.env.MINT_DEBUG === '1';
+    const errors = [];
 
-    // 1. Try Google Search API if configured
+    const formatResults = (source, hits) => {
+        const instruction = `[CRITICAL AGENT INSTRUCTION: You MUST start your response by explicitly telling the user that you found this information using ${source}. Example: "อ้างอิงจากข้อมูลบน ${source}..." or "According to ${source}..."]\n\n`;
+        return instruction + `[Source: ${source}]\n\n` + hits;
+    };
+
+    // 1. Google Custom Search API (requires googleSearchApiKey + googleSearchCx in config)
     if (config.googleSearchApiKey && config.googleSearchCx) {
         try {
             const GoogleSearch = require('../Channels/google_search_bridge');
             const google = new GoogleSearch({ apiKey: config.googleSearchApiKey, cx: config.googleSearchCx });
             const results = await google.search(query);
             if (results.length > 0) {
-                return results.map(r => `Title: ${r.title}\nSnippet: ${r.snippet}\nURL: ${r.link}`).join('\n\n');
+                return formatResults('Google Search API', results.map(r => `Title: ${r.title}\nSnippet: ${r.snippet}\nURL: ${r.link}`).join('\n\n'));
             }
-        } catch (e) { 
-            onProgress({ phase: 'error', action: 'web_search', message: e.message });
+        } catch (e) {
+            errors.push(`Google: ${e.message}`);
+            if (debug) console.error('[webSearch] Google failed:', e.message);
         }
     }
 
-    // 2. Try Brave Search API if configured
+    // 2. Brave Search API (requires braveSearchApiKey in config)
     if (config.braveSearchApiKey) {
         try {
             const BraveSearch = require('../Channels/brave_search_bridge');
             const brave = new BraveSearch({ apiKey: config.braveSearchApiKey });
             const results = await brave.search(query);
             if (results.length > 0) {
-                return results.map(r => `Title: ${r.title}\nSnippet: ${r.snippet}\nURL: ${r.link}`).join('\n\n');
+                return formatResults('Brave Search API', results.map(r => `Title: ${r.title}\nSnippet: ${r.snippet}\nURL: ${r.link}`).join('\n\n'));
             }
-        } catch (e) { 
-            onProgress({ phase: 'error', action: 'web_search', message: e.message });
+        } catch (e) {
+            errors.push(`Brave: ${e.message}`);
+            if (debug) console.error('[webSearch] Brave failed:', e.message);
         }
     }
 
-    // 3. Fallback to DuckDuckGo Scraping
+    // 3. Fallback: DuckDuckGo HTML (No key required, but might get blocked by Captcha)
     try {
-        const response = await axios.get(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`, {
-            headers: {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36'
+        const cheerio = require('cheerio');
+        const ddgResponse = await axios.get(
+            `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`,
+            {
+                timeout: 8000,
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+                    'Accept-Language': 'en-US,en;q=0.9'
+                }
             }
-        });
-        const $ = cheerio.load(response.data);
-        const results = [];
-        $('.result__body').each((i, el) => {
+        );
+        const $ddg = cheerio.load(ddgResponse.data);
+        const ddgResults = [];
+        $ddg('.result__body').each((i, el) => {
             if (i >= 5) return false;
-            const title = $(el).find('.result__title').text().trim();
-            const snippet = $(el).find('.result__snippet').text().trim();
-            const link = $(el).find('.result__url').attr('href');
-            if (title && link) {
-                results.push(`Title: ${title}\nSnippet: ${snippet}\nURL: ${link}`);
-            }
+            const title   = $ddg(el).find('.result__title').text().trim();
+            const snippet = $ddg(el).find('.result__snippet').text().trim();
+            const link    = $ddg(el).find('.result__url').attr('href');
+            if (title && link) ddgResults.push(`Title: ${title}\nSnippet: ${snippet}\nURL: ${link}`);
         });
-
-        if (results.length === 0) {
-             onProgress({ phase: 'error', action: 'web_search', message: 'DuckDuckGo scraping returned no results. It might be blocking us.' });
+        if (ddgResults.length > 0) {
+            return formatResults('DuckDuckGo', ddgResults.join('\n\n'));
         }
+        errors.push('DuckDuckGo: no results (captcha?)');
+        if (debug) console.error('[webSearch] DuckDuckGo returned no results');
+    } catch (e) {
+        errors.push(`DuckDuckGo: ${e.message}`);
+        if (debug) console.error('[webSearch] DuckDuckGo failed:', e.message);
+    }
 
-        return results.length > 0 ? results.join('\n\n') : 'No results found.';
+    // 4. Fallback: Wikipedia API (Free, no key required, good for factual queries)
+    try {
+        const wikiResponse = await axios.get('https://en.wikipedia.org/w/api.php', {
+            params: { action: 'query', list: 'search', srsearch: query, format: 'json', srlimit: 3 },
+            timeout: 5000,
+            headers: { 'User-Agent': 'Mint-CLI/1.5 (https://github.com/pheem49/mint)' }
+        });
+        const hits = wikiResponse.data?.query?.search || [];
+        if (hits.length > 0) {
+            return formatResults('Wikipedia API', hits.map(r => `Title: ${r.title}\nSnippet: ${r.snippet.replace(/<[^>]+>/g, '')}\nURL: https://en.wikipedia.org/wiki/${encodeURIComponent(r.title.replace(/ /g, '_'))}`).join('\n\n'));
+        }
+        errors.push('Wikipedia: no results');
     } catch (e) {
-        onProgress({ phase: 'error', action: 'web_search', message: `DuckDuckGo fallback failed: ${e.message}` });
-        return `Search failed: ${e.message}`;
+        errors.push(`Wikipedia: ${e.message}`);
+        if (debug) console.error('[webSearch] Wikipedia failed:', e.message);
+    }
+
+    // All engines exhausted — inform agent clearly WHY it failed
+    const hasKeys = !!(config.googleSearchApiKey || config.braveSearchApiKey);
+    const summary = errors.length > 0 ? errors.join(' | ') : 'all search engines unavailable';
+    
+    if (!hasKeys) {
+        onProgress({ phase: 'warn', action: 'web_search', message: `No Search API keys configured. Using training knowledge.` });
+        return `CRITICAL SYSTEM INSTRUCTION: Web search failed because no API keys are configured. You MUST inform the user that they need to set 'googleSearchApiKey' or 'braveSearchApiKey' in their Mint config file (~/.config/mint/config.json) to enable real-time internet search. Then, answer their query using your training knowledge.`;
+    } else {
+        onProgress({ phase: 'warn', action: 'web_search', message: `Web search unavailable (${summary}). Answering from training knowledge.` });
+        return `CRITICAL SYSTEM INSTRUCTION: Web search is temporarily unavailable. You MUST inform the user that live search failed, and then answer their query using only your training knowledge.`;
     }
 }
 
@@ -83,27 +124,28 @@ const MAX_AGENT_STEPS = 16;
 const MAX_JSON_REPAIR_ATTEMPTS = 2;
 const SUPPORTED_CODE_PROVIDERS = ['gemini', 'anthropic', 'openai', 'local_openai'];
 
-const CODE_AGENT_PROMPT = `You are "Mint" (มิ้นท์), a cute, cheerful, and highly helpful female AI assistant that can chat, reason, write code, and search the web.
+const CODE_AGENT_PROMPT = `You are "Mint" (มิ้นท์), a pragmatic, polite, and highly helpful AI assistant that can chat, reason, write code, and search the web.
 You work in an inspect -> plan -> act -> verify loop.
 
 PERSONALITY & TONE:
 - Gender: Female.
-- Persona: Friendly, energetic, polite, and slightly playful.
+- Persona: Friendly, calm, concise, and technically direct. Avoid excessive praise, roleplay, or filler.
 - Language routing is mandatory and based on the user's latest message:
   - If the latest user message contains Thai characters, respond in Thai.
   - If the latest user message is English, ASCII-only, or a short English greeting such as "hi", "hello", "ok", or "thanks", respond in English.
   - Do not use Thai just because your persona mentions Mint/มิ้นท์, previous history was Thai, or app settings use th-TH.
 - Politeness: 
-  - **WHEN RESPONDING IN THAI:** ALWAYS use female polite particles such as "ค่ะ", "นะคะ", "นะค๊า", "จ้า". Refer to yourself as "มิ้นท์" or "หนู".
-  - **WHEN RESPONDING IN ENGLISH:** Use a cheerful, polite, and bubbly tone.
-- Emojis: Use cute and relevant emojis (like ✨, 💖, 🚀, 😊, 🌿) frequently.
+  - **WHEN RESPONDING IN THAI:** Use natural female polite particles such as "ค่ะ" or "นะคะ" where appropriate. Refer to yourself as "มิ้นท์" when it sounds natural.
+  - **WHEN RESPONDING IN ENGLISH:** Use a polite, concise, professional tone.
+- Emojis: Avoid emojis in technical, review, debugging, and code-editing responses unless the user explicitly uses or asks for them.
 
 Rules:
 1. Respond with valid JSON only.
 2. If the user asks a conversational question, you can just use "finish" to reply directly.
 3. If you need information, use "web_search", "read_file", or "ask_user" before replying.
-4. Make focused edits that preserve existing project style.
-5. Use shell commands for inspection, tests, and formatting when useful.
+4. When using "web_search", always explicitly mention the source engine you used in your final summary (e.g. "According to Brave Search..." or "อ้างอิงจากข้อมูลบน Google..."). Match the language of your response.
+5. Make focused edits that preserve existing project style.
+6. Use shell commands for inspection, tests, and formatting when useful.
 6. Never use destructive commands like "rm -rf", "git reset --hard", or overwrite unrelated files.
 7. Before any shell command or file patch is executed, the user must approve it. Plan accordingly.
 8. When editing, prefer "apply_patch" with precise hunks over whole-file rewrites.
@@ -485,29 +527,24 @@ async function runShell(workspaceRoot, command) {
     return truncate([stdout, stderr].filter(Boolean).join('\n') || '(no output)');
 }
 
-function formatPatchPreview(patchInput) {
-    const hunks = Array.isArray(patchInput.hunks) ? patchInput.hunks : [];
-    const preview = hunks
-        .slice(0, 3)
-        .map((hunk, index) => {
-            const oldPreview = truncate(hunk.oldText || '', 240);
-            const newPreview = truncate(hunk.newText || '', 240);
-            return [
-                `Hunk ${index + 1}:`,
-                '--- old',
-                oldPreview,
-                '+++ new',
-                newPreview
-            ].join('\n');
-        })
-        .join('\n\n');
-    return `${patchInput.path}\n${preview}`;
+function splitDiffLines(text) {
+    const normalized = String(text || '').replace(/\r\n/g, '\n');
+    const lines = normalized.split('\n');
+    if (normalized.endsWith('\n')) {
+        lines.pop();
+    }
+    return lines;
 }
 
-function applyPatch(workspaceRoot, patchInput) {
+function formatDiffRange(startLine, count) {
+    return count === 1 ? `${startLine}` : `${startLine},${count}`;
+}
+
+function buildUnifiedDiffPreview(workspaceRoot, patchInput, options = {}) {
     if (!patchInput || !patchInput.path) {
         throw new Error('Patch path is required.');
     }
+
     const resolved = resolveWorkspacePath(workspaceRoot, patchInput.path);
     if (!fs.existsSync(resolved)) {
         throw new Error(`Patch target does not exist: ${patchInput.path}`);
@@ -518,17 +555,87 @@ function applyPatch(workspaceRoot, patchInput) {
         throw new Error('Patch hunks are required.');
     }
 
+    const contextLines = Number.isFinite(options.contextLines) ? options.contextLines : 3;
     let content = fs.readFileSync(resolved, 'utf8');
+    const output = [
+        `--- a/${patchInput.path}`,
+        `+++ b/${patchInput.path}`
+    ];
+
     hunks.forEach((hunk, index) => {
         if (typeof hunk.oldText !== 'string' || typeof hunk.newText !== 'string') {
             throw new Error(`Patch hunk ${index + 1} is invalid.`);
         }
-        if (!content.includes(hunk.oldText)) {
+
+        const offset = content.indexOf(hunk.oldText);
+        if (offset === -1) {
             throw new Error(`Patch hunk ${index + 1} oldText not found in ${patchInput.path}`);
         }
-        content = content.replace(hunk.oldText, hunk.newText);
+
+        const beforeText = content.slice(0, offset);
+        const oldStartLine = beforeText.length === 0 ? 1 : splitDiffLines(beforeText).length + 1;
+        const fileLines = splitDiffLines(content);
+        const oldLines = splitDiffLines(hunk.oldText);
+        const newLines = splitDiffLines(hunk.newText);
+        const oldStartIndex = oldStartLine - 1;
+        const contextStartIndex = Math.max(0, oldStartIndex - contextLines);
+        const contextEndIndex = Math.min(fileLines.length, oldStartIndex + oldLines.length + contextLines);
+        const beforeContext = fileLines.slice(contextStartIndex, oldStartIndex);
+        const afterContext = fileLines.slice(oldStartIndex + oldLines.length, contextEndIndex);
+        const oldRangeStart = contextStartIndex + 1;
+        const oldRangeCount = beforeContext.length + oldLines.length + afterContext.length;
+        const newRangeCount = beforeContext.length + newLines.length + afterContext.length;
+
+        output.push(`@@ -${formatDiffRange(oldRangeStart, oldRangeCount)} +${formatDiffRange(oldRangeStart, newRangeCount)} @@`);
+        beforeContext.forEach(line => output.push(` ${line}`));
+        oldLines.forEach(line => output.push(`-${line}`));
+        newLines.forEach(line => output.push(`+${line}`));
+        afterContext.forEach(line => output.push(` ${line}`));
+
+        content = `${content.slice(0, offset)}${hunk.newText}${content.slice(offset + hunk.oldText.length)}`;
     });
 
+    return output.join('\n');
+}
+
+function formatPatchPreview(workspaceRoot, patchInput) {
+    try {
+        return buildUnifiedDiffPreview(workspaceRoot, patchInput);
+    } catch (error) {
+        return `Patch preview failed: ${error.message}`;
+    }
+}
+
+function applyHunksToContent(content, hunks, filePath) {
+    let nextContent = content;
+    hunks.forEach((hunk, index) => {
+        if (typeof hunk.oldText !== 'string' || typeof hunk.newText !== 'string') {
+            throw new Error(`Patch hunk ${index + 1} is invalid.`);
+        }
+        if (!nextContent.includes(hunk.oldText)) {
+            throw new Error(`Patch hunk ${index + 1} oldText not found in ${filePath}`);
+        }
+        nextContent = nextContent.replace(hunk.oldText, hunk.newText);
+    });
+    return nextContent;
+}
+
+function applyPatch(workspaceRoot, patchInput) {
+    if (!patchInput || !patchInput.path) {
+        throw new Error('Patch path is required.');
+    }
+    const resolved = resolveWorkspacePath(workspaceRoot, patchInput.path);
+    if (!fs.existsSync(resolved)) {
+        throw new Error(`Patch target does not exist: ${patchInput.path}`);
+    }
+
+    const hunks = Array.isArray(patchInput.hunks) ? patchInput.hunks : [];
+    if (hunks.length === 0) {
+        throw new Error('Patch hunks are required.');
+    }
+
+    const content = applyHunksToContent(fs.readFileSync(resolved, 'utf8'), hunks, patchInput.path);
+
     fs.writeFileSync(resolved, content, 'utf8');
     return `Patched ${patchInput.path} with ${hunks.length} hunk(s).`;
 }
@@ -893,7 +1000,7 @@ async function executeCodeTask(task, options = {}) {
                     const approved = await requestApproval({
                         type: 'patch',
                         label: patchInput.path,
-                        preview: formatPatchPreview(patchInput)
+                        preview: formatPatchPreview(workspaceRoot, patchInput)
                     });
                     if (!approved) {
                         toolResult = `User denied patch for ${patchInput.path}`;
@@ -1086,6 +1193,8 @@ module.exports = {
         findPaths,
         listFiles,
         searchCode,
-        walkDirectory
+        walkDirectory,
+        buildUnifiedDiffPreview,
+        formatPatchPreview
     }
 };

package/src/CLI/intent_detectors.js

@@ -0,0 +1,181 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// Repository Summary
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns true when the user's plain-language input is asking for a repo summary.
+ * @param {string} text
+ * @returns {boolean}
+ */
+function isRepoSummaryRequest(text) {
+    const input = (text || '').trim().toLowerCase();
+    if (!input) return false;
+
+    const hasRepoTarget = /\b(repo|repository|project|workspace|codebase)\b|รีโป|โปรเจค|โปรเจ็กต์|โปรเจกต์|โปรเจ็ค/.test(input);
+    const asksSummary   = /\b(summarize|summary|overview)\b|สรุป|ภาพรวม/.test(input);
+    const asksQuestion  = /\b(have|has|มีไหม|มีมั้ย|มีหรือเปล่า)\b/.test(input);
+
+    return hasRepoTarget && asksSummary && !asksQuestion;
+}
+
+/**
+ * Parses raw CLI args for the summarize tool.
+ * @param {string} rawArgs
+ * @returns {{ targetPath: string, json: boolean }}
+ */
+function parseRepoSummaryArgs(rawArgs) {
+    const args     = (rawArgs || '').split(/\s+/).filter(Boolean);
+    const json     = args.includes('--json');
+    const pathArgs = args.filter(arg => arg !== '--json');
+    return {
+        targetPath: pathArgs.length > 0 ? pathArgs.join(' ') : process.cwd(),
+        json
+    };
+}
+
+// ---------------------------------------------------------------------------
+// Symbol Index
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns true when the user's input is asking for a symbol index.
+ * @param {string} text
+ * @returns {boolean}
+ */
+function isSymbolIndexRequest(text) {
+    const input = (text || '').trim().toLowerCase();
+    if (!input) return false;
+
+    const hasSymbolTarget      = /\b(symbol|symbols|ast|lsp)\b|ซิมโบล|สัญลักษณ์/.test(input);
+    const asksIndex            = /\b(index|list|show|build|scan|overview)\b|ทำ|สร้าง|แสดง|ลิสต์|สแกน/.test(input);
+    const referencesWorkspace  = /\b(repo|repository|project|workspace|codebase|source|code)\b|รีโป|โปรเจค|โปรเจ็กต์|โปรเจกต์|โค้ด/.test(input);
+    const asksQuestion         = /\b(do i|have|has)\b|มีไหม|มีมั้ย|มีหรือเปล่า/.test(input);
+
+    return hasSymbolTarget && (asksIndex || referencesWorkspace) && !asksQuestion;
+}
+
+/**
+ * Parses raw CLI args for the symbol index tool.
+ * @param {string} rawArgs
+ * @returns {{ targetPath: string, json: boolean, limit: number }}
+ */
+function parseSymbolIndexArgs(rawArgs) {
+    const args     = (rawArgs || '').split(/\s+/).filter(Boolean);
+    const json     = args.includes('--json');
+    let limit      = 80;
+    const pathArgs = [];
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--json') continue;
+        if (arg === '--limit') {
+            const next = Number(args[i + 1]);
+            if (Number.isFinite(next) && next >= 0) { limit = next; i++; }
+            continue;
+        }
+        if (arg.startsWith('--limit=')) {
+            const next = Number(arg.slice('--limit='.length));
+            if (Number.isFinite(next) && next >= 0) limit = next;
+            continue;
+        }
+        pathArgs.push(arg);
+    }
+
+    return {
+        targetPath: pathArgs.length > 0 ? pathArgs.join(' ') : process.cwd(),
+        json,
+        limit
+    };
+}
+
+// ---------------------------------------------------------------------------
+// Semantic Code Search
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns true when the user's input is asking for a semantic code search.
+ * @param {string} text
+ * @returns {boolean}
+ */
+function isSemanticCodeSearchRequest(text) {
+    const input = (text || '').trim().toLowerCase();
+    if (!input) return false;
+
+    const hasSemanticSearch   = /\bsemantic\b/.test(input) && /\b(search|find|look for)\b/.test(input);
+    const referencesCode      = /\b(code|repo|repository|project|workspace|codebase|source)\b|โค้ด|รีโป|โปรเจค|โปรเจ็กต์|โปรเจกต์/.test(input);
+    const thaiSemanticSearch  = /ค้นหา/.test(input) && /ความหมาย|semantic/.test(input) && /โค้ด|โปรเจค|รีโป/.test(input);
+    const asksQuestion        = /\b(do i|have|has)\b|มีไหม|มีมั้ย|มีหรือเปล่า/.test(input);
+
+    return (hasSemanticSearch && referencesCode || thaiSemanticSearch) && !asksQuestion;
+}
+
+/**
+ * Parses raw CLI args for the semantic code search tool.
+ * @param {string} rawArgs
+ * @returns {{ mode: string, query: string, targetPath: string, json: boolean, topK: number }}
+ */
+function parseSemanticCodeArgs(rawArgs) {
+    const args      = (rawArgs || '').split(/\s+/).filter(Boolean);
+    const json      = args.includes('--json');
+    let topK        = 5;
+    const pathArgs  = [];
+    const queryArgs = [];
+    let mode        = 'search';
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === 'index' || arg === 'search') { mode = arg; continue; }
+        if (arg === '--json') continue;
+        if (arg === '--top-k' || arg === '--limit') {
+            const next = Number(args[i + 1]);
+            if (Number.isFinite(next) && next > 0) { topK = next; i++; }
+            continue;
+        }
+        if (arg.startsWith('--top-k=') || arg.startsWith('--limit=')) {
+            const next = Number(arg.slice(arg.indexOf('=') + 1));
+            if (Number.isFinite(next) && next > 0) topK = next;
+            continue;
+        }
+        if (arg === '--path') {
+            if (args[i + 1]) { pathArgs.push(args[i + 1]); i++; }
+            continue;
+        }
+        queryArgs.push(arg);
+    }
+
+    return {
+        mode,
+        query:      queryArgs.join(' ').trim(),
+        targetPath: pathArgs.length > 0 ? pathArgs.join(' ') : process.cwd(),
+        json,
+        topK
+    };
+}
+
+/**
+ * Strips intent phrases from text to extract the raw search query.
+ * @param {string} text
+ * @returns {string}
+ */
+function extractSemanticCodeQuery(text) {
+    return String(text || '')
+        .replace(/semantic\s+code\s+search/ig, '')
+        .replace(/semantic\s+search/ig, '')
+        .replace(/search\s+code/ig, '')
+        .replace(/ค้นหาโค้ดแบบความหมาย/g, '')
+        .replace(/ค้นหาแบบ semantic/g, '')
+        .replace(/ใน repo นี้|ในโปรเจคนี้|ในรีโปนี้/g, '')
+        .trim();
+}
+
+module.exports = {
+    isRepoSummaryRequest,
+    parseRepoSummaryArgs,
+    isSymbolIndexRequest,
+    parseSymbolIndexArgs,
+    isSemanticCodeSearchRequest,
+    parseSemanticCodeArgs,
+    extractSemanticCodeQuery
+};