vigthoria-cli 1.6.51 → 1.6.52

package/dist/commands/chat.js

@@ -1644,6 +1644,7 @@ class ChatCommand {
                 : 'Interactive Chat';
         this.logger.section(this.workflowTarget ? `${chatTitle} Via Workflow Target` : chatTitle);
         console.log(chalk_1.default.gray('Type /help for commands. Type /exit to quit.'));
+        console.log(chalk_1.default.gray('Multi-line: end a line with \\ or start a block with {{{ and end with }}}'));
         if (this.workflowTarget) {
             console.log(chalk_1.default.gray(`Workflow target: ${this.workflowTarget}`));
         }
@@ -1651,10 +1652,40 @@ class ChatCommand {
             input: process.stdin,
             output: process.stdout,
         });
-        while (true) {
-            const input = await new Promise((resolve) => {
+        // Multi-line input helper
+        const readMultiLineInput = async () => {
+            const lines = [];
+            let firstLine = await new Promise((resolve) => {
                 rl.question(chalk_1.default.blue('> '), resolve);
             });
+            // Check for {{{ block mode
+            if (firstLine.trim() === '{{{' || firstLine.trim().endsWith('{{{')) {
+                if (firstLine.trim() !== '{{{') {
+                    lines.push(firstLine.trim().replace(/\{\{\{$/, '').trim());
+                }
+                console.log(chalk_1.default.gray('  (multi-line mode: type }}} on its own line to finish)'));
+                while (true) {
+                    const line = await new Promise((resolve) => {
+                        rl.question(chalk_1.default.gray('  '), resolve);
+                    });
+                    if (line.trim() === '}}}')
+                        break;
+                    lines.push(line);
+                }
+                return lines.join('\n');
+            }
+            // Check for backslash continuation
+            while (firstLine.endsWith('\\')) {
+                lines.push(firstLine.slice(0, -1));
+                firstLine = await new Promise((resolve) => {
+                    rl.question(chalk_1.default.gray('  '), resolve);
+                });
+            }
+            lines.push(firstLine);
+            return lines.join('\n');
+        };
+        while (true) {
+            const input = await readMultiLineInput();
             const trimmed = input.trim();
             if (!trimmed) {
                 continue;
@@ -2193,7 +2224,7 @@ class ChatCommand {
         // Matches "Tool <name> succeeded/FAILED." through the next blank line,
         // next tool header, or end-of-string.  The DOTALL-like [\s\S]*? is
         // terminated by whichever boundary comes first.
-        cleaned = cleaned.replace(/Tool (?:read_file|grep|list_dir|glob|bash|write_file|edit_file|ssh_exec) (?:succeeded|FAILED)\.[\s\S]*?(?=\nTool |\n\n|$)/g, '');
+        cleaned = cleaned.replace(/Tool (?:read_file|grep|list_dir|glob|bash|write_file|edit_file|ssh_exec|task|multi_edit|codebase_search) (?:succeeded|FAILED)\.[\s\S]*?(?=\nTool |\n\n|$)/g, '');
         // ── Phase 2: Strip echoed system-prompt / grounding lines ──
         const contaminationPatterns = [
             /^\[Agent recovered from backend failure[^\]]*\]\s*/m,
@@ -2382,10 +2413,10 @@ class ChatCommand {
             if (finalStatus === 'search_failed') {
                 this.agentToolEvidence.searchFailed += 1;
             }
-            else if (/^(read_file|list_dir|glob|grep|git|repo|fetch_url)$/.test(call.tool)) {
+            else if (/^(read_file|list_dir|glob|grep|git|repo|fetch_url|codebase_search)$/.test(call.tool)) {
                 this.agentToolEvidence.discovery += 1;
             }
-            else if (/^(write_file|edit_file|bash|ssh_exec)$/.test(call.tool)) {
+            else if (/^(write_file|edit_file|bash|ssh_exec|multi_edit|task)$/.test(call.tool)) {
                 this.agentToolEvidence.mutation += 1;
             }
         }

package/dist/utils/logger.d.ts

@@ -59,6 +59,7 @@ export declare class Logger {
     user(message: string): void;
     code(code: string, language?: string): void;
     diff(added: string[], removed: string[]): void;
+    unifiedDiff(filePath: string, oldText: string, newText: string): void;
     section(title: string): void;
     progress(message: string): void;
     clearLine(): void;

package/dist/utils/logger.js

@@ -107,11 +107,61 @@ class Logger {
         console.log(chalk_1.default.yellow(code));
         console.log(chalk_1.default.gray(exports.CH.hLine.repeat(60)));
     }
-    // Diff output
+    // Diff output - enhanced with syntax-highlighted unified diff
     diff(added, removed) {
         removed.forEach(line => console.log(chalk_1.default.red(`- ${line}`)));
         added.forEach(line => console.log(chalk_1.default.green(`+ ${line}`)));
     }
+    // Unified diff display with file context
+    unifiedDiff(filePath, oldText, newText) {
+        const oldLines = oldText.split('\n');
+        const newLines = newText.split('\n');
+        const fileName = filePath.split('/').pop() || filePath;
+        console.log(chalk_1.default.bold.white(`\n  ${exports.CH.hLine.repeat(3)} ${fileName} ${exports.CH.hLine.repeat(Math.max(1, 50 - fileName.length))}`));
+        console.log(chalk_1.default.gray(`  --- a/${filePath}`));
+        console.log(chalk_1.default.gray(`  +++ b/${filePath}`));
+        // Find diff ranges with context
+        const contextLines = 3;
+        let i = 0;
+        let j = 0;
+        while (i < oldLines.length || j < newLines.length) {
+            if (i < oldLines.length && j < newLines.length && oldLines[i] === newLines[j]) {
+                i++;
+                j++;
+                continue;
+            }
+            // Found a difference - show context
+            const startOld = Math.max(0, i - contextLines);
+            const startNew = Math.max(0, j - contextLines);
+            // Context before
+            for (let c = startOld; c < i; c++) {
+                console.log(chalk_1.default.gray(`  ${String(c + 1).padStart(4)} │ ${oldLines[c] || ''}`));
+            }
+            // Removed lines
+            while (i < oldLines.length && (j >= newLines.length || oldLines[i] !== newLines[j])) {
+                console.log(chalk_1.default.red(`  ${String(i + 1).padStart(4)} │-${oldLines[i]}`));
+                i++;
+                if (j < newLines.length && (i >= oldLines.length || oldLines[i] === newLines[j]))
+                    break;
+            }
+            // Added lines
+            while (j < newLines.length && (i >= oldLines.length || oldLines[i] !== newLines[j])) {
+                console.log(chalk_1.default.green(`  ${String(j + 1).padStart(4)} │+${newLines[j]}`));
+                j++;
+                if (i < oldLines.length && oldLines[i] === newLines[j])
+                    break;
+            }
+            // Context after
+            const endCtx = Math.min(oldLines.length, i + contextLines);
+            for (let c = i; c < endCtx && c < oldLines.length && j < newLines.length && oldLines[c] === newLines[j]; c++) {
+                console.log(chalk_1.default.gray(`  ${String(c + 1).padStart(4)} │ ${oldLines[c] || ''}`));
+                i = c + 1;
+                j++;
+            }
+            console.log(chalk_1.default.gray(`  ${exports.CH.hLine.repeat(55)}`));
+        }
+        console.log();
+    }
     // Section header
     section(title) {
         console.log();

package/dist/utils/tools.d.ts

@@ -71,9 +71,22 @@ export declare class AgenticTools {
     private maxUndoStack;
     private retryConfig;
     private sessionApprovedTools;
+    private static permissionsFile;
     constructor(logger: Logger, cwd: string, permissionCallback: (action: string, options?: {
         batchApproval?: boolean;
     }) => Promise<boolean | 'batch'>, autoApprove?: boolean);
+    /**
+     * Load persistent permissions for the current project
+     */
+    private loadPersistentPermissions;
+    /**
+     * Save a persistent permission for a tool in the current project
+     */
+    private savePersistentPermission;
+    /**
+     * Check if a tool has persistent permission for the current project
+     */
+    private hasPersistentPermission;
     /**
      * Clear session-approved tools (call this at the start of each new AI turn)
      */
@@ -194,6 +207,9 @@ export declare class AgenticTools {
      * Check if a path is within the allowed workspace
      */
     private isPathWithinWorkspace;
+    private task;
+    private multiEdit;
+    private codebaseSearch;
     /**
      * Parse tool calls from AI response (Vigthoria Agent format)
      * Enhanced to handle various AI output formats including malformed JSON

package/dist/utils/tools.js

@@ -102,6 +102,19 @@ const TOOL_ARG_ALIASES = {
         command: ['cmd', 'script'],
         host: ['server'],
     },
+    task: {
+        description: ['prompt', 'task', 'query', 'instructions'],
+        working_dir: ['cwd', 'dir', 'directory', 'workDir'],
+    },
+    multi_edit: {
+        edits: ['changes', 'operations', 'replacements'],
+    },
+    codebase_search: {
+        query: ['search', 'pattern', 'text', 'symbol'],
+        scope: ['type', 'mode'],
+        include: ['includePattern', 'filePattern', 'glob'],
+        max_results: ['limit', 'maxResults', 'count'],
+    },
 };
 // Error types for better handling
 var ToolErrorType;
@@ -129,12 +142,59 @@ class AgenticTools {
     };
     // Session-based tool approvals - remembers which tools user approved for this turn
     sessionApprovedTools = new Set();
+    // Persistent permissions - tool allowlists per project
+    static permissionsFile = path.join(process.env.HOME || process.env.USERPROFILE || '~', '.vigthoria', 'permissions.json');
     constructor(logger, cwd, permissionCallback, autoApprove = false) {
         this.logger = logger;
         this.cwd = cwd;
         this.permissionCallback = permissionCallback;
         this.autoApprove = autoApprove;
     }
+    /**
+     * Load persistent permissions for the current project
+     */
+    loadPersistentPermissions() {
+        try {
+            if (fs.existsSync(AgenticTools.permissionsFile)) {
+                return JSON.parse(fs.readFileSync(AgenticTools.permissionsFile, 'utf-8'));
+            }
+        }
+        catch {
+            // Corrupted file - ignore
+        }
+        return {};
+    }
+    /**
+     * Save a persistent permission for a tool in the current project
+     */
+    savePersistentPermission(toolName) {
+        const permissions = this.loadPersistentPermissions();
+        const projectKey = this.cwd;
+        if (!permissions[projectKey]) {
+            permissions[projectKey] = { tools: [], updatedAt: new Date().toISOString() };
+        }
+        if (!permissions[projectKey].tools.includes(toolName)) {
+            permissions[projectKey].tools.push(toolName);
+            permissions[projectKey].updatedAt = new Date().toISOString();
+        }
+        try {
+            const dir = path.dirname(AgenticTools.permissionsFile);
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(AgenticTools.permissionsFile, JSON.stringify(permissions, null, 2), 'utf-8');
+        }
+        catch {
+            // Non-critical - permission won't persist
+        }
+    }
+    /**
+     * Check if a tool has persistent permission for the current project
+     */
+    hasPersistentPermission(toolName) {
+        const permissions = this.loadPersistentPermissions();
+        const projectKey = this.cwd;
+        return permissions[projectKey]?.tools?.includes(toolName) || false;
+    }
     /**
      * Clear session-approved tools (call this at the start of each new AI turn)
      */
@@ -351,6 +411,43 @@ class AgenticTools {
                 riskLevel: 'high',
                 category: 'execute',
             },
+            {
+                name: 'task',
+                description: 'Launch an independent sub-agent to handle a complex subtask. The sub-agent has its own context and tool access, runs autonomously, and returns a single result. Use this to parallelize work or delegate research.',
+                parameters: [
+                    { name: 'description', description: 'A detailed description of the subtask for the sub-agent to perform', required: true },
+                    { name: 'working_dir', description: 'Working directory for the sub-agent (relative to project root)', required: false },
+                ],
+                requiresPermission: true,
+                dangerous: false,
+                riskLevel: 'medium',
+                category: 'execute',
+            },
+            {
+                name: 'multi_edit',
+                description: 'Apply multiple file edits atomically. All edits succeed or all are rolled back. Each edit specifies a file, old_text to find, and new_text to replace it with.',
+                parameters: [
+                    { name: 'edits', description: 'JSON array of edits: [{"path": "file.ts", "old_text": "find this", "new_text": "replace with"}]', required: true },
+                ],
+                requiresPermission: true,
+                dangerous: false,
+                riskLevel: 'medium',
+                category: 'write',
+            },
+            {
+                name: 'codebase_search',
+                description: 'Perform a deep semantic search across the entire codebase. Searches file names, symbol names (functions, classes, variables), and content across all files - not limited to the workspace snapshot. Use for large projects.',
+                parameters: [
+                    { name: 'query', description: 'Search query - can be a symbol name, concept, or natural language description', required: true },
+                    { name: 'scope', description: 'Search scope: "symbols" (functions/classes), "files" (filenames), "content" (full-text), or "all" (default)', required: false },
+                    { name: 'include', description: 'File pattern to include (e.g., "*.ts", "src/**/*.js")', required: false },
+                    { name: 'max_results', description: 'Maximum results to return (default: 30)', required: false },
+                ],
+                requiresPermission: false,
+                dangerous: false,
+                riskLevel: 'low',
+                category: 'search',
+            },
         ];
     }
     /**
@@ -373,8 +470,11 @@ class AgenticTools {
         }
         // Check permission for dangerous/modifying actions
         if (tool.requiresPermission && !this.autoApprove) {
-            // Check if this tool was already approved for this session/turn
-            if (this.sessionApprovedTools.has(normalizedCall.tool)) {
+            // Check persistent permissions first (project-scoped), then session
+            if (this.hasPersistentPermission(normalizedCall.tool)) {
+                this.logger.info(`${call.tool}: Auto-approved (persistent)`);
+            }
+            else if (this.sessionApprovedTools.has(normalizedCall.tool)) {
                 // Already approved - skip permission prompt
                 this.logger.info(`${call.tool}: Auto-approved (batch)`);
             }
@@ -387,8 +487,9 @@ class AgenticTools {
                         canRetry: true,
                     };
                 }
-                // Only add to session approvals if user chose 'batch' (typed 'a')
-                // 'y' or 'yes' only approves this single request
+                // 'batch' (typed 'a') = approve for this session
+                // 'persist' (typed 'p') = approve permanently for this project
+                // 'y' or 'yes' = approve this single request only
                 if (approved === 'batch') {
                     this.sessionApprovedTools.add(normalizedCall.tool);
                 }
@@ -497,6 +598,12 @@ class AgenticTools {
                 return this.fetchUrl(call.args);
             case 'ssh_exec':
                 return this.sshExec(call.args);
+            case 'task':
+                return this.task(call.args);
+            case 'multi_edit':
+                return this.multiEdit(call.args);
+            case 'codebase_search':
+                return this.codebaseSearch(call.args);
             default:
                 return this.createErrorResult(ToolErrorType.INVALID_ARGS, `Tool not implemented: ${call.tool}`);
         }
@@ -772,6 +879,8 @@ class AgenticTools {
             if (this.undoStack.length > 50) {
                 this.undoStack.shift();
             }
+            // Show syntax-highlighted diff
+            this.logger.unifiedDiff(args.path, args.old_text, args.new_text);
             return {
                 success: true,
                 output: `File edited: ${args.path}`,
@@ -921,20 +1030,45 @@ class AgenticTools {
             }
         }
         // SECURITY: Block dangerous commands that could access outside workspace
+        // HARDENED: Protects Vigthoria ecosystem, server config, and system files
         const blockedPatterns = [
+            // === System file access ===
             /\bcat\s+\/etc\//i, // Reading system files
             /\bcat\s+\/var\/(?!log)/i, // Reading /var/ except logs
             /\bcat\s+\/root\//i, // Reading root home
             /\bcat\s+\/home\/[^\/]+\/\.[^\/]/i, // Reading hidden files in home dirs
             /\bcat\s+~\/\./i, // Reading hidden files via ~
             /\bcd\s+(\/etc|\/var\/www|\/root|\/home)/i, // CD to sensitive dirs
+            // === Destructive operations ===
             /\brm\s+-rf?\s+\//i, // Dangerous rm commands
+            /\brm\s+-rf?\s+\.\.\//i, // rm going up directories
+            /\brm\s+-rf?\s+~\//i, // rm in home directory
             /\b(curl|wget).*\|\s*(bash|sh)\b/i, // Downloading and executing scripts
             /\bsudo\b/i, // Sudo commands
             /\bsu\s+-/i, // Su to root
             /\bchmod\s+[0-7]*777/i, // World-writable permissions
             /\/(var\/www|opt)\/[a-z]+-?(database|models|coder|mcp|operator|voice|music)/i, // Vigthoria ecosystem
             /vigthoria-(models|database|mcp|operator|voice|music)/i, // Vigthoria project names
+            // === Vigthoria Server Protection (CRITICAL) ===
+            /\/var\/www\/(?!$)/i, // Block ANY access to /var/www/* (server web root)
+            /\/etc\/(caddy|nginx|apache|systemd|pm2)/i, // Server config files
+            /\/etc\/(passwd|shadow|group|sudoers)/i, // System auth files
+            /\b(systemctl|service)\s+(start|stop|restart|enable|disable|reload)/i, // Service control
+            /\bpm2\s+(start|stop|restart|delete|kill|flush)/i, // PM2 process management
+            /\bjournalctl\b/i, // System logs access
+            /\bnpm\s+publish\b/i, // Block npm publish from agent
+            /\bdocker\s+(rm|kill|stop|exec|run)/i, // Docker container manipulation
+            /\biptables\b/i, // Firewall rules
+            /\bufw\s+(allow|deny|delete|disable)/i, // UFW firewall
+            /\bssh\s+.*vigthoria/i, // SSH to Vigthoria servers
+            /\bssh\s+.*78\.46\.154/i, // SSH to known Vigthoria IP
+            /\.env\b/i, // Environment files (may contain secrets)
+            /\bprivate[_-]?key|secret[_-]?key|api[_-]?key|auth[_-]?token/i, // Sensitive variable patterns in commands
+            /\bcrontab\b/i, // Cron manipulation
+            /\bmount\s/i, // Mount filesystems
+            /\bmkfs\b/i, // Format filesystems
+            />\s*\/dev\/sd/i, // Writing to disk devices
+            /\bdd\s+.*of=/i, // dd write operations
         ];
         for (const pattern of blockedPatterns) {
             if (pattern.test(args.command)) {
@@ -1836,6 +1970,347 @@ class AgenticTools {
         const workspaceRoot = path.normalize(this.cwd);
         return resolvedPath.startsWith(workspaceRoot + path.sep) || resolvedPath === workspaceRoot;
     }
+    // ═══════════════════════════════════════════════════════════════
+    // TASK (Sub-Agent) Tool
+    // ═══════════════════════════════════════════════════════════════
+    async task(args) {
+        const description = args.description;
+        const workingDir = args.working_dir
+            ? this.resolvePath(args.working_dir)
+            : this.cwd;
+        if (!this.isPathWithinWorkspace(workingDir)) {
+            return this.createErrorResult(ToolErrorType.PERMISSION_DENIED, 'Sub-agent working directory must be within the project workspace', 'Provide a relative path within the current project.');
+        }
+        this.logger.info(`Spawning sub-agent: ${description.substring(0, 80)}...`);
+        // Create a scoped sub-agent with its own tool instance
+        const subTools = new AgenticTools(this.logger, workingDir, this.permissionCallback, this.autoApprove);
+        // 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).',
+            'Complete the task thoroughly and return a detailed result.',
+            `Working directory: ${workingDir}`,
+            '',
+            AgenticTools.getToolsForPrompt(),
+        ].join('\n');
+        const messages = [
+            { role: 'system', content: systemPrompt },
+            { role: 'user', content: description },
+        ];
+        const maxSubTurns = 8;
+        const results = [];
+        try {
+            for (let turn = 0; turn < maxSubTurns; turn++) {
+                // Import api dynamically to avoid circular dependency
+                const { APIClient } = await import('./api.js');
+                const { Config } = await import('./config.js');
+                const config = new Config();
+                const api = new APIClient(config, this.logger);
+                const response = await api.chat(messages, 'code');
+                const assistantMessage = response.message || '';
+                messages.push({ role: 'assistant', content: assistantMessage });
+                const toolCalls = AgenticTools.parseToolCalls(assistantMessage);
+                if (toolCalls.length === 0) {
+                    // Sub-agent finished - extract the final answer
+                    const finalAnswer = assistantMessage
+                        .replace(/```tool[\s\S]*?```/g, '')
+                        .replace(/<tool_call>[\s\S]*?<\/tool_call>/g, '')
+                        .trim();
+                    results.push(finalAnswer);
+                    break;
+                }
+                // Execute each tool call
+                for (const call of toolCalls) {
+                    const result = await subTools.execute(call);
+                    const summary = `Tool ${call.tool} ${result.success ? 'succeeded' : 'FAILED'}.` +
+                        (call.args.path ? `\nFile: ${call.args.path}` : '') +
+                        (result.output ? `\nOutput:\n${result.output.substring(0, 4000)}` : '') +
+                        (result.error ? `\nError: ${result.error}` : '');
+                    messages.push({ role: 'system', content: summary });
+                    results.push(`[${call.tool}] ${result.success ? '✓' : '✗'}`);
+                }
+                messages.push({
+                    role: 'system',
+                    content: 'Continue with your task. Use more tools if needed, or provide your final answer.',
+                });
+            }
+            return {
+                success: true,
+                output: results.join('\n'),
+                metadata: { subAgentTurns: results.length, workingDir },
+            };
+        }
+        catch (error) {
+            return this.createErrorResult(ToolErrorType.EXECUTION_FAILED, `Sub-agent failed: ${error.message}`, 'The sub-agent encountered an error. Try simplifying the task or running it directly.');
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // MULTI_EDIT Tool - Atomic multi-file edits with rollback
+    // ═══════════════════════════════════════════════════════════════
+    async multiEdit(args) {
+        let edits;
+        try {
+            edits = JSON.parse(args.edits);
+            if (!Array.isArray(edits) || edits.length === 0) {
+                throw new Error('edits must be a non-empty array');
+            }
+        }
+        catch (parseError) {
+            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 backups = [];
+        const resolvedEdits = [];
+        for (let i = 0; i < edits.length; i++) {
+            const edit = edits[i];
+            if (!edit.path || typeof edit.old_text !== 'string' || typeof edit.new_text !== 'string') {
+                return this.createErrorResult(ToolErrorType.INVALID_ARGS, `Edit ${i}: missing required fields (path, old_text, new_text)`, 'Each edit must have path, old_text, and new_text fields.');
+            }
+            const resolvedPath = this.resolvePath(edit.path);
+            if (!this.isPathWithinWorkspace(resolvedPath)) {
+                return this.createErrorResult(ToolErrorType.PERMISSION_DENIED, `Edit ${i}: path "${edit.path}" is outside workspace`, 'All files must be within the current project.');
+            }
+            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');
+            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.`);
+            }
+            // Check for multiple matches
+            const matchCount = content.split(edit.old_text).length - 1;
+            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 });
+            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');
+                applied.push(path.relative(this.cwd, edit.resolvedPath));
+            }
+            // Push undo operations for all edits
+            for (const backup of backups) {
+                this.undoStack.push({
+                    id: `multi_edit_${Date.now()}_${path.basename(backup.path)}`,
+                    tool: 'multi_edit',
+                    timestamp: Date.now(),
+                    filePath: backup.path,
+                    originalContent: backup.content,
+                    description: `multi_edit: ${path.relative(this.cwd, backup.path)}`,
+                });
+            }
+            return {
+                success: true,
+                output: `${logger_js_1.CH.success} Atomically edited ${applied.length} file(s):\n${applied.map(f => `  ✓ ${f}`).join('\n')}`,
+                undoable: true,
+                metadata: { filesEdited: applied.length, files: applied },
+            };
+        }
+        catch (error) {
+            // ROLLBACK: Restore all files from backups
+            for (const backup of backups) {
+                try {
+                    fs.writeFileSync(backup.path, backup.content, 'utf-8');
+                }
+                catch {
+                    // Best-effort rollback
+                }
+            }
+            return this.createErrorResult(ToolErrorType.EXECUTION_FAILED, `Multi-edit failed, all changes rolled back: ${error.message}`, 'Check file permissions and disk space.');
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // CODEBASE_SEARCH Tool - Deep indexed codebase search
+    // ═══════════════════════════════════════════════════════════════
+    async codebaseSearch(args) {
+        const query = args.query;
+        const scope = args.scope || 'all';
+        const includePattern = args.include || '';
+        const maxResults = Math.min(parseInt(args.max_results || '30', 10), 100);
+        const results = [];
+        const seen = new Set();
+        // Helper: collect files recursively respecting gitignore-like patterns
+        const collectFiles = (dir, pattern) => {
+            const files = [];
+            const ignorePatterns = [
+                'node_modules', '.git', 'dist', 'build', '.next', '__pycache__',
+                '.venv', 'venv', '.tox', 'coverage', '.nyc_output', '.cache',
+                'vendor', 'target', 'bin', 'obj', '.svn', '.hg',
+            ];
+            const walk = (currentDir, depth) => {
+                if (depth > 12)
+                    return; // Prevent infinite recursion
+                let entries;
+                try {
+                    entries = fs.readdirSync(currentDir, { withFileTypes: true });
+                }
+                catch {
+                    return;
+                }
+                for (const entry of entries) {
+                    if (ignorePatterns.includes(entry.name) || entry.name.startsWith('.'))
+                        continue;
+                    const fullPath = path.join(currentDir, entry.name);
+                    if (entry.isDirectory()) {
+                        walk(fullPath, depth + 1);
+                    }
+                    else if (entry.isFile()) {
+                        if (pattern) {
+                            const basename = entry.name;
+                            // Simple glob matching for extension patterns like *.ts, *.js
+                            const globPattern = pattern.replace(/\*\*/g, '').replace(/\*/g, '.*').replace(/\?/g, '.');
+                            if (new RegExp(globPattern, 'i').test(basename) || fullPath.includes(pattern.replace(/\*/g, ''))) {
+                                files.push(fullPath);
+                            }
+                        }
+                        else {
+                            files.push(fullPath);
+                        }
+                    }
+                }
+            };
+            walk(dir, 0);
+            return files;
+        };
+        try {
+            const allFiles = collectFiles(this.cwd, includePattern || undefined);
+            // SCOPE: files - search file names/paths
+            if (scope === 'files' || scope === 'all') {
+                const queryLower = query.toLowerCase();
+                const queryParts = queryLower.split(/[\s_\-./]+/).filter(Boolean);
+                for (const filePath of allFiles) {
+                    const relativePath = path.relative(this.cwd, filePath);
+                    const filenameLower = relativePath.toLowerCase();
+                    const matches = queryParts.every(part => filenameLower.includes(part));
+                    if (matches && !seen.has(relativePath)) {
+                        seen.add(relativePath);
+                        results.push(`[file] ${relativePath}`);
+                    }
+                    if (results.length >= maxResults)
+                        break;
+                }
+            }
+            // SCOPE: symbols - extract function/class/variable definitions
+            if ((scope === 'symbols' || scope === 'all') && results.length < maxResults) {
+                const symbolRegex = /(?:(?:export\s+)?(?:async\s+)?(?:function|class|interface|type|enum|const|let|var|def|class)\s+)([A-Za-z_$][A-Za-z0-9_$]*)/g;
+                const queryLower = query.toLowerCase();
+                for (const filePath of allFiles) {
+                    if (results.length >= maxResults)
+                        break;
+                    const ext = path.extname(filePath).toLowerCase();
+                    // Only parse code files
+                    if (!['.ts', '.tsx', '.js', '.jsx', '.py', '.go', '.rs', '.java', '.rb', '.php', '.c', '.cpp', '.h', '.cs', '.swift', '.kt'].includes(ext))
+                        continue;
+                    let content;
+                    try {
+                        const stat = fs.statSync(filePath);
+                        if (stat.size > 512 * 1024)
+                            continue; // Skip files > 512KB
+                        content = fs.readFileSync(filePath, 'utf-8');
+                    }
+                    catch {
+                        continue;
+                    }
+                    let match;
+                    symbolRegex.lastIndex = 0;
+                    while ((match = symbolRegex.exec(content)) !== null) {
+                        const symbolName = match[1];
+                        if (symbolName.toLowerCase().includes(queryLower) || queryLower.includes(symbolName.toLowerCase())) {
+                            const relativePath = path.relative(this.cwd, filePath);
+                            const lineNum = content.substring(0, match.index).split('\n').length;
+                            const key = `${relativePath}:${symbolName}`;
+                            if (!seen.has(key)) {
+                                seen.add(key);
+                                results.push(`[symbol] ${symbolName} → ${relativePath}:${lineNum}`);
+                            }
+                        }
+                        if (results.length >= maxResults)
+                            break;
+                    }
+                }
+            }
+            // SCOPE: content - full-text search using ripgrep or fallback
+            if ((scope === 'content' || scope === 'all') && results.length < maxResults) {
+                try {
+                    // Try ripgrep first (fast)
+                    const rgArgs = [
+                        '-i', '--no-heading', '--line-number',
+                        '--max-count', '3',
+                        '--max-filesize', '512K',
+                        '-g', '!node_modules', '-g', '!.git', '-g', '!dist', '-g', '!build',
+                    ];
+                    if (includePattern)
+                        rgArgs.push('-g', includePattern);
+                    rgArgs.push('--', query, this.cwd);
+                    const rgOutput = (0, child_process_1.execSync)(`rg ${rgArgs.map(a => `'${a}'`).join(' ')}`, {
+                        encoding: 'utf-8',
+                        timeout: 15000,
+                        maxBuffer: 5 * 1024 * 1024,
+                    }).trim();
+                    for (const line of rgOutput.split('\n').slice(0, maxResults - results.length)) {
+                        if (!line.trim())
+                            continue;
+                        const relativeLine = line.replace(this.cwd + path.sep, '').replace(this.cwd + '/', '');
+                        const lineKey = relativeLine.substring(0, 200);
+                        if (!seen.has(lineKey)) {
+                            seen.add(lineKey);
+                            results.push(`[content] ${relativeLine}`);
+                        }
+                    }
+                }
+                catch {
+                    // Fallback: Node-native grep
+                    const queryLower = query.toLowerCase();
+                    for (const filePath of allFiles) {
+                        if (results.length >= maxResults)
+                            break;
+                        try {
+                            const stat = fs.statSync(filePath);
+                            if (stat.size > 256 * 1024)
+                                continue;
+                            const content = fs.readFileSync(filePath, 'utf-8');
+                            const lines = content.split('\n');
+                            for (let i = 0; i < lines.length; i++) {
+                                if (lines[i].toLowerCase().includes(queryLower)) {
+                                    const relativePath = path.relative(this.cwd, filePath);
+                                    const lineKey = `${relativePath}:${i + 1}`;
+                                    if (!seen.has(lineKey)) {
+                                        seen.add(lineKey);
+                                        results.push(`[content] ${relativePath}:${i + 1}: ${lines[i].trim().substring(0, 120)}`);
+                                    }
+                                    if (results.length >= maxResults)
+                                        break;
+                                }
+                            }
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                }
+            }
+            if (results.length === 0) {
+                return {
+                    success: true,
+                    output: `No results found for "${query}" in scope "${scope}".`,
+                    metadata: { searchStatus: 'search_no_matches', totalFiles: allFiles.length },
+                };
+            }
+            return {
+                success: true,
+                output: `Found ${results.length} result(s) across ${allFiles.length} files:\n\n${results.join('\n')}`,
+                metadata: { searchStatus: 'search_matches_found', resultCount: results.length, totalFiles: allFiles.length },
+            };
+        }
+        catch (error) {
+            return this.createErrorResult(ToolErrorType.EXECUTION_FAILED, `Codebase search failed: ${error.message}`, 'Try a simpler query or use grep for specific text patterns.');
+        }
+    }
     /**
      * Parse tool calls from AI response (Vigthoria Agent format)
      * Enhanced to handle various AI output formats including malformed JSON
@@ -2306,10 +2781,36 @@ To use a tool, output a JSON block in a code fence with "tool" language:
 - When comparing WEBSITES, use fetch_url - do NOT use read_file or list_dir
 
 ### Tool Names:
-- Use ONLY these exact tool names: list_dir, read_file, write_file, edit_file, bash, grep, glob, git, repo, fetch_url, ssh_exec
+- Use ONLY these exact tool names: list_dir, read_file, write_file, edit_file, bash, grep, glob, git, repo, fetch_url, ssh_exec, task, multi_edit, codebase_search
 - The JSON must be valid with double quotes for all keys and string values
 - After tool execution, you will receive results and can continue with the next step
 - Explain what you're doing before using tools
+
+### Sub-Agent Delegation (task tool):
+- Use the task tool to delegate complex subtasks to an independent sub-agent
+- The sub-agent has its own tools and context, runs autonomously, and returns results
+- Great for: parallel research, investigating side questions, exploring unfamiliar code
+- Example:
+\`\`\`tool
+{"tool": "task", "args": {"description": "Find all API endpoints in the backend and list their HTTP methods and paths"}}
+\`\`\`
+
+### Atomic Multi-File Edits (multi_edit tool):
+- Use multi_edit to apply multiple edits atomically - all succeed or all roll back
+- Pass edits as a JSON array in the edits parameter
+- Example:
+\`\`\`tool
+{"tool": "multi_edit", "args": {"edits": "[{\\"path\\": \\"src/config.ts\\", \\"old_text\\": \\"port: 3000\\", \\"new_text\\": \\"port: 8080\\"}, {\\"path\\": \\"src/server.ts\\", \\"old_text\\": \\"listen(3000)\\", \\"new_text\\": \\"listen(8080)\\"}]"}}
+\`\`\`
+
+### Deep Codebase Search (codebase_search tool):
+- Use codebase_search for large projects to find symbols, files, or content across the ENTIRE codebase
+- Not limited by workspace snapshot - searches all files recursively
+- Scopes: "symbols" (functions/classes), "files" (filenames), "content" (full-text), "all" (default)
+- Example:
+\`\`\`tool
+{"tool": "codebase_search", "args": {"query": "handleAuthentication", "scope": "symbols"}}
+\`\`\`
 `;
         return prompt;
     }

package/package.json

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