@wrongstack/tools 0.302.2 → 0.305.0

package/dist/codebase-index/indexer.d.ts

@@ -6,6 +6,12 @@ import { IndexStore } from './writer.js';
  * Re-resolved at the start of each index run so env profile changes apply.
  */
 export declare function resolveParallelBatch(): number;
+/**
+ * Pool startup is amortized across the complete index run, not one outer
+ * batch. Balanced batches are capped at 40 files, so comparing the per-batch
+ * parse count with the 500-file threshold made the worker path unreachable.
+ */
+export declare function shouldUseParserWorkerPool(candidateFileCount: number, parseBatchCount: number): boolean;
 interface IndexerOptions {
     projectRoot: string;
     files?: string[] | undefined;

package/dist/codebase-index/parser-worker-pool.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Multi-threaded parser worker pool for bulk indexing.
+ *
+ * Spawns N worker threads (N = CPU cores - 1, clamped to [1, 4]) that share
+ * the file-parsing load during startup/full reindex passes. Each worker runs
+ * `parser-worker-script.ts`, reads files from disk, parses them via
+ * `parseFileContent`, and returns `FileSymbols[]`.
+ *
+ * The main thread distributes files in round-robin batches, collects results,
+ * and performs all SQLite writes via `commitBatch`. Workers never touch the
+ * database — single-writer WAL semantics are preserved.
+ *
+ * The pool is created lazily on first use and terminated on shutdown. Workers
+ * are `unref()`'d so they don't keep the process alive.
+ */
+import type { FileSymbols, SymbolLang } from './schema.js';
+/** Minimum number of files before the pool is worth spawning. */
+export declare const WORKER_POOL_THRESHOLD = 500;
+export declare class ParserWorkerPool {
+    private readonly maxWorkers;
+    private workers;
+    private nextBatchId;
+    private pending;
+    private creating;
+    private unavailable;
+    constructor(maxWorkers?: number);
+    /**
+     * True if the pool is available for use. Returns false when:
+     * - Worker threads aren't supported (sandbox, exotic runtime)
+     * - The built worker script can't be found
+     * - Pool creation was attempted and failed
+     */
+    isAvailable(): boolean;
+    /**
+     * Lazily create the worker pool. Returns true if the pool is ready, false
+     * if it's unavailable (caller should fall back to inline parsing).
+     */
+    ensureReady(): Promise<boolean>;
+    /**
+     * Parse files in parallel across the worker pool. Returns a flat
+     * `FileSymbols[]` in completion order (caller sorts if needed).
+     *
+     * Content is pre-read by the main thread (for the content-hash check)
+     * and passed to workers to avoid a second disk read. Files are
+     * distributed round-robin across workers.
+     */
+    parseFiles(files: ReadonlyArray<{
+        file: string;
+        content: string;
+        lang: SymbolLang;
+    }>): Promise<FileSymbols[]>;
+    /** Shut down all workers. Safe to call multiple times. */
+    shutdown(): Promise<void>;
+    private handleMessage;
+    private handleError;
+}
+/**
+ * Lazily-created process-wide singleton. Returns null when worker threads
+ * are unavailable (sandbox, exotic runtime) or the compiled worker script
+ * can't be found — callers must fall back to inline parsing in that case.
+ */
+export declare function getParserPool(): ParserWorkerPool | null;
+//# sourceMappingURL=parser-worker-pool.d.ts.map

package/dist/codebase-index/parser-worker-script.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Parser worker entry point for P5's multi-threaded parser pool.
+ *
+ * Each worker in the pool runs this script. It receives batches of files,
+ * reads them from disk, parses them via the existing `parseFileContent`
+ * dispatch (which routes to tree-sitter, the TS compiler, etc.), and returns
+ * the parsed `FileSymbols[]` back to the main thread.
+ *
+ * Workers never touch SQLite — the main thread owns all DB writes via
+ * `commitBatch`. This keeps the WAL writer single-threaded and avoids
+ * cross-thread `node:sqlite` issues.
+ *
+ * The worker terminates cleanly when it receives a `{ type: 'shutdown' }`
+ * message. If the parent port closes unexpectedly, the worker exits.
+ */
+import type { FileSymbols } from './schema.js';
+import type { SymbolLang } from './schema.js';
+export interface ParserWorkerRequest {
+    type: 'parse';
+    id: number;
+    /** Content is pre-read by the main thread for the hash check; passed here
+     *  to avoid a second disk read in the worker. */
+    files: ReadonlyArray<{
+        file: string;
+        content: string;
+        lang: SymbolLang;
+    }>;
+}
+export interface ParserWorkerResponse {
+    type: 'result';
+    id: number;
+    results: FileSymbols[];
+    errors: ReadonlyArray<{
+        file: string;
+        error: string;
+    }>;
+}
+export interface ParserWorkerShutdown {
+    type: 'shutdown';
+}
+export type ParserWorkerInbound = ParserWorkerRequest | ParserWorkerShutdown;
+//# sourceMappingURL=parser-worker-script.d.ts.map

package/dist/codebase-index/project-server-protocol.d.ts

@@ -13,6 +13,8 @@ export interface ProjectIndexServerInfo {
     indexDir: string;
     endpoint: string;
     startedAt: string;
+    /** P6: server can switch to binary MessagePack framing after handshake. */
+    binarySupported?: boolean;
 }
 export interface ProjectIndexServerActivity {
     indexing: boolean;