magus-cli 7.13.0 → 7.14.1

package/README.md

@@ -149,15 +149,18 @@ check. So does `magus install --check`.
 ## Company marketplaces
 
 A company marketplace is your team's own Claude Code plugin marketplace on GitHub.
-magus lists it first, and `magus market` manages it: create or connect one, add
-plugins and skills, copy a skill here with `market skill edit`, and send the edits
-back with `market publish` as the plugin's next version. Every change prints its
+magus lists it first, shown as "by" its company name, and `magus edit` (its screens) or
+the `magus market` commands manage it: create or connect one, add
+plugins and skills (a skill of your own, or a plugin folder of your own with
+`market plugin add`), copy a skill here with `market skill edit`, and send the edits
+back with `market publish` as the plugin's next version, one skill or every edited
+skill of a plugin at once. Every change prints its
 plan and asks first; `--yes=<planId>` applies exactly that plan in a script.
 Teammates get the marketplace and every new version through `magus update` with
 the project's profile.
 
 ```
-magus market             Open the company marketplace screens
+magus edit               Open the company marketplace screens
 magus market --help      Every market command, its flags and exit codes
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magus-cli",
-  "version": "7.13.0",
+  "version": "7.14.1",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -65,8 +65,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "magus-cli-darwin-arm64": "7.13.0",
-    "magus-cli-darwin-x64": "7.13.0",
-    "magus-cli-linux-x64": "7.13.0"
+    "magus-cli-darwin-arm64": "7.14.1",
+    "magus-cli-darwin-x64": "7.14.1",
+    "magus-cli-linux-x64": "7.14.1"
   }
 }

package/src/__tests__/market-r2-adapters.test.ts

@@ -0,0 +1,190 @@
+import { expect, test } from "bun:test";
+import type { MarketOverviewEntry } from "../services/market-ops.js";
+import { companySkillNames } from "../services/market-ops.js";
+import type { LocalItem, SkillStatusRow } from "../services/market-types.js";
+import {
+	editedSkills,
+	marketplaceItems,
+	marketplacesItems,
+	nextSelectable,
+	pluginsToPush,
+	selectable,
+} from "../ui/adapters/marketAdapter.js";
+
+function status(
+	skill: string,
+	state: SkillStatusRow["state"],
+	owner: string | null = "review-kit@acme",
+	from: SkillStatusRow["from"] = "project",
+): SkillStatusRow {
+	return { skill, state, owner, from, path: [from, skill].join("/") };
+}
+const overview = (): MarketOverviewEntry => ({
+	name: "acme",
+	repo: "acme/market",
+	company: "10xlabs",
+	scope: "user",
+	freshness: "fresh",
+	reason: "",
+	fix: "",
+	commit: "a".repeat(40),
+	plugins: [
+		{
+			name: "review-kit",
+			version: "0.3.1",
+			skills: ["review", "lint", "unchanged"],
+		},
+		{ name: "deploy-kit", version: "1.0.0", skills: ["deploy"] },
+	],
+});
+
+test("R3.1 TEST-7 editedSkills counts each owned edited skill once and excludes every other state", () => {
+	const rows: SkillStatusRow[] = [
+		status("review", "edited"),
+		status("review", "edited", "review-kit@acme", "user"),
+		status("lint", "edited"),
+		status("unknown-origin", "no-base"),
+		status("both-changed", "conflict"),
+		status("unchanged", "same"),
+		status("remote-newer", "plugin-newer"),
+		status("offline", "not-checked"),
+		status("ambiguous", "ambiguous", null),
+		status("unowned", "not-owned", null),
+		status("elsewhere", "edited", "review-kit@beta"),
+	];
+	const before = JSON.stringify(rows);
+
+	expect(editedSkills(rows, "review-kit@acme").sort()).toEqual([
+		"lint",
+		"review",
+	]);
+	expect(editedSkills(rows, "missing@acme")).toEqual([]);
+	expect(JSON.stringify(rows)).toBe(before);
+});
+
+test("R3.1 TEST-7 pluginsToPush counts plugins rather than skills and isolates the marketplace", () => {
+	const rows = [
+		status("review", "edited"),
+		status("lint", "edited"),
+		status("review", "edited", "review-kit@acme", "user"),
+		status("deploy", "edited", "deploy-kit@acme"),
+		status("blocked", "conflict", "blocked-kit@acme"),
+		status("foreign", "edited", "review-kit@beta"),
+	];
+
+	expect(pluginsToPush("acme", rows).sort()).toEqual([
+		"deploy-kit",
+		"review-kit",
+	]);
+	expect(pluginsToPush("missing", rows)).toEqual([]);
+});
+
+test("R3.1 TEST-8 marketplace and plugin rows carry edited plugin and skill counts without expansion", () => {
+	const entry = overview();
+	const states = [
+		status("review", "edited"),
+		status("lint", "edited"),
+		status("unchanged", "same"),
+		status("deploy", "no-base", "deploy-kit@acme"),
+	];
+	const before = JSON.stringify({ entry, states });
+
+	const first = marketplacesItems([entry], states);
+	const marketplace = first.find((item) => item.kind === "marketplace");
+	expect(marketplace?.kind).toBe("marketplace");
+	if (marketplace?.kind !== "marketplace")
+		throw new Error("Marketplace row missing");
+	expect(marketplace.toPush).toEqual(["review-kit"]);
+
+	const plugins = marketplaceItems(entry, {}, states, new Set());
+	expect(plugins.map((item) => item.kind)).toEqual(["plugin", "plugin"]);
+	const review = plugins.find(
+		(item) => item.kind === "plugin" && item.ref === "review-kit@acme",
+	);
+	const deploy = plugins.find(
+		(item) => item.kind === "plugin" && item.ref === "deploy-kit@acme",
+	);
+	expect(
+		review?.kind === "plugin" ? [...review.edited].sort() : undefined,
+	).toEqual(["lint", "review"]);
+	expect(deploy?.kind === "plugin" ? deploy.edited : undefined).toEqual([]);
+	expect(JSON.stringify({ entry, states })).toBe(before);
+});
+
+test("R4.1 TEST-9 local heading and items follow company marketplaces and add actions", () => {
+	const local: LocalItem[] = [
+		{
+			kind: "skill",
+			name: "authoring",
+			scope: "project",
+			path: "project/authoring",
+		},
+		{ kind: "plugin", name: "my-kit", scope: "user", path: "user/my-kit" },
+	];
+	const rows = marketplacesItems([overview()], [], local);
+
+	expect(rows.map((item) => item.kind)).toEqual([
+		"marketplace",
+		"create",
+		"connect",
+		"local-heading",
+		"local",
+		"local",
+	]);
+	expect(rows[3]).toEqual({ kind: "local-heading", count: 2 });
+	expect(rows.slice(4)).toEqual(local.map((item) => ({ kind: "local", item })));
+	expect(selectable(rows[3])).toBe(false);
+	expect(selectable(rows[4])).toBe(true);
+	expect(nextSelectable(rows, 2, 1)).toBe(4);
+	expect(nextSelectable(rows, 4, -1)).toBe(2);
+	expect(nextSelectable(rows, 5, 1)).toBe(5);
+});
+
+test("R4.1 R4.4 TEST-9 local-only rows remain selectable without any marketplaces; no empty heading", () => {
+	const item: LocalItem = {
+		kind: "skill",
+		name: "solo",
+		scope: "project",
+		path: "project/solo",
+	};
+	const rows = marketplacesItems([], [], [item]);
+
+	expect(rows).toEqual([
+		{ kind: "create" },
+		{ kind: "connect" },
+		{ kind: "local-heading", count: 1 },
+		{ kind: "local", item },
+	]);
+	expect(nextSelectable(rows, 1, 1)).toBe(3);
+	expect(marketplacesItems([], [], [])).toEqual([
+		{ kind: "create" },
+		{ kind: "connect" },
+	]);
+});
+
+test("R4.1 TEST-30 companySkillNames unions every plugin's skill names without duplicates", () => {
+	const marketplaces = [
+		{ plugins: overview().plugins },
+		{
+			plugins: [
+				{
+					name: "other-kit",
+					version: "1.0.0",
+					skills: ["review", "authoring"],
+				},
+			],
+		},
+		{ plugins: [] },
+	];
+	const before = JSON.stringify(marketplaces);
+
+	expect([...companySkillNames(marketplaces)].sort()).toEqual([
+		"authoring",
+		"deploy",
+		"lint",
+		"review",
+		"unchanged",
+	]);
+	expect([...companySkillNames([])]).toEqual([]);
+	expect(JSON.stringify(marketplaces)).toBe(before);
+});

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

@@ -0,0 +1,350 @@
+import { afterEach, expect, test } from "bun:test";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { LocalMarketplace } from "../services/local-marketplace.js";
+import type { Marketplace } from "../types/index.js";
+import {
+	MANIFEST,
+	MarketFixture,
+	readJson,
+	sourceModule,
+	writeJson,
+} from "./market-fixture.js";
+
+let f: MarketFixture | undefined;
+afterEach(() => {
+	f?.close();
+	f = undefined;
+});
+
+test.each([
+	{
+		label: "split flag",
+		flags: ["--company", "  10xlabs  "],
+		company: "10xlabs",
+	},
+	{ label: "equals flag", flags: ["--company=10xlabs"], company: "10xlabs" },
+	{
+		label: "64 Unicode code points",
+		flags: [`--company=${"🏢".repeat(64)}`],
+		company: "🏢".repeat(64),
+	},
+	{ label: "GitHub owner default", flags: [], company: "different-owner" },
+])(
+	"R1.1 R1.2 TEST-10 create writes owner.name from $label",
+	({ flags, company }) => {
+		f = new MarketFixture();
+
+		const result = f.market([
+			"create",
+			"different-owner/team-tools",
+			"--private",
+			"--name",
+			"team",
+			...flags,
+			"--yes",
+		]);
+
+		expect({ exit: result.code, outcome: result.result.outcome }).toEqual({
+			exit: 0,
+			outcome: "ok",
+		});
+		const bare = join(f.root, "remotes", "different-owner", "team-tools.git");
+		const manifest = JSON.parse(
+			f.git(f.root, "--git-dir", bare, "show", `HEAD:${MANIFEST}`),
+		);
+		expect(manifest.owner).toEqual({ name: company });
+		expect(
+			f.market(["list"]).result.marketplaces?.find((row) => row.name === "team")
+				?.company,
+		).toBe(company);
+		f.assertOwned();
+	},
+	60_000,
+);
+
+const invalidCompanies = [
+	"",
+	"  ",
+	"Acme\nLabs",
+	"Acme\rLabs",
+	"Acme\tLabs",
+	"Acme\u0000Labs",
+	"Acme\u007fLabs",
+	"Acme
Labs",
+	"Acme
Labs",
+	"x".repeat(65),
+	"🏢".repeat(65),
+];
+// NUL cannot be represented in an OS argv; its validation is covered by TEST-2.
+for (const command of ["create", "connect"] as const) {
+	test.each(invalidCompanies.filter((name) => !name.includes("\u0000")))(
+		`R1.3 TEST-11 ${command} rejects company %j before any GitHub work`,
+		(company) => {
+			f = new MarketFixture();
+			const before = f.snapshot();
+			const args =
+				command === "create"
+					? ["create", "acme/not-created", "--private"]
+					: ["connect", "acme/not-created"];
+
+			const result = f.market([...args, `--company=${company}`, "--yes"]);
+
+			expect(result.code).toBe(2);
+			expect(f.snapshot()).toEqual(before);
+			expect(
+				existsSync(join(f.root, "remotes", "acme", "not-created.git")),
+			).toBe(false);
+			expect(f.journal().filter((event) => event.tool === "gh")).toEqual([]);
+		},
+		30_000,
+	);
+	test(`R1.3 TEST-11 ${command} rejects a missing --company value without writes`, () => {
+		f = new MarketFixture();
+		const before = f.snapshot();
+		const args =
+			command === "create"
+				? ["create", "acme/not-created", "--private"]
+				: ["connect", "acme/not-created"];
+
+		const result = f.cli(["market", ...args, "--company"]);
+
+		expect(result.code).toBe(2);
+		expect(f.snapshot()).toEqual(before);
+		expect(f.journal()).toEqual([]);
+	}, 30_000);
+}
+
+test.each(["create", "connect"] as const)(
+	"R1.4 R4.5 TEST-12 %s plan displays the trimmed company and binds consent to it",
+	(command) => {
+		f = new MarketFixture();
+		const repo = command === "connect" ? f.seed({ empty: true }) : undefined;
+		const base =
+			command === "create"
+				? ["create", "acme/new-market", "--private", "--name", "acme"]
+				: ["connect", repo!.slug, "--name", "acme"];
+		const before = f.snapshot();
+		const plan = f.market([...base, "--company", "  10xlabs  "]);
+		const equivalent = f.market([...base, "--company=10xlabs"]);
+
+		expect(plan.code).toBe(3);
+		expect(plan.result.outcome).toBe("needs-consent");
+		expect(plan.result.plan).toContain(
+			'Company name: 10xlabs (magus shows the marketplace as "by 10xlabs")',
+		);
+		expect(typeof plan.result.planId).toBe("string");
+		expect(plan.result.planId?.length).toBeGreaterThan(0);
+		expect(equivalent.result.planId).toBe(plan.result.planId);
+		expect(f.snapshot()).toEqual(before);
+
+		const changed = f.market([
+			...base,
+			"--company",
+			"Other Labs",
+			`--yes=${plan.result.planId}`,
+		]);
+
+		expect({
+			exit: changed.code,
+			outcome: changed.result.outcome,
+			error: changed.result.error?.code,
+		}).toEqual({
+			exit: 3,
+			outcome: "needs-consent",
+			error: "plan-changed",
+		});
+		expect(changed.result.planId).not.toBe(plan.result.planId);
+		expect(changed.result.plan).toContain(
+			'Company name: Other Labs (magus shows the marketplace as "by Other Labs")',
+		);
+		const bare =
+			repo?.bare ?? join(f.root, "remotes", "acme", "new-market.git");
+		if (repo) {
+			expect(
+				f.git(f.root, "--git-dir", bare, "rev-list", "--all", "--count"),
+			).toBe("0");
+		} else {
+			expect(existsSync(bare)).toBe(false);
+		}
+		// A refused apply may sync its disposable clone; no repository or registration is changed.
+		expect(f.market(["list"]).result.marketplaces).toEqual([]);
+
+		const applied = f.market([
+			...base,
+			"--company=10xlabs",
+			`--yes=${plan.result.planId}`,
+		]);
+		expect(applied.code).toBe(0);
+		const manifest = JSON.parse(
+			f.git(f.root, "--git-dir", bare, "show", `HEAD:${MANIFEST}`),
+		);
+		expect(manifest.owner).toEqual({ name: "10xlabs" });
+		f.assertOwned();
+	},
+	60_000,
+);
+
+test.each([
+	{
+		empty: true,
+		companyFlag: ["--company", "  10xlabs  "],
+		expected: "10xlabs",
+	},
+	{ empty: false, companyFlag: ["--company=10xlabs"], expected: "10xlabs" },
+	{ empty: true, companyFlag: [], expected: "acme" },
+	{ empty: false, companyFlag: [], expected: "acme" },
+])(
+	"R1.1 R1.5 TEST-13 connect writes company only when making a manifest: %j",
+	({ empty, companyFlag, expected }) => {
+		f = new MarketFixture();
+		const repo = f.seed({ empty, noManifest: true });
+		const old = empty ? undefined : f.head(repo);
+
+		const result = f.market([
+			"connect",
+			repo.slug,
+			"--name",
+			"acme",
+			...companyFlag,
+			"--yes",
+		]);
+
+		expect(result.code).toBe(0);
+		expect(f.remoteJson(repo, MANIFEST).owner).toEqual({ name: expected });
+		if (old) {
+			expect(
+				f.git(
+					f.root,
+					"--git-dir",
+					repo.bare,
+					"rev-list",
+					"--count",
+					`${old}..HEAD`,
+				),
+			).toBe("1");
+			expect(f.remoteFile(repo, "README.md")).toBe(
+				"Existing repository documentation",
+			);
+		}
+		f.assertOwned();
+	},
+	60_000,
+);
+
+test.each([true, false])(
+	"R1.5 TEST-14 existing marketplace refuses --company, marker=%s",
+	(marker) => {
+		f = new MarketFixture();
+		const repo = f.seed({ marker });
+		const manifest = readJson(join(repo.author, MANIFEST));
+		manifest.owner = { name: "Manifest Company" };
+		writeJson(join(repo.author, MANIFEST), manifest);
+		f.push(repo);
+		const before = f.snapshot();
+		const head = f.head(repo);
+
+		const refused = f.market([
+			"connect",
+			repo.slug,
+			"--company",
+			"Override",
+			"--yes",
+		]);
+
+		expect(refused.code).toBe(2);
+		expect(f.head(repo)).toBe(head);
+		expect(f.remoteJson(repo, MANIFEST).owner).toEqual({
+			name: "Manifest Company",
+		});
+		expect(f.snapshot()).toEqual(before);
+
+		const connected = f.market(["connect", repo.slug, "--yes"]);
+		expect(connected.code).toBe(0);
+		expect(f.remoteJson(repo, MANIFEST).owner).toEqual({
+			name: "Manifest Company",
+		});
+		expect(f.market(["list"]).result.marketplaces?.[0]?.company).toBe(
+			"Manifest Company",
+		);
+		f.assertOwned();
+	},
+	60_000,
+);
+
+test.each([
+	{ owner: { name: "  10xlabs  " }, expected: "10xlabs" },
+	{ owner: { name: "   " }, expected: undefined },
+	{ owner: {}, expected: undefined },
+])(
+	"R1.6 TEST-6 scanner and catalog carry trimmed ownerName or omit the key: %j",
+	({ owner, expected }) => {
+		f = new MarketFixture(true);
+		const repo = f.seed();
+		const manifest = readJson(join(repo.author, MANIFEST));
+		manifest.owner = owner;
+		writeJson(join(repo.author, MANIFEST), manifest);
+		f.push(repo);
+		f.register(repo);
+		const before = f.snapshot();
+
+		const data = f.value<{
+			local: LocalMarketplace;
+			catalog: Marketplace;
+			localHasName: boolean;
+			catalogHasName: boolean;
+		}>(
+			`const {scanLocalMarketplaces}=await import(${JSON.stringify(sourceModule("services/local-marketplace.js"))});const {getAllMarketplaces}=await import(${JSON.stringify(sourceModule("data/marketplaces.js"))});const locals=await scanLocalMarketplaces(); const local=locals.get('acme'); const catalog=getAllMarketplaces(locals).find(m=>m.name==='acme');console.log(JSON.stringify({local,catalog,localHasName:Object.hasOwn(local,'ownerName'),catalogHasName:Object.hasOwn(catalog,'ownerName')}));`,
+		);
+
+		expect(data.local.ownerName).toBe(expected);
+		expect(data.catalog.ownerName).toBe(expected);
+		expect(data.localHasName).toBe(expected !== undefined);
+		expect(data.catalogHasName).toBe(expected !== undefined);
+		expect(f.snapshot()).toEqual(before);
+	},
+	30_000,
+);
+
+test.each([
+	{ owner: { name: "  10xlabs  " }, company: "10xlabs" },
+	{ owner: { name: "" }, company: "acme" },
+])(
+	"R1.7 TEST-15 list JSON and text show company without changing state: %j",
+	({ owner, company }) => {
+		f = new MarketFixture(true);
+		const repo = f.seed();
+		const manifest = readJson(join(repo.author, MANIFEST));
+		manifest.owner = owner;
+		writeJson(join(repo.author, MANIFEST), manifest);
+		f.push(repo);
+		f.register(repo);
+		const before = f.snapshot();
+		const head = f.head(repo);
+
+		const json = f.market(["list"]);
+		const text = f.cli(["market", "list"]);
+
+		expect(json.code).toBe(0);
+		expect(
+			json.result.marketplaces?.map(
+				({ name, repo: source, company: value, scope }) => ({
+					name,
+					repo: source,
+					company: value,
+					scope,
+				}),
+			),
+		).toEqual([{ name: "acme", repo: "acme/market", company, scope: "user" }]);
+		expect(text.code).toBe(0);
+		const line = text.out
+			.split("\n")
+			.find((line) => line.includes(`by ${company}`));
+		expect(line).toBeDefined();
+		expect(line).toContain("acme/market");
+		expect(line).toContain("USER");
+		expect(f.snapshot()).toEqual(before);
+		expect(f.head(repo)).toBe(head);
+	},
+	30_000,
+);