dw-sdlc 0.21.0 → 0.21.1

package/dist/worker/origin.js

@@ -1,10 +1,9 @@
 // Brings the clone's view of origin's default branch up to date before a Worker starts: Claude Code's
 // `--worktree` branches from the cached `origin/<default>` and fetches it only when the clone has gone a
 // day without a fetch, so a Worker could otherwise begin from a ref that is hours or days behind.
-import { exec, SLOW_LIMIT_MS, TimedOut } from "../exec.js";
-import { repositoryFreeEnv } from "../git-env.js";
-import { asked } from "../working-tree.js";
-import { Refusal } from "./herdr.js";
+import { CannotRun } from "../cannot-run.js";
+import { SLOW_LIMIT_MS, TimedOut } from "../exec.js";
+import { asked, git } from "../git.js";
 const REMOTE_HEAD = "refs/remotes/origin/HEAD";
 const PREFIX = "refs/remotes/origin/";
 /** The branch to fetch: the one origin/HEAD names, else `baseBranch` of the config; undefined when neither names one. */
@@ -17,7 +16,7 @@ function defaultBranch(root, baseBranch) {
 }
 /**
  * Fetches origin's default branch, or every branch of origin when no default is known, into the remote-tracking
- * refs at `root`; a clone with no origin has nothing to fetch and is left alone. Throws a `Refusal` when the
+ * refs at `root`; a clone with no origin has nothing to fetch and is left alone. Throws `CannotRun` when the
  * fetch fails, since a Worker started on a stale base is the fault this prevents.
  */
 export function freshenOrigin(root, baseBranch) {
@@ -25,19 +24,18 @@ export function freshenOrigin(root, baseBranch) {
         return;
     }
     const branch = defaultBranch(root, baseBranch);
-    const args = ["-C", root, "fetch", "--quiet", "origin", ...(branch === undefined ? [] : [branch])];
+    const args = ["fetch", "--quiet", "origin", ...(branch === undefined ? [] : [branch])];
     const fetched = `git fetch origin${branch === undefined ? "" : ` ${branch}`}`;
-    const stale = (why) => new Refusal(`${fetched} failed, so the Worker would begin from a stale base: ${why}`, "check the network and the access to origin; when origin/HEAD names a branch the remote no longer has, " +
+    const stale = (why) => new CannotRun(`${fetched} failed, so the Worker would begin from a stale base: ${why}`, "check the network and the access to origin; when origin/HEAD names a branch the remote no longer has, " +
         "run `git remote set-head origin --auto`; then start the Worker again");
     let result;
     try {
-        result = exec("git", args, { env: repositoryFreeEnv(), limitMs: SLOW_LIMIT_MS });
+        result = git(root, args, { limitMs: SLOW_LIMIT_MS });
     }
     catch (error) {
         throw error instanceof TimedOut ? stale(error.message) : error;
     }
-    if (result.status !== 0) {
-        const said = result.stderr.split("\n").find((line) => line.trim() !== "");
-        throw stale(said?.trim() ?? `exited ${result.status ?? "on a signal"}`);
+    if ("error" in result) {
+        throw stale(result.said);
     }
 }

package/dist/worker/tabs.js

@@ -1,17 +1,19 @@
 // The tab of a Worker's terminal in the herdr window: `hc run` with a `herdr.space` label opens one that herdr
 // numbers, and `herdr-app` names it.
 import { setTimeout as sleep } from "node:timers/promises";
+import { CannotRun } from "../cannot-run.js";
+import { whyFailed } from "../exec.js";
 import { isObject, parseObject } from "../json-text.js";
-import { call, Refusal, said } from "./herdr.js";
+import { herdrApp } from "./herdr.js";
 /** The tabs `herdr-app ls` shows, each with the addresses of its terminals. */
 function tabsOf() {
-    const listed = call("herdr-app", ["ls"]);
+    const listed = herdrApp(["ls"]);
     if (listed.status !== 0) {
-        throw new Refusal(`herdr-app ls failed: ${said(listed)}`);
+        throw new CannotRun(`herdr-app ls failed: ${whyFailed(listed)}`);
     }
     const parsed = parseObject(listed.stdout);
     if (parsed === undefined) {
-        throw new Refusal("herdr-app ls answered no JSON object");
+        throw new CannotRun("herdr-app ls answered no JSON object");
     }
     const spaces = Array.isArray(parsed.spaces) ? parsed.spaces : [];
     return spaces
@@ -47,14 +49,16 @@ export async function nameTab(address, name, boundSeconds) {
         if (tab === undefined) {
             return { kept: `the tab of ${address} is not in herdr-app ls within ${boundSeconds} s, so it keeps herdr's name` };
         }
-        const renamed = call("herdr-app", ["do", "tab.rename", "--id", tab.id, "--name", name]);
+        const renamed = herdrApp(["do", "tab.rename", "--id", tab.id, "--name", name]);
         if (renamed.status !== 0) {
-            return { kept: `herdr-app could not rename the tab of ${address}: ${errorOf(renamed.stdout) ?? said(renamed)}` };
+            return {
+                kept: `herdr-app could not rename the tab of ${address}: ${errorOf(renamed.stdout) ?? whyFailed(renamed)}`
+            };
         }
         return "renamed";
     }
     catch (error) {
-        if (error instanceof Refusal) {
+        if (error instanceof CannotRun) {
             return { kept: `the tab of ${address} keeps herdr's name: ${error.message}` };
         }
         throw error;

package/dist/working-tree.d.ts

@@ -1,11 +1,3 @@
-/** `git <args>` in the repository at `root`, on `index` when given. */
-export declare function git(root: string, args: string[], index?: string): {
-    out: string;
-} | {
-    error: string;
-};
-/** `git <args>` at `root`, or undefined when it exits non-zero as a question answered no. */
-export declare function asked(root: string, args: string[]): string | undefined;
 /** The tree of the checkout at `root` and its git dir, or why it has none. */
 export declare function workingTree(root: string): {
     tree: string;

package/dist/working-tree.js

@@ -3,25 +3,8 @@
 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 = exec("git", ["-C", root, ...args], {
-        env: index === undefined ? env : { ...env, GIT_INDEX_FILE: index }
-    });
-    if (result.status === 0) {
-        return { out: result.stdout.trim() };
-    }
-    const reason = result.error?.message ?? result.stderr.split("\n").find((line) => line.trim() !== "");
-    return { error: `git ${args[0] ?? ""}: ${reason?.trim() ?? `exited ${result.status ?? "on a signal"}`}` };
-}
-/** `git <args>` at `root`, or undefined when it exits non-zero as a question answered no. */
-export function asked(root, args) {
-    const result = git(root, args);
-    return "out" in result ? result.out : undefined;
-}
+import { messageOf } from "./cannot-run.js";
+import { git } from "./git.js";
 /**
  * The tree `git write-tree` hashes from a copy of the index after `git add -A` on it: the copy keeps the
  * stat cache, so only what changed is read again; identical content survives a commit, an amend or a
@@ -39,8 +22,9 @@ function treeOf(root, gitDir) {
             copyFileSync(real, index);
             utimesSync(index, atime, mtime);
         }
-        const added = git(root, ["add", "-A"], index);
-        return "error" in added ? added : git(root, ["write-tree"], index);
+        const scratchIndex = { env: { GIT_INDEX_FILE: index } };
+        const added = git(root, ["add", "-A"], scratchIndex);
+        return "error" in added ? added : git(root, ["write-tree"], scratchIndex);
     }
     finally {
         rmSync(scratch, { recursive: true, force: true });
@@ -57,6 +41,6 @@ export function workingTree(root) {
         return "error" in tree ? tree : { tree: tree.out, gitDir: gitDir.out };
     }
     catch (error) {
-        return { error: error instanceof Error ? error.message : String(error) };
+        return { error: messageOf(error) };
     }
 }

package/dist/worktree-lock.js

@@ -2,7 +2,7 @@
 // `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 { exec } from "./exec.js";
-import { shellLine } from "./pr/decide.js";
+import { shellLine } from "./shell-line.js";
 const CLAUDE_LOCK = /^claude session .* \(pid (?<pid>\d{1,10}) start (?<start>.+)\)$/;
 const MAX_PID = 2 ** 31 - 1;
 const squeezed = (text) => text.trim().replace(/\s+/g, " ");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dw-sdlc",
-  "version": "0.21.0",
+  "version": "0.21.1",
   "description": "The Gate and the agentic config behind the sdlc Claude Code plugin: a bin with the Gate and its Checks, the setup, the doctor, the Sync of References, the Ship script that drives a pull request to merged, the Sweep, and Lead and Worker sessions in herdr; the resolver of a repository's .ai/agentic.config.json layers and its JSON Schema.",
   "license": "MIT",
   "repository": {

package/dist/git-env.d.ts

@@ -1,2 +0,0 @@
-/** This process's environment without the variables that tie git to one repository, as git lists them. */
-export declare function repositoryFreeEnv(): NodeJS.ProcessEnv;

package/dist/git-env.js

@@ -1,10 +0,0 @@
-// The environment a git command runs under to find its repository from its own directory, as a git
-// hook's GIT_DIR or GIT_INDEX_FILE would otherwise aim it at the hook's repository.
-import { exec } from "./exec.js";
-let repositoryVars;
-/** This process's environment without the variables that tie git to one repository, as git lists them. */
-export function repositoryFreeEnv() {
-    repositoryVars ??= new Set((exec("git", ["rev-parse", "--local-env-vars"]).stdout ?? "").split("\n").filter(Boolean));
-    const vars = repositoryVars;
-    return Object.fromEntries(Object.entries(process.env).filter(([name]) => !vars.has(name)));
-}