magus-cli 7.13.0 → 7.14.0

package/src/services/market-ops-publish.ts

@@ -15,6 +15,8 @@
  * the in-domain part of the plugin's skill, commits exactly the planned paths,
  * delivers, moves this machine's installs through `claude plugin` commands,
  * and removes the local copy only when it holds exactly the committed files.
+ * A plugin-wide publish does the same for every skill of one plugin edited
+ * here, as one commit and one version.
  */
 
 import fs from "node:fs";
@@ -56,6 +58,7 @@ import {
 	installLines,
 	installStep,
 	pluginViewAt,
+	readPlugin,
 	versionFiles,
 	versionLine,
 } from "./market-ops-content.js";
@@ -73,6 +76,7 @@ import {
 	planError,
 } from "./market-ops.js";
 import {
+	type InstalledAt,
 	type SourceSets,
 	copyMismatch,
 	installReaches,
@@ -498,6 +502,41 @@ function sourceFolder(cwd: string, args: PublishArgs): string {
 const FORCE_FIX =
 	"to replace the plugin's version with this copy, run again with --force";
 
+/**
+ * Why a publish keeps the local copy at `folder`, or null when it will be
+ * removed once the push lands and every install moves. Read-only.
+ */
+async function keepReasonFor(input: {
+	folder: string;
+	skill: string;
+	from: "project" | "global";
+	keepLocal: boolean;
+	plugin: string;
+	pluginId: string;
+	installs: readonly InstalledAt[];
+	committed: readonly SkillFile[];
+	cwd: string;
+}): Promise<{ reason: string | null; managed: boolean }> {
+	const managed =
+		input.from === "project" && (await profileManaged(input.cwd, input.skill));
+	const reason = input.keepLocal
+		? "--keep-local"
+		: managed
+			? PROFILE_KEEPS
+			: !installReaches(
+						input.from === "global" ? "user" : "project",
+						input.installs.map((i) => i.scope),
+					)
+				? `${input.plugin} is not installed where this copy loads`
+				: ((await offHereReason(input.plugin, input.pluginId, input.cwd)) ??
+					(await copyMismatch(
+						input.folder,
+						input.committed,
+						"will not be published",
+					)));
+	return { reason, managed };
+}
+
 export async function planPublish(
 	args: PublishArgs,
 	cwd: string,
@@ -584,23 +623,21 @@ export async function planPublish(
 		const target = await deliveryTarget(m.source, m.name);
 		const installs = await installedScopes(pluginId, cwd);
 		const copyScope = args.from === "global" ? "user" : "project";
-		const managed =
-			args.from === "project" && (await profileManaged(cwd, args.skill));
 		const committed: SkillFile[] = [
 			...cmp.sets.published,
 			...cmp.theirsOut.map((f) => ({ path: f.path, oid: f.oid })),
 		];
-		const keepReason = args.keepLocal
-			? "--keep-local"
-			: managed
-				? PROFILE_KEEPS
-				: !installReaches(
-							copyScope,
-							installs.map((i) => i.scope),
-						)
-					? `${plugin} is not installed where this copy loads`
-					: ((await offHereReason(plugin, pluginId, cwd)) ??
-						(await copyMismatch(folder, committed, "will not be published")));
+		const { reason: keepReason, managed } = await keepReasonFor({
+			folder,
+			skill: args.skill,
+			from: args.from,
+			keepLocal: args.keepLocal,
+			plugin,
+			pluginId,
+			installs,
+			committed,
+			cwd,
+		});
 		const predicted: LocalCopy = keepReason
 			? {
 					scope: copyScope,
@@ -624,7 +661,7 @@ export async function planPublish(
 				message: `${plugin}: update ${args.skill} skill (${to})`,
 				slug: `${plugin}-${to}`,
 				prBody: `Updates the skill \`${args.skill}\` in \`${plugin}\` and bumps it to ${to}.\n\nChanged: ${changeList(cmp.changes)}.`,
-				verify: { dir: skillDir, files: committed },
+				verify: [{ dir: skillDir, files: committed }],
 				state,
 			}),
 			installStep(view, installs, to, state),
@@ -730,6 +767,316 @@ export async function planPublish(
 	}
 }
 
+// ─── publish a plugin ────────────────────────────────────────────────────────
+
+export interface PluginPublishArgs {
+	/** `plugin@marketplace`; the marketplace may be left out when there is one. */
+	plugin: string;
+	keepLocal: boolean;
+}
+
+const STATE_WORDS: Record<"no-base" | "conflict", string> = {
+	"no-base": "origin unknown",
+	conflict: "changed here and on GitHub",
+};
+
+/** One local copy a plugin-wide publish sends. */
+interface PublishedCopy {
+	skill: string;
+	from: "project" | "global";
+	folder: string;
+	skillDir: string;
+	cmp: LocalCompare;
+	committed: SkillFile[];
+	keepReason: string | null;
+	managed: boolean;
+	predicted: LocalCopy;
+}
+
+/**
+ * `market publish --plugin <p@m>` with no skill: every skill of the plugin
+ * whose local copy here has edits the plugin has not seen (`edited` in
+ * `market status`), sent as one commit and one patch version. A copy whose
+ * origin is unknown, or that changed on both sides, is listed and left out:
+ * it goes on its own, by name, with --force. Read-only.
+ */
+export async function planPluginPublish(
+	args: PluginPublishArgs,
+	cwd: string,
+): Promise<PlanAnswer> {
+	const command: MarketCommand = "market publish";
+	try {
+		const view = await readPlugin(args.plugin);
+		const { m, snap, plugin } = view;
+		const pluginId = `${plugin}@${m.name}`;
+		const prefix = joinRel(view.dir, "skills", "");
+		const skills = new Set<string>();
+		for (const p of snap.entries.keys()) {
+			if (!p.startsWith(`${prefix}/`)) continue;
+			const rest = p.slice(prefix.length + 1).split("/");
+			if (rest.length === 2 && rest[1] === "SKILL.md" && rest[0]) {
+				skills.add(rest[0]);
+			}
+		}
+		const folders = localSkillFolders(cwd).filter((f) => skills.has(f.skill));
+		const edited: Array<{ f: LocalFolder; cmp: LocalCompare }> = [];
+		const leftOut: Array<{
+			skill: string;
+			from: "project" | "global";
+			state: "no-base" | "conflict";
+		}> = [];
+		for (const f of folders) {
+			const cmp = await compareLocal(f.path, view, f.skill);
+			if (cmp.state === "fast") edited.push({ f, cmp });
+			else if (cmp.state === "no-base" || cmp.state === "conflict") {
+				leftOut.push({
+					skill: f.skill,
+					from: f.from === "user" ? "global" : "project",
+					state: cmp.state,
+				});
+			}
+		}
+		const twice = edited.find(
+			(e, i) => edited.findIndex((o) => o.f.skill === e.f.skill) !== i,
+		);
+		if (twice) {
+			throw new MarketError(
+				"ambiguous",
+				`Both this project and your USER skills have edits to ${twice.f.skill}`,
+				`publish one at a time: \`magus market publish ${twice.f.skill} --plugin ${pluginId} --from project\` (or --from global)`,
+			);
+		}
+		const leftOutLines = leftOut.map(
+			(l) =>
+				`Not included: ${l.skill} (${STATE_WORDS[l.state]}) — publish it on its own with \`magus market publish ${l.skill} --plugin ${pluginId}${l.from === "global" ? " --from global" : ""} --force\``,
+		);
+		const base = { marketplace: m.name, plugin };
+		if (edited.length === 0) {
+			if (leftOut.length > 0) {
+				const message = `No skill of ${pluginId} has edits here that it can publish as they are — nothing changed`;
+				return {
+					kind: "result",
+					result: {
+						command,
+						outcome: "failed",
+						message,
+						...base,
+						plan: leftOutLines,
+						steps: [],
+						error: {
+							code: leftOut[0]?.state ?? "no-base",
+							message,
+							fix: "publish each one on its own with --force, which asks before it replaces the plugin's version",
+						},
+					},
+				};
+			}
+			return {
+				kind: "result",
+				result: {
+					command,
+					outcome: "unchanged",
+					message: `No skill of ${pluginId} has edits here to publish`,
+					...base,
+					steps: [],
+				},
+			};
+		}
+
+		const { from, to } = bumpFrom(view);
+		const target = await deliveryTarget(m.source, m.name);
+		const installs = await installedScopes(pluginId, cwd);
+		const copies: PublishedCopy[] = [];
+		for (const { f, cmp } of edited) {
+			const fromWord = f.from === "user" ? "global" : "project";
+			const committed: SkillFile[] = [
+				...cmp.sets.published,
+				...cmp.theirsOut.map((t) => ({ path: t.path, oid: t.oid })),
+			];
+			const { reason, managed } = await keepReasonFor({
+				folder: f.path,
+				skill: f.skill,
+				from: fromWord,
+				keepLocal: args.keepLocal,
+				plugin,
+				pluginId,
+				installs,
+				committed,
+				cwd,
+			});
+			const scope = f.from;
+			copies.push({
+				skill: f.skill,
+				from: fromWord,
+				folder: f.path,
+				skillDir: joinRel(view.dir, "skills", f.skill),
+				cmp,
+				committed,
+				keepReason: reason,
+				managed,
+				predicted: reason
+					? { scope, name: f.skill, action: "kept", reason }
+					: { scope, name: f.skill, action: "removed" },
+			});
+		}
+		const files = [
+			...copies.flatMap((c) =>
+				c.cmp.changes.map((ch) => ({
+					path: joinRel(c.skillDir, ch.path),
+					change: ch.change,
+				})),
+			),
+			...versionFiles(view),
+		];
+		const names = copies.map((c) => c.skill);
+		const state: ChangeSpec["state"] & { moved?: boolean } = {};
+		const steps: MarketStep[] = [
+			...copies.map((c) =>
+				replaceStep(
+					c.folder,
+					c.skillDir,
+					plugin,
+					c.skill,
+					c.cmp,
+					c.committed,
+					`replace:${c.skill}`,
+				),
+			),
+			bumpStep(view, to),
+			...changeSteps({
+				label: m.name,
+				source: m.source,
+				branch: snap.branch,
+				target,
+				stage: [
+					...copies.map((c) => c.skillDir),
+					...versionFiles(view).map((f) => f.path),
+				],
+				files,
+				message: `${plugin}: update ${names.join(", ")} (${to})`,
+				slug: `${plugin}-${to}`,
+				prBody: `Updates ${plural(names.length, "skill")} in \`${plugin}\` and bumps it to ${to}.\n\n${copies.map((c) => `- \`${c.skill}\`: ${changeList(c.cmp.changes)}`).join("\n")}`,
+				verify: copies.map((c) => ({ dir: c.skillDir, files: c.committed })),
+				state,
+			}).map((s) =>
+				s.id === "deliver"
+					? {
+							...s,
+							// A pull request stops the apply here: nothing is installed,
+							// so every local copy stays until it is merged.
+							run: async (ctx: Parameters<MarketStep["run"]>[0]) => {
+								const out = await s.run(ctx);
+								if (!out?.stop) return out;
+								const kept: LocalCopy[] = copies.map((c) => ({
+									scope: c.predicted.scope,
+									name: c.skill,
+									action: "kept",
+									reason:
+										"the change went out as a pull request; the plugin's version replaces this copy once it is merged",
+								}));
+								return {
+									...out,
+									patch: { ...out.patch, localCopies: kept },
+								};
+							},
+						}
+					: s,
+			),
+			installStep(view, installs, to, state),
+			{
+				id: "local-copy",
+				label: "settled the local copies",
+				outside: true,
+				async run() {
+					const settled: LocalCopy[] = [];
+					for (const c of copies) {
+						const copy = await settleLocalCopy({
+							folder: c.folder,
+							committed: c.committed,
+							copy: { scope: c.predicted.scope, name: c.skill },
+							keepReason: c.keepReason,
+							moved: state.moved === true,
+							plugin,
+							pluginId,
+							cwd,
+						});
+						if (
+							copy.action === "kept" &&
+							!copy.partial &&
+							!c.managed &&
+							state.commit
+						) {
+							recordBase(c.folder, {
+								marketplace: m.name,
+								repo: m.source,
+								plugin,
+								skill: c.skill,
+								commit: state.commit,
+								tree: c.cmp.sets.hash,
+							});
+						}
+						settled.push(copy);
+					}
+					return { patch: { localCopies: settled } };
+				},
+			},
+		];
+		const lines = [
+			`Publishes ${plural(copies.length, "edited skill")} to ${pluginId} as one new version: ${names.join(", ")}`,
+			versionLine(plugin, from, to),
+			...copies.flatMap((c) => [
+				`${c.skill} (${whoseCopy(c.from)}): ${plural(c.cmp.changes.length, "file")} — ${changeList(c.cmp.changes)}`,
+				...(c.cmp.sets.notPublished.length > 0
+					? [
+							`${c.skill}, not published: ${c.cmp.sets.notPublished.map((n) => `${n.path} (${n.reason})`).join(", ")}`,
+						]
+					: []),
+			]),
+			...leftOutLines,
+			targetLine(target, snap.branch),
+			"A pull request moves no install and keeps the local copies",
+			...installLines(plugin, installs, to),
+			...copies.map((c) =>
+				c.predicted.action === "removed"
+					? `Afterwards removes ${whoseCopy(c.from)} of ${c.skill}`
+					: `Keeps ${whoseCopy(c.from)} of ${c.skill}: ${c.predicted.reason}`,
+			),
+		];
+		const plan: MarketPlan = {
+			command,
+			lines,
+			planId: computePlanId({
+				op: "publish-plugin",
+				plugin: pluginId,
+				keepLocal: args.keepLocal,
+				branch: snap.branch,
+				commit: snap.commit,
+				skills: copies.map((c) => ({
+					skill: c.skill,
+					from: c.from,
+					base: c.cmp.baseCommit,
+					hash: c.cmp.sets.hash,
+					notPublished: c.cmp.sets.notPublished,
+					localCopy: c.predicted,
+				})),
+				leftOut,
+				target,
+				version: { from, to },
+				installs,
+			}),
+			summary: { ...base, version: { from, to }, files, target },
+			steps,
+			sync: { name: m.name, url: cloneUrl(m.source) },
+			lock: m.name,
+			replan: () => planPluginPublish({ ...args, plugin: pluginId }, cwd),
+			doneMessage: `${names.join(", ")} ${names.length === 1 ? "is" : "are"} published in ${pluginId} ${to}. Takes effect in new sessions, or after /reload-plugins.`,
+		};
+		return { kind: "plan", plan };
+	} catch (error) {
+		return planError(command, error);
+	}
+}
+
 function capital(text: string): string {
 	return text.charAt(0).toUpperCase() + text.slice(1);
 }
@@ -760,9 +1107,10 @@ function replaceStep(
 	skill: string,
 	cmp: LocalCompare,
 	committed: readonly SkillFile[],
+	id = "replace",
 ): MarketStep {
 	return {
-		id: "replace",
+		id,
 		label: `copied ${skill} into ${plugin}`,
 		outside: false,
 		async run(ctx) {

package/src/services/market-ops-repo.ts

@@ -71,10 +71,53 @@ import { fastForwardCloneIfPresent } from "./marketplace-refresh.js";
 const MANIFEST = ".claude-plugin/marketplace.json";
 const README = "README.md";
 
-function newManifest(name: string, owner: string, description?: string) {
+/** The longest company name a marketplace may carry, in characters. */
+export const COMPANY_NAME_MAX = 64;
+
+/**
+ * Check a company name for `owner.name`: one line, not blank, at most
+ * {@link COMPANY_NAME_MAX} characters once trimmed. Returns it trimmed; a
+ * bad one is a usage error (exit 2).
+ */
+export function checkCompanyName(value: string): string {
+	const company = value.trim();
+	if (company === "") {
+		throw new MarketError(
+			"invalid-name",
+			"The company name is empty",
+			"pass --company <name>",
+			2,
+		);
+	}
+	// Every control character (C0, DEL, C1 — NEL included) and the Unicode
+	// line and paragraph separators.
+	if (/[\p{Cc}\u2028\u2029]/u.test(company)) {
+		throw new MarketError(
+			"invalid-name",
+			"The company name must be a single line",
+			"pass --company <name>",
+			2,
+		);
+	}
+	if ([...company].length > COMPANY_NAME_MAX) {
+		throw new MarketError(
+			"invalid-name",
+			`The company name is longer than ${COMPANY_NAME_MAX} characters`,
+			"pass a shorter --company <name>",
+			2,
+		);
+	}
+	return company;
+}
+
+function companyLine(company: string): string {
+	return `Company name: ${company} (magus shows the marketplace as "by ${company}")`;
+}
+
+function newManifest(name: string, company: string, description?: string) {
 	return withMarker({
 		name,
-		owner: { name: owner },
+		owner: { name: company },
 		metadata: {
 			description: description ?? `${name} company plugin marketplace`,
 		},
@@ -171,7 +214,7 @@ function trustStep(
 function initSteps(
 	name: string,
 	source: string,
-	owner: string,
+	company: string,
 	branch: string,
 	description: string | undefined,
 ): MarketStep[] {
@@ -186,7 +229,7 @@ function initSteps(
 				fs.rmSync(dir, { recursive: true, force: true });
 				const r = await initWithRemote(dir, cloneUrl(source), branch);
 				if (!r.ok) throw gitError(r, name);
-				writeJson(dir, MANIFEST, newManifest(name, owner, description), name);
+				writeJson(dir, MANIFEST, newManifest(name, company, description), name);
 				writeFileUnder(dir, README, readme(name, source), linkRefusal(name));
 				return undefined;
 			},
@@ -290,6 +333,11 @@ export interface CreateArgs {
 	visibility: "private" | "public";
 	name?: string;
 	description?: string;
+	/**
+	 * The company name written as the manifest's `owner.name`; the GitHub
+	 * owner of `repo` when absent.
+	 */
+	company?: string;
 }
 
 /**
@@ -324,6 +372,7 @@ export async function planCreate(args: CreateArgs): Promise<PlanAnswer> {
 			);
 		}
 		const [owner = "", repoName = ""] = args.repo.split("/");
+		const company = checkCompanyName(args.company ?? owner);
 		const name = args.name ?? repoName.toLowerCase();
 		if (!validPackageName(name)) {
 			throw new MarketError(
@@ -382,7 +431,7 @@ export async function planCreate(args: CreateArgs): Promise<PlanAnswer> {
 				},
 			},
 			...[
-				...initSteps(name, source, owner, branch, args.description),
+				...initSteps(name, source, company, branch, args.description),
 				registerStep(name, source),
 				trustStep(name, source, "create"),
 			].map((s) => afterCreate(s, args.repo)),
@@ -392,9 +441,16 @@ export async function planCreate(args: CreateArgs): Promise<PlanAnswer> {
 			lines: [
 				`Creates the ${args.visibility} GitHub repository ${args.repo}`,
 				`Writes a company marketplace named ${name} into it and pushes it to ${branch}`,
+				companyLine(company),
 				`Adds ${name} to this machine at USER scope and marks it as a company marketplace here`,
 			],
-			planId: computePlanId({ op: "create", ...args, name, branch }),
+			planId: computePlanId({
+				op: "create",
+				...args,
+				name,
+				company,
+				branch,
+			}),
 			summary: { marketplace: name },
 			steps: steps.map((s) =>
 				s.id === "init" ||
@@ -427,6 +483,12 @@ function teammateNote(name: string): string {
 export interface ConnectArgs {
 	source: string;
 	name?: string;
+	/**
+	 * The company name for a manifest connect writes (`init` and `add` only);
+	 * the GitHub owner of the source when absent. A repository that already
+	 * holds a marketplace keeps the `owner.name` its manifest gives.
+	 */
+	company?: string;
 }
 
 async function readRemoteManifest(
@@ -470,6 +532,8 @@ export async function planConnect(
 ): Promise<PlanAnswer> {
 	const command: MarketCommand = "market connect";
 	try {
+		// The value's form is checked before any GitHub or git work.
+		if (args.company !== undefined) checkCompanyName(args.company);
 		const source = normaliseSource(args.source, cwd);
 		const github = isGithubSource(source);
 		const url = cloneUrl(source);
@@ -495,6 +559,14 @@ export async function planConnect(
 				2,
 			);
 		}
+		if (args.company !== undefined && !fresh) {
+			throw new MarketError(
+				"other",
+				"--company applies only when connect sets up a repository with no marketplace in it; this one keeps the company name its manifest gives",
+				"run it again without --company",
+				2,
+			);
+		}
 		const base = path
 			.basename(source)
 			.replace(/\.git$/, "")
@@ -549,18 +621,25 @@ export async function planConnect(
 				: source;
 		const steps: MarketStep[] = [];
 		const lines: string[] = [];
-		const owner = github ? (source.split("/")[0] ?? name) : name;
+		const company = fresh
+			? checkCompanyName(
+					args.company ?? (github ? (source.split("/")[0] ?? name) : name),
+				)
+			: null;
 		const delivered: ChangeSpec["state"] = {};
 		if (action === "init") {
 			lines.push(
 				`${source} holds no marketplace yet: writes a company marketplace named ${name} into it and pushes it to ${branch}`,
+				companyLine(company as string),
 			);
 			steps.push(
-				...initSteps(name, source, owner, branch, undefined).map((s) => ({
-					...s,
-					run: (ctx: Parameters<MarketStep["run"]>[0]) =>
-						s.run({ ...ctx, clone: workingClonePath(name) }),
-				})),
+				...initSteps(name, source, company as string, branch, undefined).map(
+					(s) => ({
+						...s,
+						run: (ctx: Parameters<MarketStep["run"]>[0]) =>
+							s.run({ ...ctx, clone: workingClonePath(name) }),
+					}),
+				),
 			);
 		} else if (action === "mark" || action === "add") {
 			const target = await deliveryTarget(source, name);
@@ -568,6 +647,7 @@ export async function planConnect(
 				action === "mark"
 					? `${name} is a marketplace without the company marker: commits the marker to its manifest`
 					: `${source} holds no marketplace yet: commits a company marketplace named ${name} on top of its ${branch} history, leaving its files as they are`,
+				...(action === "add" ? [companyLine(company as string)] : []),
 				targetLine(target, branch),
 			);
 			const state = delivered;
@@ -597,7 +677,7 @@ export async function planConnect(
 							writeJson(
 								clone,
 								MANIFEST,
-								newManifest(name, owner, undefined),
+								newManifest(name, company as string, undefined),
 								name,
 							);
 							return undefined;
@@ -689,6 +769,7 @@ export async function planConnect(
 				branch,
 				action,
 				name,
+				company,
 				registered,
 			}),
 			summary: { marketplace: name },