@kridaydave/code-mapper 1.0.0 → 1.0.1

package/src/graph/GraphBuilder.ts

@@ -1,258 +0,0 @@
-import { createRequire } from "node:module";
-const require = createRequire(import.meta.url);
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const Graph: typeof import("graphology").default = require("graphology");
-import type { AbstractGraph, Attributes } from "graphology-types";
-import { ParseResult } from "../parser/types.js";
-import { GraphNode, GraphEdge } from "./types.js";
-
-type CodeGraph = AbstractGraph<Attributes, Attributes, Attributes>;
-
-export class GraphBuilder {
-  build(parseResult: ParseResult): { graph: CodeGraph; nodes: GraphNode[]; edges: GraphEdge[] } {
-    const graph = new Graph({ multi: true });
-    const nodes: GraphNode[] = [];
-    const edges: GraphEdge[] = [];
-
-    const classLookup = new Map<string, { filePath: string; name: string; lineNumber: number }>();
-    for (const fileInfo of parseResult.files) {
-      for (const cls of fileInfo.classes) {
-        classLookup.set(fileInfo.filePath + "::" + cls.name, { filePath: fileInfo.filePath, name: cls.name, lineNumber: cls.lineNumber });
-      }
-    }
-
-    const fileNodeIds = new Map<string, string>();
-
-    // Phase 1: Create file nodes
-    for (const fileInfo of parseResult.files) {
-      const fileId = `file:${fileInfo.filePath}`;
-      fileNodeIds.set(fileInfo.relativePath, fileId);
-      fileNodeIds.set(fileInfo.filePath, fileId);
-
-      graph.addNode(fileId, {
-        kind: "file",
-        label: fileInfo.relativePath,
-        filePath: fileInfo.filePath,
-      });
-
-      nodes.push({
-        id: fileId,
-        kind: "file",
-        label: fileInfo.relativePath,
-        filePath: fileInfo.filePath,
-      });
-    }
-
-    // Phase 2: Create function and class nodes, add containment edges
-    for (const fileInfo of parseResult.files) {
-      const fileId = `file:${fileInfo.filePath}`;
-
-      for (const fn of fileInfo.functions) {
-        const fnId = `fn:${fileInfo.filePath}:${fn.name}:${fn.lineNumber}`;
-        graph.addNode(fnId, {
-          kind: "function",
-          label: fn.name,
-          filePath: fileInfo.filePath,
-          lineNumber: fn.lineNumber,
-        });
-
-        graph.addEdge(fileId, fnId, {
-          kind: "contains",
-          label: `contains ${fn.name}`,
-        });
-
-        edges.push({
-          source: fileId,
-          target: fnId,
-          kind: "contains",
-          label: `contains ${fn.name}`,
-        });
-
-        nodes.push({
-          id: fnId,
-          kind: "function",
-          label: fn.name,
-          filePath: fileInfo.filePath,
-          lineNumber: fn.lineNumber,
-        });
-      }
-
-      for (const cls of fileInfo.classes) {
-        const clsId = `class:${fileInfo.filePath}:${cls.name}:${cls.lineNumber}`;
-        graph.addNode(clsId, {
-          kind: "class",
-          label: cls.name,
-          filePath: fileInfo.filePath,
-          lineNumber: cls.lineNumber,
-        });
-
-        graph.addEdge(fileId, clsId, {
-          kind: "contains",
-          label: `contains ${cls.name}`,
-        });
-
-        edges.push({
-          source: fileId,
-          target: clsId,
-          kind: "contains",
-          label: `contains ${cls.name}`,
-        });
-
-        nodes.push({
-          id: clsId,
-          kind: "class",
-          label: cls.name,
-          filePath: fileInfo.filePath,
-          lineNumber: cls.lineNumber,
-        });
-      }
-    }
-
-    // Phase 3: Build import edges between files
-    for (const fileInfo of parseResult.files) {
-      const sourceFileId = `file:${fileInfo.filePath}`;
-
-      for (const imp of fileInfo.imports) {
-        const targetPath = this.resolveImportPath(fileInfo.filePath, imp.moduleSpecifier, parseResult);
-        if (targetPath) {
-          const targetFileId = `file:${targetPath}`;
-          if (graph.hasNode(targetFileId)) {
-            const edgeLabel = imp.namedImports.length > 0
-              ? `imports {${imp.namedImports.join(", ")}}`
-              : imp.defaultImport
-                ? `imports ${imp.defaultImport}`
-                : "imports module";
-
-            if (!graph.hasEdge(sourceFileId, targetFileId)) {
-              graph.addEdge(sourceFileId, targetFileId, {
-                kind: "imports",
-                label: edgeLabel,
-              });
-
-              edges.push({
-                source: sourceFileId,
-                target: targetFileId,
-                kind: "imports",
-                label: edgeLabel,
-              });
-            }
-          }
-        }
-      }
-    }
-
-    // Phase 4: Build extends/implements edges for classes
-    for (const fileInfo of parseResult.files) {
-      for (const cls of fileInfo.classes) {
-        const clsId = `class:${fileInfo.filePath}:${cls.name}:${cls.lineNumber}`;
-
-        if (cls.extends) {
-          // Try to find the parent class in the codebase
-          const parentName = cls.extends.split("<")[0].trim(); // Handle generics
-          const parentClass = this.findClassByName(parentName, parseResult, classLookup);
-          if (parentClass) {
-            const parentId = `class:${parentClass.filePath}:${parentClass.name}:${parentClass.lineNumber}`;
-            if (graph.hasNode(parentId)) {
-              graph.addEdge(clsId, parentId, {
-                kind: "extends",
-                label: `extends ${parentClass.name}`,
-              });
-              edges.push({
-                source: clsId,
-                target: parentId,
-                kind: "extends",
-                label: `extends ${parentClass.name}`,
-              });
-            }
-          }
-        }
-
-        for (const impl of cls.implements) {
-          const implName = impl.split("<")[0].trim();
-          const implClass = this.findClassByName(implName, parseResult, classLookup);
-          if (implClass) {
-            const implId = `class:${implClass.filePath}:${implClass.name}:${implClass.lineNumber}`;
-            if (graph.hasNode(implId)) {
-              graph.addEdge(clsId, implId, {
-                kind: "implements",
-                label: `implements ${implClass.name}`,
-              });
-              edges.push({
-                source: clsId,
-                target: implId,
-                kind: "implements",
-                label: `implements ${implClass.name}`,
-              });
-            }
-          }
-        }
-      }
-    }
-
-    return { graph, nodes, edges };
-  }
-
-  private resolveImportPath(fromFile: string, moduleSpecifier: string, parseResult: ParseResult): string | null {
-    // Skip external packages (no leading . or /)
-    if (!moduleSpecifier.startsWith(".") && !moduleSpecifier.startsWith("/")) {
-      return null;
-    }
-
-    // Strip .js/.jsx/.ts/.tsx extension from the specifier
-    let specifier = moduleSpecifier;
-    for (const ext of [".js", ".jsx", ".ts", ".tsx"]) {
-      if (specifier.endsWith(ext)) {
-        specifier = specifier.slice(0, -ext.length);
-        break;
-      }
-    }
-
-    // Resolve relative path using forward-slash logic (ts-morph always uses /)
-    const fromDir = fromFile.replace(/\\/g, "/").replace(/\/[^/]+$/, "");
-    const parts = [...(fromDir === "" ? [] : fromDir.split("/")), ...specifier.split("/")];
-    const resolved: string[] = [];
-     for (const part of parts) {
-       if (part === "..") {
-         if (resolved.length > 0) {
-           resolved.pop();
-         }
-         // else: excessive ".." — ignore, prevents escaping root
-       } else if (part !== "." && part !== "") {
-         resolved.push(part);
-       }
-     }
-     // Reconstruct with the drive prefix if present
-     let resolvedPath = resolved.join("/");
-     // If original fromFile had a Windows drive letter, preserve it
-     const fromFileNormalized = fromFile.replace(/\\/g, "/");
-     const driveMatch = fromFileNormalized.match(/^([A-Za-z]:\/)/);
-      if (driveMatch && !resolvedPath.startsWith(driveMatch[1])) {
-        resolvedPath = driveMatch[1] + resolvedPath;
-      }
-
-    // Try exact match first
-    if (parseResult.files.some(f => f.filePath === resolvedPath)) {
-      return resolvedPath;
-    }
-
-    // Try adding extensions
-    const extensions = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
-    for (const ext of extensions) {
-      const candidate = resolvedPath + ext;
-      if (parseResult.files.some(f => f.filePath === candidate)) {
-        return candidate;
-      }
-    }
-
-    return null;
-  }
-
-  private findClassByName(name: string, _parseResult: ParseResult, classLookup: Map<string, { filePath: string; name: string; lineNumber: number }>): { filePath: string; name: string; lineNumber: number } | null {
-    for (const [_key, value] of classLookup) {
-      if (value.name === name) {
-        return value;
-      }
-    }
-    return null;
-  }
-}

