claudeup 4.37.0 → 4.38.0

package/src/__tests__/terminology-filler.test.ts

@@ -0,0 +1,214 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import fs from "fs-extra";
+import { splitFrontmatter } from "../services/styles-manager.js";
+import {
+	buildPrompt,
+	fillTemplate,
+	fillTerminology,
+	parseTerminologyRows,
+	terminologyStyleFile,
+} from "../services/terminology-filler.js";
+
+/** The shape the shipped template actually has. */
+const TEMPLATE = [
+	"### Terminology",
+	"",
+	"One concept, one name, everywhere.",
+	"",
+	"| Use | Not | Because |",
+	"|---|---|---|",
+	"| <!-- filled during /style:apply --> | | |",
+	"",
+	"Rules that hold regardless of the table above:",
+	"",
+	"- Use the domain's word, not the implementation's.",
+].join("\n");
+
+describe("parseTerminologyRows", () => {
+	test("reads well-formed rows", () => {
+		expect(
+			parseTerminologyRows(
+				"| booking | reservation | the domain says booking\n",
+			),
+		).toEqual([
+			{
+				use: "booking",
+				not: "reservation",
+				because: "the domain says booking",
+			},
+		]);
+	});
+
+	test("ignores commentary around the table", () => {
+		// `claude -p` often frames its answer, however firmly it is told not to.
+		const out = [
+			"Here are the rows I found:",
+			"",
+			"| booking | reservation | the domain says booking |",
+			"| tenant | account | billing is per tenant |",
+			"",
+			"Let me know if you want more.",
+		].join("\n");
+		expect(parseTerminologyRows(out)).toHaveLength(2);
+	});
+
+	test("drops a header row and separator the model added anyway", () => {
+		const out = [
+			"| Use | Not | Because |",
+			"|---|---|---|",
+			"| booking | reservation | the domain says booking |",
+		].join("\n");
+		expect(parseTerminologyRows(out)).toEqual([
+			{
+				use: "booking",
+				not: "reservation",
+				because: "the domain says booking",
+			},
+		]);
+	});
+
+	test("drops an aligned separator too", () => {
+		expect(parseTerminologyRows("|:---|:---:|---:|\n| a | b | c |")).toEqual([
+			{ use: "a", not: "b", because: "c" },
+		]);
+	});
+
+	test("skips rows with the wrong number of cells", () => {
+		expect(parseTerminologyRows("| only | two |")).toEqual([]);
+		expect(parseTerminologyRows("| a | b | c | d |")).toEqual([]);
+	});
+
+	test("skips rows missing the two cells that carry meaning", () => {
+		expect(parseTerminologyRows("|  |  | because |")).toEqual([]);
+		expect(parseTerminologyRows("| use |  | because |")).toEqual([]);
+	});
+
+	test("returns nothing for output with no table at all", () => {
+		expect(parseTerminologyRows("I could not find any terminology.")).toEqual(
+			[],
+		);
+	});
+});
+
+describe("fillTemplate", () => {
+	test("replaces the placeholder row", () => {
+		const filled = fillTemplate(TEMPLATE, [
+			{ use: "booking", not: "reservation", because: "the domain says so" },
+		]);
+		expect(filled).not.toContain("filled during");
+		expect(filled).toContain("| booking | reservation | the domain says so |");
+	});
+
+	test("keeps the rules below the table verbatim", () => {
+		// These are substantive guidance. Losing them would leave a style that
+		// looks filled in and says almost nothing.
+		const filled = fillTemplate(TEMPLATE, [
+			{ use: "a", not: "b", because: "c" },
+		]);
+		expect(filled).toContain("Rules that hold regardless of the table above:");
+		expect(filled).toContain(
+			"- Use the domain's word, not the implementation's.",
+		);
+		expect(filled).toContain("### Terminology");
+	});
+
+	test("still places rows if the placeholder is gone", () => {
+		// Guards against the upstream template changing shape and this silently
+		// producing an empty table.
+		const noPlaceholder = TEMPLATE.replace(
+			"| <!-- filled during /style:apply --> | | |\n",
+			"",
+		);
+		const filled = fillTemplate(noPlaceholder, [
+			{ use: "a", not: "b", because: "c" },
+		]);
+		expect(filled).toContain("| a | b | c |");
+	});
+
+	test("refuses to produce a table with no rows", () => {
+		expect(() => fillTemplate(TEMPLATE, [])).toThrow(/No usable table rows/);
+	});
+});
+
+describe("terminologyStyleFile", () => {
+	test("keeps coding instructions on", () => {
+		const { frontmatter } = splitFrontmatter(terminologyStyleFile("### x"));
+		expect(frontmatter["keep-coding-instructions"]).toBe("true");
+		expect(frontmatter.name).toBe("terminology");
+	});
+});
+
+describe("buildPrompt", () => {
+	test("asks for rows only and includes the template for context", () => {
+		const prompt = buildPrompt(TEMPLATE);
+		expect(prompt).toContain("ONLY markdown table rows");
+		expect(prompt).toContain("No header row");
+		expect(prompt).toContain("### Terminology");
+	});
+});
+
+describe("fillTerminology", () => {
+	let dir: string;
+
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "claudeup-terminology-"));
+	});
+	afterEach(async () => {
+		await rm(dir, { recursive: true, force: true });
+	});
+
+	test("writes the filled style into the project so it commits with the repo", async () => {
+		const result = await fillTerminology({
+			projectPath: dir,
+			templateBody: TEMPLATE,
+			run: async () =>
+				"| booking | reservation | the domain says booking |\n| tenant | account | billing is per tenant |",
+		});
+
+		expect(result.rows).toHaveLength(2);
+		expect(result.path).toBe(
+			join(dir, ".claude", "output-styles", "terminology.md"),
+		);
+
+		const written = await fs.readFile(result.path, "utf8");
+		const { frontmatter, body } = splitFrontmatter(written);
+		expect(frontmatter.name).toBe("terminology");
+		expect(frontmatter["keep-coding-instructions"]).toBe("true");
+		expect(body).toContain("| booking | reservation |");
+		expect(body).toContain("Rules that hold regardless of the table above:");
+	});
+
+	test("writes nothing when the model returns no usable rows", async () => {
+		await expect(
+			fillTerminology({
+				projectPath: dir,
+				templateBody: TEMPLATE,
+				run: async () => "I could not determine any terminology.",
+			}),
+		).rejects.toThrow(/no usable table rows/i);
+
+		// A half-written or empty style file is worse than none: it would show up
+		// under Team looking finished.
+		expect(await fs.pathExists(join(dir, ".claude", "output-styles"))).toBe(
+			false,
+		);
+	});
+
+	test("propagates a failure from the subprocess without writing", async () => {
+		await expect(
+			fillTerminology({
+				projectPath: dir,
+				templateBody: TEMPLATE,
+				run: async () => {
+					throw new Error("claude exited 1");
+				},
+			}),
+		).rejects.toThrow(/claude exited 1/);
+		expect(await fs.pathExists(join(dir, ".claude", "output-styles"))).toBe(
+			false,
+		);
+	});
+});