td-barrage 0.1.2 → 0.1.3

package/README.md

@@ -90,6 +90,7 @@ Options:
 - `--cwd <path>`: working directory for tasks that do not set their own
 - `--results-dir <path>`: where result files are expected, default `.queue/results`
 - `--dry-run`: print the topological plan (one id per line) and exit without running
+- `--no-commit`: skip the git commit stage that otherwise runs after each successful task
 - `--json`: emit newline-delimited JSON events instead of human output
 
 Exit codes:
@@ -128,6 +129,14 @@ stays easy to pipe.
 
 `result_json` succeeds when the configured JSON file parses and contains `"status": "ok"`.
 
+## Commits
+
+After a task passes its success check, the orchestrator stages everything with
+`git add -A` and commits it in the task's cwd with the message `feat: <id>`. A
+clean working tree (nothing to commit) is a quiet no-op, and a commit that fails
+outright is reported as a warning but never flips the task back to failed — the
+task already succeeded. Pass `--no-commit` to skip this stage entirely.
+
 ## Recovery
 
 On startup, any task persisted as `running` is reset to `pending`, annotated in `recoveryNotes`, and retried. The `attempts` counter is preserved, so a task that crashed mid-run still counts that attempt.

package/dist/git.d.ts

@@ -0,0 +1,28 @@
+export interface GitExecResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+/** Runs `git <args>` in `cwd` and resolves with its exit code and output (never rejects). */
+export type GitExec = (args: string[], cwd: string) => Promise<GitExecResult>;
+export interface CommitInput {
+    cwd: string;
+    message: string;
+}
+export interface CommitResult {
+    /** "committed" — a new commit was made; "nothing" — clean tree, nothing staged; "error" — git failed. */
+    status: "committed" | "nothing" | "error";
+    /** Short SHA of the new commit, when status is "committed". */
+    commit?: string;
+    /** Human-readable detail, primarily for the "error" status. */
+    detail?: string;
+}
+export interface GitCommitter {
+    commit(input: CommitInput): Promise<CommitResult>;
+}
+/**
+ * Stages every change with `git add -A` and commits it. A clean working tree
+ * (nothing to commit) is reported as "nothing" rather than an error, since a
+ * task can legitimately succeed without touching tracked files.
+ */
+export declare function createGitCommitter(exec?: GitExec): GitCommitter;

package/dist/git.js

@@ -0,0 +1,47 @@
+import { execFile } from "node:child_process";
+/**
+ * Stages every change with `git add -A` and commits it. A clean working tree
+ * (nothing to commit) is reported as "nothing" rather than an error, since a
+ * task can legitimately succeed without touching tracked files.
+ */
+export function createGitCommitter(exec = defaultExec) {
+    return {
+        async commit({ cwd, message }) {
+            const add = await exec(["add", "-A"], cwd);
+            if (add.code !== 0) {
+                return { status: "error", detail: detailOf(add) || "git add failed" };
+            }
+            const commit = await exec(["commit", "-m", message], cwd);
+            if (commit.code === 0) {
+                const head = await exec(["rev-parse", "--short", "HEAD"], cwd);
+                return { status: "committed", commit: head.code === 0 ? head.stdout.trim() : undefined };
+            }
+            if (isNothingToCommit(commit)) {
+                return { status: "nothing" };
+            }
+            return { status: "error", detail: detailOf(commit) || `git commit exited with code ${commit.code}` };
+        },
+    };
+}
+// `git commit` exits non-zero with this phrasing when the index has no staged
+// changes — a no-op we treat as success, not failure.
+function isNothingToCommit(result) {
+    const text = `${result.stdout}\n${result.stderr}`;
+    return /nothing to commit|no changes added to commit|nothing added to commit/i.test(text);
+}
+function detailOf(result) {
+    return (result.stderr.trim() || result.stdout.trim()).split("\n")[0] ?? "";
+}
+const defaultExec = (args, cwd) => new Promise((resolve) => {
+    execFile("git", args, { cwd }, (error, stdout, stderr) => {
+        if (!error) {
+            resolve({ code: 0, stdout: String(stdout), stderr: String(stderr) });
+            return;
+        }
+        // A process that exits non-zero surfaces a numeric `code`; a spawn
+        // failure (e.g. git not installed) surfaces a string code like "ENOENT",
+        // in which case we fall back to 1 and lean on the error message.
+        const code = typeof error.code === "number" ? error.code : 1;
+        resolve({ code, stdout: String(stdout), stderr: String(stderr) || error.message });
+    });
+});

package/dist/index.d.ts

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

package/dist/index.js

@@ -7,6 +7,7 @@ import { pathToFileURL } from "node:url";
 import { parseArgs } from "node:util";
 import { createOpenCodeClient } from "./client.js";
 import { topologicalOrder } from "./deps.js";
+import { createGitCommitter } from "./git.js";
 import { createLogger } from "./log.js";
 import { defaultResultsDir, runOrchestrator } from "./orchestrator.js";
 import { loadTasks } from "./tasks.js";
