magus-cli 0.0.0-placeholder → 7.0.0

package/src/__tests__/plugin-cli-argv.test.ts

@@ -0,0 +1,109 @@
+/**
+ * What `claude` subcommand does each plugin operation actually run?
+ *
+ * This file exists because the answer was wrong for a long time and nothing
+ * could see it. `updatePlugin` ran `claude plugin install`, on a comment that
+ * asserted install "handles both fresh installs and re-installs (upgrades)".
+ * It does not. Measured against Claude Code 2.1.252, with designer@magus
+ * installed at 0.6.0 and 0.6.1 published:
+ *
+ *     $ claude plugin install designer@magus --scope project
+ *     ✔ Plugin "designer@magus" is already installed (scope: project)   # exit 0
+ *
+ *     $ claude plugin update designer@magus --scope project
+ *     ✔ Plugin "designer" updated from 0.6.0 to 0.6.1 for scope project # exit 0
+ *
+ * Both exit 0. The no-op is indistinguishable from success at every layer
+ * above, so every magus update path — the TUI's `U`, "update all", the
+ * scope menu, `magus update` — reported
+ * success and changed nothing, for ever.
+ *
+ * Mocking the CLI cannot catch that: a stub answers whatever the test asks it
+ * to. Only the argv is checkable here, so the argv is what these assert, with a
+ * real `claude` shim on PATH recording what it was called with.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+	chmodSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import {
+	installPlugin,
+	repairPlugin,
+	updatePlugin,
+} from "../services/claude-cli.js";
+
+let root: string;
+let logFile: string;
+let savedPath: string | undefined;
+
+beforeEach(() => {
+	root = mkdtempSync(path.join(tmpdir(), "claude-argv-"));
+	const bin = path.join(root, "bin");
+	mkdirSync(bin);
+	logFile = path.join(root, "argv.log");
+
+	// A real executable, so this goes through which(1), execFile and the whole
+	// wrapper rather than a module double.
+	const shim = path.join(bin, "claude");
+	writeFileSync(shim, `#!/bin/sh\necho "$@" >> "${logFile}"\nexit 0\n`);
+	chmodSync(shim, 0o755);
+
+	savedPath = process.env.PATH;
+	// The shim dir goes FIRST so it shadows a real claude, but the system dirs
+	// stay: `getClaudePath` resolves through which(1), which lives in /usr/bin.
+	process.env.PATH = [bin, "/usr/bin", "/bin"].join(path.delimiter);
+});
+
+afterEach(() => {
+	process.env.PATH = savedPath ?? "";
+	rmSync(root, { recursive: true, force: true });
+});
+
+/** Every argv the shim saw, one line per invocation. */
+function calls(): string[] {
+	try {
+		return readFileSync(logFile, "utf8").trim().split("\n").filter(Boolean);
+	} catch {
+		return [];
+	}
+}
+
+describe("which claude subcommand each operation runs", () => {
+	test("updatePlugin runs `plugin update` — NOT `plugin install`", async () => {
+		await updatePlugin("designer@magus", "project");
+		expect(calls()).toEqual(["plugin update designer@magus --scope project"]);
+	});
+
+	test("installPlugin runs `plugin install`", async () => {
+		await installPlugin("designer@magus", "project");
+		expect(calls()).toEqual(["plugin install designer@magus --scope project"]);
+	});
+
+	test("repairPlugin uninstalls then installs, in that order", async () => {
+		// Content drift under an unchanged version: `update` has no version bump
+		// to act on and `install` answers "already installed", so only the
+		// uninstall+install pair re-copies the files.
+		await repairPlugin("designer@magus", "project", root);
+		expect(calls()).toEqual([
+			"plugin uninstall designer@magus --scope project",
+			"plugin install designer@magus --scope project",
+		]);
+	});
+
+	test("the scope reaches the CLI verbatim, at every scope", async () => {
+		await updatePlugin("dev@magus", "user");
+		await updatePlugin("dev@magus", "local");
+		expect(calls()).toEqual([
+			"plugin update dev@magus --scope user",
+			"plugin update dev@magus --scope local",
+		]);
+	});
+});

package/src/__tests__/plugin-contents.test.ts

