vigthoria-cli 1.6.19 → 1.6.20

package/dist/commands/chat.js

@@ -199,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 = [];
@@ -695,17 +699,41 @@ class ChatCommand {
             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/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;
@@ -273,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;
@@ -338,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

@@ -328,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(/^\.\//, '');
     }
@@ -596,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);
@@ -2292,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();
@@ -2660,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);
@@ -2683,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',
@@ -3110,9 +3197,19 @@ document.addEventListener('DOMContentLoaded', () => {
     }
     // Code operations - Using Vigthoria Centralized API
     async generateCode(prompt, language, model) {
-        // Prepend scope-enforcement instruction so the model doesn't expand
-        // a small task into an oversized glossy production page.
-        const scopedPrompt = `IMPORTANT: Follow the user's scope literally. If they ask for something small or minimal, produce exactly that — no extra styling, no external dependencies, no landing-page treatment.\n\n${prompt}`;
+        // 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,
@@ -3148,23 +3245,142 @@ document.addEventListener('DOMContentLoaded', () => {
             language,
         });
         const raw = response.data ?? {};
-        return {
-            score: typeof raw.score === 'number' ? raw.score : 0,
-            issues: Array.isArray(raw.issues) ? raw.issues : [],
-            suggestions: Array.isArray(raw.suggestions) ? raw.suggestions : [],
-        };
+        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,
         });
         const raw = response.data ?? {};
-        return {
-            fixed: typeof raw.fixed === 'string' ? raw.fixed : (typeof raw.code === 'string' ? raw.code : code),
-            changes: Array.isArray(raw.changes) ? raw.changes : [],
-        };
+        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.19",
+  "version": "1.6.20",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "main": "dist/index.js",
   "files": [