vigthoria-cli 1.6.16 → 1.6.17

package/dist/commands/chat.d.ts

@@ -32,6 +32,7 @@ export declare class ChatCommand {
     private currentModel;
     private modelExplicitlySelected;
     private autoApprove;
+    private agentToolEvidence;
     private operatorMode;
     private workflowTarget;
     private savePlanToVigFlow;

package/dist/commands/chat.js

@@ -67,6 +67,8 @@ class ChatCommand {
     currentModel = 'code';
     modelExplicitlySelected = false;
     autoApprove = false;
+    // Phase 5: Agent quality gate — track tool usage for evidence thresholds
+    agentToolEvidence = { discovery: 0, mutation: 0, searchFailed: 0 };
     operatorMode = false;
     workflowTarget = null;
     savePlanToVigFlow = false;
@@ -195,6 +197,10 @@ class ChatCommand {
     }
     buildTaskShapingInstructions(prompt) {
         const instructions = [];
+        // Platform-aware routing hints
+        if (os.platform() === 'win32') {
+            instructions.push('Platform: Windows. Use list_dir, glob, read_file, and the grep tool for searching.', 'The grep tool handles Windows automatically — do not use bash to call grep, findstr, or Select-String manually.', 'Do not use bash for Unix commands (cat, head, tail, awk, sed, wc).', 'Use read_file to inspect file contents instead of shell commands.', 'All file paths use forward slashes internally.');
+        }
         if (this.isDiagnosticPrompt(prompt)) {
             instructions.push('Diagnostic mode is active.', 'Treat this as a debugging task, not a generic code review or feature request.', 'Start with concrete evidence: logs, runtime errors, config, launch files, and exact symbol references.', 'If log files exist, inspect them before proposing fixes.', 'Do not claim a file, definition, asset, or symbol is missing until you verify that with tools.', 'If a prior diagnosis mentioned a missing symbol or YAML entry, re-check the actual files before repeating it.', 'Prefer grep plus read_file around the exact references involved in the failure.', 'Separate your reasoning into: Evidence, Confirmed Cause, and Remaining Hypotheses.', 'Do not suggest speculative fixes when the current evidence contradicts them.');
         }
@@ -657,10 +663,11 @@ class ChatCommand {
     async runSimplePrompt(prompt) {
         this.lastActionableUserInput = prompt;
         this.messages.push({ role: 'user', content: this.buildExecutionPrompt(prompt) });
-        const spinner = (0, ora_1.default)({ text: 'Thinking...', spinner: 'clock' }).start();
+        const spinner = this.jsonOutput ? null : (0, ora_1.default)({ text: 'Thinking...', spinner: 'clock' }).start();
         try {
             const response = await this.api.chat(this.getMessagesForModel(), this.currentModel);
-            spinner.stop();
+            if (spinner)
+                spinner.stop();
             const finalText = response.message.trim();
             if (finalText) {
                 console.log(finalText);
@@ -669,7 +676,8 @@ class ChatCommand {
             this.saveSession();
         }
         catch (error) {
-            spinner.fail('Failed to get response');
+            if (spinner)
+                spinner.fail('Failed to get response');
             this.logger.error(error.message);
         }
     }
@@ -707,21 +715,37 @@ class ChatCommand {
         }
         this.lastActionableUserInput = prompt;
         this.directToolContinuationCount = 0;
+        this.agentToolEvidence = { discovery: 0, mutation: 0, searchFailed: 0 };
         this.tools.clearSessionApprovals();
         this.ensureAgentSystemPrompt();
         this.messages.push({ role: 'user', content: this.buildScopedUserPrompt(prompt) });
         this.saveSession();
         const maxTurns = 10;
         for (let turn = 0; turn < maxTurns; turn += 1) {
-            const spinner = (0, ora_1.default)({ text: turn === 0 ? 'Planning...' : 'Continuing...', spinner: 'clock' }).start();
+            const spinner = this.jsonOutput ? null : (0, ora_1.default)({ text: turn === 0 ? 'Planning...' : 'Continuing...', spinner: 'clock' }).start();
             try {
                 const response = await this.api.chat(this.getMessagesForModel(), this.currentModel);
-                spinner.stop();
+                if (spinner)
+                    spinner.stop();
                 const assistantMessage = response.message || '';
                 this.messages.push({ role: 'assistant', content: assistantMessage });
                 const toolCalls = this.extractToolCalls(assistantMessage);
                 const visibleText = this.stripToolPayloads(assistantMessage).trim();
                 if (toolCalls.length === 0) {
+                    // Phase 5: Quality gate — if the agent tries to conclude on the first
+                    // turn without any discovery, push it to gather evidence first.
+                    if (turn === 0 && this.agentToolEvidence.discovery === 0 && this.isDiagnosticPrompt(prompt)) {
+                        this.messages.push({
+                            role: 'system',
+                            content: [
+                                'Quality gate: you concluded without using any discovery tools (list_dir, glob, read_file, grep).',
+                                'Before answering a diagnostic or audit question, you MUST inspect the project with tools.',
+                                'Use list_dir and read_file to gather concrete evidence, then provide your answer.',
+                            ].join('\n'),
+                        });
+                        this.directToolContinuationCount += 1;
+                        continue;
+                    }
                     const finalContent = this.resolveDirectModeCompletion(prompt, visibleText);
                     if (this.jsonOutput) {
                         console.log(JSON.stringify({
@@ -750,7 +774,8 @@ class ChatCommand {
                 this.saveSession();
             }
             catch (error) {
-                spinner.fail('Agent request failed');
+                if (spinner)
+                    spinner.fail('Agent request failed');
                 if (this.jsonOutput) {
                     process.exitCode = 1;
                     console.log(JSON.stringify({
@@ -971,6 +996,18 @@ class ChatCommand {
                 }
                 this.logger.error(errorMessage);
                 this.messages.push({ role: 'assistant', content: errorMessage });
+                if (this.jsonOutput) {
+                    process.exitCode = 1;
+                    console.log(JSON.stringify({
+                        success: false,
+                        mode: 'agent',
+                        model: routingPolicy.selectedModel,
+                        partial: false,
+                        content: '',
+                        error: errorMessage,
+                        metadata: { executionPath: 'v3-agent', previewGate },
+                    }, null, 2));
+                }
                 return true;
             }
             if (!this.jsonOutput && previewGate?.required && previewGate?.passed !== true && workspaceHasOutput) {
@@ -1028,6 +1065,18 @@ class ChatCommand {
             const errorMessage = `Agent mode requires the V3 workflow and will not fall back to the legacy CLI loop. ${error.message}`;
             this.logger.error(errorMessage);
             this.messages.push({ role: 'assistant', content: errorMessage });
+            if (this.jsonOutput) {
+                process.exitCode = 1;
+                console.log(JSON.stringify({
+                    success: false,
+                    mode: 'agent',
+                    model: routingPolicy.selectedModel,
+                    partial: false,
+                    content: '',
+                    error: errorMessage,
+                    metadata: { executionPath: 'v3-agent' },
+                }, null, 2));
+            }
             return true;
         }
     }
@@ -1437,10 +1486,20 @@ class ChatCommand {
     }
     buildContinuationPrompt() {
         const diagnosticMode = this.isDiagnosticPrompt(this.lastActionableUserInput);
+        const { discovery, mutation, searchFailed } = this.agentToolEvidence;
+        const evidenceLines = [];
+        if (discovery < 2) {
+            evidenceLines.push(`Quality gate: only ${discovery} discovery tool(s) used so far (list_dir, glob, read_file, grep). Use at least 2 before concluding.`);
+        }
+        if (searchFailed > 0) {
+            evidenceLines.push(`Warning: ${searchFailed} search tool call(s) failed. Do not treat failed searches as evidence that something is missing.`);
+        }
         return [
             `Tool results received for direct mode step ${this.directToolContinuationCount + 1}.`,
             `Original user request: ${this.lastActionableUserInput}`,
             `Project root boundary: ${this.currentProjectPath}`,
+            `Evidence collected: ${discovery} discovery, ${mutation} mutation, ${searchFailed} search failures.`,
+            ...evidenceLines,
             'Do not declare success until the exact user question has been answered with tool-backed evidence.',
             'If a user is asking which file is correct or most recent, keep inspecting until you can justify the answer from actual results.',
             diagnosticMode ? 'Because this is a debugging task, prefer logs, runtime evidence, and exact symbol references over generic fixes.' : 'Keep working from concrete tool results.',
@@ -1604,16 +1663,47 @@ class ChatCommand {
             if (!this.jsonOutput) {
                 console.log(chalk_1.default.cyan(`⚙ Executing: ${call.tool}`));
             }
-            const result = await this.tools.execute(call);
+            let result = await this.tools.execute(call);
+            // Phase 2: If a search tool failed (search_failed), retry with alternate approach
+            const searchStatus = result.metadata?.searchStatus;
+            if (call.tool === 'grep' && searchStatus === 'search_failed') {
+                if (!this.jsonOutput) {
+                    console.log(chalk_1.default.yellow(`⚠ Search backend failed, retrying with alternate method...`));
+                }
+                // Force Node-native fallback by re-executing with a note
+                const fallbackResult = await this.tools.execute({
+                    tool: 'grep',
+                    args: { ...call.args, _fallback: 'node-native' },
+                });
+                if (fallbackResult.success || fallbackResult.metadata?.searchStatus !== 'search_failed') {
+                    result = fallbackResult;
+                }
+            }
             const summary = this.formatToolResult(call, result);
             if (!this.jsonOutput) {
                 console.log(result.success ? chalk_1.default.gray(summary) : chalk_1.default.red(summary));
             }
             this.messages.push({ role: 'system', content: summary });
+            // Phase 5: Track tool evidence for quality gates
+            const finalStatus = result.metadata?.searchStatus;
+            if (finalStatus === 'search_failed') {
+                this.agentToolEvidence.searchFailed += 1;
+            }
+            else if (/^(read_file|list_dir|glob|grep|git|repo|fetch_url)$/.test(call.tool)) {
+                this.agentToolEvidence.discovery += 1;
+            }
+            else if (/^(write_file|edit_file|bash|ssh_exec)$/.test(call.tool)) {
+                this.agentToolEvidence.mutation += 1;
+            }
         }
     }
     formatToolResult(call, result) {
-        const parts = [`Tool ${call.tool} ${result.success ? 'succeeded' : 'failed'}.`];
+        const parts = [`Tool ${call.tool} ${result.success ? 'succeeded' : 'FAILED'}.`];
+        // Include search status classification for the agent to reason about
+        const searchStatus = result.metadata?.searchStatus;
+        if (searchStatus) {
+            parts.push(`Search status: ${searchStatus}`);
+        }
         if (result.output) {
             parts.push(`Output:\n${this.truncateText(result.output)}`);
         }

package/dist/utils/tools.d.ts

@@ -15,6 +15,7 @@
  */
 import { Logger } from './logger.js';
 export type RiskLevel = 'low' | 'medium' | 'high' | 'critical';
+export type SearchStatus = 'search_matches_found' | 'search_no_matches' | 'search_failed';
 export interface ToolResult {
     success: boolean;
     output?: string;
@@ -23,6 +24,7 @@ export interface ToolResult {
     canRetry?: boolean;
     undoable?: boolean;
     metadata?: {
+        searchStatus?: SearchStatus;
         [key: string]: any;
     };
 }
@@ -145,6 +147,26 @@ export declare class AgenticTools {
      */
     private bash;
     private grep;
+    /**
+     * Windows grep: rg > Select-String > Node-native
+     */
+    private grepWindows;
+    /**
+     * Unix grep: rg > system grep (BSD/GNU)
+     */
+    private grepUnix;
+    /**
+     * Search using ripgrep (rg) — works on all platforms
+     */
+    private grepWithRg;
+    /**
+     * Search using PowerShell Select-String (Windows)
+     */
+    private grepWithSelectString;
+    /**
+     * Pure Node.js recursive file search — reliable on all platforms, no external deps
+     */
+    private grepNodeNative;
     private listDir;
     private glob;
     private git;

package/dist/utils/tools.js

@@ -995,48 +995,270 @@ class AgenticTools {
     }
     grep(args) {
         const searchPath = args.path ? this.resolvePath(args.path) : this.cwd;
-        const include = args.include || '*';
-        const os = require('os');
-        // macOS uses BSD grep which has different options than GNU grep
-        const isMac = os.platform() === 'darwin';
+        const osModule = require('os');
+        const platform = osModule.platform();
+        // If forced fallback, go directly to Node-native
+        if (args._fallback === 'node-native') {
+            return this.grepNodeNative(args, searchPath);
+        }
+        // Try external search tools first (rg > grep/Select-String), fall back to Node-native
+        if (platform === 'win32') {
+            return this.grepWindows(args, searchPath);
+        }
+        return this.grepUnix(args, searchPath, platform);
+    }
+    /**
+     * Windows grep: rg > Select-String > Node-native
+     */
+    grepWindows(args, searchPath) {
+        // 1. Try ripgrep (rg) first — best cross-platform search tool
+        try {
+            (0, child_process_1.execSync)('rg --version', { encoding: 'utf-8', timeout: 5000, stdio: 'pipe' });
+            return this.grepWithRg(args, searchPath);
+        }
+        catch { /* rg not available */ }
+        // 2. Try PowerShell Select-String
+        try {
+            return this.grepWithSelectString(args, searchPath);
+        }
+        catch { /* Select-String failed */ }
+        // 3. Fall back to Node-native recursive file scanner
+        return this.grepNodeNative(args, searchPath);
+    }
+    /**
+     * Unix grep: rg > system grep (BSD/GNU)
+     */
+    grepUnix(args, searchPath, platform) {
+        // Try ripgrep first if available
+        try {
+            (0, child_process_1.execSync)('rg --version', { encoding: 'utf-8', timeout: 5000, stdio: 'pipe' });
+            return this.grepWithRg(args, searchPath);
+        }
+        catch { /* rg not available, fall through to system grep */ }
+        const isMac = platform === 'darwin';
         let cmd;
         if (isMac) {
-            // BSD grep: use -r for recursive, -n for line numbers
-            // Note: BSD grep doesn't support --color=never, just omit it
-            if (args.include) {
-                cmd = `grep -rn --include="${args.include}" "${args.pattern}" "${searchPath}"`;
-            }
-            else {
-                cmd = `grep -rn "${args.pattern}" "${searchPath}"`;
-            }
+            cmd = args.include
+                ? `grep -rn --include="${args.include}" "${args.pattern}" "${searchPath}"`
+                : `grep -rn "${args.pattern}" "${searchPath}"`;
         }
         else {
-            // GNU grep (Linux)
-            if (args.include) {
-                cmd = `grep -rn --color=never --include="${args.include}" "${args.pattern}" "${searchPath}"`;
-            }
-            else {
-                cmd = `grep -rn --color=never "${args.pattern}" "${searchPath}"`;
+            cmd = args.include
+                ? `grep -rn --color=never --include="${args.include}" "${args.pattern}" "${searchPath}"`
+                : `grep -rn --color=never "${args.pattern}" "${searchPath}"`;
+        }
+        try {
+            const output = (0, child_process_1.execSync)(cmd, {
+                cwd: this.cwd,
+                encoding: 'utf-8',
+                maxBuffer: 5 * 1024 * 1024,
+                timeout: 30000,
+                env: { ...process.env, GREP_OPTIONS: '' },
+            });
+            return {
+                success: true,
+                output: output.trim(),
+                metadata: { searchStatus: 'search_matches_found' },
+            };
+        }
+        catch (error) {
+            // Distinguish real "no matches" (exit 1 + no stderr) from command failure
+            const stderr = (error.stderr || '').toString();
+            if (error.status === 1 && !stderr.trim()) {
+                return {
+                    success: true,
+                    output: 'No matches found',
+                    metadata: { searchStatus: 'search_no_matches' },
+                };
             }
+            // Real failure: command not found, permission denied, etc.
+            return {
+                success: false,
+                error: stderr || error.message,
+                suggestion: 'The grep command failed. Install ripgrep (rg) for best cross-platform search.',
+                canRetry: true,
+                metadata: { searchStatus: 'search_failed' },
+            };
+        }
+    }
+    /**
+     * Search using ripgrep (rg) — works on all platforms
+     */
+    grepWithRg(args, searchPath) {
+        let cmd = `rg -n --no-heading`;
+        if (args.include) {
+            cmd += ` -g "${args.include}"`;
         }
+        cmd += ` "${args.pattern}" "${searchPath}"`;
         try {
             const output = (0, child_process_1.execSync)(cmd, {
                 cwd: this.cwd,
                 encoding: 'utf-8',
                 maxBuffer: 5 * 1024 * 1024,
                 timeout: 30000,
-                env: { ...process.env, GREP_OPTIONS: '' }, // Prevent user's grep options from interfering
             });
-            return { success: true, output: output.trim() };
+            return {
+                success: true,
+                output: output.trim(),
+                metadata: { searchStatus: 'search_matches_found', backend: 'ripgrep' },
+            };
         }
         catch (error) {
-            if (error.status === 1) {
-                // No matches found
-                return { success: true, output: 'No matches found' };
+            if (error.status === 1 && !(error.stderr || '').toString().trim()) {
+                return {
+                    success: true,
+                    output: 'No matches found',
+                    metadata: { searchStatus: 'search_no_matches', backend: 'ripgrep' },
+                };
             }
-            return { success: false, error: error.message };
+            throw error; // Let caller try next backend
         }
     }
+    /**
+     * Search using PowerShell Select-String (Windows)
+     */
+    grepWithSelectString(args, searchPath) {
+        // Normalize path for PowerShell
+        const psPath = searchPath.replace(/\//g, '\\');
+        const includeFilter = args.include
+            ? `-Include "${args.include}"`
+            : `-Include *`;
+        const escapedPattern = args.pattern.replace(/'/g, "''");
+        const cmd = `powershell -NoProfile -Command "Get-ChildItem -Path '${psPath}' -Recurse -File ${includeFilter} | Select-String -Pattern '${escapedPattern}' | ForEach-Object { $_.Path + ':' + $_.LineNumber + ':' + $_.Line }"`;
+        try {
+            const output = (0, child_process_1.execSync)(cmd, {
+                cwd: this.cwd,
+                encoding: 'utf-8',
+                maxBuffer: 5 * 1024 * 1024,
+                timeout: 60000,
+            });
+            const trimmed = output.trim();
+            if (!trimmed) {
+                return {
+                    success: true,
+                    output: 'No matches found',
+                    metadata: { searchStatus: 'search_no_matches', backend: 'select-string' },
+                };
+            }
+            return {
+                success: true,
+                output: trimmed,
+                metadata: { searchStatus: 'search_matches_found', backend: 'select-string' },
+            };
+        }
+        catch (error) {
+            const stderr = (error.stderr || '').toString();
+            // Select-String returns exit code 1 for no matches when used in pipeline
+            if (error.status === 1 && !stderr.trim()) {
+                return {
+                    success: true,
+                    output: 'No matches found',
+                    metadata: { searchStatus: 'search_no_matches', backend: 'select-string' },
+                };
+            }
+            throw error; // Let caller try next backend
+        }
+    }
+    /**
+     * Pure Node.js recursive file search — reliable on all platforms, no external deps
+     */
+    grepNodeNative(args, searchPath) {
+        const { minimatch } = (() => {
+            try {
+                return require('minimatch');
+            }
+            catch {
+                return { minimatch: null };
+            }
+        })();
+        const results = [];
+        let regex;
+        try {
+            regex = new RegExp(args.pattern, 'i');
+        }
+        catch {
+            // If pattern is not valid regex, treat as literal
+            regex = new RegExp(args.pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i');
+        }
+        const includeGlob = args.include || null;
+        const maxResults = 500;
+        const skipDirs = new Set(['node_modules', '.git', 'dist', 'build', '__pycache__', '.next', 'vendor', '.venv']);
+        const walk = (dir) => {
+            if (results.length >= maxResults)
+                return;
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return; // Permission denied or inaccessible
+            }
+            for (const entry of entries) {
+                if (results.length >= maxResults)
+                    break;
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (!skipDirs.has(entry.name)) {
+                        walk(fullPath);
+                    }
+                    continue;
+                }
+                if (!entry.isFile())
+                    continue;
+                // Check include pattern
+                if (includeGlob) {
+                    const matches = minimatch
+                        ? minimatch(entry.name, includeGlob)
+                        : entry.name.endsWith(includeGlob.replace('*', ''));
+                    if (!matches)
+                        continue;
+                }
+                // Skip binary files by extension
+                const ext = path.extname(entry.name).toLowerCase();
+                const binaryExts = new Set(['.png', '.jpg', '.jpeg', '.gif', '.ico', '.woff', '.woff2', '.ttf', '.eot', '.zip', '.tar', '.gz', '.exe', '.dll', '.so', '.dylib', '.pdf', '.mp3', '.mp4', '.wav', '.avi', '.mov']);
+                if (binaryExts.has(ext))
+                    continue;
+                try {
+                    const content = fs.readFileSync(fullPath, 'utf-8');
+                    const lines = content.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        if (regex.test(lines[i])) {
+                            const relativePath = path.relative(this.cwd, fullPath).replace(/\\/g, '/');
+                            results.push(`${relativePath}:${i + 1}:${lines[i]}`);
+                            if (results.length >= maxResults)
+                                break;
+                        }
+                    }
+                }
+                catch {
+                    // Skip files that can't be read (binary, encoding issues, etc.)
+                }
+            }
+        };
+        try {
+            walk(searchPath);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `File search failed: ${error.message}`,
+                metadata: { searchStatus: 'search_failed', backend: 'node-native' },
+            };
+        }
+        if (results.length === 0) {
+            return {
+                success: true,
+                output: 'No matches found',
+                metadata: { searchStatus: 'search_no_matches', backend: 'node-native' },
+            };
+        }
+        const truncationNote = results.length >= maxResults ? `\n...[truncated at ${maxResults} matches]` : '';
+        return {
+            success: true,
+            output: results.join('\n') + truncationNote,
+            metadata: { searchStatus: 'search_matches_found', backend: 'node-native' },
+        };
+    }
     listDir(args) {
         const dirPath = this.resolvePath(args.path);
         if (!fs.existsSync(dirPath)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.6.16",
+  "version": "1.6.17",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "main": "dist/index.js",
   "files": [