vigthoria-cli 1.6.31 → 1.6.33

package/dist/commands/edit.d.ts

@@ -27,6 +27,10 @@ export declare class EditCommand {
      * Applies iteratively until no further duplicates are found.
      */
     private deduplicateCode;
+    /**
+     * Append missing closing delimiters if dedup left brackets unbalanced.
+     */
+    private repairBrackets;
     private deduplicateOnce;
     private showDiffAndConfirm;
     private showFullDiff;

package/dist/commands/edit.js

@@ -231,8 +231,55 @@ Return the complete modified file content:`,
                 break;
             result = deduped;
         }
+        // Safety net: if dedup accidentally removed structural delimiters,
+        // re-balance braces/parens/brackets by appending missing closers.
+        if (result !== code) {
+            result = this.repairBrackets(result);
+        }
         return result;
     }
+    /**
+     * Append missing closing delimiters if dedup left brackets unbalanced.
+     */
+    repairBrackets(code) {
+        const stack = [];
+        const closer = { '{': '}', '(': ')', '[': ']' };
+        const openers = new Set(Object.keys(closer));
+        const closers = new Set(Object.values(closer));
+        let inString = null;
+        let escaped = false;
+        for (const ch of code) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (inString) {
+                if (ch === inString)
+                    inString = null;
+                continue;
+            }
+            if (ch === '"' || ch === "'" || ch === '`') {
+                inString = ch;
+                continue;
+            }
+            if (openers.has(ch))
+                stack.push(ch);
+            else if (closers.has(ch)) {
+                if (stack.length > 0 && closer[stack[stack.length - 1]] === ch) {
+                    stack.pop();
+                }
+            }
+        }
+        if (stack.length === 0)
+            return code;
+        // Append missing closers in reverse order (innermost first)
+        const suffix = stack.reverse().map(o => closer[o]).join('\n');
+        return code + '\n' + suffix;
+    }
     deduplicateOnce(code) {
         const lines = code.split('\n');
         const len = lines.length;
@@ -252,7 +299,10 @@ Return the complete modified file content:`,
                 i++;
                 continue;
             }
-            // Count the run length of identical consecutive lines
+            // Count the run length of identical consecutive lines.
+            // For runs of 3+, trimmed comparison is fine (clear stutter).
+            // For trailing pairs, require EXACT match (including indentation)
+            // so that e.g. "  }" and "}" (different blocks) are not collapsed.
             let runEnd = i + 1;
             while (runEnd < lines.length && lines[runEnd].trim() === trimmed) {
                 runEnd++;
@@ -263,11 +313,11 @@ Return the complete modified file content:`,
             const isAtEffectiveEnd = runEnd === lines.length
                 || lines.slice(runEnd).every(l => l.trim() === '');
             if (runLen >= 3) {
-                // 3+ identical lines is almost certainly stutter — keep one
+                // 3+ identical (trimmed) lines is almost certainly stutter — keep one
                 deduped.push(lines[i]);
             }
-            else if (runLen === 2 && isAtEffectiveEnd) {
-                // Exactly 2 identical lines at the very end — trailing stutter
+            else if (runLen === 2 && isAtEffectiveEnd && lines[i] === lines[i + 1]) {
+                // Exactly 2 identical lines (EXACT, including indentation) at end
                 deduped.push(lines[i]);
             }
             else {

package/dist/commands/generate.js

@@ -105,9 +105,10 @@ class GenerateCommand {
             if (options.output) {
                 await this.saveToFile(options.output, code);
             }
-            else {
+            else if (process.stdout.isTTY) {
                 await this.promptForAction(code, options.language);
             }
+            // Non-TTY: code was already printed above — skip interactive menu
         }
         catch (error) {
             spinner.stop();

package/dist/utils/api.d.ts

@@ -351,6 +351,11 @@ export declare class APIClient {
      * Ensure code has balanced curly braces by appending missing closing braces.
      */
     private ensureBalancedBraces;
+    /**
+     * Quick JS/TS syntax validation using Node's built-in parser.
+     * Returns true if the code parses without errors.
+     */
+    private validateJsSyntax;
     /**
      * Extract the first complete function/class from code.
      * Used as last-resort when the model keeps over-producing.

package/dist/utils/api.js

@@ -3454,21 +3454,76 @@ document.addEventListener('DOMContentLoaded', () => {
      * Ensure code has balanced curly braces by appending missing closing braces.
      */
     ensureBalancedBraces(code) {
-        let depth = 0;
-        for (const ch of 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 === '{')
-                depth++;
+                braces++;
             else if (ch === '}')
-                depth--;
+                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;
         }
-        if (depth > 0) {
-            let result = code.trimEnd();
-            for (let i = 0; i < depth; i++) {
-                result += '\n}';
-            }
-            code = result;
+        catch {
+            return false;
         }
-        return code;
     }
     /**
      * Extract the first complete function/class from code.
@@ -3588,9 +3643,11 @@ document.addEventListener('DOMContentLoaded', () => {
             'Rules:',
             '- Return concrete, line-specific issues with severity.',
             '- Every issue MUST reference a line number.',
-            '- If the score is below 50, list at least 2 specific issues.',
+            '- 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.',
-            '- Only report style issues AFTER listing all real bugs.',
+            '- 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 = {};
@@ -3605,25 +3662,40 @@ document.addEventListener('DOMContentLoaded', () => {
         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 : [];
-        // Always run client-side heuristics and merge any findings the
-        // server missed.  This ensures arithmetic/logic bugs are surfaced
-        // even when the server only reports style issues like console.log.
+        // 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) {
-            // 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);
-                }
+            // 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;
-            }
-            // 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) {
+            // 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);
             }
         }
@@ -3772,9 +3844,11 @@ document.addEventListener('DOMContentLoaded', () => {
         const sysPrompt = [
             `You are a ${language} code fixer. Fix the code for: ${fixType}.`,
             'Return a JSON object with:',
-            '  "fixed": the corrected code as a string,',
+            '  "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.',
@@ -3814,6 +3888,26 @@ document.addEventListener('DOMContentLoaded', () => {
         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.

package/package.json

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