vigthoria-cli 1.6.52 → 1.6.54

package/README.md

@@ -24,6 +24,11 @@ AI-powered terminal coding assistant integrated with Vigthoria's AI models and s
 - 🔐 **Secure Auth** - Integration with Vigthoria accounts
 - 📦 **Project Context** - Understands your codebase
 - 🗂️ **Vigthoria Repo** - Push/Pull projects to your personal cloud repository
+- 🔍 **Deep Codebase Search** - Indexed search across files, symbols, and content via ripgrep
+- ✏️ **Atomic Multi-File Edits** - Coordinated changes across multiple files with rollback
+- 🧩 **Sub-Agent Delegation** - Spawn focused sub-agents for parallel investigation
+- 🔒 **Persistent Permissions** - Per-project tool approvals saved across sessions
+- 📝 **Multi-Line Input** - Block mode ({{{ }}}) and line continuation (\\) for complex prompts
 
 ## Installation
 
@@ -96,7 +101,7 @@ If you see `ENOTFOUND registry.npmjs.org`, try these solutions:
 4. **Direct tarball download:**
    ```bash
    # Download directly
-  npm install -g https://cli.vigthoria.io/downloads/vigthoria-cli-1.6.12.tgz
+  npm install -g https://cli.vigthoria.io/downloads/vigthoria-cli-1.6.52.tgz
    ```
 
 5. **Use Git clone method (no npm registry needed):**

package/dist/commands/chat.js

@@ -47,6 +47,7 @@ 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 bridge_client_js_1 = require("../utils/bridge-client.js");
+const workspace_stream_js_1 = require("../utils/workspace-stream.js");
 const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS || '3900000';
     const parsed = Number.parseInt(rawValue, 10);
@@ -1442,6 +1443,17 @@ class ChatCommand {
             targetPath: this.currentProjectPath,
             ...runtimeContext,
         };
+        // Start workspace watcher for bidirectional real-time sync
+        let watcher = null;
+        if (this.currentProjectPath && fs.existsSync(this.currentProjectPath)) {
+            watcher = new workspace_stream_js_1.WorkspaceWatcher({
+                workspaceRoot: this.currentProjectPath,
+                onFileChange: (relativePath, content, action) => {
+                    this.logger.debug(`Local change detected: ${action} ${relativePath}`);
+                },
+            });
+            watcher.start();
+        }
         try {
             const workflowPromise = this.api.runV3AgentWorkflow(executionPrompt, {
                 workspace: { path: this.currentProjectPath },
@@ -1484,6 +1496,7 @@ class ChatCommand {
                     }
                     this.logger.warn('Falling back to legacy CLI agent loop');
                     this.logger.debug(`V3 agent workflow returned an incomplete result: ${previewGate?.error || 'workspace changes were not fully validated'}`);
+                    watcher?.stop();
                     return false;
                 }
                 const errorMessage = `V3 agent workflow returned an incomplete result and legacy fallback is disabled. ${previewGate?.error || 'Workspace changes were not fully validated.'}`;
@@ -1504,6 +1517,7 @@ class ChatCommand {
                         metadata: { executionPath: 'v3-agent', previewGate },
                     }, null, 2));
                 }
+                watcher?.stop();
                 return true;
             }
             if (!this.jsonOutput && previewGate?.required && previewGate?.passed !== true && workspaceHasOutput) {
@@ -1543,9 +1557,11 @@ class ChatCommand {
                 }
             }
             this.messages.push({ role: 'assistant', content: response.content || 'V3 agent workflow completed.' });
