magus-cli 7.12.2 → 7.14.0

package/src/ui/market/useMarketState.ts

@@ -0,0 +1,694 @@
+/**
+ * The market screens' state and actions.
+ *
+ * Reading is read-only: the overview (`marketOverview`), this project's skill
+ * copies (`marketStatus`), the installs (`installedVersionAt`) and the
+ * skills and plugin folders here that no marketplace holds (`localItems`)
+ * write nothing, so opening the screens changes nothing on the machine.
+ *
+ * Every change is a planner from the market services, shown in a confirm
+ * dialog and applied by `applyMarketPlan` — the functions `magus market`'s
+ * verbs run, so the TUI and the CLI cannot do different things. `r` runs
+ * `marketFetch`, the one action that writes without a plan, and it writes
+ * only magus's own copies of the marketplaces.
+ */
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import { viewerLogin, viewerOrgs } from "../../services/github-cli.js";
+import { localItems } from "../../services/market-local.js";
+import {
+	planPluginAdd,
+	planPluginCreate,
+	planPluginDelete,
+} from "../../services/market-ops-plugin.js";
+import {
+	localSkillFolders,
+	marketStatus,
+	planPluginPublish,
+	planPublish,
+} from "../../services/market-ops-publish.js";
+import {
+	planConnect,
+	planCreate,
+	planRemove,
+} from "../../services/market-ops-repo.js";
+import {
+	planSkillAdd,
+	planSkillEdit,
+	planSkillRemove,
+} from "../../services/market-ops-skill.js";
+import {
+	type MarketOverviewEntry,
+	applyMarketPlan,
+	companyPluginNames,
+	companySkillNames,
+	errorResult,
+	marketFetch,
+	marketOverview,
+	planError,
+} from "../../services/market-ops.js";
+import { installedVersionAt } from "../../services/market-publish.js";
+import type {
+	InstallScope,
+	LocalItem,
+	MarketResult,
+	PlanAnswer,
+	SkillStatusRow,
+} from "../../services/market-types.js";
+import {
+	type ScopeVersions,
+	marketFailureReport,
+	plural,
+	resultNote,
+} from "../adapters/marketAdapter.js";
+import { useApp, useFailurePopup, useModal } from "../state/AppContext.js";
+import { type AsyncData, asyncValue } from "../state/types.js";
+
+export type MarketRoute =
+	| { screen: "marketplaces" }
+	| { screen: "marketplace"; name: string };
+
+export interface MarketData {
+	marketplaces: MarketOverviewEntry[];
+	/** This project's and your USER skill copies that company plugins hold. */
+	status: SkillStatusRow[];
+	/** Installed versions by `plugin@marketplace`. */
+	installs: Record<string, ScopeVersions>;
+	/** Skills and plugin folders here that no company marketplace holds. */
+	local: LocalItem[];
+}
+
+const SCOPES: readonly InstallScope[] = ["user", "project", "local"];
+
+async function readInstalls(
+	marketplaces: readonly MarketOverviewEntry[],
+	cwd: string,
+): Promise<Record<string, ScopeVersions>> {
+	const out: Record<string, ScopeVersions> = {};
+	for (const m of marketplaces) {
+		for (const p of m.plugins) {
+			const ref = `${p.name}@${m.name}`;
+			const versions: ScopeVersions = {
+				user: null,
+				project: null,
+				local: null,
+			};
+			for (const scope of SCOPES) {
+				versions[scope] = await installedVersionAt(ref, scope, cwd);
+			}
+			out[ref] = versions;
+		}
+	}
+	return out;
+}
+
+/** Everything the screens draw, read without writing anything. */
+async function readMarketData(cwd: string): Promise<MarketData> {
+	const marketplaces = await marketOverview();
+	const [status, installs, local] = await Promise.all([
+		marketStatus(undefined, cwd).then((r) => r.skills ?? []),
+		readInstalls(marketplaces, cwd),
+		localItems(
+			cwd,
+			companySkillNames(marketplaces),
+			companyPluginNames(marketplaces),
+		),
+	]);
+	return { marketplaces, status, installs, local };
+}
+
+/** What a confirmed action is, for its dialog and its failure popup. */
+interface ActionWords {
+	/** The confirm dialog's title: "Publish review to review-kit@acme?". */
+	title: string;
+	/** What failed, when it does: the marketplace, plugin or skill. */
+	subject: string;
+	/** The marketplace whose rows show the result. */
+	marketplace?: string;
+}
+
+export function useMarketState() {
+	const { state } = useApp();
+	const cwd = state.projectPath;
+	const modal = useModal();
+	const showFailures = useFailurePopup();
+
+	const [route, setRoute] = useState<MarketRoute>({ screen: "marketplaces" });
+	const [data, setData] = useState<AsyncData<MarketData>>({
+		status: "loading",
+	});
+	const [selected, setSelected] = useState({ marketplaces: 0, marketplace: 0 });
+	const [expanded, setExpanded] = useState<ReadonlySet<string>>(new Set());
+	/** The last finished change on each marketplace, as one line. */
+	const [notes, setNotes] = useState<Readonly<Record<string, string>>>({});
+	const loadSeq = useRef(0);
+
+	const reload = useCallback(async () => {
+		const seq = ++loadSeq.current;
+		setData((d) =>
+			d.status === "success"
+				? { status: "loading", previous: d.data }
+				: { status: "loading" },
+		);
+		try {
+			const next = await readMarketData(cwd);
+			if (seq === loadSeq.current) setData({ status: "success", data: next });
+		} catch (error) {
+			if (seq === loadSeq.current) {
+				setData({
+					status: "error",
+					error: error instanceof Error ? error : new Error(String(error)),
+				});
+			}
+		}
+	}, [cwd]);
+
+	useEffect(() => {
+		void reload();
+	}, [reload]);
+
+	const note = useCallback(
+		(marketplace: string | undefined, line: string | null) => {
+			if (!marketplace || !line) return;
+			setNotes((n) => ({ ...n, [marketplace]: line }));
+		},
+		[],
+	);
+
+	/** `market fetch`, with each marketplace's progress in the loading dialog. */
+	const fetchAll = useCallback(
+		async (name?: string | readonly string[]): Promise<MarketResult> => {
+			modal.loading("Fetching from GitHub…");
+			const result = await marketFetch(name, (_step, label) =>
+				modal.loading(`Fetching from GitHub…\n${label}`),
+			);
+			modal.hideModal();
+			return result;
+		},
+		[modal],
+	);
+
+	/**
+	 * Plan, confirm, apply — the TUI's face of the CLI's consent loop. A stale
+	 * read offers to fetch and plans again; a plan that changed before it was
+	 * applied is shown again; a forced publish asks its second question with
+	 * No as the default. Success shows in the rows; a failure is one popup.
+	 */
+	const runPlanned = useCallback(
+		async (words: ActionWords, plan: () => Promise<PlanAnswer>) => {
+			let fetched = false;
+			let changed = false;
+			for (;;) {
+				modal.loading("Reading the marketplace…");
+				let answer: PlanAnswer;
+				try {
+					answer = await plan();
+				} catch (error) {
+					answer = planError("market ?", error);
+				}
+				modal.hideModal();
+
+				if (answer.kind === "error") {
+					if (answer.error.code === "stale" && !fetched) {
+						const fetch = await modal.confirm(
+							"GitHub has newer commits",
+							`${answer.error.message}\n\nFetch them now?`,
+						);
+						if (!fetch) return;
+						fetched = true;
+						const result = await fetchAll(answer.error.marketplaces);
+						if (result.outcome !== "ok") {
+							await showFailures(marketFailureReport(result, words.subject));
+							await reload();
+							return;
+						}
+						continue;
+					}
+					await showFailures(
+						marketFailureReport(
+							errorResult(answer.command, answer.error),
+							words.subject,
+						),
+					);
+					return;
+				}
+
+				if (answer.kind === "result") {
+					note(words.marketplace, resultNote(answer.result));
+					await showFailures(marketFailureReport(answer.result, words.subject));
+					await reload();
+					return;
+				}
+
+				const p = answer.plan;
+				const yes = await modal.confirm(
+					changed ? `The plan changed — ${words.title}` : words.title,
+					changed
+						? "GitHub moved while this was open. This is the plan now:"
+						: "This is what it does:",
+					p.lines,
+				);
+				if (!yes) return;
+				if (p.secondConfirm !== undefined) {
+					const replace = await modal.select(
+						p.secondConfirm,
+						"The plugin's version on GitHub is replaced by this copy.",
+						[
+							{ label: "No", value: "no" },
+							{ label: "Yes, replace it", value: "yes" },
+						],
+						0,
+					);
+					if (replace !== "yes") return;
+				}
+
+				modal.loading(words.title);
+				const result = await applyMarketPlan(p, {
+					approved: p.planId,
+					cwd,
+					onStep: (_step, label) => modal.loading(`${words.title}\n${label}`),
+				});
+				modal.hideModal();
+				if (result.error?.code === "plan-changed") {
+					changed = true;
+					continue;
+				}
+				note(words.marketplace ?? result.marketplace, resultNote(result));
+				await showFailures(marketFailureReport(result, words.subject));
+				await reload();
+				return;
+			}
+		},
+		[cwd, fetchAll, modal, note, reload, showFailures],
+	);
+
+	// ─── Screen 1 actions ───────────────────────────────────────────────────
+
+	const fetch = useCallback(async () => {
+		const result = await fetchAll();
+		await showFailures(marketFailureReport(result, "company marketplaces"));
+		await reload();
+	}, [fetchAll, reload, showFailures]);
+
+	const create = useCallback(async () => {
+		modal.loading("Asking GitHub who you are…");
+		const [login, orgs] = await Promise.all([viewerLogin(), viewerOrgs()]);
+		modal.hideModal();
+		if (!login.ok) {
+			await showFailures({
+				headline: "Could not create a company marketplace",
+				rows: [{ subject: "GitHub", reason: login.message }],
+				fix:
+					login.failure === "gh-missing"
+						? "Install the GitHub CLI (gh), then press c again"
+						: "Run gh auth login, then press c again",
+			});
+			return;
+		}
+		const owners = [login.value, ...(orgs.ok ? orgs.value : [])];
+		const owner = await modal.select(
+			"Create a company marketplace",
+			"Which GitHub account owns the repository?",
+			owners.map((o, i) => ({
+				label: o,
+				value: o,
+				...(i === 0 ? { meta: "you" } : {}),
+			})),
+			0,
+		);
+		if (!owner) return;
+		const company = (
+			await modal.input(
+				"Create a company marketplace",
+				'Company name (shown as "by <name>" in magus):',
+				owner,
+			)
+		)?.trim();
+		if (!company) return;
+		const repo = (
+			await modal.input(
+				"Create a company marketplace",
+				`Repository name under ${owner}:`,
+				"claude-market",
+			)
+		)?.trim();
+		if (!repo) return;
+		const visibility = await modal.select(
+			"Create a company marketplace",
+			`Who can see ${owner}/${repo}?`,
+			[
+				{ label: "Private", value: "private", meta: "you and who you add" },
+				{ label: "Public", value: "public", meta: "everyone" },
+			],
+			0,
+		);
+		if (visibility !== "private" && visibility !== "public") return;
+		await runPlanned(
+			{
+				title: `Create ${owner}/${repo}?`,
+				subject: `${owner}/${repo}`,
+			},
+			() => planCreate({ repo: `${owner}/${repo}`, visibility, company }),
+		);
+	}, [modal, runPlanned, showFailures]);
+
+	const connect = useCallback(async () => {
+		const source = (
+			await modal.input(
+				"Connect a company marketplace",
+				"Repository (owner/repo, a git URL, or a folder):",
+			)
+		)?.trim();
+		if (!source) return;
+		await runPlanned({ title: `Connect ${source}?`, subject: source }, () =>
+			planConnect({ source }, cwd),
+		);
+	}, [cwd, modal, runPlanned]);
+
+	const remove = useCallback(
+		async (name: string) => {
+			await runPlanned(
+				{ title: `Remove ${name} from this machine?`, subject: name },
+				() => planRemove(name, cwd),
+			);
+		},
+		[cwd, runPlanned],
+	);
+
+	/**
+	 * Add a local skill or plugin folder to a company marketplace: pick the
+	 * marketplace (when there is more than one), then for a skill the plugin
+	 * it goes into, a new one included. One plan, one consent.
+	 */
+	const addLocal = useCallback(
+		async (item: LocalItem) => {
+			const marketplaces = asyncValue(data)?.marketplaces ?? [];
+			if (marketplaces.length === 0) {
+				await showFailures({
+					headline: `No company marketplace to add ${item.name} to`,
+					rows: [
+						{
+							subject: item.name,
+							reason: "this machine has no company marketplace yet",
+						},
+					],
+					fix: "Press c to create one, or o to connect one, then press a again",
+				});
+				return;
+			}
+			const title = `Add ${item.name} to a company marketplace`;
+			const marketplace =
+				marketplaces.length === 1
+					? marketplaces[0]?.name
+					: await modal.select(
+							title,
+							"Which marketplace?",
+							marketplaces.map((m) => ({
+								label: m.name,
+								value: m.name,
+								...(m.company ? { meta: `by ${m.company}` } : {}),
+							})),
+							0,
+						);
+			if (!marketplace) return;
+			if (item.kind === "plugin") {
+				await runPlanned(
+					{
+						title: `Add the plugin ${item.name} to ${marketplace}?`,
+						subject: item.name,
+						marketplace,
+					},
+					() => planPluginAdd({ path: item.path, to: marketplace }, cwd),
+				);
+				return;
+			}
+			const entry = marketplaces.find((m) => m.name === marketplace);
+			const NEW = "+new";
+			const choice = await modal.select(
+				title,
+				`Which plugin in ${marketplace}?`,
+				[
+					...(entry?.plugins ?? []).map((p) => ({
+						label: p.name,
+						value: p.name,
+						meta: plural(p.skills.length, "skill"),
+					})),
+					{ label: "+ New plugin", value: NEW },
+				],
+				0,
+			);
+			if (!choice) return;
+			let plugin = choice;
+			if (choice === NEW) {
+				const name = (
+					await modal.input(
+						`New plugin in ${marketplace}`,
+						`Plugin name (it is created with ${item.name} in it):`,
+						item.name,
+					)
+				)?.trim();
+				if (!name) return;
+				plugin = name;
+			}
+			const ref = `${plugin}@${marketplace}`;
+			await runPlanned(
+				{
+					title:
+						choice === NEW
+							? `Create ${ref} with ${item.name}?`
+							: `Add ${item.name} to ${ref}?`,
+					subject: item.name,
+					marketplace,
+				},
+				() =>
+					planSkillAdd(
+						{
+							skill: item.name,
+							plugin: ref,
+							from: item.scope === "user" ? "global" : "project",
+							keepLocal: false,
+							...(choice === NEW ? { createPlugin: true } : {}),
+						},
+						cwd,
+					),
+			);
+		},
+		[cwd, data, modal, runPlanned, showFailures],
+	);
+
+	// ─── Screen 2 actions ───────────────────────────────────────────────────
+
+	/** Push every skill of a plugin edited here, as one new version. */
+	const publishPlugin = useCallback(
+		async (ref: string, marketplace: string) => {
+			await runPlanned(
+				{
+					title: `Push a new version of ${ref}?`,
+					subject: ref,
+					marketplace,
+				},
+				() => planPluginPublish({ plugin: ref, keepLocal: false }, cwd),
+			);
+		},
+		[cwd, runPlanned],
+	);
+
+	const newPlugin = useCallback(
+		async (marketplace: string) => {
+			const name = (
+				await modal.input(`New plugin in ${marketplace}`, "Plugin name:")
+			)?.trim();
+			if (!name) return;
+			const description = (
+				await modal.input(
+					`New plugin in ${marketplace}`,
+					"What it does (Enter to leave it out):",
+				)
+			)?.trim();
+			if (description === undefined) return;
+			const ref = `${name}@${marketplace}`;
+			await runPlanned(
+				{ title: `Create ${ref}?`, subject: ref, marketplace },
+				() => planPluginCreate(ref, description || undefined),
+			);
+		},
+		[modal, runPlanned],
+	);
+
+	const deletePlugin = useCallback(
+		async (ref: string, marketplace: string) => {
+			await runPlanned(
+				{ title: `Delete ${ref}?`, subject: ref, marketplace },
+				() => planPluginDelete(ref, cwd),
+			);
+		},
+		[cwd, runPlanned],
+	);
+
+	const addSkill = useCallback(
+		async (ref: string, marketplace: string) => {
+			const folders = localSkillFolders(cwd);
+			if (folders.length === 0) {
+				await showFailures({
+					headline: `No skill to add to ${ref}`,
+					rows: [
+						{
+							subject: "skills",
+							reason: "this project and your USER skills hold none",
+						},
+					],
+					fix: "Create the skill in this project first, then press a again",
+				});
+				return;
+			}
+			const choice = await modal.select(
+				`Add a skill to ${ref}`,
+				"Which skill?",
+				folders.map((f) => ({
+					label: f.skill,
+					value: `${f.from}:${f.skill}`,
+					meta: f.from === "user" ? "USER" : "PROJECT",
+				})),
+				0,
+			);
+			if (!choice) return;
+			const at = choice.indexOf(":");
+			const from = choice.slice(0, at) === "user" ? "global" : "project";
+			const skill = choice.slice(at + 1);
+			await runPlanned(
+				{ title: `Add ${skill} to ${ref}?`, subject: skill, marketplace },
+				() => planSkillAdd({ skill, plugin: ref, from, keepLocal: false }, cwd),
+			);
+		},
+		[cwd, modal, runPlanned, showFailures],
+	);
+
+	const editSkill = useCallback(
+		async (skill: string, ref: string, marketplace: string) => {
+			await runPlanned(
+				{
+					title: `Copy ${skill} into this project to edit?`,
+					subject: skill,
+					marketplace,
+				},
+				() => planSkillEdit({ skill, plugin: ref, to: "project" }, cwd),
+			);
+		},
+		[cwd, runPlanned],
+	);
+
+	const removeSkill = useCallback(
+		async (skill: string, ref: string, marketplace: string) => {
+			await runPlanned(
+				{ title: `Remove ${skill} from ${ref}?`, subject: skill, marketplace },
+				() => planSkillRemove({ skill, plugin: ref }, cwd),
+			);
+		},
+		[cwd, runPlanned],
+	);
+
+	const publish = useCallback(
+		async (
+			skill: string,
+			ref: string,
+			marketplace: string,
+			local: SkillStatusRow,
+		) => {
+			if (local.state === "not-checked") {
+				const result = await fetchAll(marketplace);
+				if (result.outcome !== "ok") {
+					await showFailures(marketFailureReport(result, marketplace));
+				}
+				await reload();
+				return;
+			}
+			const plan = (force: boolean) =>
+				planPublish(
+					{
+						skill,
+						plugin: ref,
+						from: local.from === "user" ? "global" : "project",
+						keepLocal: false,
+						force,
+					},
+					cwd,
+				);
+			const force = local.state === "no-base" || local.state === "conflict";
+			await runPlanned(
+				{ title: `Publish ${skill} to ${ref}?`, subject: skill, marketplace },
+				async () => {
+					if (force) return plan(true);
+					// A row several plugins claim has no comparison state until a
+					// plugin is chosen: compared with this one it can need the
+					// replacing publish, which asks twice. The planner answers that
+					// refusal as a failed result, not as an error.
+					const answer = await plan(false);
+					const refused =
+						answer.kind === "result" ? answer.result.error?.code : undefined;
+					if (
+						local.state === "ambiguous" &&
+						(refused === "no-base" || refused === "conflict")
+					) {
+						return plan(true);
+					}
+					return answer;
+				},
+			);
+		},
+		[cwd, fetchAll, reload, runPlanned, showFailures],
+	);
+
+	const fetchOne = useCallback(
+		async (marketplace: string) => {
+			const result = await fetchAll(marketplace);
+			await showFailures(marketFailureReport(result, marketplace));
+			await reload();
+		},
+		[fetchAll, reload, showFailures],
+	);
+
+	const toggle = useCallback((ref: string) => {
+		setExpanded((open) => {
+			const next = new Set(open);
+			if (next.has(ref)) next.delete(ref);
+			else next.add(ref);
+			return next;
+		});
+	}, []);
+
+	const open = useCallback((name: string) => {
+		setRoute({ screen: "marketplace", name });
+		setSelected((s) => ({ ...s, marketplace: 0 }));
+	}, []);
+
+	const back = useCallback(() => setRoute({ screen: "marketplaces" }), []);
+
+	return {
+		cwd,
+		route,
+		data,
+		selected,
+		setSelected,
+		expanded,
+		notes,
+		reload,
+		open,
+		back,
+		toggle,
+		fetch,
+		fetchOne,
+		create,
+		connect,
+		remove,
+		addLocal,
+		publishPlugin,
+		newPlugin,
+		deletePlugin,
+		addSkill,
+		editSkill,
+		removeSkill,
+		publish,
+	};
+}
+
+export type MarketState = ReturnType<typeof useMarketState>;