vigthoria-cli 1.6.14 → 1.6.16

package/dist/commands/chat.d.ts

@@ -50,6 +50,9 @@ export declare class ChatCommand {
     private buildTaskShapingInstructions;
     private buildExecutionPrompt;
     private getPromptRuntimeContext;
+    private v3IterationCount;
+    private v3ToolCallCount;
+    private v3LastActivity;
     private describeV3AgentTool;
     private updateV3AgentSpinner;
     private updateOperatorSpinner;

package/dist/commands/chat.js

@@ -47,9 +47,9 @@ const api_js_1 = require("../utils/api.js");
 const tools_js_1 = require("../utils/tools.js");
 const session_js_1 = require("../utils/session.js");
 const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
-    const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS || '1200000';
+    const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS || '3900000';
     const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 1200000;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 3900000;
 })();
 class ChatCommand {
     config;
@@ -227,37 +227,87 @@ class ChatCommand {
             devtoolsBridgeEndpoint: bridgeStatus.endpoint,
         };
     }
+    v3IterationCount = 0;
+    v3ToolCallCount = 0;
+    v3LastActivity = Date.now();
     describeV3AgentTool(toolName) {
         const normalized = String(toolName || '').toLowerCase();
         if (/read|grep|search|list|find|glob/.test(normalized)) {
-            return 'Planning... gathering project context';
+            return 'Reading project files';
         }
         if (/write|edit|patch|create|delete|replace|rename/.test(normalized)) {
-            return 'Applying changes...';
+            return 'Writing changes';
         }
         if (/test|lint|build|run|exec|terminal/.test(normalized)) {
-            return 'Validating changes...';
+            return 'Running verification';
         }
-        return 'Working...';
+        if (/hyperloop/.test(normalized)) {
+            return 'Hyperloop processing';
+        }
+        return 'Working';
     }
     updateV3AgentSpinner(spinner, event) {
         if (!event || typeof event !== 'object') {
             return;
         }
+        this.v3LastActivity = Date.now();
         if (event.type === 'tool_call') {
-            spinner.text = this.describeV3AgentTool(event.tool || event.name || event.tool_name);
+            this.v3ToolCallCount += 1;
+            const toolDesc = this.describeV3AgentTool(event.tool || event.name || event.tool_name);
+            const toolTarget = event.arguments?.path || event.arguments?.file_path || event.arguments?.pattern || '';
+            const shortTarget = toolTarget ? ` → ${String(toolTarget).split('/').slice(-2).join('/')}` : '';
+            spinner.text = chalk_1.default.cyan(`[${this.v3IterationCount}/${this.v3ToolCallCount}] `) + `${toolDesc}${shortTarget}`;
+            return;
+        }
+        if (event.type === 'tool_result') {
+            const success = event.success !== false;
+            const toolName = event.name || event.tool || '';
+            const indicator = success ? chalk_1.default.green('✓') : chalk_1.default.red('✗');
+            spinner.text = `${indicator} ${toolName} complete — next step...`;
+            return;
+        }
+        if (event.type === 'thinking') {
+            this.v3IterationCount += 1;
+            const iterText = event.content || '';
+            const iterMatch = iterText.match(/Iteration (\d+)/i);
+            const iterNum = iterMatch ? iterMatch[1] : String(this.v3IterationCount);
+            spinner.text = chalk_1.default.cyan(`[Iteration ${iterNum}] `) + 'Analyzing...';
             return;
         }
         if (event.type === 'message') {
-            spinner.text = 'Writing response...';
+            const preview = String(event.content || '').slice(0, 80).replace(/\n/g, ' ');
+            spinner.text = chalk_1.default.cyan('[Response] ') + (preview || 'Writing response...');
             return;
         }
         if (event.type === 'complete') {
-            spinner.text = 'Finishing...';
+            const elapsed = event.elapsed || '';
+            const iters = event.iterations || this.v3IterationCount;
+            const tools = event.tool_calls || this.v3ToolCallCount;
+            spinner.text = chalk_1.default.green('✓ ') + `Complete — ${iters} iterations, ${tools} tool calls${elapsed ? `, ${elapsed}` : ''}`;
+            return;
+        }
+        if (event.type === 'plan') {
+            const planKind = event.plan?.task_kind || event.task_kind || '';
+            spinner.text = chalk_1.default.cyan('[Plan] ') + `Task: ${planKind || 'analyzing'}...`;
+            return;
+        }
+        if (event.type === 'error') {
+            if (event.checkpointed) {
+                spinner.text = chalk_1.default.yellow('[Checkpoint] ') + 'Budget reached — auto-continuing...';
+            }
+            else {
+                spinner.text = chalk_1.default.red('[Error] ') + (event.message || 'Agent error');
+            }
+            return;
+        }
+        if (event.type === 'context') {
+            spinner.text = chalk_1.default.cyan('[Context] ') + 'Workspace bound...';
             return;
         }
-        if (event.type === 'plan' || event.type === 'analysis' || event.type === 'thinking') {
-            spinner.text = 'Planning...';
+        if (event.type === 'start') {
+            this.v3IterationCount = 0;
+            this.v3ToolCallCount = 0;
+            spinner.text = chalk_1.default.cyan('[Start] ') + 'Agent initialized...';
         }
     }
     updateOperatorSpinner(spinner, event) {
@@ -856,6 +906,10 @@ class ChatCommand {
         const runtimeContext = await this.getPromptRuntimeContext(prompt);
         const routingPolicy = this.resolveAgentExecutionPolicy(prompt);
         const rescueEligible = this.isSaaSRescuePrompt(prompt);
+        // Reset streaming counters for new workflow
+        this.v3IterationCount = 0;
+        this.v3ToolCallCount = 0;
+        this.v3LastActivity = Date.now();
         const spinner = this.jsonOutput ? null : (0, ora_1.default)({
             text: routingPolicy.cloudSelected ? 'Routing heavy task to Vigthoria Cloud...' : 'Routing to V3 Agent...',
             spinner: 'clock',

package/dist/utils/api.d.ts

@@ -188,6 +188,7 @@ export declare class APIClient {
     private getAccessToken;
     getV3AgentBaseUrls(preferLocal?: boolean): string[];
     getV3AgentRunUrl(baseUrl: string): string;
+    getV3AgentContinueUrl(baseUrl: string): string;
     getOperatorBaseUrls(): string[];
     getOperatorStreamUrl(baseUrl: string): string;
     getMcpBaseUrls(): string[];
@@ -244,7 +245,7 @@ export declare class APIClient {
     };
     waitForAgentWorkspaceSettle(context?: Record<string, any>, options?: Record<string, any>): Promise<void>;
     extractExpectedWorkspaceFiles(message?: string, context?: Record<string, any>): string[];
-    captureV3AgentStreamMutation(event: any, streamedFiles: Record<string, string>): void;
+    captureV3AgentStreamMutation(event: any, streamedFiles: Record<string, string>, serverRoot?: string | null): void;
     recoverAgentWorkspaceFiles(context?: Record<string, any>, streamedFiles?: Record<string, string>, expectedFiles?: string[]): void;
     normalizeAgentWorkspaceRelativePath(rawPath: string, rootPath?: string): string;
     ensureAgentFrontendPolish(message?: string, context?: Record<string, any>): Promise<void>;

package/dist/utils/api.js

@@ -26,9 +26,9 @@ const DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS = (() => {
     return Number.isFinite(parsed) && parsed > 0 ? parsed : 90000;
 })();
 const DEFAULT_OPERATOR_TIMEOUT_MS = (() => {
-    const rawValue = process.env.VIGTHORIA_OPERATOR_TIMEOUT_MS || process.env.OPERATOR_TIMEOUT_MS || '1200000';
+    const rawValue = process.env.VIGTHORIA_OPERATOR_TIMEOUT_MS || process.env.OPERATOR_TIMEOUT_MS || '3900000';
     const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 1200000;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 3900000;
 })();
 class APIClient {
     client;
@@ -276,6 +276,12 @@ class APIClient {
         }
         return `${baseUrl}/api/v3-agent/run`;
     }
+    getV3AgentContinueUrl(baseUrl) {
+        if (/127\.0\.0\.1:8030|localhost:8030/.test(baseUrl)) {
+            return `${baseUrl}/api/agent/continue`;
+        }
+        return `${baseUrl}/api/v3-agent/continue`;
+    }
     getOperatorBaseUrls() {
         const configuredModelsApiUrl = String(this.config.get('modelsApiUrl') || 'https://api.vigthoria.io').replace(/\/$/, '');
         const urls = [
@@ -1684,13 +1690,13 @@ menu {
         addMatches(context.agentPrompt);
         return Array.from(candidates);
     }
-    captureV3AgentStreamMutation(event, streamedFiles) {
+    captureV3AgentStreamMutation(event, streamedFiles, serverRoot) {
         if (!event || event.type !== 'tool_call' || !streamedFiles) {
             return;
         }
         const args = event.arguments || {};
         if ((event.name === 'write_file' || event.name === 'edit_file') && typeof args.path === 'string') {
-            const filePath = this.normalizeAgentWorkspaceRelativePath(args.path);
+            const filePath = this.normalizeAgentWorkspaceRelativePath(args.path, serverRoot || undefined);
             if (!filePath) {
                 return;
             }
@@ -1708,9 +1714,21 @@ menu {
     }
     recoverAgentWorkspaceFiles(context = {}, streamedFiles = {}, expectedFiles = []) {
         const rootPath = this.resolveAgentTargetPath(context);
-        if (!rootPath || !fs_1.default.existsSync(rootPath) || Object.keys(streamedFiles).length === 0) {
+        if (!rootPath || Object.keys(streamedFiles).length === 0) {
             return;
         }
+        // Create the local workspace directory if it doesn't exist yet.
+        // This is needed for remote CLI clients where the user specified a
+        // path (e.g., C:\vigthoria\Apps\pacman_rogue) that may not have
+        // been created before the V3 run.
+        if (!fs_1.default.existsSync(rootPath)) {
+            try {
+                fs_1.default.mkdirSync(rootPath, { recursive: true });
+            }
+            catch {
+                return;
+            }
+        }
         const targets = expectedFiles.length > 0 ? expectedFiles : Object.keys(streamedFiles);
         for (const targetPath of targets) {
             const relativePath = this.normalizeAgentWorkspaceRelativePath(targetPath, rootPath);
@@ -2142,6 +2160,7 @@ document.addEventListener('DOMContentLoaded', () => {
         const events = [];
         let final = null;
         let contextId = response.headers.get('x-context-id') || String(context.contextId || '').trim() || null;
+        let serverWorkspaceRoot = null;
         const streamedFiles = {};
         const idleTimeoutMs = context.agentIdleTimeoutMs || DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS;
         while (true) {
@@ -2208,7 +2227,10 @@ document.addEventListener('DOMContentLoaded', () => {
                 if (!contextId && typeof event.context_id === 'string' && event.context_id.trim()) {
                     contextId = event.context_id.trim();
                 }
-                this.captureV3AgentStreamMutation(event, streamedFiles);
+                if (!serverWorkspaceRoot && event.type === 'context' && typeof event.workspace_root === 'string' && event.workspace_root.trim()) {
+                    serverWorkspaceRoot = event.workspace_root.trim();
+                }
+                this.captureV3AgentStreamMutation(event, streamedFiles, serverWorkspaceRoot);
                 if (typeof context.onStreamEvent === 'function') {
                     try {
                         context.onStreamEvent(event);
@@ -2218,6 +2240,19 @@ document.addEventListener('DOMContentLoaded', () => {
                     }
                 }
                 if (event.type === 'error') {
+                    if (event.checkpointed && event.task_id) {
+                        // Agent checkpointed — return data so caller can auto-continue
+                        return {
+                            task_id: event.task_id,
+                            context_id: contextId,
+                            result: final || event,
+                            events,
+                            files: streamedFiles,
+                            partial: true,
+                            checkpointed: true,
+                            checkpointed_task_id: event.task_id,
+                        };
+                    }
                     if (this.hasAgentWorkspaceOutput(context)) {
                         return {
                             task_id: events.find((entry) => entry && entry.task_id)?.task_id || null,
@@ -2241,6 +2276,7 @@ document.addEventListener('DOMContentLoaded', () => {
             result: final,
             events,
             files: streamedFiles,
+            serverWorkspaceRoot: serverWorkspaceRoot || null,
         };
     }
     async runV3AgentWorkflow(message, context = {}) {
@@ -2295,6 +2331,66 @@ document.addEventListener('DOMContentLoaded', () => {
                         throw new Error(`V3 agent ${response.status}: ${errorText.slice(0, 200)}`);
                     }
                     const data = await this.collectV3AgentStream(response, requestExecutionContext);
+                    // Auto-continuation: if the agent checkpointed (budget exceeded), continue automatically
+                    if (data.checkpointed && data.checkpointed_task_id) {
+                        const maxContinuations = 10;
+                        let continuationData = data;
+                        let continuations = 0;
+                        while (continuationData.checkpointed && continuationData.checkpointed_task_id && continuations < maxContinuations) {
+                            continuations++;
+                            if (typeof requestExecutionContext.onStreamEvent === 'function') {
+                                try {
+                                    requestExecutionContext.onStreamEvent({
+                                        type: 'message',
+                                        content: `Auto-continuing task (phase ${continuations + 1})...`,
+                                    });
+                                }
+                                catch { /* ignore */ }
+                            }
+                            const continueBody = {
+                                task_id: continuationData.checkpointed_task_id,
+                                context: requestBody.context,
+                                context_id: requestBody.context_id,
+                                mcp_context_id: requestBody.mcp_context_id,
+                                stream: true,
+                            };
+                            const continueController = new AbortController();
+                            const continueTimeoutId = setTimeout(() => continueController.abort(), timeoutMs);
+                            try {
+                                const continueHeaders = await this.getV3AgentHeaders();
+                                const continueResponse = await fetch(this.getV3AgentContinueUrl(baseUrl), {
+                                    method: 'POST',
+                                    headers: { ...continueHeaders, 'Content-Type': 'application/json' },
+                                    body: JSON.stringify(continueBody),
+                                    signal: continueController.signal,
+                                });
+                                if (!continueResponse.ok) {
+                                    break; // Fall through to normal completion with partial data
+                                }
+                                continuationData = await this.collectV3AgentStream(continueResponse, requestExecutionContext);
+                            }
+                            catch {
+                                break; // Fall through to normal completion with partial data
+                            }
+                            finally {
+                                clearTimeout(continueTimeoutId);
+                            }
+                        }
+                        // Use the final continuation data for workspace recovery
+                        this.recoverAgentWorkspaceFiles(executionContext, continuationData.files || {}, expectedFiles);
+                        await this.waitForAgentWorkspaceSettle(executionContext, { expectedFiles });
+                        await this.ensureAgentFrontendPolish(message, executionContext);
+                        const previewGate = await this.runTemplateServicePreviewGate(message, executionContext);
+                        const finalContextId = continuationData.context_id || data.context_id || response.headers.get('x-context-id') || requestExecutionContext.contextId || null;
+                        return {
+                            content: this.formatV3AgentResponse(continuationData) || this.formatV3AgentResponse(data),
+                            taskId: continuationData.task_id || data.task_id || null,
+                            contextId: finalContextId,
+                            backendUrl: baseUrl,
+                            partial: continuationData.checkpointed === true,
+                            metadata: { source: 'v3-agent', mode: 'agent', contextId: finalContextId, continuations, previewGate },
+                        };
+                    }
                     const contextId = data.context_id || response.headers.get('x-context-id') || requestExecutionContext.contextId || null;
                     const mcpContextId = response.headers.get('x-mcp-context-id') || requestExecutionContext.mcpContextId || null;
                     this.recoverAgentWorkspaceFiles(executionContext, data.files || {}, expectedFiles);

package/package.json

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