codemap-ai 0.2.0 → 3.0.0

package/dist/index.js

@@ -1,26 +1,12 @@
 import {
-  GraphStorage
-} from "./chunk-FLUWKIEM.js";
+  FlowStorage
+} from "./chunk-GX7ZMBC2.js";
 
-// 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/graph/builder.ts
-import { readFileSync } from "fs";
+// src/flow/builder.ts
+import { readFileSync, statSync } from "fs";
+import { createHash } from "crypto";
 import { glob } from "glob";
-import { relative, resolve } from "path";
+import { resolve, relative, extname } from "path";
 
 // src/parsers/base.ts
 var BaseParser = class {
@@ -108,13 +94,40 @@ var TypeScriptParser = class extends BaseParser {
   }
   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);
     }
-    const tree = this.parser.parse(content);
-    const lines = content.split("\n");
+    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,
@@ -357,7 +370,13 @@ var JavaScriptParser = class extends TypeScriptParser {
     this.parser.setLanguage(JavaScript);
   }
   parse(filePath, content) {
-    const analysis = super.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";
@@ -380,8 +399,41 @@ var PythonParser = class extends BaseParser {
   }
   parse(filePath, content) {
     const analysis = this.createEmptyAnalysis(filePath);
-    const tree = this.parser.parse(content);
-    const lines = content.split("\n");
+    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,
@@ -486,17 +538,66 @@ var PythonParser = class extends BaseParser {
     if (!nameNode) return;
     const name = nameNode.text;
     const decorators = [];
-    let currentNode = node.previousSibling;
-    while (currentNode?.type === "decorator") {
-      const decoratorName = currentNode.children.find(
-        (c) => c.type === "identifier" || c.type === "attribute"
-      );
-      if (decoratorName) {
-        decorators.push(decoratorName.text);
+    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: [] });
+          }
+        }
       }
-      currentNode = currentNode.previousSibling;
     }
     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,
@@ -506,12 +607,20 @@ var PythonParser = class extends BaseParser {
       {
         async: isAsync,
         decorators,
+        decoratorDetails: JSON.stringify(decoratorDetails),
         isPrivate: name.startsWith("_"),
-        isDunder: name.startsWith("__") && name.endsWith("__")
+        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);
@@ -524,6 +633,95 @@ var PythonParser = class extends BaseParser {
       });
     }
   }
