@mxalbert/context-mode 2.0.0

package/build/runPool.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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/runPool.js

@@ -0,0 +1,51 @@
+/**
+ * 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/runtime.d.ts

@@ -0,0 +1,71 @@
+export declare function isAllowlistedShell(shellPath: string): boolean;
+export type Language = "javascript" | "typescript" | "python" | "shell" | "ruby" | "go" | "rust" | "php" | "perl" | "r" | "elixir" | "csharp";
+export interface RuntimeInfo {
+    command: string;
+    available: boolean;
+    version: string;
+    preferred: boolean;
+}
+export interface RuntimeMap {
+    javascript: string | null;
+    typescript: string | null;
+    python: string | null;
+    shell: string;
+    ruby: string | null;
+    go: string | null;
+    rust: string | null;
+    php: string | null;
+    perl: string | null;
+    r: string | null;
+    elixir: string | null;
+    csharp: string | null;
+}
+/**
+ * Resolve the JavaScript runtime used by PolyglotExecutor.
+ *
+ * PR #190 (f69b0d2) made `process.execPath` the default so snap-Node
+ * envs would not re-invoke the snap wrapper via PATH. That assumed
+ * `process.execPath` always points at a JS runtime — true on Node,
+ * tsx, and snap-Node, but FALSE when context-mode runs in-process
+ * inside a bun-compiled self-contained binary (OpenCode, Kilo, …).
+ * In those hosts, `process.execPath` resolves to `opencode.exe` /
+ * `opencode` (NOT node), and spawning that with a `.js` argument
+ * triggers the yargs "Failed to change directory" error (#731).
+ *
+ * Fix: gate `process.execPath` on the existing `JS_RUNTIMES`
+ * allowlist (single source of truth — same set used by
+ * `buildNodeCommand()` in src/adapters/types.ts since PR #708). When
+ * the execPath basename is not a known JS runtime, fall back to a
+ * PATH-resolved `node`. If neither is reachable, return `null` and
+ * let ctx_doctor surface an actionable error.
+ *
+ * The cross-OS guard is the allowlist itself — NOT a `win32` check.
+ * OpenCode ships self-contained binaries on macOS and Linux too,
+ * and the bug reproduces identically there.
+ */
+export declare function resolveJavascriptRuntime(bun: string | null, deps?: {
+    execPath?: string;
+    commandExists?: (cmd: string) => boolean;
+}): string | null;
+export declare function detectRuntimes(): RuntimeMap;
+export declare function hasBunRuntime(): boolean;
+/**
+ * Resolved JS runtime for hook spawn commands. `path` is the absolute (or
+ * bare-name on POSIX where PATH resolution is reliable) binary path.
+ * `isBun` is true only when we successfully probed a Bun ≥1.0 install.
+ */
+export interface HookRuntime {
+    readonly path: string;
+    readonly isBun: boolean;
+}
+/**
+ * Reset the hook-runtime resolution cache. Test-only — production code
+ * should never call this. Vitest mocks `node:child_process`/`node:fs`
+ * per-test, so the per-process cache from a previous test would otherwise
+ * mask the mock and yield the host's real bun/node detection result.
+ */
+export declare function resetHookRuntimeCache(): void;
+export declare function resolveHookRuntime(): HookRuntime;
+export declare function getRuntimeSummary(runtimes: RuntimeMap): string;
+export declare function getAvailableLanguages(runtimes: RuntimeMap): Language[];
+export declare function buildCommand(runtimes: RuntimeMap, language: Language, filePath: string): string[];