codemap-ai 3.2.0 → 3.4.0

package/dist/cli.js

@@ -18,6 +18,392 @@ import { createHash } from "crypto";
 import { glob } from "glob";
 import { resolve, relative, extname } from "path";
 
+// src/analysis/class-hierarchy.ts
+function buildClassHierarchy(nodes) {
+  const classes = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  const parents = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (node.type === "class") {
+      const classNode = {
+        id: node.id,
+        name: node.name,
+        file: node.filePath,
+        line: node.startLine,
+        extends: node.extends || [],
+        methods: []
+        // Will populate in next step
+      };
+      classes.set(node.name, classNode);
+    }
+  }
+  for (const node of nodes) {
+    if (node.type === "method" && node.parentClass) {
+      const classNode = classes.get(node.parentClass);
+      if (classNode) {
+        classNode.methods.push(node.name);
+      }
+    }
+  }
+  for (const [className, classNode] of classes) {
+    for (const parentName of classNode.extends) {
+      if (!children.has(parentName)) {
+        children.set(parentName, []);
+      }
+      children.get(parentName).push(className);
+      if (!parents.has(className)) {
+        parents.set(className, []);
+      }
+      parents.get(className).push(parentName);
+    }
+  }
+  return {
+    classes,
+    children,
+    parents
+  };
+}
+function findMethodDefinition(className, methodName, hierarchy) {
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [className];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (visited.has(current)) {
+      continue;
+    }
+    visited.add(current);
+    const classNode = hierarchy.classes.get(current);
+    if (classNode) {
+      if (classNode.methods.includes(methodName)) {
+        return classNode;
+      }
+      const parentNames = hierarchy.parents.get(current) || [];
+      for (const parent of parentNames) {
+        queue.push(parent);
+      }
+    }
+  }
+  return null;
+}
+function resolveMethodCall(instanceType, methodName, hierarchy) {
+  return findMethodDefinition(instanceType, methodName, hierarchy);
+}
+
+// src/flow/enhanced-resolver.ts
+var EnhancedResolver = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  hierarchy = null;
+  variableTypes = /* @__PURE__ */ new Map();
+  /**
+   * Build class hierarchy from all nodes in storage
+   */
+  buildHierarchy() {
+    const nodes = this.getAllNodes();
+    this.hierarchy = buildClassHierarchy(nodes);
+  }
+  /**
+   * Load variable type information from storage
+   */
+  loadVariableTypes() {
+    const stmt = this.storage.db.prepare(`
+      SELECT * FROM variable_types
+    `);
+    const rows = stmt.all();
+    for (const row of rows) {
+      const scopeId = row.scope_node_id;
+      if (!this.variableTypes.has(scopeId)) {
+        this.variableTypes.set(scopeId, []);
+      }
+      this.variableTypes.get(scopeId).push({
+        name: row.variable_name,
+        type: row.type_name,
+        scope: scopeId,
+        line: row.line
+      });
+    }
+  }
+  /**
+   * Resolve all unresolved edges using type information
+   */
+  resolveAllCalls() {
+    if (!this.hierarchy) {
+      this.buildHierarchy();
+    }
+    this.loadVariableTypes();
+    const resolvedCalls = [];
+    const stmt = this.storage.db.prepare(`
+      SELECT * FROM edges
+      WHERE target_id LIKE 'ref:%'
+      AND type = 'calls'
+    `);
+    const edges = stmt.all();
+    for (const edgeRow of edges) {
+      const edge = {
+        id: edgeRow.id,
+        type: edgeRow.type,
+        sourceId: edgeRow.source_id,
+        targetId: edgeRow.target_id,
+        metadata: edgeRow.metadata ? JSON.parse(edgeRow.metadata) : void 0
+      };
+      const resolved = this.resolveCall(edge);
+      if (resolved.targetNode) {
+        resolvedCalls.push(resolved);
+        this.updateEdgeTarget(edge.id, resolved.targetNode.id);
+      }
+    }
+    return resolvedCalls;
+  }
+  /**
+   * Resolve a single call edge
+   */
+  resolveCall(edge) {
+    const unresolvedName = edge.metadata?.unresolvedName;
+    if (!unresolvedName) {
+      return {
+        originalEdge: edge,
+        targetNode: null,
+        confidence: "LOW",
+        reason: "No unresolved name in metadata"
+      };
+    }
+    const sourceNode = this.storage.getNode(edge.sourceId);
+    if (!sourceNode) {
+      return {
+        originalEdge: edge,
+        targetNode: null,
+        confidence: "LOW",
+        reason: "Source node not found"
+      };
+    }
+    if (!unresolvedName.includes(".")) {
+      return this.resolveSimpleCall(unresolvedName, sourceNode, edge);
+    }
+    return this.resolveMethodCall(unresolvedName, sourceNode, edge);
+  }
+  /**
+   * Resolve simple function call (no dot notation)
+   */
+  resolveSimpleCall(functionName, sourceNode, edge) {
+    const sameFileNodes = this.storage.getNodesByFile(sourceNode.filePath);
+    const localMatch = sameFileNodes.find(
+      (n) => (n.type === "function" || n.type === "method") && n.name === functionName
+    );
+    if (localMatch) {
+      return {
+        originalEdge: edge,
+        targetNode: localMatch,
+        confidence: "HIGH",
+        reason: "Found in same file"
+      };
+    }
+    const globalMatches = this.storage.searchNodesByName(functionName);
+    if (globalMatches.length === 1) {
+      return {
+        originalEdge: edge,
+        targetNode: globalMatches[0],
+        confidence: "MEDIUM",
+        reason: "Single global match"
+      };
+    }
+    if (globalMatches.length > 1) {
+      const sourceDir = sourceNode.filePath.split("/").slice(0, -1).join("/");
+      const sameDirMatch = globalMatches.find((n) => n.filePath.startsWith(sourceDir));
+      if (sameDirMatch) {
+        return {
+          originalEdge: edge,
+          targetNode: sameDirMatch,
+          confidence: "MEDIUM",
+          reason: "Multiple matches, picked same directory"
+        };
+      }
+      return {
+        originalEdge: edge,
+        targetNode: globalMatches[0],
+        confidence: "LOW",
+        reason: `Multiple matches (${globalMatches.length}), picked first`
+      };
+    }
+    return {
+      originalEdge: edge,
+      targetNode: null,
+      confidence: "LOW",
+      reason: "No matches found"
+    };
+  }
+  /**
+   * Resolve method call using type information
+   * Pattern: obj.method() or self.method()
+   */
+  resolveMethodCall(fullName, sourceNode, edge) {
+    const parts = fullName.split(".");
+    const varName = parts[0];
+    const methodName = parts.slice(1).join(".");
+    if (varName === "self" || varName === "this") {
+      return this.resolveSelfMethodCall(methodName, sourceNode, edge);
+    }
+    const scopeTypes = this.variableTypes.get(sourceNode.id) || [];
+    const varType = scopeTypes.find((v) => v.name === varName);
+    if (!varType) {
+      return this.resolveSimpleCall(methodName, sourceNode, edge);
+    }
+    if (!this.hierarchy) {
+      return {
+        originalEdge: edge,
+        targetNode: null,
+        confidence: "LOW",
+        reason: "Class hierarchy not built"
+      };
+    }
+    const classNode = resolveMethodCall(varType.type, methodName, this.hierarchy);
+    if (classNode) {
+      const methodNode = this.findMethodInClass(classNode.name, methodName);
+      if (methodNode) {
+        return {
+          originalEdge: edge,
+          targetNode: methodNode,
+          confidence: "HIGH",
+          reason: `Resolved via type tracking: ${varName}: ${varType.type}`
+        };
+      }
+    }
+    return {
+      originalEdge: edge,
+      targetNode: null,
+      confidence: "LOW",
+      reason: `Type found (${varType.type}) but method not resolved`
+    };
+  }
+  /**
+   * Resolve self.method() or this.method()
+   */
+  resolveSelfMethodCall(methodName, sourceNode, edge) {
+    const parentClass = sourceNode.metadata?.parentClass;
+    if (!parentClass) {
+      return {
+        originalEdge: edge,
+        targetNode: null,
+        confidence: "LOW",
+        reason: "self/this call but no parent class"
+      };
+    }
+    if (!this.hierarchy) {
+      return {
+        originalEdge: edge,
+        targetNode: null,
+        confidence: "LOW",
+        reason: "Class hierarchy not built"
+      };
+    }
+    const classNode = resolveMethodCall(parentClass, methodName, this.hierarchy);
+    if (classNode) {
+      const methodNode2 = this.findMethodInClass(classNode.name, methodName);
+      if (methodNode2) {
+        return {
+          originalEdge: edge,
+          targetNode: methodNode2,
+          confidence: "HIGH",
+          reason: `Resolved self.${methodName} in ${parentClass}`
+        };
+      }
+    }
+    const sameFileNodes = this.storage.getNodesByFile(sourceNode.filePath);
+    const methodNode = sameFileNodes.find(
+      (n) => n.type === "method" && n.name === methodName
+    );
+    if (methodNode) {
+      return {
+        originalEdge: edge,
+        targetNode: methodNode,
+        confidence: "MEDIUM",
+        reason: "Found method in same file"
+      };
+    }
+    return {
+      originalEdge: edge,
+      targetNode: null,
+      confidence: "LOW",
+      reason: `Method ${methodName} not found in ${parentClass}`
+    };
+  }
+  /**
+   * Find method node in a class
+   */
+  findMethodInClass(className, methodName) {
+    const stmt = this.storage.db.prepare(`
+      SELECT * FROM nodes
+      WHERE type = 'method'
+      AND name = ?
+      AND json_extract(metadata, '$.parentClass') = ?
+    `);
+    const row = stmt.get(methodName, className);
+    if (!row) return null;
+    return {
+      id: row.id,
+      type: row.type,
+      name: row.name,
+      filePath: row.file_path,
+      startLine: row.start_line,
+      endLine: row.end_line,
+      language: row.language,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0
+    };
+  }
+  /**
+   * Get all nodes from storage
+   */
+  getAllNodes() {
+    const stmt = this.storage.db.prepare("SELECT * FROM nodes");
+    const rows = stmt.all();
+    return rows.map((row) => ({
+      id: row.id,
+      type: row.type,
+      name: row.name,
+      filePath: row.file_path,
+      startLine: row.start_line,
+      endLine: row.end_line,
+      language: row.language,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0
+    }));
+  }
+  /**
+   * Update edge target in database
+   */
+  updateEdgeTarget(edgeId, newTargetId) {
+    const stmt = this.storage.db.prepare(`
+      UPDATE edges
+      SET target_id = ?
+      WHERE id = ?
+    `);
+    stmt.run(newTargetId, edgeId);
+  }
+  /**
+   * Get resolution statistics
+   */
+  getStats() {
+    const totalStmt = this.storage.db.prepare(`
+      SELECT COUNT(*) as count FROM edges WHERE type = 'calls'
+    `);
+    const totalRow = totalStmt.get();
+    const totalCalls = totalRow.count;
+    const resolvedStmt = this.storage.db.prepare(`
+      SELECT COUNT(*) as count FROM edges
+      WHERE type = 'calls' AND target_id NOT LIKE 'ref:%'
+    `);
+    const resolvedRow = resolvedStmt.get();
+    const resolvedCalls = resolvedRow.count;
+    const unresolvedCalls = totalCalls - resolvedCalls;
+    const resolutionRate = totalCalls > 0 ? resolvedCalls / totalCalls * 100 : 0;
+    return {
+      totalCalls,
+      resolvedCalls,
+      unresolvedCalls,
+      resolutionRate
+    };
+  }
+};
+
 // src/parsers/base.ts
 var BaseParser = class {
   nodeIdCounter = 0;
@@ -272,31 +658,38 @@ var TypeScriptParser = class extends BaseParser {
   handleClass(node, filePath, analysis, parentId) {
     const nameNode = node.childForFieldName("name");
     if (!nameNode) return;
+    const extends_ = [];
+    for (const child of node.children) {
+      if (child.type === "class_heritage") {
+        const extendsClause = child.children.find((c) => c.type === "extends_clause");
+        if (extendsClause) {
+          const baseClass = extendsClause.children.find((c) => c.type === "identifier");
+          if (baseClass) {
+            extends_.push(baseClass.text);
+          }
+        }
+      }
+    }
     const classNode = this.createNode(
       "class",
       nameNode.text,
       filePath,
       node.startPosition.row + 1,
-      node.endPosition.row + 1
+      node.endPosition.row + 1,
+      {
+        extends: extends_
+      }
     );
     analysis.nodes.push(classNode);
     analysis.edges.push(
       this.createEdge("contains", parentId, classNode.id)
     );
-    for (const child of node.children) {
-      if (child.type === "class_heritage") {
-        const extendsClause = child.children.find((c) => c.type === "extends_clause");
-        if (extendsClause) {
-          const baseClass = extendsClause.children.find((c) => c.type === "identifier");
-          if (baseClass) {
-            analysis.edges.push(
-              this.createEdge("extends", classNode.id, `ref:${baseClass.text}`, {
-                unresolvedName: baseClass.text
-              })
-            );
-          }
-        }
-      }
+    for (const baseClass of extends_) {
+      analysis.edges.push(
+        this.createEdge("extends", classNode.id, `ref:${baseClass}`, {
+          unresolvedName: baseClass
+        })
+      );
     }
     const body = node.childForFieldName("body");
     if (body) {
@@ -310,6 +703,8 @@ var TypeScriptParser = class extends BaseParser {
   handleMethod(node, filePath, analysis, parentId) {
     const nameNode = node.childForFieldName("name");
     if (!nameNode) return;
+    const parentNode = analysis.nodes.find((n) => n.id === parentId);
+    const parentClass = parentNode?.type === "class" ? parentNode.name : void 0;
     const methodNode = this.createNode(
       "method",
       nameNode.text,
@@ -318,7 +713,8 @@ var TypeScriptParser = class extends BaseParser {
       node.endPosition.row + 1,
       {
         static: node.children.some((c) => c.type === "static"),
-        async: node.children.some((c) => c.type === "async")
+        async: node.children.some((c) => c.type === "async"),
+        parentClass
       }
     );
     analysis.nodes.push(methodNode);
@@ -753,6 +1149,8 @@ var PythonParser = class extends BaseParser {
       node.endPosition.row + 1,
       {
         bases,
+        extends: bases,
+        // Add extends for consistency with TypeScript
         isPrivate: name.startsWith("_")
       }
     );
@@ -790,6 +1188,8 @@ var PythonParser = class extends BaseParser {
     const nameNode = node.childForFieldName("name");
     if (!nameNode) return;
     const name = nameNode.text;
+    const parentNode = analysis.nodes.find((n) => n.id === classId);
+    const parentClass = parentNode?.type === "class" ? parentNode.name : void 0;
     const decorators = [];
     if (node.parent?.type === "decorated_definition") {
       for (const sibling of node.parent.children) {
@@ -818,7 +1218,8 @@ var PythonParser = class extends BaseParser {
         classmethod: isClassMethod,
         property: isProperty,
         isPrivate: name.startsWith("_"),
-        isDunder: name.startsWith("__") && name.endsWith("__")
+        isDunder: name.startsWith("__") && name.endsWith("__"),
+        parentClass
       }
     );
     analysis.nodes.push(methodNode);
@@ -1021,6 +1422,12 @@ var FlowBuilder = class {
       currentFile: ""
     });
     this.resolveAllCalls();
+    const enhancedResolver = new EnhancedResolver(this.storage);
+    enhancedResolver.buildHierarchy();
+    const enhancedResolved = enhancedResolver.resolveAllCalls();
+    if (enhancedResolved.length > 0) {
+      console.log(`\u2728 Enhanced resolver: resolved ${enhancedResolved.length} additional calls`);
+    }
     const stats = this.storage.getStats();
     this.emitProgress({
       phase: "complete",
@@ -1383,6 +1790,87 @@ function getGitStatus(rootPath) {
 
 // src/analysis/imports.ts
 import { readFileSync as readFileSync2 } from "fs";
+function isJavaScriptBuiltin(identifier) {
+  const builtins = /* @__PURE__ */ new Set([
+    "Object",
+    "Array",
+    "String",
+    "Number",
+    "Boolean",
+    "Date",
+    "RegExp",
+    "Error",
+    "TypeError",
+    "SyntaxError",
+    "ReferenceError",
+    "Promise",
+    "Map",
+    "Set",
+    "WeakMap",
+    "WeakSet",
+    "JSON",
+    "Math",
+    "Infinity",
+    "NaN",
+    "undefined",
+    "Function",
+    "Symbol",
+    "Proxy",
+    "Reflect",
+    "Int8Array",
+    "Uint8Array",
+    "Int16Array",
+    "Uint16Array",
+    "Int32Array",
+    "Uint32Array",
+    "Float32Array",
+    "Float64Array",
+    "BigInt",
+    "ArrayBuffer",
+    "DataView",
+    "Intl",
+    "WebAssembly",
+    "Buffer",
+    "URL",
+    "URLSearchParams",
+    "console",
+    "process",
+    "global",
+    "window",
+    "document",
+    // Common keywords that look like types
+    "TRUE",
+    "FALSE",
+    "NULL"
+  ]);
+  return builtins.has(identifier);
+}
+function isPythonBuiltin(identifier) {
+  const builtins = /* @__PURE__ */ new Set([
+    "True",
+    "False",
+    "None",
+    "Exception",
+    "BaseException",
+    "ValueError",
+    "TypeError",
+    "KeyError",
+    "AttributeError",
+    "IndexError",
+    "RuntimeError",
+    "NotImplementedError",
+    "Dict",
+    "List",
+    "Tuple",
+    "Set",
+    "FrozenSet",
+    "Optional",
+    "Union",
+    "Any",
+    "Callable"
+  ]);
+  return builtins.has(identifier);
+}
 function analyzeJavaScriptImports(filePath) {
   const content = readFileSync2(filePath, "utf-8");
   const lines = content.split("\n");
@@ -1423,19 +1911,52 @@ function analyzeJavaScriptImports(filePath) {
     }
   }
   const missing = [];
-  const commonLibraries = ["express", "cors", "winston", "Redis", "MongoClient", "mongoose", "axios"];
-  for (const lib of commonLibraries) {
-    if (!imports.has(lib)) {
+  const localDefinitions = /* @__PURE__ */ new Set();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const classMatch = line.match(/^(?:export\s+)?class\s+([A-Z][a-zA-Z0-9]*)/);
+    if (classMatch) {
+      localDefinitions.add(classMatch[1]);
+    }
+    const funcMatch = line.match(/^(?:export\s+)?(?:async\s+)?function\s+([A-Z][a-zA-Z0-9]*)/);
+    if (funcMatch) {
+      localDefinitions.add(funcMatch[1]);
+    }
+    const constMatch = line.match(/^(?:export\s+)?const\s+([A-Z][a-z][a-zA-Z0-9]*)\s*=/);
+    if (constMatch) {
+      localDefinitions.add(constMatch[1]);
+    }
+  }
+  const potentialImports = /* @__PURE__ */ new Set();
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+    if (line.trim().startsWith("import ") || line.trim().startsWith("//") || line.trim().startsWith("*") || line.trim().startsWith("#")) {
+      continue;
+    }
+    line = line.replace(/\/\/.*$/g, "");
+    line = line.replace(/\/\*.*?\*\//g, "");
+    line = line.replace(/[`"'].*?[`"']/g, "");
+    const matches = line.matchAll(/(?<!\.)([A-Z][a-z][a-zA-Z0-9]*)(?!\.)/g);
+    for (const match of matches) {
+      const identifier = match[1];
+      if (!isJavaScriptBuiltin(identifier)) {
+        potentialImports.add(identifier);
+      }
+    }
+  }
+  for (const identifier of potentialImports) {
+    if (!imports.has(identifier) && !localDefinitions.has(identifier)) {
       const usageLines = [];
       for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
-        if (line.includes(lib) && !line.trim().startsWith("//")) {
+        const regex = new RegExp(`\\b${identifier}\\b`);
+        if (regex.test(line) && !line.trim().startsWith("//")) {
           usageLines.push(i + 1);
         }
       }
       if (usageLines.length > 0) {
         missing.push({
-          identifier: lib,
+          identifier,
           line: usageLines[0],
           type: "missing",
           usedAt: usageLines
@@ -1484,7 +2005,56 @@ function analyzePythonImports(filePath) {
       unused.push({ identifier, line, type: "unused" });
     }
   }
-  return { missing: [], unused };
+  const missing = [];
+  const localDefinitions = /* @__PURE__ */ new Set();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const classMatch = line.match(/^class\s+([A-Z][a-zA-Z0-9_]*)/);
+    if (classMatch) {
+      localDefinitions.add(classMatch[1]);
+    }
+    const funcMatch = line.match(/^(?:async\s+)?def\s+([A-Z][a-zA-Z0-9_]*)/);
+    if (funcMatch) {
+      localDefinitions.add(funcMatch[1]);
+    }
+  }
+  const potentialImports = /* @__PURE__ */ new Set();
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+    if (line.trim().startsWith("import ") || line.trim().startsWith("from ") || line.trim().startsWith("#")) {
+      continue;
+    }
+    line = line.replace(/#.*$/g, "");
+    line = line.replace(/[`"'f].*?[`"']/g, "");
+    const matches = line.matchAll(/(?<!\.)([A-Z][a-zA-Z0-9_]*)(?!\.)/g);
+    for (const match of matches) {
+      const identifier = match[1];
+      if (!isPythonBuiltin(identifier)) {
+        potentialImports.add(identifier);
+      }
+    }
+  }
+  for (const identifier of potentialImports) {
+    if (!imports.has(identifier) && !localDefinitions.has(identifier)) {
+      const usageLines = [];
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const regex = new RegExp(`\\b${identifier}\\b`);
+        if (regex.test(line) && !line.trim().startsWith("#")) {
+          usageLines.push(i + 1);
+        }
+      }
+      if (usageLines.length > 0) {
+        missing.push({
+          identifier,
+          line: usageLines[0],
+          type: "missing",
+          usedAt: usageLines
+        });
+      }
+    }
+  }
+  return { missing, unused };
 }
 function analyzeImports(filePath) {
   if (filePath.endsWith(".py")) {
@@ -1650,6 +2220,549 @@ function calculateServiceBlastRadius(graph, serviceName) {
   return Array.from(affected);
 }
 
+// src/analysis/line-diff.ts
+import { execSync as execSync2 } from "child_process";
+function parseLineLevelDiff(projectRoot) {
+  try {
+    const diffOutput = execSync2("git diff HEAD", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB buffer
+    });
+    if (!diffOutput.trim()) {
+      return {
+        removedLines: [],
+        addedLines: [],
+        modifiedLines: []
+      };
+    }
+    return parseDiffOutput(diffOutput);
+  } catch (error) {
+    return {
+      removedLines: [],
+      addedLines: [],
+      modifiedLines: []
+    };
+  }
+}
+function parseDiffOutput(diffOutput) {
+  const removedLines = [];
+  const addedLines = [];
+  let currentFile = "";
+  let currentFunction = "";
+  let removedLineNumber = 0;
+  let addedLineNumber = 0;
+  const lines = diffOutput.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("diff --git")) {
+      const match = line.match(/b\/(.*?)$/);
+      if (match) {
+        currentFile = match[1].trim();
+      }
+      continue;
+    }
+    if (line.startsWith("@@")) {
+      const match = line.match(/@@ -(\d+),\d+ \+(\d+),\d+ @@(.*)/);
+      if (match) {
+        removedLineNumber = parseInt(match[1]);
+        addedLineNumber = parseInt(match[2]);
+        const context = match[3].trim();
+        if (context) {
+          currentFunction = extractFunctionName(context);
+        }
+      }
+      continue;
+    }
+    if (line.startsWith("---") || line.startsWith("+++") || line.startsWith("index ")) {
+      continue;
+    }
+    if (line.startsWith("-") && !line.startsWith("---")) {
+      const content = line.substring(1);
+      if (content.trim()) {
+        removedLines.push({
+          file: currentFile,
+          lineNumber: removedLineNumber,
+          content,
+          inFunction: currentFunction || void 0
+        });
+      }
+      removedLineNumber++;
+      continue;
+    }
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      const content = line.substring(1);
+      if (content.trim()) {
+        addedLines.push({
+          file: currentFile,
+          lineNumber: addedLineNumber,
+          content,
+          inFunction: currentFunction || void 0
+        });
+      }
+      addedLineNumber++;
+      continue;
+    }
+    if (line.startsWith(" ") || !line.startsWith("-") && !line.startsWith("+")) {
+      removedLineNumber++;
+      addedLineNumber++;
+    }
+  }
+  const modifiedLines = matchModifiedLines(removedLines, addedLines);
+  return {
+    removedLines,
+    addedLines,
+    modifiedLines
+  };
+}
+function extractFunctionName(context) {
+  context = context.replace(/^(function|def|class|const|let|var|async|export)\s+/, "");
+  const patterns = [
+    /^(\w+)\s*\(/,
+    // functionName(
+    /^(\w+)\s*=/,
+    // functionName =
+    /^(\w+)\s*{/,
+    // ClassName {
+    /^(\w+)\s*:/
+    // functionName:
+  ];
+  for (const pattern of patterns) {
+    const match = context.match(pattern);
+    if (match) {
+      return match[1];
+    }
+  }
+  const firstWord = context.split(/\s+/)[0];
+  return firstWord || "";
+}
+function matchModifiedLines(removedLines, addedLines) {
+  const modifiedLines = [];
+  const removedByLocation = /* @__PURE__ */ new Map();
+  const addedByLocation = /* @__PURE__ */ new Map();
+  for (const removed of removedLines) {
+    const key = `${removed.file}:${removed.inFunction || "global"}`;
+    if (!removedByLocation.has(key)) {
+      removedByLocation.set(key, []);
+    }
+    removedByLocation.get(key).push(removed);
+  }
+  for (const added of addedLines) {
+    const key = `${added.file}:${added.inFunction || "global"}`;
+    if (!addedByLocation.has(key)) {
+      addedByLocation.set(key, []);
+    }
+    addedByLocation.get(key).push(added);
+  }
+  for (const [location, removedLinesInLocation] of removedByLocation) {
+    const addedLinesInLocation = addedByLocation.get(location) || [];
+    for (const removed of removedLinesInLocation) {
+      const matchingAdded = addedLinesInLocation.find(
+        (added) => Math.abs(added.lineNumber - removed.lineNumber) <= 2
+      );
+      if (matchingAdded) {
+        modifiedLines.push({
+          before: removed,
+          after: matchingAdded
+        });
+      }
+    }
+  }
+  return modifiedLines;
+}
+
+// src/analysis/removed-calls.ts
+function extractRemovedCalls(removedLines) {
+  const removedCalls = [];
+  for (const line of removedLines) {
+    const calls = parseLineForCalls(line.content, line.file);
+    for (const call of calls) {
+      removedCalls.push({
+        callee: call.name,
+        removedFrom: line.inFunction || "unknown",
+        file: line.file,
+        lineNumber: line.lineNumber,
+        rawContent: line.content.trim()
+      });
+    }
+  }
+  return removedCalls;
+}
+function parseLineForCalls(lineContent, filePath) {
+  const calls = [];
+  if (isCommentOrString(lineContent)) {
+    return calls;
+  }
+  lineContent = lineContent.replace(/\/\/.*$/g, "");
+  lineContent = lineContent.replace(/#.*$/g, "");
+  lineContent = lineContent.replace(/\/\*.*?\*\//g, "");
+  lineContent = lineContent.replace(/["'`].*?["'`]/g, "");
+  const isJS = /\.(js|ts|jsx|tsx)$/.test(filePath);
+  const isPython = /\.py$/.test(filePath);
+  if (isJS) {
+    calls.push(...extractJavaScriptCalls(lineContent));
+  }
+  if (isPython) {
+    calls.push(...extractPythonCalls(lineContent));
+  }
+  return calls;
+}
+function isCommentOrString(line) {
+  const trimmed = line.trim();
+  if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*") || trimmed.startsWith("#")) {
+    return true;
+  }
+  const stringPrefixes = ['"', "'", "`"];
+  if (stringPrefixes.some((prefix) => trimmed.startsWith(prefix))) {
+    return true;
+  }
+  return false;
+}
+function extractJavaScriptCalls(lineContent) {
+  const calls = [];
+  const seen = /* @__PURE__ */ new Set();
+  const simplePattern = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g;
+  let match;
+  while ((match = simplePattern.exec(lineContent)) !== null) {
+    const functionName = match[1];
+    if (!isJavaScriptKeyword(functionName) && !seen.has(functionName)) {
+      calls.push({ name: functionName });
+      seen.add(functionName);
+    }
+  }
+  const methodPattern = /\.([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g;
+  while ((match = methodPattern.exec(lineContent)) !== null) {
+    const methodName = match[1];
+    if (!isJavaScriptKeyword(methodName) && !seen.has(methodName)) {
+      calls.push({ name: methodName });
+      seen.add(methodName);
+    }
+  }
+  const awaitPattern = /await\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g;
+  while ((match = awaitPattern.exec(lineContent)) !== null) {
+    const functionName = match[1];
+    if (!isJavaScriptKeyword(functionName) && !seen.has(functionName)) {
+      calls.push({ name: functionName });
+      seen.add(functionName);
+    }
+  }
+  return calls;
+}
+function extractPythonCalls(lineContent) {
+  const calls = [];
+  const seen = /* @__PURE__ */ new Set();
+  const simplePattern = /\b([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/g;
+  let match;
+  while ((match = simplePattern.exec(lineContent)) !== null) {
+    const functionName = match[1];
+    if (!isPythonKeyword(functionName) && !seen.has(functionName)) {
+      calls.push({ name: functionName });
+      seen.add(functionName);
+    }
+  }
+  const methodPattern = /\.([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/g;
+  while ((match = methodPattern.exec(lineContent)) !== null) {
+    const methodName = match[1];
+    if (!isPythonKeyword(methodName) && !seen.has(methodName)) {
+      calls.push({ name: methodName });
+      seen.add(methodName);
+    }
+  }
+  const awaitPattern = /await\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/g;
+  while ((match = awaitPattern.exec(lineContent)) !== null) {
+    const functionName = match[1];
+    if (!isPythonKeyword(functionName) && !seen.has(functionName)) {
+      calls.push({ name: functionName });
+      seen.add(functionName);
+    }
+  }
+  return calls;
+}
+function isJavaScriptKeyword(identifier) {
+  const keywords = /* @__PURE__ */ new Set([
+    // Keywords
+    "if",
+    "else",
+    "for",
+    "while",
+    "do",
+    "switch",
+    "case",
+    "break",
+    "continue",
+    "return",
+    "throw",
+    "try",
+    "catch",
+    "finally",
+    "new",
+    "typeof",
+    "instanceof",
+    "delete",
+    "void",
+    "async",
+    "await",
+    "yield",
+    "import",
+    "export",
+    "from",
+    "class",
+    "extends",
+    "super",
+    "this",
+    "static",
+    "const",
+    "let",
+    "var",
+    "function",
+    "constructor",
+    "get",
+    "set",
+    // Common builtins to skip
+    "console",
+    "parseInt",
+    "parseFloat",
+    "isNaN",
+    "isFinite",
+    "setTimeout",
+    "setInterval",
+    "clearTimeout",
+    "clearInterval",
+    "require",
+    "module",
+    "exports",
+    "__dirname",
+    "__filename"
+  ]);
+  return keywords.has(identifier);
+}
+function isPythonKeyword(identifier) {
+  const keywords = /* @__PURE__ */ new Set([
+    // Keywords
+    "if",
+    "elif",
+    "else",
+    "for",
+    "while",
+    "break",
+    "continue",
+    "pass",
+    "return",
+    "raise",
+    "try",
+    "except",
+    "finally",
+    "with",
+    "as",
+    "yield",
+    "import",
+    "from",
+    "class",
+    "def",
+    "lambda",
+    "global",
+    "nonlocal",
+    "assert",
+    "del",
+    "in",
+    "is",
+    "not",
+    "and",
+    "or",
+    "async",
+    "await",
+    // Common builtins to skip
+    "print",
+    "len",
+    "range",
+    "enumerate",
+    "zip",
+    "map",
+    "filter",
+    "sorted",
+    "reversed",
+    "sum",
+    "min",
+    "max",
+    "abs",
+    "round",
+    "open",
+    "input",
+    "type",
+    "isinstance",
+    "hasattr",
+    "getattr",
+    "setattr"
+  ]);
+  return keywords.has(identifier);
+}
+
+// src/analysis/removed-call-impact.ts
+var SECURITY_KEYWORDS = [
+  // Authentication & Authorization
+  "authenticate",
+  "authorization",
+  "authorize",
+  "login",
+  "logout",
+  "signin",
+  "signout",
+  "verify",
+  "check",
+  "validate",
+  "permission",
+  "access",
+  "role",
+  "admin",
+  "auth",
+  // Input validation & sanitization
+  "sanitize",
+  "escape",
+  "clean",
+  "filter",
+  "whitelist",
+  "blacklist",
+  "validate",
+  "verification",
+  "check",
+  // Security tokens & sessions
+  "token",
+  "session",
+  "cookie",
+  "csrf",
+  "xsrf",
+  "jwt",
+  "oauth",
+  "api_key",
+  "apikey",
+  "secret",
+  "password",
+  "hash",
+  "encrypt",
+  // Injection prevention
+  "xss",
+  "sql",
+  "injection",
+  "query",
+  "prepared",
+  "statement",
+  // Rate limiting & abuse prevention
+  "ratelimit",
+  "throttle",
+  "captcha",
+  "honeypot"
+];
+function analyzeRemovedCallImpact(removedCalls, storage) {
+  const impacts = [];
+  for (const removedCall of removedCalls) {
+    try {
+      const impact = analyzeSingleRemovedCall(removedCall, storage);
+      if (impact) {
+        impacts.push(impact);
+      }
+    } catch (error) {
+      console.error(`Error analyzing removed call ${removedCall.callee}:`, error);
+    }
+  }
+  return impacts;
+}
+function analyzeSingleRemovedCall(removedCall, storage) {
+  const nodes = storage.searchNodesByName(removedCall.callee);
+  if (nodes.length === 0) {
+    return null;
+  }
+  const functionNode = nodes[0];
+  const allCallers = storage.getResolvedCallers(functionNode.id);
+  const stillCalledBy = allCallers.filter((c) => c.name !== removedCall.removedFrom).map((c) => ({
+    name: c.name,
+    file: c.filePath,
+    line: c.startLine
+  }));
+  const removedFromNodes = storage.searchNodesByName(removedCall.removedFrom);
+  let impactedFunctions = [];
+  if (removedFromNodes.length > 0) {
+    const removedFromNode = removedFromNodes[0];
+    const impactedNodes = storage.getImpactedNodes(removedFromNode.id, 5);
+    impactedFunctions = impactedNodes.map((n) => ({
+      name: n.name,
+      file: n.filePath,
+      line: n.startLine,
+      reason: `Calls ${removedCall.removedFrom}() which no longer calls ${removedCall.callee}()`
+    }));
+  }
+  const severity = calculateSeverity(
+    removedCall,
+    stillCalledBy,
+    impactedFunctions
+  );
+  const description = buildImpactDescription(
+    removedCall,
+    stillCalledBy,
+    impactedFunctions,
+    severity
+  );
+  return {
+    removedCall,
+    functionNode: {
+      id: functionNode.id,
+      name: functionNode.name,
+      file: functionNode.filePath,
+      line: functionNode.startLine
+    },
+    stillCalledBy,
+    impactedFunctions,
+    severity,
+    description
+  };
+}
+function calculateSeverity(removedCall, stillCalledBy, impactedFunctions) {
+  const isSecurityFunction = SECURITY_KEYWORDS.some(
+    (keyword) => removedCall.callee.toLowerCase().includes(keyword)
+  );
+  if (isSecurityFunction && impactedFunctions.length > 5) {
+    return "CRITICAL";
+  }
+  if (isSecurityFunction && stillCalledBy.length === 0) {
+    return "CRITICAL";
+  }
+  if (stillCalledBy.length === 0) {
+    return "HIGH";
+  }
+  if (impactedFunctions.length > 20) {
+    return "HIGH";
+  }
+  if (impactedFunctions.length >= 10) {
+    return "MEDIUM";
+  }
+  if (isSecurityFunction && impactedFunctions.length > 0) {
+    return "MEDIUM";
+  }
+  return "LOW";
+}
+function buildImpactDescription(removedCall, stillCalledBy, impactedFunctions, severity) {
+  const parts = [];
+  parts.push(
+    `${removedCall.callee}() was removed from ${removedCall.removedFrom}() at line ${removedCall.lineNumber}`
+  );
+  if (stillCalledBy.length === 0) {
+    parts.push(`\u26A0\uFE0F ORPHANED: ${removedCall.callee}() is no longer called anywhere in the codebase`);
+  } else {
+    const callerNames = stillCalledBy.slice(0, 3).map((c) => c.name).join(", ");
+    const moreCount = stillCalledBy.length > 3 ? ` and ${stillCalledBy.length - 3} more` : "";
+    parts.push(`Still called by: ${callerNames}${moreCount}`);
+  }
+  if (impactedFunctions.length > 0) {
+    parts.push(
+      `Impact: ${impactedFunctions.length} function${impactedFunctions.length === 1 ? "" : "s"} depend on ${removedCall.removedFrom}()`
+    );
+  }
+  if (severity === "CRITICAL") {
+    parts.push("\u{1F534} CRITICAL: Security or validation function removed from execution path");
+  }
+  return parts.join("\n");
+}
+
 // src/commands/impact.ts
 async function analyzeImpact(options = {}) {
   const rootPath = resolve2(options.path || ".");
@@ -1674,6 +2787,8 @@ async function analyzeImpactWithGit(storage, rootPath, options) {
       directCallers: /* @__PURE__ */ new Map(),
       affectedEndpoints: [],
       importIssues: /* @__PURE__ */ new Map(),
+      removedCallImpacts: [],
+      // NEW
       riskLevel: "LOW",
       totalImpact: 0
     };
@@ -1730,17 +2845,22 @@ async function analyzeImpactWithGit(storage, rootPath, options) {
       entryPointFiles
     };
   }
+  const lineDiff = parseLineLevelDiff(rootPath);
+  const removedCalls = extractRemovedCalls(lineDiff.removedLines);
+  const removedCallImpacts = analyzeRemovedCallImpact(removedCalls, storage);
   const totalCallers = Array.from(directCallers.values()).reduce((sum, callers) => sum + callers.length, 0);
   const hasCriticalImportIssues = Array.from(importIssues.values()).some((i) => i.missing.length > 0);
   const hasDockerImpact = dockerImpact && dockerImpact.affectedServices.length > 0;
+  const hasCriticalRemovedCalls = removedCallImpacts.some((i) => i.severity === "CRITICAL");
+  const hasHighRiskRemovedCalls = removedCallImpacts.some((i) => i.severity === "HIGH");
   let riskLevel = "LOW";
-  if (hasCriticalImportIssues && hasDockerImpact) {
+  if (hasCriticalRemovedCalls || hasCriticalImportIssues && hasDockerImpact) {
     riskLevel = "CRITICAL";
-  } else if (hasCriticalImportIssues || hasDockerImpact && dockerImpact.affectedServices.length > 2) {
+  } else if (hasHighRiskRemovedCalls || hasCriticalImportIssues || hasDockerImpact && dockerImpact.affectedServices.length > 2) {
     riskLevel = "HIGH";
   } else if (totalCallers > 20 || affectedEndpoints.length > 5) {
     riskLevel = "HIGH";
-  } else if (totalCallers > 10 || affectedEndpoints.length > 2 || hasDockerImpact) {
+  } else if (totalCallers > 10 || affectedEndpoints.length > 2 || hasDockerImpact || removedCallImpacts.length > 0) {
     riskLevel = "MEDIUM";
   }
   return {
@@ -1750,8 +2870,10 @@ async function analyzeImpactWithGit(storage, rootPath, options) {
     affectedEndpoints,
     importIssues,
     dockerImpact,
+    removedCallImpacts,
+    // NEW
     riskLevel,
-    totalImpact: totalCallers + (dockerImpact?.affectedServices.length || 0)
+    totalImpact: totalCallers + (dockerImpact?.affectedServices.length || 0) + removedCallImpacts.length
   };
 }
 async function analyzeImpactWithHash(storage, rootPath, options) {
@@ -1786,6 +2908,8 @@ async function analyzeImpactWithHash(storage, rootPath, options) {
     directCallers: /* @__PURE__ */ new Map(),
     affectedEndpoints: [],
     importIssues,
+    removedCallImpacts: [],
+    // NEW - not available in hash mode
     riskLevel: hasCriticalImportIssues ? "CRITICAL" : changedFiles.length > 10 ? "HIGH" : changedFiles.length > 5 ? "MEDIUM" : "LOW",
     totalImpact: result.indexed
   };
@@ -2021,12 +3145,12 @@ program.command("impact").description("Analyze impact of code changes").argument
       for (const [file, issues] of result.importIssues.entries()) {
         if (issues.missing.length > 0) {
           console.log(chalk.red(`    \u274C CRITICAL: ${file} - Missing imports still in use:`));
-          for (const missing of issues.missing.slice(0, 5)) {
+          for (const missing of issues.missing.slice(0, 10)) {
             const usageInfo = missing.usedAt ? ` (used at lines: ${missing.usedAt.slice(0, 3).join(", ")}${missing.usedAt.length > 3 ? "..." : ""})` : "";
             console.log(chalk.gray(`       \u2022 ${missing.identifier}${usageInfo}`));
           }
-          if (issues.missing.length > 5) {
-            console.log(chalk.gray(`       ... and ${issues.missing.length - 5} more`));
+          if (issues.missing.length > 10) {
+            console.log(chalk.gray(`       ... and ${issues.missing.length - 10} more`));
           }
         }
         if (issues.unused.length > 0 && options.verbose) {
@@ -2037,6 +3161,42 @@ program.command("impact").description("Analyze impact of code changes").argument
         }
       }
     }
+    if (result.removedCallImpacts && result.removedCallImpacts.length > 0) {
+      console.log(chalk.blue("\n  \u{1F6A8} Removed Function Calls:\n"));
+      for (const impact of result.removedCallImpacts) {
+        const severityColors = {
+          "CRITICAL": chalk.red,
+          "HIGH": chalk.red,
+          "MEDIUM": chalk.yellow,
+          "LOW": chalk.gray
+        };
+        const severityColor = severityColors[impact.severity];
+        console.log(severityColor(`    ${impact.severity}: ${impact.removedCall.callee}()`));
+        console.log(chalk.gray(`       Removed from: ${impact.removedCall.removedFrom}() at line ${impact.removedCall.lineNumber}`));
+        console.log(chalk.gray(`       File: ${impact.removedCall.file}`));
+        if (impact.stillCalledBy.length === 0) {
+          console.log(chalk.red(`       \u26A0\uFE0F ORPHANED: No longer called anywhere!`));
+        } else {
+          const callerNames = impact.stillCalledBy.slice(0, 3).map((c) => c.name).join(", ");
+          const moreCount = impact.stillCalledBy.length > 3 ? ` and ${impact.stillCalledBy.length - 3} more` : "";
+          console.log(chalk.gray(`       Still called by: ${callerNames}${moreCount}`));
+        }
+        if (impact.impactedFunctions.length > 0) {
+          console.log(chalk.gray(`       Impact: ${impact.impactedFunctions.length} dependent function${impact.impactedFunctions.length === 1 ? "" : "s"}`));
+          const topImpacted = impact.impactedFunctions.slice(0, 3);
+          for (const func of topImpacted) {
+            console.log(chalk.gray(`         \u2022 ${func.name} (${func.file}:${func.line})`));
+          }
+          if (impact.impactedFunctions.length > 3) {
+            console.log(chalk.gray(`         ... and ${impact.impactedFunctions.length - 3} more`));
+          }
+        }
+        if (impact.severity === "CRITICAL") {
+          console.log(chalk.red(`       \u{1F534} ${impact.description.split("\n").pop()}`));
+        }
+        console.log();
+      }
+    }
     if (result.dockerImpact) {
       console.log(chalk.blue("\n  \u{1F4E6} Docker Service Impact:\n"));
       console.log(chalk.red(`    \u26A0\uFE0F  Entry point file(s) modified - service(s) will not start:`));
@@ -2076,7 +3236,7 @@ program.command("reindex").description("Force full re-index of codebase").argume
 program.command("mcp-server").description("Start MCP server for Claude Code integration").option("-p, --path <path>", "Project root path", ".").action(async (options) => {
   process.env.CODEMAP_PROJECT_ROOT = resolve3(options.path);
   process.env.CODEMAP_DB_PATH = join4(resolve3(options.path), ".codemap", "graph.db");
-  await import("./flow-server-UQEOUP2C.js");
+  await import("./flow-server-4XSR5P4N.js");
 });
 program.parse();
 //# sourceMappingURL=cli.js.map