@pmelab/gtd 58.2.0 → 59.0.1

package/src/workflows/fix/fix.test.ts

@@ -1,74 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { runsItsScript, testRepo } from "../../testkit/index.js"
-import { CONFIG_SCAFFOLD } from "../../install/index.js"
-import { reviewDoc } from "../shared/config.fixture.js"
-
-const REVIEW = ".gtd/REVIEW.md"
-const ORIG = ".gtd/REVIEW.orig.md"
-const CALC = "export const add = (a: number, b: number) => a + b\n"
-
-describe("the fix workflow", () => {
-  it("with no handed-off review, repairs a red baseline and hands it to review", async () => {
-    const repo = testRepo({ workflow: CONFIG_SCAFFOLD, env: { GTD_QUALITYREVIEWS: "" } })
-    await repo.start("fix")
-    const rest = await repo.drive({
-      "fix-precheck": (_, r) => r.write(".gtd/FEEDBACK.md", "1 test failing\n"),
-      "build.fix": (beat, r) => {
-        expect(beat.content).toContain(".gtd/FEEDBACK.md")
-        r.remove(".gtd/FEEDBACK.md")
-        r.write("src/repair.ts", "export const repaired = true\n")
-      },
-      "build.health.check": () => undefined,
-    })
-    expect(rest).toMatchObject({ state: "build.review.reviewing", actor: "agent" })
-    expect(repo.subjects().slice(1)).toEqual([
-      "gtd(human): fix-precheck",
-      "gtd(check): fix-precheck → build.fix",
-      "gtd(agent): build.fix → build.health.check",
-      "gtd(check): build.health.check → build.review.reviewing",
-    ])
-  })
-
-  it("with a green baseline, has nothing to fix", async () => {
-    const repo = testRepo({ workflow: CONFIG_SCAFFOLD, env: { GTD_QUALITYREVIEWS: "" } })
-    await repo.start("fix")
-    const rest = await repo.drive({ "fix-precheck": () => undefined })
-    expect(rest.state).toBe("idle")
-    expect(repo.subjects().at(-1)).toBe("gtd(check): fix-precheck → idle")
-  })
-
-  it("fixes a handed-off review's notes and risks in one turn, removes both review files, then checks health", async () => {
-    const repo = testRepo({
-      workflow: CONFIG_SCAFFOLD,
-      env: { GTD_QUALITYREVIEWS: "" },
-      files: {
-        "src/calc.ts": CALC,
-        [REVIEW]: reviewDoc("add — rename it to sum", "Risk: drops the carry"),
-        [ORIG]: reviewDoc("add", "Risk: drops the carry"),
-      },
-    })
-    await repo.door("fix")
-    const rest = await repo.drive({
-      "notes.fixing": (beat, r) => {
-        expect(beat.content).toContain("rename it to sum")
-        expect(beat.content).toContain("Risk: drops the carry")
-        r.write("src/calc.ts", CALC.replace("add", "sum"))
-      },
-      "notes.closing": runsItsScript,
-    })
-    expect(rest.state).toBe("build.health.check")
-    expect(repo.subjects().slice(1)).toEqual([
-      "gtd(human): notes.fixing",
-      "gtd(agent): notes.fixing → notes.closing",
-      "gtd(check): notes.closing → build.health.check",
-    ])
-    expect(repo.read("src/calc.ts")).toContain("sum")
-    expect(repo.read(REVIEW)).toBeUndefined()
-    expect(repo.read(ORIG)).toBeUndefined()
-  })
-
-  it("refuses a review with no reviewer's copy, so no note is deleted unread", async () => {
-    const repo = testRepo({ workflow: CONFIG_SCAFFOLD, files: { [REVIEW]: reviewDoc("add") } })
-    await expect(repo.door("fix")).rejects.toThrow(/not handed off/)
-  })
-})

package/src/workflows/fix/fix.ts

