magus-cli 0.0.0-placeholder → 7.1.0

package/src/__tests__/manifest.test.ts

@@ -0,0 +1,281 @@
+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 {
+	emptyManifest,
+	mergeManifestSettings,
+	migrateToV2,
+	readManifest,
+	validateManifest,
+	writeManifest,
+} from "../services/manifest.js";
+import type { ProfileManifest } from "../types/index.js";
+
+describe("migrateToV2", () => {
+	test("a v1 file migrates by version bump, profiles preserved", () => {
+		const v1 = {
+			version: 1,
+			profiles: {
+				mine: {
+					name: "Mine",
+					plugins: { "dev@magus": true },
+					createdAt: "t",
+					updatedAt: "t",
+				},
+			},
+		};
+		const v2 = migrateToV2(v1);
+		expect(v2.version).toBe(2);
+		expect(v2.profiles.mine!.name).toBe("Mine");
+		expect(v2.profiles.mine!.plugins).toEqual({ "dev@magus": true });
+	});
+
+	test("null/garbage input degrades to an empty manifest", () => {
+		expect(migrateToV2(null)).toEqual(emptyManifest());
+		expect(migrateToV2(42)).toEqual(emptyManifest());
+		expect(migrateToV2({})).toEqual(emptyManifest());
+	});
+
+	test("non-object profile entries are dropped", () => {
+		const v2 = migrateToV2({
+			version: 2,
+			profiles: { good: { name: "G" }, bad: 5 },
+		});
+		expect(Object.keys(v2.profiles)).toEqual(["good"]);
+	});
+
+	test("strictVersions is carried through as a boolean", () => {
+		expect(
+			migrateToV2({ version: 2, strictVersions: true, profiles: {} })
+				.strictVersions,
+		).toBe(true);
+		// Omitted (not written as false) to keep a committed manifest minimal.
+		expect(
+			migrateToV2({ version: 2, profiles: {} }).strictVersions,
+		).toBeUndefined();
+	});
+});
+
+describe("validateManifest", () => {
+	const valid: ProfileManifest = {
+		version: 2,
+		profiles: {
+			frontend: {
+				name: "Frontend",
+				plugins: { "dev@magus": "2.9.0" },
+				marketplaces: { magus: { source: "github", repo: "MadAppGang/magus" } },
+				skills: [{ name: "A", repo: "o/r", path: "skills/a" }],
+			},
+		},
+	};
+
+	test("a well-formed manifest yields no errors", () => {
+		expect(validateManifest(valid)).toEqual([]);
+	});
+
+	test("flags version != 2 and empty profiles", () => {
+		const errors = validateManifest({ version: 1, profiles: {} } as never);
+		expect(errors.some((e) => e.path === "version")).toBe(true);
+		expect(errors.some((e) => e.path === "profiles")).toBe(true);
+	});
+
+	test("flags a plugin id without a marketplace", () => {
+		const errors = validateManifest({
+			version: 2,
+			profiles: { p: { name: "P", plugins: { dev: "1.0.0" } } },
+		});
+		expect(errors.some((e) => e.path === "profiles.p.plugins.dev")).toBe(true);
+	});
+
+	test("flags a github marketplace missing repo and a skill missing path", () => {
+		const errors = validateManifest({
+			version: 2,
+			profiles: {
+				p: {
+					name: "P",
+					marketplaces: { m: { source: "github" } },
+					skills: [{ name: "A", repo: "o/r" } as never],
+				},
+			},
+		});
+		expect(errors.some((e) => e.path === "profiles.p.marketplaces.m")).toBe(
+			true,
+		);
+		expect(errors.some((e) => e.path.startsWith("profiles.p.skills"))).toBe(
+			true,
+		);
+	});
+
+	// Model routing is the one field whose bad value does not degrade: MEASURED
+	// (benches/agent-model-routing `bogus-model`, 5/5), a model the Agent tool
+	// does not accept refuses the spawn outright, so every subagent dispatch
+	// fails for everyone who pulled the manifest. This is the gate.
+	test("a hand-edited models block is validated, path-prefixed by profile", () => {
+		const errors = validateManifest({
+			version: 2,
+			profiles: {
+				p: {
+					name: "P",
+					models: {
+						version: 1,
+						preset: "hand",
+						main: { model: "opus" },
+						grades: {
+							smart: { model: "claude-opus-4-6" },
+							normal: { model: "opus" },
+							cheap: { model: "sonnet" },
+						},
+						agents: {},
+						fallback: "normal",
+					},
+				},
+			},
+		} as unknown as ProfileManifest);
+
+		expect(
+			errors.some((e) => e.path === "profiles.p.models.grades.smart.model"),
+		).toBe(true);
+	});
+
+	test("a valid models block reports nothing", () => {
+		const errors = validateManifest({
+			version: 2,
+			profiles: {
+				p: {
+					name: "P",
+					models: {
+						version: 1,
+						preset: "fable-advisor",
+						main: { model: "opus", effort: "medium" },
+						grades: {
+							smart: { model: "fable", effort: "xhigh" },
+							normal: { model: "opus", effort: "medium" },
+							cheap: { model: "sonnet", effort: "low" },
+						},
+						agents: { "dev:architect": "smart" },
+						fallback: "normal",
+					},
+				},
+			},
+		} as unknown as ProfileManifest);
+
+		expect(errors).toEqual([]);
+	});
+});
+
+describe("mergeManifestSettings", () => {
+	let dir: string;
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "manifest-merge-"));
+	});
+	afterEach(async () => {
+		await rm(dir, { recursive: true, force: true });
+	});
+
+	test("merges into the entry's settings, keeping what was there", async () => {
+		await writeManifest(
+			{
+				version: 2,
+				profiles: { p: { name: "P", settings: { outputStyle: "direct" } } },
+			},
+			dir,
+		);
+
+		expect(await mergeManifestSettings(dir, "p", { model: "opus" })).toBe(true);
+
+		const m = await readManifest(dir);
+		expect(m.profiles.p!.settings).toEqual({
+			outputStyle: "direct",
+			model: "opus",
+		});
+		expect(m.profiles.p!.updatedAt).toBeDefined();
+	});
+
+	test("unset removes keys outright, not as undefined", async () => {
+		await writeManifest(
+			{
+				version: 2,
+				profiles: { p: { name: "P", settings: { model: "opus", keep: 1 } } },
+			},
+			dir,
+		);
+
+		await mergeManifestSettings(dir, "p", {}, { unset: ["model"] });
+
+		const raw = await fs.readJson(join(dir, ".claude", "profiles.json"));
+		expect("model" in raw.profiles.p.settings).toBe(false);
+		expect(raw.profiles.p.settings.keep).toBe(1);
+	});
+
+	test("false, not an error, when there is nothing to record against", async () => {
+		expect(await mergeManifestSettings(dir, "p", { model: "opus" })).toBe(
+			false,
+		);
+		expect(await mergeManifestSettings(dir, null, { model: "opus" })).toBe(
+			false,
+		);
+
+		await writeManifest(
+			{ version: 2, profiles: { other: { name: "O" } } },
+			dir,
+		);
+		expect(await mergeManifestSettings(dir, "p", { model: "opus" })).toBe(
+			false,
+		);
+	});
+
+	// readManifest degrades a corrupt file to an empty manifest. Reusing it here
+	// would record nothing and report success, leaving the caller's live setting
+	// to be reverted by the next install with no way to learn why.
+	test("throws on an unreadable manifest instead of silently doing nothing", async () => {
+		await fs.outputFile(join(dir, ".claude", "profiles.json"), "{ not json");
+
+		await expect(
+			mergeManifestSettings(dir, "p", { model: "opus" }),
+		).rejects.toThrow(/not valid JSON/);
+
+		expect(
+			await fs.readFile(join(dir, ".claude", "profiles.json"), "utf8"),
+		).toBe("{ not json");
+	});
+});
+
+describe("readManifest / writeManifest", () => {
+	let dir: string;
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "manifest-"));
+	});
+	afterEach(async () => {
+		await rm(dir, { recursive: true, force: true });
+	});
+
+	test("absent file → empty manifest", async () => {
+		expect(await readManifest(dir)).toEqual(emptyManifest());
+	});
+
+	test("roundtrip write→read preserves content", async () => {
+		const manifest: ProfileManifest = {
+			version: 2,
+			strictVersions: true,
+			profiles: { p: { name: "P", plugins: { "dev@magus": "1.0.0" } } },
+		};
+		await writeManifest(manifest, dir);
+		expect(await fs.pathExists(join(dir, ".claude", "profiles.json"))).toBe(
+			true,
+		);
+		expect(await readManifest(dir)).toEqual(manifest);
+	});
+
+	test("a committed v1 file is read as migrated v2", async () => {
+		await fs.ensureDir(join(dir, ".claude"));
+		await fs.writeJson(join(dir, ".claude", "profiles.json"), {
+			version: 1,
+			profiles: { legacy: { name: "L", plugins: { "dev@magus": true } } },
+		});
+		const m = await readManifest(dir);
+		expect(m.version).toBe(2);
+		expect(m.profiles.legacy!.name).toBe("L");
+	});
+});

