vigthoria-cli 1.6.25 → 1.6.27

package/dist/commands/chat.js

@@ -421,12 +421,42 @@ class ChatCommand {
             return;
         }
         if (options.prompt) {
+            // Wrap in a timeout to guarantee bridge cleanup even if the agent
+            // loop hangs (e.g. model takes forever on a turn).
+            const BRIDGE_TIMEOUT_MS = 180_000; // 3 minutes max for a single prompt
+            let timedOut = false;
+            const timeoutId = options.bridge
+                ? setTimeout(() => {
+                    timedOut = true;
+                    const b = (0, bridge_client_js_1.getBridgeClient)();
+                    if (b) {
+                        b.emitEnd({ reason: 'timeout' });
+                        b.destroy();
+                    }
+                    if (!this.jsonOutput) {
+                        this.logger.error('Bridge prompt timed out after 3 minutes.');
+                    }
+                    process.exitCode = 1;
+                }, BRIDGE_TIMEOUT_MS)
+                : null;
             await this.handleDirectPrompt(options.prompt);
-            (0, bridge_client_js_1.getBridgeClient)()?.emitEnd({ reason: 'prompt-complete' });
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (!timedOut) {
+                const bridge = (0, bridge_client_js_1.getBridgeClient)();
+                if (bridge) {
+                    bridge.emitEnd({ reason: 'prompt-complete' });
+                    bridge.destroy();
+                }
+            }
             return;
         }
         await this.startInteractiveChat();
