vigthoria-cli 1.6.30 → 1.6.31

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,43 +3553,55 @@ 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.',
+            '- If the score is below 50, list at least 2 specific issues.',
+            '- Prioritize REAL BUGS: wrong operators, logic errors, off-by-one, type mismatches.',
+            '- Only report style issues AFTER listing all real bugs.',
+            '- 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 : [];
@@ -3729,12 +3769,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.31",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "main": "dist/index.js",
   "files": [