package/src/graph/types.ts

@@ -1,42 +0,0 @@
-export interface GraphNode {
-  id: string;
-  kind: "file" | "function" | "class";
-  label: string;
-  filePath: string;
-  lineNumber?: number;
-  metadata?: Record<string, unknown>;
-}
-
-export interface GraphEdge {
-  source: string;
-  target: string;
-  kind: "imports" | "calls" | "extends" | "implements" | "contains";
-  label: string;
-}
-
-export interface RankedFile {
-  filePath: string;
-  relativePath: string;
-  score: number;
-  metric: string;
-  functionCount: number;
-  classCount: number;
-  importCount: number;
-  exportCount: number;
-}
-
-export interface FunctionMatch {
-  name: string;
-  filePath: string;
-  relativePath: string;
-  lineNumber: number;
-  kind: "function" | "class";
-  parameters: string[];
-  returnType: string;
-  isExported: boolean;
-}
-
-export interface CallChainResult {
-  found: boolean;
-  paths: string[][];
-}

package/src/index.ts

@@ -1,38 +0,0 @@
-#!/usr/bin/env node
-
-import { McpServer } from "@modelcontextprotocol/server";
-import { StdioServerTransport } from "@modelcontextprotocol/server";
-import { registerTools } from "./mcp/tools.js";
-import { registerResources } from "./mcp/resources.js";
-
-async function main() {
-  const server = new McpServer(
-     {
-       name: "code-mapper",
-       version: "1.0.0",
-     },
-     {
-       instructions:
-         "CodeMapper analyzes TypeScript/JavaScript codebases using AST parsing. " +
-         "Always start by calling scan_codebase with the target directory. " +
-         "Then use find_function to locate symbols, analyze_dependencies to see the graph, " +
-         "rank_impact to find central files, or trace_call_chain to follow dependency paths. " +
-         "The codebase://summary and codebase://graph/{format} resources provide cached views.",
-     }
-  );
-
-  // Register all tools and resources
-  registerTools(server);
-  registerResources(server);
-
-  // Connect via stdio
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-
-  console.error("CodeMapper MCP server running on stdio");
-}
-
-main().catch((error) => {
-  console.error("Fatal error:", error);
-  process.exit(1);
-});

