context-mode 1.0.168 → 2.0.0-next.5

package/build/concurrency/runPool.d.ts

@@ -1,36 +0,0 @@
-/**
- * Generic in-flight-capped worker pool.
- *
- * Used by:
- *   - runBatchCommands (ctx_batch_execute parallel branch)
- *   - runBatchFetch    (ctx_fetch_and_index batch path)
- *
- * Returns Promise.allSettled-style results so one job's throw cannot
- * strand siblings. Caller maps fulfilled/rejected per index. Output
- * order is preserved by input index (not completion order).
- *
- * Designed to be the SINGLE concurrency primitive for the project —
- * all "run N independent operations with at most M in flight" needs
- * route here. Avoids the worker-pool copy-paste flagged in the
- * concurrency PRD architectural review (finding G).
- */
-export interface PoolJob<T> {
-    run(): Promise<T>;
-}
-export interface RunPoolOptions {
-    /** Hard concurrency cap (1-N). Auto-clamped to job count. */
-    concurrency: number;
-    /** Optional: also clamp by `os.cpus().length` (memory-pressure safety). Default false. */
-    capByCpuCount?: boolean;
-    /** Optional: per-settled callback (e.g. for progress reporting / metrics). */
-    onSettled?: (idx: number, result: PromiseSettledResult<unknown>) => void;
-}
-export interface RunPoolResult<T> {
-    /** Per-index settled result, ordered by input index. */
-    settled: PromiseSettledResult<T>[];
-    /** Concurrency actually used after all caps applied. */
-    effectiveConcurrency: number;
-    /** True when effectiveConcurrency < requested concurrency. */
-    capped: boolean;
-}
-export declare function runPool<T>(jobs: PoolJob<T>[], opts: RunPoolOptions): Promise<RunPoolResult<T>>;

package/build/concurrency/runPool.js

@@ -1,51 +0,0 @@
-/**
- * Generic in-flight-capped worker pool.
- *
- * Used by:
- *   - runBatchCommands (ctx_batch_execute parallel branch)
- *   - runBatchFetch    (ctx_fetch_and_index batch path)
- *
- * Returns Promise.allSettled-style results so one job's throw cannot
- * strand siblings. Caller maps fulfilled/rejected per index. Output
- * order is preserved by input index (not completion order).
- *
- * Designed to be the SINGLE concurrency primitive for the project —
- * all "run N independent operations with at most M in flight" needs
- * route here. Avoids the worker-pool copy-paste flagged in the
- * concurrency PRD architectural review (finding G).
- */
-import { cpus } from "node:os";
-export async function runPool(jobs, opts) {
-    const { concurrency, capByCpuCount = false, onSettled } = opts;
-    if (jobs.length === 0) {
-        return { settled: [], effectiveConcurrency: 0, capped: false };
-    }
-    const requested = Math.max(1, concurrency);
-    const cpuCap = capByCpuCount ? Math.max(1, cpus().length) : requested;
-    const effectiveConcurrency = Math.min(requested, cpuCap, jobs.length);
-    const capped = effectiveConcurrency < requested;
-    const settled = new Array(jobs.length);
-    let nextIdx = 0;
-    async function worker() {
-        while (true) {
-            const idx = nextIdx++;
-            if (idx >= jobs.length)
-                return;
-            try {
-                const value = await jobs[idx].run();
-                settled[idx] = { status: "fulfilled", value };
-            }
-            catch (err) {
-                settled[idx] = { status: "rejected", reason: err };
-            }
-            onSettled?.(idx, settled[idx]);
-        }
-    }
-    const workers = [];
-    for (let w = 0; w < effectiveConcurrency; w++)
-        workers.push(worker());
-    // allSettled defends against any promise rejection escaping a worker
-    // (the worker already swallows its own errors, but this is belt-and-braces).
-    await Promise.allSettled(workers);
-    return { settled, effectiveConcurrency, capped };
-}

package/build/db-base.d.ts

