magus-cli 7.12.2 → 7.14.0

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

@@ -0,0 +1,263 @@
+import { afterEach, expect, test } from "bun:test";
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import {
+	EDITED,
+	ID,
+	MANIFEST,
+	MarketFixture,
+	PLUGIN_MANIFEST,
+	REMOTE_EDIT,
+	SKILL,
+	SKILL_REL,
+	expectPublished,
+	readJson,
+	sourceModule,
+	write,
+	writeJson,
+} from "./market-fixture.js";
+
+let f: MarketFixture | undefined;
+afterEach(() => {
+	f?.close();
+	f = undefined;
+});
+function baseAt(folder: string) {
+	return f!.value(
+		`const b=await import(${JSON.stringify(sourceModule("services/market-bases.js"))}); console.log(JSON.stringify(b.readBase(${JSON.stringify(folder)})));`,
+	);
+}
+
+test.each([false, true])(
+	"TEST-23 REQ-10 REQ-29 two edit/publish cycles need no force; keep-local=%s",
+	async (keep) => {
+		f = new MarketFixture();
+		const repo = f.seed();
+		f.register(repo);
+		f.install();
+		const initial = f.head(repo);
+		f.edit();
+		expect(f.head(repo)).toBe(initial);
+		expect(readFileSync(join(f.folder(), "SKILL.md"), "utf8")).toBe(SKILL);
+		const firstToken = readFileSync(join(f.folder(), ".magus-origin"), "utf8");
+		write(join(f.folder(), "SKILL.md"), EDITED);
+
+		const first = f.market([
+			"publish",
+			"review",
+			"--plugin",
+			ID,
+			"--yes",
+			...(keep ? ["--keep-local"] : []),
+		]);
+
+		expect(first.code).toBe(0);
+		expectPublished(f, repo);
+		expect(f.version()).toBe("0.3.2");
+		expect(first.result.localCopy?.action).toBe(keep ? "kept" : "removed");
+		if (keep) {
+			expect(readFileSync(join(f.folder(), ".magus-origin"), "utf8")).not.toBe(
+				firstToken,
+			);
+			expect(baseAt(f.folder())).not.toBeNull();
+		} else {
+			expect(existsSync(f.folder())).toBe(false);
+			expect(baseAt(f.folder())).toBeNull();
+			f.edit();
+		}
+		const next = `${EDITED}\nReview retries too.\n`;
+		write(join(f.folder(), "SKILL.md"), next);
+
+		const second = f.market([
+			"publish",
+			"review",
+			"--plugin",
+			ID,
+			"--yes",
+			...(keep ? ["--keep-local"] : []),
+		]);
+
+		expect(second.code).toBe(0);
+		expectPublished(f, repo, "0.3.3", next);
+		expect(f.version()).toBe("0.3.3");
+		expect(second.result.localCopy?.action).toBe(keep ? "kept" : "removed");
+		f.assertOwned();
+	},
+	60_000,
+);
+
+test("TEST-24 REQ-11 identical local content is unchanged even without a base", () => {
+	f = new MarketFixture();
+	const repo = f.seed();
+	f.register(repo);
+	write(join(f.folder(), "SKILL.md"), SKILL);
+	const before = f.snapshot();
+	const head = f.head(repo);
+
+	const r = f.market(["publish", "review", "--plugin", ID]);
+
+	expect({ code: r.code, outcome: r.result.outcome }).toEqual({
+		code: 0,
+		outcome: "unchanged",
+	});
+	expect(f.head(repo)).toBe(head);
+	expect(f.snapshot()).toEqual(before);
+}, 30_000);
+
+test("TEST-24 REQ-11 an unchanged old copy reports plugin-newer and writes nothing", () => {
+	f = new MarketFixture();
+	const repo = f.seed();
+	f.register(repo);
+	f.install();
+	f.edit();
+	write(join(repo.author, SKILL_REL), REMOTE_EDIT);
+	const plugin = readJson(join(repo.author, PLUGIN_MANIFEST));
+	plugin.version = "0.3.2";
+	writeJson(join(repo.author, PLUGIN_MANIFEST), plugin);
+	f.push(repo);
+	f.ok(["fetch"]);
+	const before = f.snapshot();
+	const head = f.head(repo);
+
+	const r = f.market(["publish", "review", "--plugin", ID]);
+
+	expect({ code: r.code, outcome: r.result.outcome }).toEqual({
+		code: 0,
+		outcome: "plugin-newer",
+	});
+	expect(f.snapshot()).toEqual(before);
+	expect(f.head(repo)).toBe(head);
+}, 30_000);
+
+test.each(["no-base", "conflict"] as const)(
+	"TEST-24 REQ-11 %s refuses first; explicit force has its own consent and replacement",
+	async (state) => {
+		f = new MarketFixture();
+		const repo = state === "conflict" ? await f.prepared() : f.seed();
+		if (state === "no-base") {
+			f.register(repo);
+			f.install();
+			write(join(f.folder(), "SKILL.md"), EDITED);
+		} else {
+			write(join(repo.author, SKILL_REL), REMOTE_EDIT);
+			const manifest = readJson(join(repo.author, MANIFEST));
+			manifest.plugins[0].version = "0.3.2";
+			writeJson(join(repo.author, MANIFEST), manifest);
+			writeJson(join(repo.author, PLUGIN_MANIFEST), {
+				name: "review-kit",
+				version: "0.3.2",
+			});
+			f.push(repo);
+			f.ok(["fetch"]);
+		}
+		const before = f.snapshot();
+		const head = f.head(repo);
+
+		const refused = f.market(["publish", "review", "--plugin", ID]);
+
+		expect(refused.code).toBe(1);
+		expect(refused.result.error?.code).toBe(state);
+		expect(
+			refused.result.files?.some((file) => file.path.endsWith("SKILL.md")),
+		).toBe(true);
+		expect(refused.result.plan?.length).toBeGreaterThan(0);
+		expect(f.head(repo)).toBe(head);
+		expect(f.snapshot()).toEqual(before);
+
+		const consent = f.market(["publish", "review", "--plugin", ID, "--force"]);
+		expect(consent.code).toBe(3);
+		expect(typeof consent.result.planId).toBe("string");
+		expect(f.head(repo)).toBe(head);
+		const applied = f.market([
+			"publish",
+			"review",
+			"--plugin",
+			ID,
+			"--force",
+			`--yes=${consent.result.planId}`,
+		]);
+		expect(applied.code).toBe(0);
+		expectPublished(f, repo, state === "conflict" ? "0.3.3" : "0.3.2");
+		f.assertOwned();
+	},
+	60_000,
+);
+
+test.each([
+	{ keep: false, restoreToken: false },
+	{ keep: false, restoreToken: true },
+	{ keep: true, restoreToken: true },
+])(
+	"TEST-25 REQ-29 old copy restoration does not reuse path provenance: %j",
+	async ({ keep, restoreToken }) => {
+		f = new MarketFixture();
+		const repo = await f.prepared();
+		const oldToken = readFileSync(join(f.folder(), ".magus-origin"), "utf8");
+		f.ok([
+			"publish",
+			"review",
+			"--plugin",
+			ID,
+			"--yes",
+			...(keep ? ["--keep-local"] : []),
+		]);
+		rmSync(f.folder(), { recursive: true, force: true });
+		write(
+			join(f.folder(), "SKILL.md"),
+			`${SKILL}\nAn edit restored from before the push.\n`,
+		);
+		if (restoreToken) write(join(f.folder(), ".magus-origin"), oldToken);
+		const head = f.head(repo);
+		const before = f.snapshot();
+
+		const r = f.market(["publish", "review", "--plugin", ID, "--yes"]);
+
+		expect(r.code).toBe(1);
+		expect(r.result.error?.code).toBe("no-base");
+		expect(f.head(repo)).toBe(head);
+		expect(f.snapshot()).toEqual(before);
+		f.assertOwned();
+	},
+	60_000,
+);
+
+test.each([false, true])(
+	"TEST-26 REQ-12 unversioned plugin bumps to 0.0.1; no plugin manifest=%s",
+	(noPluginJson) => {
+		f = new MarketFixture();
+		const repo = f.seed({
+			entryVersion: null,
+			pluginVersion: null,
+			noPluginJson,
+		});
+		f.register(repo);
+		f.install();
+		f.edit();
+		write(join(f.folder(), "SKILL.md"), EDITED);
+
+		const r = f.market(["publish", "review", "--plugin", ID, "--yes"]);
+
+		expect(r.code).toBe(0);
+		expect(f.remoteJson(repo, MANIFEST).plugins[0].version).toBe("0.0.1");
+		if (noPluginJson)
+			expect(f.remotePaths(repo)).not.toContain(PLUGIN_MANIFEST);
+		else expect(f.remoteJson(repo, PLUGIN_MANIFEST).version).toBe("0.0.1");
+		f.assertOwned();
+	},
+	60_000,
+);
+
+test("TEST-26 REQ-12 a divergent catalog entry cannot override plugin.json's patch base", () => {
+	f = new MarketFixture();
+	const repo = f.seed({ entryVersion: "9.9.9", pluginVersion: "0.3.1" });
+	f.register(repo);
+	f.install();
+	f.edit();
+	write(join(f.folder(), "SKILL.md"), EDITED);
+
+	const r = f.market(["publish", "review", "--plugin", ID, "--yes"]);
+
+	expect(r.code).toBe(0);
+	expectPublished(f, repo, "0.3.2");
+	f.assertOwned();
+}, 60_000);

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);
+});