vigthoria-cli 1.6.41 → 1.6.43

package/dist/commands/chat.d.ts

@@ -60,6 +60,13 @@ export declare class ChatCommand {
      * file scanning, or infrastructure changes.
      */
     private isOperatorDirectAnswerable;
+    /**
+     * Returns true when the prompt references code artefacts, file paths,
+     * or analysis verbs that require tool-backed file reading to answer
+     * correctly.  Used to route operator prompts through the agent loop
+     * instead of the toolless BMAD/direct-answer path.
+     */
+    private isRepoGroundedPrompt;
     private inferAgentTaskType;
     private buildTaskShapingInstructions;
     private buildExecutionPrompt;
@@ -124,10 +131,22 @@ export declare class ChatCommand {
     private isProtectedFileReferenceSafe;
     private isProtectedFileReference;
     private buildContinuationPrompt;
+    /**
+     * Extract Key* / event-handler identifiers from tool results grouped by
+     * file, then compute which identifiers actually overlap across files.
+     * Returns a formatted hint string, or empty string if not applicable.
+     */
+    private computeCrossFileKeyEvidence;
     private extractToolCalls;
     private parseToolPayload;
     private stripToolPayloads;
     private extractFinalFileContent;
+    /**
+     * Synthesize a best-effort answer from tool evidence already collected
+     * in the message history.  Used as a fallback when the model API fails
+     * on a continuation turn after evidence was gathered.
+     */
+    private synthesizeEvidenceFromHistory;
     private resolveDirectModeCompletion;
     private isDirectModeFollowUpQuestion;
     private buildLocalAnalysisFallback;

package/dist/commands/chat.js

@@ -216,11 +216,38 @@ class ChatCommand {
      */
     isOperatorDirectAnswerable(prompt) {
         const trimmed = prompt.trim();
-        // Short prompts (under 200 chars) that do not contain action verbs
-        // targeting infrastructure are almost always direct-answerable.
-        const isShortNonAction = trimmed.length < 200
-            && !/\b(deploy|provision|scale|migrate|rollback|restart|install|configure|create|build|scaffold|generate|set up|tear down|spin up|initialize|bootstrap)\b/i.test(trimmed);
-        return this.isAnalysisLookupPrompt(trimmed) || isShortNonAction;
+        // ── Exclusion guard: any prompt that references code artefacts,
+        // file paths, or analysis verbs MUST go through a tool-backed path
+        // (BMAD or agent loop), never the toolless direct-answer shortcut.
+        const repoGrounded = /\b(src\/|\.js\b|\.ts\b|\.py\b|\.jsx\b|\.tsx\b|\.css\b|\.html\b|\.json\b|\.yaml\b|\.yml\b)/i.test(trimmed)
+            || /\b(file|folder|directory|module|class|function|method|variable|handler|listener|binding|conflict|bug|issue|error)\b/i.test(trimmed)
+            || /\b(inspect|analyze|analyse|audit|review|find|diagnose|debug|trace|compare|diff|check|investigate)\b/i.test(trimmed)
+            || /\b(Camera|InputManager|keydown|KeyS|KeyA|KeyW|stopPropagation|addEventListener|handleKeyDown)\b/.test(trimmed)
+            || /\/[a-zA-Z]/.test(trimmed) // slash-prefixed paths
+            || /[A-Z][a-z]+\.[a-z_][a-zA-Z]+/.test(trimmed) // ClassName.methodName
+            || /\b(key\s*code|keydown|keyup|key\s*bind|event\s*listener|event\s*handler|addEventListener|handleKey|onKey)\b/i.test(trimmed);
+        if (repoGrounded)
+            return false;
+        // Only truly trivial prompts are direct-answerable: short echo/smoke
+        // prompts and factual questions with no code or repo reference.
+        const isTrivialEcho = trimmed.length < 120
+            && /^(reply with|say|echo|respond with|return|ping|hello|hi|test|status|what is \d|how much is)\b/i.test(trimmed);
+        return isTrivialEcho;
+    }
+    /**
+     * Returns true when the prompt references code artefacts, file paths,
+     * or analysis verbs that require tool-backed file reading to answer
+     * correctly.  Used to route operator prompts through the agent loop
+     * instead of the toolless BMAD/direct-answer path.
+     */
+    isRepoGroundedPrompt(prompt) {
+        const trimmed = prompt.trim();
+        return /\b(src\/|\.js\b|\.ts\b|\.py\b|\.jsx\b|\.tsx\b|\.css\b|\.html\b|\.json\b)/i.test(trimmed)
+            || /\b(file|folder|module|class|function|method|handler|listener|binding|conflict|bug|error)\b/i.test(trimmed)
+            || /\b(inspect|analyze|analyse|audit|review|find|diagnose|debug|trace|compare|diff|check|investigate)\b/i.test(trimmed)
+            || /\/[a-zA-Z]/.test(trimmed)
+            || /[A-Z][a-z]+\.[a-z_][a-zA-Z]+/.test(trimmed) // ClassName.methodName patterns
+            || /\b(key\s*code|keydown|keyup|key\s*bind|event\s*listener|event\s*handler|addEventListener|handleKey|onKey)\b/i.test(trimmed);
     }
     inferAgentTaskType(prompt) {
         if (this.isDiagnosticPrompt(prompt))
@@ -798,6 +825,16 @@ class ChatCommand {
             await this.runOperatorDirectAnswer(prompt);
             return;
         }
+        // ── Repo-grounded operator path: use the agent loop with tools ──
+        // Prompts that reference files, code symbols, or analysis verbs need
+        // tool access to read actual file contents.  Route these through the
+        // local agent loop (which has read_file, grep, etc.) instead of the
+        // toolless BMAD SSE workflow which cannot read files and will fabricate.
+        if (this.isRepoGroundedPrompt(prompt) && this.tools) {
+            this.operatorMode = true;
+            await this.runLocalAgentLoop(prompt);
+            return;
+        }
         (0, bridge_client_js_1.getBridgeClient)()?.emitPrompt({ prompt, mode: 'operator', model: this.currentModel });
         const runtimeContext = await this.getPromptRuntimeContext(prompt);
         const spinner = this.jsonOutput ? null : (0, logger_js_1.createSpinner)({ text: 'Thinking like an operator...', spinner: 'clock' }).start();
@@ -1096,10 +1133,52 @@ class ChatCommand {
         const maxTurns = 10;
         for (let turn = 0; turn < maxTurns; turn += 1) {
             const spinner = this.jsonOutput ? null : (0, logger_js_1.createSpinner)({ text: turn === 0 ? 'Planning...' : 'Continuing...', spinner: 'clock' }).start();
+            let response;
+            try {
+                response = await this.api.chat(this.getMessagesForModel(), this.currentModel);
+            }
+            catch (firstErr) {
+                // If we already gathered evidence and the model API fails on a
+                // continuation turn, retry once after a short delay.
+                if (turn > 0 && this.agentToolEvidence.discovery > 0) {
+                    this.logger.debug('Agent continuation API call failed, retrying once...');
+                    try {
+                        await new Promise(r => setTimeout(r, 2000));
+                        response = await this.api.chat(this.getMessagesForModel(), this.currentModel);
+                    }
+                    catch (retryErr) {
+                        // Retry also failed — synthesize an answer from evidence
+                        if (spinner)
+                            spinner.stop();
+                        const evidenceSummary = this.synthesizeEvidenceFromHistory();
+                        if (evidenceSummary) {
+                            const fallbackContent = `[Agent recovered from backend failure — answer synthesized from gathered evidence]\n\n${evidenceSummary}`;
+                            if (this.jsonOutput) {
+                                console.log(JSON.stringify({
+                                    success: true,
+                                    mode: 'agent',
+                                    model: this.currentModel,
+                                    partial: true,
+                                    content: fallbackContent,
+                                    metadata: { executionPath: 'local-agent-loop', recovered: true },
+                                }, null, 2));
+                            }
+                            else {
+                                console.log(fallbackContent);
+                            }
+                            this.saveSession();
+                            return;
+                        }
+                        throw retryErr;
+                    }
+                }
+                else {
+                    throw firstErr;
+                }
+            }
+            if (spinner)
+                spinner.stop();
             try {
-                const response = await this.api.chat(this.getMessagesForModel(), this.currentModel);
-                if (spinner)
-                    spinner.stop();
                 const assistantMessage = response.message || '';
                 this.messages.push({ role: 'assistant', content: assistantMessage });
                 const toolCalls = this.extractToolCalls(assistantMessage);
@@ -1896,6 +1975,11 @@ class ChatCommand {
         if (searchFailed > 0) {
             evidenceLines.push(`Warning: ${searchFailed} search tool call(s) failed. Do not treat failed searches as evidence that something is missing.`);
         }
+        // Cross-file overlap: extract Key* identifiers per file from tool results
+        const crossFileEvidence = this.computeCrossFileKeyEvidence();
+        if (crossFileEvidence) {
+            evidenceLines.push(crossFileEvidence);
+        }
         return [
             `Tool results received for direct mode step ${this.directToolContinuationCount + 1}.`,
             `Original user request: ${this.lastActionableUserInput}`,
@@ -1912,6 +1996,75 @@ class ChatCommand {
             'Do not ask follow-up questions or drift into unrelated tasks.',
         ].join('\n');
     }
+    /**
+     * Extract Key* / event-handler identifiers from tool results grouped by
+     * file, then compute which identifiers actually overlap across files.
+     * Returns a formatted hint string, or empty string if not applicable.
+     */
+    computeCrossFileKeyEvidence() {
+        const fileKeyMap = new Map();
+        // Match standalone Key* codes like KeyA, KeyS, KeyW etc.
+        // Exclude false positives from method names like handleKeyDown, KeyboardEvent
+        const keyPattern = /(?<![a-z])Key[A-Z](?![a-z])/g;
+        let currentFile = '';
+        for (const msg of this.messages) {
+            if (msg.role !== 'system')
+                continue;
+            // Detect which file a tool result is about from "File: xxx" tag
+            const fileTag = msg.content.match(/^Tool (?:read_file|grep) (?:succeeded|FAILED)\.\nFile: (.+)/m);
+            if (fileTag) {
+                currentFile = fileTag[1].trim();
+            }
+            if (!currentFile)
+                continue;
+            // Extract keys from code content, filtering out method name false positives
+            const cleanedContent = msg.content
+                .replace(/handleKeyDown|handleKeyUp|onKeyDown|onKeyUp|_onKeyDown|_onKeyUp|KeyboardEvent|keydown|keyup/gi, '___');
+            const keys = cleanedContent.match(keyPattern);
+            if (keys) {
+                if (!fileKeyMap.has(currentFile)) {
+                    fileKeyMap.set(currentFile, new Set());
+                }
+                const keySet = fileKeyMap.get(currentFile);
+                for (const k of keys)
+                    keySet.add(k);
+            }
+        }
+        if (fileKeyMap.size < 2)
+            return '';
+        // Compute overlap
+        const allFiles = [...fileKeyMap.keys()];
+        const allKeys = new Set();
+        for (const ks of fileKeyMap.values())
+            for (const k of ks)
+                allKeys.add(k);
+        const overlapping = [];
+        const unique = new Map();
+        for (const key of allKeys) {
+            const filesWithKey = allFiles.filter(f => fileKeyMap.get(f).has(key));
+            if (filesWithKey.length > 1) {
+                overlapping.push(key);
+            }
+            else {
+                const file = filesWithKey[0];
+                if (!unique.has(file))
+                    unique.set(file, []);
+                unique.get(file).push(key);
+            }
+        }
+        const lines = ['MANDATORY CROSS-FILE EVIDENCE (computed from actual tool output — this is ground truth):'];
+        if (overlapping.length > 0) {
+            lines.push(`CONFIRMED CONFLICTING keys (found in MULTIPLE files): ${overlapping.join(', ')}`);
+        }
+        else {
+            lines.push('WARNING: No keys found in multiple files — there may be no actual key conflict.');
+        }
+        for (const [file, keys] of unique) {
+            lines.push(`Keys found ONLY in ${file} (NOT in other files): ${keys.join(', ')}`);
+        }
+        lines.push('CONSTRAINT: Your answer MUST list ONLY the keys from the "CONFIRMED CONFLICTING" line above as conflicting. Keys listed as "ONLY in [file]" MUST NOT be reported as conflicts. This data was computed from the exact tool output and overrides any assumption.');
+        return lines.join('\n');
+    }
     extractToolCalls(message) {
         const calls = [];
         const seen = new Set();
@@ -1973,6 +2126,30 @@ class ChatCommand {
         }
         return trimmed;
     }
+    /**
+     * Synthesize a best-effort answer from tool evidence already collected
+     * in the message history.  Used as a fallback when the model API fails
+     * on a continuation turn after evidence was gathered.
+     */
+    synthesizeEvidenceFromHistory() {
+        const toolOutputs = [];
+        for (const msg of this.messages) {
+            if (msg.role === 'system' && msg.content.includes('Tool results')) {
+                // Collect tool result summaries
+                toolOutputs.push(msg.content);
+            }
+        }
+        if (toolOutputs.length === 0)
+            return '';
+        // Extract file contents and grep results from tool outputs
+        const evidence = ['Evidence gathered before backend failure:\n'];
+        for (const output of toolOutputs) {
+            // Truncate long outputs but keep the key evidence
+            const trimmed = output.length > 3000 ? output.slice(0, 3000) + '\n[...truncated]' : output;
+            evidence.push(trimmed);
+        }
+        return evidence.join('\n---\n');
+    }
     resolveDirectModeCompletion(prompt, visibleText) {
         const normalized = (visibleText || '').trim();
         if (normalized && !this.isDirectModeFollowUpQuestion(normalized)) {
@@ -2110,6 +2287,10 @@ class ChatCommand {
     }
     formatToolResult(call, result) {
         const parts = [`Tool ${call.tool} ${result.success ? 'succeeded' : 'FAILED'}.`];
+        // Include file path for read_file/grep so cross-file evidence can be computed
+        if (call.args.path) {
+            parts.push(`File: ${call.args.path}`);
+        }
         // Include search status classification for the agent to reason about
         const searchStatus = result.metadata?.searchStatus;
         if (searchStatus) {
@@ -2127,7 +2308,7 @@ class ChatCommand {
         return parts.join('\n');
     }
     truncateText(text) {
-        const maxLength = 4000;
+        const maxLength = 12000;
         if (text.length <= maxLength) {
             return text;
         }

package/dist/utils/tools.js

@@ -624,12 +624,20 @@ class AgenticTools {
             }
             const content = fs.readFileSync(filePath, 'utf-8');
             const lines = content.split('\n');
-            const startLine = args.start_line ? parseInt(args.start_line) - 1 : 0;
-            const endLine = args.end_line ? parseInt(args.end_line) : lines.length;
-            // Validate line numbers
-            if (startLine < 0 || startLine >= lines.length) {
-                return this.createErrorResult(ToolErrorType.INVALID_ARGS, `Invalid start_line: ${args.start_line}. File has ${lines.length} lines.`);
-            }
+            // Clamp start_line: API is 1-based; the model sometimes emits 0 or
+            // negative values.  Silently clamp to valid range instead of failing.
+            let rawStart = args.start_line ? parseInt(args.start_line) : 1;
+            if (rawStart < 1)
+                rawStart = 1;
+            if (rawStart > lines.length)
+                rawStart = lines.length;
+            const startLine = rawStart - 1; // convert to 0-based
+            let rawEnd = args.end_line ? parseInt(args.end_line) : lines.length;
+            if (rawEnd < rawStart)
+                rawEnd = rawStart;
+            if (rawEnd > lines.length)
+                rawEnd = lines.length;
+            const endLine = rawEnd;
             const selectedLines = lines.slice(startLine, Math.min(endLine, lines.length));
             return {
                 success: true,

package/package.json

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