@pmelab/gtd 58.0.0 → 58.2.0

package/dist/gtd.bundle.mjs

@@ -38979,7 +38979,7 @@ const WORKFLOW_MODULE = "gtd.config.ts";
 * The file names gtd read repository settings from before `gtd.config.ts` took
 * them over. Still looked for, only to refuse them: a leftover one would
 * otherwise be silently ignored. Shared with the in-memory counterpart in
-* `src/testkit/Layers.ts`, so both tiers refuse the same names.
+* `src/twins/Layers.ts`, so both tiers refuse the same names.
 */
 const LEGACY_RC_FILES = [
 	".gtdrc",
@@ -39011,7 +39011,7 @@ const legacyRcFileAt = (path) => {
 * the user's home dir (inclusive, when it is an ancestor) or after reaching the
 * filesystem root — whichever comes first. Returned innermost→outermost.
 * Exported (via the barrel) for the same reason `SEARCH_PLACES` is — one
-* shared implementation, not a second copy in `src/testkit/Layers.ts` that
+* shared implementation, not a second copy in `src/twins/Layers.ts` that
 * could silently diverge.
 */
 const walkUp = (from, home) => {
@@ -39045,7 +39045,7 @@ const workflowModule = (root, home) => try_({
 * reads; discovery is effectful and environment-dependent: `.Live` reads
 * REAL disk, so an `@inmem` scenario's fake
 * `Workspace` — a pure in-memory `Map`, no real files anywhere on disk —
-* cannot back it. `src/testkit/Layers.ts` provides the in-memory
+* cannot back it. `src/twins/Layers.ts` provides the in-memory
 * counterpart instead, mirroring how `Workspace`/`Host`/`GitService` already
 * each have a production and a fake layer behind one Tag.
 */
@@ -39295,13 +39295,13 @@ const shippedModules = () => shippedMemo ??= (async () => {
 		missing
 	};
 })();
-/** The file each subpath a config may import serves: all but `flows`, the engine's own, and `testkit`. */
+/** The file each subpath a config may import serves: all but `flows`, the engine's own, and the testkit's. */
 const subpathFiles = (condition) => {
 	const { root, pkg } = ownPackage();
 	const files = /* @__PURE__ */ new Map();
 	for (const [subpath, target] of Object.entries(pkg.exports)) {
 		const file = typeof target === "string" ? target : target[condition];
-		if (subpath === "./flows" || subpath === "./testkit" || file === void 0) continue;
+		if (subpath === "./flows" || subpath.startsWith("./testkit") || file === void 0) continue;
 		files.set(`${PACKAGE}/${subpath.replace(/^\.\//, "")}`, join(root, file));
 	}
 	return files;
@@ -40918,7 +40918,7 @@ const fetchHistoryRefs = (remote) => [
 	`after=$(git for-each-ref --format='x' 'refs/gtd/history/' | wc -l)`,
 	`printf '%s history refs arrived\\n' "$((after - before))"`
 ].join("\n");
-/** Marks an emitted block as print-only — mirrors `OutcomeScript.ts`'s `OUTCOME_MARKER` verbatim, so `src/testkit/EmittedScriptRecognizer.ts` recognizes either path's output identically. */
+/** Marks an emitted block as print-only — mirrors `OutcomeScript.ts`'s `OUTCOME_MARKER` verbatim, so `src/twins/EmittedScriptRecognizer.ts` recognizes either path's output identically. */
 const OUTCOME_MARKER$1 = "# gtd: outcome (print-only)";
 const printfLine$1 = (fmt, args) => `${OUTCOME_MARKER$1}\nprintf ${shellQuote$1(fmt.replace(/\n/g, "\\n"))} ${args.join(" ")}`;
 const renderOutcome = (outcome) => {
@@ -41032,7 +41032,7 @@ const emitScripts = (required = [], optional = []) => ({
 	required: assembleScript(required),
 	optional: assembleScript(optional)
 });
-/** Exported so `src/testkit/EmittedScriptRecognizer.ts` can recognize these by exact string comparison. `printf`, not `echo`, avoids shell-specific backslash-escape quirks. */
+/** Exported so `src/twins/EmittedScriptRecognizer.ts` can recognize these by exact string comparison. `printf`, not `echo`, avoids shell-specific backslash-escape quirks. */
 const DID_NOT_RUN_COMMENT = "# gtd emitted this and did NOT run it — pipe it into `sh` to land the turn";
 const PRESENTATION_ONLY_COMMENT = "# presentation only — safe to skip";
 const PRESENTATION_FAILURE_WARNING = "printf 'gtd: presentation-only follow-up failed — continuing\\n' >&2";
@@ -41070,7 +41070,7 @@ const combinedScript = (required, optional) => {
 const printfLine = (fmt, args) => `${OUTCOME_MARKER}\nprintf ${shellQuote$1(fmt.replace(/\n/g, "\\n"))} ${args.join(" ")}`;
 /**
 * Marks an emitted block as print-only. Load-bearing beyond documentation:
-* `src/testkit/EmittedScriptRecognizer.ts` recognizes an outcome block by
+* `src/twins/EmittedScriptRecognizer.ts` recognizes an outcome block by
 * this line, and a bare `printf` would be ambiguous with a workflow
 * `script:` command that happens to start the same way.
 */

package/dist/testkit/gherkin.mjs

@@ -0,0 +1,283 @@
+import { n as testRepo, t as runsItsScript } from "../chunks/testkit-JDtpNKyi.mjs";
+import { resolve } from "node:path";
+import assert from "node:assert";
+import { pathToFileURL } from "node:url";
+import { Given, QuickPickleWorld, Then, When, setWorldConstructor } from "quickpickle";
+//#region src/gherkin/index.ts
+var TestkitWorld = class extends QuickPickleWorld {
+	constructor(context, info) {
+		super(context, info);
+	}
+	gtdConfig = void 0;
+	env = {};
+	commands = [];
+	/** Per step, what its scripted actor does, in the order the scenario declared it. */
+	actions = /* @__PURE__ */ new Map();
+	verdicts = /* @__PURE__ */ new Map();
+	/** Per judge step, a verdict for each text its questions may contain; the first match answers. */
+	conditionalVerdicts = /* @__PURE__ */ new Map();
+	created = void 0;
+	configure(config) {
+		this.assertNotCreated("a gtd config");
+		this.gtdConfig = config;
+	}
+	extendConfig(tail) {
+		this.assertNotCreated("a gtd config");
+		if (this.gtdConfig === void 0) throw new Error("no gtd config to extend");
+		if (typeof this.gtdConfig !== "string") throw new Error("a gtd config from a module cannot be extended");
+		this.gtdConfig += `\n${tail}`;
+	}
+	command(command) {
+		if (this.created === void 0) this.commands.push(command);
+		else this.created.command(command);
+	}
+	setEnv(name, value) {
+		this.assertNotCreated(`the environment variable ${name}`);
+		this.env[name] = value;
+	}
+	assertNotCreated(what) {
+		if (this.created !== void 0) throw new Error(`${what} must be set before any step that touches the repository`);
+	}
+	repo() {
+		if (this.gtdConfig === void 0) throw new Error("no gtd config: add a `gtd config` step first");
+		return this.created ??= testRepo({
+			workflow: this.gtdConfig,
+			env: this.env,
+			commands: this.commands
+		});
+	}
+	act(step, action) {
+		this.actions.set(step, [...this.actions.get(step) ?? [], action]);
+	}
+	async drive() {
+		const actors = {};
+		for (const [step, actions] of this.actions) actors[step] = async (beat, repo) => {
+			for (const action of actions) await action(beat, repo);
+		};
+		for (const [step, verdict] of this.verdicts) {
+			if (this.actions.has(step)) throw new Error(`step "${step}" has a judge verdict and queued actions; the actions would never run`);
+			actors[step] = () => verdict;
+		}
+		for (const [step, choices] of this.conditionalVerdicts) {
+			if (this.actions.has(step) || this.verdicts.has(step)) throw new Error(`step "${step}" has a conditional verdict and another script`);
+			actors[step] = async (_, repo) => {
+				const { stdout } = await repo.gtd("judge");
+				const hit = choices.find(([text]) => stdout.includes(text));
+				if (hit === void 0) throw new Error(`judge step "${step}" matched no verdict:\n${stdout}`);
+				return hit[1];
+			};
+		}
+		await this.repo().drive(actors);
+	}
+};
+setWorldConstructor(TestkitWorld);
+const withNewline = (content) => content.endsWith("\n") ? content : `${content}\n`;
+const args = (list) => list.split(" ").filter((arg) => arg !== "");
+Given("a gtd config with:", (world, source) => {
+	world.configure(withNewline(source));
+});
+Given("a gtd config from the module {string}", async (world, path) => {
+	world.configure({ ...await import(pathToFileURL(resolve(path)).href) });
+});
+Given("the gtd config ends with:", (world, source) => {
+	world.extendConfig(withNewline(source));
+});
+Given("an environment variable {string} set to {string}", (world, name, value) => {
+	world.setEnv(name, value);
+});
+Given("the command {string} exits {int}", (world, run, exit) => {
+	world.command({
+		run,
+		exit
+	});
+});
+Given("the command {string} exits {int} with:", (world, run, exit, output) => {
+	world.command({
+		run,
+		exit,
+		output: withNewline(output)
+	});
+});
+Given("a branch {string}", (world, name) => {
+	world.repo().branch(name);
+});
+Given("{string} is checked out", (world, name) => {
+	world.repo().checkout(name);
+});
+Given("the ref {string} points at HEAD", (world, name) => {
+	world.repo().ref(name);
+});
+Given("a file {string} with:", (world, path, content) => {
+	world.repo().write(path, withNewline(content));
+});
+Given("the file {string} is deleted", (world, path) => {
+	world.repo().remove(path);
+});
+Given("the text {string} in {string} is replaced with {string}", (world, text, path, replacement) => {
+	const content = world.repo().read(path) ?? "";
+	assert.ok(content.includes(text), `${path}: ${content}`);
+	world.repo().write(path, content.replace(text, () => replacement));
+});
+Given("{string} gets appended:", (world, path, text) => {
+	const content = world.repo().read(path) ?? "";
+	world.repo().write(path, `${content.trimEnd()}\n\n${text}\n`);
+});
+Given("the working tree is committed as {string}", (world, message) => {
+	world.repo().commit(message);
+});
+Given("the working tree is committed with the message:", (world, message) => {
+	world.repo().commit(message);
+});
+Given("step {string} changes nothing", (world, step) => {
+	world.act(step, () => void 0);
+});
+Given("step {string} from now on changes nothing", (world, step) => {
+	world.actions.set(step, [() => void 0]);
+});
+Given("step {string} is no longer scripted", (world, step) => {
+	world.actions.delete(step);
+});
+Given("step {string} writes {string} with:", (world, step, path, content) => {
+	world.act(step, (_, repo) => repo.write(path, withNewline(content)));
+});
+Given("step {string}, when prompted with {string}, writes {string} with:", (world, step, text, path, content) => {
+	world.act(step, (beat, repo) => {
+		if (beat.content.includes(text)) repo.write(path, withNewline(content));
+	});
+});
+Given("step {string} appends to {string}:", (world, step, path, text) => {
+	world.act(step, (_, repo) => {
+		repo.write(path, `${(repo.read(path) ?? "").trimEnd()}\n\n${withNewline(text)}`);
+	});
+});
+Given("step {string} replaces the text {string} in {string} with {string}", (world, step, text, path, replacement) => {
+	world.act(step, (_, repo) => {
+		const content = repo.read(path) ?? "";
+		assert.ok(content.includes(text), `${path}: ${content}`);
+		repo.write(path, content.replace(text, () => replacement));
+	});
+});
+Given("step {string} deletes {string}", (world, step, path) => {
+	world.act(step, (_, repo) => repo.remove(path));
+});
+Given("step {string} is prompted with {string}", (world, step, text) => {
+	world.act(step, (beat) => {
+		if (!beat.content.includes(text)) throw new Error(`step "${step}" was not prompted with "${text}":\n${beat.content}`);
+	});
+});
+Given("step {string} rewrites {string} with:", (world, step, path, content) => {
+	world.act(step, (_, repo) => {
+		if (repo.read(path) !== void 0) repo.write(path, withNewline(content));
+	});
+});
+Given("step {string} runs its script", (world, step) => {
+	world.act(step, runsItsScript);
+});
+Given("judge step {string} answers:", (world, step, verdict) => {
+	world.verdicts.set(step, String(verdict));
+});
+Given("judge step {string}, when its questions contain {string}, answers:", (world, step, text, verdict) => {
+	world.conditionalVerdicts.set(step, [...world.conditionalVerdicts.get(step) ?? [], [text, String(verdict)]]);
+});
+When("gtd starts workflow {string}", async (world, workflow) => {
+	await world.repo().start(workflow);
+});
+When("gtd starts workflow {string} with {string}", async (world, workflow, list) => {
+	await world.repo().start(workflow, ...args(list));
+});
+When("gtd opens door {string}", async (world, door) => {
+	await world.repo().door(door);
+});
+When("gtd opens door {string} with {string}", async (world, door, list) => {
+	await world.repo().door(door, ...args(list));
+});
+When("gtd lands", async (world) => {
+	await world.repo().land();
+});
+When("the process is driven", async (world) => {
+	await world.drive();
+});
+Then("opening door {string} is refused with {string}", async (world, door, message) => {
+	await assert.rejects(world.repo().door(door), (error) => error.message.includes(message));
+});
+Then("starting workflow {string} with {string} is refused with {string}", async (world, workflow, list, message) => {
+	await assert.rejects(world.repo().start(workflow, ...args(list)), (error) => error.message.includes(message));
+});
+Then("landing is refused with {string}", async (world, message) => {
+	await assert.rejects(world.repo().land(), (error) => error.message.includes(message));
+});
+Then("driving the process is refused with {string}", async (world, message) => {
+	await assert.rejects(world.drive(), (error) => error.message.includes(message));
+});
+Then("driving the process is refused without {string}", async (world, message) => {
+	await assert.rejects(world.drive(), (error) => !error.message.includes(message));
+});
+Then("the process rests at {string}", async (world, step) => {
+	assert.strictEqual((await world.repo().next()).state, step);
+});
+Then("the resting step's content contains {string}", async (world, text) => {
+	const { content } = await world.repo().next();
+	assert.ok(content.includes(text), content);
+});
+Then("the resting step's content contains the hash of the commit {string}", async (world, subject) => {
+	const repo = world.repo();
+	const hash = repo.hashes()[repo.subjects().lastIndexOf(subject)];
+	assert.ok(hash !== void 0, `no commit "${subject}"`);
+	const { content } = await repo.next();
+	assert.ok(content.includes(hash), content);
+});
+Then("the resting step's content does not contain {string}", async (world, text) => {
+	const { content } = await world.repo().next();
+	assert.ok(!content.includes(text), content);
+});
+Then("the last commit subject is {string}", (world, subject) => {
+	assert.strictEqual(world.repo().subjects().at(-1), subject);
+});
+Then("the commit subjects end with:", (world, list) => {
+	const expected = list.split("\n").filter((line) => line.trim() !== "");
+	assert.deepStrictEqual(world.repo().subjects().slice(-expected.length), expected);
+});
+const outputOf = async (world, list) => {
+	const result = await world.repo().gtd(...args(list));
+	assert.strictEqual(result.exitCode, 0, result.stderr);
+	return result.stdout;
+};
+Then("the output of gtd {string} contains {string}", async (world, list, text) => {
+	const out = await outputOf(world, list);
+	assert.ok(out.includes(text), out);
+});
+Then("the output of gtd {string} does not contain {string}", async (world, list, text) => {
+	const out = await outputOf(world, list);
+	assert.ok(!out.includes(text), out);
+});
+Then("the output lines of gtd {string} start with:", async (world, list, prefixes) => {
+	const out = (await outputOf(world, list)).split("\n").filter((line) => line !== "");
+	const expected = prefixes.split("\n").filter((line) => line.trim() !== "");
+	assert.strictEqual(out.length, expected.length, out.join("\n"));
+	out.forEach((line, i) => assert.ok(line.startsWith(expected[i]), out.join("\n")));
+});
+Then("{string} contains {string}", (world, path, text) => {
+	assert.ok(world.repo().read(path)?.includes(text), `${path}: ${world.repo().read(path)}`);
+});
+Then("{string} contains:", (world, path, text) => {
+	assert.ok(world.repo().read(path)?.includes(text), `${path}: ${world.repo().read(path)}`);
+});
+Then("{string} contains the short hash of the commit {string}", (world, path, subject) => {
+	const repo = world.repo();
+	const hash = repo.hashes()[repo.subjects().lastIndexOf(subject)];
+	assert.ok(hash !== void 0, `no commit "${subject}"`);
+	assert.ok(repo.read(path)?.includes(hash.slice(0, 7)), `${path}: ${repo.read(path)}`);
+});
+Then("{string} contains {string} exactly once", (world, path, text) => {
+	const content = world.repo().read(path) ?? "";
+	assert.strictEqual(content.split(text).length - 1, 1, `${path}: ${content}`);
+});
+Then("{string} does not contain {string}", (world, path, text) => {
+	const content = world.repo().read(path);
+	assert.ok(content !== void 0 && !content.includes(text), `${path}: ${content}`);
+});
+Then("{string} does not exist", (world, path) => {
+	assert.strictEqual(world.repo().read(path), void 0);
+});
+//#endregion
+export { TestkitWorld };