@aria-cli/tools 1.0.8 → 1.0.10

package/dist-cjs/executors/code-intelligence.js

@@ -1,926 +0,0 @@
-"use strict";
-/**
- * @aria/tools - Code intelligence executors
- *
- * 7 native tools wrapping external CLI binaries:
- * rg (ripgrep), ug (ugrep), probe, sg (ast-grep),
- * cbm (codebase-memory-mcp), serena, fff
- */
-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;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeRg = executeRg;
-exports.executeUg = executeUg;
-exports.executeProbe = executeProbe;
-exports.executeSg = executeSg;
-exports.executeCbm = executeCbm;
-exports.executeLsp = executeLsp;
-exports.executeSerena = executeSerena;
-exports.executeFff = executeFff;
-const node_child_process_1 = require("node:child_process");
-const node_util_1 = require("node:util");
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const node_net_1 = require("node:net");
-const utils_js_1 = require("./utils.js");
-const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
-// ---------------------------------------------------------------------------
-// Shared helpers
-// ---------------------------------------------------------------------------
-const binaryCache = new Map();
-async function hasBinary(name) {
-    if (binaryCache.has(name))
-        return binaryCache.get(name);
-    try {
-        await execFileAsync("which", [name]);
-        binaryCache.set(name, true);
-    }
-    catch {
-        binaryCache.set(name, false);
-    }
-    return binaryCache.get(name);
-}
-async function shellExec(cmd, args, opts) {
-    return execFileAsync(cmd, args, {
-        cwd: opts.cwd,
-        timeout: opts.timeout ?? 30_000,
-        signal: opts.signal,
-        maxBuffer: 10 * 1024 * 1024, // 10MB
-    });
-}
-function pushIf(args, condition, ...flags) {
-    if (condition)
-        args.push(...flags);
-}
-function mergeExtraArgs(args, extra) {
-    if (extra?.length)
-        args.push(...extra);
-}
-function escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function asExecError(err) {
-    if (err && typeof err === "object")
-        return err;
-    return { message: String(err) };
-}
-// ---------------------------------------------------------------------------
-// 1. rg — ripgrep
-// ---------------------------------------------------------------------------
-async function executeRg(input, ctx) {
-    if (ctx.abortSignal?.aborted)
-        return (0, utils_js_1.fail)("Operation cancelled");
-    if (!(await hasBinary("rg")))
-        return (0, utils_js_1.fail)("ripgrep (rg) not installed. Install: brew install ripgrep");
-    // When count mode is active, rg -c outputs plain text (file:count) even with --json.
-    // We omit --json and parse the plain-text output instead.
-    const rgCountMode = !!input.count;
-    const args = rgCountMode
-        ? ["--line-number", "--color", "never"]
-        : ["--json", "--line-number", "--color", "never"];
-    pushIf(args, input.ignore_case, "-i");
-    pushIf(args, input.smart_case, "-S");
-    pushIf(args, input.fixed_strings, "-F");
-    pushIf(args, input.word_regexp, "-w");
-    pushIf(args, input.invert, "-v");
-    pushIf(args, input.files_only, "-l");
-    pushIf(args, input.count, "-c");
-    if (input.file_type)
-        args.push("-t", input.file_type);
-    if (input.glob)
-        args.push("-g", input.glob);
-    if (input.context != null)
-        args.push("-C", String(input.context));
-    if (input.max_count != null)
-        args.push("-m", String(input.max_count));
-    mergeExtraArgs(args, input.extra_args);
-    args.push("--", input.pattern);
-    args.push(input.path ?? ctx.workingDir);
-    try {
-        const { stdout } = await shellExec("rg", args, {
-            cwd: ctx.workingDir,
-            signal: ctx.abortSignal,
-        });
-        if (rgCountMode) {
-            const counts = parseRipgrepCount(stdout);
-            const total = counts.reduce((s, c) => s + c.count, 0);
-            return (0, utils_js_1.success)(`Found ${total} matches across ${counts.length} files for "${input.pattern}"`, { counts, total });
-        }
-        const matches = parseRipgrepJson(stdout);
-        return (0, utils_js_1.success)(`Found ${matches.length} matches for "${input.pattern}"`, { matches });
-    }
-    catch (err) {
-        const e = asExecError(err);
-        if (e.code === 1)
-            return (0, utils_js_1.success)("No matches found", { matches: [] });
-        return (0, utils_js_1.fail)(`rg failed: ${e.stderr || e.message}`);
-    }
-}
-function parseRipgrepJson(stdout) {
-    const matches = [];
-    for (const line of stdout.split("\n")) {
-        if (!line.trim())
-            continue;
-        try {
-            const obj = JSON.parse(line);
-            if (obj.type === "match") {
-                matches.push({
-                    file: obj.data.path.text,
-                    line: obj.data.line_number,
-                    text: obj.data.lines.text.trimEnd(),
-                    submatches: obj.data.submatches?.map((s) => s.match?.text) ?? [],
-                });
-            }
-        }
-        catch {
-            // Skip malformed lines
-        }
-    }
-    return matches;
-}
-/** Parse rg/ug plain-text count output: `file:count` per line.
- *  Filters out files with 0 matches (ug -c outputs 0-count lines, rg doesn't). */
-function parseRipgrepCount(stdout) {
-    const counts = [];
-    for (const line of stdout.split("\n")) {
-        if (!line.trim())
-            continue;
-        const lastColon = line.lastIndexOf(":");
-        if (lastColon === -1)
-            continue;
-        const file = line.slice(0, lastColon);
-        const count = parseInt(line.slice(lastColon + 1), 10);
-        if (!isNaN(count) && count > 0)
-            counts.push({ file, count });
-    }
-    return counts;
-}
-// ---------------------------------------------------------------------------
-// 2. ug — ugrep
-// ---------------------------------------------------------------------------
-async function executeUg(input, ctx) {
-    if (ctx.abortSignal?.aborted)
-        return (0, utils_js_1.fail)("Operation cancelled");
-    if (!(await hasBinary("ug")))
-        return (0, utils_js_1.fail)("ugrep (ug) not installed. Install: brew install ugrep");
-    // --ignore-files: respect .gitignore / .ignore (parity with rg default behaviour).
-    // --ignore-binary: skip binary files (tar, images, etc.) — rg skips them by default.
-    // Without these flags ug searches dist/, node_modules/, .tar archives, etc.
-    const ugCountMode = !!input.count;
-    const args = ugCountMode
-        ? ["--line-number", "--color=never", "-r", "--ignore-files", "--ignore-binary"]
-        : ["--json", "--line-number", "--color=never", "-r", "--ignore-files", "--ignore-binary"];
-    pushIf(args, input.ignore_case, "-i");
-    pushIf(args, input.smart_case, "-j");
-    pushIf(args, input.fixed_strings, "-F");
-    pushIf(args, input.word_regexp, "-w");
-    pushIf(args, input.files_only, "-l");
-    pushIf(args, input.count, "-c");
-    pushIf(args, input.decompress, "-z");
-    if (input.file_type)
-        args.push("-t", input.file_type);
-    if (input.glob)
-        args.push("-g", input.glob);
-    if (input.context != null)
-        args.push("-C", String(input.context));
-    if (input.max_count != null)
-        args.push("-m", String(input.max_count));
-    if (input.neg_pattern)
-        args.push("-N", input.neg_pattern);
-    // Fuzzy matching
-    if (input.fuzzy === true) {
-        args.push("-Z");
-    }
-    else if (typeof input.fuzzy === "number") {
-        args.push(`-Z${input.fuzzy}`);
-    }
-    // Boolean query mode
-    if (input.bool)
-        args.push("-%%");
-    mergeExtraArgs(args, input.extra_args);
-    args.push("--", input.pattern);
-    args.push(input.path ?? ctx.workingDir);
-    try {
-        const { stdout } = await shellExec("ug", args, {
-            cwd: ctx.workingDir,
-            signal: ctx.abortSignal,
-        });
-        if (ugCountMode) {
-            const counts = parseRipgrepCount(stdout); // same file:count format
-            const total = counts.reduce((s, c) => s + c.count, 0);
-            return (0, utils_js_1.success)(`Found ${total} matches across ${counts.length} files for "${input.pattern}"`, { counts, total });
-        }
-        const matches = parseUgrepJson(stdout);
-        return (0, utils_js_1.success)(`Found ${matches.length} matches for "${input.pattern}"`, { matches });
-    }
-    catch (err) {
-        const e = asExecError(err);
-        if (e.code === 1)
-            return (0, utils_js_1.success)("No matches found", { matches: [] });
-        return (0, utils_js_1.fail)(`ug failed: ${e.stderr || e.message}`);
-    }
-}
-function parseUgrepJson(stdout) {
-    // ugrep --json outputs: [{ file, matches: [{ line, match }] }]
-    // This is a JSON array, NOT NDJSON like ripgrep
-    const results = [];
-    try {
-        const parsed = JSON.parse(stdout);
-        for (const fileGroup of parsed) {
-            for (const m of fileGroup.matches) {
-                results.push({
-                    file: fileGroup.file,
-                    line: m.line,
-                    text: m.match.trimEnd(),
-                    submatches: [],
-                });
-            }
-        }
-    }
-    catch {
-        // Fallback: try NDJSON parsing in case format varies
-        for (const line of stdout.split("\n")) {
-            if (!line.trim())
-                continue;
-            try {
-                const obj = JSON.parse(line);
-                if (obj.file && obj.matches) {
-                    for (const m of obj.matches) {
-                        results.push({
-                            file: obj.file,
-                            line: m.line,
-                            text: m.match?.trimEnd() ?? "",
-                            submatches: [],
-                        });
-                    }
-                }
-            }
-            catch {
-                // Skip
-            }
-        }
-    }
-    return results;
-}
-// ---------------------------------------------------------------------------
-// 3. probe
-// ---------------------------------------------------------------------------
-async function executeProbe(input, ctx) {
-    if (ctx.abortSignal?.aborted)
-        return (0, utils_js_1.fail)("Operation cancelled");
-    if (!(await hasBinary("probe")))
-        return (0, utils_js_1.fail)("probe not installed. Install: npm install -g @probelabs/probe");
-    const cmd = input.command ?? "search";
-    const args = [cmd];
-    switch (cmd) {
-        case "search": {
-            if (!input.query)
-                return (0, utils_js_1.fail)("query required for search");
-            pushIf(args, input.exact, "--exact");
-            pushIf(args, input.allow_tests, "--allow-tests");
-            if (input.max_tokens != null)
-                args.push("--max-tokens", String(input.max_tokens));
-            if (input.max_results != null)
-                args.push("--max-results", String(input.max_results));
-            if (input.session)
-                args.push("--session", input.session);
-            if (input.language)
-                args.push("--language", input.language);
-            if (input.reranker)
-                args.push("--reranker", input.reranker);
-            args.push("--format", "json");
-            mergeExtraArgs(args, input.extra_args);
-            args.push("--", input.query);
-            if (input.path)
-                args.push(input.path);
-            break;
-        }
-        case "extract": {
-            if (!input.files?.length)
-                return (0, utils_js_1.fail)("files required for extract");
-            args.push("--format", "json");
-            mergeExtraArgs(args, input.extra_args);
-            args.push(...input.files);
-            break;
-        }
-        case "symbols": {
-            // Accept files via `files` array or fall back to `query` as a file path
-            const symbolFiles = input.files?.length ? input.files : input.query ? [input.query] : [];
-            if (!symbolFiles.length)
-                return (0, utils_js_1.fail)("files required for symbols (pass via 'files' or 'query')");
-            args.push("--format", "json");
-            mergeExtraArgs(args, input.extra_args);
-            args.push(...symbolFiles);
-            break;
-        }
-        case "query": {
-            if (!input.query)
-                return (0, utils_js_1.fail)("query (AST pattern) required for query command");
-            if (input.language)
-                args.push("--language", input.language);
-            if (input.max_results != null)
-                args.push("--max-results", String(input.max_results));
-            pushIf(args, input.allow_tests, "--allow-tests");
-            args.push("--format", "json");
-            mergeExtraArgs(args, input.extra_args);
-            args.push("--", input.query);
-            if (input.path)
-                args.push(input.path);
-            break;
-        }
-    }
-    try {
-        const { stdout } = await shellExec("probe", args, {
-            cwd: ctx.workingDir,
-            signal: ctx.abortSignal,
-            timeout: 60_000,
-        });
-        try {
-            const data = JSON.parse(stdout);
-            return (0, utils_js_1.success)(`probe ${cmd} completed`, data);
-        }
-        catch {
-            // If not valid JSON, return raw output
-            return (0, utils_js_1.success)(`probe ${cmd} completed`, { raw: stdout });
-        }
-    }
-    catch (err) {
-        const e = asExecError(err);
-        return (0, utils_js_1.fail)(`probe ${cmd} failed: ${e.stderr || e.message}`);
-    }
-}
-// ---------------------------------------------------------------------------
-// 4. sg — ast-grep
-// ---------------------------------------------------------------------------
-async function executeSg(input, ctx) {
-    if (ctx.abortSignal?.aborted)
-        return (0, utils_js_1.fail)("Operation cancelled");
-    if (!(await hasBinary("sg")))
-        return (0, utils_js_1.fail)("ast-grep (sg) not installed. Install: cargo install ast-grep --locked");
-    const cmd = input.command ?? "run";
-    const isMutation = !!(input.rewrite || input.update_all);
-    // Require confirmation for mutations
-    if (isMutation && !input.update_all && ctx.confirm) {
-        const approved = await ctx.confirm(`Rewrite code matching \`${input.pattern}\` to \`${input.rewrite}\` in ${input.language || "auto-detected"} files?`);
-        if (!approved)
-            return (0, utils_js_1.fail)("Rewrite cancelled by user");
-    }
-    const args = [cmd];
-    if (cmd === "run") {
-        if (!input.pattern)
-            return (0, utils_js_1.fail)("pattern required for sg run");
-        args.push("--pattern", input.pattern);
-        if (input.language)
-            args.push("--lang", input.language);
-        if (input.rewrite)
-            args.push("--rewrite", input.rewrite);
-        if (input.strictness)
-            args.push("--strictness", input.strictness);
-        pushIf(args, input.update_all, "-U");
-    }
-    else if (cmd === "scan") {
-        if (input.rule)
-            args.push("--rule", input.rule);
-        if (input.inline_rules)
-            args.push("--inline-rules", input.inline_rules);
-    }
-    // Shared flags
-    if (input.globs)
-        args.push("--globs", input.globs);
-    if (input.context != null)
-        args.push("-C", String(input.context));
-    // Always JSON for machine parsing, skip color
-    if (!isMutation) {
-        args.push("--json=compact");
-    }
-    args.push("--color", "never");
-    mergeExtraArgs(args, input.extra_args);
-    args.push(input.path ?? ctx.workingDir);
-    try {
-        const { stdout } = await shellExec("sg", args, {
-            cwd: ctx.workingDir,
-            signal: ctx.abortSignal,
-        });
-        if (isMutation) {
-            return (0, utils_js_1.success)(`sg ${cmd}: rewrites applied`, { raw: stdout });
-        }
-        try {
-            const data = JSON.parse(stdout);
-            const count = Array.isArray(data) ? data.length : 0;
-            return (0, utils_js_1.success)(`Found ${count} matches`, { matches: data });
-        }
-        catch {
-            return (0, utils_js_1.success)(`sg ${cmd} completed`, { raw: stdout });
-        }
-    }
-    catch (err) {
-        // Exit code 1 = no matches for run
-        const e = asExecError(err);
-        if (e.code === 1 && cmd === "run")
-            return (0, utils_js_1.success)("No matches found", { matches: [] });
-        return (0, utils_js_1.fail)(`sg ${cmd} failed: ${e.stderr || e.message}`);
-    }
-}
-// ---------------------------------------------------------------------------
-// 5. cbm — codebase-memory-mcp
-// ---------------------------------------------------------------------------
-// Internal helper to call cbm CLI
-async function cbmCall(tool, params, ctx, timeout) {
-    // Remove undefined/null values from params
-    const clean = {};
-    for (const [k, v] of Object.entries(params)) {
-        if (v !== undefined && v !== null)
-            clean[k] = v;
-    }
-    const { stdout } = await shellExec("codebase-memory-mcp", ["cli", tool, JSON.stringify(clean)], {
-        cwd: ctx.workingDir,
-        signal: ctx.abortSignal,
-        timeout: timeout ?? 30_000,
-    });
-    // cbm cli returns MCP content format: { content: [{ type: "text", text: "..." }] }
-    // Filter log lines (level=info ...) and parse
-    const jsonLines = stdout.split("\n").filter((l) => l.trim() && !l.startsWith("level="));
-    const parsed = JSON.parse(jsonLines.join("\n"));
-    if (Array.isArray(parsed.content)) {
-        const textBlocks = parsed.content
-            .filter((c) => c.type === "text")
-            .map((c) => c.text);
-        const combined = textBlocks.join("\n");
-        try {
-            return JSON.parse(combined);
-        }
-        catch {
-            return { text: combined };
-        }
-    }
-    return parsed;
-}
-async function executeCbm(input, ctx) {
-    if (ctx.abortSignal?.aborted)
-        return (0, utils_js_1.fail)("Operation cancelled");
-    if (!(await hasBinary("codebase-memory-mcp")))
-        return (0, utils_js_1.fail)("codebase-memory-mcp not installed. Install:\ncurl -fsSL https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/scripts/setup.sh | bash");
-    // Auto-detect project name: cbm slugifies repo_path by replacing / with -
-    // and stripping the leading separator: /Users/hole/aria → Users-hole-aria
-    const p = input.project ?? (input.path ?? ctx.workingDir).replace(/^\//, "").replace(/\//g, "-");
-    // Auto-index: if the action requires an indexed project and no project exists,
-    // transparently run a fast index first so queries don't silently return empty.
-    const queryActions = new Set([
-        "search",
-        "trace",
-        "impact",
-        "context",
-        "snippet",
-        "code_search",
-        "architecture",
-        "schema",
-        "cypher",
-    ]);
-    if (queryActions.has(input.action)) {
-        let needsIndex = false;
-        try {
-            const statusResult = (await cbmCall("index_status", { project: p }, ctx));
-            // If status indicates no project or empty graph, auto-index
-            if (statusResult?.status === "no_project" ||
-                statusResult?.node_count === 0 ||
-                statusResult?.error) {
-                needsIndex = true;
-            }
-        }
-        catch {
-            // index_status failed — likely no project
-            needsIndex = true;
-        }
-        if (needsIndex) {
-            try {
-                await cbmCall("index_repository", { repo_path: input.path ?? ctx.workingDir, mode: "full" }, ctx, 300_000);
-            }
-            catch {
-                // If auto-index fails, continue — let the actual action produce the error
-            }
-        }
-    }
-    switch (input.action) {
-        case "index":
-            return (0, utils_js_1.success)("Indexed", await cbmCall("index_repository", { repo_path: input.path ?? ctx.workingDir, mode: input.mode ?? "full" }, ctx, 300_000));
-        case "search":
-            return (0, utils_js_1.success)("Search results", await cbmCall("search_graph", {
-                project: p,
-                name_pattern: input.name,
-                label: input.label,
-                file_pattern: input.file,
-                limit: input.limit ?? 20,
-            }, ctx));
-        case "trace": {
-            if (!input.name)
-                return (0, utils_js_1.fail)("name required for trace");
-            return (0, utils_js_1.success)(`Call chain: ${input.name}`, await cbmCall("trace_call_path", {
-                project: p,
-                function_name: input.name,
-                direction: input.direction ?? "both",
-                depth: input.depth ?? 3,
-                edge_types: input.edge_types,
-            }, ctx));
-        }
-        case "impact":
-            return (0, utils_js_1.success)("Impact analysis", await cbmCall("detect_changes", {
-                project: p,
-                scope: input.scope,
-                depth: input.depth ?? 2,
-                base_branch: input.base_branch ?? "main",
-            }, ctx));
-        case "context": {
-            if (!input.name)
-                return (0, utils_js_1.fail)("name required for context");
-            const [sym, callers, callees] = await Promise.all([
-                cbmCall("search_graph", { project: p, name_pattern: `^${escapeRegex(input.name)}$`, limit: 1 }, ctx),
-                cbmCall("trace_call_path", { project: p, function_name: input.name, direction: "inbound", depth: 2 }, ctx),
-                cbmCall("trace_call_path", { project: p, function_name: input.name, direction: "outbound", depth: 2 }, ctx),
-            ]);
-            return (0, utils_js_1.success)(`360° context: ${input.name}`, {
-                definition: sym.results?.[0],
-                callers,
-                callees,
-            });
-        }
-        case "snippet": {
-            if (!input.qualified_name)
-                return (0, utils_js_1.fail)("qualified_name required for snippet");
-            return (0, utils_js_1.success)("Code snippet", await cbmCall("get_code_snippet", {
-                project: p,
-                qualified_name: input.qualified_name,
-                include_neighbors: input.include_neighbors,
-            }, ctx));
-        }
-        case "code_search":
-            return (0, utils_js_1.success)("Code search", await cbmCall("search_code", {
-                project: p,
-                pattern: input.code_pattern,
-                mode: input.code_mode ?? "compact",
-                regex: input.regex,
-                limit: input.limit ?? 10,
-                file_pattern: input.file,
-                context: input.context,
-            }, ctx));
-        case "architecture":
-            return (0, utils_js_1.success)("Architecture", await cbmCall("get_architecture", { project: p }, ctx));
-        case "schema":
-            return (0, utils_js_1.success)("Schema", await cbmCall("get_graph_schema", { project: p }, ctx));
-        case "cypher": {
-            if (!input.query)
-                return (0, utils_js_1.fail)("query required for cypher");
-            return (0, utils_js_1.success)("Cypher result", await cbmCall("query_graph", { project: p, query: input.query, max_rows: input.max_rows }, ctx));
-        }
-        case "list_projects":
-            return (0, utils_js_1.success)("Projects", await cbmCall("list_projects", {}, ctx));
-        case "delete_project": {
-            if (!input.project)
-                return (0, utils_js_1.fail)("project required for delete_project");
-            if (ctx.confirm) {
-                const ok = await ctx.confirm(`Delete project "${input.project}" from cbm index?`);
-                if (!ok)
-                    return (0, utils_js_1.fail)("Cancelled");
-            }
-            return (0, utils_js_1.success)("Deleted", await cbmCall("delete_project", { project: p }, ctx));
-        }
-        case "status":
-            return (0, utils_js_1.success)("Status", await cbmCall("index_status", { project: p }, ctx));
-        default:
-            return (0, utils_js_1.fail)(`Unknown cbm action: ${input.action}`);
-    }
-}
-let _lspClient;
-async function getLspClient() {
-    if (!_lspClient) {
-        // Use variable to prevent TypeScript from following the import in CJS build
-        const modulePath = "./lsp-client.js";
-        _lspClient = (await Promise.resolve(`${modulePath}`).then(s => __importStar(require(s))));
-    }
-    return _lspClient;
-}
-async function executeLsp(input, ctx) {
-    if (ctx.abortSignal?.aborted)
-        return (0, utils_js_1.fail)("Operation cancelled");
-    if (!input.file)
-        return (0, utils_js_1.fail)("file required");
-    const { getServerForFile, getOrCreateServer, LSP_SERVERS } = await getLspClient();
-    const serverName = getServerForFile(input.file);
-    if (!serverName) {
-        const ext = input.file.slice(input.file.lastIndexOf("."));
-        const supported = Object.entries(LSP_SERVERS)
-            .map(([name, cfg]) => `${name}: ${Object.keys(cfg.extensionToLanguage).join(", ")}`)
-            .join("\n  ");
-        return (0, utils_js_1.fail)(`No language server for extension "${ext}". Supported:\n  ${supported}`);
-    }
-    // Rename requires confirmation
-    if (input.action === "rename" && ctx.confirm) {
-        const ok = await ctx.confirm(`Rename symbol at ${input.file}:${input.line}:${input.character} to "${input.new_name}"?`);
-        if (!ok)
-            return (0, utils_js_1.fail)("Cancelled by user");
-    }
-    const server = getOrCreateServer(serverName, ctx.workingDir);
-    try {
-        await server.start();
-        switch (input.action) {
-            case "definition": {
-                if (input.line == null || input.character == null)
-                    return (0, utils_js_1.fail)("line and character required for definition");
-                const result = await server.definition(input.file, input.line, input.character);
-                return (0, utils_js_1.success)(`lsp definition`, result);
-            }
-            case "references": {
-                if (input.line == null || input.character == null)
-                    return (0, utils_js_1.fail)("line and character required for references");
-                const result = await server.references(input.file, input.line, input.character);
-                return (0, utils_js_1.success)(`lsp references`, result);
-            }
-            case "hover": {
-                if (input.line == null || input.character == null)
-                    return (0, utils_js_1.fail)("line and character required for hover");
-                const result = await server.hover(input.file, input.line, input.character);
-                return (0, utils_js_1.success)(`lsp hover`, result);
-            }
-            case "symbols": {
-                const result = await server.documentSymbols(input.file);
-                return (0, utils_js_1.success)(`lsp symbols`, result);
-            }
-            case "rename": {
-                if (input.line == null || input.character == null || !input.new_name)
-                    return (0, utils_js_1.fail)("line, character, and new_name required for rename");
-                const result = await server.rename(input.file, input.line, input.character, input.new_name);
-                return (0, utils_js_1.success)(`lsp rename`, result);
-            }
-            default:
-                return (0, utils_js_1.fail)(`Unknown lsp action: ${input.action}. Use: definition, references, hover, symbols, rename`);
-        }
-    }
-    catch (err) {
-        const e = asExecError(err);
-        return (0, utils_js_1.fail)(`lsp ${input.action} failed: ${e.message}`);
-    }
-}
-// ---------------------------------------------------------------------------
-// 7. serena — HTTP project server (kept alongside native LSP for full Serena API)
-// ---------------------------------------------------------------------------
-const SERENA_PORT = 9750;
-const SERENA_BASE = `http://127.0.0.1:${SERENA_PORT}`;
-const SERENA_PROJECT = "aria";
-const SERENA_TOOL_MAP = {
-    find_symbol: "find_symbol",
-    find_references: "find_referencing_symbols",
-    overview: "get_symbols_overview",
-    replace_body: "replace_symbol_body",
-    insert_after: "insert_after_symbol",
-    insert_before: "insert_before_symbol",
-    rename: "rename_symbol",
-    search: "search_for_pattern",
-};
-// ---------------------------------------------------------------------------
-// Serena auto-start: spawn the HTTP project server on demand
-// ---------------------------------------------------------------------------
-let serenaStarting = null;
-async function isSerenaAlive() {
-    // Lightweight TCP probe — just check if something is listening on the port.
-    // A full HTTP request is too heavy during startup (Serena takes seconds to load projects).
-    return new Promise((resolve) => {
-        const sock = (0, node_net_1.createConnection)({ host: "127.0.0.1", port: SERENA_PORT }, () => {
-            sock.destroy();
-            resolve(true);
-        });
-        sock.setTimeout(2_000);
-        sock.on("error", () => resolve(false));
-        sock.on("timeout", () => {
-            sock.destroy();
-            resolve(false);
-        });
-    });
-}
-function findSerenaProjectRoot() {
-    // Walk up from cwd looking for .serena/project.yml
-    let dir = (0, node_path_1.resolve)(process.cwd());
-    while (dir !== (0, node_path_1.dirname)(dir)) {
-        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(dir, ".serena", "project.yml")))
-            return dir;
-        dir = (0, node_path_1.dirname)(dir);
-    }
-    // Fallback: walk up from this file's directory
-    // (compiled JS lives in packages/tools/dist/executors/)
-    // __dirname is available since the build target is CJS
-    dir = typeof __dirname === "string" ? (0, node_path_1.resolve)(__dirname) : (0, node_path_1.resolve)(".");
-    while (dir !== (0, node_path_1.dirname)(dir)) {
-        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(dir, ".serena", "project.yml")))
-            return dir;
-        dir = (0, node_path_1.dirname)(dir);
-    }
-    return process.cwd();
-}
-let cachedSerenaBin;
-function resolveSerenaBin() {
-    if (cachedSerenaBin !== undefined)
-        return cachedSerenaBin;
-    // Find the serena binary from uv's cache directory.
-    // We avoid `uvx --from git+... which serena` because it triggers a blocking
-    // git fetch that hangs inside a detached spawn context.
-    const cacheBase = (0, node_path_1.join)(process.env.HOME ?? "/tmp", ".cache", "uv", "archive-v0");
-    try {
-        const entries = (0, node_fs_1.readdirSync)(cacheBase)
-            .map((d) => (0, node_path_1.join)(cacheBase, d, "bin", "serena"))
-            .filter((p) => (0, node_fs_1.existsSync)(p))
-            .sort((a, b) => (0, node_fs_1.statSync)(b).mtimeMs - (0, node_fs_1.statSync)(a).mtimeMs);
-        cachedSerenaBin = entries.length > 0 ? entries[0] : null;
-    }
-    catch {
-        cachedSerenaBin = null;
-    }
-    return cachedSerenaBin ?? null;
-}
-function spawnSerenaServer() {
-    const projectRoot = findSerenaProjectRoot();
-    const serenaBin = resolveSerenaBin();
-    if (!serenaBin)
-        return;
-    // Spawn the cached Python binary directly with stdio:'ignore' + detached.
-    // Using 'uvx --from git+...' does NOT work because uvx triggers a blocking
-    // git fetch that hangs/dies with closed file descriptors.
-    const child = (0, node_child_process_1.spawn)(serenaBin, ["start-project-server", "--port", String(SERENA_PORT)], {
-        cwd: projectRoot,
-        detached: true,
-        stdio: "ignore",
-        env: { ...process.env },
-    });
-    child.unref();
-}
-async function ensureSerenaServer() {
-    if (await isSerenaAlive())
-        return true;
-    // Deduplicate concurrent start attempts
-    if (serenaStarting)
-        return serenaStarting;
-    serenaStarting = (async () => {
-        spawnSerenaServer();
-        // Poll for readiness (serena can take a few seconds to initialize)
-        const deadline = Date.now() + 30_000;
-        const interval = 500;
-        while (Date.now() < deadline) {
-            await new Promise((r) => setTimeout(r, interval));
-            if (await isSerenaAlive()) {
-                serenaStarting = null;
-                return true;
-            }
-        }
-        serenaStarting = null;
-        return false;
-    })();
-    return serenaStarting;
-}
-async function executeSerena(input, ctx) {
-    if (ctx.abortSignal?.aborted)
-        return (0, utils_js_1.fail)("Operation cancelled");
-    const toolName = SERENA_TOOL_MAP[input.action];
-    if (!toolName)
-        return (0, utils_js_1.fail)(`Unknown serena action: ${input.action}`);
-    const isMutation = ["replace_body", "insert_after", "insert_before", "rename"].includes(input.action);
-    if (isMutation && ctx.confirm) {
-        const desc = input.action === "rename"
-            ? `Rename "${input.name_path}" to "${input.new_name}"?`
-            : `${input.action} on "${input.name_path}"?`;
-        const ok = await ctx.confirm(desc);
-        if (!ok)
-            return (0, utils_js_1.fail)("Cancelled by user");
-    }
-    // Auto-start the Serena project server if not running
-    const alive = await ensureSerenaServer();
-    if (!alive) {
-        return (0, utils_js_1.fail)("Failed to auto-start Serena project server after 30s. " +
-            "Check logs or start manually:\n" +
-            `uvx --from "git+https://github.com/oraios/serena" serena start-project-server --port ${SERENA_PORT}`);
-    }
-    const params = { ...input.extra_args };
-    if (input.name_path) {
-        if (input.action === "find_symbol") {
-            params.name_path_pattern = input.name_path;
-        }
-        else {
-            params.name_path = input.name_path;
-        }
-    }
-    if (input.relative_path)
-        params.relative_path = input.relative_path;
-    if (input.include_body != null)
-        params.include_body = input.include_body;
-    if (input.include_info != null)
-        params.include_info = input.include_info;
-    if (input.depth != null)
-        params.depth = input.depth;
-    if (input.body)
-        params.body = input.body;
-    if (input.new_name)
-        params.new_name = input.new_name;
-    if (input.pattern)
-        params.substring_pattern = input.pattern;
-    if (input.context_before != null)
-        params.context_lines_before = input.context_before;
-    if (input.context_after != null)
-        params.context_lines_after = input.context_after;
-    if (input.paths_include)
-        params.paths_include_glob = input.paths_include;
-    if (input.paths_exclude)
-        params.paths_exclude_glob = input.paths_exclude;
-    try {
-        const body = JSON.stringify({
-            project_name: SERENA_PROJECT,
-            tool_name: toolName,
-            tool_params_json: JSON.stringify(params),
-        });
-        const response = await fetch(`${SERENA_BASE}/query_project`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body,
-            signal: ctx.abortSignal,
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            return (0, utils_js_1.fail)(`serena ${input.action}: HTTP ${response.status} — ${text.slice(0, 200)}`);
-        }
-        const text = await response.text();
-        try {
-            return (0, utils_js_1.success)(`serena ${input.action} completed`, JSON.parse(text));
-        }
-        catch {
-            return (0, utils_js_1.success)(`serena ${input.action} completed`, { raw: text });
-        }
-    }
-    catch (err) {
-        const e = asExecError(err);
-        return (0, utils_js_1.fail)(`serena ${input.action} failed: ${e.message}`);
-    }
-}
-// ---------------------------------------------------------------------------
-// 8. fff — native CLI (fff-cli binary, zero MCP)
-// ---------------------------------------------------------------------------
-async function executeFff(input, ctx) {
-    if (ctx.abortSignal?.aborted)
-        return (0, utils_js_1.fail)("Operation cancelled");
-    if (!(await hasBinary("fff-cli")))
-        return (0, utils_js_1.fail)("fff-cli not installed. Build: cd vendor/fff-cli && cargo build --release && cp target/release/fff-cli ~/.local/bin/");
-    const args = [input.action];
-    // Query or patterns. Native fff-cli supports positional query terms; constraints are
-    // appended as additional terms for grep/find_files and patterns for multi_grep.
-    if (input.action === "multi_grep" && input.patterns?.length) {
-        args.push(...input.patterns);
-        if (input.constraints)
-            args.push(input.constraints);
-    }
-    else {
-        if (input.query)
-            args.push(input.query);
-        if (input.constraints)
-            args.push(input.constraints);
-    }
-    // Path
-    args.push("--path", input.path ?? ctx.workingDir);
-    try {
-        const { stdout } = await shellExec("fff-cli", args, {
-            cwd: ctx.workingDir,
-            signal: ctx.abortSignal,
-            timeout: 30_000,
-        });
-        return (0, utils_js_1.success)(`fff ${input.action} completed`, JSON.parse(stdout));
-    }
-    catch (err) {
-        const e = asExecError(err);
-        return (0, utils_js_1.fail)(`fff ${input.action} failed: ${e.stderr || e.message}`);
-    }
-}
-//# sourceMappingURL=code-intelligence.js.map