@taj-special/dravix-code 1.1.1

package/dist/services/executor.js

@@ -0,0 +1,628 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { spawn } from 'child_process';
+const SKIP_DIRS = new Set([
+    'node_modules', '.git', 'dist', 'build', '.next', 'out',
+    '.cache', 'coverage', '__pycache__', '.venv', 'venv', 'env',
+    'vendor', '.tox', '.eggs', '.mypy_cache', '.pytest_cache',
+]);
+function safeResolvePath(cwd, userPath) {
+    const base = path.resolve(cwd);
+    const full = path.resolve(cwd, userPath);
+    if (full !== base && !full.startsWith(base + path.sep))
+        return null;
+    return full;
+}
+function findFile(name, cwd) {
+    const target = path.basename(name);
+    function search(dir, depth) {
+        if (depth > 10)
+            return null;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return null;
+        }
+        // Check files first (breadth-first)
+        for (const entry of entries) {
+            if (!SKIP_DIRS.has(entry.name) && entry.isFile() && entry.name === target) {
+                return path.relative(cwd, path.join(dir, entry.name)).replace(/\\/g, '/');
+            }
+        }
+        for (const entry of entries) {
+            if (!SKIP_DIRS.has(entry.name) && entry.isDirectory()) {
+                const found = search(path.join(dir, entry.name), depth + 1);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    }
+    return search(cwd, 0);
+}
+export function computeDiff(oldText, newText) {
+    const o = oldText.split('\n');
+    const n = newText.split('\n');
+    if (o[o.length - 1] === '')
+        o.pop();
+    if (n[n.length - 1] === '')
+        n.pop();
+    const m = o.length, N = n.length;
+    // For very large files skip full LCS diff — caller should use snippet diff instead
+    if (m > 2500 || N > 2500)
+        return [];
+    // LCS-based diff (prefix dp)
+    const dp = Array.from({ length: m + 1 }, () => new Array(N + 1).fill(0));
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= N; j++) {
+            if (o[i - 1].trimEnd() === n[j - 1].trimEnd()) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+            }
+            else {
+                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+    // Traceback from (m, N)
+    const result = [];
+    let i = m, j = N;
+    while (i > 0 || j > 0) {
+        if (i > 0 && j > 0 && o[i - 1].trimEnd() === n[j - 1].trimEnd()) {
+            result.push({ kind: 'context', text: n[j - 1].trimEnd(), lineNo: j });
+            i--;
+            j--;
+        }
+        else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+            result.push({ kind: 'add', text: n[j - 1].trimEnd(), lineNo: j });
+            j--;
+        }
+        else {
+            result.push({ kind: 'remove', text: o[i - 1].trimEnd(), lineNo: i });
+            i--;
+        }
+    }
+    result.reverse();
+    // Re-order each non-context block so removes always precede adds
+    const sorted = [];
+    let idx = 0;
+    while (idx < result.length) {
+        if (result[idx].kind === 'context') {
+            sorted.push(result[idx++]);
+        }
+        else {
+            const block = [];
+            while (idx < result.length && result[idx].kind !== 'context')
+                block.push(result[idx++]);
+            for (const l of block)
+                if (l.kind === 'remove')
+                    sorted.push(l);
+            for (const l of block)
+                if (l.kind === 'add')
+                    sorted.push(l);
+        }
+    }
+    return sorted;
+}
+export function parseOps(text) {
+    const ops = [];
+    const writeRe = /<write_file\s+path="([^"]+)">([\s\S]*?)<\/write_file>/g;
+    let m;
+    while ((m = writeRe.exec(text)) !== null) {
+        ops.push({ type: 'write', path: m[1], content: m[2].replace(/^\n/, '') });
+    }
+    const editRe = /<edit_file\s+path="([^"]+)">[\s\S]*?<find>([\s\S]*?)<\/find>[\s\S]*?<replace>([\s\S]*?)<\/replace>[\s\S]*?<\/edit_file>/g;
+    while ((m = editRe.exec(text)) !== null) {
+        ops.push({ type: 'edit', path: m[1], find: m[2], replace: m[3] });
+    }
+    const mkdirRe = /<create_folder\s+path="([^"]+)"\s*(?:\/>|><\/create_folder>)/g;
+    while ((m = mkdirRe.exec(text)) !== null) {
+        ops.push({ type: 'mkdir', path: m[1] });
+    }
+    const deleteRe = /<delete_file\s+path="([^"]+)"\s*(?:\/>|><\/delete_file>)/g;
+    while ((m = deleteRe.exec(text)) !== null) {
+        ops.push({ type: 'delete', path: m[1] });
+    }
+    const runRe = /<run_command(?:\s+cwd="([^"]*)")?>([\s\S]*?)<\/run_command>/g;
+    while ((m = runRe.exec(text)) !== null) {
+        ops.push({ type: 'run', command: m[2].trim(), workdir: m[1] || undefined });
+    }
+    const readRe = /<read_file\s+path="([^"]+)"(?:\s+lines="([^"]+)")?\s*(?:\/>|><\/read_file>)/g;
+    while ((m = readRe.exec(text)) !== null) {
+        ops.push({ type: 'read_file', path: m[1], lines: m[2] || undefined });
+    }
+    const readFolderRe = /<read_folder\s+path="([^"]+)"\s*(?:\/>|><\/read_folder>)/g;
+    while ((m = readFolderRe.exec(text)) !== null) {
+        ops.push({ type: 'read_folder', path: m[1] });
+    }
+    const searchRe = /<search_code\s+pattern="([^"]+)"(?:\s+path="([^"]*)")?\s*(?:\/>|><\/search_code>)/g;
+    while ((m = searchRe.exec(text)) !== null) {
+        ops.push({ type: 'search_code', pattern: m[1], path: m[2] || undefined });
+    }
+    return ops;
+}
+export async function executeSingleOp(op, cwd, onStage) {
+    const stage = (msg) => onStage?.(msg);
+    // ── write ────────────────────────────────────────────────────────────────
+    if (op.type === 'write' && op.path && op.content !== undefined) {
+        try {
+            const fullPath = safeResolvePath(cwd, op.path);
+            if (!fullPath)
+                return { type: 'error', message: `Access denied: ${op.path} is outside the project directory` };
+            const exists = fs.existsSync(fullPath);
+            stage(exists ? `Writing     ${op.path}` : `Creating    ${op.path}`);
+            const oldContent = exists ? fs.readFileSync(fullPath, 'utf-8') : '';
+            if (exists && oldContent === op.content)
+                return { type: 'skipped', path: op.path };
+            fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+            fs.writeFileSync(fullPath, op.content, 'utf-8');
+            if (exists) {
+                const diff = computeDiff(oldContent, op.content);
+                const tooLarge = diff.length === 0 && oldContent !== op.content;
+                return {
+                    type: 'modified', path: op.path, diff,
+                    ...(tooLarge ? {
+                        linesBefore: oldContent.split('\n').length,
+                        linesAfter: op.content.split('\n').length,
+                    } : {}),
+                };
+            }
+            return { type: 'created', path: op.path };
+        }
+        catch (e) {
+            return { type: 'error', message: `Failed to write ${op.path}: ${e instanceof Error ? e.message : String(e)}` };
+        }
+        // ── edit ─────────────────────────────────────────────────────────────────
+    }
+    else if (op.type === 'edit' && op.path && op.find !== undefined && op.replace !== undefined) {
+        try {
+            stage(`Searching   ${path.basename(op.path)}`);
+            let fullPath = safeResolvePath(cwd, op.path);
+            if (!fullPath)
+                return { type: 'error', message: `Access denied: ${op.path} is outside the project directory` };
+            let resolvedPath = op.path;
+            if (!fs.existsSync(fullPath)) {
+                const found = findFile(op.path, cwd);
+                if (!found)
+                    return { type: 'error', message: `File not found: ${op.path}` };
+                const foundFull = safeResolvePath(cwd, found);
+                if (!foundFull)
+                    return { type: 'error', message: `Access denied: ${found} is outside the project directory` };
+                resolvedPath = found;
+                fullPath = foundFull;
+            }
+            stage(`Reading     ${resolvedPath}`);
+            const oldContent = fs.readFileSync(fullPath, 'utf-8');
+            // ── Robust match: try exact first, then trimEnd-normalized ──────────────
+            let actualFind = op.find;
+            if (!oldContent.includes(op.find)) {
+                // Try matching with trailing-whitespace normalization (most common AI copy error)
+                const oldLines = oldContent.split('\n');
+                const findLines = op.find.split('\n').map(l => l.trimEnd());
+                let matchStart = -1;
+                outer: for (let i = 0; i <= oldLines.length - findLines.length; i++) {
+                    for (let j = 0; j < findLines.length; j++) {
+                        if (oldLines[i + j].trimEnd() !== findLines[j])
+                            continue outer;
+                    }
+                    matchStart = i;
+                    break;
+                }
+                if (matchStart >= 0) {
+                    // Rebuild actualFind from the REAL file lines so replaceAll works
+                    actualFind = oldLines.slice(matchStart, matchStart + findLines.length).join('\n');
+                }
+                else {
+                    // Truly not found — give AI a useful hint
+                    const firstLine = op.find.trim().split('\n')[0].trim().slice(0, 60);
+                    let hintLine = -1;
+                    for (let i = 0; i < oldLines.length; i++) {
+                        if (firstLine.length > 4 && oldLines[i].includes(firstLine.slice(0, Math.min(30, firstLine.length)))) {
+                            hintLine = i + 1;
+                            break;
+                        }
+                    }
+                    const hint = hintLine > 0
+                        ? ` First line found near line ${hintLine} but block didn't match — use <read_file path="${resolvedPath}" lines="${Math.max(1, hintLine - 2)}-${hintLine + 20}"/> to get EXACT text, then retry.`
+                        : ` Use <search_code pattern="${firstLine.slice(0, 40)}"/> to find the text, then <read_file lines="N-M"/> to read that section.`;
+                    return { type: 'error', message: `Text not found in ${resolvedPath}.${hint}` };
+                }
+            }
+            stage(`Applying    ${resolvedPath}`);
+            const newContent = oldContent.replaceAll(actualFind, op.replace);
+            // No actual change — skip write and return skipped
+            if (newContent === oldContent)
+                return { type: 'skipped', path: resolvedPath };
+            fs.writeFileSync(fullPath, newContent, 'utf-8');
+            // Try full diff first (fast for files <= 2500 lines)
+            const diff = computeDiff(oldContent, newContent);
+            if (diff.length > 0) {
+                const adds = diff.filter(d => d.kind === 'add').length;
+                const removes = diff.filter(d => d.kind === 'remove').length;
+                if (adds > 0 || removes > 0) {
+                    return { type: 'modified', path: resolvedPath, diff };
+                }
+            }
+            // Full diff empty or no changes detected — use snippet diff for accurate display
+            const snippetDiff = computeDiff(op.find, op.replace);
+            if (snippetDiff.length > 0) {
+                const adds = snippetDiff.filter(d => d.kind === 'add').length;
+                const removes = snippetDiff.filter(d => d.kind === 'remove').length;
+                if (adds > 0 || removes > 0) {
+                    const findIdx = oldContent.indexOf(op.find);
+                    const lineOffset = findIdx >= 0 ? oldContent.slice(0, findIdx).split('\n').length - 1 : 0;
+                    const adjusted = snippetDiff.map(d => ({ ...d, lineNo: d.lineNo + lineOffset }));
+                    return { type: 'modified', path: resolvedPath, diff: adjusted };
+                }
+            }
+            return {
+                type: 'modified', path: resolvedPath, diff: [],
+                linesBefore: oldContent.split('\n').length,
+                linesAfter: newContent.split('\n').length,
+            };
+        }
+        catch (e) {
+            return { type: 'error', message: `Failed to edit ${op.path}: ${e instanceof Error ? e.message : String(e)}` };
+        }
+        // ── mkdir ─────────────────────────────────────────────────────────────────
+    }
+    else if (op.type === 'mkdir' && op.path) {
+        try {
+            stage(`Creating    ${op.path}`);
+            const mkdirFull = safeResolvePath(cwd, op.path);
+            if (!mkdirFull)
+                return { type: 'error', message: `Access denied: ${op.path} is outside the project directory` };
+            fs.mkdirSync(mkdirFull, { recursive: true });
+            return { type: 'folder_created', path: op.path };
+        }
+        catch (e) {
+            return { type: 'error', message: `Failed to create folder ${op.path}: ${e instanceof Error ? e.message : String(e)}` };
+        }
+        // ── delete ────────────────────────────────────────────────────────────────
+    }
+    else if (op.type === 'delete' && op.path) {
+        try {
+            stage(`Searching   ${path.basename(op.path)}`);
+            let fullPath = safeResolvePath(cwd, op.path);
+            if (!fullPath)
+                return { type: 'error', message: `Access denied: ${op.path} is outside the project directory` };
+            let resolvedPath = op.path;
+            if (!fs.existsSync(fullPath)) {
+                const found = findFile(op.path, cwd);
+                if (!found)
+                    return { type: 'error', message: `Not found: ${op.path}` };
+                const foundFull = safeResolvePath(cwd, found);
+                if (!foundFull)
+                    return { type: 'error', message: `Access denied: ${found} is outside the project directory` };
+                resolvedPath = found;
+                fullPath = foundFull;
+            }
+            stage(`Deleting    ${resolvedPath}`);
+            const stat = fs.statSync(fullPath);
+            if (stat.isDirectory()) {
+                fs.rmSync(fullPath, { recursive: true, force: true });
+            }
+            else {
+                fs.unlinkSync(fullPath);
+            }
+            return { type: 'deleted', path: resolvedPath };
+        }
+        catch (e) {
+            return { type: 'error', message: `Failed to delete ${op.path}: ${e instanceof Error ? e.message : String(e)}` };
+        }
+        // ── run ───────────────────────────────────────────────────────────────────
+    }
+    else if (op.type === 'run' && op.command) {
+        try {
+            const runCwd = op.workdir ? path.resolve(cwd, op.workdir) : cwd;
+            stage(`Running     ${op.command.slice(0, 55)}`);
+            // Detect long-running server commands — capture initial output then detach
+            const isServerCmd = /(?:^|\s)(?:npm|yarn|pnpm|bun)\s+(?:run\s+(?:dev|start|serve|watch|preview)|start)(?:\s|$)/i.test(op.command)
+                || /(?:^|\s)(?:node|ts-node|tsx|nodemon)\s+/i.test(op.command)
+                || /(?:^|\s)(?:python|python3|uvicorn|gunicorn|flask|django-admin)\s+.*(?:runserver|run|serve|start)/i.test(op.command)
+                || /(?:^|\s)python3?\s+-m\s+(?:http\.server|flask|uvicorn)/i.test(op.command)
+                || /(?:^|\s)npx\s+(?:--yes\s+)?(?:serve|live-server|http-server|@web\/dev-server|vite|parcel)(?:\s|$)/i.test(op.command)
+                || /(?:^|\s)(?:live-server|http-server|serve)\s*/i.test(op.command)
+                || /(?:^|\s)php\s+-S\s+/i.test(op.command)
+                || /(?:^|\s)ruby\s+.*(?:-p\s+\d+|WEBrick|rails\s+s)/i.test(op.command);
+            // Auto-add --yes to npx commands so they never block on "Ok to proceed? (y)"
+            const safeCmd = /(?:^|\s)npx\s+(?!--yes\b)/i.test(op.command)
+                ? op.command.replace(/(?<=(?:^|\s))npx(\s+)/i, 'npx --yes$1')
+                : op.command;
+            // In PowerShell 5.1, 'curl' is an alias for Invoke-WebRequest — use curl.exe for real FTP/HTTP
+            const psCmd = safeCmd.replace(/\bcurl\b(?!\.\w)/g, 'curl.exe');
+            const out = await new Promise((res, rej) => {
+                const child = spawn('powershell.exe', ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', psCmd], { cwd: runCwd, windowsHide: true });
+                child.stdout?.setEncoding('utf-8');
+                child.stderr?.setEncoding('utf-8');
+                let stdout = '';
+                let stderr = '';
+                let settled = false;
+                const settle = (output, isErr = false) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(killTimer);
+                    try {
+                        child.stdout?.destroy();
+                        child.stderr?.destroy();
+                    }
+                    catch { /* ignore */ }
+                    if (isErr)
+                        rej(new Error(output));
+                    else
+                        res(output);
+                };
+                // Match Vite/Next/CRA/Express server ready signals (check both stdout+stderr)
+                const SUCCESS_PAT = /localhost:\d{2,5}|Local:\s*http|ready in \d|server running|listening on|started on port|\blistening\b.*\d{4}|Serving\s+HTTP|Available\s+on:|http:\/\/127\.0\.0\.1:\d|http:\/\/0\.0\.0\.0:\d|Serving!|Accepting connections|─+\n.*\n.*localhost/i;
+                const FATAL_PAT = /EADDRINUSE|EACCES|cannot find module|MODULE_NOT_FOUND/i;
+                const checkSuccess = () => {
+                    const combined = stdout + stderr;
+                    if (SUCCESS_PAT.test(combined)) {
+                        child.unref();
+                        settle(combined.trim());
+                    }
+                    else if (FATAL_PAT.test(combined)) {
+                        settle(combined.trim(), true);
+                    }
+                };
+                const timeoutMs = isServerCmd ? 25_000 : 600_000;
+                const killTimer = setTimeout(() => {
+                    if (isServerCmd) {
+                        child.unref();
+                        const combined = (stdout + stderr).trim();
+                        settle(combined || 'Server started (running in background)');
+                    }
+                    else {
+                        try {
+                            child.kill();
+                        }
+                        catch { /* ignore */ }
+                        settle(`Command timed out`, true);
+                    }
+                }, timeoutMs);
+                child.stdout?.on('data', (d) => { stdout += d; if (isServerCmd)
+                    checkSuccess(); });
+                child.stderr?.on('data', (d) => { stderr += d; if (isServerCmd)
+                    checkSuccess(); });
+                child.on('close', (code) => {
+                    if (code !== 0 && !settled) {
+                        settle([stderr.trim(), stdout.trim()].filter(Boolean).join('\n') || `Exit code ${code}`, true);
+                    }
+                    else {
+                        settle((stdout + stderr).trim());
+                    }
+                });
+                child.on('error', (e) => settle(e.message, true));
+            });
+            return { type: 'run', message: op.command, output: out };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return { type: 'error', message: msg.slice(0, 600) };
+        }
+        // ── read_file ─────────────────────────────────────────────────
+    }
+    else if (op.type === 'read_file' && op.path) {
+        try {
+            stage(`Searching   ${path.basename(op.path)}`);
+            let fullPath = safeResolvePath(cwd, op.path);
+            if (!fullPath)
+                return { type: 'error', message: `Access denied: ${op.path} is outside the project directory` };
+            let resolvedPath = op.path;
+            if (!fs.existsSync(fullPath)) {
+                const found = findFile(op.path, cwd);
+                if (!found)
+                    return { type: 'error', message: `File not found: ${op.path}` };
+                const foundFull = safeResolvePath(cwd, found);
+                if (!foundFull)
+                    return { type: 'error', message: `Access denied: ${found} is outside the project directory` };
+                resolvedPath = found;
+                fullPath = foundFull;
+            }
+            stage(`Reading     ${resolvedPath}`);
+            const raw = fs.readFileSync(fullPath, 'utf-8');
+            const allLines = raw.split('\n');
+            const total = allLines.length;
+            // Files under 6000 lines → always return full content so AI has complete context
+            const LARGE_FILE_THRESHOLD = 6000;
+            // Only truly huge files (>6000 lines) get paginated — return first 600 lines + hint
+            if (!op.lines && total > LARGE_FILE_THRESHOLD) {
+                const PAGE = 600;
+                const preview = allLines.slice(0, PAGE).map((l, i) => `${String(i + 1).padStart(4)} │ ${l}`).join('\n');
+                const pages = Math.ceil(total / PAGE);
+                const output = `[File: ${resolvedPath} — ${total} lines — page 1/${pages}]\n` +
+                    `⚠ In <find>, copy ONLY the content AFTER " │ " — never include line number or "│"\n` +
+                    `⚠ To read next page: <read_file path="${resolvedPath}" lines="${PAGE + 1}-${PAGE * 2}"/>\n\n` +
+                    preview +
+                    `\n\n... (${total - PAGE} more lines — next page: lines ${PAGE + 1}-${PAGE * 2})`;
+                return { type: 'run', message: resolvedPath, output };
+            }
+            let startLine = 1;
+            let endLine = total;
+            if (op.lines) {
+                const parts = op.lines.split('-').map(s => parseInt(s.trim(), 10));
+                if (parts.length === 2 && !isNaN(parts[0]) && !isNaN(parts[1])) {
+                    startLine = Math.max(1, parts[0]);
+                    endLine = Math.min(total, parts[1]);
+                }
+                else if (parts.length === 1 && !isNaN(parts[0])) {
+                    startLine = Math.max(1, parts[0]);
+                    endLine = Math.min(total, parts[0] + 199);
+                }
+            }
+            const slice = allLines.slice(startLine - 1, endLine);
+            // Format: "  42 │ code" — the " │ " separator makes it clear numbers are NOT file content
+            const numbered = slice.map((line, i) => `${String(startLine + i).padStart(4)} │ ${line}`).join('\n');
+            const header = op.lines
+                ? `[File: ${resolvedPath} — lines ${startLine}-${endLine} of ${total}]\n` +
+                    `⚠ In <find>, copy ONLY the content AFTER " │ " — never include the line number or "│"\n`
+                : `[File: ${resolvedPath} — ${total} lines]\n` +
+                    `⚠ In <find>, copy ONLY the content AFTER " │ " — never include the line number or "│"\n`;
+            return { type: 'run', message: resolvedPath, output: header + numbered };
+        }
+        catch (e) {
+            return { type: 'error', message: `Failed to read ${op.path}: ${e instanceof Error ? e.message : String(e)}` };
+        }
+        // ── read_folder ──────────────────────────────────────────────
+    }
+    else if (op.type === 'read_folder' && op.path) {
+        try {
+            const fullDir = safeResolvePath(cwd, op.path);
+            if (!fullDir)
+                return { type: 'error', message: `Access denied: ${op.path} is outside the project directory` };
+            if (!fs.existsSync(fullDir) || !fs.statSync(fullDir).isDirectory()) {
+                return { type: 'error', message: `Folder not found: ${op.path}` };
+            }
+            stage(`Reading     ${op.path}`);
+            const entries = [];
+            function walkDir(dir, rel, depth) {
+                if (depth > 6)
+                    return;
+                let de;
+                try {
+                    de = fs.readdirSync(dir, { withFileTypes: true });
+                }
+                catch {
+                    return;
+                }
+                const sorted = [...de].sort((a, b) => {
+                    if (a.isDirectory() && !b.isDirectory())
+                        return -1;
+                    if (!a.isDirectory() && b.isDirectory())
+                        return 1;
+                    return a.name.localeCompare(b.name);
+                });
+                for (const e of sorted) {
+                    if (SKIP_DIRS.has(e.name))
+                        continue;
+                    if (e.name.startsWith('.') && e.name !== '.env' && e.name !== '.gitignore')
+                        continue;
+                    const eRel = rel ? `${rel}/${e.name}` : e.name;
+                    const eFull = path.join(dir, e.name);
+                    if (e.isDirectory()) {
+                        entries.push({ rel: eRel + '/', isDir: true, depth });
+                        walkDir(eFull, eRel, depth + 1);
+                    }
+                    else {
+                        let size;
+                        try {
+                            size = fs.statSync(eFull).size;
+                        }
+                        catch { /* ignore */ }
+                        entries.push({ rel: eRel, size, isDir: false, depth });
+                    }
+                }
+            }
+            walkDir(fullDir, '', 0);
+            const fileCount = entries.filter(e => !e.isDir).length;
+            const dirCount = entries.filter(e => e.isDir).length;
+            const lines = [`Folder: ${op.path}  (${fileCount} files, ${dirCount} dirs)`, ''];
+            for (const e of entries) {
+                const indent = '  '.repeat(e.depth);
+                const name = e.rel.split('/').filter(Boolean).pop() ?? e.rel;
+                const sizeStr = e.size !== undefined
+                    ? ` (${e.size < 1024 ? e.size + 'B' : e.size < 1_048_576 ? (e.size / 1024).toFixed(1) + 'KB' : (e.size / 1_048_576).toFixed(1) + 'MB'})`
+                    : '';
+                lines.push(`${indent}${name}${e.isDir ? '/' : sizeStr}`);
+            }
+            return { type: 'run', message: `folder:${op.path}`, output: lines.join('\n') };
+        }
+        catch (e) {
+            return { type: 'error', message: `Failed to read folder ${op.path}: ${e instanceof Error ? e.message : String(e)}` };
+        }
+        // ── search_code ───────────────────────────────────────────────
+    }
+    else if (op.type === 'search_code' && op.pattern) {
+        try {
+            const searchRoot = safeResolvePath(cwd, op.path ?? '.');
+            if (!searchRoot)
+                return { type: 'error', message: `Access denied: path is outside the project directory` };
+            stage(`Searching   ${op.pattern.slice(0, 45)}`);
+            const TEXT_EXTS = new Set([
+                '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+                '.py', '.go', '.java', '.c', '.cpp', '.h', '.hpp', '.cs', '.rs', '.rb', '.php',
+                '.vue', '.svelte', '.html', '.css', '.scss', '.sass', '.less',
+                '.json', '.yaml', '.yml', '.toml', '.xml', '.md', '.txt', '.sh', '.bash', '.zsh',
+                '.env', '.sql', '.graphql', '.prisma', '.proto', '.swift', '.kt', '.dart',
+            ]);
+            const matches = [];
+            const MAX_MATCHES = 200;
+            const patternLower = op.pattern.toLowerCase();
+            function walkSearch(dir) {
+                if (matches.length >= MAX_MATCHES)
+                    return;
+                let de;
+                try {
+                    de = fs.readdirSync(dir, { withFileTypes: true });
+                }
+                catch {
+                    return;
+                }
+                for (const entry of de) {
+                    if (matches.length >= MAX_MATCHES)
+                        return;
+                    if (SKIP_DIRS.has(entry.name))
+                        continue;
+                    if (entry.name.startsWith('.') && entry.name !== '.env' && entry.name !== '.gitignore')
+                        continue;
+                    const eFull = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        walkSearch(eFull);
+                    }
+                    else {
+                        if (!TEXT_EXTS.has(path.extname(entry.name).toLowerCase()))
+                            continue;
+                        let content;
+                        try {
+                            content = fs.readFileSync(eFull, 'utf-8');
+                        }
+                        catch {
+                            continue;
+                        }
+                        const fileLines = content.split('\n');
+                        const relFile = path.relative(cwd, eFull).replace(/\\/g, '/');
+                        for (let i = 0; i < fileLines.length; i++) {
+                            if (matches.length >= MAX_MATCHES)
+                                break;
+                            if (fileLines[i].toLowerCase().includes(patternLower)) {
+                                matches.push({ file: relFile, line: i + 1, content: fileLines[i].trim().slice(0, 200) });
+                            }
+                        }
+                    }
+                }
+            }
+            walkSearch(searchRoot);
+            if (matches.length === 0) {
+                return { type: 'run', message: `search:${op.pattern}`, output: `No matches found for "${op.pattern}"` };
+            }
+            const byFile = new Map();
+            for (const fm of matches) {
+                if (!byFile.has(fm.file))
+                    byFile.set(fm.file, []);
+                byFile.get(fm.file).push(fm);
+            }
+            const outLines = [];
+            for (const [file, fileMatches] of byFile) {
+                for (const fm of fileMatches) {
+                    outLines.push(`${file}:${fm.line}: ${fm.content}`);
+                }
+            }
+            if (matches.length >= MAX_MATCHES)
+                outLines.push(`... truncated at ${MAX_MATCHES} matches`);
+            outLines.push(`\nTotal: ${matches.length} match${matches.length !== 1 ? 'es' : ''} in ${byFile.size} file${byFile.size !== 1 ? 's' : ''}`);
+            return { type: 'run', message: `search:${op.pattern}`, output: outLines.join('\n') };
+        }
+        catch (e) {
+            return { type: 'error', message: `Search failed: ${e instanceof Error ? e.message : String(e)}` };
+        }
+    }
+    return { type: 'error', message: 'Unknown operation' };
+}
+export async function executeOps(ops, cwd) {
+    const results = [];
+    for (const op of ops)
+        results.push(await executeSingleOp(op, cwd));
+    return results;
+}