wtf-p 0.7.4 → 0.8.0

package/vendors/clio-extension/runtime/extension.test.ts

@@ -0,0 +1,248 @@
+// Generated by WTF-P adapter compiler v5 from clio/runtime/extension.test.ts; do not edit.
+/**
+ * Package tests for the WTF-P desk, run by `clio-coder extensions test
+ * vendors/clio-extension`. One case per runtime tool, the write guard, the
+ * desk workspace and the desk without its plugin, each against a small valid
+ * project in a task-owned TMPDIR. The kit serves no plugin unless a case
+ * passes one.
+ */
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { test } from "node:test";
+import { fileURLToPath } from "node:url";
+import { createExtensionTestHost } from "@iowarp/clio-coder/extensions/testing";
+
+const ROOT = fileURLToPath(new URL("../", import.meta.url));
+const PROJECT = "desk-test";
+const AT = "2026-10-01T12:00:00Z";
+const GATE = "checkpoint-framing";
+
+function project(): string {
+	assert.ok(process.env.TMPDIR, "Tests need a task-owned TMPDIR.");
+	const workspace = mkdtempSync(path.join(process.env.TMPDIR, "wtfp-desk-test-"));
+	const put = (relative: string, value: unknown): void => {
+		mkdirSync(path.dirname(path.join(workspace, relative)), { recursive: true });
+		writeFileSync(path.join(workspace, relative), typeof value === "string" ? value : `${JSON.stringify(value, null, 2)}\n`);
+	};
+	put(".planning/project.json", {
+		schema: "wtfp.project.manifest/v1",
+		protocol_version: 1,
+		id: PROJECT,
+		title: "Logging on Shared Memory",
+		document_type: "research-article",
+		core_argument: "Shared memory removes the flush bottleneck without weakening durability.",
+		target: { audience: "Storage researchers", word_limit: 100 },
+		requirements: { must_have: [], should_have: [], out_of_scope: [] },
+		created_at: AT,
+		updated_at: AT,
+		artifacts: {
+			manifest: "project://manifest",
+			config: "project://config",
+			state: "project://state",
+			decisions: "project://decisions",
+			outline: "project://structure/outline",
+			materials: [],
+			manuscripts: [],
+			deliverables: [],
+			archives: [],
+		},
+	});
+	put(".planning/config.json", {
+		schema: "wtfp.project.config/v1",
+		project_id: PROJECT,
+		interaction_mode: "standard",
+		depth: "standard",
+		output_format: "markdown",
+		language: "en-US",
+		citation_style: "author-date",
+		gates: { confirm_outline: true, confirm_plan: true, confirm_write: true, confirm_review: true, confirm_delivery: true },
+		workflow: { research: true, plan_validation: true, argument_validation: true, coherence_validation: true },
+		safety: { destructive_requires_authorization: true, external_publish_requires_authorization: true, backup_before_major_edits: true },
+		parallelism: { enabled: false, max_workers: 1 },
+	});
+	put(".planning/state.json", {
+		schema: "wtfp.project.state/v1",
+		project_id: PROJECT,
+		revision: 3,
+		phase: "writing",
+		status: "active",
+		current_section_uri: "project://sections/introduction",
+		progress: { sections_total: 1, sections_complete: 0, word_target: 100, word_count: 0 },
+		active_checkpoint_uris: [`project://checkpoints/${GATE}`],
+		last_transition: { from: "planning", to: "writing", reason: "The plan is approved.", at: AT },
+		updated_at: AT,
+	});
+	put(".planning/structure/outline.json", {
+		schema: "wtfp.project.outline/v1",
+		project_id: PROJECT,
+		revision: 1,
+		thesis: "Shared memory removes the flush bottleneck without weakening durability.",
+		target_words: 100,
+		sections: [
+			{
+				id: "introduction",
+				title: "Introduction",
+				goal: "State the flush bottleneck and the contribution.",
+				argument_role: "setup",
+				word_target: 100,
+				wave: 1,
+				depends_on: [],
+				claim_ids: [],
+				research: { required: false, topics: [] },
+			},
+		],
+		updated_at: AT,
+	});
+	put(".planning/sections/introduction/section.json", {
+		schema: "wtfp.project.section/v1",
+		id: "introduction",
+		project_id: PROJECT,
+		outline_uri: "project://structure/outline",
+		title: "Introduction",
+		goal: "State the flush bottleneck and the contribution.",
+		status: "planned",
+		word_target: 100,
+		word_count: 0,
+		wave: 1,
+		depends_on: [],
+		claims: [],
+		artifacts: {
+			context: "project://sections/introduction/context",
+			research: "project://sections/introduction/research",
+			plans: ["project://sections/introduction/plans/initial"],
+			reviews: [],
+			manuscript: "project://paper/introduction",
+		},
+		checkpoint_uris: [`project://checkpoints/${GATE}`],
+		validation_uris: [],
+		updated_at: AT,
+	});
+	put(`.planning/checkpoints/${GATE}.json`, {
+		schema: "wtfp.project.checkpoint/v1",
+		id: GATE,
+		project_id: PROJECT,
+		kind: "decision",
+		status: "pending",
+		blocking: true,
+		scope_uri: "project://sections/introduction",
+		request: "Lead with the protocol or with the workflow?",
+		options: [
+			{ id: "protocol-first", label: "Protocol first", implication: "Lead with interoperability." },
+			{ id: "workflow-first", label: "Workflow first", implication: "Lead with the end-to-end process." },
+		],
+		resume_action: "write-section",
+		created_at: AT,
+	});
+	// Eleven body words: front matter, the heading, the citation key and the code block do not count.
+	put(
+		"paper/introduction.md",
+		"---\ntitle: Introduction\n---\n# Introduction\n\nShared memory changes the cost of logging [@smith2024]. It's a well-known trade-off.\n\n```c\nint flush = 1;\n```\n",
+	);
+	return workspace;
+}
+
+type Json = Record<string, unknown>;
+const read = (workspace: string, relative: string): Json => JSON.parse(readFileSync(path.join(workspace, relative), "utf8")) as Json;
+
+const SERVED = { id: "wtfp", prompts: ["wtfp:check-todos", "wtfp:plan-section", "wtfp:progress", "wtfp:write-section"] };
+
+async function withDesk(
+	run: (host: Awaited<ReturnType<typeof createExtensionTestHost>>, workspace: string) => Promise<void>,
+	plugin: typeof SERVED | null = null,
+): Promise<void> {
+	const workspace = project();
+	const host = await createExtensionTestHost(ROOT, { workspace, plugin });
+	try {
+		await run(host, workspace);
+	} finally {
+		await host.dispose();
+		rmSync(workspace, { recursive: true, force: true });
+	}
+}
+
+test("record writes a validated record at the revision the caller read and refuses a stale or invalid one", () =>
+	withDesk(async (host, workspace) => {
+		const state = read(workspace, ".planning/state.json");
+		const written = await host.tool("record", { uri: "project://state", record: { ...state, phase: "reviewing" }, expect_revision: 3 });
+		assert.equal(written.isError, undefined, written.text);
+		assert.deepEqual(written.data, { uri: "project://state", file: ".planning/state.json", revision: 4 });
+		assert.equal(read(workspace, ".planning/state.json").phase, "reviewing");
+		const stale = await host.tool("record", { uri: "project://state", record: { ...state, phase: "ready" }, expect_revision: 3 });
+		assert.equal(stale.isError, true);
+		assert.match(stale.text, /revision 4, not 3/);
+		const invalid = await host.tool("record", { uri: "project://state", record: { ...state, phase: "drafting" } });
+		assert.equal(invalid.isError, true);
+		assert.match(invalid.text, /would not validate/);
+		assert.deepEqual([read(workspace, ".planning/state.json").phase, read(workspace, ".planning/state.json").revision], ["reviewing", 4]);
+	}));
+
+test("measure_section counts body words by the desk's one method and records them in the section and state", () =>
+	withDesk(async (host, workspace) => {
+		const measured = await host.tool("measure_section", { section: "introduction" });
+		assert.equal(measured.isError, undefined, measured.text);
+		assert.deepEqual(measured.data, { words: 11, target: 100, file: "paper/introduction.md", total: 11 });
+		assert.equal(read(workspace, ".planning/sections/introduction/section.json").word_count, 11);
+		assert.equal((read(workspace, ".planning/state.json").progress as Json).word_count, 11);
+	}));
+
+test("gate asks the author and records only the author's answer", () =>
+	withDesk(async (host, workspace) => {
+		const asked = await host.tool("gate", { checkpoint: GATE });
+		assert.equal(asked.interview?.id, "gate-one");
+		assert.equal(asked.interview?.step.key, GATE);
+		assert.equal(read(workspace, `.planning/checkpoints/${GATE}.json`).status, "pending");
+		const answered = await host.interview({ id: "gate-one", step: GATE, nav: "next", answers: { choice: "workflow-first" } });
+		assert.match("done" in answered ? answered.text : "", /Recorded the author's answer/);
+		const checkpoint = read(workspace, `.planning/checkpoints/${GATE}.json`);
+		assert.equal(checkpoint.status, "resolved");
+		assert.deepEqual(
+			[(checkpoint.resolution as Json).resolved_by, (checkpoint.resolution as Json).selected_option],
+			["author", "workflow-first"],
+		);
+		assert.deepEqual(read(workspace, ".planning/state.json").active_checkpoint_uris, []);
+	}));
+
+test("the write guard refuses a write outside the roots the armed action declares", () =>
+	withDesk(async (host) => {
+		const armed = await host.hook({ point: "prompt_submit", text: "/wtfp:write-section introduction" });
+		assert.equal(armed.effects?.[0]?.kind, "notify_operator");
+		const refused = await host.hook({ point: "before_tool", tool: "write", turnId: "t1", args: { path: "src/notes.md" } });
+		const effect = refused.effects?.[0];
+		assert.equal(effect?.kind, "block_tool");
+		assert.match(effect && "reason" in effect ? effect.reason : "", /\/wtfp:write-section may write only under \.planning, paper; refused src\/notes\.md/);
+	}, SERVED));
+
+test("the desk enters with its four regions and clears its ambient UI when left in a folder with no project", async () => {
+	assert.ok(process.env.TMPDIR, "Tests need a task-owned TMPDIR.");
+	const workspace = mkdtempSync(path.join(process.env.TMPDIR, "wtfp-desk-empty-"));
+	const host = await createExtensionTestHost(ROOT, { workspace });
+	try {
+		const entered = await host.command("desk");
+		assert.deepEqual(entered.workspace, { enter: "desk" });
+		assert.deepEqual(Object.keys(entered.regions ?? {}), ["header", "board", "rail", "footer"]);
+		assert.match(JSON.stringify(entered.band), /new-paper/);
+		const left = await host.observe({ event: "workspace_leave", workspace: "desk" });
+		assert.deepEqual(left, { text: "", status: null, band: null, islands: null });
+	} finally {
+		await host.dispose();
+		rmSync(workspace, { recursive: true, force: true });
+	}
+});
+
+test("without its plugin the desk names only its own commands and never a /wtfp: prompt", () =>
+	withDesk(async (host) => {
+		const outputs: unknown[] = [];
+		for (const name of ["desk", "progress", "help", "check-todos", "checkpoints", "validate"]) outputs.push(await host.command(name));
+		for (const id of ["next", "help"]) outputs.push(await host.action(id));
+		outputs.push(await host.action("section", "introduction"));
+		outputs.push(await host.hook({ point: "prompt_submit", text: "/wtfp:write-section introduction" }));
+		outputs.push(await host.hook({ point: "before_tool", tool: "write", turnId: "t1", args: { path: "src/notes.md" } }));
+		await host.hook({ point: "prompt_submit", text: "plain text" });
+		outputs.push(await host.hook({ point: "before_tool", tool: "write", turnId: "t1", args: { path: "paper/introduction.md" } }));
+		outputs.push(await host.observe({ event: "session_open", reason: "startup" }));
+		const emitted = JSON.stringify(outputs);
+		assert.doesNotMatch(emitted, /\/wtfp:/);
+		assert.match(emitted, /\/ext:wtfp:check-todos/);
+		assert.match(emitted, /needs the WTF-P plugin|not installed and enabled/);
+	}));