claudeup 4.37.0 → 4.38.1

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

@@ -0,0 +1,452 @@
+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 {
+	COMMUNITY_STYLES,
+	resolveCommunityStyle,
+} from "../data/community-styles.js";
+import {
+	type ImportedStyle,
+	type StyleDeclaration,
+	type StylePreset,
+	applyStyles,
+	computeStyleStatus,
+	loadStyles,
+	readStyleDeclaration,
+	resolveDeclaration,
+	styleHash,
+} from "../services/styles-manager.js";
+
+function preset(
+	name: string,
+	body = "rules",
+	axis: "verbosity" | "modifier" = "modifier",
+): StylePreset {
+	return {
+		kind: "preset",
+		id: name,
+		name,
+		displayName: name,
+		axis,
+		summary: "",
+		conflicts: [],
+		template: false,
+		body,
+		path: `/styles/${name}.md`,
+	};
+}
+
+function imported(name: string, body = "imported rules"): ImportedStyle {
+	return {
+		kind: "imported",
+		id: `project:${name}`,
+		name,
+		displayName: name,
+		scope: "project",
+		origin: "team",
+		managed: false,
+		description: "",
+		updatedAt: null,
+		capturedFrom: null,
+		community: null,
+		body,
+		path: `/p/.claude/output-styles/${name}.md`,
+	};
+}
+
+function declaration(over: Partial<StyleDeclaration> = {}): StyleDeclaration {
+	return {
+		version: 1,
+		presets: ["direct"],
+		imports: [],
+		hash: "sha256:whatever",
+		updatedAt: "2026-08-18T00:00:00.000Z",
+		...over,
+	};
+}
+
+describe("styleHash", () => {
+	test("is stable for the same sources", () => {
+		const sources = [preset("direct"), preset("no-slop")];
+		expect(styleHash(sources)).toBe(styleHash([...sources]));
+	});
+
+	test("changes when a preset's BODY changes, not just its name", () => {
+		// The case that matters: a plugin update rewrites a preset. The names the
+		// project declared are unchanged, but what Claude Code is told is not.
+		// Hashing names alone would call this in-sync.
+		expect(styleHash([preset("direct", "old text")])).not.toBe(
+			styleHash([preset("direct", "new text")]),
+		);
+	});
+
+	test("changes when the set changes", () => {
+		expect(styleHash([preset("direct")])).not.toBe(
+			styleHash([preset("direct"), preset("no-slop")]),
+		);
+	});
+
+	test("changes when the ORDER changes", () => {
+		// Order is meaningful — imports first, then verbosity, then modifiers, so
+		// a later rule refines an earlier one.
+		expect(styleHash([preset("a"), preset("b")])).not.toBe(
+			styleHash([preset("b"), preset("a")]),
+		);
+	});
+
+	test("cannot be spoofed by moving text across a boundary", () => {
+		// Naive concatenation would make these collide.
+		expect(styleHash([preset("ab", "c")])).not.toBe(
+			styleHash([preset("a", "bc")]),
+		);
+	});
+});
+
+describe("resolveDeclaration", () => {
+	test("returns sources in composition order", () => {
+		const { sources, missing } = resolveDeclaration(
+			declaration({
+				presets: ["no-slop", "direct"],
+				imports: ["project:house"],
+			}),
+			[preset("direct", "d", "verbosity"), preset("no-slop", "n")],
+			[imported("house")],
+		);
+		expect(sources.map((s) => s.name)).toEqual(["house", "direct", "no-slop"]);
+		expect(missing).toEqual([]);
+	});
+
+	test("reports names that no longer resolve", () => {
+		// A teammate committed a style this machine does not have — saying so is
+		// more useful than silently composing a smaller set.
+		const { sources, missing } = resolveDeclaration(
+			declaration({ presets: ["direct", "gone"], imports: ["project:absent"] }),
+			[preset("direct")],
+			[],
+		);
+		expect(sources.map((s) => s.name)).toEqual(["direct"]);
+		expect(missing).toEqual(["gone", "project:absent"]);
+	});
+});
+
+describe("computeStyleStatus", () => {
+	const presets = [preset("direct", "d")];
+
+	test("undeclared when the project has committed nothing", () => {
+		expect(
+			computeStyleStatus({
+				declaration: null,
+				presets,
+				imports: [],
+				localHash: null,
+				isActive: false,
+			}).state,
+		).toBe("undeclared");
+	});
+
+	test("not-applied when the style is declared but not active here", () => {
+		// The fresh-clone case.
+		expect(
+			computeStyleStatus({
+				declaration: declaration(),
+				presets,
+				imports: [],
+				localHash: null,
+				isActive: false,
+			}).state,
+		).toBe("not-applied");
+	});
+
+	test("not-applied when active but the file records no hash", () => {
+		// A file written before hashing existed. Unknown must read as out of
+		// date, never as in sync.
+		expect(
+			computeStyleStatus({
+				declaration: declaration(),
+				presets,
+				imports: [],
+				localHash: null,
+				isActive: true,
+			}).state,
+		).toBe("not-applied");
+	});
+
+	test("in-sync when the local hash matches what the declaration composes to now", () => {
+		const expected = styleHash([preset("direct", "d")]);
+		expect(
+			computeStyleStatus({
+				declaration: declaration(),
+				presets,
+				imports: [],
+				localHash: expected,
+				isActive: true,
+			}).state,
+		).toBe("in-sync");
+	});
+
+	test("stale when the preset text changed underneath an applied style", () => {
+		// Same declaration, same names, different rules — exactly the drift the
+		// hash exists to catch.
+		const appliedEarlier = styleHash([preset("direct", "OLD")]);
+		const status = computeStyleStatus({
+			declaration: declaration(),
+			presets: [preset("direct", "NEW")],
+			imports: [],
+			localHash: appliedEarlier,
+			isActive: true,
+		});
+		expect(status.state).toBe("stale");
+		expect(status.detail).toMatch(/re-apply/);
+	});
+
+	test("carries the missing names through", () => {
+		const status = computeStyleStatus({
+			declaration: declaration({ presets: ["direct", "gone"] }),
+			presets,
+			imports: [],
+			localHash: null,
+			isActive: false,
+		});
+		expect(status.missing).toEqual(["gone"]);
+	});
+});
+
+// ─── Phase 5: declaration portability ─────────────────────────────────────────
+
+/**
+ * A community style as it exists on a machine that HAS fetched it.
+ *
+ * `name` is the coordinate id, `id` prefixes it with the scope — the same split
+ * the `builtin-` handling uses, and what lets a declaration name a style that is
+ * not on this machine yet.
+ */
+function communityStyle(coordinate: string, body = "third-party rules") {
+	return {
+		...imported(coordinate, body),
+		id: `community:${coordinate}`,
+		name: coordinate,
+		displayName: coordinate,
+		scope: "community" as const,
+		origin: "community" as const,
+		managed: true,
+	};
+}
+
+describe("a declaration naming a community style this machine lacks", () => {
+	const declared = declaration({
+		presets: [],
+		imports: ["community:attention-span--spartan"],
+	});
+
+	test("resolves as FETCHABLE rather than bare missing", () => {
+		// The feature's best argument, and it collapses without this: a teammate
+		// clones a repo whose .claude/style.json names a community style and has
+		// fetched nothing. Reporting a bare "missing" would be an unactionable
+		// error for a situation that is one keypress from resolved.
+		const { missing, fetchable } = resolveDeclaration(declared, [], []);
+		expect(fetchable).toEqual(["community:attention-span--spartan"]);
+		expect(missing).toEqual([]);
+	});
+
+	test("the two lists are disjoint — a dead end is not the same as a fetch", () => {
+		const { missing, fetchable } = resolveDeclaration(
+			declaration({
+				presets: ["gone"],
+				imports: [
+					"community:attention-span--spartan",
+					"community:nobody--nothing",
+					"project:absent",
+				],
+			}),
+			[],
+			[],
+		);
+		expect(fetchable).toEqual(["community:attention-span--spartan"]);
+		// An id the registry has never heard of is NOT fetchable, however it is
+		// spelled — the prefix is not a licence to invent a coordinate.
+		expect(missing).toEqual([
+			"gone",
+			"community:nobody--nothing",
+			"project:absent",
+		]);
+	});
+
+	test("the status detail says what to press, and the count", () => {
+		const one = computeStyleStatus({
+			declaration: declared,
+			presets: [],
+			imports: [],
+			localHash: null,
+			isActive: false,
+		});
+		expect(one.detail).toBe("project style needs 1 community style — press f");
+
+		const two = computeStyleStatus({
+			declaration: declaration({
+				presets: [],
+				imports: [
+					"community:attention-span--spartan",
+					"community:attention-span--rundown",
+				],
+			}),
+			presets: [],
+			imports: [],
+			localHash: null,
+			isActive: false,
+		});
+		expect(two.detail).toBe("project style needs 2 community styles — press f");
+	});
+
+	test("never reports in-sync while a declared style is still un-fetched", () => {
+		// The hashes agree because the un-fetched style was left out of BOTH
+		// sides. That is the composition matching itself, not the declaration.
+		const localHash = styleHash([]);
+		const status = computeStyleStatus({
+			declaration: declared,
+			presets: [],
+			imports: [],
+			localHash,
+			isActive: true,
+		});
+		expect(status.state).toBe("stale");
+		expect(status.detail).toMatch(/press f/);
+	});
+
+	test("once fetched it resolves normally and composes like any import", () => {
+		const style = communityStyle("attention-span--spartan");
+		const { sources, missing, fetchable } = resolveDeclaration(
+			declared,
+			[],
+			[style],
+		);
+		expect(sources.map((s) => s.id)).toEqual([
+			"community:attention-span--spartan",
+		]);
+		expect(missing).toEqual([]);
+		expect(fetchable).toEqual([]);
+
+		expect(
+			computeStyleStatus({
+				declaration: declared,
+				presets: [],
+				imports: [style],
+				localHash: styleHash(sources),
+				isActive: true,
+			}).state,
+		).toBe("in-sync");
+	});
+});
+
+describe("the registry rule: entries are retired, never deleted", () => {
+	/**
+	 * Every coordinate shipped in v1.
+	 *
+	 * A deleted entry breaks a committed `.claude/style.json` on every
+	 * teammate's machine — the id stops resolving, so it stops being FETCHABLE
+	 * and becomes an unactionable "missing". Retiring one instead
+	 * (`retired: true`) drops it from the offers list while keeping every
+	 * declaration that names it working.
+	 *
+	 * If this fails, do not delete the id from the list. Mark the registry entry
+	 * `retired: true` and leave it resolvable.
+	 */
+	const SHIPPED_IDS = [
+		"attention-span--attention-kind",
+		"attention-span--rundown",
+		"attention-span--spartan",
+		"claude-mods--executive",
+		"claude-mods--mentor",
+		"claude-mods--noir",
+		"claude-mods--pair",
+		"claude-mods--roast",
+		"lej-output-fixer--bottom-line-first",
+		"lej-output-fixer--scannable",
+		"lej-output-fixer--walk-me-through-it",
+		"hesreallyhim--door-to-door-vim-salesman",
+		"hesreallyhim--existentialist-poet",
+		"hesreallyhim--haiku-helper",
+		"hesreallyhim--tabloid-journalist",
+		"hesreallyhim--technical-evangelist",
+		"hesreallyhim--zen-master",
+		"nattergabriel--challenger",
+		"nattergabriel--paranoid",
+		"nattergabriel--socratic",
+		"nattergabriel--tdd",
+		"nattergabriel--think-aloud",
+	];
+
+	test("every id ever shipped still resolves against the registry", () => {
+		const unresolvable = SHIPPED_IDS.filter((id) => !resolveCommunityStyle(id));
+		expect(unresolvable).toEqual([]);
+	});
+
+	test("every shipped id is still reported as fetchable by a declaration", () => {
+		// The consequence that actually matters. Resolving is the mechanism;
+		// staying fetchable is the promise made to a teammate's checkout.
+		const { fetchable } = resolveDeclaration(
+			declaration({
+				presets: [],
+				imports: SHIPPED_IDS.map((id) => `community:${id}`),
+			}),
+			[],
+			[],
+		);
+		expect(fetchable).toHaveLength(SHIPPED_IDS.length);
+	});
+
+	test("a retired entry still resolves — retirement hides it, it does not delete it", () => {
+		const retired = COMMUNITY_STYLES.filter((style) => style.retired);
+		for (const style of retired) {
+			expect(resolveCommunityStyle(style.id), style.id).not.toBeNull();
+		}
+	});
+});
+
+describe("declaration round-trip", () => {
+	let dir: string;
+
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "claudeup-sync-"));
+	});
+	afterEach(async () => {
+		await rm(dir, { recursive: true, force: true });
+	});
+
+	test("apply writes a declaration that commits with the project", async () => {
+		const result = await applyStyles({
+			projectPath: dir,
+			presets: [preset("direct", "d", "verbosity")],
+			imports: [],
+		});
+
+		expect(result.declarationPath).toBe(join(dir, ".claude", "style.json"));
+		const written = await readStyleDeclaration(dir);
+		expect(written?.presets).toEqual(["direct"]);
+		expect(written?.hash).toBe(result.hash);
+	});
+
+	test("a freshly applied project reads back as in-sync", async () => {
+		await applyStyles({
+			projectPath: dir,
+			presets: [preset("direct", "d", "verbosity")],
+			imports: [],
+		});
+		// loadStyles resolves against the INSTALLED plugin, which the sandbox has
+		// no copy of, so assert on the recorded hash instead of the state.
+		const snapshot = await loadStyles(dir, { home: join(dir, "home") });
+		expect(snapshot.declaration?.presets).toEqual(["direct"]);
+		expect(snapshot.applied?.hash).toBe(snapshot.declaration?.hash);
+	});
+
+	test("a corrupt declaration reads as none rather than crashing", async () => {
+		await fs.outputFile(join(dir, ".claude", "style.json"), "{ not json");
+		expect(await readStyleDeclaration(dir)).toBeNull();
+	});
+
+	test("a declaration missing its arrays reads as none", async () => {
+		await fs.outputJson(join(dir, ".claude", "style.json"), { version: 1 });
+		expect(await readStyleDeclaration(dir)).toBeNull();
+	});
+});

