@gr8ful/spf 0.1.5 → 0.1.7

package/dist/test/watch.test.js

@@ -1,17 +1,15 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
+import path from "node:path";
 import { branchNameFor, claimNewWork, createWatchState, finishReviews, reconcileOrphans } from "../core/watch.js";
 /** In-memory fake — exactly the seam `provider.ts` exists for. */
 class FakeProvider {
     entries = new Map();
-    prs = new Map();
     ensureLabelsCalls = 0;
     transitions = [];
-    openedPrs = [];
     claimCalls = [];
-    nextPrNumber = 1000;
-    addIssue(number, title, state = "ready", marker = null) {
-        this.entries.set(number, { issue: { number, title, body: "", labels: [`spf:${state}`] }, state, marker });
+    addIssue(id, title, state = "ready", marker = null) {
+        this.entries.set(id, { issue: { id, title, body: "", labels: [`spf:${state}`] }, state, marker });
     }
     async ensureLabels() {
         this.ensureLabelsCalls++;
@@ -24,33 +22,39 @@ class FakeProvider {
         return [...this.entries.values()].filter((e) => e.state === state).map((e) => e.issue);
     }
     async claim(issue) {
-        this.claimCalls.push(issue.number);
-        const entry = this.entries.get(issue.number);
+        this.claimCalls.push(issue.id);
+        const entry = this.entries.get(issue.id);
         if (entry.state !== "ready")
             return false;
         entry.state = "working";
         return true;
     }
     async transition(issue, to, detail) {
-        this.entries.get(issue.number).state = to;
-        this.transitions.push({ number: issue.number, to, detail });
+        this.entries.get(issue.id).state = to;
+        this.transitions.push({ id: issue.id, to, detail });
     }
     async comment() { }
-    async openPr(issue, opts) {
+    async readMarker(issue) {
+        return this.entries.get(issue.id)?.marker ?? null;
+    }
+    async writeMarker(issue, marker) {
+        this.entries.get(issue.id).marker = marker;
+    }
+}
+/** In-memory fake `CodeHostProvider` — separate from `FakeProvider`, mirroring the real split. */
+class FakeCodeHost {
+    prs = new Map();
+    openedPrs = [];
+    nextPrNumber = 1000;
+    async openPr(opts) {
         const number = this.nextPrNumber++;
-        this.openedPrs.push({ issueNumber: issue.number, branch: opts.branch });
+        this.openedPrs.push({ title: opts.title, branch: opts.branch });
         this.prs.set(number, { merged: false, state: "open", ciStatus: "pending" });
         return { number, branch: opts.branch, url: `https://example.invalid/pr/${number}` };
     }
     async prStatus(pr) {
         return this.prs.get(pr.number) ?? { merged: false, state: "open", ciStatus: "pending" };
     }
-    async readMarker(issue) {
-        return this.entries.get(issue.number)?.marker ?? null;
-    }
-    async writeMarker(issue, marker) {
-        this.entries.get(issue.number).marker = marker;
-    }
 }
 function fakeGit(overrides = {}) {
     return {
@@ -77,9 +81,10 @@ function fakeGit(overrides = {}) {
         ...overrides,
     };
 }
-function makeDeps(provider, overrides = {}) {
+function makeDeps(provider, codeHost, overrides = {}) {
     return {
         provider,
+        codeHost,
         git: fakeGit(),
         worktreeGit: () => fakeGit({ diffFiles: () => ["src/index.ts"] }), // a real commit landed, by default
         labelPrefix: "spf",
@@ -87,6 +92,7 @@ function makeDeps(provider, overrides = {}) {
         baseBranch: "main",
         concurrency: 2,
         worktreesDir: "/tmp/spf-watch-test-worktrees",
+        linkDataDir: () => { },
         dryRun: false,
         runChain: async () => ({ accepted: true, adwId: "issue-1", detail: "" }),
         log: () => { },
@@ -102,63 +108,107 @@ async function waitUntil(predicate, timeoutMs = 2000) {
     }
 }
 test("branchNameFor: sanitizes a title into a safe branch name", () => {
-    assert.equal(branchNameFor({ number: 42, title: "Add a /health endpoint!!", body: "", labels: [] }), "spf-watch/42-add-a-health-endpoint");
-    assert.equal(branchNameFor({ number: 7, title: "", body: "", labels: [] }), "spf-watch/7-issue");
+    assert.equal(branchNameFor({ id: "42", title: "Add a /health endpoint!!", body: "", labels: [] }), "spf-watch/42-add-a-health-endpoint");
+    assert.equal(branchNameFor({ id: "7", title: "", body: "", labels: [] }), "spf-watch/7-issue");
+    assert.equal(branchNameFor({ id: "PROJ-123", title: "Fix the thing", body: "", labels: [] }), "spf-watch/PROJ-123-fix-the-thing");
+});
+test("claimNewWork: clears a stale worktree/branch from a killed prior attempt before creating a fresh one", async () => {
+    const provider = new FakeProvider();
+    provider.addIssue("2", "Retry me");
+    const codeHost = new FakeCodeHost();
+    const state = createWatchState();
+    const calls = [];
+    // Simulates a `spf watch` process killed mid-run for this exact issue: a
+    // real `git.worktreeAdd` would refuse outright with "fatal: a branch
+    // named '...' already exists" until the leftover branch is cleared.
+    let branchExists = true;
+    const deps = makeDeps(provider, codeHost, {
+        git: fakeGit({
+            worktreeRemove: (p) => calls.push(`remove:${p}`),
+            deleteLocalBranch: (n) => {
+                calls.push(`delete-branch:${n}`);
+                branchExists = false;
+            },
+            worktreeAdd: (p, b) => {
+                if (branchExists)
+                    throw new Error(`fatal: a branch named '${b}' already exists`);
+                calls.push(`add:${p}`);
+            },
+        }),
+    });
+    await claimNewWork(deps, state);
+    await waitUntil(() => state.inflight.size === 0);
+    const branchIdx = calls.findIndex((c) => c.startsWith("delete-branch:"));
+    const addIdx = calls.findIndex((c) => c.startsWith("add:"));
+    assert.ok(branchIdx !== -1 && addIdx !== -1 && branchIdx < addIdx, `expected the stale branch cleared before worktreeAdd, got: ${calls.join(", ")}`);
+    // The retry then succeeds normally, same as any other claim.
+    assert.deepEqual(provider.transitions.map((t) => t.to), ["review"]);
 });
 test("claimNewWork: claims a ready issue, runs the chain, opens a PR, and moves to review", async () => {
     const provider = new FakeProvider();
-    provider.addIssue(1, "Add a /health endpoint");
+    provider.addIssue("1", "Add a /health endpoint");
+    const codeHost = new FakeCodeHost();
     const state = createWatchState();
-    const deps = makeDeps(provider);
+    const linkedWorktrees = [];
+    const deps = makeDeps(provider, codeHost, { linkDataDir: (worktreePath) => linkedWorktrees.push(worktreePath) });
     await claimNewWork(deps, state);
     await waitUntil(() => state.inflight.size === 0);
-    assert.deepEqual(provider.claimCalls, [1]);
-    assert.equal(provider.openedPrs.length, 1);
-    assert.equal(provider.openedPrs[0].issueNumber, 1);
+    assert.deepEqual(provider.claimCalls, ["1"]);
+    assert.equal(codeHost.openedPrs.length, 1);
+    assert.match(codeHost.openedPrs[0].title, /^Add a \/health endpoint \(1\)/);
     assert.deepEqual(provider.transitions.map((t) => t.to), ["review"]);
-    assert.equal(provider.entries.get(1).marker?.pr, 1000);
+    assert.equal(provider.entries.get("1").marker?.pr, 1000);
+    // linkDataDir must run before the chain does — otherwise the run's own
+    // session/trace data resolves into the worktree's throwaway .spf/data
+    // instead of the main repo's persistent one (invisible in spf ui, and
+    // deleted along with the worktree on cleanup).
+    assert.deepEqual(linkedWorktrees, [path.join(deps.worktreesDir, "issue-1")]);
 });
 test("claimNewWork: a rejected chain run blocks the issue with the failure detail", async () => {
     const provider = new FakeProvider();
-    provider.addIssue(2, "Flaky feature");
+    provider.addIssue("2", "Flaky feature");
+    const codeHost = new FakeCodeHost();
     const state = createWatchState();
-    const deps = makeDeps(provider, {
+    const deps = makeDeps(provider, codeHost, {
         runChain: async () => ({ accepted: false, adwId: "issue-2", detail: "build-test failed at phase build" }),
     });
     await claimNewWork(deps, state);
     await waitUntil(() => state.inflight.size === 0);
-    assert.deepEqual(provider.transitions, [{ number: 2, to: "blocked", detail: "build-test failed at phase build" }]);
-    assert.equal(provider.openedPrs.length, 0);
+    assert.deepEqual(provider.transitions, [{ id: "2", to: "blocked", detail: "build-test failed at phase build" }]);
+    assert.equal(codeHost.openedPrs.length, 0);
 });
 test("claimNewWork: an accepted run with nothing committed also blocks, without opening a PR", async () => {
     const provider = new FakeProvider();
-    provider.addIssue(3, "No-op request");
+    provider.addIssue("3", "No-op request");
+    const codeHost = new FakeCodeHost();
     const state = createWatchState();
-    const deps = makeDeps(provider, { worktreeGit: () => fakeGit({ diffFiles: () => [] }) });
+    const deps = makeDeps(provider, codeHost, { worktreeGit: () => fakeGit({ diffFiles: () => [] }) });
     await claimNewWork(deps, state);
     await waitUntil(() => state.inflight.size === 0);
     assert.equal(provider.transitions[0]?.to, "blocked");
     assert.match(provider.transitions[0]?.detail ?? "", /no committed changes/);
-    assert.equal(provider.openedPrs.length, 0);
+    assert.equal(codeHost.openedPrs.length, 0);
 });
 test("claimNewWork: never claims more than the concurrency budget in one tick", async () => {
     const provider = new FakeProvider();
-    provider.addIssue(10, "one");
-    provider.addIssue(11, "two");
-    provider.addIssue(12, "three");
+    provider.addIssue("10", "one");
+    provider.addIssue("11", "two");
+    provider.addIssue("12", "three");
+    const codeHost = new FakeCodeHost();
     const state = createWatchState();
     // A runChain that never resolves keeps every claimed issue "inflight" for this assertion.
-    const deps = makeDeps(provider, { concurrency: 2, runChain: () => new Promise(() => { }) });
+    const deps = makeDeps(provider, codeHost, { concurrency: 2, runChain: () => new Promise(() => { }) });
     await claimNewWork(deps, state);
     assert.equal(state.inflight.size, 2);
     assert.equal(provider.claimCalls.length, 2);
 });
 test("claimNewWork: dry-run claims nothing and calls neither claim() nor runChain", async () => {
     const provider = new FakeProvider();
-    provider.addIssue(20, "dry run me");
+    provider.addIssue("20", "dry run me");
+    const codeHost = new FakeCodeHost();
     const state = createWatchState();
     let runChainCalled = false;
-    const deps = makeDeps(provider, {
+    const deps = makeDeps(provider, codeHost, {
         dryRun: true,
         runChain: async () => {
             runChainCalled = true;
@@ -168,60 +218,66 @@ test("claimNewWork: dry-run claims nothing and calls neither claim() nor runChai
     await claimNewWork(deps, state);
     assert.equal(provider.claimCalls.length, 0);
     assert.equal(runChainCalled, false);
-    assert.equal(provider.entries.get(20).state, "ready");
+    assert.equal(provider.entries.get("20").state, "ready");
 });
 test("reconcileOrphans: a working issue with an open PR in its marker resumes as review", async () => {
     const provider = new FakeProvider();
-    provider.addIssue(30, "orphaned mid-review", "working", { pr: 500, branch: "spf-watch/30-x" });
-    provider.prs.set(500, { merged: false, state: "open", ciStatus: "pending" });
+    provider.addIssue("30", "orphaned mid-review", "working", { pr: 500, branch: "spf-watch/30-x" });
+    const codeHost = new FakeCodeHost();
+    codeHost.prs.set(500, { merged: false, state: "open", ciStatus: "pending" });
     const state = createWatchState();
-    await reconcileOrphans(makeDeps(provider), state);
-    assert.deepEqual(provider.transitions, [{ number: 30, to: "review", detail: undefined }]);
+    await reconcileOrphans(makeDeps(provider, codeHost), state);
+    assert.deepEqual(provider.transitions, [{ id: "30", to: "review", detail: undefined }]);
 });
 test("reconcileOrphans: a working issue with no marker retries up to the cap, then blocks", async () => {
     const provider = new FakeProvider();
-    provider.addIssue(31, "orphaned, no marker", "working", null);
+    provider.addIssue("31", "orphaned, no marker", "working", null);
+    const codeHost = new FakeCodeHost();
     const state = createWatchState();
-    const deps = makeDeps(provider);
+    const deps = makeDeps(provider, codeHost);
     await reconcileOrphans(deps, state); // attempt 1 -> ready
-    assert.equal(provider.entries.get(31).state, "ready");
-    assert.equal(provider.entries.get(31).marker?.attempt, 1);
-    provider.entries.get(31).state = "working"; // simulate it getting re-claimed and orphaned again
+    assert.equal(provider.entries.get("31").state, "ready");
+    assert.equal(provider.entries.get("31").marker?.attempt, 1);
+    provider.entries.get("31").state = "working"; // simulate it getting re-claimed and orphaned again
     await reconcileOrphans(deps, state); // attempt 2 -> ready
-    assert.equal(provider.entries.get(31).state, "ready");
-    provider.entries.get(31).state = "working";
+    assert.equal(provider.entries.get("31").state, "ready");
+    provider.entries.get("31").state = "working";
     await reconcileOrphans(deps, state); // attempt 3 exceeds MAX_ORPHAN_ATTEMPTS (2) -> blocked
-    assert.equal(provider.entries.get(31).state, "blocked");
+    assert.equal(provider.entries.get("31").state, "blocked");
     assert.match(provider.transitions.at(-1)?.detail ?? "", /Gave up after 2 orphaned attempts/);
 });
 test("reconcileOrphans: skips issues this process is already tracking as in-flight", async () => {
     const provider = new FakeProvider();
-    provider.addIssue(32, "actually still running", "working", null);
+    provider.addIssue("32", "actually still running", "working", null);
+    const codeHost = new FakeCodeHost();
     const state = createWatchState();
-    state.inflight.add(32);
-    await reconcileOrphans(makeDeps(provider), state);
+    state.inflight.add("32");
+    await reconcileOrphans(makeDeps(provider, codeHost), state);
     assert.equal(provider.transitions.length, 0, "an in-flight issue must not be treated as orphaned");
 });
 test("finishReviews: a merged PR moves the issue to done", async () => {
     const provider = new FakeProvider();
-    provider.addIssue(40, "shipped", "review", { pr: 600, branch: "spf-watch/40-x" });
-    provider.prs.set(600, { merged: true, state: "closed", ciStatus: "success" });
-    await finishReviews(makeDeps(provider));
-    assert.deepEqual(provider.transitions, [{ number: 40, to: "done", detail: undefined }]);
+    provider.addIssue("40", "shipped", "review", { pr: 600, branch: "spf-watch/40-x" });
+    const codeHost = new FakeCodeHost();
+    codeHost.prs.set(600, { merged: true, state: "closed", ciStatus: "success" });
+    await finishReviews(makeDeps(provider, codeHost));
+    assert.deepEqual(provider.transitions, [{ id: "40", to: "done", detail: undefined }]);
 });
 test("finishReviews: a closed-without-merging PR blocks the issue", async () => {
     const provider = new FakeProvider();
-    provider.addIssue(41, "rejected", "review", { pr: 601, branch: "spf-watch/41-x" });
-    provider.prs.set(601, { merged: false, state: "closed", ciStatus: "failure" });
-    await finishReviews(makeDeps(provider));
+    provider.addIssue("41", "rejected", "review", { pr: 601, branch: "spf-watch/41-x" });
+    const codeHost = new FakeCodeHost();
+    codeHost.prs.set(601, { merged: false, state: "closed", ciStatus: "failure" });
+    await finishReviews(makeDeps(provider, codeHost));
     assert.equal(provider.transitions[0]?.to, "blocked");
     assert.match(provider.transitions[0]?.detail ?? "", /closed without merging/);
 });
 test("finishReviews: a still-open PR leaves the issue in review", async () => {
     const provider = new FakeProvider();
-    provider.addIssue(42, "still cooking", "review", { pr: 602, branch: "spf-watch/42-x" });
-    provider.prs.set(602, { merged: false, state: "open", ciStatus: "pending" });
-    await finishReviews(makeDeps(provider));
+    provider.addIssue("42", "still cooking", "review", { pr: 602, branch: "spf-watch/42-x" });
+    const codeHost = new FakeCodeHost();
+    codeHost.prs.set(602, { merged: false, state: "open", ciStatus: "pending" });
+    await finishReviews(makeDeps(provider, codeHost));
     assert.equal(provider.transitions.length, 0);
-    assert.equal(provider.entries.get(42).state, "review");
+    assert.equal(provider.entries.get("42").state, "review");
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gr8ful/spf",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Super Portable Factory — a global CLI for repeatable agents-plus-code workflows (ADWs)",
   "type": "module",
   "license": "MIT",