gitnexus 1.6.10-rc.47 → 1.6.10-rc.49

package/README.md

@@ -471,6 +471,8 @@ Configure the behavior with these environment variables:
 | `GITNEXUS_FTS_CJK_SEGMENTATION`              | `none`, `bigram`               | `none`              | `bigram` inserts overlapping character-bigram boundaries into Chinese/Japanese Han-ideograph spans in `content`/`description` before FTS indexing, so LadybugDB's space-only tokenizer can see sub-phrase word boundaries. Scoped to CJK Unified Ideographs only — Japanese Hiragana/Katakana and Korean Hangul are not currently segmented. Unlike `GITNEXUS_FTS_STEMMER`, this rewrites stored text — enabling it on an already-indexed repo requires a full `gitnexus analyze --force`; neither `--repair-fts` nor a plain incremental `analyze` applies it to previously-indexed files. Set the same value wherever `analyze` and search-serving processes (CLI query, MCP server, web server) run. |
 | `GITNEXUS_COMMUNITY_ENGINE`                  | `graphology`, `icebug`, `auto` | `graphology`        | Community-detection engine used during analyze. `graphology` uses the bundled default path. `icebug` and `auto` currently behave identically: both try the experimental Icebug CSR path and fall back to Graphology if the optional native module is unavailable or incompatible.                                                                                                                                                                                                                                                                                                                                                                                                                       |
 | `GITNEXUS_WAL_CHECKPOINT_THRESHOLD`          | integer `>= -1`                | `67108864` (64 MiB) | LadybugDB WAL auto-checkpoint threshold during analyze (bytes). Auto-checkpoint remains enabled; `-1` keeps Ladybug's stock ~16 MiB. Larger thresholds reduce checkpoint frequency but increase the WAL size at rotation time — choose a smaller value on disk-constrained environments.                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `GITNEXUS_LBUG_BUFFER_POOL_SIZE`             | integer `>= 0` (bytes)         | min(2 GiB, 80% RAM) | LadybugDB buffer-pool ceiling for every GitNexus database (analyze, MCP server, serve, group bridges). Bounded so a long-lived `gitnexus mcp` process or a large incremental `analyze` cannot grow toward LadybugDB's native 80%-of-RAM default and OOM the host (#2557). `0` restores that native unbounded default; invalid values warn and fall back to the default.                                                                                                                                                                                                                                                                                                                                  |
+| `GITNEXUS_LBUG_MAX_DB_SIZE`                  | positive integer (bytes)       | `17179869184` (16 GiB) | Upper bound for a single LadybugDB database file. This is an mmap/disk-address-space ceiling, not a memory limit — it does not constrain the buffer pool (use `GITNEXUS_LBUG_BUFFER_POOL_SIZE` for that). Raise it when indexing genuinely huge monorepos; invalid values silently fall back to the default.                                                                                                                                                                                                                                                                                                                                                                                             |
 
 ```bash
 # Offline/airgapped: never reach the network for extensions

package/dist/core/ingestion/languages/dart/captures.js

@@ -36,6 +36,7 @@ import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { encodeMarker } from '../../utils/heritage-marker.js';
 import { DART_BUILT_INS } from './built-ins.js';
 import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+import { preprocessDartExtensionTypes } from './extension-type-preprocess.js';
 const FUNCTION_DECL_TAGS = [
     '@declaration.function',
     '@declaration.method',
@@ -70,14 +71,15 @@ function dartLexicalFunctionOwner(input) {
     return undefined;
 }
 export function emitDartScopeCaptures(sourceText, _filePath, cachedTree) {
+    const parseText = preprocessDartExtensionTypes(sourceText);
     let tree;
     if (cachedTree !== undefined && cachedTree !== null) {
         tree = cachedTree;
         recordCacheHit();
     }
     else {
-        tree = parseSourceSafe(getDartParser(), sourceText, undefined, {
-            bufferSize: getTreeSitterBufferSize(sourceText),
+        tree = parseSourceSafe(getDartParser(), parseText, undefined, {
+            bufferSize: getTreeSitterBufferSize(parseText),
         });
         recordCacheMiss();
     }
@@ -161,6 +163,10 @@ export function emitDartScopeCaptures(sourceText, _filePath, cachedTree) {
             emitHeritage(node, out);
             return;
         }
+        if (node.type === 'extension_declaration') {
+            emitExtensionImplementsHeritage(node, out);
+            return;
+        }
     });
     out.push(...synthesizeCallableFlowCaptures(root, DART_CALLABLE_CAPTURE_OPTIONS));
     return out;
@@ -475,6 +481,47 @@ function emitHeritage(classNode, out) {
         emitHeritageMarkers(interfaces, 'implements', className, out);
     }
 }
+function emitExtensionImplementsHeritage(extensionNode, out) {
+    const nameNode = extensionNode.childForFieldName('name');
+    if (nameNode === null)
+        return;
+    const bodyStart = extensionNode.text.indexOf('{');
+    const header = bodyStart === -1 ? extensionNode.text : extensionNode.text.slice(0, bodyStart);
+    const implementsIndex = header.indexOf('implements');
+    if (implementsIndex === -1)
+        return;
+    const className = nameNode.text;
+    const interfaces = header.slice(implementsIndex + 'implements'.length);
+    for (const rawInterface of splitTopLevelCommaList(interfaces)) {
+        const target = /^[ \t]*([A-Za-z_$][A-Za-z0-9_$]*)/.exec(rawInterface)?.[1];
+        if (target === undefined)
+            continue;
+        const payload = encodeMarker('heritage', ['implements', target, className]);
+        out.push({ '@import.heritage': syntheticCapture('@import.heritage', nameNode, payload) });
+    }
+}
+function splitTopLevelCommaList(text) {
+    const parts = [];
+    let start = 0;
+    let angleDepth = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '<') {
+            angleDepth++;
+            continue;
+        }
+        if (ch === '>' && angleDepth > 0) {
+            angleDepth--;
+            continue;
+        }
+        if (ch === ',' && angleDepth === 0) {
+            parts.push(text.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(text.slice(start));
+    return parts;
+}
 function emitHeritageMarkers(container, kind, className, out) {
     for (let i = 0; i < container.namedChildCount; i++) {
         const c = container.namedChild(i);

package/dist/core/ingestion/languages/dart/extension-type-preprocess.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Rewrites Dart 3.3 `extension type Name(Type value)` headers into ordinary
+ * extension headers before tree-sitter sees the source. The vendored grammar
+ * currently recovers these declarations through an ERROR subtree, while the
+ * existing Dart ingestion path already handles `extension Name on Type`.
+ */
+export declare function preprocessDartExtensionTypes(sourceText: string): string;

package/dist/core/ingestion/languages/dart/extension-type-preprocess.js

@@ -0,0 +1,30 @@
+const DART_EXTENSION_TYPE_HEADER = /\b(extension)([ \t]+type[ \t]+(?:const[ \t]+)?)([A-Za-z_$][A-Za-z0-9_$]*)([ \t]*<[^()\r\n]*>)?([ \t]*)\(([^()\r\n]*)\)/g;
+function representationType(representation) {
+    const trimmed = representation.trim();
+    const match = /^(.*\S)\s+[A-Za-z_$][A-Za-z0-9_$]*$/.exec(trimmed);
+    const typeName = match?.[1]?.trim();
+    return typeName && typeName.length > 0 ? typeName : null;
+}
+/**
+ * Rewrites Dart 3.3 `extension type Name(Type value)` headers into ordinary
+ * extension headers before tree-sitter sees the source. The vendored grammar
+ * currently recovers these declarations through an ERROR subtree, while the
+ * existing Dart ingestion path already handles `extension Name on Type`.
+ */
+export function preprocessDartExtensionTypes(sourceText) {
+    return sourceText.replace(DART_EXTENSION_TYPE_HEADER, (match, extensionKeyword, extensionTypeGap, name, typeParameters, beforeRepresentation, representation) => {
+        const typeName = representationType(representation);
+        if (typeName === null)
+            return match;
+        const representationSpanLength = beforeRepresentation.length + representation.length + 2;
+        const rewrittenRepresentation = ` on ${typeName}`;
+        if (rewrittenRepresentation.length > representationSpanLength)
+            return match;
+        return (extensionKeyword +
+            ' '.repeat(extensionTypeGap.length) +
+            name +
+            (typeParameters ?? '') +
+            rewrittenRepresentation +
+            ' '.repeat(representationSpanLength - rewrittenRepresentation.length));
+    });
+}

package/dist/core/ingestion/languages/dart.js

@@ -29,6 +29,7 @@ import { createCallExtractor } from '../call-extractors/generic.js';
 import { dartCallConfig } from '../call-extractors/configs/dart.js';
 import { emitDartScopeCaptures, interpretDartImport, interpretDartTypeBinding, dartBindingScopeFor, dartImportOwningScope, dartReceiverBinding, dartMergeBindings, dartArityCompatibility, } from './dart/index.js';
 import { DART_BUILT_INS } from './dart/built-ins.js';
+import { preprocessDartExtensionTypes } from './dart/extension-type-preprocess.js';
 /**
  * Resolve the enclosing function from a `function_body` node by looking at its
  * previous sibling.  In Dart's tree-sitter grammar, function_signature and
@@ -100,6 +101,7 @@ export const dartProvider = defineLanguage({
         },
     ],
     treeSitterQueries: DART_QUERIES,
+    preprocessSource: preprocessDartExtensionTypes,
     typeConfig: dartConfig,
     exportChecker: dartExportChecker,
     importResolver: createImportResolver(dartImportConfig),

package/dist/core/ingestion/utils/ast-helpers.js

@@ -209,7 +209,7 @@ export const CONTAINER_TYPE_TO_LABEL = {
     record_declaration: 'Record',
     protocol_declaration: 'Interface',
     mixin_declaration: 'Mixin',
-    extension_declaration: 'Extension',
+    extension_declaration: 'Class',
     class: 'Class',
     // Ruby `module` declarations map to `Trait` so they participate in the
     // class-like type registry used by `lookupClassByName` / inheritance

package/dist/core/lbug/lbug-config.d.ts

@@ -39,8 +39,15 @@ export declare function resolveNativeSafeStorageDir(storagePath: string, subdir:
  *    `true` (0.16.0). Existing call sites that relied on the positional
  *    default must now pass `false` explicitly to preserve behaviour.
  *
- * Putting both in one shared module guarantees every `new lbug.Database(...)`
- * call site agrees on the same ceiling and behaviour.
+ * 3. `bufferManagerSize` (not a 0.16.0 change, same pin-explicitly
+ *    principle): `0` means "native default", and the native default buffer
+ *    pool is 80% of physical RAM. A long-lived `gitnexus mcp` process or a
+ *    large incremental analyze can balloon to that ceiling and OOM-kill the
+ *    host session (#2557), so GitNexus pins an explicit bounded pool — see
+ *    `resolveBufferManagerSize`.
+ *
+ * Putting these in one shared module guarantees every `new lbug.Database(...)`
+ * call site agrees on the same ceilings and behaviour.
  */
 /**
  * Upper bound for any single GitNexus LadybugDB file (graph index, group

package/dist/core/lbug/lbug-config.js

@@ -227,8 +227,15 @@ export function resolveNativeSafeStorageDir(storagePath, subdir) {
  *    `true` (0.16.0). Existing call sites that relied on the positional
  *    default must now pass `false` explicitly to preserve behaviour.
  *
- * Putting both in one shared module guarantees every `new lbug.Database(...)`
- * call site agrees on the same ceiling and behaviour.
+ * 3. `bufferManagerSize` (not a 0.16.0 change, same pin-explicitly
+ *    principle): `0` means "native default", and the native default buffer
+ *    pool is 80% of physical RAM. A long-lived `gitnexus mcp` process or a
+ *    large incremental analyze can balloon to that ceiling and OOM-kill the
+ *    host session (#2557), so GitNexus pins an explicit bounded pool — see
+ *    `resolveBufferManagerSize`.
+ *
+ * Putting these in one shared module guarantees every `new lbug.Database(...)`
+ * call site agrees on the same ceilings and behaviour.
  */
 /**
  * Upper bound for any single GitNexus LadybugDB file (graph index, group
@@ -286,6 +293,53 @@ const resolveCheckpointThreshold = () => {
     }
     return DEFAULT_WAL_CHECKPOINT_THRESHOLD;
 };
+/**
+ * Default ceiling for the LadybugDB buffer pool in bytes (#2557).
+ *
+ * The pool is a page cache with eviction, so the ceiling trades throughput
+ * on very large working sets for a machine that stays alive: 2 GiB is
+ * ~40× the GitNexus self-index, while the native 80%-of-RAM default let a
+ * `detect_changes` call grow a 105 MiB on-disk index to 19.5 GiB RSS and
+ * OOM-kill the reporter's session. The `min` with 80% of `os.totalmem()`
+ * keeps sub-2.5-GiB machines at the native-equivalent bound (no regression
+ * there); the 64 MiB floor keeps tiny containers above any plausible
+ * native minimum pool size.
+ */
+const DEFAULT_BUFFER_POOL_CAP = 2 * 1024 * 1024 * 1024;
+const BUFFER_POOL_FLOOR = 64 * 1024 * 1024;
+const parseBufferPoolSize = (raw) => {
+    if (raw === undefined)
+        return undefined;
+    const normalized = raw.trim();
+    if (normalized.length === 0)
+        return undefined;
+    const parsed = Number(normalized);
+    if (!Number.isFinite(parsed) || parsed < 0)
+        return undefined;
+    return Math.floor(parsed);
+};
+const defaultBufferPoolSize = () => Math.min(DEFAULT_BUFFER_POOL_CAP, Math.max(BUFFER_POOL_FLOOR, Math.floor(os.totalmem() * 0.8)));
+/**
+ * Resolve the `bufferManagerSize` passed to every `new lbug.Database(...)`.
+ * `GITNEXUS_LBUG_BUFFER_POOL_SIZE` (bytes) overrides the default; `0` is a
+ * deliberate escape hatch that restores LadybugDB's native unbounded
+ * 80%-of-RAM default. Resolved at call time (not module load) so tests can
+ * stub the env var and `os.totalmem`.
+ */
+const resolveBufferManagerSize = () => {
+    const raw = process.env.GITNEXUS_LBUG_BUFFER_POOL_SIZE;
+    if (raw === undefined)
+        return defaultBufferPoolSize();
+    const parsed = parseBufferPoolSize(raw);
+    if (parsed !== undefined)
+        return parsed;
+    // Non-empty but unparseable input: warn the operator and fall back —
+    // mirrors the GITNEXUS_WAL_CHECKPOINT_THRESHOLD env path above.
+    if (raw.trim().length > 0) {
+        logger.warn({ rawValue: raw, fallback: defaultBufferPoolSize() }, `Ignoring invalid GITNEXUS_LBUG_BUFFER_POOL_SIZE=${raw}; expected integer >= 0 (bytes; 0 restores the native 80%-of-RAM default); falling back to min(2 GiB, 80% of RAM).`);
+    }
+    return defaultBufferPoolSize();
+};
 /** Matches WAL corruption errors from the LadybugDB engine. */
 const WAL_CORRUPTION_RE = /corrupt(ed)?\s+wal|invalid\s+wal\s+record|wal.*corrupt|checksum.*wal/i;
 export const WAL_RECOVERY_SUGGESTION = 'WAL corruption detected. Run `gitnexus analyze --force` to rebuild the index.';
@@ -496,7 +550,7 @@ export const classifyDeleteAllError = (err) => {
 };
 export function createLbugDatabase(lbugModule, databasePath, options = {}) {
     // .d.ts declares fewer args than the native constructor accepts.
-    return new lbugModule.Database(databasePath, 0, // bufferManagerSize
+    return new lbugModule.Database(databasePath, resolveBufferManagerSize(), // bufferManagerSize (#2557: default min(2 GiB, 80% RAM); GITNEXUS_LBUG_BUFFER_POOL_SIZE overrides; 0 restores the native 80%-of-RAM default)
     false, // enableCompression (pinned for v0.16.0)
     options.readOnly ?? false, LBUG_MAX_DB_SIZE, true, // autoCheckpoint (always on)
     resolveCheckpointThreshold(), // checkpointThreshold (default 64 MiB; override with GITNEXUS_WAL_CHECKPOINT_THRESHOLD; -1 keeps Ladybug stock ~16 MiB)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.10-rc.47",
+  "version": "1.6.10-rc.49",
   "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",