callgraph-mcp 1.3.0 → 1.4.1

package/dist/tools/findDuplicates.js

@@ -0,0 +1,254 @@
+"use strict";
+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.registerFindDuplicates = registerFindDuplicates;
+const zod_1 = require("zod");
+const fs = __importStar(require("fs"));
+const analysis_1 = require("../utils/analysis");
+const toolHelper_1 = require("../utils/toolHelper");
+// ---------------------------------------------------------------------------
+// Jaccard similarity between two sets of strings
+// ---------------------------------------------------------------------------
+function jaccard(a, b) {
+    if (a.size === 0 && b.size === 0)
+        return 1;
+    let intersection = 0;
+    for (const v of a)
+        if (b.has(v))
+            intersection++;
+    const union = a.size + b.size - intersection;
+    return union === 0 ? 0 : intersection / union;
+}
+// ---------------------------------------------------------------------------
+// Union-Find to cluster similar functions
+// ---------------------------------------------------------------------------
+class UnionFind {
+    parent = new Map();
+    find(x) {
+        if (this.parent.get(x) !== x) {
+            this.parent.set(x, this.find(this.parent.get(x)));
+        }
+        return this.parent.get(x);
+    }
+    union(x, y) {
+        if (!this.parent.has(x))
+            this.parent.set(x, x);
+        if (!this.parent.has(y))
+            this.parent.set(y, y);
+        const rx = this.find(x);
+        const ry = this.find(y);
+        if (rx !== ry)
+            this.parent.set(rx, ry);
+    }
+    init(id) {
+        if (!this.parent.has(id))
+            this.parent.set(id, id);
+    }
+    clusters() {
+        const map = new Map();
+        for (const id of this.parent.keys()) {
+            const root = this.find(id);
+            if (!map.has(root))
+                map.set(root, []);
+            map.get(root).push(id);
+        }
+        return map;
+    }
+}
+function envThreshold() {
+    const v = parseFloat(process.env.FLOWMAP_DUP_THRESHOLD ?? '');
+    return isFinite(v) && v >= 0 && v <= 1 ? v : 0.75;
+}
+function envMinCallees() {
+    const v = parseInt(process.env.FLOWMAP_DUP_MIN_CALLEES ?? '', 10);
+    return isFinite(v) && v >= 1 ? v : 2;
+}
+function registerFindDuplicates(server) {
+    (0, toolHelper_1.registerTool)(server, 'flowmap_find_duplicates', 'Identify functionally duplicate functions — different names, potentially in different files or components, but calling the same set of dependencies (same business logic). Uses callee-set Jaccard similarity: two functions are flagged as duplicates when the overlap of what they call exceeds the similarity threshold. Results are grouped into clusters so you can see when 3+ functions are all doing the same thing. Use this to find refactoring opportunities and candidates for a shared utility. Default thresholds can be tuned via FLOWMAP_DUP_THRESHOLD and FLOWMAP_DUP_MIN_CALLEES environment variables.', {
+        workspacePath: zod_1.z.string().describe('Absolute path to the repository root'),
+        similarityThreshold: zod_1.z.number().min(0).max(1).optional().describe('Jaccard similarity threshold (0–1). Default: 0.75 (or FLOWMAP_DUP_THRESHOLD env var). Lower = more matches, higher = stricter. 1.0 = identical callee sets.'),
+        minCallees: zod_1.z.number().int().min(1).optional().describe('Minimum number of distinct callees a function must have to be considered. Default: 2 (or FLOWMAP_DUP_MIN_CALLEES env var). Raising this avoids matching trivial one-liner wrappers.'),
+        exclude: zod_1.z.string().optional().describe('Comma-separated glob patterns to exclude. Defaults: node_modules,dist,.git,__pycache__,*.test.*,*.spec.*'),
+    }, async ({ workspacePath, similarityThreshold, minCallees, exclude }) => {
+        const resolvedThreshold = similarityThreshold ?? envThreshold();
+        const resolvedMinCallees = minCallees ?? envMinCallees();
+        try {
+            if (!fs.existsSync(workspacePath)) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: true,
+                                code: 'WORKSPACE_NOT_FOUND',
+                                message: `Directory does not exist: ${workspacePath}`,
+                                workspacePath,
+                            }),
+                        }],
+                };
+            }
+            const DEFAULT_EXCLUDES = ['node_modules', 'dist', '.git', '__pycache__', '*.test.*', '*.spec.*'];
+            const excludeList = exclude
+                ? exclude.split(',').map(s => s.trim()).filter(Boolean)
+                : DEFAULT_EXCLUDES;
+            const graph = await (0, analysis_1.analyzeWorkspace)(workspacePath, { exclude: excludeList });
+            const similarityThreshold = resolvedThreshold;
+            const minCallees = resolvedMinCallees;
+            // Build callee-name set per function
+            // Using callee *names* (not IDs) so the comparison is semantic, not
+            // identity-based — two functions calling `validateInput` both call the
+            // same concept even if the resolved IDs differ across files.
+            const calleeNames = new Map();
+            const nodeById = new Map(graph.nodes.map(n => [n.id, n]));
+            for (const node of graph.nodes) {
+                calleeNames.set(node.id, new Set());
+            }
+            for (const edge of graph.edges) {
+                if (edge.from === edge.to)
+                    continue; // skip self-loops
+                const calleeNode = nodeById.get(edge.to);
+                const calleeName = calleeNode?.name ?? edge.to;
+                calleeNames.get(edge.from)?.add(calleeName);
+            }
+            // Filter to functions with enough callees to be meaningful
+            const candidates = graph.nodes.filter(n => (calleeNames.get(n.id)?.size ?? 0) >= minCallees);
+            // O(n²) pair comparison — guarded by minCallees filter
+            const uf = new UnionFind();
+            for (const node of candidates)
+                uf.init(node.id);
+            // Track best similarity per pair for reporting
+            const pairSimilarity = new Map();
+            for (let i = 0; i < candidates.length; i++) {
+                const a = candidates[i];
+                const setA = calleeNames.get(a.id);
+                for (let j = i + 1; j < candidates.length; j++) {
+                    const b = candidates[j];
+                    // Quick skip: if names are identical and in the same file, not a duplication concern
+                    if (a.name === b.name && a.filePath === b.filePath)
+                        continue;
+                    const setB = calleeNames.get(b.id);
+                    const sim = jaccard(setA, setB);
+                    if (sim >= similarityThreshold) {
+                        uf.union(a.id, b.id);
+                        const key = [a.id, b.id].sort().join('|||');
+                        pairSimilarity.set(key, sim);
+                    }
+                }
+            }
+            // Build clusters — only keep clusters with >1 member
+            const rawClusters = uf.clusters();
+            const duplicateClusters = [];
+            let clusterIndex = 1;
+            for (const [, memberIds] of rawClusters) {
+                if (memberIds.length < 2)
+                    continue;
+                const members = memberIds.map(id => {
+                    const n = nodeById.get(id);
+                    const callees = [...(calleeNames.get(id) ?? [])].sort();
+                    return {
+                        id,
+                        name: n?.name ?? 'unknown',
+                        filePath: n?.filePath ?? 'unknown',
+                        startLine: n?.startLine ?? 0,
+                        language: n?.language ?? 'unknown',
+                        calleeCount: callees.length,
+                        callees,
+                    };
+                });
+                // Shared callees across all members in the cluster
+                const allCalleeSets = memberIds.map(id => calleeNames.get(id));
+                const sharedCallees = [...allCalleeSets[0]].filter(c => allCalleeSets.every(s => s.has(c))).sort();
+                // Compute min/max similarity across all pairs in this cluster
+                let minSim = 1;
+                let maxSim = 0;
+                for (let i = 0; i < memberIds.length; i++) {
+                    for (let j = i + 1; j < memberIds.length; j++) {
+                        const key = [memberIds[i], memberIds[j]].sort().join('|||');
+                        const sim = pairSimilarity.get(key) ?? jaccard(calleeNames.get(memberIds[i]), calleeNames.get(memberIds[j]));
+                        if (sim < minSim)
+                            minSim = sim;
+                        if (sim > maxSim)
+                            maxSim = sim;
+                    }
+                }
+                // Derive a suggestion
+                const uniqueFiles = new Set(members.map(m => m.filePath)).size;
+                const suggestion = uniqueFiles > 1
+                    ? `These ${members.length} functions across ${uniqueFiles} files share the same core logic. Consider extracting a shared utility that accepts parameters for any behavioural differences.`
+                    : `These ${members.length} functions in the same file appear to duplicate logic. Consider merging them or extracting a private helper.`;
+                duplicateClusters.push({
+                    clusterIndex: clusterIndex++,
+                    size: members.length,
+                    members,
+                    sharedCallees,
+                    minSimilarity: Math.round(minSim * 100) / 100,
+                    maxSimilarity: Math.round(maxSim * 100) / 100,
+                    suggestion,
+                });
+            }
+            // Sort by cluster size descending (largest duplication opportunity first)
+            duplicateClusters.sort((a, b) => b.size - a.size || b.sharedCallees.length - a.sharedCallees.length);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            duplicateClusters,
+                            totalClusters: duplicateClusters.length,
+                            totalFunctionsInvolved: duplicateClusters.reduce((s, c) => s + c.size, 0),
+                            parameters: { similarityThreshold, minCallees, envOverrides: { FLOWMAP_DUP_THRESHOLD: process.env.FLOWMAP_DUP_THRESHOLD ?? null, FLOWMAP_DUP_MIN_CALLEES: process.env.FLOWMAP_DUP_MIN_CALLEES ?? null } },
+                            durationMs: graph.durationMs,
+                            scannedFiles: graph.scannedFiles,
+                            note: duplicateClusters.length === 0
+                                ? 'No functionally duplicate functions detected at the current threshold. Try lowering similarityThreshold or minCallees.'
+                                : `${duplicateClusters.length} duplicate cluster(s) found. Each cluster is a group of functions that call the same logical dependencies and are candidates for generalisation.`,
+                        }),
+                    }],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: true,
+                            code: 'PARSE_ERROR',
+                            message,
+                            workspacePath,
+                        }),
+                    }],
+            };
+        }
+    });
+}

