@pmelab/gtd 45.2.0 → 46.0.0

package/dist/workflows/tests.mjs

@@ -1,193 +0,0 @@
-import { changes, changesSince, glob, read, refuse, removeScript, run, scope, sectionBodies, start, vars } from "../flows.mjs";
-import { E as fixCheck, Et as envDefaults, J as finisherSystem, Ot as testsDefaults, P as agentWithSkills, Tt as defaults, c as testsShipped, d as gate, i as skills, n as summary, p as healthy, r as access, t as steering, w as coder, y as REQUIREMENTS } from "../chunks/reserved-FWrjy7zo.mjs";
-import { a as refusePendingHandOff, o as tail } from "../chunks/tail-B-Es6Hwj.mjs";
-import { a as reUnwind, i as isCode, n as fixFeedback, r as humanReview } from "../chunks/review-Dhl4vvDe.mjs";
-//#region src/workflows/tests/tests.ts
-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 = ["delete it", "keep it skipped"];
-testsDefaults.skipPattern;
-/** `skipPattern` as a per-line expression; refuses one that is blank, invalid, or matches every line. */
-const skipExpression = (pattern) => {
-	if (pattern.trim() === "") return refuse("gtd: skipPattern must not be blank");
-	let expression;
-	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. */
-const skipsIn = (files, expression) => files.flatMap(({ path, text }) => text.split("\n").flatMap((line, i) => expression.test(line) ? [{
-	path,
-	line: i + 1,
-	text: line.trim()
-}] : []));
-const testPaths = () => {
-	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, expression) => skipsIn(paths.map((path) => ({
-	path,
-	text: read(path) ?? ""
-})), expression);
-/** A section title as a repository path: backticks and a leading `./` dropped. */
-const pathOf = (title) => title.replace(/`/g, "").trim().replace(/^\.\//, "");
-const below = (section) => section.split("\n").slice(1).join("\n").trim();
-const sweepingPrompt = (skips) => `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, found) => `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 = () => `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) => `\`.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) => 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, path) => {
-	const token = new RegExp(`(?<![\\w./-])${path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w/-])`);
-	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, expression, path) => () => {
-	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`);
-	if (path === void 0) return;
-	const left = scan([path], expression).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, known) => {
-	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.
-*/
-const testsFlow = async () => {
-	refusePendingHandOff();
-	for (const file of [
-		REQUIREMENTS,
-		TESTS,
-		RETIRE
-	]) if (read(file) !== void 0) 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());
-	const guard = guardFor(known, expression);
-	const report = await scope("tests", async () => {
-		const skips = scan([...known], expression);
-		await agentWithSkills("sweeping", sweepingPrompt(skips), {
-			label: "Sweeping the tests",
-			file: TESTS,
-			model: coder(),
-			system: finisherSystem(),
-			allowEmpty: true
-		});
-		guard();
-		const packages = planned(skips, known);
-		for (const { path, found } of packages) {
-			const guarded = guardFor(known, expression, path);
-			await agentWithSkills("rewriting", rewritingPrompt(path, found), {
-				label: `Rewriting ${path}`,
-				file: RETIRE,
-				model: coder(),
-				system: finisherSystem(),
-				allowEmpty: true
-			});
-			guarded();
-			if (!changes().some((c) => isCode(c.path))) continue;
-			await healthy(() => fixCheck(), {
-				guard: guarded,
-				guardRests: false
-			});
-		}
-		const retired = proposals(read(RETIRE) ?? "");
-		if (read(TESTS) !== void 0 || read(RETIRE) !== void 0) await run("closing", removeScript([TESTS, RETIRE]), { label: "Closing the sweep" });
-		const changed = changesSince(base).paths.some(isCode);
-		return retired.length === 0 && !changed ? void 0 : {
-			notes: retired,
-			fixed: [],
-			noise: []
-		};
-	});
-	if (report === void 0) return;
-	let outcome = await tail((escalations) => humanReview(base, escalations, {
-		report,
-		awaitMessage: report.notes.length > 0 ? awaitMessage : void 0
-	}), {
-		lenses: [],
-		green: true
-	});
-	while (outcome.verdict === "feedback") {
-		await reUnwind(outcome);
-		await fixFeedback();
-		outcome = await tail((escalations) => humanReview(base, escalations), { lenses: [] });
-	}
-};
-const tests = testsShipped(testsFlow);
-//#endregion
-//#region src/workflows/tests/index.ts
-var tests_default = tests;
-//#endregion
-export { access, tests_default as default, defaults, envDefaults, skills, steering, summary, tests, testsFlow };

package/src/workflows/tests/index.ts

@@ -1,6 +0,0 @@
-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

@@ -1,52 +0,0 @@
-@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

@@ -1,266 +0,0 @@
-@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

@@ -1,51 +0,0 @@
-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" },
-    ])
-  })
-})