td-barrage 0.1.4 → 0.1.5

package/README.md

@@ -1,12 +1,12 @@
 # td-barrage
 
-A small TypeScript queue runner for OpenCode tasks. It loads a JSON task file, resolves dependencies, runs ready tasks through the OpenCode SDK, persists state after every transition, and resumes interrupted work on the next invocation.
+A persistent, dependency-aware task queue for the pi coding agent. It loads a JSON task file, runs ready tasks through pi, saves state after every transition, and resumes interrupted work on the next invocation.
 
 ## Requirements
 
-- Node.js 20.11 or newer
+- Node.js 22.19 or newer
 - npm
-- OpenCode available when running against a real server
+- pi authenticated with a model provider (`pi`, then `/login`), or a supported provider API key in the environment
 
 ## Install
 
@@ -62,7 +62,7 @@ Task files use a top-level `tasks` array. A bare array is also accepted when loa
 Supported task fields:
 
 - `id`: unique task id
-- `prompt`: prompt sent to OpenCode
+- `prompt`: prompt sent to pi
 - `dependsOn`: dependency ids
 - `status`: `pending`, `running`, `done`, `failed`, or `blocked`
 - `attempts`: persisted attempt counter
@@ -98,6 +98,13 @@ Exit codes:
 - `2`: CLI usage or missing task-file error
 - `75`: the run paused on a provider quota / rate-limit wall (see below)
 
+## Pi sessions
+
+Each task runs in its own in-memory pi agent session scoped to the task working
+directory. Barrage uses pi's existing authentication and model settings. Terminal
+provider errors from pi's final assistant state feed into the pause/resume flow
+below. Sessions are disposed after their task prompt settles.
+
 ## Pausing on quota / rate limits
 
 Running out of provider tokens is treated as a property of the run, not of any
