magus-cli 7.12.2 → 7.14.0

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

@@ -0,0 +1,277 @@
+/**
+ * market-ops-content.ts — what the plans for a marketplace's contents share:
+ * reading one plugin from fresh state, its files, the version bump, and the
+ * step that moves this machine's installs after a push.
+ *
+ * Every read here is of the marketplace as GitHub has it now (a stale read
+ * decides nothing); nothing here writes outside a step's `run`.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { checkIgnore } from "./git-write.js";
+import { forgetBase, forgetBasesFor, recordBase } from "./market-bases.js";
+import {
+	type ChangeSpec,
+	changeSteps,
+	cloneOf,
+	deliveryTarget,
+	linkRefusal,
+	readJson,
+	targetLine,
+	writeJson,
+} from "./market-change.js";
+import { type Snapshot, cloneUrl } from "./market-clone.js";
+import { refuseLinkUnder } from "./market-fs.js";
+import {
+	SYMLINK_MODE,
+	type SkillFile,
+	addPluginEntry,
+	currentVersion,
+	findSkillOwners,
+	inDomain,
+	joinRel,
+	nextVersion,
+	pluginEntries,
+	pluginRelDir,
+	pluginRootOf,
+	removePluginEntry,
+	setEntryVersion,
+	treeHash,
+	validPackageName,
+	validSkillName,
+} from "./market-layout.js";
+import {
+	type MarketCommand,
+	computePlanId,
+	freshSnapshot,
+	manifestAt,
+	planError,
+	resolvePluginRef,
+} from "./market-ops.js";
+import {
+	type InstalledAt,
+	installReaches,
+	installedScopes,
+	moveInstalls,
+	profileManaged,
+	readSourceSets,
+	removeLocalCopy,
+} from "./market-publish.js";
+import {
+	type TrustedRegistration,
+	listCompanyMarketplaces,
+} from "./market-registry.js";
+import {
+	type FileChange,
+	type LocalCopy,
+	MarketError,
+	type MarketPlan,
+	type MarketStep,
+	type PlanAnswer,
+} from "./market-types.js";
+import { fastForwardCloneIfPresent } from "./marketplace-refresh.js";
+import { getUserSkillsDir } from "./skills-manager.js";
+
+export const MANIFEST = ".claude-plugin/marketplace.json";
+export const SCOPE_WORD = {
+	user: "USER",
+	project: "PROJECT",
+	local: "LOCAL",
+} as const;
+
+/** What a content plan reads first: the marketplace and one plugin in it. */
+export interface PluginView {
+	m: TrustedRegistration;
+	snap: Snapshot;
+	manifest: Record<string, unknown>;
+	plugin: string;
+	/** The plugin's directory in the repository. */
+	dir: string;
+	pluginJsonPath: string;
+	pluginJson: unknown;
+}
+
+export async function readPlugin(ref: string): Promise<PluginView> {
+	const { plugin, m } = await resolvePluginRef(ref);
+	const snap = await freshSnapshot(m);
+	return pluginViewAt(m, snap, await manifestAt(snap, m.name), plugin);
+}
+
+/** One plugin of a marketplace snapshot already read. */
+export async function pluginViewAt(
+	m: TrustedRegistration,
+	snap: Snapshot,
+	manifest: Record<string, unknown>,
+	plugin: string,
+): Promise<PluginView> {
+	const entry = pluginEntries(manifest).find((p) => p.name === plugin);
+	if (!entry) {
+		throw new MarketError(
+			"not-found",
+			`${m.name} has no plugin named ${plugin}`,
+			"`magus market list` shows its plugins",
+		);
+	}
+	const dir = pluginRelDir(entry.source, pluginRootOf(manifest));
+	if (dir === null) {
+		throw new MarketError(
+			"external-plugin",
+			`${plugin} lives outside ${m.name}'s repository, so magus cannot change it`,
+		);
+	}
+	const pluginJsonPath = joinRel(dir, ".claude-plugin", "plugin.json");
+	return {
+		m,
+		snap,
+		manifest,
+		plugin,
+		dir,
+		pluginJsonPath,
+		pluginJson: await snap.readJson(pluginJsonPath),
+	};
+}
+
+/** Every blob under `dir/` at the snapshot, relative to `dir`. */
+export function filesUnder(
+	snap: Snapshot,
+	dir: string,
+): Array<SkillFile & { mode: string }> {
+	const prefix = dir ? `${dir}/` : "";
+	const out: Array<SkillFile & { mode: string }> = [];
+	for (const [p, e] of snap.entries) {
+		if (p.startsWith(prefix)) {
+			out.push({ path: p.slice(prefix.length), oid: e.oid, mode: e.mode });
+		}
+	}
+	return out.sort((a, b) => (a.path < b.path ? -1 : 1));
+}
+
+export function versionLine(
+	plugin: string,
+	from: string | null,
+	to: string,
+): string {
+	return from === null
+		? `${plugin} is unversioned → ${to}`
+		: `${plugin} ${from} → ${to}`;
+}
+
+/** The plugin's next version, or an error for one magus will not bump. */
+export function bumpFrom(view: PluginView): {
+	from: string | null;
+	to: string;
+} {
+	const entry = pluginEntries(view.manifest).find(
+		(p) => p.name === view.plugin,
+	);
+	const from = currentVersion(view.pluginJson, entry);
+	const to = nextVersion(from);
+	if (!to) {
+		throw new MarketError(
+			"other",
+			`${view.plugin}'s version ${from} is not major.minor.patch, so magus cannot bump it`,
+		);
+	}
+	return { from, to };
+}
+
+/** Write the new version to the entry, and to `plugin.json` when it exists. */
+export function bumpStep(view: PluginView, to: string): MarketStep {
+	return {
+		id: "bump",
+		label: `${view.plugin} ${to}`,
+		outside: false,
+		async run(ctx) {
+			const clone = cloneOf(ctx);
+			const label = view.m.name;
+			const manifest = readJson(clone, MANIFEST, label);
+			writeJson(
+				clone,
+				MANIFEST,
+				setEntryVersion(manifest, view.plugin, to),
+				label,
+			);
+			refuseLinkUnder(clone, view.pluginJsonPath, linkRefusal(label));
+			if (fs.existsSync(path.join(clone, view.pluginJsonPath))) {
+				const current = readJson(clone, view.pluginJsonPath, label);
+				writeJson(
+					clone,
+					view.pluginJsonPath,
+					{ ...current, version: to },
+					label,
+				);
+			}
+			return undefined;
+		},
+	};
+}
+
+/** The version files a bump changes, as staged paths and expected changes. */
+export function versionFiles(
+	view: PluginView,
+): Array<{ path: string; change: FileChange }> {
+	const out: Array<{ path: string; change: FileChange }> = [
+		{ path: MANIFEST, change: "modified" },
+	];
+	if (view.pluginJson !== null) {
+		out.push({ path: view.pluginJsonPath, change: "modified" });
+	}
+	return out;
+}
+
+export function installLines(
+	plugin: string,
+	installs: readonly InstalledAt[],
+	to: string,
+): string[] {
+	if (installs.length === 0) {
+		return [`${plugin} is not installed here, so no install moves`];
+	}
+	return installs.map(
+		(i) => `Moves ${SCOPE_WORD[i.scope]} ${plugin} ${i.version} → ${to}`,
+	);
+}
+
+/** Step 7: move this machine's installs to the version just pushed. */
+export function installStep(
+	view: PluginView,
+	installs: readonly InstalledAt[],
+	to: string,
+	state: { moved?: boolean },
+): MarketStep {
+	return {
+		id: "install",
+		label: `moved installs to ${to}`,
+		outside: true,
+		async run(ctx) {
+			if (installs.length === 0) {
+				state.moved = false;
+				return { skipped: true };
+			}
+			const r = await moveInstalls(
+				view.m.name,
+				`${view.plugin}@${view.m.name}`,
+				installs,
+				to,
+				ctx.cwd,
+			);
+			state.moved = r.ok;
+			if (r.ok) return { patch: { installs: r.installs } };
+			return {
+				patch: {
+					installs: r.installs,
+					outcome: "partial",
+					message:
+						r.message ??
+						`The push landed, but not every install moved to ${to}`,
+					error: {
+						code: "install-failed",
+						message: r.message ?? "not every install moved",
+						fix: r.fix ?? "magus update",
+					},
+				},
+			};
+		},
+	};
+}