gitnexus 1.6.13-rc.82 → 1.6.13-rc.83

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

@@ -12,6 +12,12 @@ 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>;
+/** Result returned by leiden.detailed() */
+interface LeidenDetailedResult {
+    communities: Record<string, number>;
+    count: number;
+    modularity: number;
+}
 type CommunityEngine = 'graphology' | 'icebug';
 export type CommunityDetectionEngine = CommunityEngine | 'auto';
 export interface CommunityDetectionOptions {
@@ -48,6 +54,11 @@ export interface CommunityCsr {
     indptr: BigUint64Array;
     indices: BigUint64Array;
 }
+interface CommunityEngineResult extends LeidenDetailedResult {
+    engine: CommunityEngine;
+    engineRequested: CommunityDetectionEngine;
+    fallbackReason?: string;
+}
 export declare const resolveCommunityDetectionEngine: (raw?: string) => CommunityDetectionEngine;
 export interface CommunityNode {
     id: string;
@@ -92,6 +103,7 @@ export declare const processCommunities: (knowledgeGraph: KnowledgeGraph, onProg
 export declare const buildCommunityProjection: (knowledgeGraph: KnowledgeGraph) => CommunityProjection;
 export declare const buildCommunityCsr: (projection: CommunityProjection) => CommunityCsr;
 export declare const buildGraphologyGraph: (projection: CommunityProjection) => GraphInstance;
+export declare const runGraphologyLeiden: (graph: GraphInstance, isLarge: boolean, engineRequested: CommunityDetectionEngine, timeoutMs?: number) => Promise<CommunityEngineResult>;
 /**
  * Runs Leiden in a worker so a native crash cannot take the analyze process
  * with it. Written against @ladybugmem/icebug's published surface (lib/index.js

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

@@ -21,7 +21,9 @@ const __dirname = dirname(__filename);
 // Navigate to package root (works from both src/ and dist/)
 const leidenPath = resolve(__dirname, '..', '..', '..', 'vendor', 'leiden', 'index.cjs');
 const _require = createRequire(import.meta.url);
-const leiden = _require(leidenPath);
+// The Leiden worker loads its own copy; this load keeps a missing vendor/ asset
+// failing at import time and keeps it visible to dockerfile-runtime-asset-parity.
+_require(leidenPath);
 /**
  * Deterministic PRNG (mulberry32) seed for the vendored Leiden algorithm.
  * Vendored Leiden defaults `rng: Math.random`, which makes community
@@ -30,15 +32,6 @@ const leiden = _require(leidenPath);
  * incremental-indexing equivalence test (incremental ≡ full rebuild).
  */
 const LEIDEN_SEED = 0xc0de;
-function createSeededRng(seed) {
-    let s = seed >>> 0;
-    return () => {
-        s = (s + 0x6d2b79f5) >>> 0;
-        let t = Math.imul(s ^ (s >>> 15), 1 | s);
-        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
-        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-    };
-}
 const COMMUNITY_ENGINE_ENV = 'GITNEXUS_COMMUNITY_ENGINE';
 /**
  * Not a declared dependency: the prebuilds need system Arrow 24, libomp and
@@ -289,19 +282,96 @@ const runCommunityEngine = async (graph, projection, engineRequested, options, o
         const fallbackReason = error instanceof Error ? error.message : String(error);
         onProgress?.(`Icebug community engine unavailable, falling back to Graphology: ${fallbackReason}`, 35);
         const fallback = await runGraphologyLeiden(graph, projection.isLarge, engineRequested);
-        return { ...fallback, fallbackReason };
+        return {
+            ...fallback,
+            fallbackReason: fallback.fallbackReason
+                ? `${fallbackReason}; ${fallback.fallbackReason}`
+                : fallbackReason,
+        };
     }
 };
-const runGraphologyLeiden = async (graph, isLarge, engineRequested) => {
+/**
+ * Runs the vendored Leiden in a worker so LEIDEN_TIMEOUT_MS can actually fire.
+ * leiden.detailed is synchronous and, on some graphs, never returns
+ * (graphology/graphology#557); a timer on the main thread cannot interrupt it.
+ * The worker is pure JS, so terminate() is safe (unlike the icebug N-API worker).
+ */
+const GRAPHOLOGY_WORKER_SOURCE = `
+const { parentPort, workerData } = require('node:worker_threads');
+try {
+  const Graph = require(workerData.graphologyPath);
+  const leiden = require(workerData.leidenPath);
+  const graph = Graph.from(workerData.graph);
+  const rng = (() => {
+    let s = workerData.seed >>> 0;
+    return () => {
+      s = (s + 0x6d2b79f5) >>> 0;
+      let t = Math.imul(s ^ (s >>> 15), 1 | s);
+      t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+      return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+  })();
+  const d = leiden.detailed(graph, {
+    resolution: workerData.resolution,
+    maxIterations: workerData.maxIterations,
+    rng,
+  });
+  parentPort.postMessage({
+    ok: true,
+    communities: d.communities,
+    count: d.count,
+    modularity: d.modularity,
+  });
+} catch (error) {
+  parentPort.postMessage({ ok: false, error: error instanceof Error ? error.message : String(error) });
+}
+`;
+export const runGraphologyLeiden = async (graph, isLarge, engineRequested, timeoutMs = LEIDEN_TIMEOUT_MS) => {
     try {
-        const details = await Promise.race([
-            Promise.resolve(leiden.detailed(graph, {
-                resolution: isLarge ? 2.0 : 1.0,
-                maxIterations: isLarge ? 3 : 0,
-                rng: createSeededRng(LEIDEN_SEED),
-            })),
-            new Promise((_, reject) => setTimeout(() => reject(new Error('Leiden timeout')), LEIDEN_TIMEOUT_MS)),
-        ]);
+        const details = await new Promise((resolve, reject) => {
+            const worker = new Worker(GRAPHOLOGY_WORKER_SOURCE, {
+                eval: true,
+                workerData: {
+                    graphologyPath: _require.resolve('graphology'),
+                    leidenPath,
+                    graph: graph.export(),
+                    seed: LEIDEN_SEED,
+                    resolution: isLarge ? 2.0 : 1.0,
+                    maxIterations: isLarge ? 3 : 0,
+                },
+            });
+            let settled = false;
+            const timeout = setTimeout(() => {
+                settled = true;
+                void worker.terminate();
+                reject(new Error('Leiden timeout'));
+            }, timeoutMs);
+            worker.once('message', (message) => {
+                settled = true;
+                clearTimeout(timeout);
+                if (message.ok === true) {
+                    resolve({
+                        communities: message.communities,
+                        count: message.count,
+                        modularity: message.modularity,
+                    });
+                }
+                else {
+                    reject(new Error(message.error));
+                }
+            });
+            worker.once('error', (error) => {
+                settled = true;
+                clearTimeout(timeout);
+                reject(error);
+            });
+            worker.once('exit', (code) => {
+                if (settled)
+                    return;
+                clearTimeout(timeout);
+                reject(new Error(`Graphology Leiden worker exited with code ${code}`));
+            });
+        });
         return { ...details, engine: 'graphology', engineRequested };
     }
     catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.13-rc.82",
+  "version": "1.6.13-rc.83",
   "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",

package/scripts/cross-platform-tests.ts

@@ -289,6 +289,7 @@ const SPAWN_CLI = [
 // Worker threads tests — exercise real worker_threads which have
 // platform-specific behavior (thread spawning, IPC, exit handling)
 const WORKER_THREADS = [
+  'test/unit/community-processor.test.ts',
   'test/integration/worker-pool.test.ts',
   'test/integration/parse-impl-quarantine-cache-skip.test.ts',
 ];