magus-cli 7.13.0 → 7.14.1

package/src/__tests__/market-r2b-fit-row.test.ts

@@ -0,0 +1,287 @@
+import { expect, test } from "bun:test";
+import { fitRow } from "../ui/adapters/marketAdapter.js";
+import { displayWidth } from "../ui/text-width.js";
+
+const widths = Array.from({ length: 60 }, (_, index) => index + 1);
+
+function rowColumns(
+	row: { name: string; secondary: readonly { text: string }[] },
+	fixed: number,
+	gap = 2,
+): number {
+	return (
+		displayWidth(row.name) +
+		fixed +
+		row.secondary.reduce(
+			(total, part) => total + gap + displayWidth(part.text),
+			0,
+		)
+	);
+}
+
+test.each(widths)(
+	"R7.1 REQ-7 TEST-13 fits an over-wide name and empty secondary list at width %i",
+	(width) => {
+		const name = "n".repeat(80);
+
+		for (const fixed of new Set([0, Math.min(8, width - 1)])) {
+			const row = fitRow(width, name, fixed, []);
+			const available = width - fixed;
+
+			expect(row).toEqual({
+				name: `${"n".repeat(available - 1)}…`,
+				secondary: [],
+			});
+			expect(rowColumns(row, fixed)).toBeLessThanOrEqual(width);
+		}
+	},
+);
+
+test.each(widths)(
+	"R7.1 REQ-7 TEST-14 reserves fixed columns for over-wide Unicode names at width %i",
+	(width) => {
+		const names = ["日本語".repeat(30), "é".repeat(80), "👩‍💻".repeat(40)];
+		const fixed = Math.min(8, width - 1);
+
+		for (const name of names) {
+			const row = fitRow(width, name, fixed, [
+				{ text: "optional metadata" },
+				{ text: "x" },
+			]);
+
+			expect(displayWidth(name)).toBeGreaterThan(width);
+			expect(row.name.endsWith("…")).toBe(true);
+			expect(row.secondary).toEqual([]);
+			expect(rowColumns(row, fixed)).toBeLessThanOrEqual(width);
+		}
+	},
+);
+
+test.each([
+	{
+		label: "exact ASCII name",
+		width: 9,
+		fixed: 4,
+		name: "hello",
+		expected: "hello",
+	},
+	{
+		label: "one name column",
+		width: 5,
+		fixed: 4,
+		name: "hello",
+		expected: "…",
+	},
+	{
+		label: "CJK name",
+		width: 9,
+		fixed: 2,
+		name: "日本語会社",
+		expected: "日本語…",
+	},
+	{
+		label: "combining-mark name",
+		width: 5,
+		fixed: 3,
+		name: "ééé",
+		expected: "é…",
+	},
+	{
+		label: "joined-emoji name",
+		width: 5,
+		fixed: 2,
+		name: "👩‍💻👩‍💻👩‍💻",
+		expected: "👩‍💻…",
+	},
+])(
+	"R7.1 REQ-7 TEST-15 preserves fixed columns and the exact expected $label",
+	({ width, fixed, name, expected }) => {
+		const row = fitRow(width, name, fixed, []);
+
+		expect(row).toEqual({ name: expected, secondary: [] });
+		expect(rowColumns(row, fixed)).toBeLessThanOrEqual(width);
+	},
+);
+
+test.each([0, 2, 5])(
+	"R7.1 REQ-7 TEST-16 keeps a secondary whole at its exact fit with gap %i",
+	(gap) => {
+		const first = { text: "ready", id: "state" };
+		const width = 3 + 4 + gap + 5;
+
+		const row = fitRow(
+			width,
+			"kit",
+			4,
+			[first, { text: "z", id: "later" }],
+			gap,
+		);
+
+		expect(row).toEqual({ name: "kit", secondary: [first] });
+		expect(rowColumns(row, 4, gap)).toBe(width);
+	},
+);
+
+const remainingCases = [
+	{ remaining: 0, expectedText: null },
+	{ remaining: 1, expectedText: null },
+	{ remaining: 2, expectedText: null },
+	{ remaining: 3, expectedText: null },
+	{ remaining: 4, expectedText: "abc…" },
+	{ remaining: 5, expectedText: "abcd…" },
+];
+const clippingCases = [0, 2, 5].flatMap((gap) =>
+	remainingCases.map((entry) => ({ gap, ...entry })),
+);
+
+test.each(clippingCases)(
+	"R7.1 REQ-7 TEST-17 clips only at four or more available columns: gap=$gap remaining=$remaining",
+	({ gap, remaining, expectedText }) => {
+		const width = 3 + 4 + gap + remaining;
+
+		const row = fitRow(
+			width,
+			"kit",
+			4,
+			[
+				{ text: "abcdefgh", id: "first" },
+				{ text: "x", id: "later" },
+			],
+			gap,
+		);
+
+		expect(row).toEqual({
+			name: "kit",
+			secondary:
+				expectedText === null ? [] : [{ text: expectedText, id: "first" }],
+		});
+		expect(rowColumns(row, 4, gap)).toBeLessThanOrEqual(width);
+	},
+);
+
+test("R7.1 REQ-7 TEST-18 keeps whole secondary text before the first clipped one and drops later text", () => {
+	const row = fitRow(20, "kit", 4, [
+		{ text: "ready", id: "state" },
+		{ text: "long-detail", id: "detail" },
+		{ text: "x", id: "later" },
+	]);
+
+	expect(row).toEqual({
+		name: "kit",
+		secondary: [
+			{ text: "ready", id: "state" },
+			{ text: "lon…", id: "detail" },
+		],
+	});
+	expect(rowColumns(row, 4)).toBe(20);
+});
+
+test("R7.1 REQ-7 TEST-19 drops later short text rather than skipping a non-fitting secondary", () => {
+	const row = fitRow(19, "kit", 4, [
+		{ text: "ready", id: "state" },
+		{ text: "long-detail", id: "blocked" },
+		{ text: "x", id: "would-fit-if-skipped" },
+	]);
+
+	expect(row).toEqual({
+		name: "kit",
+		secondary: [{ text: "ready", id: "state" }],
+	});
+	expect(rowColumns(row, 4)).toBeLessThanOrEqual(19);
+});
+
+test.each([
+	{ label: "CJK", text: "日本語", expected: "日…" },
+	{
+		label: "combining marks",
+		text: "é".repeat(8),
+		expected: "ééé…",
+	},
+	{
+		label: "joined emoji",
+		text: "👩‍💻👩‍💻👩‍💻",
+		expected: "👩‍💻…",
+	},
+])(
+	"R7.1 REQ-7 TEST-20 clips $label secondary text by display columns",
+	({ text, expected }) => {
+		const row = fitRow(13, "kit", 4, [
+			{ text, id: "first" },
+			{ text: "x", id: "later" },
+		]);
+
+		expect(row).toEqual({
+			name: "kit",
+			secondary: [{ text: expected, id: "first" }],
+		});
+		expect(rowColumns(row, 4)).toBeLessThanOrEqual(13);
+	},
+);
+
+test.each(widths)(
+	"R7.1 REQ-7 TEST-21 keeps mixed secondary rows within width %i in their original order",
+	(width) => {
+		const fixed = Math.min(6, width - 1);
+		const secondary = [
+			{ text: "会社の道具", id: "company" },
+			{ text: "● 4 plugins to push", id: "status" },
+			{ text: "v1.2.3", id: "version" },
+		];
+		const available = width - fixed;
+		const expectedName = available >= 3 ? "kit" : available === 2 ? "k…" : "…";
+
+		const row = fitRow(width, "kit", fixed, secondary);
+
+		expect(row.name).toBe(expectedName);
+		expect(rowColumns(row, fixed)).toBeLessThanOrEqual(width);
+		expect(row.secondary.length).toBeLessThanOrEqual(secondary.length);
+		expect(row.secondary.map((part) => part.id)).toEqual(
+			secondary.slice(0, row.secondary.length).map((part) => part.id),
+		);
+		for (let index = 0; index < row.secondary.length; index++) {
+			const returned = row.secondary[index]!;
+			const original = secondary[index]!;
+			if (returned.text !== original.text) {
+				expect(index).toBe(row.secondary.length - 1);
+				expect(returned.text.endsWith("…")).toBe(true);
+			}
+		}
+	},
+);
+
+const sufficientWidthCases = [
+	{ label: "default two-column gap", gap: undefined, effectiveGap: 2 },
+	{ label: "zero-column gap", gap: 0, effectiveGap: 0 },
+	{ label: "one-column gap", gap: 1, effectiveGap: 1 },
+	{ label: "five-column gap", gap: 5, effectiveGap: 5 },
+].flatMap((entry) => [0, 9].map((spare) => ({ ...entry, spare })));
+
+test.each(sufficientWidthCases)(
+	"R7.2 REQ-8 TEST-22 preserves all text with $label and $spare spare columns",
+	({ gap, effectiveGap, spare }) => {
+		const name = "会社-kit";
+		const fixed = 8;
+		const secondary = [
+			{ text: "by Équipe", id: "company" },
+			{ text: "● 3 skills edited here", id: "status" },
+			{ text: "👩‍💻 é", id: "detail" },
+		];
+		const required =
+			displayWidth(name) +
+			fixed +
+			secondary.reduce(
+				(total, part) => total + effectiveGap + displayWidth(part.text),
+				0,
+			);
+		const width = required + spare;
+
+		const row =
+			gap === undefined
+				? fitRow(width, name, fixed, secondary)
+				: fitRow(width, name, fixed, secondary, gap);
+
+		expect(row).toEqual({ name, secondary });
+		expect(rowColumns(row, fixed, effectiveGap)).toBe(required);
+		expect(rowColumns(row, fixed, effectiveGap)).toBeLessThanOrEqual(width);
+	},
+);

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