package/src/mcp/cache.ts

@@ -1,89 +0,0 @@
-import { resolve } from "node:path";
-import { GraphAnalyzer } from "../graph/GraphAnalyzer.js";
-
-interface CacheEntry {
-  analyzer: GraphAnalyzer;
-  timestamp: number;
-}
-
-const MAX_CACHE_SIZE = 10;
-const CACHE_TTL_MS = 30 * 60 * 1000;
-
-export const analyzerCache = new Map<string, CacheEntry>();
-const pendingAnalyzers = new Map<string, Promise<GraphAnalyzer>>();
-
-let _lastScannedDirectory: string | null = null;
-
-export function setLastScannedDirectory(dir: string): void {
-  _lastScannedDirectory = dir;
-}
-
-export function getLastScannedDirectory(): string | null {
-  return _lastScannedDirectory;
-}
-
-export function normalizeCacheKey(directory: string): string {
-  return resolve(directory);
-}
-
-function evictIfNeeded(): void {
-  if (analyzerCache.size >= MAX_CACHE_SIZE) {
-    let oldestKey: string | null = null;
-    let oldestTime = Infinity;
-    for (const [key, entry] of analyzerCache) {
-      if (entry.timestamp < oldestTime) {
-        oldestTime = entry.timestamp;
-        oldestKey = key;
-      }
-    }
-    if (oldestKey) {
-      analyzerCache.delete(oldestKey);
-    }
-  }
-}
-
-function isEntryExpired(entry: CacheEntry): boolean {
-  return Date.now() - entry.timestamp > CACHE_TTL_MS;
-}
-
-export function getAnalyzerFromCache(directory: string): GraphAnalyzer | undefined {
-  const normalizedDir = normalizeCacheKey(directory);
-  const entry = analyzerCache.get(normalizedDir);
-  if (entry && !isEntryExpired(entry)) {
-    return entry.analyzer;
-  }
-  if (entry) {
-    analyzerCache.delete(normalizedDir);
-  }
-  return undefined;
-}
-
-export function setAnalyzerInCache(directory: string, analyzer: GraphAnalyzer): void {
-  evictIfNeeded();
-  const normalizedDir = normalizeCacheKey(directory);
-  analyzerCache.set(normalizedDir, {
-    analyzer,
-    timestamp: Date.now(),
-  });
-}
-
-export function getPendingAnalyzer(directory: string): Promise<GraphAnalyzer> | undefined {
-  const normalizedDir = normalizeCacheKey(directory);
-  return pendingAnalyzers.get(normalizedDir);
-}
-
-export function setPendingAnalyzer(directory: string, promise: Promise<GraphAnalyzer>): void {
-  const normalizedDir = normalizeCacheKey(directory);
-  pendingAnalyzers.set(normalizedDir, promise);
-  promise.finally(() => {
-    pendingAnalyzers.delete(normalizedDir);
-  });
-}
-
-export function clearAnalyzerCache(directory?: string): void {
-  if (directory) {
-    analyzerCache.delete(normalizeCacheKey(directory));
-  } else {
-    analyzerCache.clear();
-  }
-}

