codemap-ai 0.2.0 → 3.0.0

package/dist/chunk-GX7ZMBC2.js

@@ -0,0 +1,730 @@
+// src/flow/storage.ts
+import Database from "better-sqlite3";
+var FlowStorage = class {
+  db;
+  // Public for builder to access
+  constructor(dbPath) {
+    this.db = new Database(dbPath);
+    this.initSchema();
+  }
+  initSchema() {
+    this.db.exec(`
+      -- Nodes table (enhanced with hash)
+      CREATE TABLE IF NOT EXISTS nodes (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        name TEXT NOT NULL,
+        file_path TEXT NOT NULL,
+        start_line INTEGER NOT NULL,
+        end_line INTEGER NOT NULL,
+        language TEXT NOT NULL,
+        hash TEXT,
+        metadata TEXT
+      );
+
+      -- Edges table (calls and related edges)
+      CREATE TABLE IF NOT EXISTS edges (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        source_id TEXT NOT NULL,
+        target_id TEXT NOT NULL,
+        metadata TEXT
+      );
+
+      -- Files table
+      CREATE TABLE IF NOT EXISTS files (
+        path TEXT PRIMARY KEY,
+        language TEXT NOT NULL,
+        hash TEXT NOT NULL,
+        analyzed_at TEXT NOT NULL
+      );
+
+      -- Exports: symbols exported by each file
+      CREATE TABLE IF NOT EXISTS exports (
+        file_path TEXT NOT NULL,
+        symbol_name TEXT NOT NULL,
+        node_id TEXT NOT NULL,
+        PRIMARY KEY (file_path, symbol_name)
+      );
+
+      -- Imports: what each file imports and from where
+      CREATE TABLE IF NOT EXISTS imports (
+        file_path TEXT NOT NULL,
+        imported_symbol TEXT NOT NULL,
+        from_module TEXT NOT NULL,
+        resolved_node_id TEXT,
+        line INTEGER NOT NULL
+      );
+
+      -- Containers (Docker services)
+      CREATE TABLE IF NOT EXISTS containers (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        image TEXT,
+        ports TEXT,
+        environment TEXT,
+        depends_on TEXT,
+        networks TEXT,
+        metadata TEXT
+      );
+
+      -- HTTP Endpoints (API routes)
+      CREATE TABLE IF NOT EXISTS http_endpoints (
+        id TEXT PRIMARY KEY,
+        method TEXT NOT NULL,
+        path TEXT NOT NULL,
+        handler_node_id TEXT,
+        container_id TEXT,
+        middleware TEXT,
+        metadata TEXT
+      );
+
+      -- HTTP Calls (client requests)
+      CREATE TABLE IF NOT EXISTS http_calls (
+        id TEXT PRIMARY KEY,
+        source_node_id TEXT NOT NULL,
+        target_endpoint_id TEXT,
+        url TEXT NOT NULL,
+        method TEXT NOT NULL,
+        line INTEGER,
+        metadata TEXT
+      );
+
+      -- Framework Dependencies (FastAPI Depends, etc.)
+      CREATE TABLE IF NOT EXISTS framework_dependencies (
+        id TEXT PRIMARY KEY,
+        source_node_id TEXT NOT NULL,
+        target_node_id TEXT,
+        framework TEXT NOT NULL,
+        pattern TEXT NOT NULL,
+        parameter_name TEXT,
+        line INTEGER,
+        unresolved_name TEXT,
+        metadata TEXT
+      );
+
+      -- Database Operations
+      CREATE TABLE IF NOT EXISTS database_operations (
+        id TEXT PRIMARY KEY,
+        node_id TEXT NOT NULL,
+        database_type TEXT NOT NULL,
+        operation TEXT NOT NULL,
+        collection TEXT,
+        line INTEGER,
+        metadata TEXT
+      );
+
+      -- Message Queue Operations
+      CREATE TABLE IF NOT EXISTS message_queue_operations (
+        id TEXT PRIMARY KEY,
+        node_id TEXT NOT NULL,
+        operation TEXT NOT NULL,
+        exchange TEXT,
+        routing_key TEXT,
+        queue TEXT,
+        line INTEGER,
+        metadata TEXT
+      );
+
+      -- Variable Type Tracking
+      CREATE TABLE IF NOT EXISTS variable_types (
+        id TEXT PRIMARY KEY,
+        variable_name TEXT NOT NULL,
+        type_name TEXT NOT NULL,
+        scope_node_id TEXT NOT NULL,
+        file_path TEXT NOT NULL,
+        line INTEGER NOT NULL,
+        is_parameter BOOLEAN DEFAULT 0,
+        metadata TEXT
+      );
+
+      -- Indexes for fast queries
+      CREATE INDEX IF NOT EXISTS idx_nodes_file ON nodes(file_path);
+      CREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes(name);
+      CREATE INDEX IF NOT EXISTS idx_nodes_hash ON nodes(hash);
+      CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id);
+      CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id);
+      CREATE INDEX IF NOT EXISTS idx_edges_resolved ON edges(target_id) WHERE target_id NOT LIKE 'ref:%';
+      CREATE INDEX IF NOT EXISTS idx_exports_file ON exports(file_path);
+      CREATE INDEX IF NOT EXISTS idx_imports_file ON imports(file_path);
+      CREATE INDEX IF NOT EXISTS idx_http_endpoints_path ON http_endpoints(method, path);
+      CREATE INDEX IF NOT EXISTS idx_http_calls_url ON http_calls(url);
+      CREATE INDEX IF NOT EXISTS idx_framework_deps_source ON framework_dependencies(source_node_id);
+      CREATE INDEX IF NOT EXISTS idx_framework_deps_target ON framework_dependencies(target_node_id);
+      CREATE INDEX IF NOT EXISTS idx_variable_types_scope ON variable_types(scope_node_id, variable_name);
+      CREATE INDEX IF NOT EXISTS idx_variable_types_file ON variable_types(file_path, variable_name);
+    `);
+  }
+  // ============ Node Operations ============
+  insertNode(node) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO nodes (id, type, name, file_path, start_line, end_line, language, hash, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      node.id,
+      node.type,
+      node.name,
+      node.filePath,
+      node.startLine,
+      node.endLine,
+      node.language,
+      node.hash || null,
+      node.metadata ? JSON.stringify(node.metadata) : null
+    );
+  }
+  getNode(id) {
+    const stmt = this.db.prepare("SELECT * FROM nodes WHERE id = ?");
+    const row = stmt.get(id);
+    if (!row) return null;
+    return this.rowToNode(row);
+  }
+  searchNodesByName(name) {
+    const stmt = this.db.prepare("SELECT * FROM nodes WHERE name = ? OR name LIKE ?");
+    const rows = stmt.all(name, `%${name}%`);
+    return rows.map((r) => this.rowToNode(r));
+  }
+  getNodesByFile(filePath) {
+    const stmt = this.db.prepare("SELECT * FROM nodes WHERE file_path = ?");
+    const rows = stmt.all(filePath);
+    return rows.map((r) => this.rowToNode(r));
+  }
+  rowToNode(row) {
+    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
+    };
+  }
+  // ============ Edge Operations ============
+  insertEdge(edge) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO edges (id, type, source_id, target_id, metadata)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      edge.id,
+      edge.type,
+      edge.sourceId,
+      edge.targetId,
+      edge.metadata ? JSON.stringify(edge.metadata) : null
+    );
+  }
+  // ============ Call Graph Queries ============
+  /**
+   * Get all resolved callees (functions this node calls)
+   */
+  getResolvedCallees(nodeId) {
+    const stmt = this.db.prepare(`
+      SELECT n.* FROM nodes n
+      JOIN edges e ON n.id = e.target_id
+      WHERE e.source_id = ? AND e.type = 'calls' AND e.target_id NOT LIKE 'ref:%'
+    `);
+    const rows = stmt.all(nodeId);
+    return rows.map((r) => this.rowToNode(r));
+  }
+  /**
+   * Get all resolved callers (functions that call this node)
+   */
+  getResolvedCallers(nodeId) {
+    const stmt = this.db.prepare(`
+      SELECT n.* FROM nodes n
+      JOIN edges e ON n.id = e.source_id
+      WHERE e.target_id = ? AND e.type = 'calls'
+    `);
+    const rows = stmt.all(nodeId);
+    return rows.map((r) => this.rowToNode(r));
+  }
+  /**
+   * Get impact: all nodes affected by changes to this node (BFS traversal)
+   */
+  getImpactedNodes(nodeId, maxDepth = 3) {
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    const queue = [{ id: nodeId, depth: 0 }];
+    while (queue.length > 0) {
+      const { id, depth } = queue.shift();
+      if (visited.has(id) || depth > maxDepth) continue;
+      visited.add(id);
+      const callers = this.getResolvedCallers(id);
+      for (const caller of callers) {
+        if (!visited.has(caller.id)) {
+          result.push(caller);
+          queue.push({ id: caller.id, depth: depth + 1 });
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Trace call path from source to target using BFS
+   */
+  traceCallPath(fromId, toId) {
+    const visited = /* @__PURE__ */ new Set();
+    const parent = /* @__PURE__ */ new Map();
+    const queue = [fromId];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current === toId) {
+        const path = [];
+        let node = toId;
+        while (node !== fromId) {
+          path.unshift(node);
+          node = parent.get(node).nodeId;
+        }
+        path.unshift(fromId);
+        const nodes = path.map((id) => {
+          const n = this.getNode(id);
+          return {
+            id: n.id,
+            name: n.name,
+            file: n.filePath,
+            line: n.startLine
+          };
+        });
+        const edges = [];
+        for (let i = 0; i < path.length - 1; i++) {
+          edges.push({
+            from: path[i],
+            to: path[i + 1],
+            type: "calls"
+          });
+        }
+        return { nodes, edges };
+      }
+      if (visited.has(current)) continue;
+      visited.add(current);
+      const callees = this.getResolvedCallees(current);
+      for (const callee of callees) {
+        if (!visited.has(callee.id)) {
+          parent.set(callee.id, { nodeId: current, edgeType: "calls" });
+          queue.push(callee.id);
+        }
+      }
+    }
+    return null;
+  }
+  // ============ Export/Import Tracking ============
+  registerExport(filePath, symbolName, nodeId) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO exports (file_path, symbol_name, node_id)
+      VALUES (?, ?, ?)
+    `);
+    stmt.run(filePath, symbolName, nodeId);
+  }
+  registerImport(filePath, symbol, fromModule, line) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO imports (file_path, imported_symbol, from_module, line)
+      VALUES (?, ?, ?, ?)
+    `);
+    stmt.run(filePath, symbol, fromModule, line);
+  }
+  resolveImport(filePath, symbol) {
+    const importStmt = this.db.prepare(`
+      SELECT from_module FROM imports WHERE file_path = ? AND imported_symbol = ?
+    `).get(filePath, symbol);
+    if (!importStmt) return null;
+    const modulePath = importStmt.from_module;
+    const possiblePaths = this.resolvePythonModulePath(filePath, modulePath);
+    for (const targetPath of possiblePaths) {
+      const exportStmt = this.db.prepare(`
+        SELECT node_id FROM exports WHERE file_path = ? AND symbol_name = ?
+      `).get(targetPath, symbol);
+      if (exportStmt) {
+        return exportStmt.node_id;
+      }
+    }
+    return null;
+  }
+  /**
+   * Resolve a Python module path to possible file paths
+   * Handles: absolute imports, relative imports, __init__.py
+   */
+  resolvePythonModulePath(currentFile, modulePath) {
+    const possiblePaths = [];
+    if (modulePath.startsWith(".")) {
+      const currentDir = currentFile.substring(0, currentFile.lastIndexOf("/"));
+      const depth = modulePath.match(/^\.+/)?.[0].length || 0;
+      const moduleName = modulePath.replace(/^\.+/, "");
+      let targetDir = currentDir;
+      for (let i = 1; i < depth; i++) {
+        const lastSlash = targetDir.lastIndexOf("/");
+        if (lastSlash > 0) {
+          targetDir = targetDir.substring(0, lastSlash);
+        }
+      }
+      if (moduleName) {
+        const relativePath = moduleName.replace(/\./g, "/");
+        possiblePaths.push(`${targetDir}/${relativePath}.py`);
+        possiblePaths.push(`${targetDir}/${relativePath}/__init__.py`);
+      } else {
+        possiblePaths.push(`${targetDir}/__init__.py`);
+      }
+    } else {
+      const pathComponents = modulePath.split(".");
+      const filePath = pathComponents.join("/");
+      possiblePaths.push(`${filePath}.py`);
+      possiblePaths.push(`${filePath}/__init__.py`);
+      possiblePaths.push(`src/${filePath}.py`);
+      possiblePaths.push(`src/${filePath}/__init__.py`);
+      const lastComponent = pathComponents[pathComponents.length - 1];
+      const matchingFiles = this.db.prepare(`
+        SELECT DISTINCT file_path FROM exports
+        WHERE file_path LIKE ?
+      `).all(`%/${lastComponent}.py`);
+      for (const file of matchingFiles) {
+        const normalizedFilePath = file.file_path.replace(/\\/g, "/");
+        if (normalizedFilePath.includes(filePath)) {
+          possiblePaths.push(normalizedFilePath);
+        }
+      }
+    }
+    return possiblePaths;
+  }
+  /**
+   * Resolve a class method call like ClassName.method_name
+   * Handles: static methods, class methods, imported classes
+   */
+  resolveClassMethod(className, methodName, callerFilePath) {
+    const classNodeId = this.resolveImport(callerFilePath, className);
+    if (classNodeId) {
+      const methods = this.db.prepare(`
+        SELECT target_id FROM edges
+        WHERE source_id = ? AND type = 'contains'
+      `).all(classNodeId);
+      for (const edge of methods) {
+        const methodNode = this.getNode(edge.target_id);
+        if (methodNode && methodNode.name === methodName) {
+          return methodNode.id;
+        }
+      }
+    }
+    const classNode = this.db.prepare(`
+      SELECT id FROM nodes
+      WHERE file_path = ? AND name = ? AND type = 'class'
+    `).get(callerFilePath, className);
+    if (classNode) {
+      const methodNode = this.db.prepare(`
+        SELECT n.id FROM nodes n
+        JOIN edges e ON e.target_id = n.id
+        WHERE e.source_id = ? AND e.type = 'contains' AND n.name = ?
+      `).get(classNode.id, methodName);
+      if (methodNode) {
+        return methodNode.id;
+      }
+    }
+    const allClasses = this.db.prepare(`
+      SELECT id FROM nodes WHERE name = ? AND type = 'class'
+    `).all(className);
+    for (const cls of allClasses) {
+      const methodNode = this.db.prepare(`
+        SELECT n.id FROM nodes n
+        JOIN edges e ON e.target_id = n.id
+        WHERE e.source_id = ? AND e.type = 'contains' AND n.name = ?
+      `).get(cls.id, methodName);
+      if (methodNode) {
+        return methodNode.id;
+      }
+    }
+    return null;
+  }
+  // ============ Variable Type Tracking ============
+  /**
+   * Register a variable type (from assignment or parameter)
+   */
+  registerVariableType(variableName, typeName, scopeNodeId, filePath, line, isParameter = false) {
+    const id = `${scopeNodeId}:var:${variableName}`;
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO variable_types
+        (id, variable_name, type_name, scope_node_id, file_path, line, is_parameter)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(id, variableName, typeName, scopeNodeId, filePath, line, isParameter ? 1 : 0);
+  }
+  /**
+   * Resolve variable.method to actual method node
+   * Example: user.get_name() where user is of type User
+   */
+  resolveVariableMethod(variableName, methodName, scopeNodeId) {
+    if (variableName === "self") {
+      return this.resolveSelfMethod(methodName, scopeNodeId);
+    }
+    const varType = this.db.prepare(`
+      SELECT type_name FROM variable_types
+      WHERE scope_node_id = ? AND variable_name = ?
+    `).get(scopeNodeId, variableName);
+    if (!varType) {
+      return null;
+    }
+    return this.resolveClassMethod(varType.type_name, methodName, "");
+  }
+  /**
+   * Resolve self.method() calls to methods in the same class
+   */
+  resolveSelfMethod(methodName, scopeNodeId) {
+    const parentClass = this.db.prepare(`
+      SELECT source_id FROM edges
+      WHERE target_id = ? AND type = 'contains'
+    `).get(scopeNodeId);
+    if (!parentClass) {
+      return null;
+    }
+    const method = this.db.prepare(`
+      SELECT n.id FROM nodes n
+      JOIN edges e ON e.target_id = n.id
+      WHERE e.source_id = ? AND e.type = 'contains' AND n.name = ?
+    `).get(parentClass.source_id, methodName);
+    return method?.id || null;
+  }
+  /**
+   * Resolve super().method() calls to parent class methods
+   */
+  resolveSuperMethod(methodName, scopeNodeId) {
+    const parentClass = this.db.prepare(`
+      SELECT source_id FROM edges
+      WHERE target_id = ? AND type = 'contains'
+    `).get(scopeNodeId);
+    if (!parentClass) {
+      return null;
+    }
+    const classNode = this.getNode(parentClass.source_id);
+    if (!classNode || classNode.type !== "class") {
+      return null;
+    }
+    const baseClass = this.db.prepare(`
+      SELECT target_id FROM edges
+      WHERE source_id = ? AND type = 'extends'
+    `).get(classNode.id);
+    if (!baseClass) {
+      return null;
+    }
+    let baseClassId = baseClass.target_id;
+    if (baseClassId.startsWith("ref:")) {
+      const baseClassName = baseClassId.replace("ref:", "");
+      const resolvedClass = this.db.prepare(`
+        SELECT id FROM nodes WHERE name = ? AND type = 'class'
+      `).get(baseClassName);
+      if (!resolvedClass) {
+        return null;
+      }
+      baseClassId = resolvedClass.id;
+    }
+    const method = this.db.prepare(`
+      SELECT n.id FROM nodes n
+      JOIN edges e ON e.target_id = n.id
+      WHERE e.source_id = ? AND e.type = 'contains' AND n.name = ?
+    `).get(baseClassId, methodName);
+    return method?.id || null;
+  }
+  // ============ File Operations ============
+  upsertFile(filePath, language, hash) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO files (path, language, hash, analyzed_at)
+      VALUES (?, ?, ?, ?)
+    `);
+    stmt.run(filePath, language, hash, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  getFileHash(filePath) {
+    const stmt = this.db.prepare("SELECT hash FROM files WHERE path = ?");
+    const row = stmt.get(filePath);
+    return row?.hash || null;
+  }
+  deleteFileData(filePath) {
+    this.db.prepare("DELETE FROM nodes WHERE file_path = ?").run(filePath);
+    this.db.prepare("DELETE FROM exports WHERE file_path = ?").run(filePath);
+    this.db.prepare("DELETE FROM imports WHERE file_path = ?").run(filePath);
+    this.db.prepare("DELETE FROM files WHERE path = ?").run(filePath);
+  }
+  // ============ Stats ============
+  getStats() {
+    const totalFiles = this.db.prepare("SELECT COUNT(*) as count FROM files").get().count;
+    const totalNodes = this.db.prepare("SELECT COUNT(*) as count FROM nodes").get().count;
+    const totalEdges = this.db.prepare("SELECT COUNT(*) as count FROM edges WHERE type = 'calls'").get().count;
+    const resolvedCalls = this.db.prepare("SELECT COUNT(*) as count FROM edges WHERE type = 'calls' AND target_id NOT LIKE 'ref:%'").get().count;
+    const unresolvedCalls = totalEdges - resolvedCalls;
+    const httpEndpoints = this.db.prepare("SELECT COUNT(*) as count FROM http_endpoints").get().count;
+    const frameworkDependencies = this.db.prepare("SELECT COUNT(*) as count FROM framework_dependencies").get().count;
+    const resolvedDependencies = this.db.prepare("SELECT COUNT(*) as count FROM framework_dependencies WHERE target_node_id IS NOT NULL").get().count;
+    const containers = this.db.prepare("SELECT COUNT(*) as count FROM containers").get().count;
+    return {
+      totalFiles,
+      totalNodes,
+      totalEdges,
+      resolvedCalls,
+      unresolvedCalls,
+      httpEndpoints,
+      frameworkDependencies,
+      resolvedDependencies,
+      containers
+    };
+  }
+  // ============ Container Operations ============
+  insertContainer(container) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO containers (id, name, image, ports, environment, depends_on, networks, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      container.id,
+      container.name,
+      container.image || null,
+      container.ports ? JSON.stringify(container.ports) : null,
+      container.environment ? JSON.stringify(container.environment) : null,
+      container.depends_on ? JSON.stringify(container.depends_on) : null,
+      container.networks ? JSON.stringify(container.networks) : null,
+      container.metadata ? JSON.stringify(container.metadata) : null
+    );
+  }
+  getContainer(id) {
+    const stmt = this.db.prepare("SELECT * FROM containers WHERE id = ?");
+    const row = stmt.get(id);
+    if (!row) return null;
+    return {
+      id: row.id,
+      name: row.name,
+      image: row.image,
+      ports: row.ports ? JSON.parse(row.ports) : [],
+      environment: row.environment ? JSON.parse(row.environment) : {},
+      depends_on: row.depends_on ? JSON.parse(row.depends_on) : [],
+      networks: row.networks ? JSON.parse(row.networks) : [],
+      metadata: row.metadata ? JSON.parse(row.metadata) : {}
+    };
+  }
+  getAllContainers() {
+    const stmt = this.db.prepare("SELECT * FROM containers");
+    const rows = stmt.all();
+    return rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      image: row.image,
+      ports: row.ports ? JSON.parse(row.ports) : [],
+      environment: row.environment ? JSON.parse(row.environment) : {},
+      depends_on: row.depends_on ? JSON.parse(row.depends_on) : [],
+      networks: row.networks ? JSON.parse(row.networks) : [],
+      metadata: row.metadata ? JSON.parse(row.metadata) : {}
+    }));
+  }
+  // ============ HTTP Endpoint Operations ============
+  insertHttpEndpoint(endpoint) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO http_endpoints (id, method, path, handler_node_id, container_id, middleware, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      endpoint.id,
+      endpoint.method,
+      endpoint.path,
+      endpoint.handler_node_id || null,
+      endpoint.container_id || null,
+      endpoint.middleware ? JSON.stringify(endpoint.middleware) : null,
+      endpoint.metadata ? JSON.stringify(endpoint.metadata) : null
+    );
+  }
+  insertDatabaseOperation(dbOp) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO database_operations (id, node_id, database_type, operation, collection, line, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      dbOp.id,
+      dbOp.node_id,
+      dbOp.database_type,
+      dbOp.operation,
+      dbOp.collection || null,
+      dbOp.line || null,
+      dbOp.metadata ? JSON.stringify(dbOp.metadata) : null
+    );
+  }
+  findHttpEndpoint(method, path) {
+    const stmt = this.db.prepare("SELECT * FROM http_endpoints WHERE method = ? AND path = ?");
+    const row = stmt.get(method, path);
+    if (!row) return null;
+    return {
+      id: row.id,
+      method: row.method,
+      path: row.path,
+      handler_node_id: row.handler_node_id,
+      container_id: row.container_id,
+      middleware: row.middleware ? JSON.parse(row.middleware) : [],
+      metadata: row.metadata ? JSON.parse(row.metadata) : {}
+    };
+  }
+  // ============ Framework Dependency Operations ============
+  insertFrameworkDependency(dep) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO framework_dependencies
+      (id, source_node_id, target_node_id, framework, pattern, parameter_name, line, unresolved_name, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      dep.id,
+      dep.source_node_id,
+      dep.target_node_id || null,
+      dep.framework,
+      dep.pattern,
+      dep.parameter_name || null,
+      dep.line || null,
+      dep.unresolved_name || null,
+      dep.metadata ? JSON.stringify(dep.metadata) : null
+    );
+  }
+  getFrameworkDependencies(sourceNodeId) {
+    const stmt = this.db.prepare("SELECT * FROM framework_dependencies WHERE source_node_id = ?");
+    const rows = stmt.all(sourceNodeId);
+    return rows.map((row) => ({
+      id: row.id,
+      source_node_id: row.source_node_id,
+      target_node_id: row.target_node_id,
+      framework: row.framework,
+      pattern: row.pattern,
+      parameter_name: row.parameter_name,
+      line: row.line,
+      unresolved_name: row.unresolved_name,
+      metadata: row.metadata ? JSON.parse(row.metadata) : {}
+    }));
+  }
+  getAllUnresolvedDependencies() {
+    const stmt = this.db.prepare("SELECT * FROM framework_dependencies WHERE target_node_id IS NULL");
+    const rows = stmt.all();
+    return rows.map((row) => ({
+      id: row.id,
+      source_node_id: row.source_node_id,
+      framework: row.framework,
+      pattern: row.pattern,
+      unresolved_name: row.unresolved_name,
+      line: row.line
+    }));
+  }
+  updateFrameworkDependencyTarget(id, targetNodeId) {
+    const stmt = this.db.prepare("UPDATE framework_dependencies SET target_node_id = ? WHERE id = ?");
+    stmt.run(targetNodeId, id);
+  }
+  clear() {
+    this.db.exec(`
+      DELETE FROM nodes;
+      DELETE FROM edges;
+      DELETE FROM files;
+      DELETE FROM exports;
+      DELETE FROM imports;
+      DELETE FROM containers;
+      DELETE FROM http_endpoints;
+      DELETE FROM http_calls;
+      DELETE FROM framework_dependencies;
+      DELETE FROM database_operations;
+      DELETE FROM message_queue_operations;
+    `);
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+export {
+  FlowStorage
+};
+//# sourceMappingURL=chunk-GX7ZMBC2.js.map