magus-cli 7.13.0 → 7.14.0

package/src/__tests__/market-r2-company-unit.test.ts

@@ -0,0 +1,224 @@
+import { describe, expect, test } from "bun:test";
+import {
+	COMPANY_NAME_MAX,
+	checkCompanyName,
+} from "../services/market-ops-repo.js";
+import { companyOf } from "../services/market-ops.js";
+import { MarketError } from "../services/market-types.js";
+import type { Marketplace } from "../types/index.js";
+import {
+	buildPluginBrowserItems,
+	companyName,
+} from "../ui/adapters/pluginsAdapter.js";
+
+const marketplace = (over: Partial<Marketplace> = {}): Marketplace => ({
+	name: "company-tools",
+	displayName: "Company tools",
+	description: "Team tools",
+	source: { source: "github", repo: "github-owner/tools" },
+	company: true,
+	...over,
+});
+
+describe("round-two company identity", () => {
+	test.each([
+		{ input: "  10xlabs  ", expected: "10xlabs" },
+		{ input: "A", expected: "A" },
+		{ input: "  North Star Labs  ", expected: "North Star Labs" },
+		{ input: "x".repeat(64), expected: "x".repeat(64) },
+		{ input: `  ${"界".repeat(64)}  `, expected: "界".repeat(64) },
+		{ input: "🏢".repeat(64), expected: "🏢".repeat(64) },
+	])(
+		"R1.3 TEST-1 returns trimmed company name at valid boundaries: $input",
+		({ input, expected }) => {
+			expect(COMPANY_NAME_MAX).toBe(64);
+			expect(checkCompanyName(input)).toBe(expected);
+		},
+	);
+
+	const invalidNames = [
+		{ input: "", message: "The company name is empty" },
+		{ input: "   ", message: "The company name is empty" },
+		{
+			input: "x".repeat(65),
+			message: "The company name is longer than 64 characters",
+		},
+		{
+			input: "🏢".repeat(65),
+			message: "The company name is longer than 64 characters",
+		},
+		...[0, 1, 8, 9, 10, 11, 12, 13, 31, 127, 128, 133, 159, 0x2028, 0x2029].map(
+			(code) => ({
+				input: `Acme${String.fromCodePoint(code)}Labs`,
+				message: "The company name must be a single line",
+			}),
+		),
+	];
+	test.each(invalidNames)(
+		"R1.3 TEST-2 rejects invalid company name %j as invalid-name usage",
+		({ input, message }) => {
+			expect(() => checkCompanyName(input)).toThrow(MarketError);
+			expect(() => checkCompanyName(input)).toThrow(message);
+			let failure: unknown;
+			try {
+				checkCompanyName(input);
+			} catch (error) {
+				failure = error;
+			}
+			expect(failure).toBeInstanceOf(MarketError);
+			if (!(failure instanceof MarketError))
+				throw new Error("Expected a company-name MarketError");
+			expect({ code: failure.code, exit: failure.exit }).toEqual({
+				code: "invalid-name",
+				exit: 2,
+			});
+		},
+	);
+
+	test.each([
+		{
+			manifest: { owner: { name: "  10xlabs  " } },
+			source: "git-owner/market",
+			expected: "10xlabs",
+		},
+		{
+			manifest: { owner: { name: "10xlabs" } },
+			source: "https://git.example.invalid/team/market",
+			expected: "10xlabs",
+		},
+		{
+			manifest: { owner: { name: "  " } },
+			source: "GitOwner/market",
+			expected: "GitOwner",
+		},
+		{
+			manifest: { owner: { name: 42 } },
+			source: "GitOwner/market",
+			expected: "GitOwner",
+		},
+		{ manifest: {}, source: "GitOwner/market", expected: "GitOwner" },
+		{ manifest: null, source: "GitOwner/market", expected: "GitOwner" },
+		{ manifest: { owner: null }, source: "", expected: undefined },
+		{
+			manifest: { owner: { name: "" } },
+			source: "https://git.example.invalid/team/market",
+			expected: undefined,
+		},
+		{ manifest: {}, source: "file:///company-market", expected: undefined },
+	])(
+		"R1.6 TEST-3 companyOf prefers manifest owner and falls back only to GitHub source: %j",
+		({ manifest, source, expected }) => {
+			expect(companyOf(manifest, source)).toBe(expected);
+		},
+	);
+
+	test.each([
+		{ mp: marketplace({ ownerName: "10xlabs" }), expected: "10xlabs" },
+		{ mp: marketplace(), expected: "github-owner" },
+		{
+			mp: marketplace({ source: { source: "github", repo: "" } }),
+			expected: undefined,
+		},
+	])(
+		"R1.6 TEST-4 companyName uses manifest, GitHub owner, then no name: %j",
+		({ mp, expected }) => {
+			expect(companyName(mp)).toBe(expected);
+		},
+	);
+});
+
+describe("round-two company badges", () => {
+	test.each([
+		{ mp: marketplace({ ownerName: "10xlabs" }), badge: "by 10xlabs" },
+		{ mp: marketplace(), badge: "by github-owner" },
+		{
+			mp: marketplace({ source: { source: "github", repo: "" } }),
+			badge: "◆ Company",
+		},
+		{
+			mp: marketplace({
+				source: { source: "github", repo: "MadAppGang/team-tools" },
+				ownerName: "Different Company",
+			}),
+			badge: "by Different Company",
+		},
+	])(
+		"R1.6 TEST-5 empty company marketplace has the real byline and info tone: $badge",
+		({ mp, badge }) => {
+			const rows = buildPluginBrowserItems({
+				marketplaces: [mp],
+				plugins: [],
+				collapsedMarketplaces: new Set(),
+			});
+			const row = rows.find((item) => item.kind === "category");
+			expect(row?.kind).toBe("category");
+			if (row?.kind !== "category") throw new Error("Company category missing");
+			expect({ tone: row.tone, badge: row.badge }).toEqual({
+				tone: "info",
+				badge,
+			});
+		},
+	);
+
+	test.each([
+		{ name: "A".repeat(24), expected: `by ${"A".repeat(24)}` },
+		{ name: "A".repeat(25), expected: `by ${"A".repeat(23)}…` },
+	])(
+		"R1.6 TEST-5 truncates the company name to 24 columns including ellipsis: $name",
+		({ name, expected }) => {
+			const row = buildPluginBrowserItems({
+				marketplaces: [marketplace({ ownerName: name })],
+				plugins: [],
+				collapsedMarketplaces: new Set(["company-tools"]),
+			}).find((item) => item.kind === "category");
+			expect(row?.kind === "category" ? row.badge : undefined).toBe(expected);
+		},
+	);
+
+	test("R1.6 TEST-5 wide company characters also fit the 24-column name budget", () => {
+		const row = buildPluginBrowserItems({
+			marketplaces: [marketplace({ ownerName: "界".repeat(20) })],
+			plugins: [],
+			collapsedMarketplaces: new Set(),
+		}).find((item) => item.kind === "category");
+		if (row?.kind !== "category" || !row.badge)
+			throw new Error("Company badge missing");
+		expect(row.badge.startsWith("by ")).toBe(true);
+		expect(row.badge.endsWith("…")).toBe(true);
+		expect(Bun.stringWidth(row.badge.slice(3))).toBeLessThanOrEqual(24);
+	});
+
+	test("R1.6 TEST-5 company marketplaces sort before ordinary and MadAppGang marketplaces", () => {
+		const rows = buildPluginBrowserItems({
+			marketplaces: [
+				marketplace({
+					name: "ordinary",
+					company: false,
+					source: { source: "github", repo: "other/ordinary" },
+				}),
+				marketplace({
+					name: "magus",
+					company: false,
+					source: { source: "github", repo: "MadAppGang/magus" },
+				}),
+				marketplace({ name: "company-tools", ownerName: "10xlabs" }),
+			],
+			plugins: ["ordinary", "magus", "company-tools"].map((name) => ({
+				id: `demo@${name}`,
+				name: "demo",
+				version: "1.0.0",
+				description: "Demonstration plugin",
+				marketplace: name,
+				marketplaceDisplay: name,
+				author: { name: "Publisher" },
+			})),
+			collapsedMarketplaces: new Set(),
+		}).filter((item) => item.kind === "category");
+		expect(rows.map((row) => row.marketplace.name).sort()).toEqual([
+			"company-tools",
+			"magus",
+			"ordinary",
+		]);
+		expect(rows[0]?.marketplace.name).toBe("company-tools");
+	});
+});

