vigthoria-cli 1.6.18 → 1.6.20

package/dist/commands/chat.js

@@ -118,7 +118,13 @@ class ChatCommand {
         return this.getDefaultChatModel();
     }
     isLegacyAgentFallbackAllowed() {
-        return process.env.VIGTHORIA_ALLOW_LEGACY_AGENT_FALLBACK === '1';
+        // CLI always has local file access, so fallback to local agent loop
+        // is safe and should be the default when V3 agent is unreachable or
+        // rejects the request (e.g. context too large).
+        if (process.env.VIGTHORIA_ALLOW_LEGACY_AGENT_FALLBACK === '0') {
+            return false;
+        }
+        return true;
     }
     resolveAgentExecutionPolicy(prompt) {
         const explicitModel = this.modelExplicitlySelected;
@@ -193,7 +199,11 @@ class ChatCommand {
         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);
     }
     inferAgentTaskType(prompt) {
-        return this.isDiagnosticPrompt(prompt) ? 'debugging' : 'implementation';
+        if (this.isDiagnosticPrompt(prompt))
+            return 'debugging';
+        if (/^(what|which|how many|list|show|check|inspect|analyze|analyse|audit|explain|describe|summarize|summarise|review|overview|find|count|read|look at|tell me)/i.test(prompt.trim()))
+            return 'analysis';
+        return 'implementation';
     }
     buildTaskShapingInstructions(prompt) {
         const instructions = [];
@@ -657,28 +667,73 @@ class ChatCommand {
             if (spinner) {
                 spinner.fail('Operator workflow failed');
             }
-            this.logger.error(error.message);
+            const errorMsg = error.message || 'Operator workflow failed with an unknown error.';
+            if (this.jsonOutput) {
+                process.exitCode = 1;
+                console.log(JSON.stringify({
+                    success: false,
+                    mode: 'operator',
+                    content: '',
+                    error: errorMsg,
+                }, null, 2));
+            }
+            else {
+                this.logger.error(errorMsg);
+            }
         }
     }
     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.
