codemap-ai 3.4.0 → 3.6.0

package/dist/chunk-6TAWVGMT.js

@@ -0,0 +1,3539 @@
+#!/usr/bin/env node
+
+import {
+  FlowStorage
+} from "./chunk-BRVRY5KT.js";
+
+// src/parsers/base.ts
+var BaseParser = class {
+  nodeIdCounter = 0;
+  edgeIdCounter = 0;
+  generateNodeId(filePath, name, line) {
+    return `${filePath}:${name}:${line}`;
+  }
+  generateEdgeId() {
+    return `edge_${++this.edgeIdCounter}`;
+  }
+  createNode(type, name, filePath, startLine, endLine, metadata) {
+    return {
+      id: this.generateNodeId(filePath, name, startLine),
+      type,
+      name,
+      filePath,
+      startLine,
+      endLine,
+      language: this.language,
+      metadata
+    };
+  }
+  createEdge(type, sourceId, targetId, metadata) {
+    return {
+      id: this.generateEdgeId(),
+      type,
+      sourceId,
+      targetId,
+      metadata
+    };
+  }
+  createEmptyAnalysis(filePath) {
+    return {
+      filePath,
+      language: this.language,
+      nodes: [],
+      edges: [],
+      imports: [],
+      exports: []
+    };
+  }
+};
+var ParserRegistry = class {
+  parsers = /* @__PURE__ */ new Map();
+  extensionMap = /* @__PURE__ */ new Map();
+  register(parser) {
+    this.parsers.set(parser.language, parser);
+    for (const ext of parser.extensions) {
+      this.extensionMap.set(ext, parser);
+    }
+  }
+  getByLanguage(language) {
+    return this.parsers.get(language);
+  }
+  getByExtension(extension) {
+    const ext = extension.startsWith(".") ? extension : `.${extension}`;
+    return this.extensionMap.get(ext);
+  }
+  getForFile(filePath) {
+    const ext = filePath.substring(filePath.lastIndexOf("."));
+    return this.getByExtension(ext);
+  }
+  getSupportedExtensions() {
+    return Array.from(this.extensionMap.keys());
+  }
+  getSupportedLanguages() {
+    return Array.from(this.parsers.keys());
+  }
+};
+var parserRegistry = new ParserRegistry();
+
+// src/parsers/typescript.ts
+import Parser from "tree-sitter";
+import TypeScript from "tree-sitter-typescript";
+import JavaScript from "tree-sitter-javascript";
+var TypeScriptParser = class extends BaseParser {
+  language = "typescript";
+  extensions = [".ts", ".tsx"];
+  parser;
+  treeSitterParser;
+  // Expose for Phase 3
+  constructor() {
+    super();
+    this.parser = new Parser();
+    this.parser.setLanguage(TypeScript.typescript);
+    this.treeSitterParser = this.parser;
+  }
+  parse(filePath, content) {
+    const analysis = this.createEmptyAnalysis(filePath);
+    const sourceCode = typeof content === "string" ? content : String(content);
+    if (sourceCode.length > 5e5) {
+      const lines2 = sourceCode.split("\n");
+      const fileNode2 = this.createNode(
+        "file",
+        filePath.split("/").pop() || filePath,
+        filePath,
+        1,
+        lines2.length
+      );
+      analysis.nodes.push(fileNode2);
+      return analysis;
+    }
+    if (filePath.endsWith(".tsx")) {
+      this.parser.setLanguage(TypeScript.tsx);
+    } else {
+      this.parser.setLanguage(TypeScript.typescript);
+    }
+    let tree;
+    try {
+      tree = this.parser.parse(sourceCode);
+    } catch {
+      const lines2 = sourceCode.split("\n");
+      const fileNode2 = this.createNode(
+        "file",
+        filePath.split("/").pop() || filePath,
+        filePath,
+        1,
+        lines2.length
+      );
+      analysis.nodes.push(fileNode2);
+      return analysis;
+    }
+    const lines = sourceCode.split("\n");
+    const fileNode = this.createNode(
+      "file",
+      filePath.split("/").pop() || filePath,
+      filePath,
+      1,
+      lines.length
+    );
+    analysis.nodes.push(fileNode);
+    this.walkTree(tree.rootNode, filePath, analysis, fileNode.id);
+    return analysis;
+  }
+  walkTree(node, filePath, analysis, parentId) {
+    switch (node.type) {
+      case "import_statement":
+        this.handleImport(node, analysis);
+        break;
+      case "export_statement":
+        this.handleExport(node, filePath, analysis, parentId);
+        break;
+      case "function_declaration":
+      case "arrow_function":
+      case "function_expression":
+        this.handleFunction(node, filePath, analysis, parentId);
+        break;
+      case "class_declaration":
+        this.handleClass(node, filePath, analysis, parentId);
+        break;
+      case "method_definition":
+        this.handleMethod(node, filePath, analysis, parentId);
+        break;
+      case "call_expression":
+        this.handleCall(node, filePath, analysis, parentId);
+        break;
+      case "variable_declaration":
+        this.handleVariable(node, filePath, analysis, parentId);
+        break;
+    }
+    for (const child of node.children) {
+      this.walkTree(child, filePath, analysis, parentId);
+    }
+  }
+  handleImport(node, analysis) {
+    const sourceNode = node.childForFieldName("source");
+    if (!sourceNode) return;
+    const source = sourceNode.text.replace(/['"]/g, "");
+    const specifiers = [];
+    let isDefault = false;
+    let isNamespace = false;
+    for (const child of node.children) {
+      if (child.type === "import_clause") {
+        for (const clauseChild of child.children) {
+          if (clauseChild.type === "identifier") {
+            specifiers.push(clauseChild.text);
+            isDefault = true;
+          } else if (clauseChild.type === "namespace_import") {
+            isNamespace = true;
+            const nameNode = clauseChild.childForFieldName("name");
+            if (nameNode) specifiers.push(nameNode.text);
+          } else if (clauseChild.type === "named_imports") {
+            for (const importSpec of clauseChild.children) {
+              if (importSpec.type === "import_specifier") {
+                const name = importSpec.childForFieldName("name");
+                if (name) specifiers.push(name.text);
+              }
+            }
+          }
+        }
+      }
+    }
+    analysis.imports.push({
+      source,
+      specifiers,
+      isDefault,
+      isNamespace,
+      line: node.startPosition.row + 1
+    });
+  }
+  handleExport(node, filePath, analysis, parentId) {
+    const isDefault = node.children.some((c) => c.type === "default");
+    for (const child of node.children) {
+      if (child.type === "function_declaration") {
+        const nameNode = child.childForFieldName("name");
+        if (nameNode) {
+          analysis.exports.push({
+            name: nameNode.text,
+            isDefault,
+            line: node.startPosition.row + 1
+          });
+        }
+        this.handleFunction(child, filePath, analysis, parentId);
+      } else if (child.type === "class_declaration") {
+        const nameNode = child.childForFieldName("name");
+        if (nameNode) {
+          analysis.exports.push({
+            name: nameNode.text,
+            isDefault,
+            line: node.startPosition.row + 1
+          });
+        }
+        this.handleClass(child, filePath, analysis, parentId);
+      } else if (child.type === "identifier") {
+        analysis.exports.push({
+          name: child.text,
+          isDefault,
+          line: node.startPosition.row + 1
+        });
+      }
+    }
+  }
+  handleFunction(node, filePath, analysis, parentId) {
+    let name = "anonymous";
+    const nameNode = node.childForFieldName("name");
+    if (nameNode) {
+      name = nameNode.text;
+    }
+    const funcNode = this.createNode(
+      "function",
+      name,
+      filePath,
+      node.startPosition.row + 1,
+      node.endPosition.row + 1,
+      {
+        async: node.children.some((c) => c.type === "async"),
+        generator: node.children.some((c) => c.text === "*")
+      }
+    );
+    analysis.nodes.push(funcNode);
+    analysis.edges.push(
+      this.createEdge("contains", parentId, funcNode.id)
+    );
+  }
+  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,
+      {
+        extends: extends_
+      }
+    );
+    analysis.nodes.push(classNode);
+    analysis.edges.push(
+      this.createEdge("contains", parentId, classNode.id)
+    );
+    for (const baseClass of extends_) {
+      analysis.edges.push(
+        this.createEdge("extends", classNode.id, `ref:${baseClass}`, {
+          unresolvedName: baseClass
+        })
+      );
+    }
+    const body = node.childForFieldName("body");
+    if (body) {
+      for (const member of body.children) {
+        if (member.type === "method_definition") {
+          this.handleMethod(member, filePath, analysis, classNode.id);
+        }
+      }
+    }
+  }
+  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,
+      filePath,
+      node.startPosition.row + 1,
+      node.endPosition.row + 1,
+      {
+        static: node.children.some((c) => c.type === "static"),
+        async: node.children.some((c) => c.type === "async"),
+        parentClass
+      }
+    );
+    analysis.nodes.push(methodNode);
+    analysis.edges.push(
+      this.createEdge("contains", parentId, methodNode.id)
+    );
+  }
+  handleCall(node, filePath, analysis, parentId) {
+    const funcNode = node.childForFieldName("function");
+    if (!funcNode) return;
+    let calledName = "";
+    if (funcNode.type === "identifier") {
+      calledName = funcNode.text;
+    } else if (funcNode.type === "member_expression") {
+      calledName = funcNode.text;
+    }
+    if (calledName) {
+      analysis.edges.push(
+        this.createEdge("calls", parentId, `ref:${calledName}`, {
+          unresolvedName: calledName,
+          line: node.startPosition.row + 1
+        })
+      );
+    }
+  }
+  handleVariable(node, filePath, analysis, parentId) {
+    for (const child of node.children) {
+      if (child.type === "variable_declarator") {
+        const nameNode = child.childForFieldName("name");
+        const valueNode = child.childForFieldName("value");
+        if (nameNode && nameNode.type === "identifier") {
+          if (valueNode && (valueNode.type === "arrow_function" || valueNode.type === "function_expression")) {
+            const funcNode = this.createNode(
+              "function",
+              nameNode.text,
+              filePath,
+              node.startPosition.row + 1,
+              node.endPosition.row + 1,
+              {
+                kind: node.children[0]?.text || "const"
+              }
+            );
+            analysis.nodes.push(funcNode);
+            analysis.edges.push(
+              this.createEdge("contains", parentId, funcNode.id)
+            );
+          }
+        }
+      }
+    }
+  }
+};
+var JavaScriptParser = class extends TypeScriptParser {
+  language = "javascript";
+  extensions = [".js", ".jsx", ".mjs", ".cjs"];
+  constructor() {
+    super();
+    this.parser = new Parser();
+    this.parser.setLanguage(JavaScript);
+    this.treeSitterParser = this.parser;
+  }
+  parse(filePath, content) {
+    const sourceCode = typeof content === "string" ? content : String(content);
+    if (filePath.endsWith(".jsx")) {
+      this.parser.setLanguage(TypeScript.tsx);
+    } else {
+      this.parser.setLanguage(JavaScript);
+    }
+    const analysis = super.parse(filePath, sourceCode);
+    analysis.language = "javascript";
+    for (const node of analysis.nodes) {
+      node.language = "javascript";
+    }
+    return analysis;
+  }
+};
+
+// src/parsers/python.ts
+import Parser2 from "tree-sitter";
+import Python from "tree-sitter-python";
+var PythonParser = class extends BaseParser {
+  language = "python";
+  extensions = [".py"];
+  parser;
+  treeSitterParser;
+  // Expose for Phase 3
+  constructor() {
+    super();
+    this.parser = new Parser2();
+    this.parser.setLanguage(Python);
+    this.treeSitterParser = this.parser;
+  }
+  parse(filePath, content) {
+    const analysis = this.createEmptyAnalysis(filePath);
+    const sourceCode = typeof content === "string" ? content : String(content);
+    if (sourceCode.length > 5e5) {
+      const lines2 = sourceCode.split("\n");
+      const fileNode2 = this.createNode(
+        "file",
+        filePath.split("/").pop() || filePath,
+        filePath,
+        1,
+        lines2.length
+      );
+      analysis.nodes.push(fileNode2);
+      return analysis;
+    }
+    let tree;
+    try {
+      tree = this.parser.parse((index, position) => {
+        if (index >= sourceCode.length) {
+          return null;
+        }
+        const endIndex = Math.min(index + 1024, sourceCode.length);
+        return sourceCode.substring(index, endIndex);
+      });
+    } catch (error) {
+      const lines2 = sourceCode.split("\n");
+      const fileNode2 = this.createNode(
+        "file",
+        filePath.split("/").pop() || filePath,
+        filePath,
+        1,
+        lines2.length
+      );
+      analysis.nodes.push(fileNode2);
+      return analysis;
+    }
+    const lines = sourceCode.split("\n");
+    const fileNode = this.createNode(
+      "file",
+      filePath.split("/").pop() || filePath,
+      filePath,
+      1,
+      lines.length
+    );
+    analysis.nodes.push(fileNode);
+    this.walkTree(tree.rootNode, filePath, analysis, fileNode.id);
+    return analysis;
+  }
+  walkTree(node, filePath, analysis, parentId) {
+    switch (node.type) {
+      case "import_statement":
+        this.handleImport(node, analysis);
+        break;
+      case "import_from_statement":
+        this.handleFromImport(node, analysis);
+        break;
+      case "function_definition":
+        this.handleFunction(node, filePath, analysis, parentId);
+        return;
+      // Don't recurse into function body for top-level analysis
+      case "class_definition":
+        this.handleClass(node, filePath, analysis, parentId);
+        return;
+      // Don't recurse, class handler will process methods
+      case "call":
+        this.handleCall(node, filePath, analysis, parentId);
+        break;
+    }
+    for (const child of node.children) {
+      this.walkTree(child, filePath, analysis, parentId);
+    }
+  }
+  handleImport(node, analysis) {
+    for (const child of node.children) {
+      if (child.type === "dotted_name") {
+        analysis.imports.push({
+          source: child.text,
+          specifiers: [child.text.split(".").pop() || child.text],
+          isDefault: false,
+          isNamespace: true,
+          line: node.startPosition.row + 1
+        });
+      } else if (child.type === "aliased_import") {
+        const nameNode = child.childForFieldName("name");
+        const aliasNode = child.childForFieldName("alias");
+        if (nameNode) {
+          analysis.imports.push({
+            source: nameNode.text,
+            specifiers: [aliasNode?.text || nameNode.text],
+            isDefault: false,
+            isNamespace: true,
+            line: node.startPosition.row + 1
+          });
+        }
+      }
+    }
+  }
+  handleFromImport(node, analysis) {
+    const moduleNode = node.childForFieldName("module_name");
+    if (!moduleNode) return;
+    const source = moduleNode.text;
+    const specifiers = [];
+    for (const child of node.children) {
+      if (child.type === "import_prefix") {
+        continue;
+      }
+      if (child.type === "dotted_name" && child !== moduleNode) {
+        specifiers.push(child.text);
+      } else if (child.type === "aliased_import") {
+        const nameNode = child.childForFieldName("name");
+        if (nameNode) {
+          specifiers.push(nameNode.text);
+        }
+      } else if (child.type === "wildcard_import") {
+        specifiers.push("*");
+      }
+    }
+    if (specifiers.length === 0) {
+      for (const child of node.children) {
+        if (child.type === "import_list" || child.type === "import_from_specifier") {
+          for (const spec of child.children) {
+            if (spec.type === "dotted_name" || spec.type === "identifier") {
+              specifiers.push(spec.text);
+            }
+          }
+        }
+      }
+    }
+    analysis.imports.push({
+      source,
+      specifiers,
+      isDefault: false,
+      isNamespace: specifiers.includes("*"),
+      line: node.startPosition.row + 1
+    });
+  }
+  handleFunction(node, filePath, analysis, parentId) {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode) return;
+    const name = nameNode.text;
+    const decorators = [];
+    const decoratorDetails = [];
+    if (node.parent?.type === "decorated_definition") {
+      for (const sibling of node.parent.children) {
+        if (sibling.type === "decorator") {
+          const decoratorCall = sibling.children.find((c) => c.type === "call");
+          const decoratorAttr = sibling.children.find((c) => c.type === "attribute" || c.type === "identifier");
+          if (decoratorCall) {
+            const funcName = decoratorCall.children.find((c) => c.type === "attribute" || c.type === "identifier");
+            if (funcName) {
+              const fullDecorator = funcName.text;
+              decorators.push(fullDecorator);
+              const args = [];
+              const kwargs = {};
+              const argList = decoratorCall.children.find((c) => c.type === "argument_list");
+              if (argList) {
+                for (const arg of argList.children) {
+                  if (arg.type === "string") {
+                    const stringContent = arg.children.find((c) => c.type === "string_content");
+                    const argText = stringContent ? stringContent.text : arg.text.replace(/^["']|["']$/g, "");
+                    args.push(argText);
+                  } else if (arg.type === "keyword_argument") {
+                    const keyNode = arg.childForFieldName("name");
+                    const valueNode = arg.childForFieldName("value");
+                    if (keyNode && valueNode) {
+                      const key = keyNode.text;
+                      let value = valueNode.text;
+                      if (valueNode.type === "list") {
+                        const items = [];
+                        for (const child of valueNode.children) {
+                          if (child.type === "string") {
+                            const stringContent = child.children.find((c) => c.type === "string_content");
+                            items.push(stringContent ? stringContent.text : child.text.replace(/^["']|["']$/g, ""));
+                          }
+                        }
+                        value = items.length > 0 ? items.join(",") : value;
+                      }
+                      kwargs[key] = value;
+                    }
+                  } else if (arg.type === "identifier") {
+                    args.push(arg.text);
+                  }
+                }
+              }
+              decoratorDetails.push({ name: fullDecorator, args, kwargs });
+            }
+          } else if (decoratorAttr) {
+            const fullDecorator = decoratorAttr.text;
+            decorators.push(fullDecorator);
+            decoratorDetails.push({ name: fullDecorator, args: [] });
+          }
+        }
+      }
+    }
+    const isAsync = node.children.some((c) => c.type === "async");
+    let returnType;
+    const returnTypeNode = node.childForFieldName("return_type");
+    if (returnTypeNode) {
+      returnType = returnTypeNode.text;
+      returnType = returnType.replace(/["']/g, "").split("[")[0].trim();
+    }
+    const funcNode = this.createNode(
+      "function",
+      name,
+      filePath,
+      node.startPosition.row + 1,
+      node.endPosition.row + 1,
+      {
+        async: isAsync,
+        decorators,
+        decoratorDetails: JSON.stringify(decoratorDetails),
+        isPrivate: name.startsWith("_"),
+        isDunder: name.startsWith("__") && name.endsWith("__"),
+        returnType
+      }
+    );
+    analysis.nodes.push(funcNode);
+    analysis.edges.push(this.createEdge("contains", parentId, funcNode.id));
+    this.detectFastAPIRoute(decoratorDetails, funcNode, analysis);
+    const parameters = node.childForFieldName("parameters");
+    if (parameters) {
+      this.detectDependsPattern(parameters, funcNode, analysis);
+      this.extractParameterTypes(parameters, funcNode.id, filePath, analysis);
+    }
+    const body = node.childForFieldName("body");
+    if (body) {
+      this.parseBodyForCalls(body, filePath, analysis, funcNode.id);
+    }
+    if (!name.startsWith("_")) {
+      analysis.exports.push({
+        name,
+        isDefault: false,
+        line: node.startPosition.row + 1
+      });
+    }
+  }
+  /**
+   * Detect FastAPI route decorators like @router.post("/chat")
+   */
+  detectFastAPIRoute(decoratorDetails, funcNode, analysis) {
+    for (const dec of decoratorDetails) {
+      const routeMatch = dec.name.match(/^(router|app)\.(get|post|put|patch|delete|options|head)$/);
+      if (routeMatch && dec.args.length > 0) {
+        const method = routeMatch[2].toUpperCase();
+        const path = dec.args[0];
+        if (!funcNode.metadata) funcNode.metadata = {};
+        funcNode.metadata.httpEndpoint = {
+          method,
+          path
+        };
+      }
+    }
+  }
+  /**
+   * Detect Depends() pattern in function parameters
+   * Example: user: User = Depends(authenticate_user)
+   */
+  detectDependsPattern(parameters, funcNode, analysis) {
+    for (const param of parameters.children) {
+      if (param.type === "typed_parameter" || param.type === "default_parameter") {
+        const defaultValue = param.children.find((c) => c.type === "call");
+        if (defaultValue) {
+          const funcCall = defaultValue.childForFieldName("function");
+          if (funcCall && funcCall.text === "Depends") {
+            const argList = defaultValue.childForFieldName("arguments");
+            if (argList) {
+              for (const arg of argList.children) {
+                if (arg.type === "identifier") {
+                  const dependencyName = arg.text;
+                  const paramName = param.children.find(
+                    (c) => c.type === "identifier"
+                  )?.text;
+                  if (!funcNode.metadata) funcNode.metadata = {};
+                  if (!funcNode.metadata.depends) funcNode.metadata.depends = [];
+                  funcNode.metadata.depends.push({
+                    parameterName: paramName,
+                    dependencyName,
+                    line: param.startPosition.row + 1
+                  });
+                  analysis.edges.push(
+                    this.createEdge("depends", funcNode.id, `ref:${dependencyName}`, {
+                      unresolvedName: dependencyName,
+                      parameterName: paramName,
+                      line: param.startPosition.row + 1
+                    })
+                  );
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Extract parameter type hints and register as variable types
+   * Example: def process(user: User, config: Config)
+   */
+  extractParameterTypes(parameters, scopeId, filePath, analysis) {
+    for (const param of parameters.children) {
+      if (param.type === "typed_parameter") {
+        const nameNode = param.children.find((c) => c.type === "identifier");
+        if (!nameNode) continue;
+        const paramName = nameNode.text;
+        if (paramName === "self" || paramName === "cls") continue;
+        const typeNode = param.children.find((c) => c.type === "type");
+        if (!typeNode) continue;
+        let typeName = typeNode.text;
+        typeName = typeName.replace(/["']/g, "").trim();
+        const genericMatch = typeName.match(/(?:Optional|List|Dict|Set)\[([^\]]+)\]/);
+        if (genericMatch) {
+          typeName = genericMatch[1].trim();
+        }
+        if (!analysis.variableTypes) {
+          analysis.variableTypes = [];
+        }
+        analysis.variableTypes.push({
+          variableName: paramName,
+          typeName,
+          scopeId,
+          line: param.startPosition.row + 1
+        });
+      }
+    }
+  }
+  handleClass(node, filePath, analysis, parentId) {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode) return;
+    const name = nameNode.text;
+    const bases = [];
+    const argumentList = node.children.find((c) => c.type === "argument_list");
+    if (argumentList) {
+      for (const arg of argumentList.children) {
+        if (arg.type === "identifier" || arg.type === "attribute") {
+          bases.push(arg.text);
+        }
+      }
+    }
+    const classNode = this.createNode(
+      "class",
+      name,
+      filePath,
+      node.startPosition.row + 1,
+      node.endPosition.row + 1,
+      {
+        bases,
+        extends: bases,
+        // Add extends for consistency with TypeScript
+        isPrivate: name.startsWith("_")
+      }
+    );
+    analysis.nodes.push(classNode);
+    analysis.edges.push(this.createEdge("contains", parentId, classNode.id));
+    for (const base of bases) {
+      analysis.edges.push(
+        this.createEdge("extends", classNode.id, `ref:${base}`, {
+          unresolvedName: base
+        })
+      );
+    }
+    const body = node.childForFieldName("body");
+    if (body) {
+      for (const child of body.children) {
+        if (child.type === "function_definition") {
+          this.handleMethod(child, filePath, analysis, classNode.id);
+        } else if (child.type === "decorated_definition") {
+          const funcNode = child.children.find((c) => c.type === "function_definition");
+          if (funcNode) {
+            this.handleMethod(funcNode, filePath, analysis, classNode.id);
+          }
+        }
+      }
+    }
+    if (!name.startsWith("_")) {
+      analysis.exports.push({
+        name,
+        isDefault: false,
+        line: node.startPosition.row + 1
+      });
+    }
+  }
+  handleMethod(node, filePath, analysis, classId) {
+    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) {
+        if (sibling.type === "decorator") {
+          const decoratorAttr = sibling.children.find((c) => c.type === "attribute" || c.type === "identifier");
+          if (decoratorAttr) {
+            decorators.push(decoratorAttr.text);
+          }
+        }
+      }
+    }
+    const isStatic = decorators.includes("staticmethod");
+    const isClassMethod = decorators.includes("classmethod");
+    const isProperty = decorators.includes("property");
+    const isAsync = node.children.some((c) => c.type === "async");
+    const methodNode = this.createNode(
+      "method",
+      name,
+      filePath,
+      node.startPosition.row + 1,
+      node.endPosition.row + 1,
+      {
+        async: isAsync,
+        decorators,
+        static: isStatic,
+        classmethod: isClassMethod,
+        property: isProperty,
+        isPrivate: name.startsWith("_"),
+        isDunder: name.startsWith("__") && name.endsWith("__"),
+        parentClass
+      }
+    );
+    analysis.nodes.push(methodNode);
+    analysis.edges.push(this.createEdge("contains", classId, methodNode.id));
+    const body = node.childForFieldName("body");
+    if (body) {
+      this.parseBodyForCalls(body, filePath, analysis, methodNode.id);
+    }
+  }
+  handleCall(node, filePath, analysis, parentId) {
+    const funcNode = node.childForFieldName("function");
+    if (!funcNode) return;
+    let calledName = "";
+    if (funcNode.type === "identifier") {
+      calledName = funcNode.text;
+    } else if (funcNode.type === "attribute") {
+      calledName = funcNode.text;
+    }
+    if (calledName) {
+      analysis.edges.push(
+        this.createEdge("calls", parentId, `ref:${calledName}`, {
+          unresolvedName: calledName,
+          line: node.startPosition.row + 1
+        })
+      );
+      this.detectDatabaseOperation(calledName, node, parentId, analysis);
+    }
+  }
+  /**
+   * Detect database operations (MongoDB, SQL, etc.)
+   * Examples: collection.find_one(), db.users.insert_one(), collection.update_many()
+   */
+  detectDatabaseOperation(calledName, node, parentId, analysis) {
+    const mongoOps = [
+      "find_one",
+      "find",
+      "insert_one",
+      "insert_many",
+      "update_one",
+      "update_many",
+      "delete_one",
+      "delete_many",
+      "aggregate",
+      "count_documents",
+      "replace_one"
+    ];
+    const parts = calledName.split(".");
+    const operation = parts[parts.length - 1];
+    if (mongoOps.includes(operation)) {
+      let collection = "unknown";
+      if (parts.length >= 2) {
+        collection = parts[parts.length - 2];
+      }
+      if (!analysis.databaseOperations) {
+        analysis.databaseOperations = [];
+      }
+      analysis.databaseOperations.push({
+        nodeId: parentId,
+        operation,
+        collection,
+        databaseType: "mongodb",
+        line: node.startPosition.row + 1
+      });
+    }
+  }
+  parseBodyForCalls(body, filePath, analysis, parentId) {
+    const walkForCalls = (node) => {
+      if (node.type === "call") {
+        this.handleCall(node, filePath, analysis, parentId);
+      } else if (node.type === "import_statement") {
+        this.handleImport(node, analysis);
+      } else if (node.type === "import_from_statement") {
+        this.handleFromImport(node, analysis);
+      } else if (node.type === "assignment") {
+        this.handleAssignment(node, filePath, analysis, parentId);
+      }
+      for (const child of node.children) {
+        walkForCalls(child);
+      }
+    };
+    walkForCalls(body);
+  }
+  /**
+   * Handle variable assignments to track types
+   * Examples:
+   *   user = get_user(id)           # Track if get_user has type hint
+   *   handler = UserHandler(db)     # Track: handler -> UserHandler
+   *   org_handler = OrgHandler.get_instance()  # Track: org_handler -> OrgHandler
+   */
+  handleAssignment(node, filePath, analysis, scopeId) {
+    const leftNode = node.childForFieldName("left");
+    if (!leftNode || leftNode.type !== "identifier") return;
+    const variableName = leftNode.text;
+    const rightNode = node.childForFieldName("right");
+    if (!rightNode) return;
+    let typeName = null;
+    if (rightNode.type === "call") {
+      const funcNode = rightNode.childForFieldName("function");
+      if (funcNode) {
+        if (funcNode.type === "identifier") {
+          const funcName = funcNode.text;
+          if (funcName[0] === funcName[0].toUpperCase()) {
+            typeName = funcName;
+          } else {
+            typeName = `@call:${funcName}`;
+          }
+        } else if (funcNode.type === "attribute") {
+          const parts = funcNode.text.split(".");
+          if (parts.length >= 2) {
+            const className = parts[0];
+            const methodName = parts[1];
+            if (className[0] === className[0].toUpperCase()) {
+              typeName = className;
+            } else {
+              typeName = `@call:${funcNode.text}`;
+            }
+          }
+        }
+      }
+    }
+    if (typeName && !analysis.variableTypes) {
+      analysis.variableTypes = [];
+    }
+    if (typeName) {
+      analysis.variableTypes.push({
+        variableName,
+        typeName,
+        scopeId,
+        line: node.startPosition.row + 1
+      });
+    }
+  }
+};
+
+// src/parsers/index.ts
+function registerAllParsers() {
+  parserRegistry.register(new TypeScriptParser());
+  parserRegistry.register(new JavaScriptParser());
+  parserRegistry.register(new PythonParser());
+}
+registerAllParsers();
+
+// src/flow/builder.ts
+import { readFileSync as readFileSync2, statSync } from "fs";
+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/flow/phase3-analyzer.ts
+import { readFileSync } from "fs";
+
+// src/analysis/property-tracker.ts
+function extractPropertyAccesses(functionNode, scopeId, scopeName, filePath) {
+  const accesses = [];
+  const isJS = /\.(js|ts|jsx|tsx)$/.test(filePath);
+  const isPython = /\.py$/.test(filePath);
+  if (isJS) {
+    extractJavaScriptPropertyAccesses(functionNode, scopeId, scopeName, accesses);
+  } else if (isPython) {
+    extractPythonPropertyAccesses(functionNode, scopeId, scopeName, accesses);
+  }
+  return accesses;
+}
+function extractJavaScriptPropertyAccesses(node, scopeId, scopeName, accesses) {
+  traverseNode(node, (current) => {
+    if (current.type === "member_expression") {
+      const access = parseJavaScriptMemberExpression(current, scopeId);
+      if (access) {
+        accesses.push(access);
+      }
+    }
+    if (current.type === "optional_chain") {
+      const memberExpr = current.children.find((c) => c.type === "member_expression");
+      if (memberExpr) {
+        const access = parseJavaScriptMemberExpression(memberExpr, scopeId);
+        if (access) {
+          access.accessType = "optional";
+          accesses.push(access);
+        }
+      }
+    }
+    if (current.type === "subscript_expression") {
+      const access = parseJavaScriptSubscript(current, scopeId);
+      if (access) {
+        accesses.push(access);
+      }
+    }
+  });
+}
+function parseJavaScriptMemberExpression(node, scopeId) {
+  const propertyPath = [];
+  let objectName = "";
+  let currentNode = node;
+  while (currentNode && currentNode.type === "member_expression") {
+    const propertyNode = currentNode.childForFieldName("property");
+    if (propertyNode) {
+      propertyPath.unshift(propertyNode.text);
+    }
+    const objectNode = currentNode.childForFieldName("object");
+    if (!objectNode) break;
+    if (objectNode.type === "identifier") {
+      objectName = objectNode.text;
+      break;
+    } else if (objectNode.type === "member_expression") {
+      currentNode = objectNode;
+    } else {
+      return null;
+    }
+  }
+  if (!objectName || isCommonJavaScriptObject(objectName)) {
+    return null;
+  }
+  if (propertyPath.length === 0) {
+    return null;
+  }
+  return {
+    objectName,
+    propertyPath,
+    fullPath: `${objectName}.${propertyPath.join(".")}`,
+    line: node.startPosition.row + 1,
+    scopeId,
+    accessType: "dot"
+  };
+}
+function parseJavaScriptSubscript(node, scopeId) {
+  const objectNode = node.childForFieldName("object");
+  const indexNode = node.childForFieldName("index");
+  if (!objectNode || !indexNode) return null;
+  if (indexNode.type !== "string") return null;
+  const objectName = objectNode.text;
+  const propertyName = indexNode.text.replace(/['"]/g, "");
+  if (isCommonJavaScriptObject(objectName)) {
+    return null;
+  }
+  return {
+    objectName,
+    propertyPath: [propertyName],
+    fullPath: `${objectName}.${propertyName}`,
+    line: node.startPosition.row + 1,
+    scopeId,
+    accessType: "bracket"
+  };
+}
+function extractPythonPropertyAccesses(node, scopeId, scopeName, accesses) {
+  traverseNode(node, (current) => {
+    if (current.type === "attribute") {
+      const access = parsePythonAttribute(current, scopeId);
+      if (access) {
+        accesses.push(access);
+      }
+    }
+    if (current.type === "subscript") {
+      const access = parsePythonSubscript(current, scopeId);
+      if (access) {
+        accesses.push(access);
+      }
+    }
+  });
+}
+function parsePythonAttribute(node, scopeId) {
+  const propertyPath = [];
+  let objectName = "";
+  let currentNode = node;
+  while (currentNode && currentNode.type === "attribute") {
+    const attrNode = currentNode.childForFieldName("attribute");
+    if (attrNode) {
+      propertyPath.unshift(attrNode.text);
+    }
+    const objectNode = currentNode.childForFieldName("object");
+    if (!objectNode) break;
+    if (objectNode.type === "identifier") {
+      objectName = objectNode.text;
+      break;
+    } else if (objectNode.type === "attribute") {
+      currentNode = objectNode;
+    } else {
+      return null;
+    }
+  }
+  if (!objectName || isCommonPythonObject(objectName)) {
+    return null;
+  }
+  if (propertyPath.length === 0) {
+    return null;
+  }
+  return {
+    objectName,
+    propertyPath,
+    fullPath: `${objectName}.${propertyPath.join(".")}`,
+    line: node.startPosition.row + 1,
+    scopeId,
+    accessType: "dot"
+  };
+}
+function parsePythonSubscript(node, scopeId) {
+  const valueNode = node.childForFieldName("value");
+  const subscriptChildren = node.children.filter(
+    (c) => c.type === "string" || c.type === "identifier"
+  );
+  if (!valueNode || subscriptChildren.length === 0) return null;
+  const keyNode = subscriptChildren.find((c) => c.type === "string");
+  if (!keyNode) return null;
+  const objectName = valueNode.text;
+  const stringContent = keyNode.children.find((c) => c.type === "string_content");
+  const propertyName = stringContent ? stringContent.text : keyNode.text.replace(/['"]/g, "");
+  if (isCommonPythonObject(objectName)) {
+    return null;
+  }
+  return {
+    objectName,
+    propertyPath: [propertyName],
+    fullPath: `${objectName}.${propertyName}`,
+    line: node.startPosition.row + 1,
+    scopeId,
+    accessType: "bracket"
+  };
+}
+function traverseNode(node, visitor) {
+  visitor(node);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      traverseNode(child, visitor);
+    }
+  }
+}
+function isCommonJavaScriptObject(name) {
+  const commonObjects = /* @__PURE__ */ new Set([
+    // Global objects
+    "console",
+    "window",
+    "document",
+    "process",
+    "global",
+    // Common libraries
+    "Math",
+    "JSON",
+    "Date",
+    "Array",
+    "Object",
+    "String",
+    "Number",
+    // Keywords
+    "this",
+    "super",
+    // Common module patterns
+    "exports",
+    "module",
+    "require"
+  ]);
+  return commonObjects.has(name);
+}
+function isCommonPythonObject(name) {
+  const commonObjects = /* @__PURE__ */ new Set([
+    // Keywords
+    "self",
+    "cls",
+    // Built-in types
+    "str",
+    "int",
+    "float",
+    "dict",
+    "list",
+    "tuple",
+    "set",
+    // Common modules
+    "os",
+    "sys",
+    "json",
+    "math",
+    "datetime"
+  ]);
+  return commonObjects.has(name);
+}
+
+// src/analysis/return-analyzer.ts
+function analyzeReturnStatements(functionNode, functionId, functionName, filePath) {
+  const returns = [];
+  const isJS = /\.(js|ts|jsx|tsx)$/.test(filePath);
+  const isPython = /\.py$/.test(filePath);
+  if (isJS) {
+    extractJavaScriptReturns(functionNode, functionId, functionName, returns);
+  } else if (isPython) {
+    extractPythonReturns(functionNode, functionId, functionName, returns);
+  }
+  return returns;
+}
+function extractJavaScriptReturns(node, functionId, functionName, returns) {
+  traverseNode2(node, (current) => {
+    if (current.type === "return_statement") {
+      const returnNode = current.children.find(
+        (c) => c.type !== "return" && c.type !== ";"
+      );
+      if (returnNode) {
+        const returnInfo = parseJavaScriptReturnValue(
+          returnNode,
+          functionId,
+          functionName
+        );
+        if (returnInfo) {
+          returns.push(returnInfo);
+        }
+      }
+    }
+  });
+}
+function parseJavaScriptReturnValue(returnNode, functionId, functionName) {
+  const line = returnNode.startPosition.row + 1;
+  const returnExpression = returnNode.text;
+  let returnType = null;
+  let objectShape = null;
+  if (returnNode.type === "object") {
+    objectShape = extractJavaScriptObjectShape(returnNode);
+    returnType = "object";
+  } else if (returnNode.type === "array") {
+    returnType = "array";
+    objectShape = {
+      properties: [],
+      propertyTypes: /* @__PURE__ */ new Map(),
+      nestedShapes: /* @__PURE__ */ new Map(),
+      isArray: true,
+      isDictionary: false,
+      isOptional: false
+    };
+  } else if (returnNode.type === "new_expression") {
+    const constructorNode = returnNode.childForFieldName("constructor");
+    if (constructorNode) {
+      returnType = constructorNode.text;
+    }
+  } else if (returnNode.type === "identifier") {
+    returnType = `@var:${returnNode.text}`;
+  } else if (returnNode.type === "call_expression") {
+    const funcNode = returnNode.childForFieldName("function");
+    if (funcNode) {
+      returnType = `@call:${funcNode.text}`;
+    }
+  }
+  return {
+    functionId,
+    functionName,
+    returnType,
+    objectShape,
+    line,
+    returnExpression
+  };
+}
+function extractJavaScriptObjectShape(objectNode) {
+  const properties = [];
+  const propertyTypes = /* @__PURE__ */ new Map();
+  const nestedShapes = /* @__PURE__ */ new Map();
+  for (const child of objectNode.children) {
+    if (child.type === "pair") {
+      const keyNode = child.childForFieldName("key");
+      const valueNode = child.childForFieldName("value");
+      if (keyNode) {
+        const propertyName = keyNode.text.replace(/['"]/g, "");
+        properties.push(propertyName);
+        if (valueNode) {
+          const propertyType = inferJavaScriptType(valueNode);
+          propertyTypes.set(propertyName, propertyType);
+          if (valueNode.type === "object") {
+            const nestedShape = extractJavaScriptObjectShape(valueNode);
+            nestedShapes.set(propertyName, nestedShape);
+          }
+        }
+      }
+    }
+  }
+  return {
+    properties,
+    propertyTypes,
+    nestedShapes,
+    isArray: false,
+    isDictionary: false,
+    isOptional: false
+  };
+}
+function inferJavaScriptType(valueNode) {
+  switch (valueNode.type) {
+    case "number":
+      return "number";
+    case "string":
+    case "template_string":
+      return "string";
+    case "true":
+    case "false":
+      return "boolean";
+    case "null":
+      return "null";
+    case "undefined":
+      return "undefined";
+    case "array":
+      return "array";
+    case "object":
+      return "object";
+    case "arrow_function":
+    case "function_expression":
+      return "function";
+    case "identifier":
+      return `@var:${valueNode.text}`;
+    case "call_expression":
+      return "@call";
+    default:
+      return "unknown";
+  }
+}
+function extractPythonReturns(node, functionId, functionName, returns) {
+  traverseNode2(node, (current) => {
+    if (current.type === "return_statement") {
+      const returnNode = current.children.find((c) => c.type !== "return");
+      if (returnNode) {
+        const returnInfo = parsePythonReturnValue(
+          returnNode,
+          functionId,
+          functionName
+        );
+        if (returnInfo) {
+          returns.push(returnInfo);
+        }
+      }
+    }
+  });
+}
+function parsePythonReturnValue(returnNode, functionId, functionName) {
+  const line = returnNode.startPosition.row + 1;
+  const returnExpression = returnNode.text;
+  let returnType = null;
+  let objectShape = null;
+  if (returnNode.type === "dictionary") {
+    objectShape = extractPythonDictionaryShape(returnNode);
+    returnType = "dict";
+  } else if (returnNode.type === "list") {
+    returnType = "list";
+    objectShape = {
+      properties: [],
+      propertyTypes: /* @__PURE__ */ new Map(),
+      nestedShapes: /* @__PURE__ */ new Map(),
+      isArray: true,
+      isDictionary: false,
+      isOptional: false
+    };
+  } else if (returnNode.type === "call") {
+    const funcNode = returnNode.childForFieldName("function");
+    if (funcNode) {
+      const funcName = funcNode.text;
+      if (funcName[0] === funcName[0].toUpperCase()) {
+        returnType = funcName;
+      } else {
+        returnType = `@call:${funcName}`;
+      }
+    }
+  } else if (returnNode.type === "identifier") {
+    returnType = `@var:${returnNode.text}`;
+  } else if (returnNode.type === "list_comprehension") {
+    returnType = "list";
+    objectShape = {
+      properties: [],
+      propertyTypes: /* @__PURE__ */ new Map(),
+      nestedShapes: /* @__PURE__ */ new Map(),
+      isArray: true,
+      isDictionary: false,
+      isOptional: false
+    };
+  }
+  return {
+    functionId,
+    functionName,
+    returnType,
+    objectShape,
+    line,
+    returnExpression
+  };
+}
+function extractPythonDictionaryShape(dictNode) {
+  const properties = [];
+  const propertyTypes = /* @__PURE__ */ new Map();
+  const nestedShapes = /* @__PURE__ */ new Map();
+  for (const child of dictNode.children) {
+    if (child.type === "pair") {
+      const keyNode = child.children.find((c) => c.type === "string");
+      const valueNode = child.children.find(
+        (c) => c.type !== "string" && c.type !== ":"
+      );
+      if (keyNode) {
+        const stringContent = keyNode.children.find(
+          (c) => c.type === "string_content"
+        );
+        const propertyName = stringContent ? stringContent.text : keyNode.text.replace(/['"]/g, "");
+        properties.push(propertyName);
+        if (valueNode) {
+          const propertyType = inferPythonType(valueNode);
+          propertyTypes.set(propertyName, propertyType);
+          if (valueNode.type === "dictionary") {
+            const nestedShape = extractPythonDictionaryShape(valueNode);
+            nestedShapes.set(propertyName, nestedShape);
+          }
+        }
+      }
+    }
+  }
+  return {
+    properties,
+    propertyTypes,
+    nestedShapes,
+    isArray: false,
+    isDictionary: true,
+    isOptional: false
+  };
+}
+function inferPythonType(valueNode) {
+  switch (valueNode.type) {
+    case "integer":
+    case "float":
+      return "number";
+    case "string":
+      return "string";
+    case "true":
+    case "false":
+      return "boolean";
+    case "none":
+      return "None";
+    case "list":
+      return "list";
+    case "dictionary":
+      return "dict";
+    case "lambda":
+      return "function";
+    case "identifier":
+      return `@var:${valueNode.text}`;
+    case "call":
+      return "@call";
+    default:
+      return "unknown";
+  }
+}
+function traverseNode2(node, visitor) {
+  visitor(node);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      traverseNode2(child, visitor);
+    }
+  }
+}
+
+// src/flow/storage-queries-phase3.ts
+import { randomUUID } from "crypto";
+function storePropertyAccesses(db, accesses) {
+  const stmt = db.prepare(`
+    INSERT OR REPLACE INTO property_accesses
+    (id, scope_node_id, object_name, property_path, full_path, access_type, file_path, line)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const insert = db.transaction((accesses2) => {
+    for (const access of accesses2) {
+      stmt.run(
+        randomUUID(),
+        access.scopeId,
+        access.objectName,
+        JSON.stringify(access.propertyPath),
+        access.fullPath,
+        access.accessType,
+        access.filePath || "",
+        access.line
+      );
+    }
+  });
+  insert(accesses);
+}
+function storeReturnInfo(db, returns) {
+  const stmt = db.prepare(`
+    INSERT OR REPLACE INTO return_shapes
+    (id, function_id, return_type, object_shape, line, return_expression)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+  const insert = db.transaction((returns2) => {
+    for (const ret of returns2) {
+      stmt.run(
+        randomUUID(),
+        ret.functionId,
+        ret.returnType,
+        ret.objectShape ? JSON.stringify(serializeObjectShape(ret.objectShape)) : null,
+        ret.line,
+        ret.returnExpression
+      );
+    }
+  });
+  insert(returns);
+}
+function serializeObjectShape(shape) {
+  return {
+    properties: shape.properties,
+    propertyTypes: Array.from(shape.propertyTypes.entries()),
+    nestedShapes: Array.from(shape.nestedShapes.entries()).map(([key, nested]) => [
+      key,
+      serializeObjectShape(nested)
+    ]),
+    isArray: shape.isArray,
+    isDictionary: shape.isDictionary,
+    isOptional: shape.isOptional
+  };
+}
+
+// src/flow/phase3-analyzer.ts
+function analyzeFileForPhase3(filePath, functionNodes, db) {
+  try {
+    const language = getLanguageFromPath(filePath);
+    if (!language) return;
+    const parserInstance = parserRegistry.getByLanguage(language);
+    if (!parserInstance || !parserInstance.treeSitterParser) return;
+    const content = readFileSync(filePath, "utf-8");
+    const tree = parserInstance.treeSitterParser.parse(content);
+    const rootNode = tree.rootNode;
+    for (const func of functionNodes) {
+      const funcNode = findNodeAtLine(rootNode, func.startLine, func.endLine);
+      if (!funcNode) continue;
+      const accesses = extractPropertyAccesses(funcNode, func.id, func.name, filePath);
+      if (accesses.length > 0) {
+        const accessesWithFile = accesses.map((a) => ({ ...a, filePath }));
+        storePropertyAccesses(db, accessesWithFile);
+      }
+      const returns = analyzeReturnStatements(funcNode, func.id, func.name, filePath);
+      if (returns.length > 0) {
+        storeReturnInfo(db, returns);
+      }
+    }
+  } catch (error) {
+  }
+}
+function getLanguageFromPath(filePath) {
+  if (filePath.endsWith(".py")) return "python";
+  if (filePath.endsWith(".js") || filePath.endsWith(".jsx")) return "javascript";
+  if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) return "typescript";
+  return null;
+}
+function findNodeAtLine(node, startLine, endLine) {
+  const nodeStart = node.startPosition.row + 1;
+  const nodeEnd = node.endPosition.row + 1;
+  if (nodeStart === startLine && nodeEnd === endLine) {
+    return node;
+  }
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      const result = findNodeAtLine(child, startLine, endLine);
+      if (result) return result;
+    }
+  }
+  if (nodeStart <= startLine && nodeEnd >= endLine) {
+    if (node.type === "function_definition" || node.type === "function_declaration" || node.type === "method_definition" || node.type === "arrow_function" || node.type === "function_expression") {
+      return node;
+    }
+  }
+  return null;
+}
+
+// src/flow/builder.ts
+var FlowBuilder = class {
+  storage;
+  config;
+  onProgress;
+  moduleMap = /* @__PURE__ */ new Map();
+  // file path → exports
+  errors = [];
+  constructor(storage, config) {
+    this.storage = storage;
+    this.config = config;
+  }
+  setProgressCallback(callback) {
+    this.onProgress = callback;
+  }
+  async build() {
+    const rootPath = resolve(this.config.rootPath);
+    this.emitProgress({
+      phase: "discovering",
+      total: 0,
+      current: 0,
+      currentFile: ""
+    });
+    const allFiles = await this.discoverFiles(rootPath);
+    const filesToIndex = [];
+    let skipped = 0;
+    for (const filePath of allFiles) {
+      const content = readFileSync2(filePath, "utf-8");
+      const hash = this.hashContent(content);
+      if (!this.config.forceReindex) {
+        const existingHash = this.storage.getFileHash(filePath);
+        if (existingHash === hash) {
+          skipped++;
+          continue;
+        }
+      }
+      filesToIndex.push({ path: filePath, hash });
+    }
+    let indexed = 0;
+    for (const file of filesToIndex) {
+      this.emitProgress({
+        phase: "parsing",
+        total: filesToIndex.length,
+        current: indexed + 1,
+        currentFile: relative(rootPath, file.path)
+      });
+      try {
+        await this.parseAndStore(file.path, file.hash, rootPath);
+        indexed++;
+      } catch (error) {
+        this.errors.push(`${relative(rootPath, file.path)}: ${error}`);
+      }
+    }
+    this.emitProgress({
+      phase: "resolving",
+      total: filesToIndex.length,
+      current: filesToIndex.length,
+      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",
+      total: filesToIndex.length,
+      current: filesToIndex.length,
+      currentFile: ""
+    });
+    return {
+      indexed,
+      skipped,
+      resolved: stats.resolvedCalls,
+      unresolved: stats.unresolvedCalls,
+      errors: this.errors
+    };
+  }
+  async discoverFiles(rootPath) {
+    const allFiles = [];
+    for (const pattern of this.config.include) {
+      const matches = await glob(pattern, {
+        cwd: rootPath,
+        absolute: true,
+        ignore: this.config.exclude,
+        nodir: true
+      });
+      allFiles.push(...matches);
+    }
+    const supportedExts = /* @__PURE__ */ new Set([".py", ".ts", ".tsx", ".js", ".jsx"]);
+    const uniqueFiles = [...new Set(allFiles)].filter((f) => {
+      const ext = extname(f);
+      if (!supportedExts.has(ext)) return false;
+      try {
+        const stats = statSync(f);
+        if (stats.size > 2e5) return false;
+      } catch {
+        return false;
+      }
+      return true;
+    });
+    return uniqueFiles.sort();
+  }
+  hashContent(content) {
+    return createHash("sha256").update(content).digest("hex").substring(0, 16);
+  }
+  async parseAndStore(filePath, hash, rootPath) {
+    const language = this.getLanguage(filePath);
+    const content = readFileSync2(filePath, "utf-8");
+    const parser = parserRegistry.getByLanguage(language);
+    if (!parser) {
+      throw new Error(`No parser found for language: ${language}`);
+    }
+    const analysis = parser.parse(filePath, content);
+    this.storage.deleteFileData(filePath);
+    const fileExports = {};
+    for (const node of analysis.nodes) {
+      const nodeHash = this.hashContent(`${node.name}:${node.startLine}:${node.endLine}`);
+      const nodeWithHash = { ...node, hash: nodeHash };
+      this.storage.insertNode(nodeWithHash);
+      if (node.type === "function" || node.type === "class") {
+        fileExports[node.name] = node.id;
+        this.storage.registerExport(filePath, node.name, node.id);
+      }
+    }
+    this.moduleMap.set(filePath, fileExports);
+    for (const edge of analysis.edges) {
+      this.storage.insertEdge(edge);
+    }
+    for (const imp of analysis.imports) {
+      for (const spec of imp.specifiers) {
+        this.storage.registerImport(filePath, spec, imp.source, imp.line);
+      }
+    }
+    if (analysis.variableTypes) {
+      for (const varType of analysis.variableTypes) {
+        this.storage.registerVariableType(
+          varType.variableName,
+          varType.typeName,
+          varType.scopeId,
+          filePath,
+          varType.line
+        );
+      }
+    }
+    const functionNodes = analysis.nodes.filter((n) => n.type === "function" || n.type === "method").map((n) => ({
+      id: n.id,
+      name: n.name,
+      startLine: n.startLine,
+      endLine: n.endLine
+    }));
+    if (functionNodes.length > 0) {
+      analyzeFileForPhase3(filePath, functionNodes, this.storage.db);
+    }
+    if (analysis.databaseOperations) {
+      for (const dbOp of analysis.databaseOperations) {
+        this.storage.insertDatabaseOperation({
+          id: `${dbOp.nodeId}:db:${dbOp.line}`,
+          node_id: dbOp.nodeId,
+          database_type: dbOp.databaseType,
+          operation: dbOp.operation,
+          collection: dbOp.collection,
+          line: dbOp.line
+        });
+      }
+    }
+    this.storage.upsertFile(filePath, language, hash);
+    this.processFrameworkPatterns(analysis.nodes, filePath);
+  }
+  /**
+   * Process framework-specific patterns (FastAPI routes, Depends, etc.)
+   */
+  processFrameworkPatterns(nodes, filePath) {
+    for (const node of nodes) {
+      if (node.type === "function" && node.metadata) {
+        const httpEndpoint = node.metadata.httpEndpoint;
+        if (httpEndpoint) {
+          const endpointId = `${httpEndpoint.method}:${httpEndpoint.path}`;
+          this.storage.insertHttpEndpoint({
+            id: endpointId,
+            method: httpEndpoint.method,
+            path: httpEndpoint.path,
+            handler_node_id: node.id,
+            container_id: void 0,
+            // Will be set when docker-compose is parsed
+            metadata: {
+              filePath,
+              functionName: node.name,
+              line: node.startLine
+            }
+          });
+        }
+        const depends = node.metadata.depends;
+        if (depends) {
+          for (const dep of depends) {
+            const depId = `${node.id}:depends:${dep.parameterName}`;
+            this.storage.insertFrameworkDependency({
+              id: depId,
+              source_node_id: node.id,
+              target_node_id: void 0,
+              // Will be resolved later
+              framework: "fastapi",
+              pattern: "depends",
+              parameter_name: dep.parameterName,
+              line: dep.line,
+              unresolved_name: dep.dependencyName,
+              metadata: {
+                filePath,
+                functionName: node.name
+              }
+            });
+          }
+        }
+      }
+    }
+  }
+  resolveAllCalls() {
+    const unresolvedEdges = this.storage.db.prepare(`SELECT * FROM edges WHERE target_id LIKE 'ref:%'`).all();
+    for (const edge of unresolvedEdges) {
+      const refName = edge.target_id.replace("ref:", "");
+      const sourceNode = this.storage.getNode(edge.source_id);
+      if (!sourceNode) continue;
+      const resolvedId = this.resolveReference(sourceNode.filePath, refName, edge.source_id);
+      if (resolvedId) {
+        this.storage.insertEdge({
+          id: edge.id,
+          type: edge.type,
+          sourceId: edge.source_id,
+          targetId: resolvedId,
+          metadata: edge.metadata ? JSON.parse(edge.metadata) : void 0
+        });
+      }
+    }
+    this.resolveFrameworkDependencies();
+  }
+  /**
+   * Resolve framework dependencies (e.g., FastAPI Depends())
+   */
+  resolveFrameworkDependencies() {
+    const unresolvedDeps = this.storage.getAllUnresolvedDependencies();
+    for (const dep of unresolvedDeps) {
+      const sourceNode = this.storage.getNode(dep.source_node_id);
+      if (!sourceNode) continue;
+      const resolvedId = this.resolveReference(sourceNode.filePath, dep.unresolved_name);
+      if (resolvedId) {
+        this.storage.updateFrameworkDependencyTarget(dep.id, resolvedId);
+        this.storage.insertEdge({
+          id: `${dep.id}:edge`,
+          type: "calls",
+          sourceId: dep.source_node_id,
+          targetId: resolvedId,
+          metadata: {
+            framework: "fastapi",
+            pattern: "depends",
+            line: dep.line
+          }
+        });
+      }
+    }
+  }
+  resolveReference(sourceFilePath, refName, scopeNodeId) {
+    if (refName.startsWith("super().") && scopeNodeId) {
+      const methodName = refName.replace("super().", "");
+      const resolvedSuper = this.storage.resolveSuperMethod(methodName, scopeNodeId);
+      if (resolvedSuper) {
+        return resolvedSuper;
+      }
+    }
+    if (refName.includes(".")) {
+      const parts = refName.split(".");
+      if (parts.length === 2) {
+        const [objectName, methodName] = parts;
+        if (scopeNodeId) {
+          const resolvedVarMethod = this.storage.resolveVariableMethod(objectName, methodName, scopeNodeId);
+          if (resolvedVarMethod) {
+            return resolvedVarMethod;
+          }
+        }
+        const resolvedClassMethod = this.storage.resolveClassMethod(objectName, methodName, sourceFilePath);
+        if (resolvedClassMethod) {
+          return resolvedClassMethod;
+        }
+      }
+    }
+    const nodesInFile = this.storage.getNodesByFile(sourceFilePath);
+    for (const node of nodesInFile) {
+      if (node.name === refName) {
+        return node.id;
+      }
+    }
+    const resolvedFromImport = this.storage.resolveImport(sourceFilePath, refName);
+    if (resolvedFromImport) {
+      return resolvedFromImport;
+    }
+    const matches = this.storage.searchNodesByName(refName);
+    if (matches.length === 1) {
+      return matches[0].id;
+    }
+    return null;
+  }
+  getLanguage(filePath) {
+    const ext = extname(filePath);
+    if (ext === ".py") return "python";
+    if (ext === ".ts" || ext === ".tsx") return "typescript";
+    if (ext === ".js" || ext === ".jsx") return "javascript";
+    return "unknown";
+  }
+  emitProgress(progress) {
+    if (this.onProgress) {
+      this.onProgress(progress);
+    }
+  }
+};
+
+// src/types.ts
+var DEFAULT_CONFIG = {
+  include: ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx", "**/*.py"],
+  exclude: [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.git/**",
+    "**/venv/**",
+    "**/__pycache__/**",
+    "**/.next/**"
+  ],
+  languages: ["typescript", "javascript", "python"]
+};
+
+// src/commands/impact.ts
+import { resolve as resolve2, join as join3, relative as relative2 } from "path";
+
+// src/utils/git.ts
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+function isGitRepository(path) {
+  return existsSync(join(path, ".git"));
+}
+function getGitChangedFiles(rootPath) {
+  try {
+    const output = execSync("git diff HEAD --name-status", {
+      cwd: rootPath,
+      encoding: "utf-8"
+    }).trim();
+    if (!output) {
+      return [];
+    }
+    const files = [];
+    for (const line of output.split("\n")) {
+      const [status, path] = line.split("	");
+      if (path) {
+        files.push({
+          path,
+          status: status === "A" ? "added" : status === "D" ? "deleted" : "modified"
+        });
+      }
+    }
+    return files;
+  } catch (error) {
+    return [];
+  }
+}
+function parseGitDiffForFunctions(rootPath, files) {
+  const changedFunctions = [];
+  for (const file of files) {
+    if (file.status === "deleted") {
+      continue;
+    }
+    try {
+      const diff = execSync(`git diff HEAD -- "${file.path}"`, {
+        cwd: rootPath,
+        encoding: "utf-8"
+      });
+      const lines = diff.split("\n");
+      let currentFunction = null;
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.startsWith("@@")) {
+          const contextMatch = line.match(/@@.*@@\s*(.*)/);
+          if (contextMatch) {
+            const context = contextMatch[1];
+            const pythonMatch = context.match(/(?:async\s+)?def\s+(\w+)/);
+            if (pythonMatch) {
+              currentFunction = pythonMatch[1];
+            }
+            const jsMatch = context.match(/(?:function|const|class)\s+(\w+)/);
+            if (jsMatch) {
+              currentFunction = jsMatch[1];
+            }
+            const lineMatch = line.match(/\+(\d+)/);
+            const lineNumber = lineMatch ? parseInt(lineMatch[1]) : 0;
+            if (currentFunction) {
+              changedFunctions.push({
+                file: file.path,
+                functionName: currentFunction,
+                lineNumber,
+                changeType: file.status === "added" ? "added" : "modified"
+              });
+            }
+          }
+        }
+      }
+    } catch (error) {
+      continue;
+    }
+  }
+  return changedFunctions;
+}
+function getGitStatus(rootPath) {
+  try {
+    const statusOutput = execSync("git status --porcelain", {
+      cwd: rootPath,
+      encoding: "utf-8"
+    }).trim();
+    const lines = statusOutput.split("\n").filter((l) => l.trim());
+    const staged = lines.filter((l) => l[0] !== " " && l[0] !== "?").length;
+    const modified = lines.length;
+    return {
+      hasChanges: modified > 0,
+      modifiedFiles: modified,
+      stagedFiles: staged
+    };
+  } catch (error) {
+    return {
+      hasChanges: false,
+      modifiedFiles: 0,
+      stagedFiles: 0
+    };
+  }
+}
+
+// src/analysis/imports.ts
+import { readFileSync as readFileSync3 } 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 = readFileSync3(filePath, "utf-8");
+  const lines = content.split("\n");
+  const imports = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const defaultMatch = line.match(/import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/);
+    if (defaultMatch) {
+      imports.set(defaultMatch[1], i + 1);
+    }
+    const namedMatch = line.match(/import\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/);
+    if (namedMatch) {
+      const names = namedMatch[1].split(",").map((n) => n.trim().split(" as ")[0].trim());
+      names.forEach((name) => imports.set(name, i + 1));
+    }
+  }
+  const usedIdentifiers = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim().startsWith("import ") || line.trim().startsWith("//") || line.trim().startsWith("*")) {
+      continue;
+    }
+    for (const [identifier] of imports) {
+      const regex = new RegExp(`\\b${identifier}\\b`, "g");
+      if (regex.test(line)) {
+        if (!usedIdentifiers.has(identifier)) {
+          usedIdentifiers.set(identifier, []);
+        }
+        usedIdentifiers.get(identifier).push(i + 1);
+      }
+    }
+  }
+  const unused = [];
+  for (const [identifier, line] of imports) {
+    const usage = usedIdentifiers.get(identifier);
+    if (!usage || usage.length === 0) {
+      unused.push({ identifier, line, type: "unused" });
+    }
+  }
+  const missing = [];
+  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];
+        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 analyzePythonImports(filePath) {
+  const content = readFileSync3(filePath, "utf-8");
+  const lines = content.split("\n");
+  const imports = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const importMatch = line.match(/^import\s+(\w+)/);
+    if (importMatch) {
+      imports.set(importMatch[1], i + 1);
+    }
+    const fromMatch = line.match(/^from\s+[\w.]+\s+import\s+(.+)/);
+    if (fromMatch) {
+      const names = fromMatch[1].split(",").map((n) => n.trim().split(" as ")[0].trim());
+      names.forEach((name) => imports.set(name, i + 1));
+    }
+  }
+  const usedIdentifiers = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim().startsWith("import ") || line.trim().startsWith("from ") || line.trim().startsWith("#")) {
+      continue;
+    }
+    for (const [identifier] of imports) {
+      const regex = new RegExp(`\\b${identifier}\\b`, "g");
+      if (regex.test(line)) {
+        if (!usedIdentifiers.has(identifier)) {
+          usedIdentifiers.set(identifier, []);
+        }
+        usedIdentifiers.get(identifier).push(i + 1);
+      }
+    }
+  }
+  const unused = [];
+  for (const [identifier, line] of imports) {
+    const usage = usedIdentifiers.get(identifier);
+    if (!usage || usage.length === 0) {
+      unused.push({ identifier, line, type: "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")) {
+    return analyzePythonImports(filePath);
+  } else if (filePath.match(/\.(js|jsx|ts|tsx)$/)) {
+    return analyzeJavaScriptImports(filePath);
+  }
+  return { missing: [], unused: [] };
+}
+
+// src/analysis/docker.ts
+import { readFileSync as readFileSync4, existsSync as existsSync2 } from "fs";
+import { load as parseYaml } from "js-yaml";
+import { join as join2 } from "path";
+function parseDockerfile(dockerfilePath) {
+  if (!existsSync2(dockerfilePath)) {
+    return null;
+  }
+  const content = readFileSync4(dockerfilePath, "utf-8");
+  const lines = content.split("\n");
+  let inHealthCheck = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (line.includes("HEALTHCHECK")) {
+      inHealthCheck = true;
+      continue;
+    }
+    if (inHealthCheck && !line.startsWith(" ") && !line.startsWith("	")) {
+      inHealthCheck = false;
+    }
+    if (inHealthCheck) {
+      continue;
+    }
+    if (trimmed.startsWith("CMD")) {
+      const match = trimmed.match(/CMD\s+\[([^\]]+)\]/);
+      if (match) {
+        const parts = match[1].split(",").map((p) => p.trim().replace(/"/g, ""));
+        const commandStr = parts.join(" ");
+        return extractEntryPointFromCommand(commandStr);
+      }
+      const shellMatch = trimmed.match(/CMD\s+(.+)/);
+      if (shellMatch) {
+        return extractEntryPointFromCommand(shellMatch[1]);
+      }
+    }
+    if (trimmed.startsWith("ENTRYPOINT")) {
+      const match = trimmed.match(/ENTRYPOINT\s+\[([^\]]+)\]/);
+      if (match) {
+        const parts = match[1].split(",").map((p) => p.trim().replace(/"/g, ""));
+        const commandStr = parts.join(" ");
+        return extractEntryPointFromCommand(commandStr);
+      }
+    }
+  }
+  return null;
+}
+function extractEntryPointFromCommand(command) {
+  const commandStr = Array.isArray(command) ? command.join(" ") : command;
+  const patterns = [
+    /node\s+([^\s]+\.js)/,
+    /python\s+-m\s+([\w.]+)/,
+    /python\s+([^\s]+\.py)/,
+    /uvicorn\s+([\w:]+)/,
+    /npm\s+start/
+  ];
+  for (const pattern of patterns) {
+    const match = commandStr.match(pattern);
+    if (match) {
+      const entryFile = match[1];
+      if (entryFile.endsWith(".js") || entryFile.endsWith(".py")) {
+        return entryFile;
+      } else if (entryFile.includes(":")) {
+        const file = entryFile.split(":")[0];
+        return `${file}.py`;
+      } else {
+        const file = entryFile.replace(/\./g, "/");
+        return `${file}.py`;
+      }
+    }
+  }
+  return null;
+}
+function parseDockerCompose(projectRoot) {
+  const graph = {
+    services: /* @__PURE__ */ new Map(),
+    entryPoints: /* @__PURE__ */ new Map()
+  };
+  const composeFiles = [
+    join2(projectRoot, "docker-compose.yaml"),
+    join2(projectRoot, "docker-compose.yml"),
+    join2(projectRoot, "compose.yaml"),
+    join2(projectRoot, "compose.yml")
+  ];
+  let composeData = null;
+  for (const file of composeFiles) {
+    if (existsSync2(file)) {
+      const content = readFileSync4(file, "utf-8");
+      composeData = parseYaml(content);
+      break;
+    }
+  }
+  if (!composeData || !composeData.services) {
+    return graph;
+  }
+  for (const [serviceName, serviceConfig] of Object.entries(composeData.services)) {
+    const config = serviceConfig;
+    const service = {
+      name: serviceName,
+      dependsOn: [],
+      volumes: [],
+      entryPoint: config.entrypoint,
+      command: config.command
+    };
+    if (config.depends_on) {
+      if (Array.isArray(config.depends_on)) {
+        service.dependsOn = config.depends_on;
+      } else if (typeof config.depends_on === "object") {
+        service.dependsOn = Object.keys(config.depends_on);
+      }
+    }
+    if (config.volumes && Array.isArray(config.volumes)) {
+      service.volumes = config.volumes.filter((v) => typeof v === "string").map((v) => v.split(":")[0]);
+    }
+    if (config.command) {
+      const entryFile = extractEntryPointFromCommand(config.command);
+      if (entryFile) {
+        graph.entryPoints.set(serviceName, entryFile);
+      }
+    }
+    if (!graph.entryPoints.has(serviceName) && config.build) {
+      const buildContext = typeof config.build === "string" ? config.build : config.build.context;
+      if (buildContext) {
+        const dockerfilePath = join2(projectRoot, buildContext, "Dockerfile");
+        const entryFile = parseDockerfile(dockerfilePath);
+        if (entryFile) {
+          graph.entryPoints.set(serviceName, entryFile);
+        }
+      }
+    }
+    graph.services.set(serviceName, service);
+  }
+  return graph;
+}
+function findDependentServices(graph, serviceName) {
+  const dependents = [];
+  for (const [name, service] of graph.services) {
+    if (service.dependsOn.includes(serviceName)) {
+      dependents.push(name);
+    }
+  }
+  return dependents;
+}
+function calculateServiceBlastRadius(graph, serviceName) {
+  const affected = /* @__PURE__ */ new Set();
+  const queue = [serviceName];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (affected.has(current)) continue;
+    affected.add(current);
+    const dependents = findDependentServices(graph, current);
+    queue.push(...dependents);
+  }
+  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 || ".");
+  const dbPath = join3(rootPath, ".codemap", "graph.db");
+  const storage = new FlowStorage(dbPath);
+  try {
+    if (isGitRepository(rootPath)) {
+      return await analyzeImpactWithGit(storage, rootPath, options);
+    } else {
+      return await analyzeImpactWithHash(storage, rootPath, options);
+    }
+  } finally {
+    storage.close();
+  }
+}
+async function analyzeImpactWithGit(storage, rootPath, options) {
+  const gitStatus = getGitStatus(rootPath);
+  if (!gitStatus.hasChanges) {
+    return {
+      changedFiles: [],
+      changedFunctions: [],
+      directCallers: /* @__PURE__ */ new Map(),
+      affectedEndpoints: [],
+      importIssues: /* @__PURE__ */ new Map(),
+      removedCallImpacts: [],
+      // NEW
+      riskLevel: "LOW",
+      totalImpact: 0
+    };
+  }
+  const changedFiles = getGitChangedFiles(rootPath);
+  const changedFilePaths = changedFiles.map((f) => f.path);
+  const changedFunctions = parseGitDiffForFunctions(rootPath, changedFiles);
+  const builder = new FlowBuilder(storage, {
+    rootPath,
+    include: changedFilePaths.map((f) => f),
+    exclude: [],
+    forceReindex: true
+  });
+  await builder.build();
+  const directCallers = /* @__PURE__ */ new Map();
+  const affectedEndpoints = [];
+  for (const func of changedFunctions) {
+    const nodes = storage.getNodesByFile(join3(rootPath, func.file)).filter((n) => n.name === func.functionName);
+    for (const node of nodes) {
+      const callers = storage.getResolvedCallersWithLocation(node.id);
+      if (callers.length > 0) {
+        directCallers.set(func.functionName, callers);
+      }
+      const endpoints = storage.getHttpEndpointsByHandler(node.id);
+      for (const endpoint of endpoints) {
+        affectedEndpoints.push(`${endpoint.method} ${endpoint.path}`);
+      }
+    }
+  }
+  const importIssues = /* @__PURE__ */ new Map();
+  for (const filePath of changedFilePaths) {
+    const fullPath = join3(rootPath, filePath);
+    const analysis = analyzeImports(fullPath);
+    if (analysis.missing.length > 0 || analysis.unused.length > 0) {
+      importIssues.set(relative2(rootPath, fullPath), analysis);
+    }
+  }
+  const dockerGraph = parseDockerCompose(rootPath);
+  let dockerImpact;
+  const entryPointFiles = [];
+  const affectedServices = /* @__PURE__ */ new Set();
+  for (const [serviceName, entryPoint] of dockerGraph.entryPoints) {
+    for (const changedFile of changedFilePaths) {
+      if (changedFile.includes(entryPoint) || entryPoint.includes(changedFile)) {
+        entryPointFiles.push(entryPoint);
+        const blastRadius = calculateServiceBlastRadius(dockerGraph, serviceName);
+        blastRadius.forEach((s) => affectedServices.add(s));
+      }
+    }
+  }
+  if (affectedServices.size > 0) {
+    dockerImpact = {
+      affectedServices: Array.from(affectedServices),
+      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 (hasCriticalRemovedCalls || hasCriticalImportIssues && hasDockerImpact) {
+    riskLevel = "CRITICAL";
+  } 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 || removedCallImpacts.length > 0) {
+    riskLevel = "MEDIUM";
+  }
+  return {
+    changedFiles: changedFilePaths,
+    changedFunctions,
+    directCallers,
+    affectedEndpoints,
+    importIssues,
+    dockerImpact,
+    removedCallImpacts,
+    // NEW
+    riskLevel,
+    totalImpact: totalCallers + (dockerImpact?.affectedServices.length || 0) + removedCallImpacts.length
+  };
+}
+async function analyzeImpactWithHash(storage, rootPath, options) {
+  const oldHashes = storage.getAllFileHashes();
+  const builder = new FlowBuilder(storage, {
+    rootPath,
+    include: DEFAULT_CONFIG.include,
+    exclude: DEFAULT_CONFIG.exclude,
+    forceReindex: false
+    // Use hash comparison
+  });
+  const result = await builder.build();
+  const changedFiles = [];
+  const newHashes = storage.getAllFileHashes();
+  for (const [filePath, newHash] of Object.entries(newHashes)) {
+    const oldHash = oldHashes[filePath];
+    if (!oldHash || oldHash !== newHash) {
+      changedFiles.push(filePath);
+    }
+  }
+  const importIssues = /* @__PURE__ */ new Map();
+  for (const filePath of changedFiles) {
+    const analysis = analyzeImports(filePath);
+    if (analysis.missing.length > 0 || analysis.unused.length > 0) {
+      importIssues.set(relative2(rootPath, filePath), analysis);
+    }
+  }
+  const hasCriticalImportIssues = Array.from(importIssues.values()).some((i) => i.missing.length > 0);
+  return {
+    changedFiles,
+    changedFunctions: [],
+    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
+  };
+}
+
+export {
+  FlowBuilder,
+  DEFAULT_CONFIG,
+  analyzeImpact
+};
+//# sourceMappingURL=chunk-6TAWVGMT.js.map