gitnexus 1.6.6-rc.30 → 1.6.6-rc.32

package/dist/cli/analyze.js

@@ -8,7 +8,7 @@
  * skill generation (--skills), summary output, and process.exit().
  */
 import path from 'path';
-import { execFileSync } from 'child_process';
+import { spawn } from 'child_process';
 import v8 from 'v8';
 import cliProgress from 'cli-progress';
 import { closeLbug } from '../core/lbug/lbug-adapter.js';
@@ -29,6 +29,7 @@ import { isHfDownloadFailure } from '../core/embeddings/hf-env.js';
 // previous behaviour silently swallowed stack traces and made #1169
 // indistinguishable from a no-op success on Windows.
 const realStderrWrite = process.stderr.write.bind(process.stderr);
+const realStdoutWrite = process.stdout.write.bind(process.stdout);
 const writeFatalToStderr = (label, err) => {
     const isErr = err instanceof Error;
     const message = isErr ? err.message : String(err);
@@ -67,14 +68,212 @@ const HEAP_FLAG = `--max-old-space-size=${RESPAWN_HEAP_MB}`;
 /** Increase default stack size (KB) to prevent stack overflow on deep class hierarchies. */
 const STACK_KB = 4096;
 const STACK_FLAG = `--stack-size=${STACK_KB}`;
+const RESPAWN_OUTPUT_TAIL_CHARS = 1024 * 1024;
+const RESPAWN_PROGRESS_ENV = 'GITNEXUS_RESPAWN_PROGRESS_TTY';
+const terminalColumns = () => {
+    const parsed = Number(process.env.COLUMNS);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : 80;
+};
+const ANSI_ESCAPE_PATTERN = /\x1B(?:\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\)|[PX^_][\s\S]*?\x1B\\|[78]|[@-Z\\-_])/y;
+const splitGraphemes = (text) => {
+    const Segmenter = Intl.Segmenter;
+    if (Segmenter) {
+        return Array.from(new Segmenter(undefined, { granularity: 'grapheme' }).segment(text), (s) => s.segment);
+    }
+    return Array.from(text);
+};
+const isZeroWidthCodePoint = (codePoint) => codePoint === 0x200d ||
+    (codePoint >= 0x0300 && codePoint <= 0x036f) ||
+    (codePoint >= 0x1ab0 && codePoint <= 0x1aff) ||
+    (codePoint >= 0x1dc0 && codePoint <= 0x1dff) ||
+    (codePoint >= 0x20d0 && codePoint <= 0x20ff) ||
+    (codePoint >= 0xfe00 && codePoint <= 0xfe0f) ||
+    (codePoint >= 0xfe20 && codePoint <= 0xfe2f);
+const isWideCodePoint = (codePoint) => codePoint >= 0x1100 &&
+    (codePoint <= 0x115f ||
+        codePoint === 0x2329 ||
+        codePoint === 0x232a ||
+        (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+        (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+        (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+        (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+        (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+        (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+        (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+        (codePoint >= 0x1f300 && codePoint <= 0x1faff) ||
+        (codePoint >= 0x20000 && codePoint <= 0x3fffd));
+const visibleColumns = (text) => {
+    let columns = 0;
+    for (const char of Array.from(text)) {
+        const codePoint = char.codePointAt(0);
+        if (codePoint === undefined || isZeroWidthCodePoint(codePoint))
+            continue;
+        columns += isWideCodePoint(codePoint) ? 2 : 1;
+    }
+    return columns;
+};
+const readAnsiEscapeAt = (text, index) => {
+    ANSI_ESCAPE_PATTERN.lastIndex = index;
+    return ANSI_ESCAPE_PATTERN.exec(text)?.[0];
+};
+const truncateAnsiToColumns = (text, maxColumns) => {
+    if (!Number.isFinite(maxColumns) || maxColumns <= 0)
+        return '';
+    let output = '';
+    let columns = 0;
+    let index = 0;
+    while (index < text.length) {
+        const escape = readAnsiEscapeAt(text, index);
+        if (escape) {
+            output += escape;
+            index += escape.length;
+            continue;
+        }
+        const nextEscapeIndex = text.indexOf('\x1B', index);
+        const plainEnd = nextEscapeIndex === -1 ? text.length : nextEscapeIndex;
+        const plainText = text.slice(index, plainEnd);
+        for (const segment of splitGraphemes(plainText)) {
+            const width = visibleColumns(segment);
+            if (width > 0 && columns + width > maxColumns)
+                return output;
+            output += segment;
+            columns += width;
+        }
+        index = plainEnd;
+    }
+    return output;
+};
+const createAnsiPipeTerminal = (stream) => {
+    let linewrap = true;
+    let dy = 0;
+    const write = (s) => {
+        stream.write(s);
+    };
+    const moveVertical = (delta) => {
+        if (delta > 0)
+            write(`\x1B[${delta}B`);
+        else if (delta < 0)
+            write(`\x1B[${Math.abs(delta)}A`);
+    };
+    return {
+        cursorSave: () => write('\x1B7'),
+        cursorRestore: () => write('\x1B8'),
+        cursor: (enabled) => write(enabled ? '\x1B[?25h' : '\x1B[?25l'),
+        lineWrapping: (enabled) => {
+            linewrap = enabled;
+            write(enabled ? '\x1B[?7h' : '\x1B[?7l');
+        },
+        cursorTo: (x = null, y = null) => {
+            if (typeof y === 'number' && typeof x === 'number') {
+                write(`\x1B[${y + 1};${x + 1}H`);
+                return;
+            }
+            if (typeof x === 'number') {
+                write(x === 0 ? '\r' : `\x1B[${x + 1}G`);
+            }
+        },
+        cursorRelative: (dx = null, nextDy = null) => {
+            if (typeof dx === 'number' && dx !== 0) {
+                write(dx > 0 ? `\x1B[${dx}C` : `\x1B[${Math.abs(dx)}D`);
+            }
+            if (typeof nextDy === 'number' && nextDy !== 0) {
+                dy += nextDy;
+                moveVertical(nextDy);
+            }
+        },
+        cursorRelativeReset: () => {
+            moveVertical(-dy);
+            write('\r');
+            dy = 0;
+        },
+        clearRight: () => write('\x1B[0K'),
+        clearLine: () => write('\x1B[2K'),
+        clearBottom: () => write('\x1B[0J'),
+        newline: () => {
+            write('\n');
+            dy++;
+        },
+        write: (s, rawWrite = false) => {
+            const width = terminalColumns();
+            write(linewrap && rawWrite === false ? truncateAnsiToColumns(s, width) : s);
+        },
+        isTTY: () => true,
+        getWidth: terminalColumns,
+    };
+};
+const shouldBridgeRespawnProgressTty = () => process.stderr.isTTY === true || process.stdout.isTTY === true;
+const appendOutputTail = (tail, chunk) => {
+    const text = Buffer.isBuffer(chunk)
+        ? chunk.toString('utf8')
+        : typeof chunk === 'string'
+            ? chunk
+            : String(chunk ?? '');
+    if (!text)
+        return tail;
+    const next = tail + text;
+    return next.length > RESPAWN_OUTPUT_TAIL_CHARS ? next.slice(-RESPAWN_OUTPUT_TAIL_CHARS) : next;
+};
+/**
+ * Run the respawned analyzer while teeing child output through to the parent
+ * and keeping a bounded tail for crash classification.
+ *
+ * `execFileSync(..., { stdio: 'inherit' })` preserved live progress but hid
+ * stderr/stdout from the parent on abnormal exits. That made every
+ * SIGABRT/status-134 child look like an output-less V8 heap OOM, even when the
+ * terminal had already shown a native crash such as
+ * `libc++abi: ... Napi::Error`. Piped streams plus an explicit tee keeps the UX
+ * and gives `childProcessLikelyOom` the evidence it needs.
+ */
+const runRespawnedAnalyze = (args, env) => new Promise((resolve) => {
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    const finish = (exit) => {
+        if (settled)
+            return;
+        settled = true;
+        resolve(exit);
+    };
+    const child = spawn(process.execPath, [...args], {
+        stdio: ['inherit', 'pipe', 'pipe'],
+        env,
+    });
+    child.stdout?.on('data', (chunk) => {
+        stdout = appendOutputTail(stdout, chunk);
+        realStdoutWrite(chunk);
+    });
+    child.stderr?.on('data', (chunk) => {
+        stderr = appendOutputTail(stderr, chunk);
+        realStderrWrite(chunk);
+    });
+    child.on('error', (err) => {
+        finish({
+            status: 1,
+            signal: null,
+            stdout,
+            stderr,
+            message: err instanceof Error ? err.message : String(err),
+        });
+    });
+    child.on('close', (status, signal) => {
+        finish({
+            status,
+            signal,
+            stdout,
+            stderr,
+            message: `Command failed: ${process.execPath} ${args.join(' ')}`,
+        });
+    });
+});
 /**
  * Heuristic for "child re-exec likely died from V8 OOM".
  *
- * Platform-independent detection is best-effort: V8/Node usually emit
- * stable heap-exhaustion phrases in stderr/message across Linux/macOS/Windows
- * (for example "JavaScript heap out of memory" or "Reached heap limit"),
- * while some environments only expose status/signal (e.g. 134/SIGABRT).
- * We combine both text signatures and process-exit signatures.
+ * Platform-independent detection is best-effort: V8/Node usually emit stable
+ * heap-exhaustion phrases in stderr/message across Linux/macOS/Windows (for
+ * example "JavaScript heap out of memory" or "Reached heap limit"). When the
+ * child produced no output at all, we still treat status 134/SIGABRT as likely
+ * heap OOM. If stderr/stdout contains a native crash diagnostic, the output
+ * evidence wins and we do not print heap guidance.
  */
 const childProcessLikelyOom = (err) => {
     if (!err || typeof err !== 'object')
@@ -97,6 +296,23 @@ const childProcessLikelyOom = (err) => {
         return false;
     return e.status === 134 || e.signal === 'SIGABRT';
 };
+const childProcessLikelyNativeAbort = (err) => {
+    if (!err || typeof err !== 'object')
+        return false;
+    const e = err;
+    const hasNativeAbortSignature = (v) => {
+        const text = (Buffer.isBuffer(v) ? v.toString('utf8') : typeof v === 'string' ? v : '').toLowerCase();
+        if (!text)
+            return false;
+        return (text.includes('napi::error') ||
+            text.includes('libc++abi: terminating') ||
+            text.includes('abort trap') ||
+            text.includes('native stack') ||
+            text.includes('native worker') ||
+            text.includes('native binding'));
+    };
+    return [e.message, e.stderr, e.stdout].some((v) => hasNativeAbortSignature(v));
+};
 const forceHeapOOMForTestIfEnabled = () => {
     if (process.env.GITNEXUS_TEST_FORCE_HEAP_OOM !== '1')
         return;
@@ -107,7 +323,7 @@ const forceHeapOOMForTestIfEnabled = () => {
         chunks.push('x'.repeat(1024 * 1024));
 };
 /** Re-exec the process with a 16GB heap and larger stack if we're currently below that. */
-function ensureHeap() {
+async function ensureHeap() {
     const nodeOpts = process.env.NODE_OPTIONS || '';
     if (nodeOpts.includes('--max-old-space-size'))
         return false;
@@ -119,23 +335,30 @@ function ensureHeap() {
     const cliFlags = [HEAP_FLAG];
     if (!nodeOpts.includes('--stack-size'))
         cliFlags.push(STACK_FLAG);
-    try {
-        execFileSync(process.execPath, [...cliFlags, ...process.argv.slice(1)], {
-            stdio: 'inherit',
-            env: { ...process.env, NODE_OPTIONS: `${nodeOpts} ${HEAP_FLAG}`.trim() },
-        });
-    }
-    catch (e) {
-        if (childProcessLikelyOom(e)) {
+    const childArgs = [...cliFlags, ...process.argv.slice(1)];
+    const childEnv = {
+        ...process.env,
+        NODE_OPTIONS: `${nodeOpts} ${HEAP_FLAG}`.trim(),
+    };
+    if (shouldBridgeRespawnProgressTty())
+        childEnv[RESPAWN_PROGRESS_ENV] = '1';
+    const childExit = await runRespawnedAnalyze(childArgs, childEnv);
+    if (childExit.status !== 0 || childExit.signal) {
+        if (childProcessLikelyOom(childExit)) {
             cliError(`  Analysis likely ran out of memory.\n` +
                 `  Retry with a larger heap if your machine allows it:\n` +
                 `    NODE_OPTIONS="--max-old-space-size=24576" gitnexus analyze [your-args]\n` +
                 `    (Windows: set NODE_OPTIONS=--max-old-space-size=24576 && gitnexus analyze [your-args])\n` +
                 `  If this persists, it may be a native crash unrelated to heap size.\n`, { recoveryHint: 'heap-oom-respawn' });
         }
-        const status = typeof e === 'object' && e !== null && 'status' in e && typeof e.status === 'number'
-            ? e.status
-            : 1;
+        else if (childProcessLikelyNativeAbort(childExit)) {
+            cliError(`  Analysis aborted in a native worker or native binding path.\n` +
+                `  Try one of these recovery paths:\n` +
+                `    gitnexus analyze --workers 0\n` +
+                `    npm uninstall -g gitnexus && npm install -g gitnexus@latest\n` +
+                `    Use Node 22 LTS if you are on a newer non-LTS runtime.\n`, { recoveryHint: 'native-worker-abort' });
+        }
+        const status = typeof childExit.status === 'number' && childExit.status !== 0 ? childExit.status : 1;
         process.exitCode = status;
     }
     return true;
@@ -157,6 +380,7 @@ const ANALYZE_CLI_ENV_KEYS = [
     'GITNEXUS_EMBEDDING_BATCH_SIZE',
     'GITNEXUS_EMBEDDING_SUB_BATCH_SIZE',
     'GITNEXUS_EMBEDDING_DEVICE',
+    'GITNEXUS_ANALYZE_PROGRESS_ACTIVE',
 ];
 const snapshotAnalyzeEnv = () => {
     const snap = {};
@@ -188,7 +412,7 @@ const restoreAnalyzeEnv = (snap) => {
  */
 export const shouldGenerateCommunitySkillFiles = (options, pipelineResult) => Boolean(options?.skills && pipelineResult && !options?.indexOnly);
 export const analyzeCommand = async (inputPath, options) => {
-    if (ensureHeap())
+    if (await ensureHeap())
         return;
     forceHeapOOMForTestIfEnabled();
     // Install fatal handlers immediately after re-exec resolution so any
@@ -362,7 +586,7 @@ const analyzeCommandImpl = async (inputPath, options) => {
         console.log(`${maxFileSizeBanner}\n`);
     }
     // ── CLI progress bar setup ─────────────────────────────────────────
-    const bar = new cliProgress.SingleBar({
+    const barOptions = {
         format: '  {bar} {percentage}% | {phase}',
         barCompleteChar: '\u2588',
         barIncompleteChar: '\u2591',
@@ -371,7 +595,16 @@ const analyzeCommandImpl = async (inputPath, options) => {
         autopadding: true,
         clearOnComplete: false,
         stopOnComplete: false,
-    }, cliProgress.Presets.shades_grey);
+    };
+    if (process.env[RESPAWN_PROGRESS_ENV] === '1' && process.stderr.isTTY !== true) {
+        // Heap respawn pipes stderr so the parent can classify native/OOM crashes.
+        // The parent was a real TTY when it opted into this env var, so forward
+        // ANSI cursor controls through the pipe instead of cli-progress' non-TTY
+        // newline mode. That keeps one-line redraw UX while retaining stderr tail
+        // capture for diagnostics.
+        barOptions.terminal = createAnsiPipeTerminal(process.stderr);
+    }
+    const bar = new cliProgress.SingleBar(barOptions, cliProgress.Presets.shades_grey);
     bar.start(100, 0, { phase: 'Initializing...' });
     // Graceful SIGINT handling. Pino's default destination is `sync: false`
     // (buffered) — flush before exit so in-flight records reach stderr.
@@ -413,6 +646,7 @@ const analyzeCommandImpl = async (inputPath, options) => {
     console.warn = barLog;
     // eslint-disable-next-line no-console -- intentional console-routing for progress bar UX
     console.error = barLog;
+    process.env.GITNEXUS_ANALYZE_PROGRESS_ACTIVE = '1';
     // Track elapsed time per phase
     let lastPhaseLabel = 'Initializing...';
     let phaseStart = Date.now();

package/dist/cli/optional-grammars.d.ts

@@ -1,15 +1,18 @@
 /**
  * Optional grammar availability check.
  *
- * tree-sitter-dart and tree-sitter-proto are optionalDependencies that
- * require a `node-gyp rebuild` at install time. The build can be skipped
- * via GITNEXUS_SKIP_OPTIONAL_GRAMMARS=1 (postinstall scripts), or it can
- * silently soft-fail when the C++ toolchain is missing.
+ * tree-sitter-dart, tree-sitter-proto, and tree-sitter-swift are vendored
+ * under vendor/ and materialized into node_modules/ at postinstall. Dart
+ * and Proto are built from source with node-gyp; Swift ships platform
+ * prebuilds activated via node-gyp-build. All three can be skipped via
+ * GITNEXUS_SKIP_OPTIONAL_GRAMMARS=1 (postinstall scripts), or can silently
+ * soft-fail when the toolchain is missing (Dart/Proto) or no prebuild
+ * matches the host platform (Swift).
  *
  * Either path produces the same observable: the .node binding is absent
  * at runtime. This helper detects that condition and surfaces a single
- * stderr line per missing grammar so users learn why .dart/.proto support
- * is unavailable instead of silently getting a degraded index.
+ * stderr line per missing grammar so users learn why .dart/.proto/.swift
+ * support is unavailable instead of silently getting a degraded index.
  */
 export interface MissingGrammar {
     name: string;
@@ -19,8 +22,8 @@ export interface MissingGrammar {
  * Returns the list of optional grammars whose native binding cannot be
  * loaded. Actually `require()`s the package — `require.resolve` would
  * locate the entry path even when the `.node` binding is absent (the
- * `file:` package directory is installed regardless of postinstall
- * outcome), giving false negatives for the exact users we want to warn:
+ * package directory exists without a working `.node` binding), giving false
+ * negatives for the exact users we want to warn:
  * those who installed with `GITNEXUS_SKIP_OPTIONAL_GRAMMARS=1` or whose
  * native rebuild soft-failed for missing toolchain.
  *

package/dist/cli/optional-grammars.js

@@ -1,15 +1,18 @@
 /**
  * Optional grammar availability check.
  *
- * tree-sitter-dart and tree-sitter-proto are optionalDependencies that
- * require a `node-gyp rebuild` at install time. The build can be skipped
- * via GITNEXUS_SKIP_OPTIONAL_GRAMMARS=1 (postinstall scripts), or it can
- * silently soft-fail when the C++ toolchain is missing.
+ * tree-sitter-dart, tree-sitter-proto, and tree-sitter-swift are vendored
+ * under vendor/ and materialized into node_modules/ at postinstall. Dart
+ * and Proto are built from source with node-gyp; Swift ships platform
+ * prebuilds activated via node-gyp-build. All three can be skipped via
+ * GITNEXUS_SKIP_OPTIONAL_GRAMMARS=1 (postinstall scripts), or can silently
+ * soft-fail when the toolchain is missing (Dart/Proto) or no prebuild
+ * matches the host platform (Swift).
  *
  * Either path produces the same observable: the .node binding is absent
  * at runtime. This helper detects that condition and surfaces a single
- * stderr line per missing grammar so users learn why .dart/.proto support
- * is unavailable instead of silently getting a degraded index.
+ * stderr line per missing grammar so users learn why .dart/.proto/.swift
+ * support is unavailable instead of silently getting a degraded index.
  */
 import { createRequire } from 'module';
 import { cliWarn } from './cli-message.js';
@@ -17,13 +20,14 @@ const _require = createRequire(import.meta.url);
 const OPTIONAL_GRAMMARS = [
     { name: 'tree-sitter-dart', pkg: 'tree-sitter-dart', extensions: ['.dart'] },
     { name: 'tree-sitter-proto', pkg: 'tree-sitter-proto', extensions: ['.proto'] },
+    { name: 'tree-sitter-swift', pkg: 'tree-sitter-swift', extensions: ['.swift'] },
 ];
 /**
  * Returns the list of optional grammars whose native binding cannot be
  * loaded. Actually `require()`s the package — `require.resolve` would
  * locate the entry path even when the `.node` binding is absent (the
- * `file:` package directory is installed regardless of postinstall
- * outcome), giving false negatives for the exact users we want to warn:
+ * package directory exists without a working `.node` binding), giving false
+ * negatives for the exact users we want to warn:
  * those who installed with `GITNEXUS_SKIP_OPTIONAL_GRAMMARS=1` or whose
  * native rebuild soft-failed for missing toolchain.
  *

package/dist/core/ingestion/filesystem-walker.js

@@ -6,6 +6,20 @@ import { glob } from 'glob';
 import { createIgnoreFilter } from '../../config/ignore-service.js';
 import { logger } from '../logger.js';
 const READ_CONCURRENCY = 32;
+const ANALYZE_PROGRESS_ACTIVE_ENV = 'GITNEXUS_ANALYZE_PROGRESS_ACTIVE';
+const warnLargeFileSkip = (message) => {
+    if (process.env[ANALYZE_PROGRESS_ACTIVE_ENV] === '1') {
+        // analyze.ts routes console.warn through the progress bar logger while
+        // the bar is active. Emitting the operator-facing large-file notice there
+        // avoids raw pino NDJSON corrupting the one-line progress display in the
+        // heap-respawn child, whose stderr is intentionally piped for crash
+        // classification.
+        // eslint-disable-next-line no-console -- intentionally routed by analyze progress UI
+        console.warn(message);
+        return;
+    }
+    logger.warn(message);
+};
 /**
  * Phase 1: Scan repository — stat files to get paths + sizes, no content loaded.
  * Memory: ~10MB for 100K files vs ~1GB+ with content.
@@ -50,7 +64,7 @@ export const walkRepositoryPaths = async (repoPath, onProgress) => {
         const isDefault = maxFileSizeBytes === DEFAULT_MAX_FILE_SIZE_BYTES;
         const isOverrideUnset = !process.env.GITNEXUS_MAX_FILE_SIZE;
         const suffix = isDefault ? ', likely generated/vendored' : '';
-        logger.warn(`  Skipped ${skippedLarge} large files (>${maxFileSizeBytes / 1024}KB${suffix})`);
+        warnLargeFileSkip(`  Skipped ${skippedLarge} large files (>${maxFileSizeBytes / 1024}KB${suffix})`);
         // Always show at least the first few paths so users can diagnose why
         // edges are missing from a specific file (issue #1659). The full list is
         // gated behind GITNEXUS_VERBOSE=1 to avoid flooding output on repos with
@@ -61,17 +75,17 @@ export const walkRepositoryPaths = async (repoPath, onProgress) => {
         const showAll = isVerboseIngestionEnabled() || skippedLargePaths.length <= SKIPPED_PREVIEW_CAP;
         const preview = showAll ? skippedLargePaths : skippedLargePaths.slice(0, SKIPPED_PREVIEW_CAP);
         for (const p of preview) {
-            logger.warn(`  - ${p}`);
+            warnLargeFileSkip(`  - ${p}`);
         }
         if (!showAll) {
             const remaining = skippedLargePaths.length - SKIPPED_PREVIEW_CAP;
-            logger.warn(`  ...and ${remaining} more (set GITNEXUS_VERBOSE=1 to list them all)`);
+            warnLargeFileSkip(`  ...and ${remaining} more (set GITNEXUS_VERBOSE=1 to list them all)`);
         }
         // Only hint about the env var when the user has not set it at all. An
         // explicit GITNEXUS_MAX_FILE_SIZE=512 happens to resolve to the same
         // bytes as the default but the operator clearly already knows the knob.
         if (isDefault && isOverrideUnset) {
-            logger.warn(`  Set GITNEXUS_MAX_FILE_SIZE=<KB> to include files above the default cap.`);
+            warnLargeFileSkip(`  Set GITNEXUS_MAX_FILE_SIZE=<KB> to include files above the default cap.`);
         }
     }
     return entries;

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

@@ -7,7 +7,7 @@ import { extractVueScript, isVueSetupTopLevel } from './vue-sfc-extractor.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
 import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
-import { getDefinitionNodeFromCaptures, findEnclosingClassInfo, getLabelFromCaptures, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
+import { getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, getLabelFromCaptures, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
 import { buildTypeEnv } from './type-env.js';
 import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, } from './utils/method-props.js';
@@ -400,6 +400,9 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
                 ? cachedFindEnclosingClassInfo(nameNode || definitionNodeForRange, file.path, provider.resolveEnclosingOwner)
                 : null;
             const enclosingClassId = enclosingClassInfo?.classId ?? null;
+            const objectLiteralOwnerInfo = !enclosingClassId && nodeLabel === 'Method' && definitionNode
+                ? findObjectLiteralBindingInfo(definitionNode, file.path)
+                : null;
             // Qualify method/property IDs with enclosing class name to avoid collisions
             // e.g. "Method:animal.dart:Animal.speak" vs "Method:animal.dart:Dog.speak"
             const qualifiedName = enclosingClassInfo
@@ -615,7 +618,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
                 returnType: methodProps.returnType,
                 declaredType,
                 templateArguments: classTemplateArguments,
-                ownerId: enclosingClassId ?? undefined,
+                ownerId: enclosingClassId ?? objectLiteralOwnerInfo?.ownerId ?? undefined,
                 qualifiedName: qualifiedTypeName,
             });
             const fileId = generateId('File', file.path);
@@ -630,15 +633,18 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
             };
             graph.addRelationship(relationship);
             // ── HAS_METHOD / HAS_PROPERTY: link member to enclosing class ──
-            if (enclosingClassId) {
+            const ownerIdForMemberEdge = enclosingClassId ?? objectLiteralOwnerInfo?.ownerId ?? null;
+            if (ownerIdForMemberEdge) {
                 const memberEdgeType = nodeLabel === 'Property' ? 'HAS_PROPERTY' : 'HAS_METHOD';
                 graph.addRelationship({
-                    id: generateId(memberEdgeType, `${enclosingClassId}->${nodeId}`),
-                    sourceId: enclosingClassId,
+                    id: generateId(memberEdgeType, `${ownerIdForMemberEdge}->${nodeId}`),
+                    sourceId: ownerIdForMemberEdge,
                     targetId: nodeId,
                     type: memberEdgeType,
                     confidence: 1.0,
-                    reason: '',
+                    reason: objectLiteralOwnerInfo
+                        ? 'object literal method belongs to exported object binding'
+                        : '',
                 });
             }
         });