@@ -1,179 +0,0 @@
-/**
- * db-base — Reusable SQLite infrastructure for context-mode packages.
- *
- * Provides lazy-loading of better-sqlite3, WAL pragma setup, prepared
- * statement caching interface, and DB file cleanup helpers. Both
- * ContentStore and SessionDB build on top of these primitives.
- */
-import type DatabaseConstructor from "better-sqlite3";
-import type { Database as DatabaseInstance } from "better-sqlite3";
-/**
- * Explicit interface for cached prepared statements that accept varying
- * parameter counts. better-sqlite3's generic `Statement` collapses under
- * `ReturnType` to a single-param signature, so we define our own.
- */
-export interface PreparedStatement {
-    run(...params: unknown[]): {
-        changes: number;
-        lastInsertRowid: number | bigint;
-    };
-    get(...params: unknown[]): unknown;
-    all(...params: unknown[]): unknown[];
-    iterate(...params: unknown[]): IterableIterator<unknown>;
-}
-/**
- * Wraps a bun:sqlite Database to provide better-sqlite3-compatible API.
- * Bridges: .pragma(), multi-statement .exec(), .get() null→undefined.
- */
-export declare class BunSQLiteAdapter {
-    #private;
-    constructor(rawDb: any);
-    pragma(source: string): any;
-    exec(sql: string): any;
-    prepare(sql: string): any;
-    transaction(fn: (...args: any[]) => any): any;
-    close(): void;
-}
-/**
- * Wraps node:sqlite's DatabaseSync to provide better-sqlite3-compatible API.
- * Bridges: .pragma(), .transaction(). Everything else is passthrough.
- * Eliminates native addon SIGSEGV on Linux (nodejs/node#62515).
- */
-export declare class NodeSQLiteAdapter {
-    #private;
-    constructor(rawDb: any);
-    pragma(source: string): any;
-    exec(sql: string): any;
-    prepare(sql: string): any;
-    transaction(fn: (...args: any[]) => any): any;
-    close(): void;
-}
-/**
- * Probe whether the supplied node:sqlite DatabaseSync constructor links a
- * SQLite build that includes the FTS5 module. Some Node.js Linux builds
- * (e.g. v22.14.0 on Ubuntu) ship node:sqlite without FTS5 even though the
- * import succeeds, which silently breaks ctx_search/ctx_batch_execute and
- * the doctor's FTS5 check (issue #461).
- *
- * Returns true only when a `CREATE VIRTUAL TABLE … USING fts5(x)` statement
- * succeeds. Always returns false on any failure (constructor throw, missing
- * module, etc.) so the caller can fall through to better-sqlite3, whose
- * bundled SQLite always ships with FTS5.
- */
-export declare function nodeSqliteHasFts5(DatabaseSync: any): boolean;
-/**
- * Returns true when the current runtime ships a built-in SQLite binding:
- * - Bun has `bun:sqlite` always
- * - Node has `node:sqlite` since 22.5 (no flag since 22.13)
- *
- * Mirrors the helper in hooks/ensure-deps.mjs:61. Exported so the platform
- * gate in loadDatabase() can be unit-tested without spawning a child
- * process. `versionsOverride` and `bunOverride` are injection points for
- * tests — production callers pass nothing.
- *
- * Widening the gate from `process.platform === "linux"` to this helper is
- * required for Node 26 on macOS arm64 (#551): Node 26 removed
- * `info.This()` from V8 PropertyCallbackInfo, breaking better-sqlite3
- * 12.9.0's native compile. Using node:sqlite sidesteps the native addon
- * entirely on every platform that has it.
- */
-export declare function hasModernSqlite(versionsOverride?: NodeJS.ProcessVersions, bunOverride?: unknown): boolean;
-/**
- * Lazy-load the SQLite driver for the current runtime.
- * Bun → bun:sqlite via BunSQLiteAdapter (issue #45).
- * Modern Node (>= 22.5) → node:sqlite via NodeSQLiteAdapter when it ships FTS5 (#228, #461, #551).
- * Other Node (or modern Node without FTS5) → better-sqlite3 (native addon).
- */
-export declare function loadDatabase(): typeof DatabaseConstructor;
-/**
- * Apply WAL mode and NORMAL synchronous pragma to a database instance.
- * Should be called immediately after opening a new database connection.
- *
- * WAL mode provides:
- * - Concurrent readers while a write is in progress
- * - Dramatically faster writes (no full-page sync on each commit)
- * NORMAL synchronous is safe under WAL and avoids an extra fsync per
- * transaction.
- */
-export declare function applyWALPragmas(db: DatabaseInstance): void;
-/**
- * Remove orphaned WAL/SHM files when the main DB file doesn't exist.
- * On Windows, stale -wal/-shm files from crashed processes cause
- * "file is not a database" errors when creating a fresh DB.
- */
-export declare function cleanOrphanedWALFiles(dbPath: string): void;
-/**
- * Delete all three SQLite files for a given db path (main, WAL, SHM).
- * Silently ignores individual deletion errors so a partial cleanup
- * does not abort the rest.
- */
-export declare function deleteDBFiles(dbPath: string): void;
-/**
- * Safely close a database connection. Swallows errors so callers can
- * always call this in a finally/cleanup path without try/catch.
- */
-export declare function closeDB(db: DatabaseInstance): void;
-/**
- * Return the default per-process DB path for context-mode databases.
- * Uses the OS temp directory and embeds the current PID so multiple
- * server instances never share a file.
- */
-export declare function defaultDBPath(prefix?: string): string;
-/**
- * Retry a DB operation with exponential backoff on SQLITE_BUSY errors.
- * Catches errors containing "SQLITE_BUSY" or "database is locked" and
- * retries up to 3 times with delays: 100ms, 500ms, 2000ms.
- * If all retries fail, throws a descriptive error.
- * Pass custom delays for testing (e.g., [0, 0, 0] to skip waits).
- */
-export declare function withRetry<T>(fn: () => T, delays?: number[]): T;
-/**
- * Detect SQLite corruption errors that warrant a rename-and-recreate.
- * Matches SQLITE_CORRUPT, SQLITE_NOTADB, and their human-readable equivalents.
- */
-export declare function isSQLiteCorruptionError(msg: string): boolean;
-/**
- * Rename a corrupt DB and its WAL/SHM files so a fresh DB can be created.
- * Best-effort — individual rename failures are silently ignored.
- */
-export declare function renameCorruptDB(dbPath: string): void;
-export declare abstract class SQLiteBase {
-    #private;
-    /**
-     * Open (or create) a SQLite DB at `dbPath`.
-     *
-     * v1.0.130 — multi-writer is the contract. ALL SQLiteBase consumers
-     * (SessionDB, ContentStore) may open the same on-disk dbPath from
-     * multiple processes simultaneously — that is the legitimate multi-
-     * window UX shape and the WAL handles it natively. SQLITE_BUSY on
-     * write contention is absorbed by `withRetry()` below (busy_timeout
-     * = 30000ms inside `new Database(...)`).
-     *
-     * v1.0.128 introduced a single-writer guard here as a defense against
-     * #560. That defense was an over-correction — the actual root causes
-     * of #560 were #559 (zombie MCP child accumulation) and #561 (Pi
-     * misdetection writing to the wrong DB path), both fixed in v1.0.128
-     * + v1.0.129. The single-writer guard broke legitimate multi-window
-     * users; v1.0.130 rolls it out. See
-     * docs/adr/0001-sessiondb-multi-writer.md and the v1.0.130 INVARIANT
-     * block in tests/util/db-base-platform-gate.test.ts for the
-     * regression-proof anchor (source-pin + behavioural).
-     */
-    constructor(dbPath: string);
-    /** Called once after WAL pragmas are applied. Subclasses run CREATE TABLE/VIRTUAL TABLE here. */
-    protected abstract initSchema(): void;
-    /** Called once after schema init. Subclasses compile and cache their prepared statements here. */
-    protected abstract prepareStatements(): void;
-    /** Raw database instance — available to subclasses only. */
-    protected get db(): DatabaseInstance;
-    /** The path this database was opened from. */
-    get dbPath(): string;
-    /** Close the database connection without deleting files. */
-    close(): void;
-    protected withRetry<T>(fn: () => T): T;
-    /**
-     * Close the connection and delete all associated DB files (main, WAL, SHM).
-     * Call on process exit or at end of session lifecycle.
-     */
-    cleanup(): void;
-}