package/src/__tests__/markdown-renderer.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it } from "bun:test";
+import { renderMarkdown } from "../ui/renderers/markdownRenderer.js";
+
+/**
+ * The renderer emits OpenTUI elements, so these assert structure and counts
+ * rather than pixels: how many lines a construct produces, and that the raw
+ * markers (fences, pipes, hashes) do not survive into the output.
+ */
+
+/** Flatten a rendered node tree to the text a reader would see. */
+function textOf(node: any): string {
+	if (node === null || node === undefined || typeof node === "boolean") {
+		return "";
+	}
+	if (typeof node === "string" || typeof node === "number") return String(node);
+	if (Array.isArray(node)) return node.map(textOf).join("");
+	if (node.props) return textOf(node.props.children);
+	return "";
+}
+
+const render = (src: string, width = 80) =>
+	renderMarkdown(src, { width, maxLines: 500 });
+
+describe("renderMarkdown", () => {
+	it("drops the # markers from a heading", () => {
+		const { nodes } = render("## Routing");
+
+		expect(nodes).toHaveLength(1);
+		expect(textOf(nodes[0])).toBe("Routing");
+	});
+
+	it("drops the fence markers and keeps the code", () => {
+		const { nodes } = render(
+			["```bash", "which mnemex && mnemex --version", "```"].join("\n"),
+		);
+
+		const text = nodes.map(textOf).join("\n");
+		expect(text).not.toContain("```");
+		expect(text).toContain("which mnemex && mnemex --version");
+		expect(text).toContain("bash");
+	});
+
+	it("turns a pipe table into aligned columns with a rule, no pipes", () => {
+		const { nodes } = render(
+			[
+				"| Mode | Keywords |",
+				"|------|----------|",
+				"| Bug | debug, error |",
+				"| Test | coverage |",
+			].join("\n"),
+		);
+
+		// header + rule + 2 body rows
+		expect(nodes).toHaveLength(4);
+		const text = nodes.map(textOf).join("\n");
+		expect(text).not.toContain("|");
+		expect(text).toContain("Mode");
+		expect(text).toContain("debug, error");
+		expect(textOf(nodes[1])).toMatch(/^\s*─+\s+─+$/);
+	});
+
+	it("narrows the widest table column instead of overflowing the pane", () => {
+		const { nodes } = render(
+			["| Mode | Notes |", "|---|---|", `| Bug | ${"x".repeat(120)} |`].join(
+				"\n",
+			),
+			40,
+		);
+
+		for (const node of nodes) {
+			expect(textOf(node).length).toBeLessThanOrEqual(41);
+		}
+		expect(nodes.map(textOf).join("")).toContain("…");
+	});
+
+	it("strips inline markers inside table cells", () => {
+		const { nodes } = render(
+			[
+				"| Mode | Primary Commands |",
+				"|---|---|",
+				"| Bug | `context`, `callers` |",
+				"| Arch | **map** |",
+			].join("\n"),
+		);
+
+		const text = nodes.map(textOf).join("\n");
+		expect(text).toContain("context, callers");
+		expect(text).not.toContain("`");
+		expect(text).not.toContain("**");
+	});
+
+	it("draws a rule for --- rather than printing hyphens as text", () => {
+		const { nodes } = render("---", 30);
+
+		expect(textOf(nodes[0])).toMatch(/^─+$/);
+	});
+
+	it("renders a list bullet and keeps ordered markers", () => {
+		const { nodes } = render(["- first", "2. second"].join("\n"));
+
+		expect(textOf(nodes[0])).toContain("•");
+		expect(textOf(nodes[0])).toContain("first");
+		expect(textOf(nodes[1])).toContain("2.");
+	});
+
+	it("strips inline code backticks and bold asterisks", () => {
+		const { nodes } = render("Run `bun test` and **stop**.");
+
+		const text = textOf(nodes[0]);
+		expect(text).toBe("Run bun test and stop.");
+	});
+
+	it("does not read bold markers that sit inside a code span", () => {
+		const { nodes } = render("Use `a**b` here.");
+
+		expect(textOf(nodes[0])).toBe("Use a**b here.");
+	});
+
+	it("marks a blockquote with a bar instead of a > character", () => {
+		const { nodes } = render("> With a sufficient number of users");
+
+		const text = textOf(nodes[0]);
+		expect(text).toContain("│");
+		expect(text).not.toContain(">");
+	});
+
+	it("reports the lines it stopped short of", () => {
+		const long = Array.from({ length: 30 }, (_, i) => `line ${i}`).join("\n");
+
+		const { nodes, withheld } = renderMarkdown(long, {
+			width: 80,
+			maxLines: 10,
+		});
+
+		expect(nodes).toHaveLength(10);
+		expect(withheld).toBe(20);
+	});
+
+	it("withholds nothing when the whole document fits", () => {
+		expect(render("one\ntwo").withheld).toBe(0);
+	});
+});

