codemap-ai 0.2.0 → 3.0.0

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import Database from 'better-sqlite3';
+
 /**
  * Core types for CodeMap
  */
@@ -12,7 +14,7 @@ interface GraphNode {
     language: string;
     metadata?: Record<string, unknown>;
 }
-type EdgeType = "imports" | "calls" | "extends" | "implements" | "contains" | "uses" | "exports";
+type EdgeType = "imports" | "calls" | "extends" | "implements" | "contains" | "uses" | "exports" | "depends";
 interface GraphEdge {
     id: string;
     type: EdgeType;
@@ -27,6 +29,21 @@ interface FileAnalysis {
     edges: GraphEdge[];
     imports: ImportInfo[];
     exports: ExportInfo[];
+    variableTypes?: VariableTypeInfo[];
+    databaseOperations?: DatabaseOperationInfo[];
+}
+interface VariableTypeInfo {
+    variableName: string;
+    typeName: string;
+    scopeId: string;
+    line: number;
+}
+interface DatabaseOperationInfo {
+    nodeId: string;
+    operation: string;
+    collection: string;
+    databaseType: string;
+    line: number;
 }
 interface ImportInfo {
     source: string;
@@ -47,6 +64,7 @@ interface ProjectAnalysis {
     totalEdges: number;
     languages: Record<string, number>;
     analyzedAt: string;
+    parseErrors?: string[];
 }
 interface AffectedFile {
     filePath: string;
@@ -96,236 +114,195 @@ interface MCPResource {
 }
 
 /**
- * SQLite-based graph storage
+ * Flow-focused storage for call graphs
+ * Simplified from graph/storage.ts with enhanced call resolution
  */
 
-declare class GraphStorage {
-    private db;
+interface CallPath {
+    nodes: Array<{
+        id: string;
+        name: string;
+        file: string;
+        line: number;
+    }>;
+    edges: Array<{
+        from: string;
+        to: string;
+        type: string;
+    }>;
+}
+declare class FlowStorage {
+    db: Database.Database;
     constructor(dbPath: string);
     private initSchema;
-    insertNode(node: GraphNode): void;
+    insertNode(node: GraphNode & {
+        hash?: string;
+    }): void;
     getNode(id: string): GraphNode | null;
+    searchNodesByName(name: string): GraphNode[];
     getNodesByFile(filePath: string): GraphNode[];
-    getNodesByType(type: string): GraphNode[];
-    searchNodes(query: string): GraphNode[];
-    getAllNodes(): GraphNode[];
     private rowToNode;
     insertEdge(edge: GraphEdge): void;
-    getEdgesFrom(sourceId: string): GraphEdge[];
-    getEdgesTo(targetId: string): GraphEdge[];
-    getEdgesByType(type: string): GraphEdge[];
-    getAllEdges(): GraphEdge[];
-    private rowToEdge;
-    insertFileAnalysis(analysis: FileAnalysis): void;
-    deleteFileData(filePath: string): void;
     /**
-     * Get all files that import from a given file/module
+     * Get all resolved callees (functions this node calls)
      */
-    getFilesThatImport(modulePath: string): string[];
+    getResolvedCallees(nodeId: string): GraphNode[];
     /**
-     * Get all callers of a function/method
+     * Get all resolved callers (functions that call this node)
      */
-    getCallers(nodeName: string): GraphNode[];
+    getResolvedCallers(nodeId: string): GraphNode[];
     /**
-     * Get all functions/methods called by a node
+     * Get impact: all nodes affected by changes to this node (BFS traversal)
      */
-    getCallees(nodeId: string): {
-        name: string;
-        line?: number;
-    }[];
+    getImpactedNodes(nodeId: string, maxDepth?: number): GraphNode[];
     /**
-     * Get the dependency tree for a file
+     * Trace call path from source to target using BFS
      */
-    getFileDependencies(filePath: string): {
-        imports: string[];
-        importedBy: string[];
-    };
+    traceCallPath(fromId: string, toId: string): CallPath | null;
+    registerExport(filePath: string, symbolName: string, nodeId: string): void;
+    registerImport(filePath: string, symbol: string, fromModule: string, line: number): void;
+    resolveImport(filePath: string, symbol: string): string | null;
+    /**
+     * Resolve a Python module path to possible file paths
+     * Handles: absolute imports, relative imports, __init__.py
+     */
+    private resolvePythonModulePath;
+    /**
+     * Resolve a class method call like ClassName.method_name
+     * Handles: static methods, class methods, imported classes
+     */
+    resolveClassMethod(className: string, methodName: string, callerFilePath: string): string | null;
+    /**
+     * Register a variable type (from assignment or parameter)
+     */
+    registerVariableType(variableName: string, typeName: string, scopeNodeId: string, filePath: string, line: number, isParameter?: boolean): void;
+    /**
+     * Resolve variable.method to actual method node
+     * Example: user.get_name() where user is of type User
+     */
+    resolveVariableMethod(variableName: string, methodName: string, scopeNodeId: string): string | null;
+    /**
+     * Resolve self.method() calls to methods in the same class
+     */
+    private resolveSelfMethod;
     /**
-     * Get statistics about the graph
+     * Resolve super().method() calls to parent class methods
      */
+    resolveSuperMethod(methodName: string, scopeNodeId: string): string | null;
+    upsertFile(filePath: string, language: string, hash: string): void;
+    getFileHash(filePath: string): string | null;
+    deleteFileData(filePath: string): void;
     getStats(): {
         totalFiles: number;
         totalNodes: number;
         totalEdges: number;
-        nodesByType: Record<string, number>;
-        edgesByType: Record<string, number>;
-        languages: Record<string, number>;
+        resolvedCalls: number;
+        unresolvedCalls: number;
+        httpEndpoints: number;
+        frameworkDependencies: number;
+        resolvedDependencies: number;
+        containers: number;
     };
-    exportForVisualization(): {
-        nodes: Array<{
-            id: string;
-            label: string;
-            type: string;
-            file: string;
-        }>;
-        edges: Array<{
-            source: string;
-            target: string;
-            type: string;
+    insertContainer(container: {
+        id: string;
+        name: string;
+        image?: string;
+        ports?: Array<{
+            host: number;
+            container: number;
         }>;
-    };
+        environment?: Record<string, string>;
+        depends_on?: string[];
+        networks?: string[];
+        metadata?: Record<string, unknown>;
+    }): void;
+    getContainer(id: string): any | null;
+    getAllContainers(): any[];
+    insertHttpEndpoint(endpoint: {
+        id: string;
+        method: string;
+        path: string;
+        handler_node_id?: string;
+        container_id?: string;
+        middleware?: string[];
+        metadata?: Record<string, unknown>;
+    }): void;
+    insertDatabaseOperation(dbOp: {
+        id: string;
+        node_id: string;
+        database_type: string;
+        operation: string;
+        collection?: string;
+        line?: number;
+        metadata?: Record<string, unknown>;
+    }): void;
+    findHttpEndpoint(method: string, path: string): any | null;
+    insertFrameworkDependency(dep: {
+        id: string;
+        source_node_id: string;
+        target_node_id?: string;
+        framework: string;
+        pattern: string;
+        parameter_name?: string;
+        line?: number;
+        unresolved_name?: string;
+        metadata?: Record<string, unknown>;
+    }): void;
+    getFrameworkDependencies(sourceNodeId: string): any[];
+    getAllUnresolvedDependencies(): any[];
+    updateFrameworkDependencyTarget(id: string, targetNodeId: string): void;
     clear(): void;
     close(): void;
-    setMeta(key: string, value: string): void;
-    getMeta(key: string): string | null;
 }
 
 /**
- * Graph builder - scans codebase and builds the knowledge graph
+ * Flow Builder - Builds call graphs with resolved references
+ * Core implementation for CodeMap Flow Edition
  */
 
-interface ScanProgress {
+interface FlowConfig {
+    rootPath: string;
+    include: string[];
+    exclude: string[];
+    forceReindex: boolean;
+}
+interface FlowProgress {
+    phase: "discovering" | "parsing" | "resolving" | "complete";
     total: number;
     current: number;
     currentFile: string;
-    phase: "discovering" | "parsing" | "resolving" | "complete";
 }
-type ProgressCallback = (progress: ScanProgress) => void;
-declare class GraphBuilder {
+type ProgressCallback = (progress: FlowProgress) => void;
+declare class FlowBuilder {
     private storage;
     private config;
     private onProgress?;
-    constructor(storage: GraphStorage, config: CodeMapConfig);
+    private moduleMap;
+    private errors;
+    constructor(storage: FlowStorage, config: FlowConfig);
     setProgressCallback(callback: ProgressCallback): void;
-    scan(): Promise<ProjectAnalysis>;
+    build(): Promise<{
+        indexed: number;
+        skipped: number;
+        resolved: number;
+        unresolved: number;
+        errors: string[];
+    }>;
     private discoverFiles;
-    private parseFile;
-    private resolveReferences;
-    private emitProgress;
-}
-
-/**
- * Base parser interface and utilities
- */
-
-interface Parser {
-    language: string;
-    extensions: string[];
-    parse(filePath: string, content: string): FileAnalysis;
-}
-declare abstract class BaseParser implements Parser {
-    abstract language: string;
-    abstract extensions: string[];
-    protected nodeIdCounter: number;
-    protected edgeIdCounter: number;
-    abstract parse(filePath: string, content: string): FileAnalysis;
-    protected generateNodeId(filePath: string, name: string, line: number): string;
-    protected generateEdgeId(): string;
-    protected createNode(type: GraphNode["type"], name: string, filePath: string, startLine: number, endLine: number, metadata?: Record<string, unknown>): GraphNode;
-    protected createEdge(type: GraphEdge["type"], sourceId: string, targetId: string, metadata?: Record<string, unknown>): GraphEdge;
-    protected createEmptyAnalysis(filePath: string): FileAnalysis;
-}
-/**
- * Registry for all parsers
- */
-declare class ParserRegistry {
-    private parsers;
-    private extensionMap;
-    register(parser: Parser): void;
-    getByLanguage(language: string): Parser | undefined;
-    getByExtension(extension: string): Parser | undefined;
-    getForFile(filePath: string): Parser | undefined;
-    getSupportedExtensions(): string[];
-    getSupportedLanguages(): string[];
-}
-declare const parserRegistry: ParserRegistry;
-
-/**
- * TypeScript/JavaScript parser using Tree-sitter
- */
-
-declare class TypeScriptParser extends BaseParser {
-    language: string;
-    extensions: string[];
-    private parser;
-    constructor();
-    parse(filePath: string, content: string): FileAnalysis;
-    private walkTree;
-    private handleImport;
-    private handleExport;
-    private handleFunction;
-    private handleClass;
-    private handleMethod;
-    private handleCall;
-    private handleVariable;
-}
-declare class JavaScriptParser extends TypeScriptParser {
-    language: string;
-    extensions: string[];
-    constructor();
-    parse(filePath: string, content: string): FileAnalysis;
-}
-
-/**
- * Python parser using Tree-sitter
- */
-
-declare class PythonParser extends BaseParser {
-    language: string;
-    extensions: string[];
-    private parser;
-    constructor();
-    parse(filePath: string, content: string): FileAnalysis;
-    private walkTree;
-    private handleImport;
-    private handleFromImport;
-    private handleFunction;
-    private handleClass;
-    private handleMethod;
-    private handleCall;
-    private parseBodyForCalls;
-}
-
-/**
- * Parser registry and exports
- */
-
-declare function registerAllParsers(): void;
-
-/**
- * Skill Generator - Creates Claude Code skills based on codebase analysis
- */
-
-declare class SkillGenerator {
-    private storage;
-    private config;
-    constructor(storage: GraphStorage, config: SkillConfig);
+    private hashContent;
+    private parseAndStore;
     /**
-     * Generate all skills and write to .claude/skills/
+     * Process framework-specific patterns (FastAPI routes, Depends, etc.)
      */
-    generateAll(): GeneratedSkill[];
-    private generateArchitectureSkill;
-    private generatePatternsSkill;
-    private generateDependencySkill;
-    private generateImpactAnalysisSkill;
-    private generateNavigationSkill;
-    private writeSkills;
-}
-
-/**
- * CodeMap - AI-powered codebase knowledge graph generator
- *
- * Main entry point for programmatic usage
- */
-
-interface ScanResult {
-    analysis: ProjectAnalysis;
-    dbPath: string;
-}
-interface ScanAndGenerateResult extends ScanResult {
-    skills: GeneratedSkill[];
+    private processFrameworkPatterns;
+    private resolveAllCalls;
+    /**
+     * Resolve framework dependencies (e.g., FastAPI Depends())
+     */
+    private resolveFrameworkDependencies;
+    private resolveReference;
+    private getLanguage;
+    private emitProgress;
 }
-/**
- * Scan a codebase and build the knowledge graph
- */
-declare function scan(projectPath: string, options?: Partial<CodeMapConfig>): Promise<ScanResult>;
-/**
- * Generate Claude Code skills from an existing graph
- */
-declare function generateSkills(projectPath: string, projectName?: string): GeneratedSkill[];
-/**
- * Scan a codebase and generate skills in one step
- */
-declare function scanAndGenerate(projectPath: string, projectName?: string, options?: Partial<CodeMapConfig>): Promise<ScanAndGenerateResult>;
 
-export { type AffectedFile, BaseParser, type CallChain, type CodeMapConfig, DEFAULT_CONFIG, type EdgeType, type ExportInfo, type FileAnalysis, type GeneratedSkill, GraphBuilder, type GraphEdge, type GraphNode, GraphStorage, type ImportInfo, JavaScriptParser, type MCPResource, type MCPToolResult, type NodeType, ParserRegistry, type ProgressCallback, type ProjectAnalysis, PythonParser, type ScanAndGenerateResult, type ScanProgress, type ScanResult, type SkillConfig, SkillGenerator, TypeScriptParser, generateSkills, parserRegistry, registerAllParsers, scan, scanAndGenerate };
+export { type AffectedFile, type CallChain, type CallPath, type CodeMapConfig, DEFAULT_CONFIG, type DatabaseOperationInfo, type EdgeType, type ExportInfo, type FileAnalysis, FlowBuilder, type FlowConfig, type FlowProgress, FlowStorage, type GeneratedSkill, type GraphEdge, type GraphNode, type ImportInfo, type MCPResource, type MCPToolResult, type NodeType, type ProgressCallback, type ProjectAnalysis, type SkillConfig, type VariableTypeInfo };