gitnexus 1.6.9 → 1.6.10-aptos.1

package/dist/core/ingestion/class-extractors/configs/jvm.js

@@ -1,5 +1,6 @@
 // gitnexus/src/core/ingestion/class-extractors/configs/jvm.ts
 import { SupportedLanguages } from '../../../../_shared/index.js';
+import { synthesizeJavaAnonymousClassName } from '../../utils/ast-helpers.js';
 // ---------------------------------------------------------------------------
 // Java
 // ---------------------------------------------------------------------------
@@ -10,6 +11,15 @@ export const javaClassConfig = {
         'interface_declaration',
         'enum_declaration',
         'record_declaration',
+        // Anonymous class bodies (`new Runnable() { ... }`) — the matching
+        // JAVA_QUERIES pattern only captures `object_creation_expression`
+        // WITH a `class_body`, and `extractName` below returns undefined for
+        // any other shape, so plain `new Foo()` constructor calls never
+        // produce a Class node (#2550).
+        'object_creation_expression',
+        // Enum constant bodies (`enum E { A { ... } }`) — javac's other
+        // anonymous shape, named E$N by the same authority (#2555).
+        'enum_constant',
     ],
     fileScopeNodeTypes: ['package_declaration'],
     ancestorScopeNodeTypes: [
@@ -18,6 +28,25 @@ export const javaClassConfig = {
         'enum_declaration',
         'record_declaration',
     ],
+    extractName(node) {
+        if (node.type === 'object_creation_expression' || node.type === 'enum_constant') {
+            return synthesizeJavaAnonymousClassName(node);
+        }
+        return undefined;
+    },
+    // An anonymous body whose name CANNOT be synthesized must not become a
+    // Class node at all. Without this skip, `extract()`'s
+    // `extractTypeNameFromNode` fallback fabricates a name — the CONSTRUCTED
+    // type for `new Runnable() { ... }` (phantom `Class:...:Runnable`,
+    // empirically caught in review) or the constant's own identifier for an
+    // `enum_constant` (`Class:...:A`).
+    shouldSkipClassCapture({ definitionNode }) {
+        return (definitionNode !== null &&
+            definitionNode !== undefined &&
+            (definitionNode.type === 'object_creation_expression' ||
+                definitionNode.type === 'enum_constant') &&
+            synthesizeJavaAnonymousClassName(definitionNode) === undefined);
+    },
 };
 // ---------------------------------------------------------------------------
 // Kotlin

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

@@ -363,7 +363,7 @@ function parseDataItemClauses(rest) {
         result.pic = picMatch[1];
     }
     // USAGE [IS] <usage-type> — including non-standard COMP-6, COMP-X etc.
-    const usageMatch = text.match(/\bUSAGE\s+(?:IS\s+)?(COMP(?:UTATIONAL)?(?:-[0-9X])?|BINARY|PACKED-DECIMAL|DISPLAY|INDEX|POINTER|NATIONAL)\b/i);
+    const usageMatch = text.match(/\bUSAGE\s+(?:IS\s+)?(PROCEDURE-POINTER|FUNCTION-POINTER|COMP(?:UTATIONAL)?(?:-[0-9X])?|BINARY|PACKED-DECIMAL|DISPLAY|INDEX|POINTER|NATIONAL)\b/i);
     if (usageMatch) {
         result.usage = usageMatch[1].toUpperCase();
     }

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

@@ -17,6 +17,7 @@
  */
 import { parseJcl } from './jcl-parser.js';
 import { generateId } from '../../../lib/utils.js';
+import { toZeroBasedLine } from '../utils/line-base.js';
 /**
  * Process JCL files and integrate into the knowledge graph.
  *
@@ -71,8 +72,8 @@ function integrateJclResults(graph, parsed, filePath, moduleNames) {
             properties: {
                 name: job.name,
                 filePath,
-                startLine: job.line,
-                endLine: job.line,
+                startLine: toZeroBasedLine(job.line),
+                endLine: toZeroBasedLine(job.line),
                 description: `jcl-job${classPart}${msgPart}`,
             },
         });
@@ -105,8 +106,8 @@ function integrateJclResults(graph, parsed, filePath, moduleNames) {
             properties: {
                 name: step.name,
                 filePath,
-                startLine: step.line,
-                endLine: step.line,
+                startLine: toZeroBasedLine(step.line),
+                endLine: toZeroBasedLine(step.line),
                 description: `jcl-step${pgmPart}${procPart}`,
             },
         });
@@ -170,8 +171,8 @@ function integrateJclResults(graph, parsed, filePath, moduleNames) {
                 properties: {
                     name: dd.dataset,
                     filePath,
-                    startLine: dd.line,
-                    endLine: dd.line,
+                    startLine: toZeroBasedLine(dd.line),
+                    endLine: toZeroBasedLine(dd.line),
                     description: `jcl-dataset${dispPart}`,
                 },
             });
@@ -202,8 +203,8 @@ function integrateJclResults(graph, parsed, filePath, moduleNames) {
             properties: {
                 name: proc.name,
                 filePath,
-                startLine: proc.line,
-                endLine: proc.line,
+                startLine: toZeroBasedLine(proc.line),
+                endLine: toZeroBasedLine(proc.line),
                 description: 'jcl-proc-instream',
             },
         });

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

@@ -14,6 +14,7 @@
  */
 import path from 'node:path';
 import { generateId } from '../../lib/utils.js';
