gitnexus 1.6.4-rc.30 → 1.6.4-rc.32

package/dist/cli/analyze.js

@@ -12,11 +12,47 @@ import { execFileSync } from 'child_process';
 import v8 from 'v8';
 import cliProgress from 'cli-progress';
 import { closeLbug } from '../core/lbug/lbug-adapter.js';
-import { getStoragePaths, getGlobalRegistryPath, RegistryNameCollisionError, } from '../storage/repo-manager.js';
+import { getStoragePaths, getGlobalRegistryPath, RegistryNameCollisionError, AnalysisNotFinalizedError, assertAnalysisFinalized, } from '../storage/repo-manager.js';
 import { getGitRoot, hasGitDir } from '../storage/git.js';
 import { runFullAnalysis } from '../core/run-analyze.js';
 import { getMaxFileSizeBannerMessage } from '../core/ingestion/utils/max-file-size.js';
 import fs from 'fs/promises';
+// Capture stderr.write at module load BEFORE anything (LadybugDB native
+// init, progress bar, console redirection) can monkey-patch it. The
+// fatal handlers below MUST reach the user even when the analyze path
+// has redirected console.* through the progress bar's bar.log() — the
+// 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 writeFatalToStderr = (label, err) => {
+    const isErr = err instanceof Error;
+    const message = isErr ? err.message : String(err);
+    realStderrWrite(`\n  ${label}: ${message}\n`);
+    if (isErr && err.stack)
+        realStderrWrite(`${err.stack}\n`);
+};
+let fatalHandlersInstalled = false;
+/**
+ * Install one-shot `unhandledRejection` / `uncaughtException` handlers
+ * that surface the failure to the real stderr (bypassing any console
+ * redirection installed by the progress bar) and force a non-zero exit
+ * code. Without these, an async error escaping {@link analyzeCommand}'s
+ * try/catch was reported as exit 0 with no diagnostic — the silent
+ * failure mode tracked in #1169.
+ */
+const installFatalHandlers = () => {
+    if (fatalHandlersInstalled)
+        return;
+    fatalHandlersInstalled = true;
+    process.on('unhandledRejection', (err) => {
+        writeFatalToStderr('Analysis failed (unhandled rejection)', err);
+        process.exit(1);
+    });
+    process.on('uncaughtException', (err) => {
+        writeFatalToStderr('Analysis failed (uncaught exception)', err);
+        process.exit(1);
+    });
+};
 const HEAP_MB = 8192;
 const HEAP_FLAG = `--max-old-space-size=${HEAP_MB}`;
 /** Increase default stack size (KB) to prevent stack overflow on deep class hierarchies. */
