@pmelab/gtd 45.0.0 → 45.2.0

package/src/workflows/shared/text.ts

@@ -124,6 +124,8 @@ export interface ComposedReview {
     readonly unresolved?: true
     /** A fix turn removed its chunk while renaming another. */
     readonly unclear?: true
+    /** Labels for the first two boxes; absent: fix as suggested, won't fix. Read by position, so only the wording changes. */
+    readonly answers?: readonly [string, string]
   }[]
   readonly fixed: readonly { readonly title: string; readonly commit: string }[]
   readonly noise: readonly { readonly title: string; readonly p: number }[]
@@ -170,7 +172,8 @@ export const composedReview = (base: string, report: ComposedReview): string =>
   }
   const chunk = (title: string, body: string): string => `## ${title}\n\n${body.trim()}`
   // The lead-in line keeps a body that ends in a list from absorbing the boxes.
-  const answerBoxes = `${ANSWER_LEAD}\n\n- [ ] ${ANSWER_FIX}\n- [ ] ${ANSWER_WONT_FIX}\n- [ ] ${FREE_TEXT_PLACEHOLDER}`
+  const answerBoxes = ([fix, wontFix]: readonly [string, string] = [ANSWER_FIX, ANSWER_WONT_FIX]) =>
+    `${ANSWER_LEAD}\n\n- [ ] ${fix}\n- [ ] ${wontFix}\n- [ ] ${FREE_TEXT_PLACEHOLDER}`
   const conflicts = (report.standards?.undecided ?? []).map((c) =>
     chunk(unique(conflictTitle(c)), conflictBody(c)),
   )
@@ -208,7 +211,7 @@ export const composedReview = (base: string, report: ComposedReview): string =>
             : n.unclear === true
               ? `_A fix turn removed this while renaming another finding — check whether it was fixed._\n\n${unboxed(n.body)}`
               : unboxed(n.body) || "_No detail given._"