package/src/mcp/resources.ts

@@ -1,137 +0,0 @@
-import { McpServer, ResourceTemplate } from "@modelcontextprotocol/server";
-import { GraphNode, GraphEdge, RankedFile } from "../graph/types.js";
-import { analyzerCache, getLastScannedDirectory, getAnalyzerFromCache } from "./cache.js";
-
-const RANK_CACHE_LIMIT = 100;
-const rankCache = new Map<string, RankedFile[]>();
-
-export function registerResources(server: McpServer): void {
-  // Resource 1: codebase://summary
-  server.registerResource(
-    "codebase-summary",
-    "codebase://summary",
-    {
-      title: "Codebase Summary",
-      description: "Returns a summary of the most recently scanned codebase. Scan a codebase first using the scan_codebase tool.",
-      mimeType: "application/json",
-    },
-    async () => {
-      if (analyzerCache.size === 0) {
-        return {
-          contents: [{
-            uri: "codebase://summary",
-            text: JSON.stringify({ message: "No codebase has been scanned yet. Use the scan_codebase tool first." }, null, 2),
-          }],
-        };
-      }
-
-      const summaries: Record<string, unknown>[] = [];
-      for (const [directory, entry] of analyzerCache) {
-        const analyzer = entry.analyzer;
-        const nodes = analyzer.getNodes();
-        const edges = analyzer.getEdges();
-        let ranked: RankedFile[];
-        if (rankCache.has(directory)) {
-          ranked = rankCache.get(directory)!;
-        } else {
-          ranked = analyzer.rankImpact("inDegree");
-          rankCache.set(directory, ranked);
-        }
-        const cycles = analyzer.detectCycles();
-
-        const fileNodes = nodes.filter((n: GraphNode) => n.kind === "file");
-        const functionNodes = nodes.filter((n: GraphNode) => n.kind === "function");
-        const classNodes = nodes.filter((n: GraphNode) => n.kind === "class");
-
-        summaries.push({
-          directory,
-          totalFiles: fileNodes.length,
-          totalFunctions: functionNodes.length,
-          totalClasses: classNodes.length,
-          totalEdges: edges.length,
-          mostCentralFile: ranked.length > 0 ? ranked[0] : null,
-          cycleCount: cycles.length,
-          topDependencies: ranked.slice(0, 5).map((r: RankedFile) => ({
-            path: r.relativePath,
-            inDegree: r.score,
-          })),
-        });
-      }
-
-      return {
-        contents: [{
-          uri: "codebase://summary",
-          text: JSON.stringify({ scannedCodebases: summaries }, null, 2),
-        }],
-      };
-    }
-  );
-
-  // Resource 2: codebase://graph/{format}
-  server.registerResource(
-    "codebase-graph",
-    new ResourceTemplate("codebase://graph/{format}", {
-      list: async () => ({
-        resources: [
-          { uri: "codebase://graph/json", name: "Graph (JSON)" },
-          { uri: "codebase://graph/mermaid", name: "Graph (Mermaid)" },
-        ],
-      }),
-    }),
-    {
-      title: "Codebase Dependency Graph",
-      description: "Returns the dependency graph of the scanned codebase in JSON or Mermaid format.",
-      mimeType: "application/json",
-    },
-    async (uri, { format }) => {
-      if (analyzerCache.size === 0) {
-        return {
-          contents: [{
-            uri: uri.href,
-            text: JSON.stringify({ message: "No codebase has been scanned yet. Use the scan_codebase tool first." }, null, 2),
-          }],
-        };
-      }
-
-      const targetKey = getLastScannedDirectory();
-      if (!targetKey) {
-        return {
-          contents: [{
-            uri: uri.href,
-            text: JSON.stringify({ message: "No codebase has been scanned yet. Use the scan_codebase tool first." }, null, 2),
-          }],
-        };
-      }
-      const entry = analyzerCache.get(targetKey);
-      if (!entry) {
-        return {
-          contents: [{
-            uri: uri.href,
-            text: JSON.stringify({ message: "Analyzer not found for the most recently scanned codebase." }, null, 2),
-          }],
-        };
-      }
-      const analyzer = entry.analyzer;
-      const nodes = analyzer.getNodes();
-      const edges = analyzer.getEdges();
-
-      let content: string;
-      if (format === "mermaid") {
-        content = analyzer.toMermaid();
-      } else {
-        content = JSON.stringify({
-          directory: targetKey,
-          nodes: nodes.map((n: GraphNode) => ({ id: n.id, kind: n.kind, label: n.label, filePath: n.filePath })),
-          edges: edges.map((e: GraphEdge) => ({ source: e.source, target: e.target, kind: e.kind, label: e.label })),
-        }, null, 2);
-      }
-
-      return {
-        contents: [{
-          uri: uri.href,
-          text: content,
-        }],
-      };
-    }
-  );
-}