package/src/__tests__/market-r2-local-items.test.ts

@@ -0,0 +1,197 @@
+import { afterEach, expect, test } from "bun:test";
+import { mkdirSync, symlinkSync } from "node:fs";
+import { join } from "node:path";
+import type { LocalItem } from "../services/market-types.js";
+import {
+	MarketFixture,
+	SKILL,
+	sourceModule,
+	write,
+	writeJson,
+} from "./market-fixture.js";
+
+let f: MarketFixture | undefined;
+afterEach(() => {
+	f?.close();
+	f = undefined;
+});
+
+function discover(
+	world: MarketFixture,
+	companySkills: string[] = [],
+): LocalItem[] {
+	return world.value<LocalItem[]>(
+		`const {localItems}=await import(${JSON.stringify(sourceModule("services/market-local.js"))});console.log(JSON.stringify(await localItems(${JSON.stringify(world.project)},new Set(${JSON.stringify(companySkills)}))));`,
+	);
+}
+
+test("R4.1 TEST-31 absent skills roots yield no local items and create no folders", () => {
+	f = new MarketFixture(true);
+	const before = f.snapshot();
+
+	expect(discover(f)).toEqual([]);
+	expect(f.snapshot()).toEqual(before);
+});
+
+test("R4.1 TEST-31 localItems detects both scopes, distinguishes plugins, and sorts by name then scope", () => {
+	f = new MarketFixture(true);
+	const projectAlpha = f.folder("project", "alpha");
+	const userAlpha = f.folder("global", "alpha");
+	write(join(projectAlpha, "SKILL.md"), SKILL);
+	write(join(userAlpha, "SKILL.md"), SKILL);
+	const renamedPlugin = f.folder("project", "folder-label");
+	writeJson(join(renamedPlugin, ".claude-plugin", "plugin.json"), {
+		name: "beta-kit",
+		version: "1.2.3",
+	});
+	write(join(renamedPlugin, "SKILL.md"), SKILL);
+	const fallbackPlugin = f.folder("global", "gamma-kit");
+	writeJson(join(fallbackPlugin, ".claude-plugin", "plugin.json"), {
+		version: "1.0.0",
+	});
+	write(join(f.folder("global", "zeta"), "SKILL.md"), SKILL);
+	write(
+		join(f.folder("project", "not-a-skill"), "README.md"),
+		"No skill entry point\n",
+	);
+	write(join(f.project, ".claude", "skills", "regular-file"), SKILL);
+	write(join(f.home, ".claude", "skills", "wrong-config"), SKILL);
+	write(join(f.home, ".claude", "skills", "decoy", "SKILL.md"), SKILL);
+	const before = f.snapshot();
+
+	const items = discover(f);
+
+	expect(items).toEqual([
+		{ kind: "skill", name: "alpha", scope: "project", path: projectAlpha },
+		{ kind: "skill", name: "alpha", scope: "user", path: userAlpha },
+		{ kind: "plugin", name: "beta-kit", scope: "project", path: renamedPlugin },
+		{ kind: "plugin", name: "gamma-kit", scope: "user", path: fallbackPlugin },
+		{
+			kind: "skill",
+			name: "zeta",
+			scope: "user",
+			path: f.folder("global", "zeta"),
+		},
+	]);
+	expect(f.snapshot()).toEqual(before);
+});
+
+test("R4.1 TEST-32 origin copies, held-by-name skills and project profile skills are omitted, not USER namesakes", () => {
+	f = new MarketFixture(true);
+	for (const scope of ["project", "global"] as const) {
+		write(join(f.folder(scope, "company-name"), "SKILL.md"), SKILL);
+		write(join(f.folder(scope, "origin-copy"), "SKILL.md"), SKILL);
+		write(
+			join(f.folder(scope, "origin-copy"), ".magus-origin"),
+			"Even an unrecognized token excludes this copy\n",
+		);
+		write(join(f.folder(scope, "managed"), "SKILL.md"), SKILL);
+	}
+	f.profile({}, {});
+	f.active({ managed: "a".repeat(64) });
+	const unmanaged = f.folder("project", "unmanaged");
+	write(join(unmanaged, "SKILL.md"), SKILL);
+	const before = f.snapshot();
+
+	const items = discover(f, ["company-name"]);
+
+	expect(items).toEqual([
+		{
+			kind: "skill",
+			name: "managed",
+			scope: "user",
+			path: f.folder("global", "managed"),
+		},
+		{ kind: "skill", name: "unmanaged", scope: "project", path: unmanaged },
+	]);
+	expect(f.snapshot()).toEqual(before);
+});
+
+test("R4.1 TEST-32 linked directories and nonregular plugin manifests are not local items", () => {
+	f = new MarketFixture();
+	const outside = join(f.root, "outside");
+	write(join(outside, "SKILL.md"), SKILL);
+	writeJson(join(outside, ".claude-plugin", "plugin.json"), {
+		name: "outside-kit",
+	});
+	mkdirSync(join(f.project, ".claude", "skills"), { recursive: true });
+	mkdirSync(join(f.config, "skills"), { recursive: true });
+	symlinkSync(outside, f.folder("project", "linked-project"));
+	symlinkSync(outside, f.folder("global", "linked-user"));
+	const linkedManifest = join(
+		f.folder("project", "linked-manifest"),
+		".claude-plugin",
+	);
+	mkdirSync(linkedManifest, { recursive: true });
+	symlinkSync(
+		join(outside, ".claude-plugin", "plugin.json"),
+		join(linkedManifest, "plugin.json"),
+	);
+	mkdirSync(
+		join(
+			f.folder("project", "directory-manifest"),
+			".claude-plugin",
+			"plugin.json",
+		),
+		{ recursive: true },
+	);
+	const before = f.snapshot();
+
+	expect(discover(f)).toEqual([]);
+	expect(f.snapshot()).toEqual(before);
+});
+
+test.each([false, true])(
+	"R4.1 R4.4 TEST-33 text and JSON list the same local items; company marketplace=%s",
+	(withCompany) => {
+		f = new MarketFixture(true);
+		const repo = withCompany ? f.seed() : undefined;
+		if (repo) {
+			f.register(repo);
+			write(join(f.folder(), "SKILL.md"), SKILL);
+		}
+		const skill = f.folder("project", "authoring");
+		const plugin = f.folder("global", "personal-kit");
+		write(
+			join(skill, "SKILL.md"),
+			"---\nname: authoring\n---\nWrite guides.\n",
+		);
+		writeJson(join(plugin, ".claude-plugin", "plugin.json"), {
+			name: "personal-kit",
+			version: "1.0.0",
+		});
+		write(join(f.folder("project", "tracked-copy"), "SKILL.md"), SKILL);
+		write(
+			join(f.folder("project", "tracked-copy"), ".magus-origin"),
+			"tracked\n",
+		);
+		const before = f.snapshot();
+		const head = repo ? f.head(repo) : undefined;
+
+		const json = f.market(["list"]);
+		const text = f.cli(["market", "list"]);
+
+		expect(json.code).toBe(0);
+		expect(json.result.local).toEqual([
+			{ kind: "skill", name: "authoring", scope: "project", path: skill },
+			{ kind: "plugin", name: "personal-kit", scope: "user", path: plugin },
+		]);
+		expect(json.result.marketplaces?.map((entry) => entry.name)).toEqual(
+			withCompany ? ["acme"] : [],
+		);
+		expect(text.code).toBe(0);
+		expect(text.out).toContain("authoring");
+		expect(text.out).toContain("personal-kit");
+		expect(text.out).toContain("PROJECT");
+		expect(text.out).toContain("USER");
+		expect(text.out).not.toContain("tracked-copy");
+		if (repo) {
+			expect(text.out.indexOf("authoring")).toBeGreaterThan(
+				text.out.indexOf("acme"),
+			);
+			expect(f.head(repo)).toBe(head!);
+		}
+		expect(f.snapshot()).toEqual(before);
+	},
+	30_000,
+);