@@ -49,6 +85,10 @@ function ensureHeap() {
 export const analyzeCommand = async (inputPath, options) => {
     if (ensureHeap())
         return;
+    // Install fatal handlers immediately after re-exec resolution so any
+    // async error that escapes the try/catch below (#1169) surfaces with
+    // a stack trace and a non-zero exit code instead of a silent exit 0.
+    installFatalHandlers();
     if (options?.verbose) {
         process.env.GITNEXUS_VERBOSE = '1';
     }
@@ -211,6 +251,11 @@ export const analyzeCommand = async (inputPath, options) => {
             onLog: barLog,
         });
         if (result.alreadyUpToDate) {
+            // Even the fast path must prove the repo is discoverable. A prior
+            // run can write meta.json and then fail before registerRepo(); in
+            // that half-finalized state, runFullAnalysis returns alreadyUpToDate
+            // on the next invocation unless we check the registry here too.
+            await assertAnalysisFinalized(repoPath);
             clearInterval(elapsedTimer);
             process.removeListener('SIGINT', sigintHandler);
             console.log = origLog;
@@ -222,6 +267,14 @@ export const analyzeCommand = async (inputPath, options) => {
             // runFullAnalysis never opens LadybugDB, so no native handles prevent exit.
             return;
         }
+        // Post-finalize invariant (#1169): runFullAnalysis nominally writes
+        // meta.json and registers the repo, but on Windows it has been
+        // observed to return successfully with neither artifact present
+        // (banner-only output, exit 0). Verify both before declaring
+        // success so the silent-finalize state surfaces with a non-zero
+        // exit code and an actionable error instead of being mistaken for
+        // a healthy index.
+        await assertAnalysisFinalized(repoPath);
         // Skill generation (CLI-only, uses pipeline result from analysis)
         if (options?.skills && result.pipelineResult) {
             updateBar(99, 'Generating skill files...');
@@ -299,7 +352,26 @@ export const analyzeCommand = async (inputPath, options) => {
             process.exitCode = 1;
             return;
         }
-        console.error(`\n  Analysis failed: ${msg}\n`);
+        // Finalize invariant failure (#1169) — keep the rich actionable
+        // message intact and write through realStderrWrite so it can't be
+        // erased by a leftover bar refresh on slow terminals.
+        if (err instanceof AnalysisNotFinalizedError) {
+            writeFatalToStderr('Analysis did not finalize', err);
+            realStderrWrite(`\n  Diagnostic checklist:\n` +
+                `    1. Re-run "gitnexus analyze" - transient native errors often clear on retry.\n` +
+                `    2. Inspect ${err.storagePath} - a leftover lbug.wal indicates an aborted write.\n` +
+                `    3. If the failure persists, run with NODE_OPTIONS="--max-old-space-size=8192 --trace-exit"\n` +
+                `       and attach the trace to the GitNexus issue tracker.\n\n`);
+            process.exitCode = 1;
+            return;
+        }
+        // Bypass the redirected console.error and write the full stack to
+        // the real stderr captured at module load. The redirected
+        // console.error wraps every line with `\\x1b[2K\\r` (ANSI clear-line)
+        // and forces a bar.update() afterwards, which on some Windows
+        // terminals visually erases the failure message — the canonical
+        // shape of the silent-exit symptom in #1169.
+        writeFatalToStderr('Analysis failed', err);
         // Provide helpful guidance for known failure modes
         if (msg.includes('Maximum call stack size exceeded') ||
             msg.includes('call stack') ||

package/dist/storage/repo-manager.d.ts

@@ -254,6 +254,44 @@ export declare class RegistryAmbiguousTargetError extends Error {
     readonly kind: "RegistryAmbiguousTargetError";
     constructor(target: string, matches: RegistryEntry[]);
 }
+/**
+ * Thrown by {@link assertAnalysisFinalized} when a successful `analyze`
+ * run did not actually persist `meta.json` or did not register the repo
+ * in `~/.gitnexus/registry.json` (#1169).
+ *
+ * Why this exists: on Windows, `gitnexus analyze` has been observed to
+ * exit cleanly (code 0) with `lbug.wal` written but no `meta.json`,
+ * leaving the repo invisible to `gitnexus list`/`status` and downstream
+ * MCP discovery. The only signal to the user was an empty banner —
+ * which is indistinguishable from a no-op early return. This invariant
+ * fails loudly with an actionable diagnostic so the silent-finalize bug
+ * surfaces with a non-zero exit code and a recoverable error message
+ * regardless of the upstream root cause (re-exec churn, native module
+ * side effects, antivirus, or future regressions).
+ */
+export declare class AnalysisNotFinalizedError extends Error {
+    readonly repoPath: string;
+    readonly storagePath: string;
+    readonly missing: 'meta' | 'registry-entry';
+    readonly registryPath: string;
+    readonly kind: "AnalysisNotFinalizedError";
+    constructor(repoPath: string, storagePath: string, missing: 'meta' | 'registry-entry', registryPath: string);
+}
+/**
+ * Verify that a successful `analyze` call actually produced an indexed,
+ * registered repo on disk. Two checks, both strictly required:
+ *
+ *   1. `meta.json` must exist at `<repoPath>/.gitnexus/meta.json`.
+ *   2. The global registry (`getGlobalRegistryPath()`) must contain an
+ *      entry whose canonical path matches `repoPath`.
+ *
+ * Throws {@link AnalysisNotFinalizedError} on the first failure with the
+ * specific missing artifact. Pure read — does not mutate disk state.
+ *
+ * Callers must skip this assertion on the `alreadyUpToDate` early-return
+ * path, where the rebuild was deliberately not run.
+ */
+export declare const assertAnalysisFinalized: (repoPath: string) => Promise<void>;
 /**
  * Thrown by {@link assertSafeStoragePath} when a registry entry's
  * `storagePath` does NOT point at the expected `<entry.path>/.gitnexus`

package/dist/storage/repo-manager.js

@@ -454,6 +454,76 @@ export class RegistryAmbiguousTargetError extends Error {
         this.name = 'RegistryAmbiguousTargetError';
     }
 }
+/**
+ * Thrown by {@link assertAnalysisFinalized} when a successful `analyze`
+ * run did not actually persist `meta.json` or did not register the repo
+ * in `~/.gitnexus/registry.json` (#1169).
+ *
+ * Why this exists: on Windows, `gitnexus analyze` has been observed to
+ * exit cleanly (code 0) with `lbug.wal` written but no `meta.json`,
+ * leaving the repo invisible to `gitnexus list`/`status` and downstream
+ * MCP discovery. The only signal to the user was an empty banner —
+ * which is indistinguishable from a no-op early return. This invariant
+ * fails loudly with an actionable diagnostic so the silent-finalize bug
+ * surfaces with a non-zero exit code and a recoverable error message
+ * regardless of the upstream root cause (re-exec churn, native module
+ * side effects, antivirus, or future regressions).
+ */
+export class AnalysisNotFinalizedError extends Error {
+    repoPath;
+    storagePath;
+    missing;
+    registryPath;
+    kind = 'AnalysisNotFinalizedError';
+    constructor(repoPath, storagePath, missing, registryPath) {
+        const detail = missing === 'meta'
+            ? `meta.json was not written to ${path.join(storagePath, 'meta.json')}`
+            : `registry entry for ${repoPath} was not added to ${registryPath}`;
+        super(`Analysis did not finalize for ${repoPath}: ${detail}. ` +
+            `The on-disk index is incomplete and was not registered. ` +
+            `Re-run "gitnexus analyze" — if the problem persists, inspect ` +
+            `${storagePath} for a stale lbug.wal that signals an aborted write.`);
+        this.repoPath = repoPath;
+        this.storagePath = storagePath;
+        this.missing = missing;
+        this.registryPath = registryPath;
+        this.name = 'AnalysisNotFinalizedError';
+    }
+}
+/**
+ * Verify that a successful `analyze` call actually produced an indexed,
+ * registered repo on disk. Two checks, both strictly required:
+ *
+ *   1. `meta.json` must exist at `<repoPath>/.gitnexus/meta.json`.
+ *   2. The global registry (`getGlobalRegistryPath()`) must contain an
+ *      entry whose canonical path matches `repoPath`.
+ *
+ * Throws {@link AnalysisNotFinalizedError} on the first failure with the
+ * specific missing artifact. Pure read — does not mutate disk state.
+ *
+ * Callers must skip this assertion on the `alreadyUpToDate` early-return
+ * path, where the rebuild was deliberately not run.
+ */
+export const assertAnalysisFinalized = async (repoPath) => {
+    const resolved = path.resolve(repoPath);
+    const { storagePath, metaPath } = getStoragePaths(resolved);
+    try {
+        await fs.access(metaPath);
+    }
+    catch {
+        throw new AnalysisNotFinalizedError(resolved, storagePath, 'meta', getGlobalRegistryPath());
+    }
+    const entries = await readRegistry();
+    const canonicalInput = canonicalizePath(resolved);
+    const isWin = process.platform === 'win32';
+    const found = entries.some((e) => {
+        const a = canonicalizePath(e.path);
+        return isWin ? a.toLowerCase() === canonicalInput.toLowerCase() : a === canonicalInput;
+    });
+    if (!found) {
+        throw new AnalysisNotFinalizedError(resolved, storagePath, 'registry-entry', getGlobalRegistryPath());
+    }
+};
 /**
  * Thrown by {@link assertSafeStoragePath} when a registry entry's
  * `storagePath` does NOT point at the expected `<entry.path>/.gitnexus`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.4-rc.30",
+  "version": "1.6.4-rc.32",
   "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",