magus-cli 7.12.2 → 7.14.0

package/src/cli/install.ts

@@ -31,6 +31,10 @@ import {
 	summarizeClosure,
 } from "../services/install-plan.js";
 import { readManifest, validateManifest } from "../services/manifest.js";
+import {
+	conflictFreeOptions,
+	leaveOutConflicted,
+} from "../services/marketplace-conflicts.js";
 import { registerClosureMarketplaces } from "../services/marketplace-sync.js";
 import {
 	clearMarketplaceCache,
@@ -56,12 +60,15 @@ import { askYesNo, promptValue } from "./prompt.js";
 import { selectOption } from "./select.js";
 import {
 	commandHeader,
+	conflictSkipLine,
+	conflictStopLine,
 	fail as failLine,
 	field,
 	info as infoLine,
 	note as noteLine,
 	ok as okLine,
 	question,
+	registrationReport,
 	warn as warnLine,
 } from "./update-view.js";
 
@@ -122,6 +129,26 @@ async function runCheck(
  * EVERY profile's plugins — so the caller runs this inside
  * `withCliBookkeeping`, which renders the live files over it afterwards.
  */
+/**
+ * The closure without the plugins of each marketplace whose registration on
+ * this machine is not the one the profile names: installing them would take
+ * them from the wrong repository. Prints one line per marketplace left out
+ * when `report`.
+ */
+function withoutConflicted(
+	closure: ResolvedClosure,
+	conflicted: ReadonlySet<string>,
+	report = true,
+): ResolvedClosure {
+	const out = leaveOutConflicted(closure, conflicted);
+	if (report) {
+		for (const l of out.leftOut) {
+			console.log(conflictSkipLine(l.marketplace, l.plugins));
+		}
+	}
+	return out.closure;
+}
+
 async function installPlugins(closure: ResolvedClosure): Promise<string[]> {
 	const installed: string[] = [];
 	for (const pluginId of Object.keys(closure.plugins)) {
@@ -306,10 +333,14 @@ export async function runInstallCommand(
 
 	// Closure: a single profile, or the union of all — with every plugin the
 	// enabled ones depend on.
+	/** Marketplaces whose registration here is not the one the profile names. */
+	let conflicted: ReadonlySet<string> = new Set();
+	// Nothing is read for a conflicted marketplace's plugins: their
+	// dependencies and tool requirements would come from the other repository.
 	const resolveClosure = () =>
 		flags.profile
-			? resolveProfile(manifest, flags.profile)
-			: resolveAllProfiles(manifest);
+			? resolveProfile(manifest, flags.profile, conflictFreeOptions(conflicted))
+			: resolveAllProfiles(manifest, conflictFreeOptions(conflicted));
 	let closure = await resolveClosure();
 
 	if (flags.check) {
@@ -353,12 +384,17 @@ export async function runInstallCommand(
 		return 1;
 	}
 
-	await registerClosureMarketplaces(closure.marketplaces);
+	const registration = await registerClosureMarketplaces(
+		closure.marketplaces,
+		projectPath,
+	);
+	for (const line of registrationReport(registration)) console.log(line);
 	// A marketplace added just now carries the plugin.json files that name
 	// each plugin's dependencies; resolve again so those are installed too.
 	clearMarketplaceCache();
 	const before = new Set(Object.keys(closure.plugins));
-	closure = await resolveClosure();
+	conflicted = new Set(registration.conflicts.map((c) => c.name));
+	closure = withoutConflicted(await resolveClosure(), conflicted);
 	const found = Object.keys(closure.plugins).filter((id) => !before.has(id));
 	if (found.length > 0) {
 		console.log(
@@ -383,6 +419,23 @@ export async function runInstallCommand(
 		console.error(failLine("No profile chosen — stopping."));
 		return 1;
 	}
+	// Activating turns on every plugin the profile names, whatever this run
+	// installs: one from a conflicted marketplace would load from the other
+	// repository. Stop before anything is activated or installed.
+	if (activeId && conflicted.size > 0 && manifest.profiles[activeId]) {
+		const active = await resolveProfile(
+			manifest,
+			activeId,
+			conflictFreeOptions(conflicted),
+		);
+		const blocked = leaveOutConflicted(active, conflicted).leftOut;
+		if (blocked.length > 0) {
+			for (const b of blocked) {
+				console.error(conflictStopLine(activeId, b.marketplace, b.plugins));
+			}
+			return 1;
+		}
+	}
 	if (activeId) {
 		// The one switch path: what Claude Code wrote into the live config — or
 		// through an older layout's links — goes into the profile it was written
@@ -423,7 +476,13 @@ export async function runInstallCommand(
 		process.env.PATH ?? "",
 		process.env.SHELL ?? "",
 	);
-	if (env) await installDeps(await resolveClosure(), env, flags.yes);
+	if (env) {
+		await installDeps(
+			withoutConflicted(await resolveClosure(), conflicted, false),
+			env,
+			flags.yes,
+		);
+	}
 
 	if (activeId) {
 		await collectEnv(

package/src/cli/market-view.ts

@@ -0,0 +1,329 @@
+/**
+ * market-view.ts — every string `magus market` prints in text mode.
+ *
+ * Pure functions: plan or result in, lines out, built from the
+ * `magus update` report pieces (`commandHeader`, `ok`/`warn`/`fail`/`info`/
+ * `note`, `field`, `listItem`, `scopeBadge`, `question`) so the market verbs
+ * read like the rest of magus. States first, in the user's words.
+ */
+
+import type {
+	LocalCopy,
+	MarketPlan,
+	MarketResult,
+	SkillStatusRow,
+	StepRecord,
+} from "../services/market-types.js";
+import { bold, dim } from "./ansi.js";
+import {
+	commandHeader,
+	fail,
+	field,
+	info,
+	listItem,
+	note,
+	ok,
+	question,
+	scopeBadge,
+	warn,
+} from "./update-view.js";
+
+function headerFor(command: string, marketplace?: string): string[] {
+	return commandHeader(
+		command,
+		marketplace ? { label: "marketplace", value: marketplace } : undefined,
+	);
+}
+
+/** The plan, one line per thing it does, with its planId. */
+export function planLines(plan: {
+	command: string;
+	lines?: string[];
+	planId?: string;
+	marketplace?: string;
+}): string[] {
+	return [
+		...headerFor(plan.command, plan.marketplace),
+		...(plan.lines ?? []).map((l) => info(l)),
+		...(plan.planId ? [note(`plan ${plan.planId}`)] : []),
+	];
+}
+
+export function planOf(plan: MarketPlan): string[] {
+	return planLines({
+		command: plan.command,
+		lines: plan.lines,
+		planId: plan.planId,
+		marketplace: plan.summary.marketplace,
+	});
+}
+
+/**
+ * The report head for a plan applied on consent given up front (`--yes`):
+ * the same header and plan lines the question would have shown, without
+ * the planId, which nobody needs once it is applied.
+ */
+export function applyingLines(plan: MarketPlan): string[] {
+	return planLines({
+		command: plan.command,
+		lines: plan.lines,
+		marketplace: plan.summary.marketplace,
+	});
+}
+
+/** The consent question for a plan. */
+export function applyQuestion(): string {
+	return question("Apply this plan?");
+}
+
+/** The question when the state read was older than GitHub's. */
+export function fetchQuestion(): string {
+	return question("GitHub has newer commits — fetch them now?");
+}
+
+/** One step as it settles. */
+export function stepLine(step: StepRecord, label: string): string {
+	if (step.status === "done") {
+		return ok(step.detail ? `${label} ${dim(`(${step.detail})`)}` : label);
+	}
+	if (step.status === "skipped") return note(`${label} — not needed`);
+	return fail(`${label}: ${step.detail ?? "failed"}`);
+}
+
+function copyLine(copy: LocalCopy): string {
+	const whose = copy.scope === "user" ? "your USER" : "this project's";
+	if (copy.action === "removed") {
+		return ok(
+			`removed ${whose} copy of ${bold(copy.name)}${copy.scope === "project" ? ` — commit the deletion (.claude/skills/${copy.name})` : ""}`,
+		);
+	}
+	if (copy.action === "created") {
+		return ok(`${whose} copy of ${bold(copy.name)} is ready to edit`);
+	}
+	return info(`kept ${whose} copy of ${bold(copy.name)}: ${copy.reason ?? ""}`);
+}
+
+function localCopyLine(result: MarketResult): string[] {
+	return [
+		...(result.localCopy ? [result.localCopy] : []),
+		...(result.localCopies ?? []),
+	].map(copyLine);
+}
+
+function installLines(result: MarketResult): string[] {
+	const out: string[] = [];
+	for (const i of result.installs ?? []) {
+		const row = `${scopeBadge(i.scope)} ${result.plugin ?? ""} ${i.to ?? "—"}`;
+		if (i.status === "failed") {
+			out.push(fail(`${row}  ${i.message ?? ""}`));
+			if (i.fix) out.push(note(`fix: ${i.fix}`));
+		} else {
+			out.push(ok(row));
+		}
+	}
+	return out;
+}
+
+/** What a finished command says after its steps. */
+export function resultLines(result: MarketResult): string[] {
+	const lines: string[] = [];
+	if (result.outcome === "needs-consent" || result.outcome === "stale") {
+		if (result.plan) {
+			lines.push(
+				...planLines({
+					command: result.command,
+					lines: result.plan,
+					planId: result.planId,
+					marketplace: result.marketplace,
+				}),
+			);
+		}
+		lines.push(warn(result.message));
+		if (result.error?.fix) lines.push(note(result.error.fix));
+		if (result.outcome === "needs-consent" && !result.error && result.planId) {
+			lines.push(note(`to apply it: add --yes=${result.planId}`));
+		}
+		return ["", ...lines, ""];
+	}
+	lines.push(...installLines(result), ...localCopyLine(result));
+	switch (result.outcome) {
+		case "ok":
+		case "plugin-newer":
+			lines.push(ok(result.message));
+			break;
+		case "unchanged":
+		case "pull-request":
+			lines.push(info(result.message));
+			break;
+		default:
+			// A refused publish (no base, or a conflict) shows what differs.
+			if (result.steps.length === 0 && result.plan) {
+				lines.push(...result.plan.map((l) => info(l)));
+			}
+			lines.push(fail(result.message));
+			if (result.error?.fix) lines.push(note(`fix: ${result.error.fix}`));
+	}
+	return ["", ...lines, ""];
+}
+
+/** The second question before a publish replaces the plugin's version. */
+export function secondQuestion(text: string): string {
+	return question(text, "[y/N]");
+}
+
+const STATE_WORDS: Record<SkillStatusRow["state"], string> = {
+	edited: "● edited here",
+	"no-base": "◇ edited here, origin unknown",
+	conflict: "⚠ changed here and on GitHub",
+	"plugin-newer": "↓ plugin has a newer version",
+	same: "same as the plugin",
+	"not-checked": "? not checked",
+	ambiguous: "held by more than one company plugin",
+	"not-owned": "no company plugin holds it",
+};
+
+/** `market status`. */
+export function statusLines(result: MarketResult): string[] {
+	const lines = headerFor("market status");
+	const rows = result.skills ?? [];
+	if (rows.length === 0) {
+		lines.push(info(result.message));
+		return [...lines, ""];
+	}
+	for (const r of rows) {
+		const owner = r.owner ?? r.owners?.join(", ") ?? "";
+		const words =
+			r.state === "not-checked" && r.reason
+				? `${STATE_WORDS[r.state]} — ${r.reason}`
+				: STATE_WORDS[r.state];
+		lines.push(
+			`  ${scopeBadge(r.from)} ${bold(r.skill)}  ${dim(owner)}  ${words}`,
+		);
+	}
+	lines.push("");
+	lines.push(info(result.message));
+	if (rows.some((r) => r.state === "not-checked")) {
+		lines.push(note("run `magus market fetch`, then look again"));
+	}
+	if (rows.some((r) => r.state === "edited")) {
+		lines.push(note("publish one with `magus market publish <skill>`"));
+	}
+	return [...lines, ""];
+}
+
+/** `market list`. */
+export function listLines(result: MarketResult): string[] {
+	const lines = headerFor("market list");
+	const rows = result.marketplaces ?? [];
+	const local = result.local ?? [];
+	const localLines =
+		local.length === 0
+			? []
+			: [
+					`  ${bold("Here, in no marketplace")}`,
+					...local.map(
+						(l) => `  ${scopeBadge(l.scope)} ${bold(l.name)}  ${dim(l.kind)}`,
+					),
+					note(
+						rows.length === 0
+							? "a company marketplace is needed before these can be added to one"
+							: "add one with `magus market skill add <skill> --plugin <p@m> --create-plugin` or `magus market plugin add <path>`",
+					),
+					"",
+				];
+	if (rows.length === 0) {
+		lines.push(info(result.message));
+		lines.push(
+			note(
+				"create one with `magus market create`, or `magus market connect` an existing one",
+			),
+		);
+		return [...lines, "", ...localLines];
+	}
+	for (const m of rows) {
+		const by = m.company ? `  by ${m.company}` : "";
+		lines.push(
+			`  ${bold(m.name)}${by}  ${dim(m.repo)}  ${scopeBadge(m.scope)}`,
+		);
+		if (m.plugins.length === 0) lines.push(listItem(dim("no plugins yet")));
+		for (const p of m.plugins) {
+			lines.push(
+				field(
+					p.name,
+					`${p.version}  ${dim(p.skills.length === 0 ? "no skills" : p.skills.join(", "))}`,
+				),
+			);
+		}
+		lines.push("");
+	}
+	return [...lines, ...localLines];
+}
+
+/** `magus market --help`. */
+export function marketHelp(): string {
+	return `magus market — a company plugin marketplace on GitHub
+
+Usage: magus market <command> [args]
+
+The screen for all of this is \`magus edit\`; these commands run without one.
+
+  list                      Company marketplaces on this machine, with their
+                            plugins and skills. Changes nothing.
+  fetch [<m>]               Bring magus's copies of company marketplaces up to
+                            date with GitHub. Changes nothing else.
+  create <owner>/<repo> --private|--public [--name <m>] [--company <name>]
+         [--description <t>]
+                            Create a GitHub repository holding a new company
+                            marketplace and add it to this machine.
+                            --company is the name magus shows it by ("by
+                            <name>"); the GitHub owner when left out. One line,
+                            at most 64 characters.
+  connect <owner/repo|git-url|path> [--name <m>] [--company <name>]
+                            Use an existing repository as a company marketplace.
+                            --name and --company only when the repository holds
+                            no marketplace; otherwise its manifest names both.
+  remove <m>                Remove a company marketplace from this machine,
+                            uninstalling its plugins. The repository stays.
+  plugin create <p@m> [--description <t>]
+  plugin delete <p@m>       Add or delete a plugin in the marketplace.
+  plugin add <path> [--to <m>] [--name <p>]
+                            Copy a plugin folder of your own (one holding
+                            .claude-plugin/plugin.json) into the marketplace
+                            as a new plugin, at its own version (0.1.0 when it
+                            has none). The folder stays where it is.
+  skill add <skill> --plugin <p@m> [--create-plugin [--description <t>]]
+            [--from project|global] [--keep-local]
+                            Add a skill from this project (or your USER skills)
+                            to a plugin, then use the plugin's version.
+                            --create-plugin creates the plugin in the same
+                            commit when the marketplace has none of that name.
+  skill edit <skill> [--plugin <p@m>] [--to project|global]
+                            Copy a plugin's skill here to edit it.
+  skill remove <skill> --plugin <p@m>
+                            Remove a skill from a plugin.
+  status [<skill>]          How each local copy of a company skill stands
+                            against its plugin. Changes nothing.
+  publish <skill> [--plugin <p@m>] [--from project|global] [--keep-local]
+          [--force] [--dry-run]
+                            Send a local copy's edits to its plugin as the next
+                            patch version, move this machine's installs to it,
+                            then remove the local copy. --force replaces the
+                            plugin's version when the copy's origin is unknown
+                            or both sides changed. --dry-run shows the plan.
+  publish --plugin <p@m> [--keep-local] [--dry-run]
+                            Send every skill of the plugin edited here as one
+                            new patch version. A copy whose origin is unknown,
+                            or that changed on both sides, is left out: publish
+                            it on its own with --force.
+
+  @m may be left out when this machine has one company marketplace.
+
+Every command that changes something prints its plan with a planId first.
+  --yes=<planId>            Apply exactly that plan; a changed plan is refused
+  --yes                     Apply whatever the current plan is (scripts)
+  --json                    One JSON object on the last line of stdout
+
+Exit codes: 0 done · 1 failed · 2 usage or unknown name · 3 needs consent,
+the plan changed, or newer commits need fetching · 4 GitHub sign-in needed.
+`;
+}