package/dist/tools/findOrphans.js

@@ -0,0 +1,100 @@
+"use strict";
+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.registerFindOrphans = registerFindOrphans;
+const zod_1 = require("zod");
+const fs = __importStar(require("fs"));
+const analysis_1 = require("../utils/analysis");
+const toolHelper_1 = require("../utils/toolHelper");
+function registerFindOrphans(server) {
+    (0, toolHelper_1.registerTool)(server, 'flowmap_find_orphans', 'Return all functions that are never called from any entry point — potential dead code. Use this during refactoring to identify code that can safely be removed.', {
+        workspacePath: zod_1.z.string().describe('Absolute path to the repository root'),
+    }, async ({ workspacePath }) => {
+        try {
+            if (!fs.existsSync(workspacePath)) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: true,
+                                code: 'WORKSPACE_NOT_FOUND',
+                                message: `Directory does not exist: ${workspacePath}`,
+                                workspacePath,
+                            }),
+                        }],
+                };
+            }
+            const graph = await (0, analysis_1.analyzeWorkspace)(workspacePath);
+            const orphans = graph.orphans.map(orphanId => {
+                const node = graph.nodes.find(n => n.id === orphanId);
+                return node
+                    ? {
+                        id: node.id,
+                        name: node.name,
+                        filePath: node.filePath,
+                        startLine: node.startLine,
+                        language: node.language,
+                        isExported: node.isExported,
+                    }
+                    : { id: orphanId, name: 'unknown', filePath: 'unknown', startLine: 0 };
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            orphans,
+                            count: orphans.length,
+                            durationMs: graph.durationMs,
+                            note: 'Exported functions may be used by external consumers — verify before deleting.',
+                        }),
+                    }],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: true,
+                            code: 'PARSE_ERROR',
+                            message,
+                            workspacePath,
+                        }),
+                    }],
+            };
+        }
+    });
+}