@@ -0,0 +1,253 @@
+import { afterEach, expect, test } from "bun:test";
+import { isAbsolute, join } from "node:path";
+import { companyPluginNames } from "../services/market-ops.js";
+import {
+	MarketFixture,
+	SKILL,
+	sourceModule,
+	write,
+	writeJson,
+} from "./market-fixture.js";
+
+type LocalItems = Awaited<
+	ReturnType<typeof import("../services/market-local.js").localItems>
+>;
+
+let world: MarketFixture | undefined;
+afterEach(() => {
+	world?.close();
+	world = undefined;
+});
+
+const scopes = [
+	{ from: "project", scope: "project" },
+	{ from: "global", scope: "user" },
+] as const;
+
+function discover(
+	f: MarketFixture,
+	companySkills: readonly string[] = [],
+	companyPlugins?: readonly string[],
+): LocalItems {
+	const pluginsArgument =
+		companyPlugins === undefined
+			? ""
+			: `,new Set(${JSON.stringify(companyPlugins)})`;
+	return f.value<LocalItems>(
+		`const {localItems}=await import(${JSON.stringify(sourceModule("services/market-local.js"))});console.log(JSON.stringify(await localItems(${JSON.stringify(f.project)},new Set(${JSON.stringify(companySkills)})${pluginsArgument})));`,
+	);
+}
+
+test.each(["omitted", "empty"] as const)(
+	"R5.1 REQ-1 TEST-1 retains plugins when companyPlugins is %s",
+	(mode) => {
+		world = new MarketFixture(true);
+		const f = world;
+		const projectPlugin = f.folder("project", "folder-label");
+		const userPlugin = f.folder("global", "fallback-kit");
+		writeJson(join(projectPlugin, ".claude-plugin", "plugin.json"), {
+			name: "company-kit",
+			version: "1.0.0",
+		});
+		writeJson(join(userPlugin, ".claude-plugin", "plugin.json"), {
+			version: "1.0.0",
+		});
+
+		const items = discover(f, [], mode === "omitted" ? undefined : []);
+
+		expect(items).toEqual([
+			{
+				kind: "plugin",
+				name: "company-kit",
+				scope: "project",
+				path: projectPlugin,
+			},
+			{
+				kind: "plugin",
+				name: "fallback-kit",
+				scope: "user",
+				path: userPlugin,
+			},
+		]);
+	},
+);
+
+test.each(scopes)(
+	"R5.1 REQ-1 TEST-2 excludes a held manifest name in $scope but keeps skills and plugin prefix matches",
+	({ from, scope }) => {
+		world = new MarketFixture(true);
+		const f = world;
+		const held = f.folder(from, "different-folder");
+		const namesakeSkill = f.folder(from, "shared-kit");
+		const unheld = f.folder(from, "unheld-folder");
+		writeJson(join(held, ".claude-plugin", "plugin.json"), {
+			name: "shared-kit",
+			version: "1.0.0",
+		});
+		write(join(held, "SKILL.md"), SKILL);
+		write(join(namesakeSkill, "SKILL.md"), SKILL);
+		writeJson(join(unheld, ".claude-plugin", "plugin.json"), {
+			name: "shared-kit-extra",
+			version: "1.0.0",
+		});
+
+		const items = discover(f, [], ["shared-kit"]);
+
+		expect(items).toEqual([
+			{
+				kind: "skill",
+				name: "shared-kit",
+				scope,
+				path: namesakeSkill,
+			},
+			{
+				kind: "plugin",
+				name: "shared-kit-extra",
+				scope,
+				path: unheld,
+			},
+		]);
+	},
+);
+
+test.each(scopes)(
+	"R5.1 REQ-1 TEST-3 uses the manifest name rather than a held folder label in $scope",
+	({ from, scope }) => {
+		world = new MarketFixture(true);
+		const f = world;
+		const folder = f.folder(from, "held-folder");
+		writeJson(join(folder, ".claude-plugin", "plugin.json"), {
+			name: "unheld-kit",
+			version: "1.0.0",
+		});
+
+		const items = discover(f, [], ["held-folder"]);
+
+		expect(items).toEqual([
+			{ kind: "plugin", name: "unheld-kit", scope, path: folder },
+		]);
+	},
+);
+
+test.each(scopes)(
+	"R5.1 REQ-1 TEST-4 excludes a held folder-name fallback in $scope",
+	({ from, scope }) => {
+		world = new MarketFixture(true);
+		const f = world;
+		const held = f.folder(from, "held-kit");
+		const kept = f.folder(from, "kept-kit");
+		for (const folder of [held, kept]) {
+			writeJson(join(folder, ".claude-plugin", "plugin.json"), {
+				version: "1.0.0",
+			});
+		}
+
+		const items = discover(f, [], ["held-kit"]);
+
+		expect(items).toEqual([
+			{ kind: "plugin", name: "kept-kit", scope, path: kept },
+		]);
+	},
+);
+
+test("R5.1 REQ-1 TEST-5 applies companySkills and companyPlugins only to their own item kinds", () => {
+	world = new MarketFixture(true);
+	const f = world;
+	const heldSkill = f.folder("project", "held-skill");
+	const skillNamesake = f.folder("project", "held-kit");
+	const pluginNamesake = f.folder("global", "plugin-folder");
+	const heldPlugin = f.folder("global", "held-plugin-folder");
+	write(join(heldSkill, "SKILL.md"), SKILL);
+	write(join(skillNamesake, "SKILL.md"), SKILL);
+	writeJson(join(pluginNamesake, ".claude-plugin", "plugin.json"), {
+		name: "held-skill",
+		version: "1.0.0",
+	});
+	writeJson(join(heldPlugin, ".claude-plugin", "plugin.json"), {
+		name: "held-kit",
+		version: "1.0.0",
+	});
+
+	const items = discover(f, ["held-skill"], ["held-kit"]);
+
+	expect(items).toEqual([
+		{
+			kind: "skill",
+			name: "held-kit",
+			scope: "project",
+			path: skillNamesake,
+		},
+		{
+			kind: "plugin",
+			name: "held-skill",
+			scope: "user",
+			path: pluginNamesake,
+		},
+	]);
+});
+
+test("R5.2 REQ-2 TEST-6 returns the union of plugin names across every marketplace without skill names or duplicates", () => {
+	const marketplaces: Parameters<typeof companyPluginNames>[0] = [
+		{
+			plugins: [
+				{ name: "review-kit", version: "1.0.0", skills: ["review"] },
+				{ name: "deploy-kit", version: "2.0.0", skills: ["deploy"] },
+			],
+		},
+		{ plugins: [] },
+		{
+			plugins: [
+				{ name: "review-kit", version: "3.0.0", skills: ["different-skill"] },
+				{ name: "empty-kit", version: "1.0.0", skills: [] },
+			],
+		},
+	];
+
+	const names = companyPluginNames(marketplaces);
+
+	expect(names).toBeInstanceOf(Set);
+	expect([...names].sort()).toEqual(["deploy-kit", "empty-kit", "review-kit"]);
+});
+
+test.each([
+	{ label: "no marketplaces", entries: [] },
+	{
+		label: "only empty marketplaces",
+		entries: [{ plugins: [] }, { plugins: [] }],
+	},
+])("R5.2 REQ-2 TEST-7 returns an empty set for $label", ({ entries }) => {
+	const names = companyPluginNames(entries);
+
+	expect(names).toBeInstanceOf(Set);
+	expect([...names]).toEqual([]);
+});
+
+test("R6.3 REQ-6 TEST-8 keeps LocalItem.path absolute for project and USER skills and plugins", () => {
+	world = new MarketFixture();
+	const f = world;
+	const expected: LocalItems = [];
+	for (const { from, scope } of scopes) {
+		const plugin = f.folder(from, "alpha-kit");
+		const skill = f.folder(from, "beta-skill");
+		writeJson(join(plugin, ".claude-plugin", "plugin.json"), {
+			name: "alpha-kit",
+			version: "1.0.0",
+		});
+		write(join(skill, "SKILL.md"), SKILL);
+		expected.push(
+			{ kind: "plugin", name: "alpha-kit", scope, path: plugin },
+			{ kind: "skill", name: "beta-skill", scope, path: skill },
+		);
+	}
+	expected.sort(
+		(a, b) => a.name.localeCompare(b.name) || a.scope.localeCompare(b.scope),
+	);
+
+	const items = discover(f);
+
+	expect(items).toEqual(expected);
+	for (const item of items) {
+		expect(isAbsolute(item.path)).toBe(true);
+		expect(item.path.startsWith("~")).toBe(false);
+	}
+});

