vigthoria-cli 1.6.32 → 1.6.34

package/dist/commands/chat.d.ts

@@ -53,6 +53,12 @@ export declare class ChatCommand {
      */
     private isAnalysisLookupPrompt;
     private isBrowserTaskPrompt;
+    /**
+     * Returns true when a prompt can be answered directly without the full
+     * BMAD operator workflow.  Matches analysis/lookup questions.
+     * Infrastructure action verbs are already filtered at the routing level.
+     */
+    private isOperatorDirectAnswerable;
     private inferAgentTaskType;
     private buildTaskShapingInstructions;
     private buildExecutionPrompt;

package/dist/commands/chat.js

@@ -206,6 +206,14 @@ class ChatCommand {
     isBrowserTaskPrompt(prompt) {
         return /(browser|chrome|devtools|console|dom|network tab|network request|frontend runtime|client-side|client side|rendering|page load|websocket|ui bug|inspect element)/i.test(prompt);
     }
+    /**
+     * Returns true when a prompt can be answered directly without the full
+     * BMAD operator workflow.  Matches analysis/lookup questions.
+     * Infrastructure action verbs are already filtered at the routing level.
+     */
+    isOperatorDirectAnswerable(prompt) {
+        return this.isAnalysisLookupPrompt(prompt.trim());
+    }
     inferAgentTaskType(prompt) {
         if (this.isDiagnosticPrompt(prompt))
             return 'debugging';
@@ -665,6 +673,13 @@ class ChatCommand {
                 this.logger.error(this.operatorAccessMessage());
                 return;
             }
+            // Smart routing: infrastructure action verbs always need the BMAD
+            // workflow.  Everything else can be answered with a direct chat.
+            const isInfraAction = /(deploy|provision|scale|replicas|rollback|roll back|migrate|tear.?down|restart|stop\s+\w+|start\s+\w+|configure|set.?up|upgrade|pipeline)/i.test(prompt.trim());
+            if (!isInfraAction && (this.isSimpleDirectPrompt(prompt) || this.isOperatorDirectAnswerable(prompt))) {
+                await this.runSimplePrompt(prompt);
+                return;
+            }
             await this.runOperatorTurn(prompt);
             return;
         }

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,12 +313,12 @@ 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
-                deduped.push(lines[i]);
+            else if (runLen === 2 && isAtEffectiveEnd && lines[i].trimEnd() === lines[i + 1].trimEnd()) {
+                // Exactly 2 identical lines (same leading indent) at end
+                deduped.push(lines[i].trimEnd());
             }
             else {
                 // 1 line, or a pair in the middle — keep all

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.
@@ -3589,9 +3644,10 @@ document.addEventListener('DOMContentLoaded', () => {
             '- 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 at most 2 issues unless there are genuinely more distinct bugs.',
+            '- 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/robustness issues if there are no real bugs to report.',
+            '- 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 = {};
@@ -3608,8 +3664,13 @@ document.addEventListener('DOMContentLoaded', () => {
         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.
@@ -3783,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.',
@@ -3825,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.32",
+  "version": "1.6.34",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "main": "dist/index.js",
   "files": [