vigthoria-cli 1.6.24 → 1.6.26

package/dist/commands/chat.d.ts

@@ -75,6 +75,13 @@ export declare class ChatCommand {
     private slugifyWorkspaceName;
     private allocateManagedWorkspacePath;
     private initializeSession;
+    /**
+     * Determine whether a direct --prompt call is simple enough to skip the
+     * full V3 Agent planner and answer directly via the simple chat pipeline.
+     * This prevents trivial prompts like "Reply with OK" from triggering a
+     * multi-step planning workflow with quality_profile: premium-visual-build.
+     */
+    private isSimpleDirectPrompt;
     private handleDirectPrompt;
     private formatWorkflowTargetResult;
     private runWorkflowTargetPrompt;

package/dist/commands/chat.js

@@ -422,11 +422,19 @@ class ChatCommand {
         }
         if (options.prompt) {
             await this.handleDirectPrompt(options.prompt);
-            (0, bridge_client_js_1.getBridgeClient)()?.emitEnd({ reason: 'prompt-complete' });
+            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) {
@@ -576,6 +584,34 @@ class ChatCommand {
         this.currentSession = this.sessionManager.create(this.currentProjectPath, this.currentModel, this.agentMode, this.operatorMode);
         this.messages = [...this.currentSession.messages];
     }
+    /**
+     * Determine whether a direct --prompt call is simple enough to skip the
+     * full V3 Agent planner and answer directly via the simple chat pipeline.
+     * This prevents trivial prompts like "Reply with OK" from triggering a
+     * multi-step planning workflow with quality_profile: premium-visual-build.
+     */
+    isSimpleDirectPrompt(prompt) {
+        const trimmed = prompt.trim();
+        const wordCount = trimmed.split(/\s+/).length;
+        // 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 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;
+    }
     async handleDirectPrompt(prompt) {
         if (!this.jsonOutput) {
             console.log(chalk_1.default.cyan('Running single prompt in direct mode.'));
@@ -590,8 +626,16 @@ class ChatCommand {
             await this.runWorkflowTargetPrompt(prompt);
             return;
         }
+        // Smart routing: for agent mode, determine if prompt needs tool access
         if (this.agentMode) {
-            await this.runAgentTurn(prompt);
+            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) {
@@ -800,30 +844,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();
@@ -1611,7 +1661,7 @@ class ChatCommand {
         if (this.isServerBindableWorkspace(this.currentProjectPath)) {
             return false;
         }
-        return /(analyse|analyze|audit|overview|inspect|explain|review|debug|diagnos|read|summari[sz]e|investigate)/i.test(prompt);
+        return /(analyse|analyze|audit|overview|inspect|explain|review|debug|diagnos|read|summari[sz]e|investigate|list|show|find|search|check|scan|count|what|describe)/i.test(prompt);
     }
     shouldRequireV3AgentWorkflow(prompt) {
         if (!this.directPromptMode) {

package/dist/commands/edit.d.ts

@@ -21,6 +21,11 @@ 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 (original + modified).
+     */
+    private deduplicateCode;
     private showDiffAndConfirm;
     private showFullDiff;
     private applyFix;

package/dist/commands/edit.js

@@ -174,10 +174,37 @@ 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 (original + modified).
+     */
+    deduplicateCode(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 +267,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/commands/generate.d.ts

@@ -28,5 +28,10 @@ export declare class GenerateCommand {
     private saveToFile;
     private promptForAction;
     private suggestFilename;
+    /**
+     * Auto-detect the target language from the user's description.
+     * Falls back to 'javascript' if no language is recognized.
+     */
+    private detectLanguageFromDescription;
 }
 export {};

package/dist/commands/generate.js

@@ -33,6 +33,10 @@ class GenerateCommand {
         }
         // Determine mode
         const proMode = options.pro === true;
+        // Auto-detect language from description if not explicitly specified
+        if (!options.language) {
+            options.language = this.detectLanguageFromDescription(description);
+        }
         this.logger.section(proMode ? '🚀 Senior Developer Mode' : 'Code Generation');
         console.log(chalk_1.default.gray(`Language: ${options.language}`));
         console.log(chalk_1.default.gray(`Description: ${description}`));
@@ -214,5 +218,40 @@ class GenerateCommand {
         };
         return extensions[language] || 'generated.txt';
     }
+    /**
+     * Auto-detect the target language from the user's description.
+     * Falls back to 'javascript' if no language is recognized.
+     */
+    detectLanguageFromDescription(description) {
+        const lower = description.toLowerCase();
+        const patterns = [
+            [/\b(typescript|\.ts\b)/i, 'typescript'],
+            [/\b(javascript|\.js\b|node\.?js|es6|ecmascript)\b/i, 'javascript'],
+            [/\b(python|\.py\b|django|flask|fastapi)\b/i, 'python'],
+            [/\b(rust|\.rs\b|cargo)\b/i, 'rust'],
+            [/\b(go|golang|\.go\b)\b/i, 'go'],
+            [/\b(java\b|\.java\b|spring\b)/i, 'java'],
+            [/\b(c#|csharp|\.cs\b|dotnet|\.net)\b/i, 'csharp'],
+            [/\b(c\+\+|cpp|\.cpp\b|\.hpp\b)\b/i, 'cpp'],
+            [/\b(ruby|\.rb\b|rails)\b/i, 'ruby'],
+            [/\b(php|\.php\b|laravel)\b/i, 'php'],
+            [/\b(swift|\.swift\b|swiftui)\b/i, 'swift'],
+            [/\b(kotlin|\.kt\b)\b/i, 'kotlin'],
+            [/\b(html|\.html\b|webpage|web page|website|landing page)\b/i, 'html'],
+            [/\b(css|\.css\b|stylesheet)\b/i, 'css'],
+            [/\b(sql|\.sql\b|database query|select\s+\*)\b/i, 'sql'],
+            [/\b(bash|shell|\.sh\b|script)\b/i, 'bash'],
+        ];
+        for (const [regex, lang] of patterns) {
+            if (regex.test(lower)) {
+                return lang;
+            }
+        }
+        // If the description mentions "function" without any language hint, default to javascript
+        if (/\bfunction\b/i.test(lower)) {
+            return 'javascript';
+        }
+        return 'javascript';
+    }
 }
 exports.GenerateCommand = GenerateCommand;

package/dist/index.js

@@ -98,7 +98,7 @@ function getVersion() {
     catch (e) {
         // Fallback to hardcoded version
     }
-    return '1.6.24';
+    return '1.6.26';
 }
 const VERSION = getVersion();
 /**
@@ -334,7 +334,7 @@ async function main() {
         .command('generate <description>')
         .alias('g')
         .description('Generate code from description')
-        .option('-l, --language <lang>', 'Target language (html, typescript, python, etc.)', 'html')
+        .option('-l, --language <lang>', 'Target language (auto-detected from description, or specify: javascript, typescript, python, html, etc.)')
         .option('-o, --output <file>', 'Output file path')
         .option('-m, --model <model>', 'Select AI model', 'code')
         .option('-p, --pro', 'Senior Developer Mode: plan, generate, quality check (recommended)', false)

package/dist/utils/api.d.ts

@@ -320,6 +320,30 @@ export declare class APIClient {
     chatStream(messages: ChatMessage[], model: string): AsyncGenerator<StreamChunk>;
     chatWithCallback(messages: ChatMessage[], model: string, onChunk: (chunk: string) => void, onDone: () => void, onError: (error: Error) => void): Promise<void>;
     generateCode(prompt: string, language: string, model: string): Promise<string>;
+    /**
+     * Ensure code has balanced curly braces by appending missing closing braces.
+     */
+    private ensureBalancedBraces;
+    /**
+     * Extract the first complete function/class from code.
+     * Used as last-resort when the model keeps over-producing.
+     */
+    private extractFirstFunction;
+    /**
+     * Detect if code is excessively over-engineered for a short prompt.
+     * E.g. a "multiply function" request producing 20+ lines.
+     */
+    private codeIsOverEngineered;
+    /**
+     * Detect if generated code contains DOM/HTML pollution inappropriate
+     * for a pure programming language like JavaScript, Python, etc.
+     */
+    private codeContainsDomPollution;
+    /**
+     * Strip DOM pollution from generated code, keeping only the pure logic.
+     * Used as last-resort fallback when the model repeatedly ignores constraints.
+     */
+    private stripDomPollution;
     generateProject(prompt: string, projectType: string, model: string): Promise<{
         code: string;
         plan?: any;
@@ -360,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

@@ -3242,31 +3242,172 @@ document.addEventListener('DOMContentLoaded', () => {
     }
     // Code operations - Using Vigthoria Centralized API
     async generateCode(prompt, language, model) {
+        const isNonHtmlLang = !['html', 'css'].includes(language.toLowerCase());
+        const wordCount = prompt.trim().split(/\s+/).length;
         // Prepend a forceful scope-enforcement instruction so the model
         // doesn't expand a small task into an oversized glossy page.
-        const scopedPrompt = [
-            'IMPORTANT — MANDATORY SCOPE CONSTRAINTS (violation = failure):',
-            '1. Output ONLY what the user explicitly asked for. Nothing more.',
-            '2. If the prompt is ≤ 15 words, produce ≤ 80 lines of code maximum.',
-            '3. If the user says "tiny", "small", "simple", "minimal", or "basic", produce ≤ 50 lines.',
-            '4. NEVER add any of these unless the user EXPLICITLY requests them:',
-            '   - Hero sections, CTAs, testimonials, pricing tables, footers, navbars',
-            '   - CSS animations, gradients, neon effects, glass-morphism, particles',
-            '   - Google Fonts, Font Awesome, external CDN links, icon libraries',
-            '   - Responsive breakpoints, media queries (unless asked)',
-            '   - Multiple pages or components when one was requested',
-            '5. Prefer inline styles or a small <style> block. No CSS frameworks.',
-            '6. Return raw code only — no markdown fences, no explanations, no comments about what could be added.',
-            '7. Match the complexity of the request: a "hello world" is 1-5 lines, a "button" is 5-15 lines.',
-            '',
-            prompt,
-        ].join('\n');
-        const response = await this.client.post('/api/ai/generate', {
-            prompt: scopedPrompt,
+        const buildScopedPrompt = (retry) => {
+            if (retry && isNonHtmlLang) {
+                // Ultra-minimal retry prompt — no long instruction block
+                return `OUTPUT ONLY RAW ${language.toUpperCase()} CODE. MAXIMUM 10 LINES. NO DOM. NO HTML. NO CSS. NO ANIMATION. NO VALIDATION. NO COMMENTS.\n\n${prompt}`;
+            }
+            const lines = [
+                'IMPORTANT — MANDATORY SCOPE CONSTRAINTS (violation = failure):',
+                `1. You MUST output ONLY ${language.toUpperCase()} code. Do NOT output HTML, CSS, or DOM manipulation unless the language is html/css.`,
+                `2. The target language is: ${language}. Do not switch to a different language.`,
+                '3. Output ONLY what the user explicitly asked for. Nothing more.',
+                '4. If the prompt is ≤ 15 words, produce ≤ 80 lines of code maximum.',
+                '5. If the user says "tiny", "small", "simple", "minimal", or "basic", produce ≤ 50 lines.',
+                '6. NEVER add any of these unless the user EXPLICITLY requests them:',
+                '   - Hero sections, CTAs, testimonials, pricing tables, footers, navbars',
+                '   - CSS animations, gradients, neon effects, glass-morphism, particles',
+                '   - Google Fonts, Font Awesome, external CDN links, icon libraries',
+                '   - DOM manipulation, document.createElement, innerHTML',
+                '   - Responsive breakpoints, media queries (unless asked)',
+                '   - Multiple pages or components when one was requested',
+                '   - Input validation, error handling beyond what was requested',
+                '7. Prefer inline styles or a small <style> block ONLY if the language is html. No CSS frameworks.',
+                '8. Return raw code only — no markdown fences, no explanations, no comments about what could be added.',
+                '9. Match the complexity of the request: a "hello world" is 1-5 lines, a "multiply function" is 3-5 lines, a "button" is 5-15 lines.',
+            ];
+            if (isNonHtmlLang) {
+                lines.push(`10. This is a PURE ${language.toUpperCase()} task. ABSOLUTELY NO document.*, window.*, DOM, createElement, innerHTML, querySelector, addEventListener. Output a plain ${language} function/module ONLY.`);
+            }
+            lines.push('', prompt);
+            return lines.join('\n');
+        };
+        // First attempt
+        let response = await this.client.post('/api/ai/generate', {
+            prompt: buildScopedPrompt(false),
             language,
             model: this.resolvePermittedModelId(model),
         });
-        return response.data.code;
+        let code = response.data.code || '';
+        // Client-side validation: reject DOM-polluted or over-engineered responses for non-HTML languages
+        const needsRetry = isNonHtmlLang && (this.codeContainsDomPollution(code) ||
+            this.codeIsOverEngineered(code, prompt));
+        if (needsRetry) {
+            // Retry once with stronger constraint
+            response = await this.client.post('/api/ai/generate', {
+                prompt: buildScopedPrompt(true),
+                language,
+                model: this.resolvePermittedModelId(model),
+            });
+            code = response.data.code || '';
+            // If still polluted, strip DOM code client-side
+            if (this.codeContainsDomPollution(code)) {
+                code = this.stripDomPollution(code, language);
+            }
+        }
+        // Final cleanup: for non-HTML, if still over-engineered after retry,
+        // extract only the first complete function/class definition.
+        if (isNonHtmlLang && this.codeIsOverEngineered(code, prompt)) {
+            code = this.extractFirstFunction(code);
+        }
+        // Ensure balanced braces — model sometimes truncates closing braces
+        code = this.ensureBalancedBraces(code);
+        return code;
+    }
+    /**
+     * Ensure code has balanced curly braces by appending missing closing braces.
+     */
+    ensureBalancedBraces(code) {
+        let depth = 0;
+        for (const ch of code) {
+            if (ch === '{')
+                depth++;
+            else if (ch === '}')
+                depth--;
+        }
+        if (depth > 0) {
+            let result = code.trimEnd();
+            for (let i = 0; i < depth; i++) {
+                result += '\n}';
+            }
+            code = result;
+        }
+        return code;
+    }
+    /**
+     * Extract the first complete function/class from code.
+     * Used as last-resort when the model keeps over-producing.
+     */
+    extractFirstFunction(code) {
+        const lines = code.split('\n');
+        const funcStart = lines.findIndex(l => /^(export\s+)?(const\s+\w+\s*=\s*(\(|function)|function\s+\w+|class\s+\w+|def\s+\w+|fn\s+\w+|func\s+\w+)/.test(l.trim()));
+        if (funcStart === -1)
+            return code;
+        let braceDepth = 0;
+        let foundOpen = false;
+        const result = [];
+        for (let i = funcStart; i < lines.length; i++) {
+            const line = lines[i];
+            result.push(line);
+            braceDepth += (line.match(/{/g) || []).length;
+            braceDepth -= (line.match(/}/g) || []).length;
+            if (braceDepth > 0)
+                foundOpen = true;
+            if (foundOpen && braceDepth <= 0) {
+                break;
+            }
+        }
+        // If we reached the end without balancing braces, add closing
+        if (braceDepth > 0) {
+            result.push('};');
+        }
+        return result.join('\n');
+    }
+    /**
+     * Detect if code is excessively over-engineered for a short prompt.
+     * E.g. a "multiply function" request producing 20+ lines.
+     */
+    codeIsOverEngineered(code, prompt) {
+        const wordCount = prompt.trim().split(/\s+/).length;
+        const lineCount = code.trim().split('\n').length;
+        // Short prompt (≤15 words) should not produce more than 15 lines
+        if (wordCount <= 15 && lineCount > 15)
+            return true;
+        return false;
+    }
+    /**
+     * Detect if generated code contains DOM/HTML pollution inappropriate
+     * 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)/;
+        return domPatterns.test(code);
+    }
+    /**
+     * Strip DOM pollution from generated code, keeping only the pure logic.
+     * Used as last-resort fallback when the model repeatedly ignores constraints.
+     */
+    stripDomPollution(code, language) {
+        const lines = code.split('\n');
+        const cleanLines = [];
+        let insideDomBlock = false;
+        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) {
+                insideDomBlock = true;
+                braceDepth = 0;
+            }
+            if (insideDomBlock) {
+                braceDepth += (line.match(/{/g) || []).length;
+                braceDepth -= (line.match(/}/g) || []).length;
+                if (braceDepth <= 0) {
+                    insideDomBlock = false;
+                }
+                continue; // Skip DOM lines
+            }
+            cleanLines.push(line);
+        }
+        const cleaned = cleanLines.join('\n').trim();
+        // If we stripped too aggressively (less than 2 lines left), return a minimal stub
+        if (cleaned.split('\n').length < 2) {
+            return `// Auto-generated: model returned DOM code for a ${language} task.\n// Please regenerate or provide more specific instructions.`;
+        }
+        return cleaned;
     }
     // Senior Developer Mode - Planning + Generation + Quality Check
     async generateProject(prompt, projectType, model) {
@@ -3389,6 +3530,36 @@ document.addEventListener('DOMContentLoaded', () => {
                     }
                 }
             }
+            // Accumulator/reducer bug: subtraction used in a reduce/total/sum context
+            // e.g. "sum - item.price" in a function named calculateTotal, getTotal, etc.
+            if (/\w+\s*-\s*\w+\.\s*(price|cost|amount|value|total|quantity|count)\b/.test(line) || /\w+\.\s*(price|cost|amount|value|total)\s*-\s*/.test(line)) {
+                // Check enclosing function/method name for total/sum/aggregate semantics
+                for (let j = i; j >= Math.max(0, i - 10); j--) {
+                    if (/(function\s+)?(calculate|calc|get|compute|sum|total|aggregate|accumulate)\s*(Total|Sum|Cost|Price|Amount|All)?\s*[=(]/i.test(lines[j]) || /\.(reduce|forEach|map)\s*\(/.test(lines[j])) {
+                        // Also check if this looks like an accumulator pattern (sum - something instead of sum + something)
+                        if (/\w+\s*-\s*\w+\.\s*(price|cost|amount|value|total|quantity)\b/.test(line)) {
+                            issues.push({ type: 'logic', line: lineNum, message: 'Subtraction used in an accumulation context (total/sum/reduce) — likely should be addition (+).', severity: 'error' });
+                        }
+                        break;
+                    }
+                }
+            }
+            // Mismatched function name vs operator: sum/total function using wrong operator
+            if (/\breturn\b/.test(line)) {
+                for (let j = i; j >= Math.max(0, i - 8); j--) {
+                    const funcMatch = lines[j].match(/function\s+(\w+)/i) || lines[j].match(/(?:const|let|var)\s+(\w+)\s*=/i);
+                    if (funcMatch) {
+                        const funcName = funcMatch[1].toLowerCase();
+                        if ((funcName.includes('total') || funcName.includes('sum') || funcName.includes('add')) && /\s-\s/.test(line) && !/\s\+\s/.test(line)) {
+                            const alreadyReported = issues.some(iss => iss.line === lineNum && iss.type === 'logic');
+                            if (!alreadyReported) {
+                                issues.push({ type: 'logic', line: lineNum, message: `Subtraction operator in "${funcMatch[1]}" — function name implies addition. Likely should use + instead of -.`, severity: 'error' });
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
             // Off-by-one: comparing with === where <= or >= may be needed
             // (not implemented yet — would require more complex AST analysis)
             // Limit to 15 heuristic issues
@@ -3400,9 +3571,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);
-        const augmentedCode = syntaxHints
-            ? `// SYNTAX ERRORS DETECTED BY CLIENT:\n// ${syntaxHints}\n\n${code}`
+        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 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// 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,
@@ -3412,26 +3602,107 @@ document.addEventListener('DOMContentLoaded', () => {
         const raw = response.data ?? {};
         let fixed = typeof raw.fixed === 'string' ? raw.fixed : (typeof raw.code === 'string' ? raw.code : code);
         let changes = Array.isArray(raw.changes) ? raw.changes : [];
-        // If server returned no changes but we found syntax errors, strip
+        // If server returned no changes but we found issues, strip
         // our injected comment prefix from the returned code and attempt
         // a basic client-side repair.
-        if (changes.length === 0 && syntaxHints && fixed === augmentedCode) {
+        if (changes.length === 0 && allHints && fixed === augmentedCode) {
             fixed = code; // restore original
         }
         // Strip the injected comment block if it leaked into the output
-        if (fixed.startsWith('// SYNTAX ERRORS DETECTED BY CLIENT:')) {
+        if (fixed.startsWith('// BUGS DETECTED BY STATIC ANALYSIS') || fixed.startsWith('// SYNTAX ERRORS DETECTED BY CLIENT:')) {
             const idx = fixed.indexOf('\n\n');
             if (idx !== -1) {
                 fixed = fixed.slice(idx + 2);
             }
         }
-        // If there are still no changes but the fixed code differs, build a
-        // synthetic change entry so the user sees something actionable.
+        // If there are still no changes but the fixed code differs, compute
+        // 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) {
-            changes = [{ line: 1, before: '(original code)', after: '(fixed code)', reason: syntaxHints || 'AI-suggested fix' }];
+            changes = this.computeSemanticDiff(code, fixed, allHints);
         }
         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: 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',
+                });
+            }
+            else if (op.type === 'add') {
+                changes.push({
+                    line: op.fixedLine,
+                    before: '(new line)',
+                    after: op.text,
+                    reason: reason || 'AI-suggested fix',
+                });
+            }
+            idx++;
+        }
+        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.
      * Returns a human-readable description of obvious errors, or empty string.

package/package.json

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