+        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'))) {
+            this.messages.push({
+                role: 'system',
+                content: 'You are in simple chat mode with no direct file access. Do not fabricate file contents, search results, or analysis steps. If the user asks about specific files, advise them to use agent mode (vig chat --agent) for grounded repo analysis.',
+            });
+        }
         this.messages.push({ role: 'user', content: this.buildExecutionPrompt(prompt) });
         const spinner = this.jsonOutput ? null : (0, logger_js_1.createSpinner)({ text: 'Thinking...', spinner: 'clock' }).start();
         try {
             const response = await this.api.chat(this.getMessagesForModel(), this.currentModel);
             if (spinner)
                 spinner.stop();
-            const finalText = response.message.trim();
-            if (finalText) {
+            const finalText = (response.message || '').trim();
+            if (this.jsonOutput) {
+                console.log(JSON.stringify({
+                    success: true,
+                    mode: 'chat',
+                    model: this.currentModel,
+                    content: finalText || 'The model returned an empty response. Try rephrasing or use --agent for grounded file analysis.',
+                }, null, 2));
+            }
+            else if (finalText) {
                 console.log(finalText);
             }
-            this.messages.push({ role: 'assistant', content: response.message });
+            else {
+                console.log(chalk_1.default.yellow('The model returned an empty response. Try rephrasing your question, or use --agent mode for grounded repo analysis.'));
+            }
+            this.messages.push({ role: 'assistant', content: response.message || '' });
             this.saveSession();
         }
         catch (error) {
             if (spinner)
                 spinner.fail('Failed to get response');
-            this.logger.error(error.message);
+            const errorMsg = error.message;
+            if (this.jsonOutput) {
+                process.exitCode = 1;
+                console.log(JSON.stringify({
+                    success: false,
+                    mode: 'chat',
+                    model: this.currentModel,
+                    content: '',
+                    error: errorMsg,
+                }, null, 2));
+            }
+            else {
+                this.logger.error(errorMsg);
+            }
         }
     }
     async runAgentTurn(prompt) {

package/dist/commands/edit.d.ts

@@ -6,6 +6,7 @@ import { Logger } from '../utils/logger.js';
 interface EditOptions {
     instruction?: string;
     model: string;
+    apply?: boolean;
 }
 interface FixOptions {
     type: string;

package/dist/commands/edit.js

@@ -86,8 +86,13 @@ Return the complete modified code:`,
                 this.logger.error('Failed to generate valid code changes');
                 return;
             }
-            // Show diff
-            await this.showDiffAndConfirm(file.path, file.content, modifiedCode);
+            // Show diff and apply
+            if (options.apply) {
+                await this.applyFix(file.path, file.content, modifiedCode);
+            }
+            else {
+                await this.showDiffAndConfirm(file.path, file.content, modifiedCode);
+            }
         }
         catch (error) {
             spinner.stop();

package/dist/commands/workflow.js

@@ -48,10 +48,23 @@ class WorkflowCommand {
     }
     async templates(options) {
         this.ensureAuthenticated(Boolean(options.json));
-        const templates = await this.api.listVigFlowTemplates({
-            category: options.category,
-            search: options.search,
-        });
+        let templates;
+        try {
+            templates = await this.api.listVigFlowTemplates({
+                category: options.category,
+                search: options.search,
+            });
+        }
+        catch (error) {
+            const msg = `Workflow service is not reachable: ${error.message}`;
+            if (options.json) {
+                this.printJson({ success: false, error: msg, templates: [] });
+            }
+            else {
+                this.logger.error(msg);
+            }
+            return;
+        }
         if (options.json) {
             this.printJson({ success: true, templates });
             return;
@@ -70,7 +83,20 @@ class WorkflowCommand {
     }
     async list(options) {
         this.ensureAuthenticated(Boolean(options.json));
-        const workflows = await this.api.listVigFlowWorkflows();
+        let workflows;
+        try {
+            workflows = await this.api.listVigFlowWorkflows();
+        }
+        catch (error) {
+            const msg = `Workflow service is not reachable: ${error.message}`;
+            if (options.json) {
+                this.printJson({ success: false, error: msg, workflows: [] });
+            }
+            else {
+                this.logger.error(msg);
+            }
+            return;
+        }
         if (options.json) {
             this.printJson({ success: true, workflows });
             return;

package/dist/index.js

@@ -316,6 +316,7 @@ async function main() {
         .description('Edit a file with AI assistance')
         .option('-i, --instruction <text>', 'Editing instruction')
         .option('-m, --model <model>', 'Select AI model', 'code')
+        .option('--apply', 'Automatically apply changes without confirmation', false)
         .action(async (file, options) => {
         const edit = new edit_js_1.EditCommand(config, logger);
         await edit.run(file, options);

package/dist/utils/api.d.ts

@@ -195,6 +195,11 @@ export declare class APIClient {
     getVigFlowBaseUrls(): string[];
     getTemplateServiceBaseUrls(): string[];
     private isFrontendTask;
+    /**
+     * Returns true when the prompt describes a read-only / analysis task.
+     * Used to suppress preview gate and other write-oriented side effects.
+     */
+    isAnalysisOnlyTask(message?: string, context?: Record<string, any>): boolean;
     private normalizeWorkspaceRelativePath;
     private listFrontendWorkspaceFiles;
     private chooseFrontendPreviewEntry;
@@ -227,7 +232,19 @@ export declare class APIClient {
         executionOptions?: Record<string, unknown>;
     }): Promise<VigFlowExecutionResult>;
     getVigFlowExecutionStatus(executionId: string): Promise<VigFlowExecutionStatus>;
+    /** Maximum serialized context length accepted by the V3 server. */
+    private static readonly V3_CONTEXT_CHAR_LIMIT;
     buildV3AgentContext(context?: Record<string, any>): string;
+    /**
+     * Compact a V3 context payload so the serialized JSON stays under
+     * the server's character limit.  Progressively sheds bulk:
+     *   1. Trim workspaceFiles values to fit budget
+     *   2. Drop workspaceFiles entirely
+     *   3. Truncate history
+     *   4. Truncate file list
+     *   5. Drop readmeExcerpt
+     */
+    private compactV3Context;
     buildMinimalV3AgentContext(context?: Record<string, any>): string;
     private extractEmergencyAppName;
     private materializeEmergencySaaSWorkspace;
@@ -261,6 +278,11 @@ export declare class APIClient {
     private buildFallbackFrontendJs;
     private replaceMissingLocalAssetReferences;
     formatV3AgentResponse(data: any): string;
+    /**
+     * Build a human-readable answer from the tool results in a V3 event
+     * stream when the server didn't emit a proper complete/message event.
+     */
+    private synthesizeAnswerFromV3Events;
     collectV3AgentStream(response: Response, context?: Record<string, any>): Promise<any>;
     runV3AgentWorkflow(message: string, context?: Record<string, any>): Promise<V3AgentWorkflowResponse>;
     private formatOperatorResponse;
@@ -326,6 +348,11 @@ export declare class APIClient {
             reason: string;
         }[];
     }>;
+    /**
+     * Lightweight client-side syntax error detection.
+     * Returns a human-readable description of obvious errors, or empty string.
+     */
+    private detectSyntaxErrors;
     private resolveModelId;
     private getCoderHealth;
     private getModelsHealth;

package/dist/utils/api.js

@@ -306,12 +306,14 @@ class APIClient {
         return [...new Set(urls)];
     }
     getVigFlowBaseUrls() {
+        const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
         const urls = [
             process.env.VIGTHORIA_VIGFLOW_URL,
             process.env.VIGFLOW_URL,
             process.env.WORKFLOW_BUILDER_URL,
             'http://127.0.0.1:5060',
             'http://127.0.0.1:5050',
+            `${configuredApiUrl}/api/vigflow`,
         ].filter(Boolean).map((url) => String(url).replace(/\/$/, ''));
         return [...new Set(urls)];
     }
@@ -326,11 +328,29 @@ class APIClient {
         return [...new Set(urls)];
     }
     isFrontendTask(message = '', context = {}) {
+        // Never treat analysis-only tasks as frontend tasks — preview gate
+        // should not fire for read-only inspection prompts.
+        if (this.isAnalysisOnlyTask(message, context)) {
+            return false;
+        }
         const prompt = String(message || '');
         const expectedFiles = this.extractExpectedWorkspaceFiles(message, context);
         return /(premium|polished|landing|site|page|dashboard|saas|frontend|ui|pricing|showcase|hero|responsive)/i.test(prompt)
             || expectedFiles.some((filePath) => /\.(html|css|js)$/i.test(filePath));
     }
+    /**
+     * Returns true when the prompt describes a read-only / analysis task.
+     * Used to suppress preview gate and other write-oriented side effects.
+     */
+    isAnalysisOnlyTask(message = '', context = {}) {
+        const prompt = String(message || '').toLowerCase();
+        const taskType = String(context.agentTaskType || '').toLowerCase();
+        if (taskType === 'debugging' || taskType === 'analysis' || taskType === 'analysis_only')
+            return true;
+        if (context.workflowType === 'analysis_only')
+            return true;
+        return /^(what|which|how many|list|show|check|inspect|analyze|analyse|audit|explain|describe|summarize|summarise|review|overview|find|count|read|look at|tell me|diagnos)/i.test(prompt.trim());
+    }
     normalizeWorkspaceRelativePath(filePath) {
         return String(filePath || '').trim().replace(/\\/g, '/').replace(/^\.\//, '');
     }
@@ -594,7 +614,7 @@ class APIClient {
             };
         }
         // Cap artifact sizes to prevent 413 Payload Too Large
-        const PREVIEW_MAX_ARTIFACT_BYTES = 500 * 1024;
+        const PREVIEW_MAX_ARTIFACT_BYTES = 250 * 1024;
         const html = artifacts.html.slice(0, PREVIEW_MAX_ARTIFACT_BYTES);
         const css = (artifacts.css || '').slice(0, PREVIEW_MAX_ARTIFACT_BYTES);
         const js = (artifacts.js || '').slice(0, PREVIEW_MAX_ARTIFACT_BYTES);
@@ -888,6 +908,8 @@ class APIClient {
             return payload.execution;
         });
     }
+    /** Maximum serialized context length accepted by the V3 server. */
+    static V3_CONTEXT_CHAR_LIMIT = 95_000;
     buildV3AgentContext(context = {}) {
         const resolvedContext = this.ensureExecutionContext(context);
         const targetPath = resolvedContext.targetPath || resolvedContext.projectPath || resolvedContext.workspacePath || resolvedContext.projectRoot || process.cwd();
@@ -896,7 +918,7 @@ class APIClient {
         const localWorkspaceSummary = this.buildLocalWorkspaceSummary(localWorkspacePath);
         const requestedModel = String(resolvedContext.model || resolvedContext.requestedModel || 'agent');
         const resolvedModel = this.resolvePermittedModelId(requestedModel);
-        return JSON.stringify({
+        const payload = {
             workspace: resolvedContext.workspace || null,
             activeFile: resolvedContext.activeFile || null,
             history: resolvedContext.history || [],
@@ -922,7 +944,89 @@ class APIClient {
             requestStartedAt: resolvedContext.requestStartedAt,
             subscriptionPlan: this.config.getNormalizedPlan() || null,
             email: this.config.get('email') || null,
-        });
+        };
+        return this.compactV3Context(payload);
+    }
+    /**
+     * Compact a V3 context payload so the serialized JSON stays under
+     * the server's character limit.  Progressively sheds bulk:
+     *   1. Trim workspaceFiles values to fit budget
+     *   2. Drop workspaceFiles entirely
+     *   3. Truncate history
+     *   4. Truncate file list
+     *   5. Drop readmeExcerpt
+     */
+    compactV3Context(payload) {
+        const LIMIT = APIClient.V3_CONTEXT_CHAR_LIMIT;
+        let json = JSON.stringify(payload);
+        if (json.length <= LIMIT)
+            return json;
+        // Phase 1 — shrink workspaceFiles to fit
+        const summary = payload.localWorkspaceSummary;
+        if (summary?.workspaceFiles && typeof summary.workspaceFiles === 'object') {
+            const fileEntries = Object.entries(summary.workspaceFiles);
+            const overhead = json.length - JSON.stringify(summary.workspaceFiles).length;
+            const budget = LIMIT - overhead - 512; // reserve a little headroom
+            if (budget > 0) {
+                const trimmed = {};
+                let used = 2; // {}
+                for (const [k, v] of fileEntries) {
+                    const entryLen = JSON.stringify(k).length + 1 + JSON.stringify(v).length + 1;
+                    if (used + entryLen > budget)
+                        break;
+                    trimmed[k] = v;
+                    used += entryLen;
+                }
+                summary.workspaceFiles = trimmed;
+            }
+            else {
+                delete summary.workspaceFiles;
+            }
+            json = JSON.stringify(payload);
+            if (json.length <= LIMIT)
+                return json;
+        }
+        // Phase 2 — drop workspaceFiles entirely
+        if (summary?.workspaceFiles) {
+            delete summary.workspaceFiles;
+            json = JSON.stringify(payload);
+            if (json.length <= LIMIT)
+                return json;
+        }
+        // Phase 3 — truncate history to last 6 messages
+        if (Array.isArray(payload.history) && payload.history.length > 6) {
+            payload.history = payload.history.slice(-6);
+            json = JSON.stringify(payload);
+            if (json.length <= LIMIT)
+                return json;
+        }
+        // Phase 4 — truncate file list
+        if (summary?.files && Array.isArray(summary.files) && summary.files.length > 15) {
+            summary.files = summary.files.slice(0, 15);
+            json = JSON.stringify(payload);
+            if (json.length <= LIMIT)
+                return json;
+        }
+        // Phase 5 — drop readmeExcerpt
+        if (summary?.readmeExcerpt) {
+            delete summary.readmeExcerpt;
+            json = JSON.stringify(payload);
+            if (json.length <= LIMIT)
+                return json;
+        }
+        // Phase 6 — drop history entirely
+        if (Array.isArray(payload.history) && payload.history.length > 0) {
+            payload.history = [];
+            json = JSON.stringify(payload);
+            if (json.length <= LIMIT)
+                return json;
+        }
+        // Phase 7 — drop localWorkspaceSummary entirely as last resort
+        if (payload.localWorkspaceSummary) {
+            payload.localWorkspaceSummary = { path: summary?.path, name: summary?.name, fileCount: summary?.fileCount };
+            json = JSON.stringify(payload);
+        }
+        return json;
     }
     buildMinimalV3AgentContext(context = {}) {
         const resolvedContext = this.ensureExecutionContext(context);
@@ -2206,10 +2310,74 @@ document.addEventListener('DOMContentLoaded', () => {
             if (messageEvent) {
                 return messageEvent.content;
             }
+            // Synthesize a grounded answer from the tool-call evidence the
+            // agent produced, rather than dumping the raw event trace.
+            const answer = this.synthesizeAnswerFromV3Events(data.events);
+            if (answer) {
+                return answer;
+            }
+        }
+        // Last resort: if data has files written, report them.
+        if (data?.files && typeof data.files === 'object' && Object.keys(data.files).length > 0) {
+            const fileList = Object.keys(data.files).join(', ');
+            return `Agent wrote workspace files: ${fileList}`;
         }
         const text = JSON.stringify(data, null, 2);
         return text.length > 12000 ? `${text.slice(0, 12000)}\n\n[V3 agent output truncated]` : text;
     }
+    /**
+     * Build a human-readable answer from the tool results in a V3 event
+     * stream when the server didn't emit a proper complete/message event.
+     */
+    synthesizeAnswerFromV3Events(events) {
+        const toolResults = [];
+        const filesRead = [];
+        const filesWritten = [];
+        let lastAssistantText = '';
+        for (const event of events) {
+            if (!event)
+                continue;
+            if (event.type === 'tool_result' && event.success && typeof event.output === 'string') {
+                const name = event.name || 'unknown_tool';
+                if (name === 'read_file' && typeof event.target === 'string') {
+                    filesRead.push(event.target);
+                }
+                else if ((name === 'write_file' || name === 'create_file') && typeof event.target === 'string') {
+                    filesWritten.push(event.target);
+                }
+                else {
+                    // Keep last ~300 chars of output for context
+                    const excerpt = event.output.length > 300 ? event.output.slice(-300) : event.output;
+                    toolResults.push(`[${name}] ${excerpt}`);
+                }
+            }
+            if (event.type === 'assistant' && typeof event.content === 'string' && event.content.trim()) {
+                lastAssistantText = event.content.trim();
+            }
+            // Some servers emit 'text' events for incremental assistant text
+            if (event.type === 'text' && typeof event.content === 'string' && event.content.trim()) {
+                lastAssistantText = event.content.trim();
+            }
+        }
+        // Prefer the last assistant text the model emitted
+        if (lastAssistantText.length > 20) {
+            return lastAssistantText;
+        }
+        // Otherwise build a summary from tool evidence
+        const sections = [];
+        if (filesRead.length > 0) {
+            sections.push(`Files inspected: ${filesRead.join(', ')}`);
+        }
+        if (filesWritten.length > 0) {
+            sections.push(`Files written: ${filesWritten.join(', ')}`);
+        }
+        if (toolResults.length > 0) {
+            sections.push(toolResults.slice(-5).join('\n'));
+        }
+        return sections.length > 0
+            ? sections.join('\n\n')
+            : '';
+    }
     async collectV3AgentStream(response, context = {}) {
         if (!response.body || typeof response.body.getReader !== 'function') {
             return response.json();
@@ -2574,6 +2742,10 @@ document.addEventListener('DOMContentLoaded', () => {
         const timeoutMs = context.operatorTimeoutMs || DEFAULT_OPERATOR_TIMEOUT_MS;
         const errors = [];
         const authToken = this.config.get('authToken');
+        // Collect a lightweight workspace file listing so the operator can
+        // ground its analysis in real files rather than returning files_analyzed: 0.
+        const workspacePath = executionContext.workspacePath || executionContext.projectPath || executionContext.targetPath || process.cwd();
+        const workspaceSummary = this.buildLocalWorkspaceSummary(workspacePath);
         for (const baseUrl of this.getOperatorBaseUrls()) {
             const controller = new AbortController();
             const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
@@ -2597,8 +2769,9 @@ document.addEventListener('DOMContentLoaded', () => {
                         trace_id: executionContext.traceId,
                         mcp_context_id: executionContext.mcpContextId || null,
                         context: {
-                            workspace: { path: executionContext.workspacePath || executionContext.projectPath || executionContext.targetPath || process.cwd() },
-                            workspace_path: executionContext.workspacePath || executionContext.projectPath || executionContext.targetPath || process.cwd(),
+                            workspace: { path: workspacePath },
+                            workspace_path: workspacePath,
+                            workspace_summary: workspaceSummary,
                             model: this.resolveModelId(executionContext.model || 'code-8b'),
                             history: executionContext.history || [],
                             executionSurface: executionContext.executionSurface || 'cli',
@@ -3024,8 +3197,21 @@ document.addEventListener('DOMContentLoaded', () => {
     }
     // Code operations - Using Vigthoria Centralized API
     async generateCode(prompt, language, model) {
-        const response = await this.client.post('/api/ai/generate', {
+        // Prepend a forceful scope-enforcement instruction so the model
+        // doesn't expand a small task into an oversized glossy page.
+        const scopedPrompt = [
+            'IMPORTANT — SCOPE CONSTRAINTS:',
+            '1. Follow the user\'s scope literally. Output ONLY what was requested.',
+            '2. If the user says "tiny", "small", "simple", or "minimal", produce ≤ 50 lines of code.',
+            '3. Do NOT add: hero sections, animations, gradients, Google Fonts, Font Awesome, responsive breakpoints, or landing-page patterns UNLESS the user explicitly requests them.',
+            '4. Do NOT add external CDN links or dependencies unless the user asks for them.',
+            '5. Prefer inline styles or a small <style> block.  No large CSS frameworks.',
+            '6. Return raw code only — no markdown fences, no explanations.',
+            '',
             prompt,
+        ].join('\n');
+        const response = await this.client.post('/api/ai/generate', {
+            prompt: scopedPrompt,
             language,
             model: this.resolvePermittedModelId(model),
         });
@@ -3058,15 +3244,143 @@ document.addEventListener('DOMContentLoaded', () => {
             code,
             language,
         });
-        return response.data;
+        const raw = response.data ?? {};
+        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 : [];
+        // Prevent contradictory output: low score but zero issues
+        if (score < 50 && issues.length === 0) {
+            issues.push({
+                type: 'quality',
+                line: 0,
+                message: `The analysis returned a low quality score (${score}/100) but did not enumerate specific issues. This typically means the review model returned incomplete data. Consider re-running the review or inspecting the file manually.`,
+                severity: 'warning',
+            });
+        }
+        return { score, issues, suggestions };
     }
     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}`
+            : code;
         const response = await this.client.post('/api/ai/fix', {
-            code,
+            code: augmentedCode,
             language,
             fixType,
         });
-        return response.data;
+        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
+        // our injected comment prefix from the returned code and attempt
+        // a basic client-side repair.
+        if (changes.length === 0 && syntaxHints && 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:')) {
+            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 (changes.length === 0 && fixed !== code) {
+            changes = [{ line: 1, before: '(original code)', after: '(fixed code)', reason: syntaxHints || 'AI-suggested fix' }];
+        }
+        return { fixed, 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('; ');
     }
     // Model resolution - maps Vigthoria model names to internal IDs
     // INTERNAL USE ONLY - users see only Vigthoria branding

package/package.json

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