package/dist/tools/getCallees.js

@@ -0,0 +1,116 @@
+"use strict";
+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.registerGetCallees = registerGetCallees;
+const zod_1 = require("zod");
+const fs = __importStar(require("fs"));
+const analysis_1 = require("../utils/analysis");
+const toolHelper_1 = require("../utils/toolHelper");
+function registerGetCallees(server) {
+    (0, toolHelper_1.registerTool)(server, 'flowmap_get_callees', 'Return all functions directly called by the named function. Use this to understand what a function depends on.', {
+        functionName: zod_1.z.string().describe('The function name to find callees of'),
+        workspacePath: zod_1.z.string().describe('Absolute path to the repository root'),
+    }, async ({ functionName, workspacePath }) => {
+        try {
+            if (!fs.existsSync(workspacePath)) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: true,
+                                code: 'WORKSPACE_NOT_FOUND',
+                                message: `Directory does not exist: ${workspacePath}`,
+                                workspacePath,
+                            }),
+                        }],
+                };
+            }
+            const graph = await (0, analysis_1.analyzeWorkspace)(workspacePath);
+            const targets = graph.nodes.filter(n => n.name === functionName);
+            if (targets.length === 0) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: true,
+                                code: 'FUNCTION_NOT_FOUND',
+                                message: `No function named "${functionName}" found in the codebase.`,
+                                workspacePath,
+                            }),
+                        }],
+                };
+            }
+            const target = targets[0];
+            const targetIds = new Set(targets.map(t => t.id));
+            // Find edges where from is one of the target IDs
+            const calleeEdges = graph.edges.filter(e => targetIds.has(e.from));
+            const callees = calleeEdges.map(edge => {
+                const calleeNode = graph.nodes.find(n => n.id === edge.to);
+                return {
+                    id: edge.to,
+                    name: calleeNode?.name ?? 'unknown',
+                    filePath: calleeNode?.filePath ?? 'unknown',
+                    startLine: calleeNode?.startLine ?? 0,
+                    callLine: edge.line,
+                };
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            target: functionName,
+                            targetId: target.id,
+                            callees,
+                            count: callees.length,
+                        }),
+                    }],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: true,
+                            code: 'PARSE_ERROR',
+                            message,
+                            workspacePath,
+                        }),
+                    }],
+            };
+        }
+    });
+}