package/src/__tests__/tabbar-layout.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test";
+import { TABS, barWidth, layoutTabs } from "../ui/components/TabBar.js";
+
+const FULL = TABS.map((t) => `${t.key}:${t.label}`);
+const FULL_WIDTH = barWidth(FULL);
+
+describe("tab bar layout", () => {
+	test("shows every label when the bar fits", () => {
+		expect(layoutTabs(TABS, "plugins", FULL_WIDTH)).toEqual(FULL);
+	});
+
+	test("drops inactive labels when the bar does not fit", () => {
+		// A 94-column pane leaves ~90 usable, and nine full tabs need ~99 — the
+		// width at which OpenTUI clipped each cell into a meaningless stub.
+		const texts = layoutTabs(TABS, "styles", 90);
+		expect(texts).toContain("9:Styles");
+		expect(texts).toContain("1");
+		expect(texts).not.toContain("1:Plugins");
+	});
+
+	test("the compact bar actually fits a narrow pane", () => {
+		// The point of compacting is that the result fits. If it did not, the
+		// fallback would just be a differently-truncated mess.
+		expect(barWidth(layoutTabs(TABS, "styles", 90))).toBeLessThanOrEqual(90);
+	});
+
+	test("keeps the label of whichever tab is active", () => {
+		for (const tab of TABS) {
+			const texts = layoutTabs(TABS, tab.screen, 40);
+			expect(texts).toContain(`${tab.key}:${tab.label}`);
+			// Exactly one tab keeps its label.
+			expect(texts.filter((t) => t.includes(":"))).toHaveLength(1);
+		}
+	});
+
+	test("compacting never changes how many tabs are drawn", () => {
+		expect(layoutTabs(TABS, "plugins", 20)).toHaveLength(TABS.length);
+		expect(layoutTabs(TABS, "plugins", 10_000)).toHaveLength(TABS.length);
+	});
+
+	test("barWidth counts padding and separators", () => {
+		// " a " + "│" + " bb " = 3 + 1 + 4
+		expect(barWidth(["a", "bb"])).toBe(8);
+		expect(barWidth([])).toBe(0);
+	});
+
+	test("every tab key is a digit the global handler binds", () => {
+		// The compact bar shows only the number, so the number must be the key
+		// that actually navigates.
+		expect(TABS.map((t) => t.key)).toEqual([
+			"1",
+			"2",
+			"3",
+			"4",
+			"5",
+			"6",
+			"7",
+			"8",
+			"9",
+		]);
+	});
+});