package/src/__tests__/market-r2b-plugin-add.test.ts

@@ -0,0 +1,130 @@
+import { afterEach, expect, test } from "bun:test";
+import { readFileSync, statSync } from "node:fs";
+import { isAbsolute, join, relative } from "node:path";
+import { MarketFixture, SKILL, write, writeJson } from "./market-fixture.js";
+
+let world: MarketFixture | undefined;
+afterEach(() => {
+	world?.close();
+	world = undefined;
+});
+
+const scopes = [
+	{ from: "project", scope: "project" },
+	{ from: "global", scope: "user" },
+] as const;
+
+function makePlugin(f: MarketFixture, from: "project" | "global"): string {
+	const folder = f.folder(from, "copy-me");
+	writeJson(join(folder, ".claude-plugin", "plugin.json"), {
+		name: "local-kit",
+		description: "Local team tools",
+		version: "1.2.3",
+	});
+	write(join(folder, "README.md"), "Local team tools\n");
+	write(join(folder, "skills", "review", "SKILL.md"), SKILL);
+	return folder;
+}
+
+test.each(scopes)(
+	"R5.3 R6.3 REQ-3 REQ-6 TEST-9 removes the added $scope plugin from local JSON but retains its folder and unrelated items",
+	({ from, scope }) => {
+		world = new MarketFixture(true);
+		const f = world;
+		const repo = f.seed();
+		f.register(repo);
+		const folder = makePlugin(f, from);
+		const manifest = join(folder, ".claude-plugin", "plugin.json");
+		const originalManifest = readFileSync(manifest, "utf8");
+		const spareSkill = f.folder(from, "spare-skill");
+		write(join(spareSkill, "SKILL.md"), SKILL);
+
+		const before = f.market(["list"]);
+
+		expect(before.code).toBe(0);
+		expect(before.result.local).toEqual([
+			{ kind: "plugin", name: "local-kit", scope, path: folder },
+			{ kind: "skill", name: "spare-skill", scope, path: spareSkill },
+		]);
+		for (const item of before.result.local ?? []) {
+			expect(isAbsolute(item.path)).toBe(true);
+		}
+
+		const added = f.market([
+			"plugin",
+			"add",
+			folder,
+			"--to",
+			repo.name,
+			"--yes",
+		]);
+		expect({ exit: added.code, outcome: added.result.outcome }).toEqual({
+			exit: 0,
+			outcome: "ok",
+		});
+		const after = f.market(["list"]);
+
+		expect(after.code).toBe(0);
+		expect(after.result.local).toEqual([
+			{ kind: "skill", name: "spare-skill", scope, path: spareSkill },
+		]);
+		expect(
+			after.result.marketplaces
+				?.find((entry) => entry.name === repo.name)
+				?.plugins.map((plugin) => plugin.name),
+		).toContain("local-kit");
+		for (const item of after.result.local ?? []) {
+			expect(isAbsolute(item.path)).toBe(true);
+		}
+		expect(statSync(folder).isDirectory()).toBe(true);
+		expect(readFileSync(manifest, "utf8")).toBe(originalManifest);
+		expect(readFileSync(join(folder, "README.md"), "utf8")).toBe(
+			"Local team tools\n",
+		);
+		expect(
+			readFileSync(join(folder, "skills", "review", "SKILL.md"), "utf8"),
+		).toBe(SKILL);
+		f.assertOwned();
+	},
+	60_000,
+);
+
+test.each([
+	{ from: "project", input: "absolute" },
+	{ from: "project", input: "relative" },
+	{ from: "global", input: "absolute" },
+	{ from: "global", input: "relative" },
+] as const)(
+	"R6.2 REQ-5 TEST-10 prints one short source path for a $from plugin given a $input argument",
+	({ from, input }) => {
+		world = new MarketFixture();
+		const f = world;
+		const repo = f.seed();
+		f.register(repo);
+		const folder = makePlugin(f, from);
+		const argument =
+			input === "absolute" ? folder : relative(f.project, folder);
+		const expectedDisplay =
+			from === "project"
+				? join(".claude", "skills", "copy-me")
+				: join("~", ".claude", "skills", "copy-me");
+		const before = f.snapshot();
+
+		const plan = f.cli([
+			"market",
+			"plugin",
+			"add",
+			argument,
+			"--to",
+			repo.name,
+		]);
+
+		expect(plan.code).toBe(3);
+		const humanOutput = `${plan.out}\n${plan.err}`;
+		expect(humanOutput).toContain(expectedDisplay);
+		expect(humanOutput.split(expectedDisplay)).toHaveLength(2);
+		expect(humanOutput).not.toContain(folder);
+		expect(f.snapshot()).toEqual(before);
+	},
+	30_000,
+);