@@ -111,12 +118,13 @@ task. When a prompt fails with a quota, rate-limit, or overload signal (HTTP
   same wall, and
 - exits `75` (`EX_TEMPFAIL`) with the reason on stderr.
 
-Because state is persisted atomically after every transition, resuming is just
-re-running the same command once tokens are back — work picks up where it left
-off, with no failed or blocked tasks recorded from the pause. The distinct exit
-code lets a wrapper or scheduler tell "try again later" apart from `1` ("something
-is broken"). A `Retry-After` header, when present, is surfaced as a suggested
-wait in the pause message.
+Because task state and workspace changes are persisted, resuming is just
+re-running the same command once tokens are back. The pending task starts a fresh
+in-memory pi session and can inspect the work already on disk; conversation
+history is not restored. No failed or blocked task is recorded for the pause.
+The distinct exit code lets a wrapper or scheduler tell "try again later" apart
+from `1` ("something is broken"). A `Retry-After` header, when present, is
+surfaced as a suggested wait in the pause message.
 
 ## Telemetry & output
 
@@ -128,7 +136,7 @@ are always reported, along with a closing summary and total elapsed time.
 
 Verbosity flags:
 
-- `--verbose, -v`: add per-step traces — the OpenCode session id and the
+- `--verbose, -v`: add per-step traces — the agent session id and the
   success-check result for every task
 - `--quiet, -q`: show only failures, blocks, and the final summary
 - `--timestamps`: prefix each line with a wall-clock time
@@ -176,16 +184,14 @@ Integration tests are excluded by default. Run them with:
 RUN_INTEGRATION=1 npm run test:integration
 ```
 
-Optional integration environment variables:
-
-- `OPENCODE_BIN`: OpenCode executable, default `opencode`
-- `OPENCODE_PORT`: server port, default `4096`
+The integration test runs real pi sessions using your configured authentication
+and model, so it may consume provider credits.
 
 ## Architecture
 
 The orchestrator accepts its dependencies as arguments:
 
-- `client`: OpenCode client seam
+- `client`: pi-compatible agent client seam
 - `fs`: filesystem seam
 - `clock`: timer seam for timeout tests
 - `log`: human or JSON event logger

package/dist/client.d.ts

@@ -1,11 +1,11 @@
-import type { OpenCodeClient } from "./orchestrator.js";
-export interface ClientOptions {
-    baseUrl?: string;
-    hostname?: string;
-    port?: number;
-    timeout?: number;
-    config?: unknown;
-}
-/** Imports an SDK module by specifier. Injectable so the export-selection logic is testable. */
+import type { CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
+import type { AgentClient } from "./orchestrator.js";
+/** Pi session settings Barrage allows callers to override. */
+export type PiClientOptions = Pick<CreateAgentSessionOptions, "model" | "tools" | "excludeTools" | "noTools" | "thinkingLevel">;
+/** Imports an SDK module by specifier. Injectable so the lazy wiring is testable. */
 export type SdkImport = (specifier: string) => Promise<unknown>;
-export declare function createOpenCodeClient(options?: ClientOptions, importSdk?: SdkImport): Promise<OpenCodeClient>;
+/**
+ * Builds an orchestrator client backed by pi (`@earendil-works/pi-coding-agent`).
+ * Each task gets a one-shot in-memory session scoped to its working directory.
+ */
+export declare function createPiClient(options?: PiClientOptions, importSdk?: SdkImport): Promise<AgentClient>;

package/dist/client.js

@@ -1,98 +1,81 @@
-// A `new Function` indirection keeps TypeScript from rewriting this dynamic
-// import into a require during transpile, so the specifier resolves at runtime.
-const defaultImport = new Function("specifier", "return import(specifier)");
-export async function createOpenCodeClient(options = {}, importSdk = defaultImport) {
-    const sdk = (await importSdkWithFallback(importSdk));
-    // A bare client only works when we already know where the server lives.
-    // Without a baseUrl it would issue requests against relative URLs like
-    // "/session?directory=..." and fail with "Failed to parse URL".
-    if (options.baseUrl && typeof sdk.createOpencodeClient === "function") {
-        return wrapSdkClient(sdk.createOpencodeClient({ ...options, throwOnError: true }));
+const defaultImport = (specifier) => import(specifier);
+const PI_SPECIFIER = "@earendil-works/pi-coding-agent";
+/**
+ * Builds an orchestrator client backed by pi (`@earendil-works/pi-coding-agent`).
+ * Each task gets a one-shot in-memory session scoped to its working directory.
+ */
+export async function createPiClient(options = {}, importSdk = defaultImport) {
+    const sdk = (await importSdk(PI_SPECIFIER));
+    if (typeof sdk.createAgentSession !== "function") {
+        throw new Error("Unable to locate the pi createAgentSession export.");
     }
-    // No baseUrl: spawn a local server and use the client it wires up for us.
-    if (typeof sdk.createOpencode === "function") {
-        const created = (await sdk.createOpencode(options));
-        if (created.client) {
-            registerServerShutdown(created.server);
-            return wrapSdkClient(created.client);
-        }
+    if (typeof sdk.SessionManager?.inMemory !== "function") {
+        throw new Error("Unable to locate the pi SessionManager.inMemory export.");
     }
-    if (typeof sdk.createOpencodeClient === "function") {
-        return wrapSdkClient(sdk.createOpencodeClient({ ...options, throwOnError: true }));
-    }
-    const Client = (sdk.OpenCode ?? sdk.Opencode ?? sdk.Client ?? sdk.default);
-    if (!Client) {
-        throw new Error("Unable to locate an OpenCode SDK client export.");
-    }
-    return new Client(options);
-}
-function registerServerShutdown(server) {
-    if (typeof server?.close !== "function")
-        return;
-    let closed = false;
-    const close = () => {
-        if (closed)
-            return;
-        closed = true;
-        server.close?.();
-    };
-    process.once("exit", close);
-    process.once("SIGINT", () => {
-        close();
-        process.exit(130);
-    });
-    process.once("SIGTERM", () => {
-        close();
-        process.exit(143);
-    });
-}
-function wrapSdkClient(client) {
-    const sessionDirs = new Map();
-    const raw = client;
+    const createAgentSession = sdk.createAgentSession;
+    const SessionManager = sdk.SessionManager;
+    const sessions = new Map();
     return {
         session: {
-            create: async (input) => {
-                const result = unwrapData(await raw.session.create({ directory: input.cwd, title: "orchestrator task" }));
-                const id = result.id;
-                if (typeof id !== "string" || id.length === 0) {
-                    throw new Error("OpenCode SDK session.create did not return a session id.");
-                }
-                sessionDirs.set(id, input.cwd);
-                return { id };
+            create: async ({ cwd }) => {
+                const sessionOptions = {
+                    ...options,
+                    cwd,
+                    sessionManager: SessionManager.inMemory(cwd),
+                };
+                const { session } = await createAgentSession(sessionOptions);
+                sessions.set(session.sessionId, session);
+                return { id: session.sessionId };
             },
             prompt: async (sessionId, input) => {
-                const directory = sessionDirs.get(sessionId) ?? process.cwd();
-                const abort = async () => {
-                    await raw.session.abort?.({ sessionID: sessionId, directory });
-                };
-                if (input.signal?.aborted)
-                    await abort();
-                input.signal?.addEventListener("abort", abort, { once: true });
+                const session = sessions.get(sessionId);
+                if (!session)
+                    throw new Error(`Unknown pi session: ${sessionId}`);
                 try {
-                    return await raw.session.prompt({
-                        sessionID: sessionId,
-                        directory,
-                        parts: [{ type: "text", text: input.prompt }],
-                    }, { signal: input.signal });
+                    return await runPrompt(session, input.prompt, input.signal);
                 }
                 finally {
-                    input.signal?.removeEventListener("abort", abort);
+                    sessions.delete(sessionId);
+                    // Pi documents dispose() as best-effort cleanup, and its implementation
+                    // deliberately does not throw. Keep that guarantee at the adapter seam.
+                    try {
+                        session.dispose();
+                    }
+                    catch {
+                        // Cleanup must not replace the prompt result or provider error.
+                    }
                 }
             },
         },
     };
 }
-function unwrapData(value) {
-    if (value && typeof value === "object" && "data" in value) {
-        return value.data;
-    }
-    return value;
-}
-async function importSdkWithFallback(importSdk) {
+async function runPrompt(session, prompt, signal) {
+    // Aborting an idle Pi session is a no-op, so never start work that its caller
+    // has already cancelled.
+    if (signal?.aborted)
+        throw abortError(signal);
+    const abort = () => {
+        void session.abort().catch(() => {
+            // The timeout/cancellation error belongs to the caller. An abort cleanup
+            // failure must not become an unhandled rejection or mask that error.
+        });
+    };
+    signal?.addEventListener("abort", abort, { once: true });
     try {
-        return await importSdk("@opencode-ai/sdk/v2");
+        await session.prompt(prompt);
+    }
+    finally {
+        signal?.removeEventListener("abort", abort);
     }
-    catch {
-        return importSdk("@opencode-ai/sdk");
+    // Pi encodes provider/runtime failures in the terminal assistant message and
+    // resolves prompt(). Its state exposes only the final error, after Pi's own
+    // retry loop has settled, so successful retries are not misclassified.
+    if (session.state.errorMessage) {
+        throw new Error(session.state.errorMessage);
     }
 }
+function abortError(signal) {
+    if (signal.reason instanceof Error)
+        return signal.reason;
+    return new DOMException("The operation was aborted.", "AbortError");
+}

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import fs from "node:fs/promises";
 import { type GitCommitter } from "./git.js";
-import { type OpenCodeClient } from "./orchestrator.js";
+import { type AgentClient } from "./orchestrator.js";
 export interface MainDeps {
     fs?: typeof fs;
-    client?: OpenCodeClient;
+    client?: AgentClient;
     git?: GitCommitter;
     stdout?: Pick<NodeJS.WritableStream, "write">;
     stderr?: Pick<NodeJS.WritableStream, "write">;

package/dist/index.js

@@ -5,7 +5,7 @@ import { createRequire } from "node:module";
 import process from "node:process";
 import { pathToFileURL } from "node:url";
 import { parseArgs } from "node:util";
-import { createOpenCodeClient } from "./client.js";
+import { createPiClient } from "./client.js";
 import { topologicalOrder } from "./deps.js";
 import { createGitCommitter } from "./git.js";
 import { createLogger } from "./log.js";
@@ -61,7 +61,7 @@ export async function main(argv = process.argv.slice(2), deps = {}) {
             logger.event({ type: "dry_run", taskIds: ordered.map((task) => task.id) });
             return 0;
         }
-        const client = deps.client ?? (await createOpenCodeClient());
+        const client = deps.client ?? (await createPiClient());
         const git = parsed.values["no-commit"] ? undefined : deps.git ?? createGitCommitter();
         const summary = await runOrchestrator({
             tasksPath,

package/dist/orchestrator.d.ts

@@ -4,7 +4,7 @@ import { type TaskFs } from "./tasks.js";
 import type { Logger } from "./log.js";
 export declare const DEFAULT_TIMEOUT_MS: number;
 export declare const DEFAULT_MAX_ATTEMPTS = 2;
-export interface OpenCodeClient {
+export interface AgentClient {
     session: {
         create(input: {
             cwd: string;
@@ -26,7 +26,7 @@ export interface OrchestratorFs extends TaskFs, SuccessFs {
 }
 export interface OrchestratorOptions {
     tasksPath: string;
-    client: OpenCodeClient;
+    client: AgentClient;
     fs?: OrchestratorFs;
     clock?: Clock;
     log?: Logger;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "td-barrage",
-  "version": "0.1.4",
-  "description": "TypeScript queue runner that loads a JSON task file, resolves dependencies, runs tasks through the OpenCode SDK, and resumes interrupted work.",
+  "version": "0.1.5",
+  "description": "A persistent, dependency-aware task queue for the pi coding agent.",
   "type": "module",
   "engines": {
-    "node": ">=20.11"
+    "node": ">=22.19"
   },
   "bin": {
     "td-barrage": "dist/index.js"
@@ -24,7 +24,8 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "npm run clean && tsc -p tsconfig.json",
     "start": "node dist/index.js",
     "dev": "tsx src/index.ts",
     "test": "vitest run",
@@ -35,11 +36,11 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.4.0",
-    "@opencode-ai/sdk": "^1.15.10",
+    "@earendil-works/pi-coding-agent": "^0.85.1",
     "zod": "^3.25.0"
   },
   "devDependencies": {
-    "@types/node": "^20.11.0",
+    "@types/node": "^22.19.0",
     "tsx": "^4.19.0",
     "typescript": "^5.8.0",
     "vitest": "^3.1.0"

package/dist/server.d.ts

@@ -1,18 +0,0 @@
-import { spawn, type ChildProcess } from "node:child_process";
-export interface StartServerOptions {
-    command?: string;
-    args?: string[];
-    port: number;
-    host?: string;
-    timeoutMs?: number;
-    pollMs?: number;
-    spawnProcess?: typeof spawn;
-    portOpen?: (host: string, port: number) => Promise<boolean>;
-    sleep?: (ms: number) => Promise<void>;
-    now?: () => number;
-}
-export interface StopServerOptions {
-    graceMs?: number;
-}
-export declare function startServer(options: StartServerOptions): Promise<ChildProcess>;
-export declare function stopServer(child: Pick<ChildProcess, "kill" | "killed" | "exitCode" | "once">, options?: StopServerOptions): Promise<void>;

package/dist/server.js

@@ -1,64 +0,0 @@
-// Integration-test harness for standing up a real `opencode serve` at a known
-// port. Production does not use this: createOpenCodeClient (client.ts) lets the
-// SDK's createOpencode spawn its own ephemeral server. These helpers exist so the
-// integration test can connect a client to an explicit baseUrl.
-import { spawn } from "node:child_process";
-import net from "node:net";
-export async function startServer(options) {
-    const command = options.command ?? "opencode";
-    const args = options.args ?? ["serve", "--port", String(options.port)];
-    const host = options.host ?? "127.0.0.1";
-    const timeoutMs = options.timeoutMs ?? 30_000;
-    const pollMs = options.pollMs ?? 100;
-    const portOpen = options.portOpen ?? isPortOpen;
-    const wait = options.sleep ?? sleep;
-    const now = options.now ?? Date.now;
-    const child = (options.spawnProcess ?? spawn)(command, args, {
-        stdio: "ignore",
-        detached: false,
-    });
-    const startedAt = now();
-    while (now() - startedAt < timeoutMs) {
-        if (await portOpen(host, options.port))
-            return child;
-        if (child.exitCode !== null)
-            throw new Error(`Server exited before port ${options.port} opened.`);
-        await wait(pollMs);
-    }
-    child.kill("SIGTERM");
-    throw new Error(`Timed out waiting for ${host}:${options.port}.`);
-}
-export async function stopServer(child, options = {}) {
-    const graceMs = options.graceMs ?? 5_000;
-    if (child.exitCode !== null)
-        return;
-    child.kill("SIGTERM");
-    await new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-            if (child.exitCode === null)
-                child.kill("SIGKILL");
-            resolve();
-        }, graceMs);
-        child.once("exit", () => {
-            clearTimeout(timeout);
-            resolve();
-        });
-    });
-}
-async function isPortOpen(host, port) {
-    return new Promise((resolve) => {
-        const socket = net.createConnection({ host, port });
-        socket.once("connect", () => {
-            socket.destroy();
-            resolve(true);
-        });
-        socket.once("error", () => resolve(false));
-        socket.setTimeout(250, () => {
-            socket.destroy();
-            resolve(false);
-        });
-    });
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}