+import { toZeroBasedLine } from './utils/line-base.js';
 import { SupportedLanguages } from '../../_shared/index.js';
 import { preprocessCobolSource, extractCobolSymbolsWithRegex, } from './cobol/cobol-preprocessor.js';
 import { expandCopies } from './cobol/cobol-copy-expander.js';
@@ -275,8 +276,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: extracted.programName,
                 filePath,
-                startLine: 1,
-                endLine: lines.length,
+                startLine: toZeroBasedLine(1),
+                endLine: toZeroBasedLine(lines.length),
                 language: SupportedLanguages.Cobol,
                 isExported: true,
                 description: metaDesc || undefined,
@@ -310,8 +311,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: prog.name,
                 filePath,
-                startLine: prog.startLine,
-                endLine: prog.endLine,
+                startLine: toZeroBasedLine(prog.startLine),
+                endLine: toZeroBasedLine(prog.endLine),
                 language: SupportedLanguages.Cobol,
                 isExported: true,
                 description: `nested-program${prog.isCommon ? ' common' : ''}`,
@@ -349,8 +350,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: sec.name,
                 filePath,
-                startLine: sec.line,
-                endLine: nextLine,
+                startLine: toZeroBasedLine(sec.line),
+                endLine: toZeroBasedLine(nextLine),
                 language: SupportedLanguages.Cobol,
                 isExported: true,
             },
@@ -379,8 +380,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: para.name,
                 filePath,
-                startLine: para.line,
-                endLine: nextLine,
+                startLine: toZeroBasedLine(para.line),
+                endLine: toZeroBasedLine(nextLine),
                 language: SupportedLanguages.Cobol,
                 isExported: true,
             },
@@ -412,8 +413,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: item.name,
                 filePath,
-                startLine: item.line,
-                endLine: item.line,
+                startLine: toZeroBasedLine(item.line),
+                endLine: toZeroBasedLine(item.line),
                 language: SupportedLanguages.Cobol,
                 description: `level:${item.level} section:${item.section}${item.pic ? ` pic:${item.pic}` : ''}`,
             },
@@ -506,8 +507,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
                 properties: {
                     name: `CALL ${call.target}`,
                     filePath,
-                    startLine: call.line,
-                    endLine: call.line,
+                    startLine: toZeroBasedLine(call.line),
+                    endLine: toZeroBasedLine(call.line),
                     language: SupportedLanguages.Cobol,
                     description: 'dynamic-call (target is a data item, not resolvable statically)',
                 },
@@ -619,8 +620,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: `EXEC SQL ${sql.operation}`,
                 filePath,
-                startLine: sql.line,
-                endLine: sql.line,
+                startLine: toZeroBasedLine(sql.line),
+                endLine: toZeroBasedLine(sql.line),
                 language: SupportedLanguages.Cobol,
                 description: `tables:[${sql.tables.join(',')}] cursors:[${sql.cursors.join(',')}]`,
             },
@@ -691,8 +692,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: `EXEC CICS ${cics.command}`,
                 filePath,
