gitnexus 1.6.12-rc.24 → 1.6.12-rc.26

package/dist/core/ingestion/cobol-processor.d.ts

@@ -6,8 +6,8 @@
  * does its own extraction, and writes directly to the graph.
  *
  * Pipeline:
- *   1. Separate programs from copybooks
- *   2. Build copybook map (name -> content)
+ *   1. Separate programs from copybooks and JCL
+ *   2. Index file content by path for COPY expansion
  *   3. For each program: expand COPY statements, then run regex extraction
  *   4. Map CobolRegexResults to graph nodes and relationships
  *   5. Optionally process JCL files for job-step cross-references

package/dist/core/ingestion/cobol-processor.js

@@ -6,8 +6,8 @@
  * does its own extraction, and writes directly to the graph.
  *
  * Pipeline:
- *   1. Separate programs from copybooks
- *   2. Build copybook map (name -> content)
+ *   1. Separate programs from copybooks and JCL
+ *   2. Index file content by path for COPY expansion
  *   3. For each program: expand COPY statements, then run regex extraction
  *   4. Map CobolRegexResults to graph nodes and relationships
  *   5. Optionally process JCL files for job-step cross-references
@@ -19,6 +19,7 @@ import { SupportedLanguages } from '../../_shared/index.js';
 import { preprocessCobolSource, extractCobolSymbolsWithRegex, } from './cobol/cobol-preprocessor.js';
 import { expandCopies } from './cobol/cobol-copy-expander.js';
 import { processJclFiles } from './cobol/jcl-processor.js';
+import { resolveCobolCopyTarget } from './languages/cobol/copy-target.js';
 import { logger } from '../logger.js';
 // ---------------------------------------------------------------------------
 // File detection
@@ -74,36 +75,22 @@ export const processCobol = (graph, files, allPathSet) => {
     };
     // ── 1. Separate programs, copybooks, and JCL ───────────────────────
     const programs = [];
