vigthoria-cli 1.6.30 → 1.6.32

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

@@ -345,6 +345,7 @@ export declare class APIClient {
     private getSelfHostedFallbackModelId;
     chatStream(messages: ChatMessage[], model: string): AsyncGenerator<StreamChunk>;
     chatWithCallback(messages: ChatMessage[], model: string, onChunk: (chunk: string) => void, onDone: () => void, onError: (error: Error) => void): Promise<void>;
+    private chatComplete;
     generateCode(prompt: string, language: string, model: string): Promise<string>;
     /**
      * Ensure code has balanced curly braces by appending missing closing braces.

package/dist/utils/api.js

@@ -352,20 +352,35 @@ class APIClient {
         if (!token) {
             return { valid: false, error: 'No auth token configured. Run: vigthoria login' };
         }
+        // Verify auth against the Model Router (api.vigthoria.io) which is
+        // the backend all AI commands actually use.  Falls back to the Coder
+        // profile endpoint when the Model Router is unreachable so that
+        // offline/degraded scenarios don't block the user.
         try {
-            await this.client.get('/api/user/profile', { timeout: 10000 });
+            await this.modelRouterClient.get('/v1/models', { timeout: 10000 });
             return { valid: true };
         }
-        catch (error) {
-            if (error instanceof CLIError && error.category === 'auth') {
+        catch (mrError) {
+            const mrAxErr = mrError;
+            if (mrAxErr.response?.status === 401 || mrAxErr.response?.status === 403) {
                 return { valid: false, error: 'Auth token expired or invalid. Run: vigthoria login' };
             }
-            const axErr = error;
-            if (axErr.response?.status === 401 || axErr.response?.status === 403) {
-                return { valid: false, error: 'Auth token expired or invalid. Run: vigthoria login' };
+            // Model Router unreachable — try Coder profile as fallback
+            try {
+                await this.client.get('/api/user/profile', { timeout: 10000 });
+                return { valid: true };
+            }
+            catch (error) {
+                if (error instanceof CLIError && error.category === 'auth') {
+                    return { valid: false, error: 'Auth token expired or invalid. Run: vigthoria login' };
+                }
+                const axErr = error;
+                if (axErr.response?.status === 401 || axErr.response?.status === 403) {
+                    return { valid: false, error: 'Auth token expired or invalid. Run: vigthoria login' };
+                }
+                // Both unreachable — don't assume token is bad
+                return { valid: true };
             }
-            // Network/timeout errors — don't assume token is bad
-            return { valid: true };
         }
     }
     getV3AgentBaseUrls(preferLocal = false) {
@@ -3354,7 +3369,26 @@ document.addEventListener('DOMContentLoaded', () => {
             });
         });
     }
-    // Code operations - Using Vigthoria Centralized API
+    // ─── Chat completion helper ────────────────────────────────────────
+    // Routes all AI file commands through the Model Router
+    // (/v1/chat/completions on api.vigthoria.io) which is the only
+    // backend that reliably accepts our auth token.
+    async chatComplete(systemPrompt, userPrompt, model, maxTokens) {
+        const resolvedModel = model ? this.resolvePermittedModelId(model) : 'vigthoria-v3-code-30b';
+        const response = await this.modelRouterClient.post('/v1/chat/completions', {
+            model: resolvedModel,
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: userPrompt },
+            ],
+            max_tokens: maxTokens || this.config.get('preferences').maxTokens || 4096,
+            temperature: 0.3,
+            stream: false,
+        });
+        const content = response.data.choices?.[0]?.message?.content || response.data.choices?.[0]?.text || '';
+        return typeof content === 'string' ? content : '';
+    }
+    // Code operations - Using Vigthoria Centralized API (via Model Router)
     async generateCode(prompt, language, model) {
         const isNonHtmlLang = !['html', 'css'].includes(language.toLowerCase());
         const wordCount = prompt.trim().split(/\s+/).length;
@@ -3390,24 +3424,18 @@ document.addEventListener('DOMContentLoaded', () => {
             lines.push('', prompt);
             return lines.join('\n');
         };
-        // First attempt
-        let response = await this.client.post('/api/ai/generate', {
-            prompt: buildScopedPrompt(false),
-            language,
-            model: this.resolvePermittedModelId(model),
-        });
-        let code = response.data.code || '';
+        // 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
-            response = await this.client.post('/api/ai/generate', {
-                prompt: buildScopedPrompt(true),
-                language,
-                model: this.resolvePermittedModelId(model),
-            });
-            code = response.data.code || '';
+            // 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);
@@ -3525,65 +3553,88 @@ document.addEventListener('DOMContentLoaded', () => {
     }
     // Senior Developer Mode - Planning + Generation + Quality Check
     async generateProject(prompt, projectType, model) {
-        const response = await this.client.post('/api/ai/generate-project', {
-            prompt,
-            projectType,
-            model: this.resolvePermittedModelId(model),
-        }, {
-            timeout: 300000, // 5 minutes for complex generation
-        });
-        return {
-            code: response.data.code,
-            plan: response.data.plan,
-            quality: response.data.quality,
-        };
+        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 response = await this.client.post('/api/ai/explain', {
-            code,
-            language,
-        });
-        return response.data.explanation;
+        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.`;
+        return this.chatComplete(sysPrompt, code);
     }
     async reviewCode(code, language) {
-        const response = await this.client.post('/api/ai/review', {
-            code,
-            language,
-            instructions: [
-                'Return concrete, line-specific issues with severity.',
-                'Every issue MUST reference a line number.',
-                'If the score is below 50, you MUST list at least 2 specific issues.',
-                'Prioritize REAL BUGS over style issues:',
-                '- Wrong arithmetic operators (+ instead of -, * instead of /, etc.)',
-                '- Logic errors (function named "add" using subtraction, wrong comparisons)',
-                '- Off-by-one errors, incorrect return values',
-                '- Type mismatches, null/undefined access',
-                'Only report style issues (console.log, naming) AFTER listing all real bugs.',
-            ].join(' '),
-        });
-        const raw = response.data ?? {};
+        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 at most 2 issues unless there are genuinely more distinct 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.',
+            '- 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 : [];
-        // 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 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);
+            // 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++;
                 }
-                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) {
+                return overlap >= 2;
+            });
+            if (!isSemanticallyDuplicate) {
                 issues.push(h);
             }
         }
@@ -3729,12 +3780,25 @@ document.addEventListener('DOMContentLoaded', () => {
                 : '';
         }
         const augmentedCode = preamble ? `${preamble}${code}` : code;
-        const response = await this.client.post('/api/ai/fix', {
-            code: augmentedCode,
-            language,
-            fixType,
-        });
-        const raw = response.data ?? {};
+        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,',
+            '  "changes": [{ "line": number, "before": string, "after": string, "reason": string }]',
+            'Rules:',
+            '- 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

package/package.json

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