+  /**
+   * 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;
@@ -562,6 +760,11 @@ var PythonParser = class extends BaseParser {
       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);
+          }
         }
       }
     }
@@ -578,15 +781,15 @@ var PythonParser = class extends BaseParser {
     if (!nameNode) return;
     const name = nameNode.text;
     const decorators = [];
-    let currentNode = node.previousSibling;
-    while (currentNode?.type === "decorator") {
-      const decoratorName = currentNode.children.find(
-        (c) => c.type === "identifier" || c.type === "attribute"
-      );
-      if (decoratorName) {
-        decorators.push(decoratorName.text);
+    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);
+          }
+        }
       }
-      currentNode = currentNode.previousSibling;
     }
     const isStatic = decorators.includes("staticmethod");
     const isClassMethod = decorators.includes("classmethod");
@@ -624,19 +827,63 @@ var PythonParser = class extends BaseParser {
     } else if (funcNode.type === "attribute") {
       calledName = funcNode.text;
     }
-    if (calledName && !calledName.startsWith("self.")) {
+    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);
@@ -644,6 +891,56 @@ var PythonParser = class extends BaseParser {
     };
     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
@@ -654,11 +951,14 @@ function registerAllParsers() {
 }
 registerAllParsers();
 
-// src/graph/builder.ts
-var GraphBuilder = class {
+// 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;
@@ -666,498 +966,310 @@ var GraphBuilder = class {
   setProgressCallback(callback) {
     this.onProgress = callback;
   }
-  async scan() {
+  async build() {
     const rootPath = resolve(this.config.rootPath);
-    this.emitProgress({ total: 0, current: 0, currentFile: "", phase: "discovering" });
-    const files = await this.discoverFiles(rootPath);
-    const fileAnalyses = [];
-    let current = 0;
-    for (const filePath of files) {
-      current++;
+    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 = readFileSync(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({
-        total: files.length,
-        current,
-        currentFile: relative(rootPath, filePath),
-        phase: "parsing"
+        phase: "parsing",
+        total: filesToIndex.length,
+        current: indexed + 1,
+        currentFile: relative(rootPath, file.path)
       });
       try {
-        const analysis = this.parseFile(filePath);
-        if (analysis) {
-          fileAnalyses.push(analysis);
-          this.storage.insertFileAnalysis(analysis);
-        }
+        await this.parseAndStore(file.path, file.hash, rootPath);
+        indexed++;
       } catch (error) {
-        console.error(`Error parsing ${filePath}:`, error);
+        this.errors.push(`${relative(rootPath, file.path)}: ${error}`);
       }
     }
     this.emitProgress({
-      total: files.length,
-      current: files.length,
-      currentFile: "",
-      phase: "resolving"
+      phase: "resolving",
+      total: filesToIndex.length,
+      current: filesToIndex.length,
+      currentFile: ""
     });
-    this.resolveReferences();
-    const languages = {};
-    for (const analysis of fileAnalyses) {
-      languages[analysis.language] = (languages[analysis.language] || 0) + 1;
-    }
+    this.resolveAllCalls();
     const stats = this.storage.getStats();
-    this.storage.setMeta("rootPath", rootPath);
-    this.storage.setMeta("analyzedAt", (/* @__PURE__ */ new Date()).toISOString());
-    this.storage.setMeta("totalFiles", String(files.length));
     this.emitProgress({
-      total: files.length,
-      current: files.length,
-      currentFile: "",
-      phase: "complete"
+      phase: "complete",
+      total: filesToIndex.length,
+      current: filesToIndex.length,
+      currentFile: ""
     });
     return {
-      rootPath,
-      files: fileAnalyses,
-      totalNodes: stats.totalNodes,
-      totalEdges: stats.totalEdges,
-      languages,
-      analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+      indexed,
+      skipped,
+      resolved: stats.resolvedCalls,
+      unresolved: stats.unresolvedCalls,
+      errors: this.errors
     };
   }
   async discoverFiles(rootPath) {
-    const patterns = this.config.include;
-    const ignorePatterns = this.config.exclude;
     const allFiles = [];
-    for (const pattern of patterns) {
+    for (const pattern of this.config.include) {
       const matches = await glob(pattern, {
         cwd: rootPath,
         absolute: true,
-        ignore: ignorePatterns,
+        ignore: this.config.exclude,
         nodir: true
       });
       allFiles.push(...matches);
     }
-    const supportedExts = new Set(parserRegistry.getSupportedExtensions());
+    const supportedExts = /* @__PURE__ */ new Set([".py", ".ts", ".tsx", ".js", ".jsx"]);
     const uniqueFiles = [...new Set(allFiles)].filter((f) => {
-      const ext = f.substring(f.lastIndexOf("."));
-      return supportedExts.has(ext);
+      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();
   }
-  parseFile(filePath) {
-    const parser = parserRegistry.getForFile(filePath);
+  hashContent(content) {
+    return createHash("sha256").update(content).digest("hex").substring(0, 16);
+  }
+  async parseAndStore(filePath, hash, rootPath) {
+    const language = this.getLanguage(filePath);
+    const content = readFileSync(filePath, "utf-8");
+    const parser = parserRegistry.getByLanguage(language);
     if (!parser) {
-      return null;
+      throw new Error(`No parser found for language: ${language}`);
     }
-    const content = readFileSync(filePath, "utf-8");
-    return parser.parse(filePath, content);
-  }
-  resolveReferences() {
-    const allEdges = this.storage.getAllEdges();
-    const allNodes = this.storage.getAllNodes();
-    const nodeNameMap = /* @__PURE__ */ new Map();
-    for (const node of allNodes) {
-      const existing = nodeNameMap.get(node.name) || [];
-      existing.push(node.id);
-      nodeNameMap.set(node.name, existing);
+    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);
+      }
     }
-    for (const edge of allEdges) {
-      if (edge.targetId.startsWith("ref:")) {
-        const refName = edge.targetId.substring(4);
-        const candidates = nodeNameMap.get(refName);
-        if (candidates && candidates.length > 0) {
-        }
+    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
+        );
+      }
+    }
+    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);
   }
