@pmelab/gtd 36.0.0 → 38.0.0

package/src/workflows/shared/text.ts

@@ -290,6 +290,30 @@ printf '%s\\n' ${lines.map(quote).join(" ")} > ${quote(".gtd/REQUIREMENTS.md")}
 `
 }
 
+export const slicingPrompt = (cap: number): string =>
+  `${stateFileRules}
+- Read \`.gtd/REQUIREMENTS.md\`: its \`## Acceptance Criteria\` are settled
+  and more than ${cap}, too many to build in one slice
+- Group them into slices in \`.gtd/SLICES.md\`, one \`## <title>\` heading per
+  slice over a \`- AC-<n>\` list item per criterion it builds. Put criteria of
+  the same flow or subsystem together; every criterion in exactly one slice,
+  at most ${cap} per slice
+- Keep it coarse: as few slices as the cap allows, never one per criterion
+- Order the slices so each builds on the ones before: they run in that order,
+  each from where the previous one landed
+- Change nothing but \`.gtd/SLICES.md\` — leave the criteria as they are
+- Leave everything uncommitted and finish your turn — do not commit
+`
+
+/** The line telling a slice's turn which criteria are its own; empty for a single slice. */
+const sliceLine = (ids: readonly string[] | undefined): string =>
+  ids === undefined
+    ? ""
+    : `- This slice builds ${ids.join(", ")} only: every rule here about the criteria
+  means these. The others are for other slices, before or after it — leave
+  them unbuilt and untested
+`
+
 export const designSystem = (): string =>
   `${designPersona}
 
@@ -350,22 +374,30 @@ export const refactorBuildingPrompt = ({
   pattern,
   reference,
   feedback = false,
+  note = false,
 }: {
   pkg: string
   strays: readonly string[]
   pattern: string
   reference?: string | undefined
   feedback?: boolean | undefined
+  note?: boolean | undefined
 }): string =>
   `${stateFileRules}
 - The package to implement is \`${pkg}\`; never delete it
 ${
-  feedback
-    ? `- The package carries a \`## Review feedback\` section: a human's review of the
-  last refactor. Act on it, within the rules below
+  note
+    ? `- The package's \`## Refactor note\` section names the seams to open and the
+  shape each takes, written from the whole naive pass: build exactly those
 `
     : ""
-}${refactorRules(strays, pattern)}
+}${
+    feedback
+      ? `- The package carries a \`## Review feedback\` section: a human's review of the
+  last refactor. Act on it, within the rules below
+`
+      : ""
+  }${refactorRules(strays, pattern)}
 ${
   reference === undefined
     ? ""
@@ -1195,10 +1227,10 @@ ${listed(retry.strays)}
 Start over and choose a different approach; do not rebuild the same diff.
 `
 
-export const naivePassPrompt = (retry?: NaiveRetry): string =>
+export const naivePassPrompt = (retry?: NaiveRetry, slice?: readonly string[]): string =>
   `${stateFileRules}
 - Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
-${criteriaBinding(false)}
+${sliceLine(slice)}${criteriaBinding(false)}
 - Implement them the quickest way that works — the naive version. Do not
   restructure, abstract or refactor around the change; it may land exactly as
   you leave it, and a reviewer makes it fit
@@ -1217,24 +1249,102 @@ ${criteriaBinding(false)}
 - Leave everything uncommitted and finish your turn — do not commit
 ${retry === undefined ? "" : naiveRetry(retry)}`
 
+/** The naive pass's kept tip, its acceptance test files and the criterion IDs they name. */
+export interface Acceptance {
+  readonly hash: string
+  readonly tests: readonly string[]
+  readonly ids: readonly string[]
+}
+
+/** What a rebuild after a refactor-first judgment carries over from the naive pass. */
+export interface Rebuild {
+  readonly note?: string | undefined
+  readonly acceptance?: Acceptance | undefined
+}
+
+const carries = (rebuild: Rebuild): boolean => (rebuild.acceptance?.ids.length ?? 0) > 0
+
+const rebuildLines = ({ note, acceptance }: Rebuild): string =>
+  `${
+    note === undefined
+      ? ""
+      : `- The refactor note (\`.gtd/REFACTOR-NOTE.md\`) named the seams the refactor
+  opened; plug the change into them:
+
+${note
+  .trimEnd()
+  .split("\n")
+  .map((line) => (line === "" ? "" : `  > ${line}`))
+  .join("\n")}
+
+`
+  }${
+    acceptance === undefined || !carries({ acceptance })
+      ? ""
+      : `- Carry over the naive pass's acceptance tests for ${acceptance.ids.join(", ")}, the
+  one part of it you take as it is: \`git show ${acceptance.hash} -- ${acceptance.tests.map(quote).join(" ")}\`.
+  Copy each test with its \`[AC-<n>]\` name into the tree as the refactor left
+  it — check a file out of the tip whole only where the refactor did not touch
+  it — changing only what reaches the release flag. A turn whose changed tests
+  leave an ID out is refused, and the suite must be green with them
+`
+  }`
+
+export const refactorNotePrompt = (reference: string, strays: readonly string[]): string =>
+  `${stateFileRules}
+- The seam judge ruled the naive pass refactor-first: it is never applied.
+  A behaviour-neutral refactor lands first, then the change is rebuilt on
+  the refactored base. Both turns read the note you write
+- Read the whole naive pass: \`git show ${reference}\`. It changed these
+  existing files outside the allowlist:
+${listed(strays)}
+- Write \`.gtd/REFACTOR-NOTE.md\`: which seams the refactor opens (the existing
+  code to restructure, by path and symbol) and the shape each takes — the
+  signatures and where the new behaviour will plug in. Name only the files
+  listed above: the refactor may change no other path. Never the feature's own
+  behaviour, and no flag read: the refactor adds neither
+- Change nothing else — a turn that does is refused
+- Leave everything uncommitted and finish your turn — do not commit
+`
+
+const afterRefactorLine = (rebuild: Rebuild): string =>
+  `- A reviewed refactor has just landed and may already carry part of the change,
+  though never a release flag. Build only what is still missing, held to every
+  rule below; if nothing is, ${carries(rebuild) ? "carry over the acceptance tests below and change nothing else" : "change nothing and finish your turn"}
+`
+
+const flagLine = (
+  flagMode: boolean,
+  tier: "low" | "high" | undefined,
+  amend: boolean | undefined,
+  sliced: boolean,
+): string =>
+  !flagMode
+    ? "- Add no release flag — this project ships without release flags"
+    : tier === "low"
+      ? "- Add no release flag — this change is low risk tier"
+      : amend === true
+        ? "- Keep the release flag the earlier lap added, if it added one; otherwise put\n  the behaviour behind a new release flag"
+        : sliced
+          ? `- Put the new behaviour behind the release flag an earlier slice of this
+  change added; only when none did, behind a new one, following the
+  repository's flag conventions`
+          : `- Put the new behaviour behind a new release flag, following the
+  repository's flag conventions`
+
 export const implementBuildingPrompt = (
   reference: string | undefined,
   tier?: "low" | "high",
   amend?: boolean,
   afterRefactor?: boolean,
   flagMode = true,
+  rebuild: Rebuild = {},
+  slice?: readonly string[],
 ): string =>
   `${stateFileRules}
 - Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
-${criteriaBinding(true)}
-${
-  afterRefactor === true
-    ? `- A reviewed refactor has just landed and may already carry part of the change,
-  though never a release flag. Build only what is still missing, held to every
-  rule below; if nothing is, change nothing and finish your turn
-`
-    : ""
-}${
+${sliceLine(slice)}${criteriaBinding(true)}
+${afterRefactor === true ? afterRefactorLine(rebuild) : ""}${
     amend === true
       ? `- The change already exists in the tree from an earlier lap; amend it to meet
   the re-derived requirements instead of rewriting it
@@ -1250,18 +1360,9 @@ ${
       ? ""
       : `- Reference only: \`git show ${reference}\` shows an earlier naive attempt.
   Read it for ideas; never apply, cherry-pick or check it out — write
-  the change fresh
+  the change fresh${carries(rebuild) ? ", its acceptance tests excepted (below)" : ""}
 `
-  }${
-    !flagMode
-      ? "- Add no release flag — this project ships without release flags"
-      : tier === "low"
-        ? "- Add no release flag — this change is low risk tier"
-        : amend === true
-          ? "- Keep the release flag the earlier lap added, if it added one; otherwise put\n  the behaviour behind a new release flag"
-          : `- Put the new behaviour behind a new release flag, following the
-  repository's flag conventions`
-  }
+  }${rebuildLines(rebuild)}${flagLine(flagMode, tier, amend, slice !== undefined)}
 - Write the tests first, then the code that makes them pass. Name each
   criterion's ID in the test that covers it (\`[AC-3] …\`): once the suite is
   green a judge checks every ID has a passing test, and sends uncovered ones back