@@ -23,6 +24,7 @@ export async function main(argv = process.argv.slice(2), deps = {}) {
             "results-dir": { type: "string" },
             json: { type: "boolean", default: false },
             "dry-run": { type: "boolean", default: false },
+            "no-commit": { type: "boolean", default: false },
             verbose: { type: "boolean", short: "v", default: false },
             quiet: { type: "boolean", short: "q", default: false },
             color: { type: "boolean", default: false },
@@ -62,6 +64,7 @@ export async function main(argv = process.argv.slice(2), deps = {}) {
             return 0;
         }
         const client = deps.client ?? (await createOpenCodeClient());
+        const git = parsed.values["no-commit"] ? undefined : deps.git ?? createGitCommitter();
         const summary = await runOrchestrator({
             tasksPath,
             client,
@@ -70,6 +73,7 @@ export async function main(argv = process.argv.slice(2), deps = {}) {
             cwd,
             resultsDir,
             maxAttempts,
+            git,
             version: readVersion(),
         });
         return summary.failed > 0 || summary.blocked > 0 ? 1 : 0;

package/dist/log.d.ts

@@ -36,6 +36,17 @@ export type LogEvent = {
     durationMs: number;
     done: number;
     total: number;
+} | {
+    type: "task_committed";
+    taskId: string;
+    message: string;
+    status: "committed" | "nothing";
+    commit?: string;
+} | {
+    type: "task_commit_failed";
+    taskId: string;
+    message: string;
+    detail: string;
 } | {
     type: "task_failed";
     taskId: string;

package/dist/log.js

@@ -8,6 +8,8 @@ const EVENT_LEVEL = {
     task_session: 2,
     task_check: 2,
     task_done: 1,
+    task_committed: 1,
+    task_commit_failed: 0,
     task_failed: 0,
     task_blocked: 0,
     summary: 0,
@@ -105,6 +107,16 @@ function createPrettyRenderer(output, s) {
                     clack.success(msg, opts);
                 return;
             }
+            case "task_committed": {
+                const detail = event.status === "nothing"
+                    ? s.dim("no changes to commit")
+                    : `${s.dim("committed")} ${event.commit ? s.cyan(event.commit) : ""} ${s.dim(event.message)}`;
+                clack.message(detail, opts);
+                return;
+            }
+            case "task_commit_failed":
+                clack.warn(`${s.bold(event.taskId)} ${s.yellow("commit failed")} ${s.dim(event.detail)}`, opts);
+                return;
             case "task_failed": {
                 const tail = event.willRetry
                     ? s.yellow(`will retry (attempt ${event.attempt}/${event.maxAttempts})`)
@@ -181,6 +193,12 @@ function formatHuman(event, s) {
             return s.dim(`  ↳ check ${event.strategy} → ${event.ok ? "ok" : "fail"}`);
         case "task_done":
             return `${s.green("✔")} ${s.bold(event.taskId)} ${s.green("done")} ${s.dim(`in ${fmtDuration(event.durationMs)} · ${event.done}/${event.total} complete`)}`;
+        case "task_committed":
+            return event.status === "nothing"
+                ? s.dim("  ↳ no changes to commit")
+                : s.dim(`  ↳ committed ${event.commit ? `${event.commit} ` : ""}${event.message}`);
+        case "task_commit_failed":
+            return `${s.yellow("⚠")} ${s.bold(event.taskId)} ${s.yellow("commit failed")} ${s.dim(event.detail)}`;
         case "task_failed": {
             const tail = event.willRetry
                 ? s.yellow(`will retry (attempt ${event.attempt}/${event.maxAttempts})`)

package/dist/orchestrator.d.ts

@@ -1,3 +1,4 @@
+import type { GitCommitter } from "./git.js";
 import { type SuccessFs } from "./success.js";
 import { type TaskFs } from "./tasks.js";
 import type { Logger } from "./log.js";
@@ -34,6 +35,10 @@ export interface OrchestratorOptions {
     maxAttempts?: number;
     timeoutMs?: number;
     version?: string;
+    /** Commit the working tree after each task succeeds. Defaults to true. */
+    commit?: boolean;
+    /** Commits the working tree after each successful task. Omit to skip committing entirely. */
+    git?: GitCommitter;
 }
 export interface Summary {
     total: number;

package/dist/orchestrator.js

@@ -128,6 +128,38 @@ async function runTask(task, tasks, options, queueFs) {
         });
     }
     await saveTasks(options.tasksPath, { tasks }, queueFs);
+    // Commit the work the task produced. This runs after the save above so the
+    // commit captures the task file in its final "done" state. A failed commit
+    // is reported but never flips the task back to failed — the task itself
+    // already passed its success check. Skipped when no committer is wired in.
+    if (task.status === "done" && options.commit !== false && options.git) {
+        await commitTask(task, options.git, options.log, cwd);
+    }
+}
+async function commitTask(task, committer, log, cwd) {
+    const message = `feat: ${task.id}`;
+    try {
+        const result = await committer.commit({ cwd, message });
+        if (result.status === "error") {
+            log?.event({ type: "task_commit_failed", taskId: task.id, message, detail: result.detail ?? "" });
+            return;
+        }
+        log?.event({
+            type: "task_committed",
+            taskId: task.id,
+            message,
+            status: result.status,
+            commit: result.commit,
+        });
+    }
+    catch (error) {
+        log?.event({
+            type: "task_commit_failed",
+            taskId: task.id,
+            message,
+            detail: error instanceof Error ? error.message : String(error),
+        });
+    }
 }
 function countDone(tasks) {
     return tasks.reduce((total, task) => (task.status === "done" ? total + 1 : total), 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "td-barrage",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "TypeScript queue runner that loads a JSON task file, resolves dependencies, runs tasks through the OpenCode SDK, and resumes interrupted work.",
   "type": "module",
   "engines": {