package/src/mcp/tools.test.ts

@@ -1,104 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import path from "node:path";
-import {
-  validateDirectory,
-  getAnalyzer,
-  safeHandler,
-  clearAnalyzerCache,
-} from "../mcp/tools.js";
-
-describe("tools", () => {
-  describe("validateDirectory", () => {
-    it("should accept valid directory", () => {
-      const testDir = path.resolve("./fixtures/test-project");
-      const result = validateDirectory(testDir);
-      expect(result).toBe(testDir);
-    });
-
-    it("should throw for non-existent directory", () => {
-      expect(() => validateDirectory("/non/existent/path")).toThrow();
-    });
-
-    it("should throw for file instead of directory", () => {
-      const testFile = path.resolve("./fixtures/test-project/math.ts");
-      expect(() => validateDirectory(testFile)).toThrow();
-    });
-
-    it("should block Windows system paths", () => {
-      expect(() => validateDirectory("C:\\Windows\\System32")).toThrow();
-      expect(() => validateDirectory("C:\\Program Files")).toThrow();
-    });
-
-    it("should block Unix system paths", () => {
-      expect(() => validateDirectory("/etc/passwd")).toThrow();
-      expect(() => validateDirectory("/usr/bin")).toThrow();
-    });
-  });
-
-  describe("safeHandler", () => {
-    it("should return result on success", async () => {
-      const handler = vi.fn().mockResolvedValue({
-        content: [{ type: "text", text: "success" }],
-      });
-      const result = await safeHandler(handler);
-
-      expect(handler).toHaveBeenCalled();
-      expect(result.content[0].text).toBe("success");
-    });
-
-    it("should catch errors and return error content", async () => {
-      const handler = vi.fn().mockRejectedValue(new Error("test error"));
-      const result = await safeHandler(handler);
-
-      expect(result.isError).toBe(true);
-      expect(result.content[0].text).toContain("test error");
-    });
-
-    it("should handle non-Error rejections", async () => {
-      const handler = vi.fn().mockRejectedValue("string error");
-      const result = await safeHandler(handler);
-
-      expect(result.isError).toBe(true);
-      expect(result.content[0].text).toContain("string error");
-    });
-  });
-
-  describe("getAnalyzer", () => {
-    beforeEach(() => {
-      clearAnalyzerCache();
-    });
-
-    it("should create analyzer for valid directory", async () => {
-      const testDir = path.resolve("./fixtures/test-project");
-      const analyzer = await getAnalyzer(testDir);
-
-      expect(analyzer).toBeDefined();
-      expect(analyzer.getParseResult().totalFiles).toBe(3);
-    }, 30000);
-
-    it("should cache analyzer for same directory", async () => {
-      const testDir = path.resolve("./fixtures/test-project");
-      const analyzer1 = await getAnalyzer(testDir);
-      const analyzer2 = await getAnalyzer(testDir);
-
-      expect(analyzer1).toBe(analyzer2);
-    }, 30000);
-
-    it("should throw for invalid directory", async () => {
-      const testDir = path.resolve("./fixtures/test-project");
-      await getAnalyzer(testDir);
-      expect(true).toBe(true);
-    }, 30000);
-  });
-
-  describe("clearAnalyzerCache", () => {
-    it("should clear cache when called without argument", async () => {
-      const testDir = path.resolve("./fixtures/test-project");
-      await getAnalyzer(testDir);
-      
-      clearAnalyzerCache();
-      const analyzer = await getAnalyzer(testDir);
-      expect(analyzer.getParseResult().totalFiles).toBe(3);
-    }, 30000);
-  });
-});