dw-sdlc 0.13.0 → 0.15.0

package/dist/sweep-trees.js

@@ -0,0 +1,72 @@
+// What a Sweep reads of a repository's linked worktrees: where each lies, what it has checked out, its lock,
+// the files that hold it and the operation paused in it.
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { exec } from "./exec.js";
+import { repositoryFreeEnv } from "./git-env.js";
+import { CannotRun } from "./pr/read.js";
+import { asked, git } from "./working-tree.js";
+/** `git <args>` at `root`, or a stop naming its problem. */
+export function must(root, args) {
+    const result = git(root, args);
+    if ("error" in result) {
+        throw new CannotRun(result.error, "check the repository with git status");
+    }
+    return result.out;
+}
+/** Every worktree of the repository, the main checkout first. */
+export function worktreesOf(root) {
+    const trees = [];
+    let tree;
+    for (const line of must(root, ["worktree", "list", "--porcelain"]).split("\n")) {
+        if (line.startsWith("worktree ")) {
+            tree = { path: line.slice("worktree ".length), head: "", branch: undefined, lock: undefined, prunable: false };
+            trees.push(tree);
+        }
+        else if (tree !== undefined && line.startsWith("HEAD ")) {
+            tree.head = line.slice("HEAD ".length);
+        }
+        else if (tree !== undefined && line.startsWith("branch refs/heads/")) {
+            tree.branch = line.slice("branch refs/heads/".length);
+        }
+        else if (tree !== undefined && (line === "locked" || line.startsWith("locked "))) {
+            tree.lock = line.slice("locked".length).trim();
+        }
+        else if (tree !== undefined && (line === "prunable" || line.startsWith("prunable "))) {
+            tree.prunable = true;
+        }
+    }
+    return trees;
+}
+/** The files `git status` lists in the worktree at `path`, ignored ones aside, or why it cannot be read. */
+export function dirtyFiles(path) {
+    const args = ["-C", path, "status", "--porcelain=v1", "-z", "--untracked-files=all"];
+    const result = exec("git", args, { env: repositoryFreeEnv() });
+    if (result.status !== 0) {
+        const said = result.stderr.split("\n").find((line) => line.trim() !== "");
+        return { error: `git status: ${said?.trim() ?? `exited ${result.status ?? "on a signal"}`}` };
+    }
+    const files = [];
+    const entries = result.stdout.split("\0").filter((entry) => entry !== "");
+    for (let index = 0; index < entries.length; index++) {
+        const entry = entries[index] ?? "";
+        files.push(entry.slice(3));
+        if (entry.startsWith("R") || entry.startsWith("C")) {
+            index++;
+        }
+    }
+    return files;
+}
+const OPERATIONS = [
+    ["rebase-merge", "rebase"],
+    ["rebase-apply", "rebase or am"],
+    ["MERGE_HEAD", "merge"],
+    ["CHERRY_PICK_HEAD", "cherry-pick"],
+    ["REVERT_HEAD", "revert"],
+    ["BISECT_LOG", "bisect"]
+];
+/** The operation paused in the worktree at `path`: its git dir holds the state git resumes it from. */
+export function pausedOperation(path) {
+    const dir = asked(path, ["rev-parse", "--absolute-git-dir"]);
+    return dir === undefined ? undefined : OPERATIONS.find(([file]) => existsSync(join(dir, file)))?.[1];
+}

package/dist/worker/herdr.js

@@ -1,6 +1,6 @@
 // What the `worker` commands share: `hc` and `herdr-app` as child processes, the Lead a command acts for,
 // and the Workers herdr lists for it.