-  emitProgress(progress) {
-    if (this.onProgress) {
-      this.onProgress(progress);
+  /**
+   * 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
+              }
+            });
+          }
+        }
+      }
     }
   }
-};
-
-// src/skills/generator.ts
-import { mkdirSync, writeFileSync, existsSync } from "fs";
-import { join as join2, dirname, basename } from "path";
-var SkillGenerator = class {
-  storage;
-  config;
-  constructor(storage, config) {
-    this.storage = storage;
-    this.config = config;
+  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();
   }
   /**
-   * Generate all skills and write to .claude/skills/
+   * Resolve framework dependencies (e.g., FastAPI Depends())
    */
-  generateAll() {
-    const skills = [];
-    if (this.config.includeArchitecture) {
-      skills.push(this.generateArchitectureSkill());
+  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
+          }
+        });
+      }
     }
-    if (this.config.includePatterns) {
-      skills.push(this.generatePatternsSkill());
+  }
+  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 (this.config.includeDependencies) {
-      skills.push(this.generateDependencySkill());
+    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;
+        }
+      }
     }
-    skills.push(this.generateImpactAnalysisSkill());
-    skills.push(this.generateNavigationSkill());
-    this.writeSkills(skills);
-    return skills;
-  }
-  generateArchitectureSkill() {
-    const stats = this.storage.getStats();
-    const rootPath = this.storage.getMeta("rootPath") || "";
-    const allNodes = this.storage.getNodesByType("file");
-    const directories = /* @__PURE__ */ new Map();
-    for (const node of allNodes) {
-      const relativePath = node.filePath.replace(rootPath, "").replace(/^\//, "");
-      const parts = relativePath.split("/");
-      if (parts.length > 1) {
-        const topDir = parts[0];
-        directories.set(topDir, (directories.get(topDir) || 0) + 1);
+    const nodesInFile = this.storage.getNodesByFile(sourceFilePath);
+    for (const node of nodesInFile) {
+      if (node.name === refName) {
+        return node.id;
       }
     }
-    const sortedDirs = [...directories.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
-    const dirList = sortedDirs.map(([dir, count]) => `- \`${dir}/\` (${count} files)`).join("\n");
-    const langList = Object.entries(stats.languages).map(([lang, count]) => `- ${lang}: ${count} files`).join("\n");
-    const content = `---
-name: architecture
-description: Overview of ${this.config.projectName} architecture and structure
-user-invocable: true
----
-
-# ${this.config.projectName} Architecture
-
-## Project Statistics
-- **Total files**: ${stats.totalFiles}
-- **Functions/Methods**: ${stats.nodesByType.function || 0} functions, ${stats.nodesByType.method || 0} methods
-- **Classes**: ${stats.nodesByType.class || 0}
-- **Import relationships**: ${stats.edgesByType.imports || 0}
-- **Call relationships**: ${stats.edgesByType.calls || 0}
-
-## Languages
-${langList}
-
-## Directory Structure
-${dirList}
-
-## Key Patterns
-When working with this codebase:
-1. Check the main directories above for feature organization
-2. Use the \`/impact\` skill to understand changes
-3. Use the \`/navigate\` skill to find specific code
-
-## Getting Started
-To understand a specific area, ask questions like:
-- "What does the ${sortedDirs[0]?.[0] || "src"} directory contain?"
-- "How is authentication handled?"
-- "What are the main entry points?"
-`;
-    return {
-      name: "architecture",
-      description: `Overview of ${this.config.projectName} architecture`,
-      content,
-      filePath: join2(this.config.outputDir, "architecture", "SKILL.md")
-    };
-  }
-  generatePatternsSkill() {
-    const stats = this.storage.getStats();
-    const classes = this.storage.getNodesByType("class");
-    const functions = this.storage.getNodesByType("function");
-    const classDetails = classes.map((cls) => {
-      const methods = this.storage.getEdgesFrom(cls.id).filter((e) => e.type === "contains");
-      return { ...cls, methodCount: methods.length };
-    }).sort((a, b) => b.methodCount - a.methodCount);
-    const topClasses = classDetails.slice(0, 5);
-    const classList = topClasses.map((c) => `- \`${c.name}\` (${c.methodCount} methods) - [${basename(c.filePath)}](${c.filePath}#L${c.startLine})`).join("\n");
-    const callEdges = this.storage.getEdgesByType("calls");
-    const callCounts = /* @__PURE__ */ new Map();
-    for (const edge of callEdges) {
-      const target = edge.targetId.replace("ref:", "");
-      callCounts.set(target, (callCounts.get(target) || 0) + 1);
+    const resolvedFromImport = this.storage.resolveImport(sourceFilePath, refName);
+    if (resolvedFromImport) {
+      return resolvedFromImport;
     }
-    const mostCalled = [...callCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
-    const calledList = mostCalled.map(([name, count]) => `- \`${name}\` (called ${count} times)`).join("\n");
-    const content = `---
-name: patterns
-description: Common patterns and conventions in ${this.config.projectName}
----
-
-# Codebase Patterns
-
-## Key Classes
-These are the most substantial classes in the codebase:
-${classList || "No classes found"}
-
-## Most Used Functions
-These functions are called most frequently:
-${calledList || "No call data available"}
-
-## Conventions Detected
-
-### File Organization
-${stats.nodesByType.file ? `- ${stats.totalFiles} files organized across the project` : ""}
-${stats.languages.typescript ? "- TypeScript is used for type safety" : ""}
-${stats.languages.python ? "- Python follows standard module patterns" : ""}
-
-### Code Structure
-- Functions: ${stats.nodesByType.function || 0}
-- Classes: ${stats.nodesByType.class || 0}
-- Methods: ${stats.nodesByType.method || 0}
-
-## When Making Changes
-1. Follow existing naming conventions
-2. Check similar files for patterns
-3. Use \`/impact\` to verify affected areas
-`;
-    return {
-      name: "patterns",
-      description: `Common patterns in ${this.config.projectName}`,
-      content,
-      filePath: join2(this.config.outputDir, "patterns", "SKILL.md")
-    };
-  }
-  generateDependencySkill() {
-    const content = `---
-name: dependencies
-description: Explore dependencies and imports in ${this.config.projectName}
-context: fork
-agent: Explore
----
-
-# Dependency Explorer
-
-When analyzing dependencies for $ARGUMENTS:
-
-## Steps
-1. **Find the target file/module**
-   - Search for files matching the query
-   - Identify the main module or component
-
-2. **Analyze imports**
-   - What does this file import?
-   - Are there circular dependencies?
-
-3. **Analyze dependents**
-   - What files import this module?
-   - How deep is the dependency chain?
-
-4. **Provide summary**
-   - List direct dependencies
-   - List files that depend on this
-   - Highlight any concerns (circular deps, too many dependents)
-
-## Query the CodeMap database
-If the codemap MCP server is available, use these queries:
-- Get imports: Query the imports table for the file
-- Get dependents: Find files that import this module
-- Get call graph: Find functions that call into this module
-
-## Output Format
-\`\`\`
-Dependencies for [target]:
-
-IMPORTS (what this uses):
-- module1 (from ./path)
-- module2 (from package)
-
-IMPORTED BY (what uses this):
-- file1.ts (lines X-Y)
-- file2.ts (lines X-Y)
-
-DEPENDENCY DEPTH: N levels
-\`\`\`
-`;
-    return {
-      name: "dependencies",
-      description: `Explore dependencies in ${this.config.projectName}`,
-      content,
-      filePath: join2(this.config.outputDir, "dependencies", "SKILL.md")
-    };
-  }
-  generateImpactAnalysisSkill() {
-    const content = `---
-name: impact
-description: Analyze the impact of changes to a file or function
-disable-model-invocation: true
----
-
-# Impact Analysis
-
-Analyze what would be affected by changes to $ARGUMENTS.
-
-## Analysis Steps
-
-1. **Identify the target**
-   - Find the file, function, or class being modified
-   - Note its current state and purpose
-
-2. **Find direct dependents**
-   - What files import this module?
-   - What functions call this function?
-   - What classes extend this class?
-
-3. **Find indirect dependents**
-   - Follow the chain: if A depends on B, and B is our target, A is affected
-   - Go up to 3 levels deep
-
-4. **Categorize impact**
-   - **Breaking changes**: Signature changes, removed exports
-   - **Behavioral changes**: Logic changes that may affect callers
-   - **Safe changes**: Internal refactors, added functionality
-
-5. **Generate checklist**
-
-## Output Format
-
-\`\`\`markdown
-# Impact Analysis: [target]
-
-## Direct Impact
-- [ ] file1.ts - uses [specific function/import]
-- [ ] file2.ts - extends [class]
-
-## Indirect Impact
-- [ ] file3.ts - imports file1.ts which uses [target]
-
-## Recommended Actions
-1. Update tests in [test files]
-2. Check [specific callers] for compatibility
-3. Update documentation in [docs]
-
-## Risk Level: [LOW/MEDIUM/HIGH]
-[Explanation of risk assessment]
-\`\`\`
-`;
-    return {
-      name: "impact",
-      description: "Analyze impact of code changes",
-      content,
-      filePath: join2(this.config.outputDir, "impact", "SKILL.md")
-    };
+    const matches = this.storage.searchNodesByName(refName);
+    if (matches.length === 1) {
+      return matches[0].id;
+    }
+    return null;
   }
-  generateNavigationSkill() {
-    const stats = this.storage.getStats();
-    const content = `---
-name: navigate
-description: Navigate to specific code in ${this.config.projectName}
----
-
-# Code Navigation
-
-Find and navigate to code matching $ARGUMENTS.
-
-## Available Queries
-
-### By Type
-- "find class [name]" - Locate a class definition
-- "find function [name]" - Locate a function
-- "find file [pattern]" - Find files matching pattern
-- "find imports of [module]" - Find all imports of a module
-
-### By Relationship
-- "callers of [function]" - Who calls this function?
-- "callees of [function]" - What does this function call?
-- "subclasses of [class]" - Classes that extend this
-- "implementers of [interface]" - Classes implementing interface
-
-### By Location
-- "in [directory]" - Filter to specific directory
-- "in [file]" - Show contents of file
-
-## Codebase Stats
-- ${stats.totalFiles} files to search
-- ${stats.nodesByType.function || 0} functions
-- ${stats.nodesByType.class || 0} classes
-- ${stats.nodesByType.method || 0} methods
-
-## Output Format
-For each match, provide:
-- File path with line number link
-- Brief description of what it does
-- Related code (callers/callees if relevant)
-`;
-    return {
-      name: "navigate",
-      description: `Navigate ${this.config.projectName} codebase`,
-      content,
-      filePath: join2(this.config.outputDir, "navigate", "SKILL.md")
-    };
+  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";
   }
-  writeSkills(skills) {
-    for (const skill of skills) {
-      const dir = dirname(skill.filePath);
-      if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-      }
-      writeFileSync(skill.filePath, skill.content, "utf-8");
+  emitProgress(progress) {
+    if (this.onProgress) {
+      this.onProgress(progress);
     }
   }
 };
 
-// src/index.ts
-import { resolve as resolve2, join as join3 } from "path";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
-async function scan(projectPath, options = {}) {
-  const rootPath = resolve2(projectPath);
-  const outputDir = resolve2(rootPath, ".codemap");
-  if (!existsSync2(outputDir)) {
-    mkdirSync2(outputDir, { recursive: true });
-  }
-  const dbPath = join3(outputDir, "graph.db");
-  const storage = new GraphStorage(dbPath);
-  const config = {
-    rootPath,
-    include: options.include || DEFAULT_CONFIG.include,
-    exclude: options.exclude || DEFAULT_CONFIG.exclude,
-    languages: options.languages || DEFAULT_CONFIG.languages,
-    dbPath,
-    skillsOutputDir: options.skillsOutputDir || join3(rootPath, ".claude", "skills", "codemap")
-  };
-  const builder = new GraphBuilder(storage, config);
-  const analysis = await builder.scan();
-  storage.close();
-  return { analysis, dbPath };
-}
-function generateSkills(projectPath, projectName) {
-  const rootPath = resolve2(projectPath);
-  const dbPath = join3(rootPath, ".codemap", "graph.db");
-  if (!existsSync2(dbPath)) {
-    throw new Error("No graph database found. Run scan() first.");
-  }
-  const outputDir = join3(rootPath, ".claude", "skills", "codemap");
-  const storage = new GraphStorage(dbPath);
-  const generator = new SkillGenerator(storage, {
-    projectName: projectName || rootPath.split("/").pop() || "project",
-    outputDir,
-    includeArchitecture: true,
-    includePatterns: true,
-    includeDependencies: true
-  });
-  const skills = generator.generateAll();
-  storage.close();
-  return skills;
-}
-async function scanAndGenerate(projectPath, projectName, options = {}) {
-  const scanResult = await scan(projectPath, options);
-  const skills = generateSkills(projectPath, projectName);
-  return {
-    ...scanResult,
-    skills
-  };
-}
+// 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"]
+};
 export {
-  BaseParser,
   DEFAULT_CONFIG,
-  GraphBuilder,
-  GraphStorage,
-  JavaScriptParser,
-  ParserRegistry,
-  PythonParser,
-  SkillGenerator,
-  TypeScriptParser,
-  generateSkills,
-  parserRegistry,
-  registerAllParsers,
-  scan,
-  scanAndGenerate
+  FlowBuilder,
+  FlowStorage
 };
 //# sourceMappingURL=index.js.map