@@ -1,52 +0,0 @@
-import { read, refuse, removeScript, run, scope, start } from "../../flows/index.js"
-import { reviewNotes, reviewRisks } from "../../steering/index.js"
-import { baseline } from "../shared/health.js"
-import { shipped } from "../shared/options.js"
-import { coder, REVIEW } from "../shared/steps.js"
-import { handOffTail, REVIEW_ORIG } from "../shared/tail.js"
-import * as t from "../shared/text.js"
-
-/**
- * Fix every note a human left in a handed-off `.gtd/REVIEW.md` and every
- * risk its reviewer marked, in one turn; the review files go once it is done.
- */
-export const fixReviewNotes = (): Promise<void> =>
-  scope("notes", async () => {
-    const record = read(REVIEW) ?? ""
-    const orig = read(REVIEW_ORIG)
-    // Without the reviewer's copy no note can be told from the review's own text,
-    // and closing would delete notes never read — also keeps a stray review out.
-    if (orig === undefined) {
-      return refuse(
-        `gtd: ${REVIEW} has no ${REVIEW_ORIG}, so it was not handed off by a review — remove it, or restore ${REVIEW_ORIG}.`,
-      )
-    }
-    const notes = reviewNotes(orig, record)
-    await t.agentWithSkills("fixing", t.fixReviewNotesPrompt(notes, reviewRisks(record)), {
-      label: "Fixing your review notes",
-      file: REVIEW,
-      model: coder(),
-      system: t.finisherSystem(),
-      // Praise and questions are answered without an edit; the hand-off review that follows catches an unaddressed note.
-      allowEmpty: true,
-    })
-    await run("closing", removeScript([REVIEW, REVIEW_ORIG]), { label: "Closing the review" })
-  })
-
-/**
- * Fix what a review handed on, else repair a red baseline — then the
- * hand-off review of the result. A note there is handed to the next `fix`.
- */
-export const fixFlow = async (): Promise<void> => {
-  if (read(REVIEW) !== undefined) {
-    await fixReviewNotes()
-    return handOffTail(false, start())
-  }
-  if (read(REVIEW_ORIG) !== undefined) {
-    return refuse(`gtd: ${REVIEW_ORIG} has no ${REVIEW} — remove it, or restore ${REVIEW}.`)
-  }
-  if (await baseline("fix-precheck")) return
-  await handOffTail(true, start())
-}
-
-export const fix = shipped(fixFlow, { fix: {} })

package/src/workflows/fix/index.ts

@@ -1,6 +0,0 @@
-import { fix } from "./fix.js"
-
-export { fix, fixFlow, fixReviewNotes } from "./fix.js"
-export * from "../shared/reserved.js"
-
-export default fix

package/src/workflows/index.ts

@@ -1,47 +0,0 @@
-// The `@pmelab/gtd/workflows` entry, built on its own: core never imports it,
-// a repository's `gtd.config.ts` does.
-import type { Doors } from "../flows/index.js"
-import { feature } from "./feature/feature.js"
-
-export { threads, type ThreadInfo } from "../flows/index.js"
-export * from "./shared/reserved.js"
-export { FlagOptions, ShippedOptions } from "./shared/options.js"
-export { agentWithSkills, type ReviewRange } from "./shared/text.js"
-export * from "./shared/steps.js"
-export * from "./shared/health.js"
-export {
-  closeReview,
-  handOffReview,
-  handOffTail,
-  qualityLap,
-  REVIEW_ORIG,
-  tail,
-  type TailOptions,
-} from "./shared/tail.js"
-export { type Finding, type LensReport } from "./shared/lenses.js"
-export { lensEntriesOf, lensesOf, lensOf } from "../workflow-kit/index.js"
-export * from "./feature/steps.js"
-export * from "./feature/criteria.js"
-export * from "./feature/planning.js"
-export * from "./feature/refactor.js"
-export * from "./feature/seam.js"
-export {
-  buildTail,
-  type BuildTailOptions,
-  type FeedbackTarget,
-  type ReviewOutcome,
-} from "./shared/review.js"
-export * from "./feature/feature.js"
-export { base, review, reviewFlow } from "./review/review.js"
-export { fix, fixFlow, fixReviewNotes } from "./fix/fix.js"
-export { rollout, rolloutFlow } from "./rollout/rollout.js"
-export { cleanup, cleanupFlow } from "./cleanup/cleanup.js"
-
-export default feature
-
-/**
- * @deprecated Empty: each shipped workflow builds its own doors, so a config
- * gets `fix` and `review [base]` by exporting `fix` and `review`, and
- * `rollout <flag>` and `cleanup <flag>` by exporting `rollout` and `cleanup`.
- */
-export const doors: Doors = {}