-import { spawnSync } from "node:child_process";
+import { exec, TimedOut } from "../exec.js";
 import { isObject, parseObject } from "../json-text.js";
 /** What stops a `worker` command before it acts: exit 2, the problem and, when there is one, its remedy. */
 export class Refusal extends Error {
@@ -15,9 +15,21 @@ export function said(called) {
     const line = `${called.stderr}\n${called.stdout}`.split("\n").find((text) => text.trim() !== "");
     return line?.trim() ?? `exited ${called.status}`;
 }
+/** `tool args` as a child process; past its limit it stops the command as any failed call does. */
+function reach(tool, args) {
+    try {
+        return exec(tool, args);
+    }
+    catch (error) {
+        if (error instanceof TimedOut) {
+            throw new Refusal(error.message, "check herdr is responding, then call again");
+        }
+        throw error;
+    }
+}
 /** `tool args` as a child process; a tool that is not on PATH stops the command. */
 export function call(tool, args) {
-    const result = spawnSync(tool, args, { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+    const result = reach(tool, args);
     if (result.error !== undefined) {
         if ("code" in result.error && result.error.code === "ENOENT") {
             throw new Refusal(`${tool} is not on PATH`, "install herdr, or run the command in a terminal herdr started");

package/dist/working-tree.js

@@ -1,18 +1,15 @@
 // A checkout's working tree as git would commit it: the tree of every file git tracks or would track,
 // hashed on a copy of the index. The Gate's cache fingerprints it and the watch for Drift records it.
-import { spawnSync } from "node:child_process";
 import { copyFileSync, existsSync, mkdtempSync, rmSync, statSync, utimesSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { exec } from "./exec.js";
 import { repositoryFreeEnv } from "./git-env.js";
 /** `git <args>` in the repository at `root`, on `index` when given. */
 export function git(root, args, index) {
     const env = repositoryFreeEnv();
-    const result = spawnSync("git", ["-C", root, ...args], {
-        encoding: "utf8",
-        env: index === undefined ? env : { ...env, GIT_INDEX_FILE: index },
-        // A Step that writes thousands of files makes a diff-tree past the default 1 MiB.
-        maxBuffer: 64 * 1024 * 1024
+    const result = exec("git", ["-C", root, ...args], {
+        env: index === undefined ? env : { ...env, GIT_INDEX_FILE: index }
     });
     if (result.status === 0) {
         return { out: result.stdout.trim() };

package/dist/worktree-lock.d.ts

@@ -4,12 +4,15 @@ export type StaleLock = {
     held: string;
     why: string;
 };
-export type LockVerdict = {
-    state: "none";
-} | StaleLock | {
+/** A lock that keeps the worktree; `pid` is the live process a Claude Code lock names. */
+export type LockStays = {
     state: "stays";
     reason: string;
     command: string | null;
+    pid?: number;
 };
+export type LockVerdict = {
+    state: "none";
+} | StaleLock | LockStays;
 /** What the lock of the worktree at `path`, held for `reason`, says about whether the Sweep may lift it. */
 export declare function lockVerdict(path: string, reason: string | undefined): LockVerdict;

package/dist/worktree-lock.js

@@ -1,7 +1,7 @@
 // What a worktree's lock means to a Sweep. Claude Code locks the worktree of a session with the reason
 // `claude session <name> (pid <N> start <time>)`, <time> as `ps -o lstart` writes it in UTC. Such a lock is
 // stale once no process N runs or N started at another time. Any other reason is the dev's to lift.
-import { spawnSync } from "node:child_process";
+import { exec } from "./exec.js";
 import { shellLine } from "./pr/decide.js";
 const CLAUDE_LOCK = /^claude session .* \(pid (?<pid>\d{1,10}) start (?<start>.+)\)$/;
 const MAX_PID = 2 ** 31 - 1;
@@ -22,7 +22,7 @@ function runningOf(pid) {
     const starts = [{ TZ: "UTC" }, {}]
         .map((zone) => {
         const env = { ...process.env, LC_ALL: "C", ...zone };
-        const result = spawnSync("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8", env });
+        const result = exec("ps", ["-o", "lstart=", "-p", String(pid)], { env });
         return result.status === 0 ? squeezed(result.stdout) : "";
     })
         .filter((start) => start !== "");
@@ -58,6 +58,7 @@ export function lockVerdict(path, reason) {
     return {
         state: "stays",
         reason: `locked by a live Claude Code session: pid ${pid} is running (${reason})`,
-        command: null
+        command: null,
+        pid
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dw-sdlc",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "The Gate and the agentic config of a repository: the dw-sdlc bin with the Gate, the setup, the doctor, the config check, the Sync and setup of References, and the Ship script that drives a pull request to merged; the resolver of the config's layers, its JSON Schema and the validator that reads it.",
   "license": "MIT",
   "repository": {