package/dist/tools/getCallers.js

@@ -0,0 +1,117 @@
+"use strict";
+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.registerGetCallers = registerGetCallers;
+const zod_1 = require("zod");
+const fs = __importStar(require("fs"));
+const analysis_1 = require("../utils/analysis");
+const toolHelper_1 = require("../utils/toolHelper");
+function registerGetCallers(server) {
+    (0, toolHelper_1.registerTool)(server, 'flowmap_get_callers', 'Return all functions that directly call the named function. Use this for impact analysis — to understand what breaks if you change a function\'s signature.', {
+        functionName: zod_1.z.string().describe('The function name to find callers of'),
+        workspacePath: zod_1.z.string().describe('Absolute path to the repository root'),
+    }, async ({ functionName, workspacePath }) => {
+        try {
+            if (!fs.existsSync(workspacePath)) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: true,
+                                code: 'WORKSPACE_NOT_FOUND',
+                                message: `Directory does not exist: ${workspacePath}`,
+                                workspacePath,
+                            }),
+                        }],
+                };
+            }
+            const graph = await (0, analysis_1.analyzeWorkspace)(workspacePath);
+            // Find target function(s) by name
+            const targets = graph.nodes.filter(n => n.name === functionName);
+            if (targets.length === 0) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: true,
+                                code: 'FUNCTION_NOT_FOUND',
+                                message: `No function named "${functionName}" found in the codebase.`,
+                                workspacePath,
+                            }),
+                        }],
+                };
+            }
+            const target = targets[0];
+            const targetIds = new Set(targets.map(t => t.id));
+            // Find edges where to is one of the target IDs
+            const callerEdges = graph.edges.filter(e => targetIds.has(e.to));
+            const callers = callerEdges.map(edge => {
+                const callerNode = graph.nodes.find(n => n.id === edge.from);
+                return {
+                    id: edge.from,
+                    name: callerNode?.name ?? 'unknown',
+                    filePath: callerNode?.filePath ?? 'unknown',
+                    startLine: callerNode?.startLine ?? 0,
+                    callLine: edge.line,
+                };
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            target: functionName,
+                            targetId: target.id,
+                            callers,
+                            count: callers.length,
+                        }),
+                    }],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: true,
+                            code: 'PARSE_ERROR',
+                            message,
+                            workspacePath,
+                        }),
+                    }],
+            };
+        }
+    });
+}