@gevezex/gdt 0.2.0

package/dist/backends/herdr.js

@@ -0,0 +1,286 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, openSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { ROLES } from "../config.js";
+import { which } from "../doctor.js";
+import { alive, writeJsonAtomic } from "../state.js";
+/** The pane names this backend manages, in creation order (AC-2: without a supervisor pane, only roles). */
+function paneNames(opts) {
+    return opts.supervisorPane ? ["supervisor", ...ROLES] : [...ROLES];
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function shellQuote(text) {
+    return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+function bin(env) {
+    const path = which("herdr", env);
+    if (path === null)
+        throw new Error("herdr: not found on PATH");
+    return path;
+}
+/** Runs one herdr command and returns its raw stdout. Throws on a non-zero exit. */
+function call(args, opts) {
+    const result = spawnSync(bin(opts.env), args, { cwd: opts.root, env: opts.env, encoding: "utf8" });
+    if (result.status !== 0) {
+        const reason = (result.stderr ?? "").trim() || (result.stdout ?? "").trim() || `herdr exited with ${result.status ?? result.signal}`;
+        throw new Error(`herdr ${args.slice(0, 2).join(" ")}: ${reason}`);
+    }
+    return result.stdout ?? "";
+}
+/** Runs `pane run`, which prints nothing on success. */
+function callVoid(args, opts) {
+    call(args, opts);
+}
+/** Runs `pane report-agent`, which prints nothing on success. Throws on a non-zero exit. */
+function reportAgent(opts, paneId, label, state) {
+    const args = ["pane", "report-agent", "--source", "gdt", "--agent", label, "--state", state, paneId];
+    const result = spawnSync(bin(opts.env), args, { cwd: opts.root, env: opts.env, encoding: "utf8" });
+    if (result.status !== 0) {
+        const reason = (result.stderr ?? "").trim() || (result.stdout ?? "").trim() || `herdr exited with ${result.status ?? result.signal}`;
+        throw new Error(`herdr pane report-agent: ${reason}`);
+    }
+}
+/** Parses the `{ "result": ... }` envelope; a herdr `error` becomes a thrown Error. */
+function resultOf(out, command) {
+    let data;
+    try {
+        data = JSON.parse(out);
+    }
+    catch {
+        throw new Error(`herdr ${command}: unexpected output`);
+    }
+    if (!isRecord(data))
+        throw new Error(`herdr ${command}: unexpected output`);
+    if (isRecord(data.error))
+        throw new Error(`herdr: ${String(data.error.message ?? data.error.code ?? "unknown error")}`);
+    if (!isRecord(data.result))
+        throw new Error(`herdr ${command}: no result`);
+    return data.result;
+}
+function workspaceList(opts) {
+    const result = resultOf(call(["workspace", "list"], opts), "workspace list");
+    const list = result.workspaces;
+    if (!Array.isArray(list))
+        return [];
+    return list.filter((w) => isRecord(w) && typeof w.workspace_id === "string");
+}
+function paneIds(opts, workspaceId) {
+    const result = resultOf(call(["pane", "list", "--workspace", workspaceId], opts), "pane list");
+    const list = result.panes;
+    if (!Array.isArray(list))
+        return [];
+    return list.flatMap((p) => (isRecord(p) && typeof p.pane_id === "string" ? [p.pane_id] : []));
+}
+function createWorkspace(opts) {
+    const label = `gdt-${opts.issue}`;
+    const result = resultOf(call(["workspace", "create", "--cwd", opts.root, "--label", label, "--no-focus"], opts), "workspace create");
+    const workspace = result.workspace;
+    const rootPane = result.root_pane;
+    if (!isRecord(workspace) || typeof workspace.workspace_id !== "string" || !isRecord(rootPane) || typeof rootPane.pane_id !== "string") {
+        throw new Error("herdr workspace create did not return a workspace and root pane");
+    }
+    return { workspace_id: workspace.workspace_id, root_pane: rootPane.pane_id };
+}
+/** Splits `anchor` to the right; `ratio` is the share of the width that `anchor` keeps. */
+function splitPane(opts, anchor, ratio) {
+    const result = resultOf(call(["pane", "split", anchor, "--direction", "right", "--ratio", ratio.toFixed(4), "--no-focus"], opts), "pane split");
+    const pane = result.pane;
+    if (!isRecord(pane) || typeof pane.pane_id !== "string")
+        throw new Error("herdr pane split did not return a pane id");
+    return pane.pane_id;
+}
+function readPanes(file) {
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writePanes(file, state) {
+    writeJsonAtomic(file, state);
+}
+function roleTitle(role, agent, state) {
+    return role === "supervisor" ? `supervisor · ${state}` : `${role} · ${agent} · ${state}`;
+}
+/**
+ * One herdr workspace per issue, with four panes for supervisor, developer, tester and reviewer.
+ * Panes are reused across `start` calls; their ids live in `panes.json` so a restarted process can
+ * find them. Verified against herdr 0.9.1 in the default session.
+ */
+export function herdr(opts) {
+    let warnedMissing = false;
+    const findPane = (name) => {
+        const state = readPanes(opts.panesFile);
+        const id = state?.panes[name]?.pane_id;
+        return id === undefined || id === "" ? null : id;
+    };
+    const rename = (name, title) => {
+        if (warnedMissing)
+            return;
+        const paneId = findPane(name);
+        if (paneId === null) {
+            warnedMissing = true;
+            return;
+        }
+        call(["pane", "rename", paneId, title], opts);
+    };
+    return {
+        ensureWorkspace() {
+            mkdirSync(opts.pidDir, { recursive: true });
+            const known = readPanes(opts.panesFile);
+            const list = workspaceList(opts);
+            let workspaceId = known !== null && list.some((w) => w.workspace_id === known.workspace_id) ? known.workspace_id : undefined;
+            if (workspaceId === undefined) {
+                const existing = list.find((w) => w.label === `gdt-${opts.issue}`);
+                if (existing !== undefined)
+                    workspaceId = existing.workspace_id;
+                else
+                    workspaceId = createWorkspace(opts).workspace_id;
+            }
+            const live = new Set(paneIds(opts, workspaceId));
+            // AC-4: a supervisor pane from an earlier run (while `supervisor_pane` was true) is closed; its
+            // entry never enters the new panes.json, so no role can adopt the pane.
+            if (!opts.supervisorPane && known?.workspace_id === workspaceId) {
+                const leftover = known.panes.supervisor;
+                if (leftover !== undefined && live.has(leftover.pane_id)) {
+                    call(["pane", "close", leftover.pane_id], opts);
+                    live.delete(leftover.pane_id);
+                }
+            }
+            const names = paneNames(opts);
+            const mapping = {};
+            for (const name of names) {
+                const record = known?.workspace_id === workspaceId ? known.panes[name] : undefined;
+                if (record !== undefined && live.has(record.pane_id))
+                    mapping[name] = record;
+            }
+            // Adopt panes that a previous run left behind (for example after its panes.json was removed).
+            const claimed = new Set(Object.values(mapping).flatMap((p) => (p === undefined ? [] : [p.pane_id])));
+            const free = [...live].filter((id) => !claimed.has(id));
+            for (const name of names) {
+                if (mapping[name] === undefined) {
+                    const reuse = free.shift();
+                    if (reuse !== undefined)
+                        mapping[name] = { pane_id: reuse };
+                }
+            }
+            // Each new pane is split off the right of the previous one, so panes run left to right in
+            // `names` order. The anchor keeps 1/(panes still to fill), which makes a new workspace's panes
+            // equally wide.
+            const first = Object.values(mapping).flatMap((p) => (p === undefined ? [] : [p.pane_id])).find((id) => id !== "");
+            let previous;
+            names.forEach((name, index) => {
+                const record = mapping[name];
+                if (record !== undefined) {
+                    previous = record.pane_id;
+                    return;
+                }
+                const anchor = previous ?? first;
+                if (anchor === undefined)
+                    throw new Error(`herdr workspace ${workspaceId} has no pane to split`);
+                previous = splitPane(opts, anchor, 1 / (names.length - index + 1));
+                mapping[name] = { pane_id: previous };
+            });
+            writePanes(opts.panesFile, { workspace_id: workspaceId, panes: mapping });
+            if (opts.supervisorPane)
+                rename("supervisor", roleTitle("supervisor", "", "starting"));
+            for (const role of ROLES)
+                rename(role, roleTitle(role, opts.agents[role], "WAITING"));
+        },
+        spawnPane(name, argv) {
+            // AC-3: without a supervisor pane the supervisor is a detached process whose output is its log.
+            if (name === "supervisor" && !opts.supervisorPane)
+                return spawnDetached(opts, "supervisor", argv);
+            const state = readPanes(opts.panesFile);
+            const paneId = state?.panes[name]?.pane_id;
+            if (state === null || paneId === undefined || paneId === "")
+                throw new Error(`herdr: no pane named ${name}`);
+            if (argv.length === 0)
+                throw new Error("spawnPane: empty argv");
+            mkdirSync(opts.pidDir, { recursive: true });
+            const pidFile = join(opts.pidDir, name);
+            rmSync(pidFile, { force: true });
+            // The wrapper shell writes its pid and then becomes the gdt process, so the pid stays valid
+            // while the pane's own shell remains for the next command.
+            const inner = `echo $$ > ${shellQuote(pidFile)}; exec ${argv.map(shellQuote).join(" ")}`;
+            callVoid(["pane", "run", paneId, `sh -c ${shellQuote(inner)}`], opts);
+            const pid = waitForPid(pidFile);
+            state.panes[name] = { pane_id: paneId, pid };
+            writePanes(opts.panesFile, state);
+            return pid;
+        },
+        setTitle(name, title) {
+            // AC-6: without a supervisor pane there is no title to set for the supervisor.
+            if (name === "supervisor" && !opts.supervisorPane)
+                return;
+            rename(name, title);
+        },
+        reportState(name, state) {
+            // AC-6: without a supervisor pane no supervisor state is reported to herdr.
+            if (name === "supervisor" && !opts.supervisorPane)
+                return;
+            const paneId = findPane(name);
+            if (paneId === null)
+                throw new Error(`herdr: no pane named ${name}`);
+            // AC-4/AC-5: the role's agent is the label, the supervisor reports as `gdt`.
+            const label = name === "supervisor" ? "gdt" : opts.agents[name];
+            reportAgent(opts, paneId, label, state);
+        },
+        alive: (handle) => alive(handle),
+        attach: () => {
+            const state = readPanes(opts.panesFile);
+            // `workspace focus` only switches the server's focused workspace; plain `herdr` attaches the terminal.
+            return state === null ? "herdr" : `herdr workspace focus ${state.workspace_id} && herdr (workspace gdt-${opts.issue})`;
+        },
+        close(handle) {
+            try {
+                process.kill(handle, "SIGTERM");
+            }
+            catch {
+                // Already gone.
+            }
+            for (let waited = 0; waited < 5000 && alive(handle); waited += 50)
+                sleepSync(50);
+            if (alive(handle)) {
+                try {
+                    process.kill(handle, "SIGKILL");
+                }
+                catch {
+                    // Already gone.
+                }
+            }
+        },
+    };
+}
+/** Starts `argv` detached with stdout and stderr in `logs/<name>.log`, like the headless backend. */
+function spawnDetached(opts, name, argv) {
+    const [command, ...args] = argv;
+    if (command === undefined)
+        throw new Error("spawnPane: empty argv");
+    mkdirSync(opts.logs, { recursive: true });
+    const out = openSync(join(opts.logs, `${name}.log`), "a");
+    const child = spawn(command, args, { cwd: opts.root, env: opts.env, detached: true, stdio: ["ignore", out, out] });
+    child.unref();
+    if (child.pid === undefined)
+        throw new Error(`could not start ${name}`);
+    return child.pid;
+}
+function waitForPid(file) {
+    for (let waited = 0; waited < 5000; waited += 50) {
+        if (existsSync(file)) {
+            const pid = Number(readFileSync(file, "utf8").trim());
+            if (Number.isInteger(pid) && pid > 0)
+                return pid;
+        }
+        sleepSync(50);
+    }
+    throw new Error(`herdr pane did not report its process id (${file})`);
+}

package/dist/backends/index.js

@@ -0,0 +1,20 @@
+import { ROLES } from "../config.js";
+import { headless } from "./headless.js";
+import { herdr } from "./herdr.js";
+/** The backend selected by `workflow.terminal` for issue `issue` in `p.root`. */
+export function backendFor(config, root, issue, env, p) {
+    if (config.workflow.terminal === "herdr") {
+        const agents = Object.fromEntries(ROLES.map((role) => [role, config.roles[role].agent]));
+        return herdr({
+            root,
+            issue,
+            env,
+            panesFile: p.panes,
+            pidDir: p.pids,
+            logs: p.logs,
+            agents,
+            supervisorPane: config.workflow.supervisor_pane,
+        });
+    }
+    return headless(p.logs, root, env);
+}