-                startLine: cics.line,
-                endLine: cics.line,
+                startLine: toZeroBasedLine(cics.line),
+                endLine: toZeroBasedLine(cics.line),
                 language: SupportedLanguages.Cobol,
                 description: [
                     cics.mapName && `map:${cics.mapName}`,
@@ -726,8 +727,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
                     properties: {
                         name: `CICS ${cics.command} ${cics.programName}`,
                         filePath,
-                        startLine: cics.line,
-                        endLine: cics.line,
+                        startLine: toZeroBasedLine(cics.line),
+                        endLine: toZeroBasedLine(cics.line),
                         language: SupportedLanguages.Cobol,
                         description: `cics-dynamic-program (target is data item ${cics.programName})`,
                     },
@@ -879,8 +880,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: entry.name,
                 filePath,
-                startLine: entry.line,
-                endLine: entry.line,
+                startLine: toZeroBasedLine(entry.line),
+                endLine: toZeroBasedLine(entry.line),
                 language: SupportedLanguages.Cobol,
                 isExported: true,
                 description: entry.parameters.length > 0 ? `using:${entry.parameters.join(',')}` : undefined,
@@ -1014,8 +1015,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: `EXEC DLI ${dli.verb}`,
                 filePath,
-                startLine: dli.line,
-                endLine: dli.line,
+                startLine: toZeroBasedLine(dli.line),
+                endLine: toZeroBasedLine(dli.line),
                 language: SupportedLanguages.Cobol,
                 description: [
                     dli.segmentName && `segment:${dli.segmentName}`,
@@ -1148,8 +1149,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: fd.selectName,
                 filePath,
-                startLine: fd.line,
-                endLine: fd.line,
+                startLine: toZeroBasedLine(fd.line),
+                endLine: toZeroBasedLine(fd.line),
                 language: SupportedLanguages.Cobol,
                 description: `assign:${fd.assignTo}${fd.isOptional ? ' optional' : ''}${fd.organization ? ` org:${fd.organization}` : ''}${fd.access ? ` access:${fd.access}` : ''}`,
             },
@@ -1231,8 +1232,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
                 properties: {
                     name: `CANCEL ${cancel.target}`,
                     filePath,
-                    startLine: cancel.line,
-                    endLine: cancel.line,
+                    startLine: toZeroBasedLine(cancel.line),
+                    endLine: toZeroBasedLine(cancel.line),
                     language: SupportedLanguages.Cobol,
                     description: 'dynamic-cancel (target is a data item, not resolvable statically)',
                 },

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

@@ -7,7 +7,45 @@
  * Communities represent groups of code that work together frequently,
  * helping agents navigate the codebase by functional area rather than file structure.
  */
+import type { AbstractGraph, Attributes } from 'graphology-types';
+import type { NodeLabel } from '../../_shared/index.js';
 import { KnowledgeGraph } from '../graph/types.js';
+/** Graphology Graph instance type (AbstractGraph from graphology-types avoids CJS/ESM interop namespace issue) */
+type GraphInstance = AbstractGraph<Attributes, Attributes, Attributes>;
+type CommunityEngine = 'graphology' | 'icebug';
+export type CommunityDetectionEngine = CommunityEngine | 'auto';
+export interface CommunityDetectionOptions {
+    /**
+     * Graphology remains the default. `icebug`/`auto` are guarded prototype
+     * paths for #2337 and fall back to Graphology if the optional native module
+     * is not available or does not expose the expected API.
+     */
+    engine?: CommunityDetectionEngine;
+    icebug?: {
+        threads?: number;
+        seed?: number;
+        iterations?: number;
+        gamma?: number;
+        randomize?: boolean;
+    };
+}
+export interface CommunityProjectionNode {
+    id: string;
+    name: unknown;
+    filePath: unknown;
+    type: NodeLabel;
+}
+export interface CommunityProjection {
+    nodes: CommunityProjectionNode[];
+    edges: Array<readonly [number, number]>;
+    symbolCount: number;
+    isLarge: boolean;
+}
+export interface CommunityCsr {
+    indptr: BigUint64Array;
+    indices: BigUint64Array;
+}
+export declare const resolveCommunityDetectionEngine: (raw?: string) => CommunityDetectionEngine;
 export interface CommunityNode {
     id: string;
     label: string;
@@ -26,6 +64,9 @@ export interface CommunityDetectionResult {
         totalCommunities: number;
         modularity: number;
         nodesProcessed: number;
+        engine?: CommunityEngine;
+        engineRequested?: CommunityDetectionEngine;
+        fallbackReason?: string;
     };
 }
 export declare const COMMUNITY_COLORS: string[];
@@ -36,4 +77,13 @@ export declare const getCommunityColor: (communityIndex: number) => string;
  * This runs AFTER all relationships (CALLS, IMPORTS, etc.) have been built.
  * It uses primarily CALLS edges to cluster code that works together.
  */
-export declare const processCommunities: (knowledgeGraph: KnowledgeGraph, onProgress?: (message: string, progress: number) => void) => Promise<CommunityDetectionResult>;
+export declare const processCommunities: (knowledgeGraph: KnowledgeGraph, onProgress?: (message: string, progress: number) => void, options?: CommunityDetectionOptions) => Promise<CommunityDetectionResult>;
+/**
+ * Build a community projection containing only symbol nodes and clustering edges.
+ * For large graphs (>10K symbols), filter out low-confidence fuzzy-global edges
+ * and degree-1 nodes that add noise and massively increase Leiden runtime.
+ */
+export declare const buildCommunityProjection: (knowledgeGraph: KnowledgeGraph) => CommunityProjection;
+export declare const buildCommunityCsr: (projection: CommunityProjection) => CommunityCsr;
+export declare const buildGraphologyGraph: (projection: CommunityProjection) => GraphInstance;
+export {};