@@ -0,0 +1,371 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import type { PluginInfo } from "../services/plugin-manager.js";
+import {
+	fetchPluginContents,
+	splitSkillDocument,
+} from "../services/skills-manager.js";
+import type { Marketplace } from "../types/index.js";
+import {
+	buildPluginBrowserItems,
+	pluginContentsRepo,
+} from "../ui/adapters/pluginsAdapter.js";
+import type { PluginContentsEntry } from "../ui/state/types.js";
+
+// ─── fetchPluginContents ─────────────────────────────────────────────────────
+
+const realFetch = globalThis.fetch;
+
+/**
+ * Serve one canned git-tree response. `fetchGitTree` caches per repo for the
+ * life of the process, so every test must use a repo name of its own.
+ */
+function stubTree(paths: string[]): void {
+	globalThis.fetch = (async () =>
+		new Response(
+			JSON.stringify({
+				sha: "deadbeef",
+				truncated: false,
+				tree: paths.map((path) => ({
+					path,
+					mode: "100644",
+					type: "blob",
+					sha: `sha-${path}`,
+				})),
+			}),
+			{ status: 200, headers: { ETag: '"x"' } },
+		)) as unknown as typeof fetch;
+}
+
+afterEach(() => {
+	globalThis.fetch = realFetch;
+});
+
+describe("fetchPluginContents", () => {
+	it("counts a grouped skills/ tree once per skill, not once per group", async () => {
+		stubTree([
+			"README.md",
+			"skills/engineering/code-review/SKILL.md",
+			"skills/engineering/tdd/SKILL.md",
+			"skills/writing/prd/SKILL.md",
+		]);
+
+		const skills = await fetchPluginContents("fake/grouped", "./");
+
+		expect(skills.map((s) => s.name)).toEqual(["code-review", "tdd", "prd"]);
+		expect(skills.every((s) => s.kind === "skill")).toBe(true);
+		expect(skills[0].group).toBe("engineering");
+		expect(skills[2].group).toBe("writing");
+	});
+
+	it("ignores harness mirrors and translated docs trees", async () => {
+		// everything-claude-code's real shape: 286 skills under skills/, mirrored
+		// into four harness directories and six docs/<lang>/ trees for 898 files.
+		stubTree([
+			"skills/api-design/SKILL.md",
+			"skills/agent-sort/SKILL.md",
+			".agents/skills/api-design/SKILL.md",
+			".kiro/skills/api-design/SKILL.md",
+			".cursor/skills/api-design/SKILL.md",
+			"docs/ja-JP/skills/api-design/SKILL.md",
+			"docs/zh-CN/skills/api-design/SKILL.md",
+		]);
+
+		const skills = await fetchPluginContents("fake/mirrored", "./");
+
+		expect(skills.map((s) => s.name)).toEqual(["agent-sort", "api-design"]);
+	});
+
+	it("finds a plugin that is one skill at its root", async () => {
+		// blader/humanizer: a root SKILL.md and no skills/ directory at all.
+		stubTree([".claude-plugin/plugin.json", "SKILL.md", "README.md"]);
+
+		const skills = await fetchPluginContents("blader/humanizer", "./");
+
+		expect(skills).toHaveLength(1);
+		expect(skills[0].name).toBe("humanizer");
+		expect(skills[0].repoPath).toBe("SKILL.md");
+	});
+
+	it("scopes to one plugin's subtree in a multi-plugin marketplace", async () => {
+		stubTree([
+			"plugins/dev/skills/frontend/design-system/SKILL.md",
+			"plugins/dev/skills/backend/db-branching/SKILL.md",
+			"plugins/designer/skills/ui-analyse/SKILL.md",
+		]);
+
+		const skills = await fetchPluginContents("fake/multi", "./plugins/dev");
+
+		expect(skills.map((s) => s.name)).toEqual([
+			"db-branching",
+			"design-system",
+		]);
+	});
+
+	it("still lists commands and agents for a plugin with no skills", async () => {
+		stubTree(["agents/reviewer.md", "commands/go.md"]);
+
+		const found = await fetchPluginContents("fake/no-skills", "./");
+
+		expect(found.filter((c) => c.kind === "skill")).toEqual([]);
+		expect(found.map((c) => `${c.kind}:${c.name}`)).toEqual([
+			"command:go",
+			"agent:reviewer",
+		]);
+	});
+});
+
+// ─── splitSkillDocument ──────────────────────────────────────────────────────
+
+describe("splitSkillDocument", () => {
+	it("keeps frontmatter in file order so description stays near the top", () => {
+		const { frontmatter } = splitSkillDocument(
+			[
+				"---",
+				"name: code-review",
+				"description: Reviews a diff for correctness",
+				"allowed-tools: Read, Grep",
+				"---",
+				"",
+				"# Code review",
+			].join("\n"),
+		);
+
+		expect(frontmatter.map((f) => f.key)).toEqual([
+			"name",
+			"description",
+			"allowed-tools",
+		]);
+		expect(frontmatter[1].value).toBe("Reviews a diff for correctness");
+	});
+
+	it("flattens both list shapes to one display string", () => {
+		const { frontmatter } = splitSkillDocument(
+			[
+				"---",
+				'tags: ["tdd", "testing"]',
+				"allowed-tools:",
+				"  - Read",
+				"  - Bash",
+				"---",
+				"body",
+			].join("\n"),
+		);
+
+		expect(frontmatter[0]).toEqual({ key: "tags", value: "tdd, testing" });
+		expect(frontmatter[1]).toEqual({
+			key: "allowed-tools",
+			value: "Read, Bash",
+		});
+	});
+
+	it("separates the body and counts its lines", () => {
+		const doc = splitSkillDocument(
+			["---", "name: x", "---", "", "# Title", "", "Body text.", ""].join("\n"),
+		);
+
+		expect(doc.body).toBe("# Title\n\nBody text.");
+		expect(doc.bodyLines).toBe(3);
+	});
+
+	it("treats a file with no frontmatter as all body", () => {
+		const doc = splitSkillDocument("# Just markdown\n\nNo frontmatter here.");
+
+		expect(doc.frontmatter).toEqual([]);
+		expect(doc.body).toBe("# Just markdown\n\nNo frontmatter here.");
+	});
+
+	it("reports an empty body rather than a phantom line", () => {
+		const doc = splitSkillDocument("---\nname: x\ndescription: y\n---\n");
+
+		expect(doc.body).toBe("");
+		expect(doc.bodyLines).toBe(0);
+	});
+});
+
+// ─── buildPluginBrowserItems ─────────────────────────────────────────────────
+
+const marketplace: Marketplace = {
+	name: "mattpocock",
+	displayName: "Matt Pocock",
+	source: { source: "github", repo: "mattpocock/skills" },
+	description: "Agent skills for real engineering",
+	featured: true,
+};
+
+function makePlugin(overrides: Partial<PluginInfo> = {}): PluginInfo {
+	return {
+		id: "mattpocock-skills@mattpocock",
+		name: "mattpocock-skills",
+		version: "1.0.0",
+		description: "Matt Pocock's agent skills",
+		marketplace: "mattpocock",
+		marketplaceDisplay: "Matt Pocock",
+		enabled: false,
+		source: "./",
+		...overrides,
+	};
+}
+
+function build(
+	plugin: PluginInfo,
+	expandedPlugins: Set<string>,
+	pluginContents: Map<string, PluginContentsEntry> = new Map(),
+) {
+	return buildPluginBrowserItems({
+		marketplaces: [marketplace],
+		plugins: [plugin],
+		collapsedMarketplaces: new Set(),
+		expandedPlugins,
+		pluginContents,
+	});
+}
+
+describe("buildPluginBrowserItems component rows", () => {
+	it("marks a plugin expandable and emits no component rows while collapsed", () => {
+		const items = build(makePlugin(), new Set());
+
+		expect(items.map((i) => i.kind)).toEqual(["category", "plugin"]);
+		const row = items[1];
+		expect(row.kind === "plugin" && row.isExpandable).toBe(true);
+		expect(row.kind === "plugin" && row.isExpanded).toBe(false);
+	});
+
+	it("emits one row per component when expanded, of every kind", () => {
+		const items = build(
+			makePlugin(),
+			new Set(["mattpocock-skills@mattpocock"]),
+			new Map([
+				[
+					"mattpocock-skills@mattpocock",
+					{
+						status: "success",
+						components: [
+							{
+								kind: "skill",
+								name: "code-review",
+								repoPath: "skills/engineering/code-review/SKILL.md",
+								group: "engineering",
+							},
+							{ kind: "command", name: "go", repoPath: "commands/go.md" },
+							{ kind: "agent", name: "critic", repoPath: "agents/critic.md" },
+							{ kind: "mcp", name: "mnemex", repoPath: ".mcp.json" },
+						],
+					} satisfies PluginContentsEntry,
+				],
+			]),
+		);
+
+		expect(items.map((i) => i.kind)).toEqual([
+			"category",
+			"plugin",
+			"component",
+			"component",
+			"component",
+			"component",
+		]);
+		expect(items.slice(2).map((i) => i.label)).toEqual([
+			"code-review",
+			"go",
+			"critic",
+			"mnemex",
+		]);
+	});
+
+	it("gives an MCP-only plugin a row instead of rendering it as empty", () => {
+		// mnemex: no skills, no commands, no agents, one server. It used to show
+		// nothing at all, which read as a plugin that ships nothing.
+		const items = build(
+			makePlugin({ id: "mnemex@magus", name: "mnemex" }),
+			new Set(["mnemex@magus"]),
+			new Map([
+				[
+					"mnemex@magus",
+					{
+						status: "success",
+						components: [
+							{
+								kind: "mcp",
+								name: "mnemex",
+								repoPath: ".mcp.json",
+								mcpCommand: "mnemex --mcp",
+							},
+						],
+					} satisfies PluginContentsEntry,
+				],
+			]),
+		);
+
+		expect(items[2].kind).toBe("component");
+		expect(items[2].label).toBe("mnemex");
+	});
+
+	it("shows a loading row before the listing arrives", () => {
+		const items = build(
+			makePlugin(),
+			new Set(["mattpocock-skills@mattpocock"]),
+		);
+
+		expect(items[2].kind).toBe("contents-status");
+		expect(items[2].kind === "contents-status" && items[2].status).toBe(
+			"loading",
+		);
+	});
+
+	it("surfaces a failed listing instead of rendering an empty expansion", () => {
+		const items = build(
+			makePlugin(),
+			new Set(["mattpocock-skills@mattpocock"]),
+			new Map([
+				[
+					"mattpocock-skills@mattpocock",
+					{
+						status: "error",
+						error: "GitHub API rate limit exceeded",
+					} satisfies PluginContentsEntry,
+				],
+			]),
+		);
+
+		expect(items[2].kind === "contents-status" && items[2].status).toBe(
+			"error",
+		);
+		expect(items[2].kind === "contents-status" && items[2].error).toBe(
+			"GitHub API rate limit exceeded",
+		);
+	});
+
+	it("does not offer expansion for an orphaned plugin", () => {
+		const items = build(makePlugin({ isOrphaned: true }), new Set());
+
+		expect(items[1].kind === "plugin" && items[1].isExpandable).toBe(false);
+	});
+
+	it("does not offer expansion when the marketplace has no repo to read", () => {
+		const items = buildPluginBrowserItems({
+			marketplaces: [
+				{ ...marketplace, source: { source: "directory", repo: undefined } },
+			],
+			plugins: [makePlugin()],
+			collapsedMarketplaces: new Set(),
+			expandedPlugins: new Set(),
+			pluginContents: new Map(),
+		});
+
+		expect(items[1].kind === "plugin" && items[1].isExpandable).toBe(false);
+	});
+});
+
+describe("pluginContentsRepo", () => {
+	it("prefers a plugin's own repo over its marketplace's", () => {
+		const plugin = makePlugin({ sourceRepo: "addyosmani/agent-skills" });
+		expect(pluginContentsRepo(plugin, marketplace)).toBe(
+			"addyosmani/agent-skills",
+		);
+	});
+
+	it("falls back to the marketplace repo", () => {
+		expect(pluginContentsRepo(makePlugin(), marketplace)).toBe(
+			"mattpocock/skills",
+		);
+	});
+});