cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/pipeline-phases/parse.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Phase: parse
+ *
+ * Chunked parse + resolve loop: reads source in byte-budget chunks,
+ * parses via the worker pool (the sole parse path — no sequential fallback),
+ * resolves imports, heritage, and calls, synthesizes wildcard bindings.
+ *
+ * This phase encapsulates the entire `runChunkedParseAndResolve` function
+ * from the original pipeline. The chunk loop is a memory optimization
+ * internal to this phase, not a phase boundary.
+ *
+ * @deps    structure
+ * @reads   scannedFiles, allPaths, totalFiles (from structure)
+ * @writes  graph (Symbol nodes, IMPORTS/CALLS/EXTENDS/IMPLEMENTS/ACCESSES edges)
+ * @output  exportedTypeMap, allFetchCalls, allExtractedRoutes, allDecoratorRoutes,
+ *          allToolDefs, allORMQueries, bindingAccumulator
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePhase = void 0;
+const types_js_1 = require("./types.js");
+const parse_impl_js_1 = require("./parse-impl.js");
+exports.parsePhase = {
+    name: 'parse',
+    deps: ['structure'],
+    async execute(ctx, deps) {
+        // Begin streamed structural emit (#2680), if enabled. Deliberately here and
+        // not at graph construction: the pre-parse phases are not all write-only —
+        // `mapCobolToGraph` scans CALLS edges and removes the unresolved ones — and
+        // nothing before parse produces bulk edge volume anyway.
+        ctx.graphEmit?.beginStreaming();
+        const { scannedFiles, allPaths, allPathSet, totalFiles } = (0, types_js_1.getPhaseOutput)(deps, 'structure');
+        const result = await (0, parse_impl_js_1.runChunkedParseAndResolve)(ctx.graph, scannedFiles, allPaths, totalFiles, ctx.repoPath, ctx.pipelineStart, ctx.onProgress, ctx.options);
+        return {
+            ...result,
+            allPaths,
+            allPathSet,
+            totalFiles,
+        };
+    },
+};