+            watcher?.stop();
             return true;
         }
         catch (error) {
+            watcher?.stop();
             if (rescueEligible && !this.api.hasAgentWorkspaceOutput(workspaceContext)) {
                 const rescued = await this.tryCommandLevelSaaSRescue(executionPrompt, prompt, workspaceContext, routingPolicy, spinner, error);
                 if (rescued) {
@@ -2473,13 +2489,16 @@ class ChatCommand {
         });
         console.log(action);
         const answer = await new Promise((resolve) => {
-            rl.question(chalk_1.default.yellow('Approve? [y]es / [n]o / [a]ll this turn: '), resolve);
+            rl.question(chalk_1.default.yellow('Approve? [y]es / [n]o / [a]ll this turn / [p]ersist: '), resolve);
         });
         rl.close();
         const normalized = answer.trim().toLowerCase();
         if (normalized === 'a' || normalized === 'all') {
             return 'batch';
         }
+        if (normalized === 'p' || normalized === 'persist') {
+            return 'persist';
+        }
         return normalized === 'y' || normalized === 'yes';
     }
     getCurrentSessionInfo() {

package/dist/utils/api.js

@@ -17,6 +17,7 @@ const https_1 = __importDefault(require("https"));
 const net_1 = __importDefault(require("net"));
 const path_1 = __importDefault(require("path"));
 const ws_1 = __importDefault(require("ws"));
+const workspace_stream_js_1 = require("./workspace-stream.js");
 class CLIError extends Error {
     category;
     statusCode;
@@ -2636,6 +2637,19 @@ document.addEventListener('DOMContentLoaded', () => {
                     serverWorkspaceRoot = event.workspace_root.trim();
                 }
                 this.captureV3AgentStreamMutation(event, streamedFiles, serverWorkspaceRoot);
+                // Real-time workspace streaming: apply file mutations to local disk immediately
+                if (event.type === 'file_mutation') {
+                    const localRoot = context.projectPath || context.workspacePath || context.targetPath;
+                    if (localRoot && typeof event.path === 'string') {
+                        (0, workspace_stream_js_1.applyFileMutation)(event, localRoot);
+                        if (typeof event.content === 'string') {
+                            const relPath = this.normalizeAgentWorkspaceRelativePath(event.path, serverWorkspaceRoot || undefined);
+                            if (relPath) {
+                                streamedFiles[relPath] = event.content;
+                            }
+                        }
+                    }
+                }
                 // Empty workspace guard: if the remote agent lists its root
                 // and finds nothing while our local workspace has files, the
                 // workspace was not hydrated. Abort early with a clear error

package/dist/utils/tools.d.ts

@@ -74,7 +74,7 @@ export declare class AgenticTools {
     private static permissionsFile;
     constructor(logger: Logger, cwd: string, permissionCallback: (action: string, options?: {
         batchApproval?: boolean;
-    }) => Promise<boolean | 'batch'>, autoApprove?: boolean);
+    }) => Promise<boolean | 'batch' | 'persist'>, autoApprove?: boolean);
     /**
      * Load persistent permissions for the current project
      */

package/dist/utils/tools.js

@@ -493,6 +493,11 @@ class AgenticTools {
                 if (approved === 'batch') {
                     this.sessionApprovedTools.add(normalizedCall.tool);
                 }
+                else if (approved === 'persist') {
+                    this.sessionApprovedTools.add(normalizedCall.tool);
+                    this.savePersistentPermission(normalizedCall.tool);
+                    this.logger.info(`${normalizedCall.tool}: Saved as persistent permission`);
+                }
             }
         }
         // Execute with retry logic for applicable operations
@@ -1069,6 +1074,11 @@ class AgenticTools {
             /\bmkfs\b/i, // Format filesystems
             />\s*\/dev\/sd/i, // Writing to disk devices
             /\bdd\s+.*of=/i, // dd write operations
+            /\bnode\s+-e\b/i, // Node eval (sandbox bypass)
+            /\bnode\s+--eval\b/i, // Node eval long form
+            /\bpython3?\s+-c\b/i, // Python exec (sandbox bypass)
+            /\bruby\s+-e\b/i, // Ruby eval (sandbox bypass)
+            /\bperl\s+-e\b/i, // Perl eval (sandbox bypass)
         ];
         for (const pattern of blockedPatterns) {
             if (pattern.test(args.command)) {
@@ -1987,11 +1997,11 @@ class AgenticTools {
         // Build a focused system prompt for the sub-agent
         const systemPrompt = [
             'You are a focused sub-agent spawned to complete a specific subtask.',
-            'You have access to all standard tools (read_file, write_file, edit_file, bash, grep, list_dir, glob, git).',
+            'You have access to standard tools (read_file, write_file, edit_file, bash, grep, list_dir, glob, git). You cannot spawn sub-agents.',
             'Complete the task thoroughly and return a detailed result.',
             `Working directory: ${workingDir}`,
             '',
-            AgenticTools.getToolsForPrompt(),
+            AgenticTools.getToolsForPrompt().replace(/### task[\s\S]*?(?=###|$)/, ''), // Strip task from sub-agent
         ].join('\n');
         const messages = [
             { role: 'system', content: systemPrompt },
@@ -2059,6 +2069,7 @@ class AgenticTools {
             return this.createErrorResult(ToolErrorType.INVALID_ARGS, `Invalid edits JSON: ${parseError.message}`, 'Provide edits as a JSON array: [{"path": "file.ts", "old_text": "find", "new_text": "replace"}]');
         }
         // Validate all edits can proceed before modifying anything
+        const contentMap = new Map();
         const backups = [];
         const resolvedEdits = [];
         for (let i = 0; i < edits.length; i++) {
@@ -2073,7 +2084,13 @@ class AgenticTools {
             if (!fs.existsSync(resolvedPath)) {
                 return this.createErrorResult(ToolErrorType.FILE_NOT_FOUND, `Edit ${i}: file not found: ${edit.path}`, 'Use write_file to create new files instead.');
             }
-            const content = fs.readFileSync(resolvedPath, 'utf-8');
+            // Use contentMap to track cumulative edits to the same file
+            if (!contentMap.has(resolvedPath)) {
+                const diskContent = fs.readFileSync(resolvedPath, 'utf-8');
+                contentMap.set(resolvedPath, diskContent);
+                backups.push({ path: resolvedPath, content: diskContent });
+            }
+            const content = contentMap.get(resolvedPath);
             if (!content.includes(edit.old_text)) {
                 return this.createErrorResult(ToolErrorType.EXECUTION_FAILED, `Edit ${i}: old_text not found in ${edit.path}`, `The text to replace was not found. Use read_file to verify the file contents.`);
             }
@@ -2082,15 +2099,16 @@ class AgenticTools {
             if (matchCount > 1) {
                 return this.createErrorResult(ToolErrorType.EXECUTION_FAILED, `Edit ${i}: old_text matches ${matchCount} locations in ${edit.path}`, 'Make old_text more specific to match exactly one location. Include surrounding context.');
             }
-            backups.push({ path: resolvedPath, content });
+            // Apply edit to contentMap so subsequent edits to same file see updated content
+            contentMap.set(resolvedPath, content.replace(edit.old_text, edit.new_text));
             resolvedEdits.push({ resolvedPath, old_text: edit.old_text, new_text: edit.new_text, content });
         }
         // Apply all edits
         const applied = [];
         try {
             for (const edit of resolvedEdits) {
-                const newContent = edit.content.replace(edit.old_text, edit.new_text);
-                fs.writeFileSync(edit.resolvedPath, newContent, 'utf-8');
+                const finalContent = contentMap.get(edit.resolvedPath) || edit.content.replace(edit.old_text, edit.new_text);
+                fs.writeFileSync(edit.resolvedPath, finalContent, 'utf-8');
                 applied.push(path.relative(this.cwd, edit.resolvedPath));
             }
             // Push undo operations for all edits
@@ -2163,7 +2181,7 @@ class AgenticTools {
                         if (pattern) {
                             const basename = entry.name;
                             // Simple glob matching for extension patterns like *.ts, *.js
-                            const globPattern = pattern.replace(/\*\*/g, '').replace(/\*/g, '.*').replace(/\?/g, '.');
+                            const globPattern = pattern.replace(/\*\*\//g, '(.*/)?').replace(/\*/g, '[^/]*').replace(/\?/g, '.');
                             if (new RegExp(globPattern, 'i').test(basename) || fullPath.includes(pattern.replace(/\*/g, ''))) {
                                 files.push(fullPath);
                             }
@@ -2247,7 +2265,9 @@ class AgenticTools {
                     if (includePattern)
                         rgArgs.push('-g', includePattern);
                     rgArgs.push('--', query, this.cwd);
-                    const rgOutput = (0, child_process_1.execSync)(`rg ${rgArgs.map(a => `'${a}'`).join(' ')}`, {
+                    const isWin = process.platform === 'win32';
+                    const quote = (s) => isWin ? `"${s}"` : `'${s}'`;
+                    const rgOutput = (0, child_process_1.execSync)(`rg ${rgArgs.map(a => quote(a)).join(' ')}`, {
                         encoding: 'utf-8',
                         timeout: 15000,
                         maxBuffer: 5 * 1024 * 1024,

package/dist/utils/workspace-stream.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Workspace Stream — Real-time bidirectional file sync between CLI and V3.
+ *
+ * Architecture:
+ *   1. WorkspaceWatcher — chokidar-based file watcher that detects local changes
+ *      and pushes them to V3 via WebSocket.
+ *   2. MutationApplier — receives file_mutation events from V3's SSE stream
+ *      and applies them to the local workspace IN REAL TIME (not at completion).
+ *   3. WorkspaceWSClient — WebSocket client connected to V3's /ws/workspace
+ *      for bidirectional file sync outside the SSE stream.
+ *
+ * Event types (V3 → CLI via SSE):
+ *   {"type": "file_mutation", "path": "rel/path", "content": "...", "action": "write"|"edit", "tool": "write_file"|"edit_file"}
+ *
+ * Event types (CLI → V3 via /ws/workspace):
+ *   {"type": "bind", "context_id": "...", "workspace_root": "..."}
+ *   {"type": "file_sync", "path": "rel/path", "content": "...", "action": "write"|"delete"}
+ *   {"type": "file_batch", "files": [{path, content}, ...]}
+ */
+/**
+ * Apply a file_mutation event from V3's SSE stream to the local workspace.
+ * Call this from the SSE event handler for real-time file application.
+ */
+export declare function applyFileMutation(event: {
+    type: string;
+    path: string;
+    content: string;
+    action: string;
+}, workspaceRoot: string): boolean;
+export interface WatcherOptions {
+    workspaceRoot: string;
+    onFileChange?: (relativePath: string, content: string | null, action: 'write' | 'delete') => void;
+}
+export declare class WorkspaceWatcher {
+    private watcher;
+    private workspaceRoot;
+    private onFileChange;
+    private _ready;
+    constructor(options: WatcherOptions);
+    start(): void;
+    stop(): void;
+    get isReady(): boolean;
+    private _handleChange;
+}
+export interface WorkspaceWSOptions {
+    serverUrl: string;
+    token: string;
+    contextId: string;
+    workspaceRoot: string;
+    onMutation?: (event: any) => void;
+}
+export declare class WorkspaceWSClient {
+    private ws;
+    private opts;
+    private reconnectTimer;
+    private _connected;
+    private _queue;
+    private _maxQueue;
+    constructor(opts: WorkspaceWSOptions);
+    connect(): void;
+    disconnect(): void;
+    /**
+     * Push a local file change to V3's workspace.
+     */
+    syncFile(relativePath: string, content: string | null, action: 'write' | 'delete'): void;
+    /**
+     * Push multiple files at once.
+     */
+    syncBatch(files: Array<{
+        path: string;
+        content: string;
+    }>): void;
+    get isConnected(): boolean;
+    private _send;
+}

package/dist/utils/workspace-stream.js

@@ -0,0 +1,301 @@
+"use strict";
+/**
+ * Workspace Stream — Real-time bidirectional file sync between CLI and V3.
+ *
+ * Architecture:
+ *   1. WorkspaceWatcher — chokidar-based file watcher that detects local changes
+ *      and pushes them to V3 via WebSocket.
+ *   2. MutationApplier — receives file_mutation events from V3's SSE stream
+ *      and applies them to the local workspace IN REAL TIME (not at completion).
+ *   3. WorkspaceWSClient — WebSocket client connected to V3's /ws/workspace
+ *      for bidirectional file sync outside the SSE stream.
+ *
+ * Event types (V3 → CLI via SSE):
+ *   {"type": "file_mutation", "path": "rel/path", "content": "...", "action": "write"|"edit", "tool": "write_file"|"edit_file"}
+ *
+ * Event types (CLI → V3 via /ws/workspace):
+ *   {"type": "bind", "context_id": "...", "workspace_root": "..."}
+ *   {"type": "file_sync", "path": "rel/path", "content": "...", "action": "write"|"delete"}
+ *   {"type": "file_batch", "files": [{path, content}, ...]}
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceWSClient = exports.WorkspaceWatcher = void 0;
+exports.applyFileMutation = applyFileMutation;
+const chokidar = __importStar(require("chokidar"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ws_1 = __importDefault(require("ws"));
+const logger_js_1 = require("./logger.js");
+const logger = new logger_js_1.Logger();
+logger.setVerbose(!!process.env.VIGTHORIA_DEBUG);
+// Files/dirs to ignore in the watcher
+const IGNORE_PATTERNS = [
+    '**/node_modules/**',
+    '**/.git/**',
+    '**/__pycache__/**',
+    '**/.venv/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/.next/**',
+    '**/.cache/**',
+    '**/.vigthoria/**',
+    '**/coverage/**',
+    '**/*.pyc',
+];
+const BINARY_EXTENSIONS = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.ico', '.svg', '.webp', '.bmp',
+    '.mp3', '.mp4', '.wav', '.ogg', '.webm', '.avi',
+    '.zip', '.tar', '.gz', '.bz2', '.7z', '.rar',
+    '.woff', '.woff2', '.ttf', '.eot', '.otf',
+    '.pdf', '.doc', '.docx', '.xls', '.xlsx',
+    '.pyc', '.pyo', '.so', '.dll', '.exe', '.bin',
+    '.db', '.sqlite', '.sqlite3',
+]);
+const MAX_SYNC_FILE_BYTES = 500 * 1024; // 500 KB
+// ── Mutation Applier ─────────────────────────────────────────
+/**
+ * Tracks files that V3 has mutated so the watcher doesn't echo them back.
+ */
+const _v3MutatedFiles = new Set();
+const _v3MuteTimeout = 2000; // 2s mute window after V3 writes a file
+/**
+ * Apply a file_mutation event from V3's SSE stream to the local workspace.
+ * Call this from the SSE event handler for real-time file application.
+ */
+function applyFileMutation(event, workspaceRoot) {
+    if (event.type !== 'file_mutation')
+        return false;
+    if (!event.path || !workspaceRoot)
+        return false;
+    const absPath = path_1.default.resolve(workspaceRoot, event.path);
+    // Safety: ensure the resolved path is within the workspace
+    if (!absPath.startsWith(path_1.default.resolve(workspaceRoot) + path_1.default.sep) && absPath !== path_1.default.resolve(workspaceRoot)) {
+        logger.warn(`Refusing to apply mutation outside workspace: ${event.path}`);
+        return false;
+    }
+    try {
+        if (event.action === 'delete') {
+            if (fs_1.default.existsSync(absPath)) {
+                fs_1.default.unlinkSync(absPath);
+                logger.debug(`Deleted: ${event.path}`);
+            }
+        }
+        else if (typeof event.content === 'string') {
+            fs_1.default.mkdirSync(path_1.default.dirname(absPath), { recursive: true });
+            fs_1.default.writeFileSync(absPath, event.content, 'utf8');
+            // Mute the watcher for this file to prevent echo
+            _v3MutatedFiles.add(absPath);
+            setTimeout(() => _v3MutatedFiles.delete(absPath), _v3MuteTimeout);
+            logger.debug(`Applied: ${event.path} (${event.action})`);
+        }
+        return true;
+    }
+    catch (err) {
+        logger.error(`Failed to apply mutation for ${event.path}: ${err}`);
+        return false;
+    }
+}
+class WorkspaceWatcher {
+    watcher = null;
+    workspaceRoot;
+    onFileChange;
+    _ready = false;
+    constructor(options) {
+        this.workspaceRoot = path_1.default.resolve(options.workspaceRoot);
+        this.onFileChange = options.onFileChange;
+    }
+    start() {
+        if (this.watcher)
+            return;
+        this.watcher = chokidar.watch(this.workspaceRoot, {
+            ignored: IGNORE_PATTERNS,
+            persistent: true,
+            ignoreInitial: true,
+            awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 },
+        });
+        this.watcher
+            .on('ready', () => {
+            this._ready = true;
+            logger.debug('Workspace watcher ready');
+        })
+            .on('add', (filePath) => this._handleChange(filePath, 'write'))
+            .on('change', (filePath) => this._handleChange(filePath, 'write'))
+            .on('unlink', (filePath) => this._handleChange(filePath, 'delete'));
+    }
+    stop() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+            this._ready = false;
+        }
+    }
+    get isReady() {
+        return this._ready;
+    }
+    _handleChange(filePath, action) {
+        // Skip if this file was just written by V3 (echo prevention)
+        if (_v3MutatedFiles.has(filePath))
+            return;
+        const ext = path_1.default.extname(filePath).toLowerCase();
+        if (BINARY_EXTENSIONS.has(ext))
+            return;
+        const relativePath = path_1.default.relative(this.workspaceRoot, filePath);
+        if (relativePath.startsWith('..'))
+            return; // safety
+        if (action === 'delete') {
+            this.onFileChange?.(relativePath, null, 'delete');
+            return;
+        }
+        try {
+            const stat = fs_1.default.statSync(filePath);
+            if (stat.size > MAX_SYNC_FILE_BYTES)
+                return;
+            const content = fs_1.default.readFileSync(filePath, 'utf8');
+            this.onFileChange?.(relativePath, content, 'write');
+        }
+        catch {
+            // File might have been deleted between event and read
+        }
+    }
+}
+exports.WorkspaceWatcher = WorkspaceWatcher;
+class WorkspaceWSClient {
+    ws = null;
+    opts;
+    reconnectTimer = null;
+    _connected = false;
+    _queue = [];
+    _maxQueue = 200;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    connect() {
+        if (this.ws)
+            return;
+        const url = `${this.opts.serverUrl}/ws/workspace?token=${encodeURIComponent(this.opts.token)}`;
+        this.ws = new ws_1.default(url);
+        this.ws.on('open', () => {
+            this._connected = true;
+            // Bind to workspace
+            this._send({
+                type: 'bind',
+                context_id: this.opts.contextId,
+                workspace_root: this.opts.workspaceRoot,
+            });
+            // Flush queued messages
+            while (this._queue.length > 0) {
+                const msg = this._queue.shift();
+                this._send(msg);
+            }
+            logger.debug('WS workspace connected');
+        });
+        this.ws.on('message', (data) => {
+            try {
+                const event = JSON.parse(data.toString());
+                if (event.type === 'file_mutation') {
+                    this.opts.onMutation?.(event);
+                }
+            }
+            catch {
+                // ignore parse errors
+            }
+        });
+        this.ws.on('close', () => {
+            this._connected = false;
+            this.ws = null;
+            // Auto-reconnect after 3s
+            this.reconnectTimer = setTimeout(() => this.connect(), 3000);
+        });
+        this.ws.on('error', () => {
+            // error handler to prevent crash, close event handles reconnect
+        });
+    }
+    disconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this._connected = false;
+    }
+    /**
+     * Push a local file change to V3's workspace.
+     */
+    syncFile(relativePath, content, action) {
+        const msg = {
+            type: 'file_sync',
+            path: relativePath,
+            content: content || '',
+            action,
+        };
+        if (this._connected) {
+            this._send(msg);
+        }
+        else if (this._queue.length < this._maxQueue) {
+            this._queue.push(msg);
+        }
+    }
+    /**
+     * Push multiple files at once.
+     */
+    syncBatch(files) {
+        const msg = { type: 'file_batch', files };
+        if (this._connected) {
+            this._send(msg);
+        }
+        else if (this._queue.length < this._maxQueue) {
+            this._queue.push(msg);
+        }
+    }
+    get isConnected() {
+        return this._connected;
+    }
+    _send(msg) {
+        try {
+            this.ws?.send(JSON.stringify(msg));
+        }
+        catch {
+            // connection lost
+        }
+    }
+}
+exports.WorkspaceWSClient = WorkspaceWSClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.6.52",
+  "version": "1.6.54",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "main": "dist/index.js",
   "files": [
@@ -61,6 +61,7 @@
     "archiver": "^6.0.1",
     "axios": "^1.6.0",
     "chalk": "^5.3.0",
+    "chokidar": "^5.0.0",
     "commander": "^11.1.0",
     "conf": "^12.0.0",
     "diff": "^5.1.0",
@@ -86,4 +87,4 @@
   "engines": {
     "node": ">=18.0.0"
   }
-}
+}