-    const copybooks = [];
     const jclFiles = [];
     for (const file of files) {
         const ext = path.extname(file.path).toLowerCase();
         if (JCL_EXTENSIONS.has(ext)) {
             jclFiles.push(file);
         }
-        else if (isCopybook(file.path)) {
-            copybooks.push(file);
-        }
-        else if (COBOL_EXTENSIONS.has(ext)) {
+        else if (COBOL_EXTENSIONS.has(ext) && !isCopybook(file.path)) {
             programs.push(file);
         }
     }
-    // ── 2. Build copybook map (uppercase name -> content) ──────────────
-    const copybookMap = new Map();
-    for (const cb of copybooks) {
-        const name = path.basename(cb.path, path.extname(cb.path)).toUpperCase();
-        copybookMap.set(name, { content: cb.content, path: cb.path });
-    }
-    // Build reverse lookup: path -> content for O(1) readCopy
+    // Path → content for every COBOL/JCL file we ingested. Resolution picks
+    // the path (#2967 / census lockstep); this map only supplies the body.
     const copybookByPath = new Map();
-    for (const [, entry] of copybookMap) {
-        copybookByPath.set(entry.path, entry.content);
+    for (const f of files) {
+        copybookByPath.set(f.path, f.content);
     }
-    // Resolve and read callbacks for expandCopies
-    const resolveCopy = (name) => {
-        const entry = copybookMap.get(name.toUpperCase());
-        return entry ? entry.path : null;
-    };
     // Memoize preprocessed copybook content for the duration of this
     // processCobol call. A single copybook is COPYed by many programs (and at
     // many COPY sites within a program); without this cache
@@ -142,6 +129,9 @@ export const processCobol = (graph, files, allPathSet) => {
             continue;
         // Preprocess: clean patch markers
         const cleaned = preprocessCobolSource(file.content);
+        // Per-program so COPY EXTERNAL in src/PROG.cbl cannot land on
+        // vendor/EXTERNAL.cpy when a copybooks/ dir is present (#2967).
+        const resolveCopy = (name) => resolveCobolCopyTarget(name, file.path, allPathSet);
         // Expand COPY statements
         const { expandedContent, copyResolutions } = expandCopies(cleaned, file.path, resolveCopy, readCopy);
         // Extract symbols from expanded source

package/dist/core/ingestion/community-processor.js

@@ -15,6 +15,7 @@ import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
 import { dirname, resolve } from 'node:path';
 import { Worker } from 'node:worker_threads';
+import { isHeuristicEdgeReason } from '../graph/edge-reasons.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Navigate to package root (works from both src/ and dist/)
@@ -49,6 +50,16 @@ const DEFAULT_COMMUNITY_ENGINE = 'graphology';
 const LEIDEN_TIMEOUT_MS = 60_000;
 const ICEBUG_TIMEOUT_MS = 60_000;
 const MIN_CONFIDENCE_LARGE = 0.5;
+/**
+ * Whether a large graph's projection may include this edge.
+ *
+ * The confidence floor alone lets every global-name-fallback edge through — it
+ * is emitted at exactly `MIN_CONFIDENCE_LARGE`, so `confidence <` never
+ * excludes it. Clustering on unique-name guesses fuses unrelated areas into one
+ * community, which is precisely the noise the large-graph floor exists to
+ * remove, so the reason is checked too — see `graph/edge-reasons.ts`.
+ */
+const isLargeGraphEligible = (confidence, reason) => confidence >= MIN_CONFIDENCE_LARGE && !isHeuristicEdgeReason(reason);
 export const resolveCommunityDetectionEngine = (raw = process.env[COMMUNITY_ENGINE_ENV]) => {
     if (raw === undefined || raw.trim() === '')
         return DEFAULT_COMMUNITY_ENGINE;
@@ -153,12 +164,18 @@ export const buildCommunityProjection = (knowledgeGraph) => {
     const isLarge = symbolCount > 10_000;
     const connectedNodes = new Set();
     const nodeDegree = new Map();
-    // Field-wise scan (#2680): this walks every edge and reads only these four,
+    // Field-wise scan (#2680): this walks every edge and reads only these five,
     // so taking objects would allocate one per edge for nothing.
-    knowledgeGraph.forEachRelationshipFields((sourceId, targetId, type, confidence) => {
+    knowledgeGraph.forEachRelationshipFields((sourceId, targetId, type, confidence, reason) => {
         if (!isClusteringRelationship(type) || sourceId === targetId)
             return;
-        if (isLarge && confidence < MIN_CONFIDENCE_LARGE)
+        // A name-guessed edge must not join two nodes into a community at ANY graph
+        // size — the rationale in `graph/edge-reasons.ts` is about what the edge
+        // claims, not about how many symbols surround it. Process tracing applies
+        // the same reason gate unconditionally (`process-processor.ts`).
+        if (isHeuristicEdgeReason(reason))
+            return;
+        if (isLarge && !isLargeGraphEligible(confidence, reason))
             return;
         connectedNodes.add(sourceId);
         connectedNodes.add(targetId);
@@ -189,10 +206,12 @@ export const buildCommunityProjection = (knowledgeGraph) => {
     }
     const seenEdges = new Set();
     const edges = [];
-    knowledgeGraph.forEachRelationshipFields((sourceId, targetId, type, confidence) => {
+    knowledgeGraph.forEachRelationshipFields((sourceId, targetId, type, confidence, reason) => {
         if (!isClusteringRelationship(type) || sourceId === targetId)
             return;
-        if (isLarge && confidence < MIN_CONFIDENCE_LARGE)
+        if (isHeuristicEdgeReason(reason))
+            return;
+        if (isLarge && !isLargeGraphEligible(confidence, reason))
             return;
         const sourceIndex = nodeIndexById.get(sourceId);
         const targetIndex = nodeIndexById.get(targetId);

package/dist/core/ingestion/languages/cobol/copy-target.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Resolve a COBOL `COPY` member name against the workspace file set.
+ *
+ * `fromFile` is the importing program (census) or the program currently
+ * being expanded (processor). It is used only to include the importer's
+ * directory in the preferred class when a well-known copybook dir exists.
+ */
+export declare function resolveCobolCopyTarget(targetRaw: string, fromFile: string, allFilePaths: ReadonlySet<string>): string | null;

package/dist/core/ingestion/languages/cobol/copy-target.js

@@ -0,0 +1,94 @@
+/**
+ * Shared COBOL `COPY` target resolution (#2967 / #2908).
+ *
+ * Both the census (`cobolScopeResolver.resolveImportTarget`) and the live
+ * regex processor (`resolveCopy` → `cobol-copy` IMPORTS) must answer the
+ * same path for the same `(name, fromFile, allFilePaths)`. Greening only
+ * the census would leave analyze fabricating an IMPORTS edge onto a vendor
+ * decoy the compiler would never have searched.
+ *
+ * Well-known copybook directory segments (`copybooks`, `COPYBOOKS`, `cpy`,
+ * `copy`) plus the importer's own directory are the preferred class. When
+ * the file set contains at least one of those well-known segments, a `COPY`
+ * name resolves only inside that class (first in Set-iteration order).
+ * `vendor/EXTERNAL.cpy` therefore misses while `copybooks/CUSTREC.cpy` hits.
+ *
+ * When the file set has no such directory, fail-open to today's two-tier
+ * first-wins basename index — shops whose copybooks *are* the tree have
+ * nothing to prefer. The importer directory is *not* enough on its own to
+ * leave fail-open (`{vendor/EXTERNAL.cpy, src/PROG.cbl}` must still answer
+ * `vendor/EXTERNAL.cpy`).
+ *
+ * The two-tier index is still memoized on the `allFilePaths` Set identity
+ * (#2908). Preferred-class filtering happens at pick time from the stored
+ * per-name arrays, so a pass still scans the set once.
+ */
+import path from 'node:path';
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
+const COPYBOOK_EXTENSIONS = new Set(['.cpy', '.copybook']);
+const COBOL_SOURCE_EXTENSIONS = new Set(['.cbl', '.cob', '.cobol']);
+/** Path-component names that mark a conventional copybook directory. */
+const PREFERRED_DIR_NAMES = new Set(['copybooks', 'COPYBOOKS', 'cpy', 'copy']);
+function pathHasPreferredDir(fp) {
+    const parts = fp.split('/');
+    for (let i = 0; i < parts.length - 1; i++) {
+        if (PREFERRED_DIR_NAMES.has(parts[i]))
+            return true;
+    }
+    return false;
+}
+function pushUnique(map, key, fp) {
+    const list = map.get(key);
+    if (list === undefined) {
+        map.set(key, [fp]);
+        return;
+    }
+    list.push(fp);
+}
+const getCobolCopyIndex = perFileSet((allFilePaths) => {
+    const copybooks = new Map();
+    const sources = new Map();
+    let hasPreferredDir = false;
+    for (const fp of allFilePaths) {
+        const extRaw = path.extname(fp);
+        const extLower = extRaw.toLowerCase();
+        const tier = COPYBOOK_EXTENSIONS.has(extLower)
+            ? copybooks
+            : COBOL_SOURCE_EXTENSIONS.has(extLower)
+                ? sources
+                : undefined;
+        if (tier === undefined)
+            continue;
+        if (!hasPreferredDir && pathHasPreferredDir(fp))
+            hasPreferredDir = true;
+        const basename = path.basename(fp, extRaw).toUpperCase();
+        pushUnique(tier, basename, fp);
+    }
+    return { copybooks, sources, hasPreferredDir };
+});
+function pickCopyPath(paths, fromFile, hasPreferredDir) {
+    if (paths === undefined || paths.length === 0)
+        return null;
+    if (!hasPreferredDir)
+        return paths[0] ?? null;
+    const fromDir = path.dirname(fromFile);
+    for (const fp of paths) {
+        if (pathHasPreferredDir(fp) || path.dirname(fp) === fromDir)
+            return fp;
+    }
+    return null;
+}
+/**
+ * Resolve a COBOL `COPY` member name against the workspace file set.
+ *
+ * `fromFile` is the importing program (census) or the program currently
+ * being expanded (processor). It is used only to include the importer's
+ * directory in the preferred class when a well-known copybook dir exists.
+ */
+export function resolveCobolCopyTarget(targetRaw, fromFile, allFilePaths) {
+    const upper = targetRaw.toUpperCase();
+    const index = getCobolCopyIndex(allFilePaths);
+    return (pickCopyPath(index.copybooks.get(upper), fromFile, index.hasPreferredDir) ??
+        pickCopyPath(index.sources.get(upper), fromFile, index.hasPreferredDir) ??
+        null);
+}

package/dist/core/ingestion/languages/cobol/scope-resolver.js

@@ -8,46 +8,18 @@
  *
  * Reference: `languages/python/scope-resolver.ts`.
  */
-import path from 'node:path';
 import { SupportedLanguages } from '../../../../_shared/index.js';
-import { perFileSet } from '../../import-resolvers/per-file-set.js';
 import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
 import { cobolProvider } from '../cobol.js';
-// Copybook file extensions for COPY name resolution
-const COPYBOOK_EXTENSIONS = new Set(['.cpy', '.copybook']);
-// COBOL source files, searched only after every copybook has missed.
-const COBOL_SOURCE_EXTENSIONS = new Set(['.cbl', '.cob', '.cobol']);
-const getCobolCopyIndex = perFileSet((allFilePaths) => {
-    const copybooks = new Map();
-    const sources = new Map();
-    // One pass builds both tiers: the two scans walked the same files and
-    // classified each by the same extension test.
-    for (const fp of allFilePaths) {
-        const ext = path.extname(fp).toLowerCase();
-        const tier = COPYBOOK_EXTENSIONS.has(ext)
-            ? copybooks
-            : COBOL_SOURCE_EXTENSIONS.has(ext)
-                ? sources
-                : undefined;
-        if (tier === undefined)
-            continue;
-        const basename = path.basename(fp, ext).toUpperCase();
-        // First in Set-iteration order wins, as the scans' first-match `return` did.
-        if (!tier.has(basename))
-            tier.set(basename, fp);
-    }
-    return { copybooks, sources };
-});
+import { resolveCobolCopyTarget } from './copy-target.js';
 const cobolScopeResolver = {
     language: SupportedLanguages.Cobol,
     languageProvider: cobolProvider,
     importEdgeReason: 'cobol-scope: copy',
     // ── Resolve COPY bookname to file path ─────────────────────────────
-    resolveImportTarget: (targetRaw, _fromFile, allFilePaths) => {
-        const upper = targetRaw.toUpperCase();
-        const index = getCobolCopyIndex(allFilePaths);
-        // Copybooks first, then COBOL sources — the tier order IS the tie-break.
-        return index.copybooks.get(upper) ?? index.sources.get(upper) ?? null;
+    // Shared with the regex processor's resolveCopy (#2967 lockstep).
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
+        return resolveCobolCopyTarget(targetRaw, fromFile, allFilePaths);
     },
     // COBOL has no binding-merge rules beyond the default (local-first-then-imports).
     mergeBindings: (existing) => [...existing],

package/dist/core/ingestion/process-processor.js

@@ -9,6 +9,7 @@
  *
  * Processes help agents understand how features work through the codebase.
  */
+import { isHeuristicEdgeReason } from '../graph/edge-reasons.js';
 import { calculateEntryPointScore, isTestFile } from './entry-point-scoring.js';
 import { SupportedLanguages } from '../../_shared/index.js';
 import { isDev } from './utils/env.js';
@@ -289,11 +290,21 @@ outwardActionSites = []) => {
  * traces to jump across unrelated code areas.
  */
 const MIN_TRACE_CONFIDENCE = 0.5;
+/**
+ * True when an edge may seed or extend a traced flow.
+ *
+ * The confidence floor alone is not sufficient: the global-name fallback emits
+ * at exactly `MIN_TRACE_CONFIDENCE`, so a `<` comparison admits every one of
+ * its guesses. A flow assembled from name guesses reads as a real execution
+ * path through code that may never call each other, so the reason is checked
+ * too — see `graph/edge-reasons.ts`.
+ */
+const isTraceableCallsEdge = (type, confidence, reason) => type === 'CALLS' && confidence >= MIN_TRACE_CONFIDENCE && !isHeuristicEdgeReason(reason);
 const buildCallsGraph = (graph) => {
     const adj = new Map();
-    // Field-wise scan (#2680) — whole-graph walk, four fields, no object needed.
-    graph.forEachRelationshipFields((sourceId, targetId, type, confidence) => {
-        if (type !== 'CALLS' || confidence < MIN_TRACE_CONFIDENCE)
+    // Field-wise scan (#2680) — whole-graph walk, five fields, no object needed.
+    graph.forEachRelationshipFields((sourceId, targetId, type, confidence, reason) => {
+        if (!isTraceableCallsEdge(type, confidence, reason))
             return;
         const existing = adj.get(sourceId);
         if (existing === undefined)
@@ -305,8 +316,8 @@ const buildCallsGraph = (graph) => {
 };
 const buildReverseCallsGraph = (graph) => {
     const adj = new Map();
-    graph.forEachRelationshipFields((sourceId, targetId, type, confidence) => {
-        if (type !== 'CALLS' || confidence < MIN_TRACE_CONFIDENCE)
+    graph.forEachRelationshipFields((sourceId, targetId, type, confidence, reason) => {
+        if (!isTraceableCallsEdge(type, confidence, reason))
             return;
         const existing = adj.get(targetId);
         if (existing === undefined)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.12-rc.24",
+  "version": "1.6.12-rc.26",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",