package/src/workflows/review/index.ts

@@ -1,6 +0,0 @@
-import { review } from "./review.js"
-
-export { review, reviewFlow } from "./review.js"
-export * from "../shared/reserved.js"
-
-export default review

package/src/workflows/review/review-door.feature

@@ -1,199 +0,0 @@
-@inmem
-Feature: the review door fixes its notes in the same process
-
-  `gtd door review` runs the feature's review over everything since its base:
-  the triaged quality lap and its finding gate, then a reviewer's walkthrough
-  of the change with the lap's summary, where the human's notes are fixed in
-  place under the health loop before the review comes back. A sign-off ends
-  the process; nothing is left for `fix`.
-
-  Background:
-    Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
-    And a file "src/calc.ts" with:
-      """
-      export const add = (a: number, b: number) => a + b
-      """
-    And the working tree is committed as "feat: add calculator"
-    And step "review-gate.check" changes nothing
-    And step "build.health.check" changes nothing
-    And step "build.quality.correctness.reviewing" writes ".gtd/QUALITY.md" with:
-      """
-      # Quality
-
-      ## add has no test
-
-      Add a test for add.
-      """
-    And judge step "build.quality.triage" answers:
-      """
-      [{"id":"Q1","answer":"design","p":0.9}]
-      """
-    And step "build.quality.gating" runs its script
-    And step "build.quality.gate" changes nothing
-    And step "build.quality.closing" runs its script
-    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## Calculator
-
-      - [ ] ./src/calc.ts#1-1 — add(a, b)
-      """
-    And step "build.review.carrying" runs its script
-    And step "build.review.closing" runs its script
-
-  Scenario: the review is a walkthrough, its summary listing what the finding gate dropped
-    When gtd opens door "review" with "HEAD~1"
-    And the process is driven
-    Then the process rests at "build.review.await-review"
-    And the commit subjects end with:
-      """
-      gtd(human): review-gate.check
-      gtd(check): review-gate.check → build.quality.correctness.reviewing
-      gtd(agent): build.quality.correctness.reviewing → build.quality.triage
-      gtd(judge): build.quality.triage → build.quality.gating
-      gtd(check): build.quality.gating → build.quality.gate
-      gtd(human): build.quality.gate → build.quality.closing
-      gtd(check): build.quality.closing → build.review.reviewing
-      gtd(agent): build.review.reviewing → build.review.carrying
-      gtd(check): build.review.carrying → build.review.await-review
-      """
-    And ".gtd/REVIEW.md" contains:
-      """
-      ## Calculator
-
-      - [ ] ./src/calc.ts#1-1 — add(a, b)
-
-      ## Quality lap
-      """
-    And ".gtd/REVIEW.md" contains:
-      """
-      Dropped at the finding gate:
-
-      - add has no test (lens correctness)
-      """
-    And ".gtd/REVIEW.md" does not contain "Tick exactly one:"
-    When gtd lands
-    And the process is driven
-    Then the process rests at "idle"
-    And ".gtd/REVIEW.md" does not exist
-    And ".gtd/REVIEW.orig.md" does not exist
-
-  Scenario: a nit note is fixed in place, then reviewed again
-    Given judge step "build.review.triage" answers:
-      """
-      [{"id":"note-1","answer":"nit","p":0.9}]
-      """
-    And step "build.review.fix.nits.fixing" writes "src/calc.test.ts" with:
-      """
-      it("adds", () => {})
-      """
-    When gtd opens door "review" with "HEAD~1"
-    And the process is driven
-    And the text "— add(a, b)" in ".gtd/REVIEW.md" is replaced with "— add(a, b) — add a test for it"
-    And gtd lands
-    And the process is driven
-    Then the process rests at "build.review.await-review"
-    And the commit subjects end with:
-      """
-      gtd(human): build.review.await-review → build.review.triage
-      gtd(judge): build.review.triage → build.review.fix.nits.fixing
-      gtd(agent): build.review.fix.nits.fixing → build.health.check
-      gtd(check): build.health.check → build.review.closing
-      gtd(check): build.review.closing → build.review.reviewing
-      gtd(agent): build.review.reviewing → build.review.carrying
-      gtd(check): build.review.carrying → build.review.await-review
-      """
-    And "src/calc.test.ts" contains "adds"
-
-  Scenario: a note asking for a change is fixed in place, then reviewed again
-    Given judge step "build.review.triage" answers:
-      """
-      [{"id":"note-1","answer":"edit","p":0.9}]
-      """
-    And step "build.review.collecting" writes ".gtd/REQUIREMENTS.md" with:
-      """
-      # Requirements
-
-      ## Test add with negatives
-
-      add(-1, -2) returns -3.
-      """
-    And step "feedback.fixing" is prompted with ".gtd/REQUIREMENTS.md"
-    And step "feedback.fixing" writes "src/calc.test.ts" with:
-      """
-      it("adds negatives", () => {})
-      """
-    And step "re-unwind" runs its script
-    And step "feedback.closing" runs its script
-    When gtd opens door "review" with "HEAD~1"
-    And the process is driven
-    And the text "— add(a, b)" in ".gtd/REVIEW.md" is replaced with "— add(a, b) — test negatives too"
-    And gtd lands
-    And the process is driven
-    Then the process rests at "build.review.await-review"
-    And the commit subjects end with:
-      """
-      gtd(human): build.review.await-review → build.review.triage
-      gtd(judge): build.review.triage → build.review.closing
-      gtd(check): build.review.closing → build.review.collecting
-      gtd(agent): build.review.collecting → re-unwind
-      gtd(check): re-unwind → feedback.fixing
-      gtd(agent): feedback.fixing → feedback.closing
-      gtd(check): feedback.closing → build.health.check
-      gtd(check): build.health.check → build.quality.correctness.reviewing
-      gtd(agent): build.quality.correctness.reviewing → build.quality.triage
-      gtd(judge): build.quality.triage → build.quality.gating
-      gtd(check): build.quality.gating → build.quality.gate
-      gtd(human): build.quality.gate → build.quality.closing
-      gtd(check): build.quality.closing → build.review.reviewing
-      gtd(agent): build.review.reviewing → build.review.carrying
-      gtd(check): build.review.carrying → build.review.await-review
-      """
-    And ".gtd/REQUIREMENTS.md" does not exist
-    And "src/calc.test.ts" contains "adds negatives"
-    And ".gtd/REVIEW.md" does not contain "test negatives too"
-
-  Scenario: a leftover requirements file is refused before any step
-    Given a file ".gtd/REQUIREMENTS.md" with:
-      """
-      # Requirements
-      """
-    And the working tree is committed as "chore: leftover requirements"
-    Then opening door "review" is refused with ".gtd/REQUIREMENTS.md is left over"
-
-  Scenario: a note added with its own boxes is fixed as ticked, never judged
-    Given step "build.review.fix.nits.fixing" writes "src/calc.ts" with:
-      """
-      export const add = (a: number, b: number): number => a + b
-      """
-    When gtd opens door "review" with "HEAD~1"
-    And the process is driven
-    And ".gtd/REVIEW.md" gets appended:
-      """
-      ## src/calc.ts:1 (thread PRRT_1)
-
-      > Annotate the return type.
-
-      Tick exactly one:
-
-      - [x] fix as suggested
-      - [ ] won't fix
-      - [ ] _your answer_
-      """
-    And gtd lands
-    And the process is driven
-    Then the process rests at "build.review.await-review"
-    And the commit subjects end with:
-      """
-      gtd(human): build.review.await-review → build.review.fix.nits.fixing
-      gtd(agent): build.review.fix.nits.fixing → build.health.check
-      gtd(check): build.health.check → build.review.closing
-      gtd(check): build.review.closing → build.review.reviewing
-      gtd(agent): build.review.reviewing → build.review.carrying
-      gtd(check): build.review.carrying → build.review.await-review
-      """
-    And "src/calc.ts" contains "): number =>"

package/src/workflows/review/review.test.ts

@@ -1,27 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { testRepo } from "../../testkit/index.js"
-import { CONFIG_SCAFFOLD } from "../../install/index.js"
-import { reviewDoc } from "../shared/config.fixture.js"
-import { base } from "./review.js"
-
-const REVIEW = ".gtd/REVIEW.md"
-const ORIG = ".gtd/REVIEW.orig.md"
-
-describe("the review workflow", () => {
-  it("refuses a pending hand-off before requesting any step, the gate's check included", async () => {
-    const repo = testRepo({
-      workflow: CONFIG_SCAFFOLD,
-      files: { [REVIEW]: reviewDoc("note"), [ORIG]: reviewDoc("orig") },
-    })
-    await expect(repo.door("review")).rejects.toThrow(".gtd/REVIEW.orig.md is a pending hand-off")
-    expect(repo.subjects()).toEqual(["chore: initial commit"])
-  })
-})
-
-describe("the deprecated shipped base", () => {
-  it("answers for a workflow named review only, mapping reviewBase", () => {
-    expect(base("review", {})).toBe("")
-    expect(base("review", { reviewBase: "v1" })).toBe("v1")
-    expect(base("audit", { reviewBase: "v1" })).toBeUndefined()
-  })
-})

package/src/workflows/review/review.ts

@@ -1,60 +0,0 @@
-import { read, refuse, removeScript, run, start, type WorkflowBase } from "../../flows/index.js"
-import { buildTail, reUnwind } from "../shared/review.js"
-import { gate } from "../shared/health.js"
-import { shipped } from "../shared/options.js"
-import { coder, REQUIREMENTS } from "../shared/steps.js"
-import { refusePendingHandOff } from "../shared/tail.js"
-import * as t from "../shared/text.js"
-
-const fixFeedback = async (): Promise<void> => {
-  await t.agentWithSkills("feedback.fixing", t.reviewFeedbackFixPrompt(), {
-    label: "Fixing your review feedback",
-    file: REQUIREMENTS,
-    model: coder(),
-    system: t.finisherSystem(),
-    // An earlier nit fix may already have built the concern.
-    allowEmpty: true,
-  })
-  await run("feedback.closing", removeScript([REQUIREMENTS]), { label: "Closing the feedback" })
-}
-
-/**
- * The feature's review of everything since `reviewBase` — a green gate, the
- * triaged quality lap, then the human review — with no design phase: a
- * review that asks for changes is fixed in place and reviewed again, until
- * sign-off.
- */
-export const reviewFlow = async (): Promise<void> => {
-  refusePendingHandOff()
-  // A review's feedback is whatever sits in this file, so a leftover one would be built, then deleted.
-  if (read(REQUIREMENTS) !== undefined) {
-    refuse(`gtd: ${REQUIREMENTS} is left over — finish or remove it before a review.`)
-  }
-  await gate("review-gate", t.reviewGateBlockedMessage())
-  const base = start()
-  // The gate just proved the tree green.
-  let outcome = await buildTail(base, { green: true })
-  while (outcome.verdict === "feedback") {
-    await reUnwind(outcome)
-    await fixFeedback()
-    // The human reviews the whole change again; the lenses only what the fix changed.
-    outcome = await buildTail(base, { lensBase: outcome.base })
-  }
-}
-
-export const review = shipped(
-  reviewFlow,
-  {
-    review: {
-      args: [{ name: "base", optional: true }],
-      // Annotated: inferred, the literal union only fits under exactOptionalPropertyTypes.
-      vars: ({ base }): Readonly<Record<string, string>> =>
-        base === undefined ? {} : { reviewBase: base },
-    },
-  },
-  (_workflow, vars) => vars.reviewBase || "",
-)
-
-/** @deprecated The `review` factory carries its own base; kept so a hand-written `review` re-exporting it still maps `reviewBase`. */
-export const base: WorkflowBase = (workflow, vars) =>
-  workflow === "review" ? (vars.reviewBase ?? "") : undefined

package/src/workflows/rollout/index.ts

@@ -1,6 +0,0 @@
-import { rollout } from "./rollout.js"
-
-export { rollout, rolloutFlow } from "./rollout.js"
-export * from "../shared/reserved.js"
-
-export default rollout