-        }\n\n${answerBoxes}`,
+        }\n\n${answerBoxes(n.answers)}`,
       ),
     ),
     ...(report.fixed.length === 0

package/src/workflows/shared/vars.ts

@@ -16,6 +16,14 @@ export const testFileGlobs: readonly string[] = [
 
 export const defaultFlagRegistry = "src/flags/index.ts"
 
+/** The `tests` workflow's own process settings: where it looks for skipped tests, and how a skip reads. */
+export const testsDefaults: Readonly<Record<string, string>> = {
+  testFiles: testFileGlobs.join(", "),
+  // JS/TS runners' `.skip`/`.todo` and `x`-prefixed blocks, and cucumber's skip tags.
+  skipPattern:
+    "^\\s*(?:(?:describe|context|suite|it|test|specify)\\.(?:skip|todo)\\b|x(?:describe|context|it|test|specify)\\s*\\(|(?:@\\S+\\s+)*@(?:skip|ignore)(?:\\s|$))",
+}
+
 /** Process settings. */
 export const defaults: Readonly<Record<string, string>> = {
   reviewBase: "",

package/src/workflows/tests/index.ts

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

package/src/workflows/tests/tests-options.feature

@@ -0,0 +1,52 @@
+@inmem
+Feature: the tests workflow's skip detection is a workflow option
+
+  `testFiles` (globs) and `skipPattern` (a per-line regular expression) default
+  to JavaScript/TypeScript runners and cucumber tags; another stack sets its
+  own on the factory.
+
+  Background:
+    Given a gtd config with:
+      """
+      export {
+        feature as default,
+        feature,
+        defaults,
+        envDefaults,
+        summary,
+        steering,
+        skills,
+        access,
+      } from "@pmelab/gtd/workflows/feature"
+      import { tests as shippedTests } from "@pmelab/gtd/workflows/tests"
+      export const tests = shippedTests({
+        testFiles: "tests/test_*.py",
+        skipPattern: "@pytest\\.mark\\.skip\\b",
+      })
+      """
+    And a file "tests/test_calc.py" with:
+      """
+      @pytest.mark.skip
+      def test_add(): pass
+      """
+    And a file "src/calc.test.ts" with:
+      """
+      it.skip("adds", () => {})
+      """
+    And the working tree is committed as "test: python"
+    And step "tests-gate.check" changes nothing
+
+  Scenario: only the configured files and pattern count as skipped
+    Given step "tests.sweeping" is prompted with "tests/test_calc.py:1 — @pytest.mark.skip"
+    And step "tests.sweeping" changes nothing
+    When gtd starts workflow "tests"
+    Then driving the process is refused with "tests/test_calc.py has no section"
+    And driving the process is refused without "src/calc.test.ts"
+
+  Scenario Outline: an unusable skipPattern is refused before any step
+    Then starting workflow "tests" with "--var skipPattern=<pattern>" is refused with "<refusal>"
+
+    Examples:
+      | pattern | refusal                                     |
+      | .*      | skipPattern must not match the empty string |
+      | (       | skipPattern is not a valid regular expression |

package/src/workflows/tests/tests.feature

@@ -0,0 +1,266 @@
+@inmem
+Feature: the tests workflow revives skipped tests or proposes their deletion
+
+  `gtd --workflow tests` sweeps the repository for skipped tests and test-audit
+  findings into `.gtd/TESTS.md`, one section per test file. Each file is
+  rewritten in its own turn until nothing in it is skipped and the suite is
+  green. A test the agent calls obsolete stays skipped and becomes a proposal in
+  `.gtd/RETIRE.md`; the human review asks for one tick on each — delete it, keep
+  it skipped, or an own answer. Only a person's tick deletes a test.
+
+  Background:
+    Given a gtd config with:
+      """
+      export {
+        feature as default,
+        feature,
+        defaults,
+        envDefaults,
+        summary,
+        steering,
+        skills,
+        access,
+      } from "@pmelab/gtd/workflows/feature"
+      export { tests } from "@pmelab/gtd/workflows/tests"
+      """
+    And a file "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      """
+    And a file "src/calc.test.ts" with:
+      """
+      it.skip("adds", () => expect(add(1, 2)).toBe(3))
+      """
+    And a file "src/legacy.test.ts" with:
+      """
+      it.skip("calls the v1 api", () => {})
+      """
+    And the working tree is committed as "feat: calculator"
+    And step "tests-gate.check" changes nothing
+    And step "tests.sweeping" writes ".gtd/TESTS.md" with:
+      """
+      # Tests
+
+      ## src/calc.test.ts
+
+      "adds" is skipped.
+
+      ## src/legacy.test.ts
+
+      "calls the v1 api" is skipped.
+      """
+    And step "tests.rewriting", when prompted with "\"adds\" is skipped", writes "src/calc.test.ts" with:
+      """
+      it("adds", () => expect(add(1, 2)).toBe(3))
+      """
+    And step "tests.rewriting", when prompted with "\"calls the v1 api\" is skipped", writes ".gtd/RETIRE.md" with:
+      """
+      # Retire
+
+      ## calls the v1 api
+
+      src/legacy.test.ts tests the v1 api, which is gone.
+      """
+    And step "tests.health.check" changes nothing
+    And step "tests.closing" runs its script
+    And step "build.review.composing" runs its script
+    And step "build.review.closing" runs its script
+
+  Scenario: the revivable test is unskipped and the obsolete one is proposed for deletion
+    When gtd starts workflow "tests"
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+    And the commit subjects end with:
+      """
+      gtd(check): tests-gate.check → tests.sweeping
+      gtd(agent): tests.sweeping → tests.rewriting
+      gtd(agent): tests.rewriting → tests.health.check
+      gtd(check): tests.health.check → tests.rewriting
+      gtd(agent): tests.rewriting → tests.closing
+      gtd(check): tests.closing → build.review.composing
+      gtd(check): build.review.composing → build.review.await-review
+      """
+    And "src/calc.test.ts" contains "it(\"adds\""
+    And "src/legacy.test.ts" contains "it.skip"
+    And ".gtd/TESTS.md" does not exist
+    And ".gtd/RETIRE.md" does not exist
+    And ".gtd/REVIEW.md" contains:
+      """
+      ## calls the v1 api
+
+      Delete this skipped test.
+
+      src/legacy.test.ts tests the v1 api, which is gone.
+
+      Tick exactly one:
+
+      - [ ] delete it
+      - [ ] keep it skipped
+      - [ ] _your answer_
+      """
+    And the resting step's content contains "tests removed"
+
+  Scenario: signing off with an unticked proposal is refused
+    When gtd starts workflow "tests"
+    And the process is driven
+    Then landing is refused with "tick exactly one box"
+
+  Scenario: a ticked delete it has the test deleted, then the review comes back
+    Given step "build.review.fix.nits.fixing" deletes "src/legacy.test.ts"
+    And step "build.health.check" changes nothing
+    When gtd starts workflow "tests"
+    And the process is driven
+    And the text "- [ ] delete it" in ".gtd/REVIEW.md" is replaced with "- [x] delete it"
+    And gtd lands
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+    And "src/legacy.test.ts" does not exist
+    When gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+
+  Scenario: a ticked keep it skipped leaves the test skipped and ends the process
+    Given judge step "build.review.standards.judge" answers:
+      """
+      [{"id":"standard-1","answer":"no","p":0.9}]
+      """
+    When gtd starts workflow "tests"
+    And the process is driven
+    And the text "- [ ] keep it skipped" in ".gtd/REVIEW.md" is replaced with "- [x] keep it skipped"
+    And gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+    And "src/legacy.test.ts" contains "it.skip"
+    And the commit "gtd(human): build.review.await-review → build.review.standards.judge" has a body containing "Gtd-Mark: wontfix=calls the v1 api"
+
+  Scenario: a rewrite leaving a test skipped without a proposal is refused
+    Given step "tests.rewriting", when prompted with "\"calls the v1 api\" is skipped", writes ".gtd/RETIRE.md" with:
+      """
+      # Retire
+      """
+    When gtd starts workflow "tests"
+    Then driving the process is refused with "src/legacy.test.ts:1 still skipped"
+
+  Scenario: a rewrite deleting a test file is refused
+    Given step "tests.rewriting" deletes "src/legacy.test.ts"
+    When gtd starts workflow "tests"
+    Then driving the process is refused with "src/legacy.test.ts deleted"
+
+  Scenario: a sweep deleting a test file is refused
+    Given step "tests.sweeping" deletes "src/legacy.test.ts"
+    When gtd starts workflow "tests"
+    Then driving the process is refused with "src/legacy.test.ts deleted"
+
+  Scenario: a sweep changing anything but its plan is refused
+    Given step "tests.sweeping" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => b + a
+      """
+    When gtd starts workflow "tests"
+    Then driving the process is refused with "the sweep changed src/calc.ts"
+
+  Scenario: a proposal naming its file at the end of a sentence counts
+    Given step "tests.rewriting", when prompted with "\"calls the v1 api\" is skipped", writes ".gtd/RETIRE.md" with:
+      """
+      # Retire
+
+      ## calls the v1 api
+
+      The v1 api is gone, so drop it from src/legacy.test.ts.
+      """
+    When gtd starts workflow "tests"
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+
+  Scenario: a sweep planning a file that is no test file is refused
+    Given step "tests.sweeping" writes ".gtd/TESTS.md" with:
+      """
+      # Tests
+
+      ## src/calc.ts
+
+      Nothing is skipped.
+
+      ## src/calc.test.ts
+
+      "adds" is skipped.
+
+      ## src/legacy.test.ts
+
+      "calls the v1 api" is skipped.
+      """
+    When gtd starts workflow "tests"
+    Then driving the process is refused with "is no test file"
+
+  Scenario: a proposal naming its file as ./path counts
+    Given step "tests.rewriting", when prompted with "\"calls the v1 api\" is skipped", writes ".gtd/RETIRE.md" with:
+      """
+      # Retire
+
+      ## calls the v1 api
+
+      ./src/legacy.test.ts tests the v1 api, which is gone.
+      """
+    When gtd starts workflow "tests"
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+
+  Scenario: rewrites that change no code and propose nothing end the process
+    Given a file "src/legacy.test.ts" with:
+      """
+      it("calls the v2 api", () => {})
+      """
+    And a file "src/calc.test.ts" with:
+      """
+      it("adds", () => expect(add(1, 2)).toBe(3))
+      """
+    And the working tree is committed as "test: nothing skipped"
+    And step "tests.rewriting" from now on changes nothing
+    When gtd starts workflow "tests"
+    And the process is driven
+    Then the process rests at "idle"
+
+  Scenario: one proposal covers one skip, not every skip in its file
+    Given a file "src/legacy.test.ts" with:
+      """
+      it.skip("calls the v1 api", () => {})
+      it.skip("calls the v1 batch api", () => {})
+      """
+    And the working tree is committed as "test: another legacy test"
+    When gtd starts workflow "tests"
+    Then driving the process is refused with "src/legacy.test.ts:2 still skipped"
+
+  Scenario: a sweep leaving out a file with a skipped test is refused
+    Given step "tests.sweeping" writes ".gtd/TESTS.md" with:
+      """
+      # Tests
+
+      ## src/calc.test.ts
+
+      "adds" is skipped.
+      """
+    When gtd starts workflow "tests"
+    Then driving the process is refused with "src/legacy.test.ts has no section"
+
+  Scenario: the sweep is told every skipped test, path and line
+    Given step "tests.sweeping" is prompted with "src/legacy.test.ts:1 — it.skip(\"calls the v1 api\", () => {})"
+    When gtd starts workflow "tests"
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+
+  Scenario: a sweep with nothing to do ends the process
+    Given a file "src/calc.test.ts" with:
+      """
+      it("adds", () => expect(add(1, 2)).toBe(3))
+      """
+    And the file "src/legacy.test.ts" is deleted
+    And the working tree is committed as "test: revive by hand"
+    And step "tests.sweeping" from now on changes nothing
+    When gtd starts workflow "tests"
+    And the process is driven
+    Then the process rests at "idle"
+
+  Scenario: gtd door tests starts the workflow
+    When gtd opens door "tests"
+    And the process is driven
+    Then the process rests at "build.review.await-review"

package/src/workflows/tests/tests.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest"
+import { DEFAULT_SKIP_PATTERN, skipsIn } from "./tests.js"
+
+const skipped = (text: string): readonly number[] =>
+  skipsIn([{ path: "a", text }], new RegExp(DEFAULT_SKIP_PATTERN)).map((s) => s.line)
+
+describe("the default skipPattern", () => {
+  it.each([
+    'it.skip("x", () => {})',
+    'test.skip("x", () => {})',
+    'describe.skip("x", () => {})',
+    'it.todo("x")',
+    'xit("x", () => {})',
+    'xdescribe("x", () => {})',
+    "  @inmem @skip",
+    "@ignore",
+  ])("reads %s as skipped", (line) => {
+    expect(skipped(line)).toEqual([1])
+  })
+
+  it.each([
+    'it("x", () => {})',
+    'it.skipIf(windows)("x", () => {})',
+    'it.only("x", () => {})',
+    "@skipped-by-nobody",
+    "fixit()",
+    "user@skip.example",
+    '  "it.skip(x)",',
+    "// xit( is how jasmine skips",
+    "@skip-ci",
+  ])("does not read %s as skipped", (line) => {
+    expect(skipped(line)).toEqual([])
+  })
+})
+
+describe("skipsIn", () => {
+  it("names every skipped line by path and 1-based line, trimmed", () => {
+    expect(
+      skipsIn(
+        [
+          { path: "a.test.ts", text: 'it("a", f)\n  it.skip("b", f)\n' },
+          { path: "b.feature", text: "@skip\nScenario: c" },
+        ],
+        new RegExp(DEFAULT_SKIP_PATTERN),
+      ),
+    ).toEqual([
+      { path: "a.test.ts", line: 2, text: 'it.skip("b", f)' },
+      { path: "b.feature", line: 1, text: "@skip" },
+    ])
+  })
+})