@codeflow-map/core 0.1.3 → 0.2.0

package/dist/graph/callGraphBuilder.d.ts

@@ -1,2 +1,2 @@
-import { FunctionNode, RawCall, CallEdge } from '../types';
-export declare function buildCallGraph(nodes: FunctionNode[], rawCalls: RawCall[]): CallEdge[];
+import { FunctionNode, RawCall, CallEdge, Logger } from '../types';
+export declare function buildCallGraph(nodes: FunctionNode[], rawCalls: RawCall[], log?: Logger): CallEdge[];

package/dist/graph/callGraphBuilder.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildCallGraph = buildCallGraph;
-function buildCallGraph(nodes, rawCalls) {
+function buildCallGraph(nodes, rawCalls, log) {
+    const t0 = Date.now();
+    log?.(`buildCallGraph: START — ${nodes.length} nodes, ${rawCalls.length} raw calls`);
     const byName = new Map();
     const bySuffix = new Map();
+    // Index nodes by file path for fast caller lookups
+    const byFile = new Map();
     for (const n of nodes) {
         byName.set(n.name, n);
         const dotIdx = n.name.lastIndexOf('.');
@@ -13,14 +17,26 @@ function buildCallGraph(nodes, rawCalls) {
                 bySuffix.set(suffix, []);
             bySuffix.get(suffix).push(n);
         }
+        if (!byFile.has(n.filePath))
+            byFile.set(n.filePath, []);
+        byFile.get(n.filePath).push(n);
     }
+    log?.(`buildCallGraph: indexes built in ${Date.now() - t0}ms (byName=${byName.size}, bySuffix=${bySuffix.size}, byFile=${byFile.size})`);
     const edges = [];
+    const edgeSet = new Set();
+    const tLoop = Date.now();
+    let processed = 0;
+    const logInterval = Math.max(1, Math.floor(rawCalls.length / 10)); // log every ~10%
     for (const call of rawCalls) {
+        processed++;
+        if (log && processed % logInterval === 0) {
+            log(`buildCallGraph: processing call ${processed}/${rawCalls.length} (${edges.length} edges so far, ${Date.now() - tLoop}ms)`);
+        }
         let callee = byName.get(call.calleeName);
         // Find the innermost function whose range contains the call line,
         // excluding the callee itself to avoid self-loops (e.g. go func(){...}())
-        const callerCandidates = nodes.filter(n => n.filePath === call.callerFilePath &&
-            call.line >= n.startLine &&
+        const fileNodes = byFile.get(call.callerFilePath) || [];
+        const callerCandidates = fileNodes.filter(n => call.line >= n.startLine &&
             call.line <= n.endLine &&
             n !== callee);
         const caller = callerCandidates.length > 0
@@ -47,12 +63,15 @@ function buildCallGraph(nodes, rawCalls) {
         if (!callee)
             continue;
         // Deduplicate: skip if an edge with same from, to, and line already exists
-        if (edges.some(e => e.from === caller.id && e.to === callee.id && e.line === call.line))
+        const edgeKey = `${caller.id}|${callee.id}|${call.line}`;
+        if (edgeSet.has(edgeKey))
             continue;
+        edgeSet.add(edgeKey);
         const edge = { from: caller.id, to: callee.id, line: call.line };
         if (call.callType)
             edge.callType = call.callType;
         edges.push(edge);
     }
+    log?.(`buildCallGraph: DONE — ${edges.length} edges in ${Date.now() - t0}ms`);
     return edges;
 }

package/dist/graph/entryPointDetector.d.ts

@@ -1,2 +1,2 @@
-import { FunctionNode, CallEdge } from '../types';
-export declare function detectEntryPoints(nodes: FunctionNode[], edges: CallEdge[]): void;
+import { FunctionNode, CallEdge, Logger } from '../types';
+export declare function detectEntryPoints(nodes: FunctionNode[], edges: CallEdge[], log?: Logger): void;

package/dist/graph/entryPointDetector.js

@@ -1,11 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectEntryPoints = detectEntryPoints;
-function detectEntryPoints(nodes, edges) {
+function detectEntryPoints(nodes, edges, log) {
+    const t0 = Date.now();
+    log?.(`detectEntryPoints: START — ${nodes.length} nodes, ${edges.length} edges`);
     const nonSelfEdges = edges.filter(e => e.from !== e.to);
     const calledIds = new Set(nonSelfEdges.map(e => e.to));
     const callerIds = new Set(nonSelfEdges.map(e => e.from));
+    let entryCount = 0;
     for (const node of nodes) {
         node.isEntryPoint = node.isEntryPoint || (!calledIds.has(node.id) && callerIds.has(node.id));
+        if (node.isEntryPoint)
+            entryCount++;
     }
+    log?.(`detectEntryPoints: DONE — ${entryCount} entry points found in ${Date.now() - t0}ms`);
 }

package/dist/graph/flowPartitioner.d.ts

@@ -1,5 +1,5 @@
-import { FunctionNode, CallEdge, Flow } from '../types';
-export declare function partitionFlows(nodes: FunctionNode[], edges: CallEdge[]): {
+import { FunctionNode, CallEdge, Flow, Logger } from '../types';
+export declare function partitionFlows(nodes: FunctionNode[], edges: CallEdge[], log?: Logger): {
     flows: Flow[];
     orphans: string[];
 };

package/dist/graph/flowPartitioner.js

@@ -1,50 +1,101 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.partitionFlows = partitionFlows;
-function partitionFlows(nodes, edges) {
+function partitionFlows(nodes, edges, log) {
+    const t0 = Date.now();
+    log?.(`partitionFlows: START — ${nodes.length} nodes, ${edges.length} edges`);
     const flows = [];
     const visited = new Set();
     const nonSelfEdges = edges.filter(e => e.from !== e.to);
+    log?.(`partitionFlows: ${nonSelfEdges.length} non-self edges after filtering`);
+    // Build adjacency list for fast BFS
+    const adj = new Map();
+    const adjBi = new Map();
+    for (const e of nonSelfEdges) {
+        if (!adj.has(e.from))
+            adj.set(e.from, []);
+        adj.get(e.from).push(e.to);
+        // bidirectional
+        if (!adjBi.has(e.from))
+            adjBi.set(e.from, []);
+        adjBi.get(e.from).push(e.to);
+        if (!adjBi.has(e.to))
+            adjBi.set(e.to, []);
+        adjBi.get(e.to).push(e.from);
+    }
+    log?.(`partitionFlows: adjacency lists built in ${Date.now() - t0}ms`);
     // 1. BFS from every entry point (in-degree=0, out-degree>0)
+    const t1 = Date.now();
     const entryIds = findEntryIds(new Set(nodes.map(n => n.id)), nonSelfEdges);
+    log?.(`partitionFlows: phase 1 — ${entryIds.length} entry points found in ${Date.now() - t1}ms`);
     for (const eid of entryIds) {
-        const reachable = bfs(eid, nonSelfEdges);
+        const reachable = bfsAdj(eid, adj);
         flows.push({ id: eid, entryPoint: eid, nodeIds: [...reachable] });
         reachable.forEach(id => visited.add(id));
     }
+    log?.(`partitionFlows: phase 1 done — ${flows.length} flows, ${visited.size} visited nodes (${Date.now() - t0}ms)`);
     // 2. Iteratively find mini-flows in unvisited subgraph
+    const t2 = Date.now();
     let remaining = new Set(nodes.map(n => n.id).filter(id => !visited.has(id)));
+    log?.(`partitionFlows: phase 2 — ${remaining.size} remaining nodes`);
+    let phase2Iters = 0;
     while (remaining.size > 0) {
+        phase2Iters++;
         const subEdges = nonSelfEdges.filter(e => remaining.has(e.from) && remaining.has(e.to));
+        const subAdj = new Map();
+        for (const e of subEdges) {
+            if (!subAdj.has(e.from))
+                subAdj.set(e.from, []);
+            subAdj.get(e.from).push(e.to);
+        }
         const subEntries = findEntryIds(remaining, subEdges);
         if (subEntries.length === 0)
             break;
         for (const eid of subEntries) {
-            const reachable = bfs(eid, subEdges);
+            const reachable = bfsAdj(eid, subAdj);
             flows.push({ id: eid, entryPoint: eid, nodeIds: [...reachable] });
             reachable.forEach(id => visited.add(id));
         }
         remaining = new Set([...remaining].filter(id => !visited.has(id)));
+        if (phase2Iters % 50 === 0) {
+            log?.(`partitionFlows: phase 2 iteration ${phase2Iters}, ${remaining.size} remaining, ${flows.length} flows (${Date.now() - t2}ms)`);
+        }
     }
+    log?.(`partitionFlows: phase 2 done — ${phase2Iters} iterations, ${flows.length} flows, ${remaining.size} remaining (${Date.now() - t0}ms)`);
     // 3. Remaining nodes with edges (pure cycles) → pick one per component
+    const t3 = Date.now();
     remaining = new Set([...remaining]);
     if (remaining.size > 0) {
         const subEdges = nonSelfEdges.filter(e => remaining.has(e.from) && remaining.has(e.to));
+        const subAdjBi = new Map();
+        const subAdj = new Map();
+        for (const e of subEdges) {
+            if (!subAdj.has(e.from))
+                subAdj.set(e.from, []);
+            subAdj.get(e.from).push(e.to);
+            if (!subAdjBi.has(e.from))
+                subAdjBi.set(e.from, []);
+            subAdjBi.get(e.from).push(e.to);
+            if (!subAdjBi.has(e.to))
+                subAdjBi.set(e.to, []);
+            subAdjBi.get(e.to).push(e.from);
+        }
         const nodesWithEdges = new Set();
         for (const e of subEdges) {
             nodesWithEdges.add(e.from);
             nodesWithEdges.add(e.to);
         }
+        log?.(`partitionFlows: phase 3 — ${nodesWithEdges.size} cycle-nodes to process`);
         const componentVisited = new Set();
         for (const nid of nodesWithEdges) {
             if (componentVisited.has(nid))
                 continue;
             // BFS bidirectional to find connected component
-            const component = bfsBidirectional(nid, subEdges);
+            const component = bfsAdj(nid, subAdjBi);
             component.forEach(id => componentVisited.add(id));
             // Pick the first node as synthetic entry
             const syntheticEntry = nid;
-            const reachable = bfs(syntheticEntry, subEdges);
+            const reachable = bfsAdj(syntheticEntry, subAdj);
             // Include all component members even if not forward-reachable
             component.forEach(id => reachable.add(id));
             flows.push({ id: syntheticEntry, entryPoint: syntheticEntry, nodeIds: [...reachable] });
@@ -52,8 +103,10 @@ function partitionFlows(nodes, edges) {
         }
         remaining = new Set([...remaining].filter(id => !visited.has(id)));
     }
+    log?.(`partitionFlows: phase 3 done in ${Date.now() - t3}ms`);
     // 4. True orphans — zero edges in the full graph
     const orphans = [...remaining];
+    log?.(`partitionFlows: DONE — ${flows.length} flows, ${orphans.length} orphans, total ${Date.now() - t0}ms`);
     return { flows, orphans };
 }
 function findEntryIds(nodeIds, edges) {
@@ -67,33 +120,19 @@ function findEntryIds(nodeIds, edges) {
     }
     return [...nodeIds].filter(id => !calledIds.has(id) && callerIds.has(id));
 }
-function bfs(startId, edges) {
-    const visited = new Set([startId]);
-    const queue = [startId];
-    while (queue.length) {
-        const current = queue.shift();
-        for (const edge of edges) {
-            if (edge.from === current && !visited.has(edge.to)) {
-                visited.add(edge.to);
-                queue.push(edge.to);
-            }
-        }
-    }
-    return visited;
-}
-function bfsBidirectional(startId, edges) {
+/** BFS using a pre-built adjacency list (forward or bidirectional). */
+function bfsAdj(startId, adjList) {
     const visited = new Set([startId]);
     const queue = [startId];
     while (queue.length) {
         const current = queue.shift();
-        for (const edge of edges) {
-            if (edge.from === current && !visited.has(edge.to)) {
-                visited.add(edge.to);
-                queue.push(edge.to);
-            }
-            if (edge.to === current && !visited.has(edge.from)) {
-                visited.add(edge.from);
-                queue.push(edge.from);
+        const neighbors = adjList.get(current);
+        if (neighbors) {
+            for (const neighbor of neighbors) {
+                if (!visited.has(neighbor)) {
+                    visited.add(neighbor);
+                    queue.push(neighbor);
+                }
             }
         }
     }

package/dist/types.d.ts

@@ -46,6 +46,8 @@ export interface RawCall {
     callType?: 'direct' | 'ref' | 'concurrent' | 'goroutine';
     isRef?: boolean;
 }
+/** Simple logger callback used by core graph functions to report progress. */
+export type Logger = (message: string) => void;
 export interface LanguageAnalyzer {
     functionQuery: string;
     callQuery: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codeflow-map/core",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Language-agnostic call-graph analysis engine powered by Tree-sitter. Parses TypeScript, JavaScript, TSX, JSX, Python, and Go source files into a structured call graph with flows.",
   "keywords": [
     "callsight",