gitnexus 1.6.6-rc.3 → 1.6.6-rc.5

package/dist/cli/analyze.js

@@ -58,12 +58,55 @@ const installFatalHandlers = () => {
         process.exit(1);
     });
 };
-const HEAP_MB = 8192;
-const HEAP_FLAG = `--max-old-space-size=${HEAP_MB}`;
+const HEAP_MB = 16384;
+const TEST_RESPAWN_HEAP_MB = Number(process.env.GITNEXUS_TEST_RESPAWN_HEAP_MB);
+const RESPAWN_HEAP_MB = Number.isFinite(TEST_RESPAWN_HEAP_MB) && TEST_RESPAWN_HEAP_MB > 0
+    ? Math.floor(TEST_RESPAWN_HEAP_MB)
+    : HEAP_MB;
+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}`;
-/** Re-exec the process with an 8GB heap and larger stack if we're currently below that. */
+/**
+ * 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.
+ */
+const childProcessLikelyOom = (err) => {
+    if (!err || typeof err !== 'object')
+        return false;
+    const e = err;
+    const hasHeapOomSignature = (v) => {
+        const text = (Buffer.isBuffer(v) ? v.toString('utf8') : typeof v === 'string' ? v : '').toLowerCase();
+        if (!text)
+            return false;
+        return (text.includes('javascript heap out of memory') ||
+            text.includes('reached heap limit') ||
+            text.includes('allocation failed - javascript heap out of memory') ||
+            text.includes('fatalprocessoutofmemory'));
+    };
+    const fields = [e.message, e.stderr, e.stdout];
+    if (fields.some((v) => hasHeapOomSignature(v)))
+        return true;
+    const hasAnyChildOutput = [e.stderr, e.stdout].some((v) => (Buffer.isBuffer(v) && v.length > 0) || (typeof v === 'string' && v.length > 0));
+    if (hasAnyChildOutput)
+        return false;
+    return e.status === 134 || e.signal === 'SIGABRT';
+};
+const forceHeapOOMForTestIfEnabled = () => {
+    if (process.env.GITNEXUS_TEST_FORCE_HEAP_OOM !== '1')
+        return;
+    // Allocate JS strings (not Buffers) so pressure lands on V8 heap itself.
+    // Buffers can allocate off-heap, which makes OOM triggering less reliable.
+    const chunks = [];
+    for (;;)
+        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() {
     const nodeOpts = process.env.NODE_OPTIONS || '';
     if (nodeOpts.includes('--max-old-space-size'))
@@ -83,6 +126,13 @@ function ensureHeap() {
         });
     }
     catch (e) {
+        if (childProcessLikelyOom(e)) {
+            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' });
+        }
         process.exitCode = e.status ?? 1;
     }
     return true;
@@ -104,6 +154,7 @@ export const shouldGenerateCommunitySkillFiles = (options, pipelineResult) => Bo
 export const analyzeCommand = async (inputPath, options) => {
     if (ensureHeap())
         return;
+    forceHeapOOMForTestIfEnabled();
     // 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.

package/dist/cli/index.js

@@ -103,7 +103,7 @@ program
     .option('--reasoning-model', 'Mark deployment as reasoning model (o1/o3/o4-mini) — strips temperature, uses max_completion_tokens')
     .option('--no-reasoning-model', 'Disable reasoning model mode (overrides saved config)')
     .option('--concurrency <n>', 'Parallel LLM calls (default: 3)', '3')
-    .option('--timeout <seconds>', 'Per-attempt LLM request timeout in seconds (default: 60)')
+    .option('--timeout <seconds>', 'LLM request timeout in seconds (default: disabled)')
     .option('--retries <n>', 'Max LLM retry attempts per request (default: 3)')
     .option('--gist', 'Publish wiki as a public GitHub Gist after generation')
     .option('-v, --verbose', 'Enable verbose output (show LLM commands and responses)')

package/dist/cli/wiki.js

@@ -14,6 +14,19 @@ import { WikiGenerator } from '../core/wiki/generator.js';
 import { resolveLLMConfig } from '../core/wiki/llm-client.js';
 import { detectCursorCLI } from '../core/wiki/cursor-client.js';
 import { logger } from '../core/logger.js';
+function parsePositiveIntegerOption(value, flag, multiplier = 1) {
+    if (value === undefined)
+        return undefined;
+    const trimmed = value.trim();
+    if (!/^[1-9]\d*$/.test(trimmed)) {
+        throw new Error(`${flag} must be a positive integer`);
+    }
+    const parsed = parseInt(trimmed, 10);
+    if (parsed > Math.floor(Number.MAX_SAFE_INTEGER / multiplier)) {
+        throw new Error(`${flag} is too large`);
+    }
+    return parsed;
+}
 /**
  * Prompt the user for input via stdin.
  */
@@ -100,6 +113,17 @@ export const wikiCommand = async (inputPath, options) => {
         process.exitCode = 1;
         return;
     }
+    let timeoutSeconds;
+    let retries;
+    try {
+        timeoutSeconds = parsePositiveIntegerOption(options?.timeout, '--timeout', 1000);
+        retries = parsePositiveIntegerOption(options?.retries, '--retries');
+    }
+    catch (error) {
+        console.log(`  Error: ${error.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
     // ── Resolve LLM config (with interactive fallback) ─────────────────
     // Save any CLI overrides immediately
     if (options?.apiKey ||
@@ -305,15 +329,11 @@ export const wikiCommand = async (inputPath, options) => {
         }
     }
     // ── Apply per-run overrides not saved to config ────────────────────
-    if (options?.timeout) {
-        const secs = parseInt(options.timeout, 10);
-        if (!isNaN(secs) && secs > 0)
-            llmConfig.requestTimeoutMs = secs * 1000;
+    if (timeoutSeconds !== undefined) {
+        llmConfig.requestTimeoutMs = timeoutSeconds * 1000;
     }
-    if (options?.retries) {
-        const n = parseInt(options.retries, 10);
-        if (!isNaN(n) && n > 0)
-            llmConfig.maxAttempts = n;
+    if (retries !== undefined) {
+        llmConfig.maxAttempts = retries;
     }
     // ── Setup progress bar with elapsed timer ──────────────────────────
     const bar = new cliProgress.SingleBar({
@@ -473,6 +493,9 @@ export const wikiCommand = async (inputPath, options) => {
         if (err.message?.includes('No source files')) {
             console.log(`\n  ${err.message}\n`);
         }
+        else if (err.message?.includes('LLM request timed out after')) {
+            console.log(`\n  Timeout: ${err.message}\n`);
+        }
         else if (err.message?.includes('content filter')) {
             // Content filter block — actionable message
             console.log(`\n  Content Filter: ${err.message}\n`);

package/dist/core/wiki/llm-client.d.ts

@@ -19,7 +19,7 @@ export interface LLMConfig {
     apiVersion?: string;
     /** When true, strips sampling params and uses max_completion_tokens instead of max_tokens */
     isReasoningModel?: boolean;
-    /** Per-attempt fetch timeout in ms (default: 60_000). */
+    /** Per-attempt fetch timeout in ms. Omit to disable request timeouts. */
     requestTimeoutMs?: number;
     /** Max fetch attempts before giving up (default: 3). */
     maxAttempts?: number;

package/dist/core/wiki/llm-client.js

@@ -38,6 +38,19 @@ export async function resolveLLMConfig(overrides) {
 export function estimateTokens(text) {
     return Math.ceil(text.length / 4);
 }
+function formatTimeoutDuration(timeoutMs) {
+    if (timeoutMs >= 1000 && timeoutMs % 1000 === 0) {
+        return `${timeoutMs / 1000}s`;
+    }
+    return `${timeoutMs}ms`;
+}
+function isTimeoutLikeError(err) {
+    if (!(err instanceof Error))
+        return false;
+    if (err.name === 'TimeoutError' || err.name === 'AbortError')
+        return true;
+    return /time(d)?\s*out|timeout/i.test(err.message);
+}
 /**
  * Validate that a base URL supplied for LLM API calls is a safe HTTP/HTTPS
  * endpoint (CWE-918 / CodeQL js/http-to-file-access).
@@ -166,12 +179,12 @@ export async function callLLM(prompt, config, systemPrompt, options) {
                 ...authHeaders,
             },
             body: JSON.stringify(body),
-            // Per-attempt timeout. Without this each retry can hang
-            // indefinitely on a frozen TCP connection — the per-call
-            // signal is the only timeout `resilientFetch` honors;
-            // `capDelayMs` only bounds the *backoff* between attempts.
-            // Default 60s; raise via --timeout for slow models or large pages.
-            signal: AbortSignal.timeout(config.requestTimeoutMs ?? 60_000),
+            // Request timeout is opt-in for wiki generation. Large local
+            // model runs can legitimately take well over a minute, so the
+            // default runtime path must not impose a hidden 60s ceiling.
+            signal: config.requestTimeoutMs !== undefined
+                ? AbortSignal.timeout(config.requestTimeoutMs)
+                : undefined,
         }, {
             breakerKey: `wiki-llm-${new URL(url).host}`,
             retry: { maxAttempts: config.maxAttempts ?? 3, baseDelayMs: 2_000, capDelayMs: 30_000 },
@@ -185,6 +198,10 @@ export async function callLLM(prompt, config, systemPrompt, options) {
             const errorText = await err.response.text().catch(() => 'unknown error');
             throw new Error(`LLM API error (${err.response.status} after retries): ${errorText.slice(0, 500)}`);
         }
+        if (config.requestTimeoutMs !== undefined && isTimeoutLikeError(err)) {
+            throw new Error(`LLM request timed out after ${formatTimeoutDuration(config.requestTimeoutMs)}. ` +
+                'Increase --timeout or omit it to disable the request timeout.');
+        }
         throw err;
     }
     if (!response.ok) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.3",
+  "version": "1.6.6-rc.5",
   "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",