-        (0, bridge_client_js_1.getBridgeClient)()?.emitEnd({ reason: 'interactive-exit' });
+        const bridge = (0, bridge_client_js_1.getBridgeClient)();
+        if (bridge) {
+            bridge.emitEnd({ reason: 'interactive-exit' });
+            bridge.destroy();
+        }
     }
     /** Handle an inbound admin command from the Commando Bridge. */
     handleAdminCommand(cmd) {
@@ -584,16 +614,23 @@ class ChatCommand {
      */
     isSimpleDirectPrompt(prompt) {
         const trimmed = prompt.trim();
-        // Short prompts (≤ 12 words) that don't reference files, builds, or code tasks
         const wordCount = trimmed.split(/\s+/).length;
-        if (wordCount <= 12 && !/(create|build|generate|implement|write.*function|add.*feature|refactor|deploy|fix|edit|modify|update|delete|remove)\b/i.test(trimmed)) {
+        // Never treat prompts that reference files, dirs, or workspace as simple
+        // — these need agent tool access (list_dir, read_file, etc.)
+        if (/(file|folder|director|code|project|workspace|repo|module|component|function|class|api|endpoint|route|database|schema|migration|docker|deploy|build|test)\b/i.test(trimmed)) {
+            return false;
+        }
+        // Never treat tool-action verbs as simple
+        if (/(list|find|search|show|check|scan|read|inspect|analyze|analyse|audit|review|count|create|build|generate|implement|write.*function|add.*feature|refactor|fix|edit|modify|update|delete|remove)\b/i.test(trimmed)) {
+            return false;
+        }
+        // Short conversational prompts (≤ 15 words) with no file/tool context
+        if (wordCount <= 15) {
             return true;
         }
-        // Conversational / Q&A prompts
-        if (/^(what|who|when|where|why|how|is|are|do|does|can|could|would|should|tell|explain|describe|list|show|help|reply|say|respond|answer|translate|summarize|define)\b/i.test(trimmed)) {
-            if (!/(file|code|project|workspace|repo|module|component|function|class|api|endpoint|route|database|schema|migration|docker|deploy|build|test)\b/i.test(trimmed)) {
-                return true;
-            }
+        // Conversational Q&A starters
+        if (/^(what|who|when|where|why|how|is|are|do|does|can|could|would|should|tell|explain|help|reply|say|respond|answer|translate|summarize|define)\b/i.test(trimmed)) {
+            return true;
         }
         return false;
     }
@@ -611,9 +648,16 @@ class ChatCommand {
             await this.runWorkflowTargetPrompt(prompt);
             return;
         }
-        // Smart routing: skip agent planner for simple/conversational prompts
-        if (this.agentMode && !this.isSimpleDirectPrompt(prompt)) {
-            await this.runAgentTurn(prompt);
+        // Smart routing: for agent mode, determine if prompt needs tool access
+        if (this.agentMode) {
+            if (this.isSimpleDirectPrompt(prompt)) {
+                // Simple prompt: downgrade to plain chat model, no agent system prompt
+                this.currentModel = this.getDefaultChatModel();
+                await this.runSimplePrompt(prompt);
+            }
+            else {
+                await this.runAgentTurn(prompt);
+            }
             return;
         }
         if (this.operatorMode) {
@@ -822,30 +866,36 @@ class ChatCommand {
     }
     async runSimplePrompt(prompt) {
         this.lastActionableUserInput = prompt;
-        // In non-agent chat mode the model has no tool access.  Inject a
-        // grounding constraint so it doesn't fabricate file contents.
-        // Also inject a real file listing so the model can reference actual
-        // paths instead of guessing.
-        const needsGrounding = /(repo|file|code|project|workspace|source|inspect|analyze|audit|review)/i.test(prompt);
-        if (needsGrounding && !this.messages.some(m => m.role === 'system' && m.content.includes('no direct file access'))) {
-            let groundingContent = 'You are in simple chat mode with no direct file access or tools. Do not fabricate file contents, search results, or analysis steps. If the user asks you to modify, edit, or deeply inspect files, advise them to use agent mode (vig chat --agent) for grounded repo analysis.';
-            // Inject a workspace file listing so the model has real paths
-            try {
-                const snapshot = this.api.getAgentWorkspaceSnapshot(this.currentProjectPath);
-                if (snapshot && snapshot.paths.length > 0) {
-                    const listing = snapshot.paths.slice(0, 60).join('\n');
-                    groundingContent += `\n\nWorkspace: ${this.currentProjectPath}\nFile listing (${snapshot.fileCount} files total):\n${listing}`;
-                    if (snapshot.fileCount > 60) {
-                        groundingContent += `\n... and ${snapshot.fileCount - 60} more files.`;
-                    }
-                }
-            }
-            catch { /* ignore snapshot errors */ }
+        // For direct --prompt mode with simple prompts, use a minimal system
+        // message to avoid polluting the response with tool/platform context.
+        if (this.directPromptMode && !this.messages.some(m => m.role === 'system')) {
             this.messages.push({
                 role: 'system',
-                content: groundingContent,
+                content: 'Answer the user\'s question directly and concisely. Do not describe tools, platform constraints, or capabilities unless explicitly asked. If the user\'s instruction is to produce specific output, produce exactly that output with no preamble.',
             });
         }
+        else if (!this.directPromptMode) {
+            // Interactive mode: inject grounding for file-related queries
+            const needsGrounding = /(repo|file|code|project|workspace|source|inspect|analyze|audit|review)/i.test(prompt);
+            if (needsGrounding && !this.messages.some(m => m.role === 'system' && m.content.includes('no direct file access'))) {
+                let groundingContent = 'You are in simple chat mode with no direct file access or tools. Do not fabricate file contents, search results, or analysis steps. If the user asks you to modify, edit, or deeply inspect files, advise them to use agent mode (vig chat --agent) for grounded repo analysis.';
+                try {
+                    const snapshot = this.api.getAgentWorkspaceSnapshot(this.currentProjectPath);
+                    if (snapshot && snapshot.paths.length > 0) {
+                        const listing = snapshot.paths.slice(0, 60).join('\n');
+                        groundingContent += `\n\nWorkspace: ${this.currentProjectPath}\nFile listing (${snapshot.fileCount} files total):\n${listing}`;
+                        if (snapshot.fileCount > 60) {
+                            groundingContent += `\n... and ${snapshot.fileCount - 60} more files.`;
+                        }
+                    }
+                }
+                catch { /* ignore snapshot errors */ }
+                this.messages.push({
+                    role: 'system',
+                    content: groundingContent,
+                });
+            }
+        }
         this.messages.push({ role: 'user', content: this.buildExecutionPrompt(prompt) });
         (0, bridge_client_js_1.getBridgeClient)()?.emitPrompt({ prompt, mode: 'chat', model: this.currentModel });
         const spinner = this.jsonOutput ? null : (0, logger_js_1.createSpinner)({ text: 'Thinking...', spinner: 'clock' }).start();

package/dist/commands/edit.d.ts

@@ -21,6 +21,13 @@ export declare class EditCommand {
     run(filePath: string, options: EditOptions): Promise<void>;
     fix(filePath: string, options: FixOptions): Promise<void>;
     private extractCode;
+    /**
+     * Detect and remove duplicated content in model output.
+     * Models sometimes output the code twice or three times.
+     * Applies iteratively until no further duplicates are found.
+     */
+    private deduplicateCode;
+    private deduplicateOnce;
     private showDiffAndConfirm;
     private showFullDiff;
     private applyFix;

package/dist/commands/edit.js

@@ -133,7 +133,24 @@ Return the complete modified file content:`,
         try {
             const result = await this.api.fixCode(file.content, file.language, options.type);
             spinner.stop();
+            // Deduplicate the fixed output — models sometimes repeat code 2-3x
+            result.fixed = this.deduplicateCode(result.fixed);
             if (result.changes.length === 0) {
+                // Even if the diff engine found no structured changes, the fixed
+                // code may still differ (e.g. single-char operator swap).  Show a
+                // diff and let the user decide instead of silently discarding.
+                if (result.fixed && result.fixed !== file.content) {
+                    this.logger.section('Found 1 issue(s)');
+                    console.log(chalk_1.default.yellow('1. Operator/character-level fix detected'));
+                    console.log();
+                    if (options.apply) {
+                        await this.applyFix(file.path, file.content, result.fixed);
+                    }
+                    else {
+                        await this.showDiffAndConfirm(file.path, file.content, result.fixed);
+                    }
+                    return;
+                }
                 this.logger.success('No issues found!');
                 return;
             }
@@ -174,10 +191,49 @@ Return the complete modified file content:`,
         // If no code block, check if response looks like code
         const trimmed = response.trim();
         if (!trimmed.startsWith('```') && !trimmed.includes('Here') && !trimmed.includes('I ')) {
-            return trimmed;
+            return this.deduplicateCode(trimmed);
         }
         return null;
     }
+    /**
+     * Detect and remove duplicated content in model output.
+     * Models sometimes output the code twice or three times.
+     * Applies iteratively until no further duplicates are found.
+     */
+    deduplicateCode(code) {
+        let result = code;
+        // Iterate up to 3 times to handle triple+ duplication
+        for (let pass = 0; pass < 3; pass++) {
+            const deduped = this.deduplicateOnce(result);
+            if (deduped === result)
+                break;
+            result = deduped;
+        }
+        return result;
+    }
+    deduplicateOnce(code) {
+        const lines = code.split('\n');
+        const len = lines.length;
+        if (len < 4)
+            return code;
+        // Check if the second half is a near-duplicate of the first half
+        for (let splitAt = Math.floor(len * 0.4); splitAt <= Math.ceil(len * 0.6); splitAt++) {
+            const firstHalf = lines.slice(0, splitAt);
+            const secondHalf = lines.slice(splitAt).filter(l => l.trim() !== '');
+            if (secondHalf.length < 2)
+                continue;
+            let matches = 0;
+            for (const line of secondHalf) {
+                if (firstHalf.some(fl => fl.trim() === line.trim()))
+                    matches++;
+            }
+            // If >70% of second half matches first half, it's a duplicate — keep second half
+            if (matches / secondHalf.length > 0.7) {
+                return secondHalf.join('\n');
+            }
+        }
+        return code;
+    }
     async showDiffAndConfirm(filePath, original, modified) {
         const diff = this.fileUtils.createDiff(original, modified);
         if (diff.added.length === 0 && diff.removed.length === 0) {
@@ -240,23 +296,56 @@ Return the complete modified file content:`,
         const modifiedLines = modified.split('\n');
         console.log();
         console.log(chalk_1.default.gray('─'.repeat(60)));
-        const maxLen = Math.max(originalLines.length, modifiedLines.length);
-        for (let i = 0; i < maxLen; i++) {
-            const orig = originalLines[i];
-            const mod = modifiedLines[i];
-            const lineNum = String(i + 1).padStart(4, ' ');
-            if (orig === mod) {
-                console.log(chalk_1.default.gray(`${lineNum} │ ${orig || ''}`));
-            }
-            else {
-                if (orig !== undefined) {
-                    console.log(chalk_1.default.red(`${lineNum} - ${orig}`));
+        // Use LCS-based diff to avoid line-shift inflation
+        const m = originalLines.length;
+        const n = modifiedLines.length;
+        const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+        for (let i = 1; i <= m; i++) {
+            for (let j = 1; j <= n; j++) {
+                if (originalLines[i - 1] === modifiedLines[j - 1]) {
+                    dp[i][j] = dp[i - 1][j - 1] + 1;
                 }
-                if (mod !== undefined) {
-                    console.log(chalk_1.default.green(`${lineNum} + ${mod}`));
+                else {
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                 }
             }
         }
+        // Backtrack to produce diff ops
+        const ops = [];
+        let i = m, j = n;
+        while (i > 0 || j > 0) {
+            if (i > 0 && j > 0 && originalLines[i - 1] === modifiedLines[j - 1]) {
+                ops.push({ type: 'keep', text: originalLines[i - 1], lineNum: i });
+                i--;
+                j--;
+            }
+            else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+                ops.push({ type: 'add', text: modifiedLines[j - 1], lineNum: j });
+                j--;
+            }
+            else {
+                ops.push({ type: 'remove', text: originalLines[i - 1], lineNum: i });
+                i--;
+            }
+        }
+        ops.reverse();
+        let displayLine = 0;
+        for (const op of ops) {
+            if (op.type === 'keep') {
+                displayLine++;
+                const lineNum = String(displayLine).padStart(4, ' ');
+                console.log(chalk_1.default.gray(`${lineNum} │ ${op.text || ''}`));
+            }
+            else if (op.type === 'remove') {
+                displayLine++;
+                const lineNum = String(displayLine).padStart(4, ' ');
+                console.log(chalk_1.default.red(`${lineNum} - ${op.text}`));
+            }
+            else {
+                const lineNum = '   +';
+                console.log(chalk_1.default.green(`${lineNum} + ${op.text}`));
+            }
+        }
         console.log(chalk_1.default.gray('─'.repeat(60)));
         console.log();
     }

package/dist/index.js

@@ -98,7 +98,7 @@ function getVersion() {
     catch (e) {
         // Fallback to hardcoded version
     }
-    return '1.6.25';
+    return '1.6.27';
 }
 const VERSION = getVersion();
 /**
@@ -576,10 +576,9 @@ async function main() {
             force: options.force
         });
     });
-    // Default repo action shows list
-    repoCommand.action(async () => {
-        const repo = new repo_js_1.RepoCommand(config, logger);
-        await repo.list({});
+    // Default repo action shows help with available subcommands
+    repoCommand.action(() => {
+        repoCommand.outputHelp();
     });
     // ==================== DEPLOY COMMANDS ====================
     // Deploy command - Host projects on Vigthoria

package/dist/utils/api.d.ts

@@ -384,6 +384,12 @@ export declare class APIClient {
             reason: string;
         }[];
     }>;
+    /**
+     * Compute a semantic diff between original and fixed code using
+     * Longest Common Subsequence (LCS) to avoid the line-shift inflation
+     * bug where inserting one line flags all subsequent lines as changed.
+     */
+    private computeSemanticDiff;
     /**
      * Lightweight client-side syntax error detection.
      * Returns a human-readable description of obvious errors, or empty string.

package/dist/utils/api.js

@@ -50,7 +50,7 @@ class APIClient {
         // Main Vigthoria Coder API (coder.vigthoria.io)
         this.client = axios_1.default.create({
             baseURL: config.get('apiUrl'),
-            timeout: 120000,
+            timeout: 300000, // 5 minutes — covers review, fix, and agent relay flows
             httpsAgent,
             headers: {
                 'Content-Type': 'application/json',
@@ -3320,10 +3320,11 @@ document.addEventListener('DOMContentLoaded', () => {
                 depth--;
         }
         if (depth > 0) {
-            const trimmed = code.trimEnd();
+            let result = code.trimEnd();
             for (let i = 0; i < depth; i++) {
-                code = trimmed + '\n};';
+                result += '\n}';
             }
+            code = result;
         }
         return code;
     }
@@ -3373,7 +3374,7 @@ document.addEventListener('DOMContentLoaded', () => {
      * for a pure programming language like JavaScript, Python, etc.
      */
     codeContainsDomPollution(code) {
-        const domPatterns = /document\.(createElement|querySelector|getElementById|getElementsBy|body|head|addEventListener)|innerHTML|\.style\.(cssText|position|transform|animation)|@keyframes|\.appendChild|\.removeChild|window\.(onload|addEventListener)/;
+        const domPatterns = /document\.(createElement|querySelector|getElementById|getElementsBy|body|head|addEventListener)|innerHTML|\.style\.(cssText|position|transform|animation)|@keyframes|\.appendChild|\.removeChild|window\.(onload|addEventListener)|CSSAnimation|new\s+Animation\b|\.getAnimations\s*\(|\.animate\s*\(/;
         return domPatterns.test(code);
     }
     /**
@@ -3387,7 +3388,7 @@ document.addEventListener('DOMContentLoaded', () => {
         let braceDepth = 0;
         for (const line of lines) {
             // Detect start of DOM blocks
-            if (/document\.|\.style\.|\.appendChild|\.removeChild|\.textContent\s*=|@keyframes|addEventListener/.test(line) && !insideDomBlock) {
+            if (/document\.|\.style\.|\.appendChild|\.removeChild|\.textContent\s*=|@keyframes|addEventListener|CSSAnimation|\.getAnimations|\.animate\s*\(/.test(line) && !insideDomBlock) {
                 insideDomBlock = true;
                 braceDepth = 0;
             }
@@ -3455,7 +3456,18 @@ document.addEventListener('DOMContentLoaded', () => {
         // even when the server only reports style issues like console.log.
         const heuristic = this.heuristicCodeIssues(code, language);
         for (const h of heuristic) {
-            // Avoid duplicating issues the server already reported on the same line
+            // Always include critical logic bugs (severity error) from heuristics
+            // regardless of server results — these catch wrong-operator bugs the
+            // server frequently misses.
+            if (h.severity === 'error') {
+                const exactDuplicate = issues.some((existing) => existing.line === h.line && existing.message === h.message);
+                if (!exactDuplicate) {
+                    issues.push(h);
+                }
+                continue;
+            }
+            // For non-critical heuristics, avoid duplicating issues the server
+            // already reported on the same line with the same type.
             const isDuplicate = issues.some((existing) => existing.line === h.line && existing.type === h.type);
             if (!isDuplicate) {
                 issues.push(h);
@@ -3570,15 +3582,28 @@ document.addEventListener('DOMContentLoaded', () => {
     async fixCode(code, language, fixType) {
         // Client-side syntax pre-check: detect obvious errors and include
         // them in the request so the model has concrete signals.
-        const syntaxHints = this.detectSyntaxErrors(code, language);
-        // Also run heuristic logic analysis to find real bugs
+        const syntaxHints = fixType === 'bugs' || fixType === 'syntax' ? this.detectSyntaxErrors(code, language) : '';
+        // Run heuristic logic analysis, but ONLY pass hints relevant to the fixType
         const heuristicIssues = this.heuristicCodeIssues(code, language);
-        const logicHints = heuristicIssues
+        const relevantIssues = heuristicIssues.filter(issue => {
+            if (fixType === 'bugs' || fixType === 'logic')
+                return issue.type === 'logic' || issue.severity === 'error';
+            if (fixType === 'syntax')
+                return issue.severity === 'error';
+            if (fixType === 'style')
+                return issue.type === 'style' || issue.type === 'quality';
+            if (fixType === 'security')
+                return issue.type === 'security';
+            if (fixType === 'performance')
+                return issue.type === 'performance';
+            return true; // 'all' or unknown fixType: include everything
+        });
+        const logicHints = relevantIssues
             .map(i => `Line ${i.line}: [${i.type}] ${i.message}`)
             .join('\n// ');
         const allHints = [syntaxHints, logicHints].filter(Boolean).join('\n// ');
         const augmentedCode = allHints
-            ? `// BUGS DETECTED BY STATIC ANALYSIS — YOU MUST FIX THESE:\n// ${allHints}\n\n${code}`
+            ? `// BUGS DETECTED BY STATIC ANALYSIS — YOU MUST FIX THESE:\n// ${allHints}\n// IMPORTANT: Fix ONLY these specific bugs. Do not add comments, do not restructure the code, do not add or remove lines beyond the minimal fix.\n\n${code}`
             : code;
         const response = await this.client.post('/api/ai/fix', {
             code: augmentedCode,
@@ -3602,29 +3627,96 @@ document.addEventListener('DOMContentLoaded', () => {
             }
         }
         // If there are still no changes but the fixed code differs, compute
-        // a line-level diff so the user sees exactly what changed.
+        // a semantic diff using LCS so inserted/removed lines don't cause
+        // every subsequent line to appear as changed.
         if (changes.length === 0 && fixed !== code) {
-            const origLines = code.split('\n');
-            const fixedLines = fixed.split('\n');
-            const maxLen = Math.max(origLines.length, fixedLines.length);
-            for (let i = 0; i < maxLen; i++) {
-                const orig = origLines[i] ?? '';
-                const fixd = fixedLines[i] ?? '';
-                if (orig !== fixd) {
+            // Use a clean reason string — strip verbose static-analysis hints
+            const cleanReason = relevantIssues.length > 0
+                ? relevantIssues.map(i => i.message).join('; ')
+                : 'AI-suggested fix';
+            changes = this.computeSemanticDiff(code, fixed, cleanReason);
+        }
+        return { fixed, changes };
+    }
+    /**
+     * Compute a semantic diff between original and fixed code using
+     * Longest Common Subsequence (LCS) to avoid the line-shift inflation
+     * bug where inserting one line flags all subsequent lines as changed.
+     */
+    computeSemanticDiff(original, fixed, reason) {
+        const origLines = original.split('\n');
+        const fixedLines = fixed.split('\n');
+        const changes = [];
+        // Build LCS table
+        const m = origLines.length;
+        const n = fixedLines.length;
+        const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+        for (let i = 1; i <= m; i++) {
+            for (let j = 1; j <= n; j++) {
+                if (origLines[i - 1] === fixedLines[j - 1]) {
+                    dp[i][j] = dp[i - 1][j - 1] + 1;
+                }
+                else {
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+                }
+            }
+        }
+        // Backtrack to find the diff
+        let i = m, j = n;
+        const ops = [];
+        while (i > 0 || j > 0) {
+            if (i > 0 && j > 0 && origLines[i - 1] === fixedLines[j - 1]) {
+                ops.push({ type: 'keep', origLine: i, fixedLine: j, text: origLines[i - 1] });
+                i--;
+                j--;
+            }
+            else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+                ops.push({ type: 'add', fixedLine: j, text: fixedLines[j - 1] });
+                j--;
+            }
+            else {
+                ops.push({ type: 'remove', origLine: i, text: origLines[i - 1] });
+                i--;
+            }
+        }
+        ops.reverse();
+        // Merge adjacent remove+add pairs into single change entries
+        let idx = 0;
+        while (idx < ops.length) {
+            const op = ops[idx];
+            if (op.type === 'remove') {
+                // Look ahead for a matching 'add' immediately after
+                if (idx + 1 < ops.length && ops[idx + 1].type === 'add') {
                     changes.push({
-                        line: i + 1,
-                        before: orig || '(empty line)',
-                        after: fixd || '(line removed)',
-                        reason: allHints || 'AI-suggested fix',
+                        line: op.origLine,
+                        before: op.text,
+                        after: ops[idx + 1].text,
+                        reason: reason || 'AI-suggested fix',
                     });
+                    idx += 2;
+                    continue;
                 }
+                changes.push({
+                    line: op.origLine,
+                    before: op.text,
+                    after: '(line removed)',
+                    reason: reason || 'AI-suggested fix',
+                });
             }
-            // If diff produced nothing (whitespace-only?), at least show a summary
-            if (changes.length === 0) {
-                changes = [{ line: 1, before: '(whitespace changes)', after: '(see fixed file)', reason: allHints || 'AI-suggested fix' }];
+            else if (op.type === 'add') {
+                changes.push({
+                    line: op.fixedLine,
+                    before: '(new line)',
+                    after: op.text,
+                    reason: reason || 'AI-suggested fix',
+                });
             }
+            idx++;
         }
-        return { fixed, changes };
+        if (changes.length === 0) {
+            changes.push({ line: 1, before: '(whitespace changes)', after: '(see fixed file)', reason: reason || 'AI-suggested fix' });
+        }
+        return changes;
     }
     /**
      * Lightweight client-side syntax error detection.

package/package.json

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