vigthoria-cli 1.13.20 → 1.13.23

package/dist/utils/code-operations-service.js

@@ -0,0 +1,837 @@
+export class CodeOperationsService {
+    complete;
+    constructor(complete) {
+        this.complete = complete;
+    }
+    chatComplete(systemPrompt, userPrompt, model, maxTokens) {
+        return this.complete(systemPrompt, userPrompt, model, maxTokens);
+    }
+    // Code operations - Using Vigthoria Centralized API (via Model Router)
+    async generateCode(prompt, language, model) {
+        const isNonHtmlLang = !['html', 'css'].includes(language.toLowerCase());
+        // Prepend a forceful scope-enforcement instruction so the model
+        // doesn't expand a small task into an oversized glossy page.
+        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 — route through Model Router chat completions
+        const systemPrompt = `You are a code generator. Output ONLY raw ${language} code. No markdown fences, no explanations, no commentary. Just the code.`;
+        let code = await this.chatComplete(systemPrompt, buildScopedPrompt(false), model);
+        // Strip markdown fences if model included them
+        code = code.replace(/^```[\w]*\n?/gm, '').replace(/\n?```$/gm, '').trim();
+        // 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 — via Model Router
+            code = await this.chatComplete(systemPrompt, buildScopedPrompt(true), model);
+            code = code.replace(/^```[\w]*\n?/gm, '').replace(/\n?```$/gm, '').trim();
+            // 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) {
+        // Count braces/parens/brackets outside strings and comments
+        let braces = 0, parens = 0, brackets = 0;
+        let inStr = null;
+        let inLine = false, inBlock = false;
+        for (let i = 0; i < code.length; i++) {
+            const ch = code[i], nx = code[i + 1] || '';
+            if (inLine) {
+                if (ch === '\n')
+                    inLine = false;
+                continue;
+            }
+            if (inBlock) {
+                if (ch === '*' && nx === '/') {
+                    inBlock = false;
+                    i++;
+                }
+                continue;
+            }
+            if (inStr) {
+                if (ch === inStr && code[i - 1] !== '\\')
+                    inStr = null;
+                continue;
+            }
+            if (ch === '/' && nx === '/') {
+                inLine = true;
+                continue;
+            }
+            if (ch === '/' && nx === '*') {
+                inBlock = true;
+                continue;
+            }
+            if (ch === '"' || ch === "'" || ch === '`') {
+                inStr = ch;
+                continue;
+            }
+            if (ch === '{')
+                braces++;
+            else if (ch === '}')
+                braces--;
+            else if (ch === '(')
+                parens++;
+            else if (ch === ')')
+                parens--;
+            else if (ch === '[')
+                brackets++;
+            else if (ch === ']')
+                brackets--;
+        }
+        let result = code.trimEnd();
+        for (let i = 0; i < braces; i++)
+            result += '\n}';
+        for (let i = 0; i < parens; i++)
+            result += ')';
+        for (let i = 0; i < brackets; i++)
+            result += ']';
+        return braces > 0 || parens > 0 || brackets > 0 ? result : code;
+    }
+    /**
+     * Quick JS/TS syntax validation using Node's built-in parser.
+     * Returns true if the code parses without errors.
+     */
+    validateJsSyntax(code) {
+        try {
+            // Use Function constructor to check syntax without executing
+            new Function(code);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 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)|CSSAnimation|new\s+Animation\b|\.getAnimations\s*\(|\.animate\s*\(/;
+        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|CSSAnimation|\.getAnimations|\.animate\s*\(/.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) {
+        const sysPrompt = [
+            `You are a senior developer. Generate a complete ${projectType} project.`,
+            'Return a JSON object with these fields:',
+            '  "code": the full source code as a string,',
+            '  "plan": an object describing the architecture,',
+            '  "quality": { "lineCount": number, "score": number (0-100) }',
+            'Return ONLY the JSON object, no markdown fences.',
+        ].join('\n');
+        const raw = await this.chatComplete(sysPrompt, prompt, model, 8192);
+        try {
+            const cleaned = raw.replace(/^```[\w]*\n?/gm, '').replace(/\n?```$/gm, '').trim();
+            const parsed = JSON.parse(cleaned);
+            return {
+                code: parsed.code || raw,
+                plan: parsed.plan,
+                quality: parsed.quality,
+            };
+        }
+        catch {
+            return { code: raw.replace(/^```[\w]*\n?/gm, '').replace(/\n?```$/gm, '').trim() };
+        }
+    }
+    async explainCode(code, language) {
+        const sysPrompt = [
+            `You are a code explainer. Explain the following ${language} code clearly and concisely.`,
+            'Focus on what it does, how it works, and any notable patterns or potential issues.',
+            'Format your response as clean Markdown:',
+            '- Use ## headers for major sections (e.g. ## Overview, ## How It Works, ## Key Details).',
+            '- Use bullet points (- or *) for all lists. Do NOT use numbered lists.',
+            '- Wrap code references in backticks.',
+            '- Keep paragraphs short (2-3 sentences max).',
+            '- Do NOT use raw HTML or excessive blank lines.',
+            '- Do NOT nest numbered lists inside sections.',
+        ].join('\n');
+        return this.chatComplete(sysPrompt, code);
+    }
+    async reviewCode(code, language) {
+        const sysPrompt = [
+            `You are a senior code reviewer for ${language}. Analyze the code and return a JSON object with:`,
+            '  "score": number 0-100,',
+            '  "issues": [{ "type": string, "line": number, "message": string, "severity": "error"|"warning"|"info" }],',
+            '  "suggestions": [string]',
+            'Rules:',
+            '- Return concrete, line-specific issues with severity.',
+            '- Every issue MUST reference a line number.',
+            '- Report each distinct bug ONCE. Do NOT report the same bug multiple times with different wording.',
+            '- For trivial/short code (< 10 lines), report ONLY actual bugs. Do NOT pad with style, robustness, or best-practice suggestions.',
+            '- If you find a real bug (wrong operator, logic error, type mismatch), report ONLY that bug. Do NOT also suggest input validation, type checking, or error handling unless those are ACTUAL bugs.',
+            '- Prioritize REAL BUGS: wrong operators, logic errors, off-by-one, type mismatches.',
+            '- Do NOT suggest adding error handling, input validation, or documentation as issues unless the user explicitly asked for a style review.',
+            '- Return ONLY the JSON object, no markdown fences or extra text.',
+        ].join('\n');
+        let raw = {};
+        try {
+            const result = await this.chatComplete(sysPrompt, code);
+            const cleaned = result.replace(/^```[\w]*\n?/gm, '').replace(/\n?```$/gm, '').trim();
+            raw = JSON.parse(cleaned);
+        }
+        catch {
+            // If parsing fails, return minimal review
+        }
+        const score = typeof raw.score === 'number' ? raw.score : 0;
+        const issues = Array.isArray(raw.issues) ? raw.issues : [];
+        const suggestions = Array.isArray(raw.suggestions) ? raw.suggestions : [];
+        // Merge client-side heuristics, but with tight dedup to avoid
+        // redundant over-reporting when the model already found the bug.
+        const modelFoundError = issues.some(i => i.severity === 'error');
+        const heuristic = this.heuristicCodeIssues(code, language);
+        for (const h of heuristic) {
+            // If the model already found a real error, skip non-error heuristics
+            // entirely — they're just padding (style, robustness, etc.)
+            if (modelFoundError && h.severity !== 'error')
+                continue;
+            // Semantic duplicate check: same line + (similar type OR overlapping
+            // keywords in the message).  This catches cases where the model
+            // and heuristic describe the same bug with different wording.
+            const hWords = new Set(h.message.toLowerCase().split(/\W+/).filter(w => w.length > 3));
+            const hTypeNorm = h.type.toLowerCase().replace(/[^a-z]/g, '');
+            const isSemanticallyDuplicate = issues.some((existing) => {
+                if (existing.line !== h.line)
+                    return false;
+                // Normalize types: "logic-error", "logic_error", "logic" all match
+                const eTypeNorm = existing.type.toLowerCase().replace(/[^a-z]/g, '');
+                if (eTypeNorm === hTypeNorm || eTypeNorm.startsWith(hTypeNorm) || hTypeNorm.startsWith(eTypeNorm))
+                    return true;
+                // Both errors on same line about the same category of problem
+                if (existing.severity === 'error' && h.severity === 'error')
+                    return true;
+                // Check keyword overlap — if ≥2 significant words match, it's the same finding
+                const eWords = existing.message.toLowerCase().split(/\W+/).filter(w => w.length > 3);
+                let overlap = 0;
+                for (const w of eWords) {
+                    if (hWords.has(w))
+                        overlap++;
+                }
+                return overlap >= 2;
+            });
+            if (!isSemanticallyDuplicate) {
+                issues.push(h);
+            }
+        }
+        // Sort: errors first, then warnings, then info
+        const severityOrder = { error: 0, warning: 1, info: 2 };
+        issues.sort((a, b) => (severityOrder[a.severity] ?? 3) - (severityOrder[b.severity] ?? 3));
+        // Prevent contradictory output: low score but zero issues.
+        if (score < 50 && issues.length === 0) {
+            issues.push({
+                type: 'quality',
+                line: 1,
+                message: `The analysis returned a low quality score (${score}/100) but did not enumerate specific issues. Re-run the review or inspect the file manually.`,
+                severity: 'warning',
+            });
+        }
+        return { score, issues, suggestions };
+    }
+    /**
+     * Lightweight client-side heuristic scan: catches common code smells
+     * AND logic/arithmetic bugs so review never returns "score 30, no issues".
+     */
+    heuristicCodeIssues(code, _language) {
+        const issues = [];
+        const lines = code.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const lineNum = i + 1;
+            // console.log left in production code
+            if (/\bconsole\.(log|debug|info)\b/.test(line) && !/\/\//.test(line.slice(0, line.indexOf('console')))) {
+                issues.push({ type: 'quality', line: lineNum, message: 'console.log/debug statement — remove or replace with proper logging.', severity: 'warning' });
+            }
+            // TODO/FIXME/HACK comments
+            if (/\b(TODO|FIXME|HACK|XXX)\b/.test(line)) {
+                issues.push({ type: 'maintainability', line: lineNum, message: `Unresolved ${line.match(/\b(TODO|FIXME|HACK|XXX)\b/)?.[0]} comment.`, severity: 'info' });
+            }
+            // Empty catch blocks
+            if (/catch\s*\([^)]*\)\s*\{\s*\}/.test(line)) {
+                issues.push({ type: 'error-handling', line: lineNum, message: 'Empty catch block — errors are silently swallowed.', severity: 'warning' });
+            }
+            // Very long lines (> 200 chars)
+            if (line.length > 200) {
+                issues.push({ type: 'style', line: lineNum, message: `Line exceeds 200 characters (${line.length}).`, severity: 'info' });
+            }
+            // Arithmetic / logic bugs: function named 'add' but using subtraction
+            if (/\breturn\s+\w+\s*-\s*\w+/.test(line)) {
+                // Check if the enclosing function name implies addition
+                for (let j = i; j >= Math.max(0, i - 5); j--) {
+                    if (/function\s+add\b/i.test(lines[j]) || /\badd\s*[=(]/.test(lines[j])) {
+                        issues.push({ type: 'logic', line: lineNum, message: 'Subtraction operator in a function named "add" — likely should be addition (+).', severity: 'error' });
+                        break;
+                    }
+                }
+            }
+            // Multiplication where addition is expected
+            if (/\breturn\s+\w+\s*\*\s*\w+/.test(line)) {
+                for (let j = i; j >= Math.max(0, i - 5); j--) {
+                    if (/function\s+add\b/i.test(lines[j]) || /\badd\s*[=(]/.test(lines[j])) {
+                        issues.push({ type: 'logic', line: lineNum, message: 'Multiplication operator in a function named "add" — likely should be addition (+).', severity: 'error' });
+                        break;
+                    }
+                }
+            }
+            // Division where subtraction/addition is expected in subtract
+            if (/\breturn\s+\w+\s*\+\s*\w+/.test(line)) {
+                for (let j = i; j >= Math.max(0, i - 5); j--) {
+                    if (/function\s+subtract\b/i.test(lines[j]) || /\bsubtract\s*[=(]/.test(lines[j])) {
+                        issues.push({ type: 'logic', line: lineNum, message: 'Addition operator in a function named "subtract" — likely should be subtraction (-).', severity: 'error' });
+                        break;
+                    }
+                }
+            }
+            // 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
+            if (issues.length >= 15)
+                break;
+        }
+        return issues;
+    }
+    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 = 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.type !== 'logic' && 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// ');
+        // Build a constraint preamble that's stricter for syntax-only mode.
+        let preamble;
+        if (fixType === 'syntax') {
+            preamble = allHints
+                ? `// SYNTAX ERRORS DETECTED BY CLIENT:\n// ${allHints}\n// RULES: Fix ONLY bracket/parenthesis/brace mismatches and keyword typos. Do NOT rename functions, do NOT add comments, do NOT restructure or reformat. Output the corrected code ONLY.\n\n`
+                : '';
+        }
+        else {
+            preamble = 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`
+                : '';
+        }
+        const augmentedCode = preamble ? `${preamble}${code}` : code;
+        const sysPrompt = [
+            `You are a ${language} code fixer. Fix the code for: ${fixType}.`,
+            'Return a JSON object with:',
+            '  "fixed": the COMPLETE corrected source code as a string (not a snippet — the full file),',
+            '  "changes": [{ "line": number, "before": string, "after": string, "reason": string }]',
+            'Rules:',
+            '- The "fixed" field MUST contain the entire corrected source code with ALL lines, including unchanged lines.',
+            '- The "fixed" code MUST have balanced braces, parentheses, and brackets.',
+            '- Fix ONLY the issues related to the fix type.',
+            '- Do not add comments, do not restructure beyond the minimal fix.',
+            '- Return ONLY the JSON object, no markdown fences.',
+        ].join('\n');
+        let raw = {};
+        try {
+            const result = await this.chatComplete(sysPrompt, augmentedCode);
+            const cleaned = result.replace(/^```[\w]*\n?/gm, '').replace(/\n?```$/gm, '').trim();
+            raw = JSON.parse(cleaned);
+        }
+        catch {
+            // If parsing fails, fall through to client-side handling
+        }
+        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 issues, strip
+        // our injected comment prefix from the returned code and attempt
+        // a basic client-side repair.
+        if (changes.length === 0 && preamble && fixed === augmentedCode) {
+            fixed = code; // restore original
+        }
+        // Strip the injected comment block if it leaked into the output
+        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);
+            }
+        }
+        // For syntax-only fixes, strip any comments the model added that
+        // weren't in the original code (e.g. "// Fixed mismatched parentheses").
+        if (fixType === 'syntax' && fixed !== code) {
+            fixed = this.stripInjectedComments(code, fixed, language);
+        }
+        // Safety net: for syntax fixes, ensure the fix didn't make bracket
+        // balance worse.  If the original had more closing delimiters than
+        // the fix, append the missing ones.
+        if (fixType === 'syntax' && fixed !== code) {
+            fixed = this.repairBracketBalance(code, fixed);
+        }
+        // Final bracket-balance guarantee — ensure the emitted code has
+        // balanced braces/parens/brackets regardless of what the model returned.
+        fixed = this.ensureBalancedBraces(fixed);
+        // For JS/TS syntax fixes, validate the output actually parses.
+        // If it doesn't, attempt a more aggressive bracket repair.
+        if ((fixType === 'syntax' || fixType === 'bugs') && fixed !== code) {
+            const lang = language.toLowerCase();
+            if (['javascript', 'js', 'typescript', 'ts'].includes(lang)) {
+                if (!this.validateJsSyntax(fixed)) {
+                    // Try once more: strip any remaining injected comments and re-balance
+                    let repaired = this.stripInjectedComments(code, fixed, language);
+                    repaired = this.ensureBalancedBraces(repaired);
+                    if (this.validateJsSyntax(repaired)) {
+                        fixed = repaired;
+                    }
+                    // If still invalid, return the best-effort fix — better than
+                    // silently reverting to the original broken code.
+                }
+            }
+        }
+        // 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) {
+            // 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: 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.
+     */
+    detectSyntaxErrors(code, language) {
+        const lang = language.toLowerCase();
+        const errors = [];
+        if (lang === 'javascript' || lang === 'typescript' || lang === 'js' || lang === 'ts') {
+            // Bracket matching
+            let braces = 0, brackets = 0, parens = 0;
+            // Track string context (simple heuristic — not a full parser)
+            let inString = null;
+            let inLineComment = false;
+            let inBlockComment = false;
+            for (let i = 0; i < code.length; i++) {
+                const ch = code[i];
+                const next = code[i + 1] || '';
+                if (inLineComment) {
+                    if (ch === '\n')
+                        inLineComment = false;
+                    continue;
+                }
+                if (inBlockComment) {
+                    if (ch === '*' && next === '/') {
+                        inBlockComment = false;
+                        i++;
+                    }
+                    continue;
+                }
+                if (inString) {
+                    if (ch === inString && code[i - 1] !== '\\')
+                        inString = null;
+                    continue;
+                }
+                if (ch === '/' && next === '/') {
+                    inLineComment = true;
+                    continue;
+                }
+                if (ch === '/' && next === '*') {
+                    inBlockComment = true;
+                    continue;
+                }
+                if (ch === '"' || ch === "'" || ch === '`') {
+                    inString = ch;
+                    continue;
+                }
+                if (ch === '{')
+                    braces++;
+                else if (ch === '}')
+                    braces--;
+                else if (ch === '[')
+                    brackets++;
+                else if (ch === ']')
+                    brackets--;
+                else if (ch === '(')
+                    parens++;
+                else if (ch === ')')
+                    parens--;
+            }
+            if (braces !== 0)
+                errors.push(`Mismatched braces (balance: ${braces > 0 ? '+' : ''}${braces})`);
+            if (brackets !== 0)
+                errors.push(`Mismatched brackets (balance: ${brackets > 0 ? '+' : ''}${brackets})`);
+            if (parens !== 0)
+                errors.push(`Mismatched parentheses (balance: ${parens > 0 ? '+' : ''}${parens})`);
+            // Detect obvious keyword typos
+            const lines = code.split('\n');
+            for (let li = 0; li < lines.length; li++) {
+                const line = lines[li];
+                if (/\bfuncion\b|\bfuction\b|\bfuntion\b/i.test(line))
+                    errors.push(`Line ${li + 1}: Misspelled 'function'`);
+                if (/\bretrun\b/i.test(line))
+                    errors.push(`Line ${li + 1}: Misspelled 'return'`);
+                if (/\bconts\b|\bcosnt\b/i.test(line))
+                    errors.push(`Line ${li + 1}: Misspelled 'const'`);
+            }
+        }
+        if (lang === 'python' || lang === 'py') {
+            const lines = code.split('\n');
+            for (let li = 0; li < lines.length; li++) {
+                const line = lines[li];
+                if (/^\s*(def|class|if|elif|else|for|while|try|except|with)\b/.test(line) && !line.trimEnd().endsWith(':') && !line.trimEnd().endsWith('\\')) {
+                    errors.push(`Line ${li + 1}: Missing colon after '${line.trim().split(/\s/)[0]}'`);
+                }
+            }
+        }
+        return errors.join('; ');
+    }
+    /**
+     * Strip comment lines that the model added during a fix but were not
+     * present in the original code.  Used for syntax-only fixes where the
+     * model tends to annotate its changes with "// Fixed ..." comments.
+     */
+    stripInjectedComments(original, fixed, language) {
+        const lang = language.toLowerCase();
+        // Only handle JS/TS/Python single-line comment patterns for now
+        let wholeLineRe;
+        let inlineRe;
+        if (lang === 'python' || lang === 'py') {
+            wholeLineRe = /^\s*#\s/;
+            inlineRe = /\s+#\s.*$/;
+        }
+        else {
+            wholeLineRe = /^\s*\/\/\s/;
+            inlineRe = /\s+\/\/\s.*$/;
+        }
+        const origLines = original.split('\n');
+        const origSet = new Set(origLines.map(l => l.trim()));
+        const fixedLines = fixed.split('\n');
+        const result = [];
+        for (let idx = 0; idx < fixedLines.length; idx++) {
+            let line = fixedLines[idx];
+            // Remove whole-line comments not in original
+            if (wholeLineRe.test(line) && !origSet.has(line.trim())) {
+                continue;
+            }
+            // Strip inline trailing comments the model added.
+            // Only strip if the corresponding original line at the same position
+            // didn't have an inline comment at all.
+            if (inlineRe.test(line)) {
+                const origLine = idx < origLines.length ? origLines[idx] : '';
+                if (!inlineRe.test(origLine)) {
+                    line = line.replace(inlineRe, '');
+                }
+            }
+            result.push(line);
+        }
+        return result.join('\n');
+    }
+    /**
+     * Ensure the fixed code hasn't lost closing delimiters relative to the
+     * original.  Counts {, }, (, ), [, ] outside strings/comments and if
+     * the fix has fewer closers than the original, appends the missing ones.
+     */
+    repairBracketBalance(original, fixed) {
+        const count = (src) => {
+            let braces = 0, parens = 0, brackets = 0;
+            let inStr = null;
+            let inLine = false, inBlock = false;
+            for (let i = 0; i < src.length; i++) {
+                const ch = src[i], nx = src[i + 1] || '';
+                if (inLine) {
+                    if (ch === '\n')
+                        inLine = false;
+                    continue;
+                }
+                if (inBlock) {
+                    if (ch === '*' && nx === '/') {
+                        inBlock = false;
+                        i++;
+                    }
+                    continue;
+                }
+                if (inStr) {
+                    if (ch === inStr && src[i - 1] !== '\\')
+                        inStr = null;
+                    continue;
+                }
+                if (ch === '/' && nx === '/') {
+                    inLine = true;
+                    continue;
+                }
+                if (ch === '/' && nx === '*') {
+                    inBlock = true;
+                    continue;
+                }
+                if (ch === '"' || ch === "'" || ch === '`') {
+                    inStr = ch;
+                    continue;
+                }
+                if (ch === '{')
+                    braces++;
+                else if (ch === '}')
+                    braces--;
+                else if (ch === '(')
+                    parens++;
+                else if (ch === ')')
+                    parens--;
+                else if (ch === '[')
+                    brackets++;
+                else if (ch === ']')
+                    brackets--;
+            }
+            return { braces, parens, brackets };
+        };
+        const orig = count(original);
+        const fix = count(fixed);
+        const append = [];
+        // If original was balanced (or close) but fix is missing closers,
+        // append them.  Only act when the fix is *more unbalanced* than original.
+        if (fix.braces > orig.braces) {
+            for (let i = 0; i < fix.braces - orig.braces; i++)
+                append.push('}');
+        }
+        if (fix.parens > orig.parens) {
+            for (let i = 0; i < fix.parens - orig.parens; i++)
+                append.push(')');
+        }
+        if (fix.brackets > orig.brackets) {
+            for (let i = 0; i < fix.brackets - orig.brackets; i++)
+                append.push(']');
+        }
+        if (append.length > 0) {
+            return fixed.trimEnd() + '\n' + append.join('\n');
+        }
+        return fixed;
+    }
+}