@pmelab/gtd 44.0.0 → 45.1.0

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" },
+    ])
+  })
+})

package/src/workflows/tests/tests.ts

@@ -0,0 +1,270 @@
+import {
+  changes,
+  changesSince,
+  glob,
+  read,
+  refuse,
+  removeScript,
+  run,
+  scope,
+  sectionBodies,
+  start,
+  vars,
+} from "../../flows/index.js"
+import { gate, healthy } from "../shared/health.js"
+import type { LensReport } from "../shared/lenses.js"
+import { testsShipped } from "../shared/options.js"
+import { fixFeedback, humanReview, isCode, reUnwind } from "../shared/review.js"
+import { coder, fixCheck, REQUIREMENTS } from "../shared/steps.js"
+import { refusePendingHandOff, tail } from "../shared/tail.js"
+import * as t from "../shared/text.js"
+import { testsDefaults } from "../shared/vars.js"
+
+const TESTS = ".gtd/TESTS.md"
+const RETIRE = ".gtd/RETIRE.md"
+
+/** The first two answer boxes of a deletion proposal; the third stays the human's own answer. */
+const RETIRE_ANSWERS: readonly [string, string] = ["delete it", "keep it skipped"]
+
+export const DEFAULT_SKIP_PATTERN = testsDefaults.skipPattern!
+
+interface Skip {
+  readonly path: string
+  /** 1-based. */
+  readonly line: number
+  readonly text: string
+}
+
+/** `skipPattern` as a per-line expression; refuses one that is blank, invalid, or matches every line. */
+const skipExpression = (pattern: string): RegExp => {
+  if (pattern.trim() === "") return refuse("gtd: skipPattern must not be blank")
+  let expression: RegExp
+  try {
+    expression = new RegExp(pattern)
+  } catch (error) {
+    return refuse(`gtd: skipPattern is not a valid regular expression: ${String(error)}`)
+  }
+  if (expression.test("")) return refuse("gtd: skipPattern must not match the empty string")
+  return expression
+}
+
+/** Every line of `files` the expression calls skipped, in file then line order. */
+export const skipsIn = (
+  files: readonly { readonly path: string; readonly text: string }[],
+  expression: RegExp,
+): readonly Skip[] =>
+  files.flatMap(({ path, text }) =>
+    text
+      .split("\n")
+      .flatMap((line, i) =>
+        expression.test(line) ? [{ path, line: i + 1, text: line.trim() }] : [],
+      ),
+  )
+
+const testPaths = (): readonly string[] => {
+  const globs = (vars.testFiles ?? testsDefaults.testFiles!)
+    .split(",")
+    .map((g) => g.trim())
+    .filter((g) => g !== "")
+  return [...new Set(globs.flatMap((g) => glob(g)))].filter(isCode).sort()
+}
+
+const scan = (paths: readonly string[], expression: RegExp): readonly Skip[] =>
+  skipsIn(
+    paths.map((path) => ({ path, text: read(path) ?? "" })),
+    expression,
+  )
+
+/** A section title as a repository path: backticks and a leading `./` dropped. */
+const pathOf = (title: string): string => title.replace(/`/g, "").trim().replace(/^\.\//, "")
+
+const below = (section: string): string => section.split("\n").slice(1).join("\n").trim()
+
+const sweepingPrompt = (skips: readonly Skip[]): string =>
+  `Sweep this repository's tests for ones to revive.
+
+Skipped tests gtd found:
+
+${skips.length === 0 ? "- none" : skips.map((s) => `- ${s.path}:${s.line} — ${s.text}`).join("\n")}
+
+- Audit every test in the repository with the test-audit skill — the whole
+  suite, not a recent change
+- Write \`${TESTS}\`: \`# Tests\`, then one \`## <path>\` section per test file
+  that needs work — every file listed above, and each file the audit found
+  worth rewriting — saying which tests are skipped and what the audit found
+- Change nothing else; write nothing when there is nothing to do
+- Leave everything uncommitted and finish your turn`
+
+const rewritingPrompt = (path: string, found: string): string =>
+  `Rewrite the tests in \`${path}\` until none is skipped and the suite is green.
+
+What the sweep found:
+
+${found || "_Nothing more than the skipped tests._"}
+
+- Unskip every skipped test in the file and make it pass, rewriting it where
+  it rotted, and fix what the audit found
+- A test that is obsolete — what it tests is gone, or another test already
+  covers it — stays skipped: never delete it. Propose its deletion in
+  \`${RETIRE}\` instead: a \`## <title>\` section naming \`${path}\`, the test,
+  and why it should go. A person decides. Propose a line gtd misread as
+  skipped (fixture text, a comment) the same way, saying so
+- Delete no test file
+- Leave everything uncommitted and finish your turn`
+
+const gateMessage = (): string =>
+  `The test baseline is red — gtd will not revive skipped tests on a broken suite.
+\`.gtd/FEEDBACK.md\` holds the failing output.
+
+What each change does next (then run \`gtd land\`):
+- **Retry check** — edit the code and/or \`.gtd/FEEDBACK.md\` to fix the failing tests (**tests-gate.check**).
+`
+
+const awaitMessage = (base: string): string =>
+  `\`.gtd/REVIEW.md\` holds one chunk per test the sweep would delete. Each ends in
+three boxes — tick exactly one: \`delete it\` (the test is deleted, then the
+suite runs), \`keep it skipped\` (dropped, recorded in the commit), or write your
+own answer over \`_your answer_\` and tick it (judged like a note). Every
+landing here is refused until each proposal holds exactly one tick. An agent
+turn that deleted a test file was refused; check the diff for tests removed
+inside a file.
+
+Review the revived tests yourself:
+
+    git diff ${base}
+
+Then run \`gtd land\`. A note or code edit of your own is read as feedback and
+built before you review again.
+`
+
+/** A proposal's own text, made a request the nit fixer acts on once the human ticks `delete it`. */
+const proposals = (text: string): LensReport["notes"] =>
+  sectionBodies(text).map((s, i) => ({
+    id: `R${i + 1}`,
+    title: s.title,
+    body: `Delete this skipped test.\n\n${below(s.body)}`,
+    answers: RETIRE_ANSWERS,
+  }))
+
+/** Sections of `text` that name `path` as a whole token — a trailing full stop still counts. */
+const naming = (text: string, path: string): number => {
+  const token = new RegExp(`(?<![\\w./-])${path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w/-])`)
+  // `./path` names the same file.
+  return sectionBodies(text).filter((s) => token.test(s.body.replace(/(^|[^\w.])\.\//g, "$1")))
+    .length
+}
+
+/** Refuses a test file a turn deleted, and a skip left in the file being rewritten that `.gtd/RETIRE.md` does not name. */
+const guardFor = (known: ReadonlySet<string>, expression: RegExp, path?: string) => (): void => {
+  const deleted = changes()
+    .filter((c) => c.status === "deleted" && known.has(c.path))
+    .map((c) => c.path)
+  if (deleted.length > 0)
+    refuse(
+      `gtd land: tests: ${deleted.join(", ")} deleted — a test goes only once a person ticks "delete it" at the review`,
+    )
+  // Only the file being rewritten: a skip a person kept at an earlier file's escalation stays theirs.
+  if (path === undefined) return
+  const skips = scan([path], expression)
+  // One proposal per skip left: a section naming the file covers one skip in it, never all.
+  const left = skips.slice(naming(read(RETIRE) ?? "", path))
+  if (left.length > 0)
+    refuse(
+      `gtd land: tests: ${left.map((s) => `${s.path}:${s.line}`).join(", ")} still skipped — revive it, or propose its deletion in ${RETIRE}`,
+    )
+}
+
+/** The sweep's packages, refused when it changed more than its plan or the plan misses a file. */
+const planned = (
+  skips: readonly Skip[],
+  known: ReadonlySet<string>,
+): readonly { path: string; found: string }[] => {
+  const strays = changes().filter((c) => c.path !== TESTS)
+  if (strays.length > 0)
+    refuse(
+      `gtd land: tests: the sweep changed ${strays.map((c) => c.path).join(", ")} — it writes only ${TESTS}`,
+    )
+  const packages = sectionBodies(read(TESTS) ?? "").map((s) => ({
+    path: pathOf(s.title),
+    found: below(s.body),
+  }))
+  const missing = [
+    ...packages.filter((p) => !known.has(p.path)).map((p) => `"${p.path}" is no test file`),
+    ...[...new Set(skips.map((s) => s.path))]
+      .filter((path) => !packages.some((p) => p.path === path))
+      .map((path) => `${path} has no section`),
+  ]
+  if (missing.length > 0) refuse(`gtd land: tests: in ${TESTS}, ${missing.join("; ")}`)
+  return packages
+}
+
+/**
+ * Revive or retire skipped tests: a sweep plans one package per test file, each
+ * is rewritten until unskipped and green, and what an agent calls obsolete
+ * reaches the human review as a deletion proposal only a person can tick.
+ */
+export const testsFlow = async (): Promise<void> => {
+  refusePendingHandOff()
+  for (const file of [REQUIREMENTS, TESTS, RETIRE]) {
+    if (read(file) !== undefined) refuse(`gtd: ${file} is left over — finish or remove it first.`)
+  }
+  const expression = skipExpression(vars.skipPattern ?? testsDefaults.skipPattern!)
+  await gate("tests-gate", gateMessage())
+  const base = start()
+  const known = new Set(testPaths())
+  // Sweep and rewrites only: the review's "delete it" fix is the one turn allowed to delete a test.
+  const guard = guardFor(known, expression)
+  const report = await scope("tests", async (): Promise<LensReport | undefined> => {
+    const skips = scan([...known], expression)
+    await t.agentWithSkills("sweeping", sweepingPrompt(skips), {
+      label: "Sweeping the tests",
+      file: TESTS,
+      model: coder(),
+      system: t.finisherSystem(),
+      allowEmpty: true,
+    })
+    guard()
+    const packages = planned(skips, known)
+    for (const { path, found } of packages) {
+      const guarded = guardFor(known, expression, path)
+      await t.agentWithSkills("rewriting", rewritingPrompt(path, found), {
+        label: `Rewriting ${path}`,
+        file: RETIRE,
+        model: coder(),
+        system: t.finisherSystem(),
+        // A file the audit only flagged may already be fine.
+        allowEmpty: true,
+      })
+      guarded()
+      // No code changed: the suite is as green as the last loop left it.
+      if (!changes().some((c) => isCode(c.path))) continue
+      // Unguarded human rests: a person at the escalation may delete or keep what they like.
+      await healthy(() => fixCheck(), { guard: guarded, guardRests: false })
+    }
+    const retired = proposals(read(RETIRE) ?? "")
+    if (read(TESTS) !== undefined || read(RETIRE) !== undefined) {
+      await run("closing", removeScript([TESTS, RETIRE]), { label: "Closing the sweep" })
+    }
+    // Nothing revived and nothing proposed: a review would hold no diff to sign off.
+    const changed = changesSince(base).paths.some(isCode)
+    return retired.length === 0 && !changed ? undefined : { notes: retired, fixed: [], noise: [] }
+  })
+  if (report === undefined) return
+  let outcome = await tail(
+    (escalations) =>
+      humanReview(base, escalations, {
+        report,
+        awaitMessage: report.notes.length > 0 ? awaitMessage : undefined,
+      }),
+    { lenses: [], green: true },
+  )
+  while (outcome.verdict === "feedback") {
+    await reUnwind(outcome)
+    await fixFeedback()
+    outcome = await tail((escalations) => humanReview(base, escalations), {
+      lenses: [],
+    })
+  }
+}
+
+export const tests = testsShipped(testsFlow)