@@ -1371,10 +1472,10 @@ export const coverageMessage = (): string =>
 counts every criterion as uncovered.
 `
 
-export const coveringPrompt = (uncovered: readonly string[]): string =>
+export const coveringPrompt = (uncovered: readonly string[], slice?: readonly string[]): string =>
   `${stateFileRules}
 - Read \`.gtd/REQUIREMENTS.md\`: the settled requirements for this change
-${criteriaBinding(true)}
+${sliceLine(slice)}${criteriaBinding(true)}
 - A judge found no passing test in this change that covers ${uncovered.join(", ")}.
   Write a behaviour-level test for each, naming its ID in the test or scenario
   name (\`[${uncovered[0]}] …\`), and fix the code if the test shows it falls short

package/src/workflows/shared/vars.ts

@@ -26,6 +26,7 @@ export const defaults: Readonly<Record<string, string>> = {
   refactorFlagPattern: "\\bGTD_FLAG_\\w+",
   seamAllow: [...testFileGlobs, ".gtd/**"].join(", "),
   flagMode: "true",
+  sliceMaxCriteria: "8",
   // GTD_FLAG_RISK_TIER, recorded at process start; only "1" is on.
   flag_risk_tier: "0",
   // Decides the turn count: one `build.quality.<lens>` scope per entry, each

package/src/workflows/shared/workflows.steps.ts

@@ -52,3 +52,16 @@ Then("no commit body contains {string}", (world: TestkitWorld, text: string) =>
     .find((m) => m.includes(text))
   assert.ok(hit === undefined, `a commit body contains "${text}":\n${hit}`)
 })
+
+Then(
+  "slice {string} begins where slice {string} ends",
+  async (world: TestkitWorld, later: string, earlier: string) => {
+    const { stdout } = await world.repo().gtd("slices")
+    const range = (name: string): string[] => {
+      const line = stdout.split("\n").find((l) => l.startsWith(`${name} `))
+      assert.ok(line !== undefined, stdout)
+      return line.slice(name.length + 1).split("..")
+    }
+    assert.strictEqual(range(later)[0], range(earlier)[1], stdout)
+  },
+)