package/dist/core/code/engine/core/ingestion/pipeline-phases/processes.js

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * Phase: processes
+ *
+ * Detects execution flows (processes) and creates Process nodes +
+ * STEP_IN_PROCESS edges. Also links Route/Tool nodes to processes.
+ *
+ * @deps    communities, routes, tools, pruneLocalSymbols
+ * @reads   graph (all nodes and relationships), communityResult, routeRegistry, toolDefs
+ * @writes  graph (Process nodes, STEP_IN_PROCESS edges, ENTRY_POINT_OF edges)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processesPhase = void 0;
+exports.computeDynamicMaxProcesses = computeDynamicMaxProcesses;
+const types_js_1 = require("./types.js");
+const process_processor_js_1 = require("../process-processor.js");
+const utils_js_1 = require("../../../lib/utils.js");
+const route_path_js_1 = require("../route-extractors/route-path.js");
+const env_js_1 = require("../utils/env.js");
+const logger_js_1 = require("../../logger.js");
+/**
+ * Compute the dynamic max-processes budget from the symbol count.
+ *
+ * Scales proportionally (symbolCount / 10) with a floor of 20.
+ * Prior to #2198 this was capped at 300 via `Math.min(300, …)`,
+ * silently truncating process detection on large repositories.
+ */
+function computeDynamicMaxProcesses(symbolCount) {
+    return Math.max(20, Math.round(symbolCount / 10));
+}
+exports.processesPhase = {
+    name: 'processes',
+    // `structure` supplies `totalFiles` (progress counter) without the spurious
+    // structural data dependency on `parse`. `pruneLocalSymbols` is declared
+    // explicitly so process extraction always reads the trimmed graph even if a
+    // future option drops the intervening `mro`/`communities` phases.
+    deps: ['communities', 'routes', 'tools', 'pruneLocalSymbols', 'structure'],
+    async execute(ctx, deps) {
+        const { totalFiles } = (0, types_js_1.getPhaseOutput)(deps, 'structure');
+        const { communityResult } = (0, types_js_1.getPhaseOutput)(deps, 'communities');
+        const { routeRegistry } = (0, types_js_1.getPhaseOutput)(deps, 'routes');
+        const { toolDefs } = (0, types_js_1.getPhaseOutput)(deps, 'tools');
+        ctx.onProgress({
+            phase: 'processes',
+            percent: 99,
+            message: 'Detecting execution flows...',
+            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: ctx.graph.nodeCount },
+        });
+        let symbolCount = 0;
+        ctx.graph.forEachNode((n) => {
+            if (n.label !== 'File')
+                symbolCount++;
+        });
+        const dynamicMaxProcesses = computeDynamicMaxProcesses(symbolCount);
+        const processResult = await (0, process_processor_js_1.processProcesses)(ctx.graph, communityResult.memberships, (message, progress) => {
+            const processProgress = 99 + progress * 0.01;
+            ctx.onProgress({
+                phase: 'processes',
+                percent: Math.round(processProgress),
+                message,
+                stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: ctx.graph.nodeCount },
+            });
+        }, { maxProcesses: dynamicMaxProcesses, minSteps: 3 });
+        if (env_js_1.isDev) {
+            logger_js_1.logger.info(`🔄 Process detection: ${processResult.stats.totalProcesses} processes found (${processResult.stats.crossCommunityCount} cross-community)`);
+        }
+        processResult.processes.forEach((proc) => {
+            ctx.graph.addNode({
+                id: proc.id,
+                label: 'Process',
+                properties: {
+                    name: proc.label,
+                    filePath: '',
+                    heuristicLabel: proc.heuristicLabel,
+                    processType: proc.processType,
+                    stepCount: proc.stepCount,
+                    communities: proc.communities,
+                    entryPointId: proc.entryPointId,
+                    terminalId: proc.terminalId,
+                },
+            });
+        });
+        processResult.steps.forEach((step) => {
+            ctx.graph.addRelationship({
+                id: `${step.nodeId}_step_${step.step}_${step.processId}`,
+                type: 'STEP_IN_PROCESS',
+                sourceId: step.nodeId,
+                targetId: step.processId,
+                confidence: 1.0,
+                reason: 'trace-detection',
+                step: step.step,
+            });
+        });
+        // Link Route and Tool nodes to Processes
+        if (routeRegistry.size > 0 || toolDefs.length > 0) {
+            // Two-tier route lookup, mirroring the tool tables 10 lines below.
+            // Routes whose handler resolved key by `handlerSymbolId` (read from
+            // the Route node's graph properties — routes.ts stamps it there) and
+            // link ONLY to the process whose entryPoint matches; routes without a
+            // resolved handler fall back to a per-file bucket so we still attach
+            // the Route node to a same-file process (best-effort).
+            //
+            // Pre-#2289-review-P2 this was a single per-file bucket: every verb
+            // on a file's controller was linked to every process in that file,
+            // cross-wiring same-file `GET /items` and `POST /items` to each
+            // other's handler processes. The per-verb `handlerSymbolId` the
+            // routes phase stamps on the Route node was never consulted.
+            const routesByHandlerId = new Map();
+            const routesWithoutHandlerByFile = new Map();
+            for (const [, entry] of routeRegistry) {
+                // Push the Route node identity (`routeNodeKey`), not the bare URL, so the
+                // ENTRY_POINT_OF edge targets the same node id the routes phase created
+                // (#2289: a same-URL GET/POST pair is two distinct Route nodes).
+                const routeKey = (0, route_path_js_1.routeNodeKey)(entry.method, entry.url);
+                // Source of truth for handlerSymbolId is the Route node in the
+                // graph (routes.ts populates it from `routeHandlerSymbols`); the
+                // routes phase runs before processes (see `deps`), so the node is
+                // always present here.
+                const routeNode = ctx.graph.getNode((0, utils_js_1.generateId)('Route', routeKey));
+                const handlerSymbolId = routeNode?.properties.handlerSymbolId;
+                const targetMap = handlerSymbolId ? routesByHandlerId : routesWithoutHandlerByFile;
+                const bucketKey = handlerSymbolId ?? entry.filePath;
+                let list = targetMap.get(bucketKey);
+                if (!list) {
+                    list = [];
+                    targetMap.set(bucketKey, list);
+                }
+                list.push(routeKey);
+            }
+            const toolsByHandlerId = new Map();
+            const toolsWithoutHandlerByFile = new Map();
+            for (const td of toolDefs) {
+                const key = td.handlerNodeId ?? td.filePath;
+                const targetMap = td.handlerNodeId ? toolsByHandlerId : toolsWithoutHandlerByFile;
+                let list = targetMap.get(key);
+                if (!list) {
+                    list = [];
+                    targetMap.set(key, list);
+                }
+                list.push(td.name);
+            }
+            let linked = 0;
+            for (const proc of processResult.processes) {
+                if (!proc.entryPointId)
+                    continue;
+                const entryNode = ctx.graph.getNode(proc.entryPointId);
+                if (!entryNode)
+                    continue;
+                const entryFile = entryNode.properties.filePath;
+                if (!entryFile)
+                    continue;
+                const exactRouteKeys = routesByHandlerId.get(proc.entryPointId);
+                const fallbackRouteKeys = routesWithoutHandlerByFile.get(entryFile);
+                const routeKeys = exactRouteKeys ?? fallbackRouteKeys;
+                if (routeKeys) {
+                    for (const routeKey of routeKeys) {
+                        const routeNodeId = (0, utils_js_1.generateId)('Route', routeKey);
+                        ctx.graph.addRelationship({
+                            id: (0, utils_js_1.generateId)('ENTRY_POINT_OF', `${routeNodeId}->${proc.id}`),
+                            sourceId: routeNodeId,
+                            targetId: proc.id,
+                            type: 'ENTRY_POINT_OF',
+                            confidence: 0.85,
+                            reason: 'route-handler-entry-point',
+                        });
+                        linked++;
+                    }
+                }
+                const exactToolNames = toolsByHandlerId.get(proc.entryPointId);
+                const fallbackToolNames = toolsWithoutHandlerByFile.get(entryFile);
+                const toolNames = exactToolNames ?? fallbackToolNames;
+                if (toolNames) {
+                    for (const toolName of toolNames) {
+                        const toolNodeId = (0, utils_js_1.generateId)('Tool', toolName);
+                        ctx.graph.addRelationship({
+                            id: (0, utils_js_1.generateId)('ENTRY_POINT_OF', `${toolNodeId}->${proc.id}`),
+                            sourceId: toolNodeId,
+                            targetId: proc.id,
+                            type: 'ENTRY_POINT_OF',
+                            confidence: 0.85,
+                            reason: 'tool-handler-entry-point',
+                        });
+                        linked++;
+                    }
+                }
+            }
+            if (env_js_1.isDev && linked > 0) {
+                logger_js_1.logger.info(`🔗 Linked ${linked} Route/Tool nodes to execution flows`);
+            }
+        }
+        return { processResult };
+    },
+};