package/src/__tests__/market-router.test.ts

@@ -7,13 +7,13 @@ afterEach(() => {
 	f = undefined;
 });
 
-test("TEST-17 REQ-1 routing market selects a different app than bare magus", () => {
+test("TEST-17 REQ-1 routing edit selects a different app than bare magus", () => {
 	f = new MarketFixture();
 	const before = f.snapshot();
 	const routes = f.value<
 		Array<{ launchTui: boolean; app?: string; handled: boolean }>
 	>(
-		`const {route}=await import(${JSON.stringify(sourceModule("cli/router.js"))}); console.log(JSON.stringify([await route(['market'],'1.2.3'),await route([],'1.2.3')]));`,
+		`const {route}=await import(${JSON.stringify(sourceModule("cli/router.js"))}); console.log(JSON.stringify([await route(['edit'],'1.2.3'),await route([],'1.2.3')]));`,
 	);
 	expect(routes[0]).toEqual({ handled: false, launchTui: true, app: "market" });
 	expect(routes[1]?.handled).toBe(false);
@@ -21,11 +21,11 @@ test("TEST-17 REQ-1 routing market selects a different app than bare magus", ()
 	expect(routes[1]?.app ?? "main").toBe("main");
 	expect(f.snapshot()).toEqual(before);
 });
-test("TEST-17 REQ-1 headless bare market is a usage error without renderer writes", () => {
+test("TEST-17 REQ-1 headless bare edit is a usage error without renderer writes", () => {
 	f = new MarketFixture();
 	const before = f.snapshot();
 
-	const r = f.cli(["market"]);
+	const r = f.cli(["edit"]);
 
 	expect(r.code).toBe(2);
 	expect(r.out + r.err).toMatch(/terminal|TTY|interactive/i);