@nxuss/lemma 0.9.1 → 0.9.3

package/dist/cjs/mcp/tools.js

@@ -49,6 +49,9 @@ const ComplexityRouter_1 = require("../proxy/ComplexityRouter");
 const ContextSqueezer_1 = require("../utils/ContextSqueezer");
 const reportSavings_1 = require("../utils/reportSavings");
 const utils_1 = require("./utils");
+const PRReviewEngine_1 = require("../pr-review/PRReviewEngine");
+const ReviewStore_1 = require("../pr-review/ReviewStore");
+const reviewRunner_1 = require("../pr-review/reviewRunner");
 // ── Pro License Gate ──────────────────────────────────────────────────────────
 const LICENSE_FILE = path_1.default.join(os_1.default.homedir(), '.lemma-cache', 'license.json');
 let _proStatusCache = null;
@@ -471,6 +474,95 @@ const toolDefinitions = [
             },
         },
     },
+    {
+        name: "review_diff",
+        description: "Analyze a raw git diff locally for regressions, security issues, code quality, and static analysis. Zero-cost static analysis using local TypeScript compiler API — no LLM calls. Returns score, verdict, and detailed findings with suggestions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                diff: { type: "string", description: "The git diff content to analyze" },
+                baseBranch: { type: "string", description: "Base branch for regression context", default: "main" },
+                threshold: { type: "number", description: "Quality score threshold for approval (0-100)", default: 90 },
+            },
+            required: ["diff"],
+        },
+    },
+    {
+        name: "review_pr",
+        description: "Analyze a Pull Request via GitHub, Azure DevOps, or GitLab API. Detects regressions, security issues, code quality problems, and breaking changes. Posts results as PR comments and can auto-approve if quality threshold is met. Pro license required.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                platform: { type: "string", enum: ["github", "azure", "gitlab"], description: "Git platform" },
+                repo: { type: "string", description: "Full repo name (e.g., 'owner/repo' or 'org/project/repo')" },
+                prNumber: { type: "number", description: "Pull request number" },
+                autoApprove: { type: "boolean", description: "Auto-approve if score >= threshold", default: true },
+                threshold: { type: "number", description: "Quality score threshold (0-100)", default: 90 },
+                context: { type: "string", description: "Optional context from The Brain about this project" },
+            },
+            required: ["platform", "repo", "prNumber"],
+        },
+    },
+    {
+        name: "pr_status",
+        description: "Get the status and detailed results of a previously reviewed PR. Returns score, verdict, findings, and approval status.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                reviewId: { type: "string", description: "Review ID returned by review_pr" },
+                repo: { type: "string", description: "Optional repo to find by PR number" },
+                prNumber: { type: "number", description: "Optional PR number to find by repo" },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "generate_pr_workflow",
+        description: "Generate a CI/CD workflow file (GitHub Actions or Azure Pipelines) that runs Lemma PR Review on every pull request. Writes the file to the workspace.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                platform: { type: "string", enum: ["github", "azure"], description: "CI platform" },
+                outputPath: { type: "string", description: "Output path for the workflow file", default: ".github/workflows/lemma-pr-review.yml" },
+                autoApprove: { type: "boolean", description: "Enable auto-approve in the workflow", default: true },
+                threshold: { type: "number", description: "Quality threshold for auto-approve", default: 90 },
+            },
+            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,
@@ -505,6 +597,12 @@ const toolHandlers = {
     precrime_static: handlePrecrimeStatic,
     semantic_dedup_guard: handleSemanticDedupGuard,
     dead_export_necromancer: handleDeadExportNecromancer,
+    review_diff: handleReviewDiff,
+    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 () => ({
@@ -2401,4 +2499,784 @@ async function handleDeadExportNecromancer(args) {
         return { content: [{ type: "text", text: `Dead export necromancer failed: ${err.message}` }] };
     }
 }
+// ─── review_diff ─────────────────────────────────────────────────────────────
+async function handleReviewDiff(args) {
+    const diff = args?.diff;
+    const baseBranch = args?.baseBranch || "main";
+    const threshold = args?.threshold || 90;
+    if (!diff)
+        throw new Error("diff is required");
+    const workspaceRoot = process.cwd();
+    try {
+        const diffFiles = (0, PRReviewEngine_1.parseDiff)(diff);
+        if (diffFiles.length === 0) {
+            return { content: [{ type: "text", text: "No parseable diff files found. Ensure the input is a valid git diff output." }] };
+        }
+        const result = (0, PRReviewEngine_1.runAnalysis)(diffFiles, { threshold, autoApprove: false }, workspaceRoot, baseBranch);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `# 🔍 Lemma PR Review — Local Diff Analysis`,
+                        ``,
+                        `**Files analyzed:** ${diffFiles.length}`,
+                        `**Score:** ${result.score}/100 | **Verdict:** ${result.verdict}`,
+                        ``,
+                        result.summary,
+                    ].join("\n"),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        (0, utils_1.logError)("review_diff", err);
+        return { content: [{ type: "text", text: `PR review analysis failed: ${err.message}` }] };
+    }
+}
+// ─── review_pr ─────────────────────────────────────────────────────────────
+async function handleReviewPR(args) {
+    const platform = args?.platform;
+    const repo = args?.repo;
+    const prNumber = args?.prNumber;
+    const autoApprove = args?.autoApprove !== false;
+    const threshold = args?.threshold || 90;
+    if (!platform || !repo || !prNumber) {
+        throw new Error("platform, repo, and prNumber are required");
+    }
+    try {
+        const result = await (0, reviewRunner_1.runPRReview)(platform, repo, prNumber, { autoApprove, threshold });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        (0, utils_1.logError)("review_pr", err);
+        return { content: [{ type: "text", text: `PR review failed: ${err.message}` }] };
+    }
+}
+// ─── pr_status ─────────────────────────────────────────────────────────────
+async function handlePRStatus(args) {
+    const reviewId = args?.reviewId;
+    const repo = args?.repo;
+    const prNumber = args?.prNumber;
+    let review;
+    if (reviewId) {
+        review = ReviewStore_1.ReviewStore.get(reviewId);
+    }
+    else if (repo && prNumber) {
+        review = ReviewStore_1.ReviewStore.findByPR(repo, prNumber);
+    }
+    if (!review) {
+        const allReviews = ReviewStore_1.ReviewStore.getAll();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: allReviews.length === 0
+                        ? "No PR reviews found in this session."
+                        : `PR reviews in this session:\n\n${allReviews.slice(-5).map(r => `- ${r.metadata?.repo || "?"} #${r.metadata?.prNumber || "?"}: ${r.score}/100 — ${r.verdict} (${r.reviewId})`).join("\n")}`,
+                },
+            ],
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: [
+                    `# 📋 PR Review Status`,
+                    ``,
+                    `**Review ID:** ${review.reviewId}`,
+                    `**Repo:** ${review.metadata?.repo || "N/A"}`,
+                    `**PR:** #${review.metadata?.prNumber || "N/A"}`,
+                    `**Score:** ${review.score}/100`,
+                    `**Verdict:** ${review.verdict}`,
+                    `**Approved:** ${review.approved ? "✅ Yes" : "❌ No"}`,
+                    `**Timestamp:** ${review.timestamp}`,
+                    ``,
+                    review.summary,
+                ].join("\n"),
+            },
+        ],
+    };
+}
+// ─── generate_pr_workflow ─────────────────────────────────────────────────
+async function handleGeneratePRWorkflow(args) {
+    const platform = args?.platform;
+    const outputPath = args?.outputPath || ".github/workflows/lemma-pr-review.yml";
+    const autoApprove = args?.autoApprove !== false;
+    const threshold = args?.threshold || 90;
+    if (!platform)
+        throw new Error("platform is required");
+    if (!["github", "azure"].includes(platform)) {
+        throw new Error("platform must be 'github' or 'azure'");
+    }
+    const workspaceRoot = process.cwd();
+    const { resolved } = (0, utils_1.safeResolvePath)(workspaceRoot, outputPath);
+    const dir = path_1.default.dirname(resolved);
+    try {
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        const tokenName = platform === "github" ? "GITHUB_TOKEN" : "AZURE_DEVOPS_TOKEN";
+        const yaml = platform === "github"
+            ? generateGitHubWorkflowYaml(threshold)
+            : generateAzurePipelineYaml(threshold);
+        fs_1.default.writeFileSync(resolved, yaml, "utf8");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✅ Workflow file generated at \`${outputPath}\`\n\nMake sure to add your Lemma license key and ${tokenName} as secrets in your ${platform === "github" ? "GitHub repository" : "Azure Pipeline"}.`,
+                },
+            ],
+        };
+    }
+    catch (err) {
+        (0, utils_1.logError)("generate_pr_workflow", err);
+        return { content: [{ type: "text", text: `Failed to generate workflow: ${err.message}` }] };
+    }
+}
+function generateGitHubWorkflowYaml(threshold) {
+    return [
+        `name: Lemma PR Review`,
+        `on:`,
+        `  pull_request:`,
+        `    types: [opened, synchronize]`,
+        ``,
+        `jobs:`,
+        `  lemma-review:`,
+        `    runs-on: ubuntu-latest`,
+        `    steps:`,
+        `      - uses: actions/checkout@v4`,
+        `        with:`,
+        `          fetch-depth: 0`,
+        `      - uses: actions/setup-node@v4`,
+        `      - run: npm install -g @nxuss/lemma`,
+        `      - run: lemma pr-review --threshold ${threshold}`,
+        `        env:`,
+        `          LEMMA_LICENSE_KEY: \${{ secrets.LEMMA_LICENSE_KEY }}`,
+        `          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}`,
+        `          LEMMA_PLATFORM: github`,
+        `          LEMMA_REPO: \${{ github.repository }}`,
+        `          LEMMA_PR_NUMBER: \${{ github.event.pull_request.number }}`,
+    ].join("\n");
+}
+function generateAzurePipelineYaml(threshold) {
+    return [
+        `trigger: none`,
+        `pr:`,
+        `  branches:`,
+        `    include:`,
+        `      - '*'`,
+        ``,
+        `pool:`,
+        `  vmImage: ubuntu-latest`,
+        ``,
+        `steps:`,
+        `  - checkout: self`,
+        `    fetchDepth: 0`,
+        `  - task: NodeTool@0`,
+        `    inputs:`,
+        `      versionSpec: '18'`,
+        `  - script: npm install -g @nxuss/lemma`,
+        `  - script: lemma pr-review --threshold ${threshold}`,
+        `    env:`,
+        `      LEMMA_LICENSE_KEY: \$(LEMMA_LICENSE_KEY)`,
+        `      LEMMA_PLATFORM: azure`,
+        `      LEMMA_REPO: \$(Build.Repository.Name)`,
+        `      LEMMA_PR_NUMBER: \$(System.PullRequest.PullRequestId)`,
+        `      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