@nxuss/lemma 0.9.2 → 0.9.3

package/dist/cjs/mcp/tools.js

@@ -530,6 +530,39 @@ const toolDefinitions = [
             required: ["platform"],
         },
     },
+    {
+        name: "depgraph",
+        description: "Builds a real-time dependency graph for any file in the workspace using the TypeScript Compiler API. Shows what a file imports, what imports it (reverse deps), and what it exports. Zero LLM calls. Essential before any refactor to understand blast radius.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Target file path relative to workspace root" },
+                reverse: { type: "boolean", description: "Include reverse dependencies (who imports this file)", default: true },
+                depth: { type: "number", description: "Graph traversal depth 1-5 (default: 1)", default: 1 },
+                format: { type: "string", enum: ["text", "mermaid", "json"], description: "Output format: text tree, Mermaid flowchart, or JSON", default: "text" },
+                external: { type: "boolean", description: "Include node_modules dependencies (default: false)", default: false },
+                circular: { type: "boolean", description: "Detect and highlight circular dependencies", default: false },
+            },
+            required: ["filePath"],
+        },
+    },
+    {
+        name: "refactor",
+        description: "Declarative multi-file codemod engine. Rename symbols across the entire workspace or move files updating all imports. Uses TypeScript Compiler API — zero LLM calls. Supports dry-run diff preview and post-refactor tsc verification.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                operation: { type: "string", enum: ["rename", "move"], description: "Refactor operation: 'rename' a symbol everywhere, or 'move' a file updating all importers" },
+                from: { type: "string", description: "Symbol name to rename (rename op) OR source file path relative to workspace root (move op)" },
+                to: { type: "string", description: "New symbol name (rename op) OR destination file path relative to workspace root (move op)" },
+                file: { type: "string", description: "File where the symbol is declared — required for 'rename' operation" },
+                dryRun: { type: "boolean", description: "Preview changes as a unified diff without applying them", default: false },
+                tscCheck: { type: "boolean", description: "Run tsc --noEmit after applying to guarantee zero TypeScript errors", default: false },
+                backup: { type: "boolean", description: "Create .bak backup of each modified file before changing", default: false },
+            },
+            required: ["operation", "from", "to"],
+        },
+    },
 ];
 const toolHandlers = {
     scrub_privacy: handleScrubPrivacy,
@@ -568,6 +601,8 @@ const toolHandlers = {
     review_pr: handleReviewPR,
     pr_status: handlePRStatus,
     generate_pr_workflow: handleGeneratePRWorkflow,
+    depgraph: handleDepgraph,
+    refactor: handleRefactor,
 };
 function setupToolsHandlers(server, onToolCall) {
     server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
@@ -2660,4 +2695,588 @@ function generateAzurePipelineYaml(threshold) {
         `      AZURE_DEVOPS_TOKEN: \$(AZURE_DEVOPS_TOKEN)`,
     ].join("\n");
 }
+function buildDepGraphMap(workspaceRoot) {
+    const map = new Map();
+    const IGNORE_DG = new Set(["node_modules", ".git", "dist", "chroma_data", ".lemma", "build", "coverage", ".next"]);
+    function walkDG(dir) {
+        let entries = [];
+        try {
+            entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (IGNORE_DG.has(e.name))
+                continue;
+            const abs = path_1.default.join(dir, e.name);
+            if (e.isDirectory()) {
+                walkDG(abs);
+            }
+            else if (/\.(ts|tsx|js|jsx)$/.test(e.name) && !e.name.endsWith(".d.ts")) {
+                const rel = path_1.default.relative(workspaceRoot, abs).replace(/\\/g, "/");
+                map.set(rel, { rel, abs, imports: [], importedBy: [], externalImports: [], exports: [] });
+            }
+        }
+    }
+    walkDG(workspaceRoot);
+    for (const [, node] of map) {
+        try {
+            const src = fs_1.default.readFileSync(node.abs, "utf8");
+            const sf = ts.createSourceFile(node.abs, src, ts.ScriptTarget.Latest, true);
+            ts.forEachChild(sf, (n) => {
+                if (ts.isImportDeclaration(n) && ts.isStringLiteral(n.moduleSpecifier)) {
+                    const spec = n.moduleSpecifier.text;
+                    if (spec.startsWith(".")) {
+                        const dir = path_1.default.dirname(node.abs);
+                        let resolved = path_1.default.resolve(dir, spec);
+                        for (const ext of [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"]) {
+                            if (fs_1.default.existsSync(resolved + ext)) {
+                                resolved += ext;
+                                break;
+                            }
+                        }
+                        const rel = path_1.default.relative(workspaceRoot, resolved).replace(/\\/g, "/");
+                        if (!node.imports.includes(rel))
+                            node.imports.push(rel);
+                    }
+                    else {
+                        const pkg = spec.split("/")[0];
+                        if (!node.externalImports.includes(pkg))
+                            node.externalImports.push(pkg);
+                    }
+                }
+                const hasExportMod = (nd) => ts.canHaveModifiers(nd) &&
+                    (ts.getModifiers(nd) ?? []).some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+                if (hasExportMod(n)) {
+                    if (ts.isFunctionDeclaration(n) && n.name)
+                        node.exports.push(n.name.text);
+                    else if (ts.isClassDeclaration(n) && n.name)
+                        node.exports.push(n.name.text);
+                    else if (ts.isVariableStatement(n)) {
+                        for (const decl of n.declarationList.declarations) {
+                            if (ts.isIdentifier(decl.name))
+                                node.exports.push(decl.name.text);
+                        }
+                    }
+                    else if (ts.isInterfaceDeclaration(n))
+                        node.exports.push(n.name.text);
+                    else if (ts.isTypeAliasDeclaration(n))
+                        node.exports.push(n.name.text);
+                    else if (ts.isEnumDeclaration(n))
+                        node.exports.push(n.name.text);
+                }
+                if (ts.isExportDeclaration(n) && n.exportClause && ts.isNamedExports(n.exportClause)) {
+                    for (const el of n.exportClause.elements)
+                        node.exports.push(el.name.text);
+                }
+            });
+        }
+        catch { /* skip unparseable */ }
+    }
+    for (const [, node] of map) {
+        for (const imp of node.imports) {
+            const target = map.get(imp);
+            if (target && !target.importedBy.includes(node.rel))
+                target.importedBy.push(node.rel);
+        }
+    }
+    return map;
+}
+function bfsDepGraph(map, startRel, direction, maxDepth) {
+    const visited = new Map();
+    const queue = [{ rel: startRel, depth: 0 }];
+    while (queue.length > 0) {
+        const item = queue.shift();
+        if (visited.has(item.rel) || item.depth > maxDepth)
+            continue;
+        const node = map.get(item.rel);
+        if (!node)
+            continue;
+        visited.set(item.rel, { node, depth: item.depth });
+        if (item.depth < maxDepth) {
+            const neighbors = direction === "forward" ? node.imports : node.importedBy;
+            for (const n of neighbors)
+                queue.push({ rel: n, depth: item.depth + 1 });
+        }
+    }
+    return visited;
+}
+function detectDepCycles(map, subset) {
+    const cycles = [];
+    const visited = new Set();
+    const stack = new Set();
+    function dfs(rel, currentPath) {
+        if (stack.has(rel)) {
+            const idx = currentPath.indexOf(rel);
+            if (idx >= 0)
+                cycles.push([...currentPath.slice(idx), rel]);
+            return;
+        }
+        if (visited.has(rel))
+            return;
+        visited.add(rel);
+        stack.add(rel);
+        const node = map.get(rel);
+        if (node) {
+            for (const imp of node.imports) {
+                if (!subset || subset.has(imp))
+                    dfs(imp, [...currentPath, rel]);
+            }
+        }
+        stack.delete(rel);
+    }
+    const keys = subset ? [...subset] : [...map.keys()];
+    for (const k of keys)
+        dfs(k, []);
+    return cycles;
+}
+function formatDGText(targetNode, forwardVisited, backwardVisited, cycles, includeExternal, showReverse) {
+    const lines = [`📦 ${targetNode.rel}`];
+    const directImports = targetNode.imports;
+    const externalImps = includeExternal ? targetNode.externalImports : [];
+    const allImports = [...directImports, ...externalImps];
+    if (allImports.length > 0) {
+        lines.push("├── importa:");
+        allImports.forEach((imp, i) => {
+            const isLast = i === allImports.length - 1;
+            const prefix = isLast ? "│   └──" : "│   ├──";
+            const isExt = externalImps.includes(imp);
+            if (isExt) {
+                lines.push(`${prefix} ${imp}  (external)`);
+            }
+            else {
+                const impNode = forwardVisited.get(imp)?.node;
+                const expSuffix = impNode && impNode.exports.length > 0
+                    ? `  → ${impNode.exports.slice(0, 3).join(", ")}${impNode.exports.length > 3 ? "…" : ""}`
+                    : "";
+                lines.push(`${prefix} ${imp}${expSuffix}`);
+                if (impNode && impNode.imports.length > 0) {
+                    impNode.imports.forEach((subImp, si) => {
+                        const subPrefix = si === impNode.imports.length - 1 ? "│       └──" : "│       ├──";
+                        if (subImp !== targetNode.rel)
+                            lines.push(`${subPrefix} ${subImp}`);
+                    });
+                }
+            }
+        });
+    }
+    else {
+        lines.push("├── importa: (ninguno)");
+    }
+    if (showReverse) {
+        const revDeps = targetNode.importedBy;
+        if (revDeps.length > 0) {
+            lines.push("├── es importado por:");
+            revDeps.forEach((dep, i) => {
+                const prefix = i === revDeps.length - 1 ? "│   └──" : "│   ├──";
+                lines.push(`${prefix} ${dep}`);
+                const depNode = backwardVisited.get(dep)?.node;
+                if (depNode && depNode.importedBy.length > 0) {
+                    depNode.importedBy.forEach((subDep, si) => {
+                        const subPrefix = si === depNode.importedBy.length - 1 ? "│       └──" : "│       ├──";
+                        if (subDep !== targetNode.rel)
+                            lines.push(`${subPrefix} ${subDep}`);
+                    });
+                }
+            });
+        }
+        else {
+            lines.push("├── es importado por: (nadie — posible dead export)");
+        }
+    }
+    if (targetNode.exports.length > 0) {
+        lines.push("└── exporta:");
+        targetNode.exports.forEach((exp, i) => {
+            const prefix = i === targetNode.exports.length - 1 ? "    └──" : "    ├──";
+            lines.push(`${prefix} ${exp}`);
+        });
+    }
+    else {
+        lines.push("└── exporta: (ningún export detectado)");
+    }
+    if (cycles.length > 0) {
+        lines.push("");
+        lines.push("⚠️  DEPENDENCIAS CIRCULARES DETECTADAS:");
+        cycles.slice(0, 5).forEach((c) => lines.push(`  🔄 ${c.join(" → ")}`));
+    }
+    return lines.join("\n");
+}
+function formatDGMermaid(targetNode, forwardVisited, backwardVisited, cycles, includeExternal, showReverse) {
+    const lines = ["flowchart LR"];
+    const addedEdges = new Set();
+    const safeId = (s) => s.replace(/[^a-zA-Z0-9_]/g, "_");
+    const tid = safeId(targetNode.rel);
+    lines.push(`  ${tid}["📦 ${path_1.default.basename(targetNode.rel)}"]`);
+    lines.push(`  style ${tid} fill:#6366f1,color:#fff,stroke:#4f46e5`);
+    for (const imp of targetNode.imports) {
+        const eid = `${tid}-->${safeId(imp)}`;
+        if (!addedEdges.has(eid)) {
+            addedEdges.add(eid);
+            lines.push(`  ${tid} --> ${safeId(imp)}["${path_1.default.basename(imp)}"]`);
+        }
+    }
+    if (includeExternal) {
+        for (const ext of targetNode.externalImports) {
+            const extId = safeId(`ext_${ext}`);
+            lines.push(`  ${tid} --> ${extId}["📦 ${ext}"]`);
+            lines.push(`  style ${extId} fill:#374151,color:#9ca3af,stroke:#374151`);
+        }
+    }
+    for (const [rel, { node }] of forwardVisited) {
+        if (rel === targetNode.rel)
+            continue;
+        for (const imp of node.imports) {
+            const eid = `${safeId(rel)}-->${safeId(imp)}`;
+            if (!addedEdges.has(eid)) {
+                addedEdges.add(eid);
+                lines.push(`  ${safeId(rel)} --> ${safeId(imp)}["${path_1.default.basename(imp)}"]`);
+            }
+        }
+    }
+    if (showReverse) {
+        for (const dep of targetNode.importedBy) {
+            const eid = `${safeId(dep)}-->${tid}`;
+            if (!addedEdges.has(eid)) {
+                addedEdges.add(eid);
+                lines.push(`  ${safeId(dep)}["${path_1.default.basename(dep)}"] --> ${tid}`);
+                lines.push(`  style ${safeId(dep)} fill:#065f46,color:#fff,stroke:#047857`);
+            }
+        }
+        for (const [rel, { node }] of backwardVisited) {
+            if (rel === targetNode.rel)
+                continue;
+            for (const dep of node.importedBy) {
+                const eid = `${safeId(dep)}-->${safeId(rel)}`;
+                if (!addedEdges.has(eid)) {
+                    addedEdges.add(eid);
+                    lines.push(`  ${safeId(dep)}["${path_1.default.basename(dep)}"] --> ${safeId(rel)}["${path_1.default.basename(rel)}"]`);
+                }
+            }
+        }
+    }
+    if (cycles.length > 0) {
+        lines.push(`  %% ⚠️ Cycles: ${cycles.length}`);
+        cycles.slice(0, 3).forEach(c => lines.push(`  %% ${c.join(" → ")}`));
+    }
+    return lines.join("\n");
+}
+async function handleDepgraph(args) {
+    const filePath = args?.filePath;
+    const showReverse = args?.reverse !== false;
+    const depth = Math.min(Math.max(typeof args?.depth === "number" ? args.depth : 1, 1), 5);
+    const format = args?.format || "text";
+    const includeExternal = !!(args?.external);
+    const detectCircular = !!(args?.circular);
+    const workspaceRoot = process.cwd();
+    if (!filePath)
+        throw new Error("filePath is required");
+    try {
+        const { resolved } = (0, utils_1.safeResolvePath)(workspaceRoot, filePath);
+        const relTarget = path_1.default.relative(workspaceRoot, resolved).replace(/\\/g, "/");
+        const map = buildDepGraphMap(workspaceRoot);
+        const targetNode = map.get(relTarget);
+        if (!targetNode) {
+            return { content: [{ type: "text", text: `File not found in workspace graph: ${relTarget}\nCheck path is correct and has .ts/.tsx/.js/.jsx extension.` }] };
+        }
+        const forwardVisited = bfsDepGraph(map, relTarget, "forward", depth);
+        const backwardVisited = showReverse ? bfsDepGraph(map, relTarget, "backward", depth) : new Map();
+        const allRelInScope = new Set([...forwardVisited.keys(), ...(showReverse ? backwardVisited.keys() : [])]);
+        const cycles = detectCircular ? detectDepCycles(map, allRelInScope) : [];
+        let output;
+        if (format === "json") {
+            const jsonResult = {
+                target: relTarget,
+                imports: targetNode.imports,
+                importedBy: showReverse ? targetNode.importedBy : undefined,
+                externalImports: includeExternal ? targetNode.externalImports : undefined,
+                exports: targetNode.exports,
+                cycles: cycles.length > 0 ? cycles : undefined,
+                subGraph: {
+                    forward: Object.fromEntries([...forwardVisited.entries()].map(([k, v]) => [k, { depth: v.depth, imports: v.node.imports }])),
+                    backward: showReverse ? Object.fromEntries([...backwardVisited.entries()].map(([k, v]) => [k, { depth: v.depth, importedBy: v.node.importedBy }])) : undefined,
+                },
+            };
+            output = JSON.stringify(jsonResult, null, 2);
+        }
+        else if (format === "mermaid") {
+            output = formatDGMermaid(targetNode, forwardVisited, backwardVisited, cycles, includeExternal, showReverse);
+        }
+        else {
+            output = formatDGText(targetNode, forwardVisited, backwardVisited, cycles, includeExternal, showReverse);
+        }
+        const stats = `\n\n📊 Stats: ${forwardVisited.size} nodos forward, ${backwardVisited.size} nodos reverse, depth=${depth}`;
+        return { content: [{ type: "text", text: output + (format === "json" ? "" : stats) }] };
+    }
+    catch (err) {
+        (0, utils_1.logError)("depgraph", err);
+        return { content: [{ type: "text", text: `depgraph failed: ${err.message}` }] };
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// ─── refactor ─────────────────────────────────────────────────────────────────
+// ═══════════════════════════════════════════════════════════════════════════════
+function escapeRegexStr(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findSymbolRefs(workspaceRoot, symbolName) {
+    const results = [];
+    const IGNORE_RF = new Set(["node_modules", ".git", "dist", "chroma_data", ".lemma", "build", "coverage", ".next"]);
+    function walkRF(dir) {
+        let entries = [];
+        try {
+            entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (IGNORE_RF.has(e.name))
+                continue;
+            const abs = path_1.default.join(dir, e.name);
+            if (e.isDirectory()) {
+                walkRF(abs);
+            }
+            else if (/\.(ts|tsx|js|jsx)$/.test(e.name) && !e.name.endsWith(".d.ts")) {
+                const rel = path_1.default.relative(workspaceRoot, abs).replace(/\\/g, "/");
+                try {
+                    const content = fs_1.default.readFileSync(abs, "utf8");
+                    if (!content.includes(symbolName))
+                        continue;
+                    const sf = ts.createSourceFile(abs, content, ts.ScriptTarget.Latest, true);
+                    const contentLines = content.split("\n");
+                    const identifierLines = new Set();
+                    function collectIdents(node) {
+                        if (ts.isIdentifier(node) && node.text === symbolName) {
+                            const { line } = sf.getLineAndCharacterOfPosition(node.getStart());
+                            identifierLines.add(line);
+                        }
+                        ts.forEachChild(node, collectIdents);
+                    }
+                    collectIdents(sf);
+                    const matchingLines = [...identifierLines].map(li => ({ lineIndex: li, lineContent: contentLines[li] ?? "" }));
+                    if (matchingLines.length > 0)
+                        results.push({ abs, rel, lines: matchingLines });
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    walkRF(workspaceRoot);
+    return results;
+}
+function applySymbolRenameInContent(content, fromName, toName) {
+    const regex = new RegExp(`(?<![a-zA-Z0-9_$])${escapeRegexStr(fromName)}(?![a-zA-Z0-9_$])`, "g");
+    return content.replace(regex, toName);
+}
+function buildUnifiedDiff(filePath, before, after) {
+    if (before === after)
+        return "";
+    const bl = before.split("\n");
+    const al = after.split("\n");
+    const diffLines = [`--- a/${filePath}`, `+++ b/${filePath}`];
+    const changed = new Set();
+    const maxLen = Math.max(bl.length, al.length);
+    for (let i = 0; i < maxLen; i++) {
+        if (bl[i] !== al[i])
+            changed.add(i);
+    }
+    let i = 0;
+    while (i < maxLen) {
+        if (!changed.has(i)) {
+            i++;
+            continue;
+        }
+        const hunkStart = Math.max(0, i - 2);
+        let hunkEnd = i + 1;
+        while (hunkEnd < maxLen && changed.has(hunkEnd))
+            hunkEnd++;
+        hunkEnd = Math.min(maxLen, hunkEnd + 2);
+        const bc = Math.min(hunkEnd, bl.length) - hunkStart;
+        const ac = Math.min(hunkEnd, al.length) - hunkStart;
+        diffLines.push(`@@ -${hunkStart + 1},${bc} +${hunkStart + 1},${ac} @@`);
+        for (let j = hunkStart; j < hunkEnd; j++) {
+            if (j >= maxLen)
+                break;
+            if (changed.has(j)) {
+                if (j < bl.length)
+                    diffLines.push(`-${bl[j]}`);
+                if (j < al.length)
+                    diffLines.push(`+${al[j]}`);
+            }
+            else {
+                if (j < bl.length)
+                    diffLines.push(` ${bl[j]}`);
+            }
+        }
+        i = hunkEnd;
+    }
+    return diffLines.join("\n");
+}
+async function handleRefactorRename(args, workspaceRoot) {
+    const fromName = args.from;
+    const toName = args.to;
+    const dryRun = !!(args.dryRun);
+    const tscCheck = !!(args.tscCheck);
+    const backup = !!(args.backup);
+    if (!fromName || !toName)
+        throw new Error("'from' and 'to' are required for rename");
+    const refs = findSymbolRefs(workspaceRoot, fromName);
+    if (refs.length === 0) {
+        return { content: [{ type: "text", text: `No references found to symbol "${fromName}" in the workspace.` }] };
+    }
+    let filesModified = 0;
+    let totalRefs = 0;
+    const report = [];
+    const diffs = [];
+    for (const ref of refs) {
+        const before = fs_1.default.readFileSync(ref.abs, "utf8");
+        const after = applySymbolRenameInContent(before, fromName, toName);
+        if (before === after)
+            continue;
+        const count = (before.match(new RegExp(`(?<![a-zA-Z0-9_$])${escapeRegexStr(fromName)}(?![a-zA-Z0-9_$])`, "g")) || []).length;
+        totalRefs += count;
+        filesModified++;
+        if (dryRun) {
+            const d = buildUnifiedDiff(ref.rel, before, after);
+            if (d)
+                diffs.push(d);
+        }
+        else {
+            if (backup)
+                fs_1.default.writeFileSync(ref.abs + ".bak", before, "utf8");
+            fs_1.default.writeFileSync(ref.abs, after, "utf8");
+            report.push(`  ✅ ${ref.rel} (${count} refs)`);
+        }
+    }
+    if (dryRun) {
+        return { content: [{ type: "text", text: [`🔍 DRY RUN — Rename "${fromName}" → "${toName}"`, ``, `Archivos que cambiarían: ${filesModified} | Referencias: ${totalRefs}`, ``, `=== DIFF PREVIEW ===`, ...diffs].join("\n") }] };
+    }
+    let tscOutput = "";
+    if (tscCheck && filesModified > 0) {
+        try {
+            const out = (0, child_process_1.execSync)("npx tsc --noEmit 2>&1 | head -30 || true", { cwd: workspaceRoot, encoding: "utf8", timeout: 30000 });
+            const errors = out.split("\n").filter((l) => l.includes("error TS"));
+            tscOutput = errors.length === 0 ? "\n\n✅ tsc --noEmit: 0 errores" : `\n\n⚠️ tsc: ${errors.length} error(es):\n${errors.join("\n")}`;
+        }
+        catch (e) {
+            tscOutput = `\n\n⚠️ tsc check falló: ${e.message}`;
+        }
+    }
+    return { content: [{ type: "text", text: [`✅ Rename: "${fromName}" → "${toName}"`, ``, `📁 ${filesModified} archivos | 🔗 ${totalRefs} refs`, ``, ...report].join("\n") + tscOutput }] };
+}
+async function handleRefactorMove(args, workspaceRoot) {
+    const fromRel = args.from;
+    const toRel = args.to;
+    const dryRun = !!(args.dryRun);
+    const tscCheck = !!(args.tscCheck);
+    const backup = !!(args.backup);
+    const { resolved: fromAbs } = (0, utils_1.safeResolvePath)(workspaceRoot, fromRel);
+    const toAbs = path_1.default.resolve(workspaceRoot, toRel);
+    const fromRelNorm = path_1.default.relative(workspaceRoot, fromAbs).replace(/\\/g, "/");
+    const toRelNorm = path_1.default.relative(workspaceRoot, toAbs).replace(/\\/g, "/");
+    if (!fs_1.default.existsSync(fromAbs)) {
+        return { content: [{ type: "text", text: `Source file not found: ${fromRelNorm}` }] };
+    }
+    const IGNORE_MV = new Set(["node_modules", ".git", "dist", "chroma_data", ".lemma", "build", "coverage", ".next"]);
+    const importers = [];
+    function walkMV(dir) {
+        let entries = [];
+        try {
+            entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (IGNORE_MV.has(e.name))
+                continue;
+            const abs = path_1.default.join(dir, e.name);
+            if (e.isDirectory()) {
+                walkMV(abs);
+            }
+            else if (/\.(ts|tsx|js|jsx)$/.test(e.name) && !e.name.endsWith(".d.ts")) {
+                const rel = path_1.default.relative(workspaceRoot, abs).replace(/\\/g, "/");
+                if (rel === fromRelNorm)
+                    return;
+                try {
+                    const content = fs_1.default.readFileSync(abs, "utf8");
+                    const sf = ts.createSourceFile(abs, content, ts.ScriptTarget.Latest, true);
+                    let found = false;
+                    ts.forEachChild(sf, (n) => {
+                        if (!found && ts.isImportDeclaration(n) && ts.isStringLiteral(n.moduleSpecifier)) {
+                            const spec = n.moduleSpecifier.text;
+                            if (spec.startsWith(".")) {
+                                const res = path_1.default.resolve(path_1.default.dirname(abs), spec).replace(/\\/g, "/");
+                                const fromN = fromAbs.replace(/\\/g, "/");
+                                const fromNoExt = fromN.replace(/\.(ts|tsx|js|jsx)$/, "");
+                                if (res === fromN || res === fromNoExt)
+                                    found = true;
+                            }
+                        }
+                    });
+                    if (found)
+                        importers.push({ abs, rel, content });
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    walkMV(workspaceRoot);
+    const addDot = (p) => p.startsWith(".") ? p : `./${p}`;
+    const patches = [];
+    for (const imp of importers) {
+        const oldRelImport = path_1.default.relative(path_1.default.dirname(imp.abs), fromAbs).replace(/\\/g, "/");
+        const newRelImport = path_1.default.relative(path_1.default.dirname(imp.abs), toAbs).replace(/\\/g, "/");
+        const oldSpec = addDot(oldRelImport.replace(/\.(ts|tsx|js|jsx)$/, ""));
+        const newSpec = addDot(newRelImport.replace(/\.(ts|tsx|js|jsx)$/, ""));
+        const after = imp.content.replace(new RegExp(`(['"])${escapeRegexStr(oldSpec)}(['"])`, "g"), `$1${newSpec}$2`);
+        if (after !== imp.content)
+            patches.push({ rel: imp.rel, abs: imp.abs, before: imp.content, after });
+    }
+    if (dryRun) {
+        const diffs = patches.map(p => buildUnifiedDiff(p.rel, p.before, p.after)).filter(Boolean);
+        return { content: [{ type: "text", text: [`🔍 DRY RUN — Move "${fromRelNorm}" → "${toRelNorm}"`, ``, `Importadores que se actualizarían: ${patches.length}`, ``, `=== DIFF PREVIEW ===`, ...diffs].join("\n") }] };
+    }
+    fs_1.default.mkdirSync(path_1.default.dirname(toAbs), { recursive: true });
+    if (backup)
+        fs_1.default.copyFileSync(fromAbs, fromAbs + ".bak");
+    fs_1.default.copyFileSync(fromAbs, toAbs);
+    fs_1.default.unlinkSync(fromAbs);
+    for (const p of patches) {
+        if (backup)
+            fs_1.default.writeFileSync(p.abs + ".bak", p.before, "utf8");
+        fs_1.default.writeFileSync(p.abs, p.after, "utf8");
+    }
+    let tscOutput = "";
+    if (tscCheck) {
+        try {
+            const out = (0, child_process_1.execSync)("npx tsc --noEmit 2>&1 | head -30 || true", { cwd: workspaceRoot, encoding: "utf8", timeout: 30000 });
+            const errors = out.split("\n").filter((l) => l.includes("error TS"));
+            tscOutput = errors.length === 0 ? "\n\n✅ tsc --noEmit: 0 errores" : `\n\n⚠️ tsc: ${errors.length} error(es):\n${errors.join("\n")}`;
+        }
+        catch (e) {
+            tscOutput = `\n\n⚠️ tsc check falló: ${e.message}`;
+        }
+    }
+    return { content: [{ type: "text", text: [`✅ Move: "${fromRelNorm}" → "${toRelNorm}"`, ``, `📁 ${patches.length} importadores actualizados:`, ...patches.map(p => `  ✅ ${p.rel}`)].join("\n") + tscOutput }] };
+}
+async function handleRefactor(args) {
+    const operation = args?.operation;
+    const workspaceRoot = process.cwd();
+    if (!operation)
+        throw new Error("'operation' is required (rename | move)");
+    try {
+        switch (operation) {
+            case "rename": return await handleRefactorRename(args, workspaceRoot);
+            case "move": return await handleRefactorMove(args, workspaceRoot);
+            default:
+                return { content: [{ type: "text", text: `Unknown operation: "${operation}". Supported: rename, move` }] };
+        }
+    }
+    catch (err) {
+        (0, utils_1.logError)("refactor", err);
+        return { content: [{ type: "text", text: `refactor failed: ${err.message}` }] };
+    }
+}
 //# sourceMappingURL=tools.js.map