From 5e5d8d9447ff0ff76a35d7b0458e671568c9162d Mon Sep 17 00:00:00 2001 From: andreinknv Date: Thu, 7 May 2026 22:02:20 -0400 Subject: [PATCH] fix(cli): surface lock-acquisition errors and silence Emscripten Aborted() spam (#128) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix(cli): surface lock-acquisition errors and silence Emscripten Aborted() spam Two unrelated cosmetic but actively misleading bugs that surface when the indexer is under load. 1) printIndexResult fell through to "No files found to index" whenever the IndexResult had filesIndexed=0 AND filesErrored=0. The lock-acquisition path returns success:false with a generic "Could not acquire file lock" entry in result.errors[] (severity 'error'), but filesErrored counts only file-level parse failures, so the user saw "No files found to index" — actively wrong. Add a top-of-function check for the !success && !hasErrors case that surfaces the first severity:'error' message instead. 2) parse-worker.ts let Emscripten's stderr "Aborted()" lines (plus their "Build with -sASSERTIONS for more info" follow-ups) leak to the parent's terminal whenever a WASM tree-sitter parser crashed on a pathological file. Even after the JS layer caught and recovered, the user saw dozens of `Aborted()` lines spammed to stderr. Install a stderr filter at worker startup that drops only those specific Emscripten internal lines; everything we log ourselves passes through unchanged. Verified live against ollama/ollama@v0.22.0: - second concurrent `codegraph index` now shows "Could not acquire file lock - another process may be indexing" instead of "No files found to index" - WASM-crash-prone re-index produced 0 Aborted() lines (down from 68+). * fix(cli): null-safe error surfacing + clearer stderr-filter contract docs Two reviewer findings on PR #128: - printIndexResult: when result.success is false but result.errors contains no severity:'error' entry (degenerate case but possible if the result shape ever drifts), the find() returned undefined and the previous if-guard fell through to the misleading 'No files found to index' branch. Now always surfaces a clear failure message via clack.log.error, defaulting to 'Indexing failed — no further details available' when no specific error is in the errors list. - parse-worker stderr filter: callback handling was already correct but the comment didn't document it; expand the comment to spell out the Writable-stream-contract obligation, the per-call match semantics (split-chunk caveat), and the substring-exactness trade-off so future readers understand the deliberate trade-offs. --- src/bin/codegraph.ts | 17 ++++++++++++++ src/extraction/parse-worker.ts | 42 ++++++++++++++++++++++++++++++++++ 2 files changed, 59 insertions(+) diff --git a/src/bin/codegraph.ts b/src/bin/codegraph.ts index d118a1f..2843e67 100644 --- a/src/bin/codegraph.ts +++ b/src/bin/codegraph.ts @@ -265,6 +265,23 @@ type IndexResult = { function printIndexResult(clack: typeof import('@clack/prompts'), result: IndexResult, projectPath?: string): void { const hasErrors = result.filesErrored > 0; + // Surface non-file-level failures (e.g. lock-acquisition failure + // when another indexer is running) before the file-count branches. + // Without this the CLI falls through to "No files found to index", + // which is actively misleading — the index DID run, it just couldn't + // get the lock. + // + // If success is false but no severity:'error' entry exists in + // `result.errors` (degenerate case — shouldn't happen in practice + // but worth guarding because the result shape is plumbed through + // multiple call sites), fall back to a generic message rather than + // continuing to the misleading "No files found" branch or throwing. + if (!result.success && !hasErrors && result.filesIndexed === 0) { + const generic = result.errors.find((e) => e.severity === 'error'); + clack.log.error(generic?.message ?? 'Indexing failed — no further details available'); + return; + } + if (result.filesIndexed > 0) { if (hasErrors) { clack.log.success(`Indexed ${formatNumber(result.filesIndexed)} files (${formatNumber(result.filesErrored)} could not be parsed)`); diff --git a/src/extraction/parse-worker.ts b/src/extraction/parse-worker.ts index 21b239c..3ddc18e 100644 --- a/src/extraction/parse-worker.ts +++ b/src/extraction/parse-worker.ts @@ -10,6 +10,48 @@ import { extractFromSource } from './tree-sitter'; import { detectLanguage, loadGrammarsForLanguages, resetParser } from './grammars'; import type { Language, ExtractionResult } from '../types'; +// Emscripten prints `Aborted()` (and a follow-up RuntimeError diag +// line) directly to stderr when WASM aborts — before the JS catch +// runs. Worker stderr is inherited by the parent, so each crash leaks +// a noise line to the user's terminal even though the JS layer +// already handles the failure cleanly. Filter these specific lines +// out at the source. Real diagnostic output (anything we log +// ourselves) goes through console.* / parentPort and is unaffected. +// +// Caveats deliberately accepted: +// - Per-call match: each `write()` call is matched in isolation. +// If Emscripten ever splits `Aborted(` across two write()s (it +// doesn't today — synchronous abort prints the whole line at +// once via libc puts) the first fragment would leak. Buffering +// across calls would add complexity for a hypothetical case. +// - Substring exactness: the prefix `Aborted(` is the literal +// Emscripten signature. Any user code that legitimately writes +// a stderr line starting with that prefix would also be filtered; +// in practice no real diagnostic does. +{ + const realWrite = process.stderr.write.bind(process.stderr); + process.stderr.write = (( + chunk: string | Uint8Array, + encoding?: BufferEncoding | ((err?: Error | null) => void), + cb?: (err?: Error | null) => void + ): boolean => { + const s = typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf-8'); + if ( + s.startsWith('Aborted(') || + s.includes('Build with -sASSERTIONS for more info') + ) { + // Honour the Writable stream contract: callbacks must always + // fire even when the write is suppressed, or upstream code + // waiting on the drain signal would hang. Both overload forms + // are handled (`(chunk, cb)` and `(chunk, encoding, cb)`). + if (typeof encoding === 'function') encoding(); + else if (cb) cb(); + return true; + } + return realWrite(chunk as never, encoding as never, cb as never); + }) as typeof process.stderr.write; +} + const PARSER_RESET_INTERVAL = 5000; const parseCounts = new Map();