vigthoria-cli 1.6.29 → 1.6.31

package/dist/commands/auth.js

@@ -240,10 +240,14 @@ class AuthCommand {
         if (capabilityStatus.devtoolsBridge.error) {
             console.log(chalk_1.default.gray('    Error: ') + chalk_1.default.gray(capabilityStatus.devtoolsBridge.error));
         }
-        // Auth scope summary
+        // Auth scope summary — use a real server-side probe for Model Auth
+        const tokenValidation = await this.api.validateToken();
         console.log();
         console.log(chalk_1.default.white('Auth Scopes:'));
-        console.log(chalk_1.default.gray('  Model Auth: ') + (this.config.isAuthenticated() ? chalk_1.default.green('Active') : chalk_1.default.red('Missing')) + chalk_1.default.gray(' (used by chat, agent, review, explain, generate, fix)'));
+        console.log(chalk_1.default.gray('  Model Auth: ') + (tokenValidation.valid ? chalk_1.default.green('Valid') : chalk_1.default.red('Invalid')) + chalk_1.default.gray(' (used by chat, agent, review, explain, generate, fix)'));
+        if (!tokenValidation.valid && tokenValidation.error) {
+            console.log(chalk_1.default.gray('    ') + chalk_1.default.red(tokenValidation.error));
+        }
         console.log(chalk_1.default.gray('  Repo Auth: ') + (capabilityStatus.repoMemory.ok ? chalk_1.default.green('Active') : chalk_1.default.yellow('Inactive')) + chalk_1.default.gray(' (used by repo push/pull/list only)'));
         console.log(chalk_1.default.gray('  Bridge Auth: ') + (capabilityStatus.devtoolsBridge.ok ? chalk_1.default.green('Connected') : chalk_1.default.gray('N/A')) + chalk_1.default.gray(' (used by --bridge flag only)'));
         console.log();

package/dist/commands/edit.js

@@ -29,6 +29,12 @@ class EditCommand {
             this.logger.error('Not authenticated. Run: vigthoria login');
             return;
         }
+        // Server-side token validation — fail fast instead of waiting for 401
+        const tokenCheck = await this.api.validateToken();
+        if (!tokenCheck.valid) {
+            this.logger.error(tokenCheck.error || 'Auth token is invalid. Run: vigthoria login');
+            return;
+        }
         // Read file
         const file = this.fileUtils.readFile(filePath);
         if (!file) {
@@ -46,6 +52,11 @@ class EditCommand {
                 this.logger.error('The --apply flag requires --instruction. Example: vigthoria edit file.ts --apply --instruction "fix the bug"');
                 return;
             }
+            // Non-TTY stdin cannot prompt interactively
+            if (!process.stdin.isTTY) {
+                this.logger.error('No --instruction provided and stdin is not interactive. Use: vigthoria edit file.ts --instruction "..."');
+                return;
+            }
             const answer = await inquirer_1.default.prompt([
                 {
                     type: 'input',
@@ -93,11 +104,14 @@ Return the complete modified file content:`,
             ], options.model);
             spinner.stop();
             // Extract code from response
-            const modifiedCode = this.extractCode(response.message, file.language);
+            let modifiedCode = this.extractCode(response.message, file.language);
             if (!modifiedCode) {
                 this.logger.error('Failed to generate valid code changes');
                 return;
             }
+            // Always deduplicate — extractCode only dedupes on the no-fence
+            // fallback path, so fenced responses (the common case) need this.
+            modifiedCode = this.deduplicateCode(modifiedCode);
             // Show diff and apply
             if (options.apply) {
                 await this.applyFix(file.path, file.content, modifiedCode);
@@ -118,6 +132,12 @@ Return the complete modified file content:`,
             this.logger.error('Not authenticated. Run: vigthoria login');
             return;
         }
+        // Server-side token validation — fail fast instead of waiting for 401
+        const tokenCheck = await this.api.validateToken();
+        if (!tokenCheck.valid) {
+            this.logger.error(tokenCheck.error || 'Auth token is invalid. Run: vigthoria login');
+            return;
+        }
         // Read file
         const file = this.fileUtils.readFile(filePath);
         if (!file) {
@@ -238,11 +258,15 @@ Return the complete modified file content:`,
                 runEnd++;
             }
             const runLen = runEnd - i;
+            // Check if this run is "effectively at end" — only trailing empty
+            // lines follow the duplicate pair.
+            const isAtEffectiveEnd = runEnd === lines.length
+                || lines.slice(runEnd).every(l => l.trim() === '');
             if (runLen >= 3) {
                 // 3+ identical lines is almost certainly stutter — keep one
                 deduped.push(lines[i]);
             }
-            else if (runLen === 2 && runEnd === lines.length) {
+            else if (runLen === 2 && isAtEffectiveEnd) {
                 // Exactly 2 identical lines at the very end — trailing stutter
                 deduped.push(lines[i]);
             }
@@ -297,6 +321,11 @@ Return the complete modified file content:`,
             await this.applyFix(filePath, original, modified);
             return;
         }
+        // Non-TTY: show the diff but don't try to prompt — re-run with --apply
+        if (!process.stdin.isTTY) {
+            this.logger.info('Non-interactive mode. Re-run with --apply to apply changes.');
+            return;
+        }
         const { action } = await inquirer_1.default.prompt([
             {
                 type: 'list',

package/dist/commands/explain.js

@@ -33,6 +33,12 @@ class ExplainCommand {
             this.logger.error('Not authenticated. Run: vigthoria login');
             return;
         }
+        // Server-side token validation — fail fast instead of waiting for 401
+        const tokenCheck = await this.api.validateToken();
+        if (!tokenCheck.valid) {
+            this.logger.error(tokenCheck.error || 'Auth token is invalid. Run: vigthoria login');
+            return;
+        }
         // Read file
         const file = this.fileUtils.readFile(filePath);
         if (!file) {

package/dist/commands/generate.js

@@ -31,6 +31,12 @@ class GenerateCommand {
             this.logger.error('Not authenticated. Run: vigthoria login');
             return;
         }
+        // Server-side token validation — fail fast instead of waiting for 401
+        const tokenCheck = await this.api.validateToken();
+        if (!tokenCheck.valid) {
+            this.logger.error(tokenCheck.error || 'Auth token is invalid. Run: vigthoria login');
+            return;
+        }
         // Determine mode
         const proMode = options.pro === true;
         // Auto-detect language from description if not explicitly specified

package/dist/commands/review.js

@@ -33,6 +33,12 @@ class ReviewCommand {
             this.logger.error('Not authenticated. Run: vigthoria login');
             return;
         }
+        // Server-side token validation — fail fast instead of waiting for 401
+        const tokenCheck = await this.api.validateToken();
+        if (!tokenCheck.valid) {
+            this.logger.error(tokenCheck.error || 'Auth token is invalid. Run: vigthoria login');
+            return;
+        }
         // Read file
         const file = this.fileUtils.readFile(filePath);
         if (!file) {

package/dist/utils/api.d.ts

@@ -201,6 +201,17 @@ export declare class APIClient {
     private refreshToken;
     getSubscriptionStatus(): Promise<void>;
     private getAccessToken;
+    /**
+     * Validate the current auth token against the Coder API.
+     * Returns { valid: true } when the server accepts the token,
+     * { valid: false, error } when the token is rejected (401/403),
+     * and { valid: true } when the server is unreachable (network error)
+     * so that offline/degraded scenarios don't block the user.
+     */
+    validateToken(): Promise<{
+        valid: boolean;
+        error?: string;
+    }>;
     getV3AgentBaseUrls(preferLocal?: boolean): string[];
     getV3AgentRunUrl(baseUrl: string): string;
     getV3AgentContinueUrl(baseUrl: string): string;
@@ -334,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

@@ -340,6 +340,49 @@ class APIClient {
             || this.config.get('authToken')
             || null;
     }
+    /**
+     * Validate the current auth token against the Coder API.
+     * Returns { valid: true } when the server accepts the token,
+     * { valid: false, error } when the token is rejected (401/403),
+     * and { valid: true } when the server is unreachable (network error)
+     * so that offline/degraded scenarios don't block the user.
+     */
+    async validateToken() {
+        const token = this.getAccessToken();
+        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.modelRouterClient.get('/v1/models', { timeout: 10000 });
+            return { valid: true };
+        }
+        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' };
+            }
+            // 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 };
+            }
+        }
+    }
     getV3AgentBaseUrls(preferLocal = false) {
         const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
         const allowLocalV3Agent = process.env.VIGTHORIA_ALLOW_LOCAL_V3_AGENT === '1' || preferLocal;
@@ -3326,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;
@@ -3362,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);
@@ -3497,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 : [];
@@ -3701,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.29",
+  "version": "1.6.31",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "main": "dist/index.js",
   "files": [