package/dist/core/code/engine/core/ingestion/pipeline-phases/prune-local-symbols.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Phase: pruneLocalSymbols
+ *
+ * Drops inert function/block-local value symbols after scope resolution has
+ * already used them for binding and call resolution.
+ *
+ * @deps    scopeResolution
+ * @reads   graph (nodes and relationships)
+ * @writes  graph (removes unreferenced local Const/Variable/Static nodes)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pruneLocalSymbolsPhase = void 0;
+const local_symbol_pruner_js_1 = require("../local-symbol-pruner.js");
+const env_js_1 = require("../utils/env.js");
+const logger_js_1 = require("../../logger.js");
+exports.pruneLocalSymbolsPhase = {
+    name: 'pruneLocalSymbols',
+    deps: ['scopeResolution'],
+    async execute(ctx) {
+        const stats = (0, local_symbol_pruner_js_1.pruneLocalValueSymbols)(ctx.graph, {
+            keepLocalValueSymbols: ctx.options?.keepLocalValueSymbols,
+        });
+        if (env_js_1.isDev && !stats.skippedByEnv && stats.prunedNodes > 0) {
+            logger_js_1.logger.info(`Pruned ${stats.prunedNodes}/${stats.candidateNodes} inert local value symbols`);
+        }
+        return stats;
+    },
+};

package/dist/core/code/engine/core/ingestion/pipeline-phases/registry.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Phase registry seam (issue #2080, taint/PDG substrate M0).
+ *
+ * A small, behaviour-preserving abstraction over phase-list *assembly*. Today
+ * `buildPhaseList` is a hand-maintained array with a single ad-hoc
+ * `if (!skipGraphPhases)` guard; this registry generalises that guard into a
+ * per-phase `enabledWhen` predicate so later milestones can register opt-in
+ * phases (e.g. CFG → M1 #2081) without editing the array each time.
+ *
+ * M0 wires the seam with **no behaviour change**: `build(options)` must return
+ * a phase list identical in membership and order to the legacy array for every
+ * options combination. The registry covers only list assembly — the runner,
+ * topological sort, `PipelinePhase.execute`, and any result-extraction guards
+ * (e.g. the `skipGraphPhases` check in `runPipelineFromRepo`) are untouched.
+ *
+ * Generic over the options type so this module depends only on `PipelinePhase`
+ * (no import of `PipelineOptions`, which lives in `pipeline.ts` and would
+ * otherwise create an import cycle).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhaseRegistry = void 0;
+/**
+ * Ordered registry of pipeline phases. Not a global singleton — callers
+ * construct a fresh registry (so registration order is deterministic and there
+ * is no import-order or test-isolation hazard) and `build()` it per run.
+ */
+class PhaseRegistry {
+    registrations = [];
+    /**
+     * Register a phase. This is the `registerPhase(phase, { enabledWhen })` seam
+     * named in issue #2080. Returns `this` for fluent chaining. Registration
+     * order is preserved by `build()`.
+     */
+    register(phase, options) {
+        this.registrations.push({ phase, enabledWhen: options?.enabledWhen });
+        return this;
+    }
+    /**
+     * Build the ordered phase list for the given options. A phase is included
+     * iff it has no `enabledWhen` predicate or its predicate returns `true`.
+     * Order matches registration order. `options` is required — callers that may
+     * have no options normalize once at the call site (`options ?? {}`) so the
+     * predicates never see `undefined`.
+     */
+    build(options) {
+        return this.registrations
+            .filter((r) => r.enabledWhen === undefined || r.enabledWhen(options))
+            .map((r) => r.phase);
+    }
+}
+exports.PhaseRegistry = PhaseRegistry;