package/src/__tests__/marketplace-badge.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, test } from "bun:test";
+import type { Marketplace } from "../types/index.js";
+import { buildPluginBrowserItems } from "../ui/adapters/pluginsAdapter.js";
+
+/**
+ * The marketplace category badge is the line users read on every magus launch,
+ * and it had no coverage. The MadAppGang byline must not leak onto anyone else's
+ * marketplace, and the Official/Deprecated markers must still win.
+ */
+
+const mp = (over: Partial<Marketplace> & { name: string }): Marketplace => ({
+	displayName: over.displayName ?? over.name,
+	source: { source: "github", repo: `someone/${over.name}` },
+	description: "",
+	...over,
+});
+
+/** Badge for a marketplace when it has plugins and is expanded. */
+function badgeFor(marketplace: Marketplace): string | undefined {
+	const items = buildPluginBrowserItems({
+		marketplaces: [marketplace],
+		plugins: [
+			{
+				id: `demo@${marketplace.name}`,
+				name: "demo",
+				marketplace: marketplace.name,
+				// Only the fields the adapter groups on matter here.
+			} as never,
+		],
+		collapsedMarketplaces: new Set(),
+	});
+	const category = items.find((i) => i.kind === "category");
+	return category && "badge" in category ? category.badge : undefined;
+}
+
+/** Tone for a marketplace when it has plugins and is expanded. */
+function toneFor(marketplace: Marketplace): string | undefined {
+	const items = buildPluginBrowserItems({
+		marketplaces: [marketplace],
+		plugins: [
+			{
+				id: `demo@${marketplace.name}`,
+				name: "demo",
+				marketplace: marketplace.name,
+			} as never,
+		],
+		collapsedMarketplaces: new Set(),
+	});
+	const category = items.find((i) => i.kind === "category");
+	return category && "tone" in category ? category.tone : undefined;
+}
+
+describe("marketplace category badge", () => {
+	test("the byline uses a low-key tone, not an attention-grabbing one", () => {
+		// It is a signature, not a status. Green reads as "action succeeded" and
+		// competes with the plugin rows for attention.
+		expect(
+			toneFor(
+				mp({
+					name: "magus",
+					source: { source: "github", repo: "MadAppGang/magus" },
+				}),
+			),
+		).toBe("byline");
+
+		// A third-party marketplace still uses the green "Added" status tone.
+		expect(
+			toneFor(
+				mp({
+					name: "sp",
+					source: { source: "github", repo: "obra/superpowers-marketplace" },
+				}),
+			),
+		).toBe("green");
+	});
+
+	test("MadAppGang marketplaces carry the byline instead of a generic label", () => {
+		for (const name of ["magus", "magus-marketing", "magus-alpha"]) {
+			const badge = badgeFor(
+				mp({ name, source: { source: "github", repo: `MadAppGang/${name}` } }),
+			);
+			expect(badge).toBe("by MadAppGang");
+		}
+	});
+
+	test("owner match is case-insensitive", () => {
+		// The npm/GitHub casing of the org has varied in config; don't depend on it.
+		const badge = badgeFor(
+			mp({
+				name: "magus",
+				source: { source: "github", repo: "madappgang/magus" },
+			}),
+		);
+		expect(badge).toBe("by MadAppGang");
+	});
+
+	test("someone else's marketplace does NOT claim the byline", () => {
+		const badge = badgeFor(
+			mp({
+				name: "superpowers-marketplace",
+				source: { source: "github", repo: "obra/superpowers-marketplace" },
+			}),
+		);
+		expect(badge).toBe("✓ Added");
+	});
+
+	test("a repo merely containing 'madappgang' downstream does not match", () => {
+		// Guards against a substring check — only the owner segment counts.
+		const badge = badgeFor(
+			mp({
+				name: "impostor",
+				source: { source: "github", repo: "evil/madappgang-magus" },
+			}),
+		);
+		expect(badge).toBe("✓ Added");
+	});
+
+	test("Official and Deprecated still take precedence", () => {
+		expect(
+			badgeFor(
+				mp({
+					name: "claude-plugins-official",
+					source: {
+						source: "github",
+						repo: "anthropics/claude-plugins-official",
+					},
+				}),
+			),
+		).toBe("★ Official");
+
+		expect(
+			badgeFor(
+				mp({
+					name: "claude-code-plugins",
+					source: { source: "github", repo: "anthropics/claude-code" },
+				}),
+			),
+		).toBe("⚠ Deprecated");
+	});
+});