claudeup 4.37.0 → 4.38.0

package/src/__tests__/styles-origins.test.ts

@@ -0,0 +1,416 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm, utimes } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import fs from "fs-extra";
+import {
+	communityCacheDirOrNull,
+	createTeamStyle,
+	loadStyles,
+	splitFrontmatter,
+	stripBuiltinPrefix,
+	styleSlug,
+} from "../services/styles-manager.js";
+
+let dir: string;
+let home: string;
+let previousConfigDir: string | undefined;
+
+beforeEach(async () => {
+	dir = await mkdtemp(join(tmpdir(), "claudeup-origins-"));
+	home = join(dir, "home");
+	// The community cache resolves through CLAUDE_CONFIG_DIR when it is set, and
+	// another suite may have left one behind. Clearing it here makes the `home`
+	// override the only thing deciding where these tests look.
+	previousConfigDir = process.env.CLAUDE_CONFIG_DIR;
+	// Must be ABSENT, not assigned undefined: `process.env.X = undefined` stores
+	// the STRING "undefined", which is truthy, so the resolver would happily
+	// build a path under a directory literally called "undefined".
+	// biome-ignore lint/performance/noDelete: absence is the intent, not a shortcut
+	delete process.env.CLAUDE_CONFIG_DIR;
+});
+afterEach(async () => {
+	await rm(dir, { recursive: true, force: true });
+	// biome-ignore lint/performance/noDelete: same reason as above
+	if (previousConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+	else process.env.CLAUDE_CONFIG_DIR = previousConfigDir;
+});
+
+/** Write a project-scoped output style with the given frontmatter lines. */
+async function writeProjectStyle(
+	name: string,
+	frontmatter: string[],
+): Promise<string> {
+	const file = join(dir, ".claude", "output-styles", `${name}.md`);
+	await fs.outputFile(
+		file,
+		["---", ...frontmatter, "---", "", "Some rules."].join("\n"),
+	);
+	return file;
+}
+
+/** Write a user-scoped output style under the temporary home. */
+async function writeUserStyle(
+	name: string,
+	frontmatter: string[],
+): Promise<string> {
+	const file = join(home, ".claude", "output-styles", `${name}.md`);
+	await fs.outputFile(
+		file,
+		["---", ...frontmatter, "---", "", "Some rules."].join("\n"),
+	);
+	return file;
+}
+
+/** Write a style into the claudeup community cache under the temporary home. */
+async function writeCachedCommunityStyle(
+	name: string,
+	frontmatter: string[],
+): Promise<string> {
+	const cacheDir = communityCacheDirOrNull(home);
+	if (!cacheDir)
+		throw new Error("community cache dir did not resolve under test");
+	const file = join(cacheDir, `${name}.md`);
+	await fs.outputFile(
+		file,
+		["---", ...frontmatter, "---", "", "Some rules."].join("\n"),
+	);
+	return file;
+}
+
+describe("stripBuiltinPrefix", () => {
+	test("turns the slug into something readable", () => {
+		expect(stripBuiltinPrefix("builtin-explanatory")).toBe("Explanatory");
+		expect(stripBuiltinPrefix("builtin-plain-text")).toBe("Plain text");
+	});
+
+	test("leaves a name that has no prefix alone apart from casing", () => {
+		expect(stripBuiltinPrefix("house-style")).toBe("House style");
+	});
+});
+
+describe("styleSlug", () => {
+	test("makes a filename-safe name", () => {
+		expect(styleSlug("  House Style  ")).toBe("house-style");
+		expect(styleSlug("Team/Voice")).toBe("team-voice");
+	});
+
+	test("strips path traversal rather than preserving it", () => {
+		// The slug becomes a filename under .claude/output-styles/, so anything
+		// that could climb out of that directory must not survive.
+		expect(styleSlug("../../etc/passwd")).toBe("etc-passwd");
+		expect(styleSlug("..")).toBe("");
+	});
+});
+
+describe("origin classification", () => {
+	test("a captured built-in is Anthropic official, named by its captured-style", () => {
+		// capture-builtin.ts writes `captured-style` with Anthropic's own name.
+		return (async () => {
+			await writeProjectStyle("builtin-explanatory", [
+				"name: builtin-explanatory",
+				'description: "Captured built-in output style: Explanatory"',
+				"captured-from: 2.1.233",
+				"captured-style: Explanatory",
+			]);
+			const snapshot = await loadStyles(dir, { home });
+			const style = snapshot.imports.find(
+				(s) => s.name === "builtin-explanatory",
+			);
+			expect(style?.origin).toBe("anthropic");
+			expect(style?.displayName).toBe("Explanatory");
+			expect(style?.capturedFrom).toBe("2.1.233");
+		})();
+	});
+
+	test("the builtin- name alone is enough when captured-style is absent", async () => {
+		await writeProjectStyle("builtin-learning", ["name: builtin-learning"]);
+		const snapshot = await loadStyles(dir, { home });
+		const style = snapshot.imports.find((s) => s.name === "builtin-learning");
+		expect(style?.origin).toBe("anthropic");
+		expect(style?.displayName).toBe("Learning");
+	});
+
+	test("a project style the user wrote is a team style", async () => {
+		await writeProjectStyle("house", ["name: house"]);
+		const snapshot = await loadStyles(dir, { home });
+		const style = snapshot.imports.find((s) => s.name === "house");
+		expect(style?.origin).toBe("team");
+		// Display name is the real name — nothing to strip.
+		expect(style?.displayName).toBe("house");
+	});
+
+	test("the on-disk name survives for round-tripping, whatever is displayed", async () => {
+		await writeProjectStyle("builtin-proactive", [
+			"name: builtin-proactive",
+			"captured-style: Proactive",
+		]);
+		const snapshot = await loadStyles(dir, { home });
+		const style = snapshot.imports.find((s) => s.name === "builtin-proactive");
+		// `style-imports` records the id; a display-only rename that leaked into
+		// the id would break every already-applied composition.
+		expect(style?.id).toBe("project:builtin-proactive");
+		expect(style?.name).toBe("builtin-proactive");
+	});
+
+	test("reports the date the file was last written", async () => {
+		const file = await writeProjectStyle("dated", ["name: dated"]);
+		const when = new Date("2026-03-04T12:00:00Z");
+		await utimes(file, when, when);
+
+		const snapshot = await loadStyles(dir, { home });
+		const style = snapshot.imports.find((s) => s.name === "dated");
+		expect(style?.updatedAt).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+		// Local date, so allow the day either side of the UTC instant.
+		expect(["2026-03-03", "2026-03-04", "2026-03-05"]).toContain(
+			style?.updatedAt,
+		);
+	});
+});
+
+describe("the community cache directory", () => {
+	test("is NOT one of Claude Code's output-styles directories", () => {
+		// A fetched style is a copy claudeup may overwrite or delete without
+		// asking. Putting it in the user's own styles directory would make
+		// "delete this cached copy" and "delete my work" the same keypress.
+		const resolved = communityCacheDirOrNull(home);
+		expect(resolved).toBe(
+			join(home, ".claude", "claudeup", "community-styles"),
+		);
+		expect(resolved).not.toContain("output-styles");
+	});
+
+	test("honours CLAUDE_CONFIG_DIR, like every other claudeup cache", () => {
+		process.env.CLAUDE_CONFIG_DIR = join(dir, "elsewhere");
+		expect(communityCacheDirOrNull(home)).toBe(
+			join(dir, "elsewhere", "claudeup", "community-styles"),
+		);
+	});
+
+	test("returns null for a test that never isolated its home", () => {
+		// The guard that stops an unisolated test reading — and later writing —
+		// the operator's real cache. It gets an empty section instead.
+		expect(process.env.NODE_ENV).toBe("test");
+		expect(communityCacheDirOrNull(homedir())).toBeNull();
+	});
+});
+
+describe("community classification", () => {
+	const spartan = [
+		"name: attention-span--spartan",
+		'description: "Blunt Spartan mode."',
+		"keep-coding-instructions: true",
+		"community-source: alexgreensh/attention-span",
+		"community-path: output-styles/spartan.md",
+		"community-commit: b860c9f8f3c7",
+	];
+
+	test("a cached style is community, managed, and namespaced by scope", async () => {
+		await writeCachedCommunityStyle("attention-span--spartan", spartan);
+		const snapshot = await loadStyles(dir, { home });
+		const style = snapshot.imports.find(
+			(s) => s.name === "attention-span--spartan",
+		);
+		expect(style?.origin).toBe("community");
+		expect(style?.scope).toBe("community");
+		expect(style?.managed).toBe(true);
+		expect(style?.id).toBe("community:attention-span--spartan");
+	});
+
+	test("it shows upstream's own name, from the registry, not the coordinate", async () => {
+		// `name` is machinery (`attention-span--spartan`); "Spartan" is what a
+		// human wrote. Same id/displayName split the `builtin-` handling uses.
+		await writeCachedCommunityStyle("attention-span--spartan", spartan);
+		const snapshot = await loadStyles(dir, { home });
+		expect(
+			snapshot.imports.find((s) => s.name === "attention-span--spartan")
+				?.displayName,
+		).toBe("Spartan");
+	});
+
+	test("an id the registry does not know still displays, using its own name", async () => {
+		// A style fetched before an entry was retired must not render blank.
+		await writeCachedCommunityStyle("retired-repo--gone", [
+			"name: retired-repo--gone",
+			"community-source: someone/retired-repo",
+		]);
+		const snapshot = await loadStyles(dir, { home });
+		const style = snapshot.imports.find((s) => s.name === "retired-repo--gone");
+		expect(style?.origin).toBe("community");
+		expect(style?.displayName).toBe("retired-repo--gone");
+	});
+
+	test("the MARKER decides origin, the DIRECTORY decides ownership", async () => {
+		// A copy the user moved into their own output-styles directory still says
+		// where the words came from — hiding that would be exactly the
+		// directory-guessing this design rejects — but it is no longer ours to
+		// update or delete.
+		await writeUserStyle("my-copy-of-spartan", [
+			"name: my-copy-of-spartan",
+			"community-source: alexgreensh/attention-span",
+		]);
+		const snapshot = await loadStyles(dir, { home });
+		const style = snapshot.imports.find((s) => s.name === "my-copy-of-spartan");
+		expect(style?.origin).toBe("community");
+		expect(style?.scope).toBe("user");
+		expect(style?.managed).toBe(false);
+	});
+
+	test("captured-style keeps precedence over community-source", async () => {
+		// A captured built-in is an Anthropic style wherever it sits, and however
+		// it got there.
+		await writeCachedCommunityStyle("builtin-explanatory", [
+			"name: builtin-explanatory",
+			"captured-style: Explanatory",
+			"community-source: someone/repo",
+		]);
+		const snapshot = await loadStyles(dir, { home });
+		const style = snapshot.imports.find(
+			(s) => s.name === "builtin-explanatory",
+		);
+		expect(style?.origin).toBe("anthropic");
+		expect(style?.displayName).toBe("Explanatory");
+		// Not ours to manage either — it was captured, not fetched.
+		expect(style?.managed).toBe(false);
+	});
+
+	test("a hand-written file in the cache directory is not ours to manage", async () => {
+		await writeCachedCommunityStyle("stray", ["name: stray"]);
+		const snapshot = await loadStyles(dir, { home });
+		const style = snapshot.imports.find((s) => s.name === "stray");
+		expect(style?.managed).toBe(false);
+		expect(style?.origin).not.toBe("community");
+	});
+
+	test("a team or personal style is untouched by any of this", async () => {
+		await writeProjectStyle("house", ["name: house"]);
+		await writeUserStyle("mine", ["name: mine"]);
+		const snapshot = await loadStyles(dir, { home });
+		expect(snapshot.imports.find((s) => s.name === "house")?.origin).toBe(
+			"team",
+		);
+		expect(snapshot.imports.find((s) => s.name === "mine")?.origin).toBe(
+			"personal",
+		);
+		for (const style of snapshot.imports) expect(style.managed).toBe(false);
+	});
+
+	test("loadStyles works with no community cache on disk at all", async () => {
+		await writeProjectStyle("house", ["name: house"]);
+		const snapshot = await loadStyles(dir, { home });
+		expect(snapshot.imports.map((s) => s.name)).toEqual(["house"]);
+	});
+});
+
+describe("a comma in the declared name", () => {
+	// LATENT BUG, live today for any hand-written style: `composeStyleFile`
+	// serialises `style-imports` comma-separated and `readApplied` splits it back
+	// on commas, so an id containing one returns as two bogus ids and
+	// `computeStyleStatus` reports `stale` forever with no way to converge. None
+	// of the 57 community files observed trips it and `createTeamStyle` slugifies,
+	// so ours cannot — but a hand-edited file can.
+
+	test("falls back to the basename for the id", async () => {
+		await writeProjectStyle("blunt-fast", ['name: "Blunt, fast"']);
+		const snapshot = await loadStyles(dir, { home });
+		const style = snapshot.imports.find((s) => s.id === "project:blunt-fast");
+		expect(style).toBeDefined();
+		expect(style?.name).toBe("blunt-fast");
+	});
+
+	test("keeps the declared name for display, so the user still sees what they wrote", async () => {
+		await writeProjectStyle("blunt-fast", ['name: "Blunt, fast"']);
+		const snapshot = await loadStyles(dir, { home });
+		expect(
+			snapshot.imports.find((s) => s.id === "project:blunt-fast")?.displayName,
+		).toBe("Blunt, fast");
+	});
+
+	test("no id anywhere in the snapshot contains a comma", async () => {
+		// The actual invariant. An id with a comma cannot round-trip through
+		// `style-imports`, whatever produced it.
+		await writeProjectStyle("blunt-fast", ['name: "Blunt, fast"']);
+		await writeUserStyle("many-commas", ['name: "a, b, c"']);
+		const snapshot = await loadStyles(dir, { home });
+		expect(snapshot.imports.length).toBe(2);
+		for (const style of snapshot.imports) {
+			expect(style.id, style.id).not.toContain(",");
+		}
+	});
+
+	test("a name without a comma is left exactly as declared", async () => {
+		// The guard must not slugify names that were always fine — that would
+		// change every existing user's ids and break their committed declarations.
+		await writeProjectStyle("file-name", ["name: Declared Name"]);
+		const snapshot = await loadStyles(dir, { home });
+		const style = snapshot.imports.find(
+			(s) => s.displayName === "Declared Name",
+		);
+		expect(style?.name).toBe("Declared Name");
+		expect(style?.id).toBe("project:Declared Name");
+	});
+});
+
+describe("createTeamStyle", () => {
+	test("writes into the project so the style commits with the repo", async () => {
+		const created = await createTeamStyle(dir, "House Style");
+		expect(created.name).toBe("house-style");
+		expect(created.existed).toBe(false);
+		expect(created.path).toBe(
+			join(dir, ".claude", "output-styles", "house-style.md"),
+		);
+		expect(await fs.pathExists(created.path)).toBe(true);
+	});
+
+	test("the scaffold keeps coding instructions on", async () => {
+		const created = await createTeamStyle(dir, "house");
+		const { frontmatter } = splitFrontmatter(
+			await fs.readFile(created.path, "utf8"),
+		);
+		expect(frontmatter["keep-coding-instructions"]).toBe("true");
+		expect(frontmatter.name).toBe("house");
+	});
+
+	test("the new style shows up as a team style straight away", async () => {
+		await createTeamStyle(dir, "house");
+		const snapshot = await loadStyles(dir, { home });
+		const style = snapshot.imports.find((s) => s.name === "house");
+		expect(style?.origin).toBe("team");
+		expect(style?.scope).toBe("project");
+	});
+
+	test("never overwrites an existing file", async () => {
+		const first = await createTeamStyle(dir, "house");
+		await fs.writeFile(first.path, "HAND WRITTEN", "utf8");
+
+		const second = await createTeamStyle(dir, "house");
+		expect(second.existed).toBe(true);
+		// Destroying work the team already committed is not an acceptable
+		// outcome of pressing a key by mistake.
+		expect(await fs.readFile(second.path, "utf8")).toBe("HAND WRITTEN");
+	});
+
+	test("refuses a name that would collide with the generated style", async () => {
+		// composed.md is rewritten on every apply, so a team style there would
+		// be silently destroyed.
+		await expect(createTeamStyle(dir, "composed")).rejects.toThrow(
+			/claudeup generates/,
+		);
+		await expect(createTeamStyle(dir, "composed-dev")).rejects.toThrow(
+			/claudeup generates/,
+		);
+	});
+
+	test("refuses a name with nothing usable in it", async () => {
+		await expect(createTeamStyle(dir, "   ")).rejects.toThrow(/no letters/);
+		await expect(createTeamStyle(dir, "!!!")).rejects.toThrow(/no letters/);
+	});
+
+	test("a traversing name cannot escape the styles directory", async () => {
+		const created = await createTeamStyle(dir, "../../escaped");
+		expect(created.path.startsWith(join(dir, ".claude", "output-styles"))).toBe(
+			true,
+		);
+		expect(await fs.pathExists(join(dir, "..", "escaped.md"))).toBe(false);
+	});
+});