magus-cli 7.12.2 → 7.14.0

package/src/cli/market.ts

@@ -0,0 +1,664 @@
+/**
+ * `magus market <verb>` — the non-interactive face of company marketplaces.
+ *
+ * Parses the verb and its flags, asks the planner (read-only), and handles
+ * consent: a TTY is asked `[Y/n]`; anything else writes nothing and exits 3
+ * with the plan and its planId, which `--yes=<planId>` then applies — and
+ * only that plan. Under `--json` one MarketResult is printed, on the last
+ * line of stdout, and nothing is asked.
+ *
+ * Bare `magus market` prints the help; the interactive screen is `magus
+ * edit`.
+ */
+
+import {
+	planPluginAdd,
+	planPluginCreate,
+	planPluginDelete,
+} from "../services/market-ops-plugin.js";
+import {
+	marketStatus,
+	planPluginPublish,
+	planPublish,
+	provisionalPublish,
+} 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 {
+	applyMarketPlan,
+	errorResult,
+	exitCodeFor,
+	marketFetch,
+	marketList,
+	needsConsent,
+} from "../services/market-ops.js";
+import {
+	MarketError,
+	type MarketResult,
+	type PlanAnswer,
+} from "../services/market-types.js";
+import {
+	applyQuestion,
+	applyingLines,
+	fetchQuestion,
+	listLines,
+	marketHelp,
+	planOf,
+	resultLines,
+	secondQuestion,
+	statusLines,
+	stepLine,
+} from "./market-view.js";
+import { askYesNo, promptValue } from "./prompt.js";
+
+/** Flags that take a value, and flags that stand alone. */
+const VALUE_FLAGS = new Set([
+	"--name",
+	"--company",
+	"--description",
+	"--plugin",
+	"--from",
+	"--to",
+]);
+const BOOL_FLAGS = new Set([
+	"--private",
+	"--public",
+	"--keep-local",
+	"--create-plugin",
+	"--force",
+	"--dry-run",
+	"--json",
+	"--yes",
+	"-y",
+]);
+
+interface Parsed {
+	positional: string[];
+	flags: Map<string, string | true>;
+}
+
+class UsageError extends Error {}
+
+function parseArgs(argv: string[]): Parsed {
+	const positional: string[] = [];
+	const flags = new Map<string, string | true>();
+	for (let i = 0; i < argv.length; i++) {
+		const token = argv[i] as string;
+		if (!token.startsWith("-")) {
+			positional.push(token);
+			continue;
+		}
+		const eq = token.indexOf("=");
+		const name = eq > 0 ? token.slice(0, eq) : token;
+		if (name === "--yes" && eq > 0) {
+			flags.set("--yes", token.slice(eq + 1));
+			continue;
+		}
+		if (VALUE_FLAGS.has(name)) {
+			const value = eq > 0 ? token.slice(eq + 1) : argv[++i];
+			if (value === undefined || value === "") {
+				throw new UsageError(`${name} needs a value`);
+			}
+			flags.set(name, value);
+			continue;
+		}
+		if (BOOL_FLAGS.has(name) && eq < 0) {
+			flags.set(name === "-y" ? "--yes" : name, true);
+			continue;
+		}
+		throw new UsageError(`unknown option ${token}`);
+	}
+	return { positional, flags };
+}
+
+/** Refuse flags a verb does not take, and a wrong number of arguments. */
+function expect(
+	p: Parsed,
+	allowed: readonly string[],
+	args: { min: number; max: number; usage: string },
+): void {
+	for (const flag of p.flags.keys()) {
+		if (flag !== "--json" && flag !== "--yes" && !allowed.includes(flag)) {
+			throw new UsageError(
+				`${flag} does not apply here — usage: ${args.usage}`,
+			);
+		}
+	}
+	if (p.positional.length < args.min || p.positional.length > args.max) {
+		throw new UsageError(`usage: ${args.usage}`);
+	}
+}
+
+function str(p: Parsed, flag: string): string | undefined {
+	const v = p.flags.get(flag);
+	return typeof v === "string" ? v : undefined;
+}
+
+function choice<T extends string>(
+	p: Parsed,
+	flag: string,
+	values: readonly T[],
+	fallback: T,
+): T {
+	const v = str(p, flag);
+	if (v === undefined) return fallback;
+	if (!(values as readonly string[]).includes(v)) {
+		throw new UsageError(`${flag} must be ${values.join(" or ")}`);
+	}
+	return v as T;
+}
+
+interface Io {
+	json: boolean;
+	interactive: boolean;
+}
+
+function emit(result: MarketResult, io: Io): void {
+	if (io.json) {
+		console.log(JSON.stringify(result));
+		return;
+	}
+	const lines =
+		result.outcome !== "ok"
+			? resultLines(result)
+			: result.command === "market list"
+				? listLines(result)
+				: result.command === "market status"
+					? statusLines(result)
+					: resultLines(result);
+	for (const line of lines) {
+		console.log(line);
+	}
+}
+
+/**
+ * Plan, ask (or not), apply, report. Returns the exit code.
+ * `yes` is true for bare `--yes`, the planId for `--yes=<planId>`.
+ */
+async function runWrite(
+	plan: () => Promise<PlanAnswer>,
+	io: Io,
+	yes: string | true | undefined,
+	cwd: string,
+): Promise<number> {
+	let fetchedOnce = false;
+	for (;;) {
+		const answer = await plan();
+		if (answer.kind === "error") {
+			if (
+				answer.error.code === "stale" &&
+				io.interactive &&
+				yes === undefined &&
+				!fetchedOnce
+			) {
+				console.log(warnBlock(answer.error.message));
+				if (await askYesNo(fetchQuestion())) {
+					fetchedOnce = true;
+					const fetched = await marketFetch(
+						answer.error.marketplaces,
+						(s, label) => console.log(stepLine(s, label)),
+					);
+					if (fetched.outcome !== "ok") {
+						emit(fetched, io);
+						return exitCodeFor(fetched);
+					}
+					continue;
+				}
+			}
+			// Consent was given up front, and an apply syncs magus's working
+			// clones before it plans again anyway. Fetching first is that same
+			// write, so the approved plan is then compared with GitHub's state
+			// rather than refused for this machine's.
+			if (answer.error.code === "stale" && yes !== undefined && !fetchedOnce) {
+				fetchedOnce = true;
+				const fetched = await marketFetch(answer.error.marketplaces);
+				if (fetched.outcome === "ok") continue;
+			}
+			const result = errorResult(answer.command, answer.error);
+			emit(result, io);
+			return answer.error.exit ?? exitCodeFor(result);
+		}
+		if (answer.kind === "result") {
+			emit(answer.result, io);
+			return exitCodeFor(answer.result);
+		}
+		const p = answer.plan;
+		let approved: string | null;
+		if (yes !== undefined) {
+			approved = yes === true ? null : yes;
+			if (!io.json) for (const line of applyingLines(p)) console.log(line);
+		} else if (io.interactive) {
+			for (const line of planOf(p)) console.log(line);
+			if (
+				!(await askYesNo(applyQuestion())) ||
+				(p.secondConfirm !== undefined &&
+					!/^(y|yes)$/i.test(
+						await promptValue(secondQuestion(p.secondConfirm)),
+					))
+			) {
+				console.log("\n  Nothing was changed.\n");
+				return 0;
+			}
+			approved = p.planId;
+		} else {
+			const result = needsConsent(p);
+			emit(result, io);
+			return exitCodeFor(result);
+		}
+		const result = await applyMarketPlan(p, {
+			approved,
+			cwd,
+			onStep: io.json
+				? undefined
+				: (s, label) => console.log(stepLine(s, label)),
+		});
+		if (
+			result.error?.code === "plan-changed" &&
+			io.interactive &&
+			yes === undefined
+		) {
+			console.log(warnBlock(result.message));
+			continue;
+		}
+		emit(result, io);
+		return exitCodeFor(result);
+	}
+}
+
+function warnBlock(text: string): string {
+	return `\n  ⚠  ${text}`;
+}
+
+/**
+ * `publish --dry-run`: the plan, or the answer a publish would give, and
+ * nothing written. On state older than GitHub's, a provisional answer with
+ * no compare (`provisional`), still exit 0; without one, that error.
+ */
+async function dryRunPublish(
+	plan: () => Promise<PlanAnswer>,
+	io: Io,
+	provisional?: (error: MarketError) => MarketResult,
+): Promise<number> {
+	const answer = await plan();
+	if (answer.kind === "plan") {
+		const p = answer.plan;
+		const result: MarketResult = {
+			command: p.command,
+			outcome: "ok",
+			message: "Dry run — nothing was changed.",
+			planId: p.planId,
+			...p.summary,
+			plan: p.lines,
+			steps: [],
+		};
+		if (io.json) console.log(JSON.stringify(result));
+		else {
+			for (const line of planOf(p)) console.log(line);
+			console.log(`\n  ${result.message}\n`);
+		}
+		return 0;
+	}
+	if (answer.kind === "result") {
+		emit(answer.result, io);
+		return exitCodeFor(answer.result);
+	}
+	if (
+		provisional &&
+		(answer.error.code === "stale" || answer.error.code === "no-network")
+	) {
+		emit(provisional(answer.error), io);
+		return 0;
+	}
+	const result = errorResult(answer.command, answer.error);
+	emit(result, io);
+	return answer.error.exit ?? exitCodeFor(result);
+}
+
+/** Run `magus market <argv>`. Returns the exit code. */
+export async function runMarketCommand(
+	argv: string[],
+	version: string,
+	cwd: string = process.cwd(),
+): Promise<number> {
+	if (argv.includes("--help") || argv.includes("-h")) {
+		console.log(marketHelp());
+		return 0;
+	}
+	if (argv.includes("--version") || argv.includes("-v")) {
+		console.log(`magus v${version}`);
+		return 0;
+	}
+	if (argv.length === 0) {
+		console.log(marketHelp());
+		console.log("Open the screen with `magus edit`.");
+		return 0;
+	}
+
+	const json = argv.includes("--json");
+	const io: Io = {
+		json,
+		interactive:
+			!json && process.stdin.isTTY === true && process.stdout.isTTY === true,
+	};
+	const [verb = "", ...rest] = argv;
+	try {
+		const p = parseArgs(rest);
+		const yes = p.flags.get("--yes");
+		switch (verb) {
+			case "list": {
+				expect(p, [], { min: 0, max: 0, usage: "magus market list [--json]" });
+				const result = await marketList(cwd);
+				emit(result, io);
+				return exitCodeFor(result);
+			}
+			case "fetch": {
+				expect(p, [], {
+					min: 0,
+					max: 1,
+					usage: "magus market fetch [<m>] [--json]",
+				});
+				const result = await marketFetch(
+					p.positional[0],
+					io.json ? undefined : (s, label) => console.log(stepLine(s, label)),
+				);
+				emit(result, io);
+				return exitCodeFor(result);
+			}
+			case "create": {
+				const usage =
+					"magus market create <owner>/<repo> --private|--public [--name <m>] [--company <name>] [--description <t>]";
+				expect(
+					p,
+					["--private", "--public", "--name", "--company", "--description"],
+					{
+						min: 1,
+						max: 1,
+						usage,
+					},
+				);
+				const priv = p.flags.has("--private");
+				const pub = p.flags.has("--public");
+				if (priv === pub) {
+					throw new UsageError(
+						`choose one of --private or --public — usage: ${usage}`,
+					);
+				}
+				return await runWrite(
+					() =>
+						planCreate({
+							repo: p.positional[0] as string,
+							visibility: priv ? "private" : "public",
+							name: str(p, "--name"),
+							company: str(p, "--company"),
+							description: str(p, "--description"),
+						}),
+					io,
+					yes,
+					cwd,
+				);
+			}
+			case "connect": {
+				expect(p, ["--name", "--company"], {
+					min: 1,
+					max: 1,
+					usage:
+						"magus market connect <owner/repo|git-url|path> [--name <m>] [--company <name>]",
+				});
+				return await runWrite(
+					() =>
+						planConnect(
+							{
+								source: p.positional[0] as string,
+								name: str(p, "--name"),
+								company: str(p, "--company"),
+							},
+							cwd,
+						),
+					io,
+					yes,
+					cwd,
+				);
+			}
+			case "remove": {
+				expect(p, [], { min: 1, max: 1, usage: "magus market remove <m>" });
+				return await runWrite(
+					() => planRemove(p.positional[0] as string, cwd),
+					io,
+					yes,
+					cwd,
+				);
+			}
+			case "plugin": {
+				const [sub, ref, ...extra] = p.positional;
+				const sp = { ...p, positional: ref ? [ref, ...extra] : [] };
+				if (sub === "create") {
+					expect(sp, ["--description"], {
+						min: 1,
+						max: 1,
+						usage: "magus market plugin create <p@m> [--description <t>]",
+					});
+					return await runWrite(
+						() => planPluginCreate(ref as string, str(p, "--description")),
+						io,
+						yes,
+						cwd,
+					);
+				}
+				if (sub === "add") {
+					expect(sp, ["--to", "--name"], {
+						min: 1,
+						max: 1,
+						usage: "magus market plugin add <path> [--to <m>] [--name <p>]",
+					});
+					return await runWrite(
+						() =>
+							planPluginAdd(
+								{
+									path: ref as string,
+									to: str(p, "--to"),
+									name: str(p, "--name"),
+								},
+								cwd,
+							),
+						io,
+						yes,
+						cwd,
+					);
+				}
+				if (sub === "delete") {
+					expect(sp, [], {
+						min: 1,
+						max: 1,
+						usage: "magus market plugin delete <p@m>",
+					});
+					return await runWrite(
+						() => planPluginDelete(ref as string, cwd),
+						io,
+						yes,
+						cwd,
+					);
+				}
+				throw new UsageError(
+					"usage: magus market plugin create|delete <p@m>, or magus market plugin add <path>",
+				);
+			}
+			case "skill": {
+				const [sub, skill, ...extra] = p.positional;
+				const sp = { ...p, positional: skill ? [skill, ...extra] : [] };
+				if (sub === "add") {
+					const usage =
+						"magus market skill add <skill> --plugin <p@m> [--create-plugin [--description <t>]] [--from project|global] [--keep-local]";
+					expect(
+						sp,
+						[
+							"--plugin",
+							"--from",
+							"--keep-local",
+							"--create-plugin",
+							"--description",
+						],
+						{
+							min: 1,
+							max: 1,
+							usage,
+						},
+					);
+					const plugin = str(p, "--plugin");
+					if (!plugin)
+						throw new UsageError(`--plugin is required — usage: ${usage}`);
+					const createPlugin = p.flags.has("--create-plugin");
+					if (p.flags.has("--description") && !createPlugin) {
+						throw new UsageError(
+							`--description describes a plugin --create-plugin creates — usage: ${usage}`,
+						);
+					}
+					const from = choice(
+						p,
+						"--from",
+						["project", "global"] as const,
+						"project",
+					);
+					return await runWrite(
+						() =>
+							planSkillAdd(
+								{
+									skill: skill as string,
+									plugin,
+									from,
+									keepLocal: p.flags.has("--keep-local"),
+									...(createPlugin
+										? {
+												createPlugin: true,
+												description: str(p, "--description"),
+											}
+										: {}),
+								},
+								cwd,
+							),
+						io,
+						yes,
+						cwd,
+					);
+				}
+				if (sub === "edit") {
+					expect(sp, ["--plugin", "--to"], {
+						min: 1,
+						max: 1,
+						usage:
+							"magus market skill edit <skill> [--plugin <p@m>] [--to project|global]",
+					});
+					const to = choice(
+						p,
+						"--to",
+						["project", "global"] as const,
+						"project",
+					);
+					return await runWrite(
+						() =>
+							planSkillEdit(
+								{ skill: skill as string, plugin: str(p, "--plugin"), to },
+								cwd,
+							),
+						io,
+						yes,
+						cwd,
+					);
+				}
+				if (sub === "remove") {
+					const usage = "magus market skill remove <skill> --plugin <p@m>";
+					expect(sp, ["--plugin"], { min: 1, max: 1, usage });
+					const plugin = str(p, "--plugin");
+					if (!plugin)
+						throw new UsageError(`--plugin is required — usage: ${usage}`);
+					return await runWrite(
+						() => planSkillRemove({ skill: skill as string, plugin }, cwd),
+						io,
+						yes,
+						cwd,
+					);
+				}
+				throw new UsageError(
+					"usage: magus market skill add|edit|remove <skill>",
+				);
+			}
+			case "status": {
+				expect(p, [], {
+					min: 0,
+					max: 1,
+					usage: "magus market status [<skill>] [--json]",
+				});
+				const result = await marketStatus(p.positional[0], cwd);
+				emit(result, io);
+				return exitCodeFor(result);
+			}
+			case "publish": {
+				const usage =
+					"magus market publish <skill> [--plugin <p@m>] [--from project|global] [--keep-local] [--force] [--dry-run], or magus market publish --plugin <p@m> [--keep-local] [--dry-run]";
+				expect(
+					p,
+					["--plugin", "--from", "--keep-local", "--force", "--dry-run"],
+					{ min: 0, max: 1, usage },
+				);
+				const skill = p.positional[0];
+				const keepLocal = p.flags.has("--keep-local");
+				if (skill === undefined) {
+					const plugin = str(p, "--plugin");
+					if (!plugin) {
+						throw new UsageError(
+							`name a skill, or a plugin with --plugin — usage: ${usage}`,
+						);
+					}
+					for (const flag of ["--from", "--force"]) {
+						if (p.flags.has(flag)) {
+							throw new UsageError(
+								`${flag} applies to one named skill: \`magus market publish <skill> ${flag} …\``,
+							);
+						}
+					}
+					const plan = () => planPluginPublish({ plugin, keepLocal }, cwd);
+					if (p.flags.has("--dry-run")) return await dryRunPublish(plan, io);
+					return await runWrite(plan, io, yes, cwd);
+				}
+				const args = {
+					skill,
+					plugin: str(p, "--plugin"),
+					from: choice(p, "--from", ["project", "global"] as const, "project"),
+					keepLocal,
+					force: p.flags.has("--force"),
+				};
+				const plan = () => planPublish(args, cwd);
+				if (p.flags.has("--dry-run")) {
+					return await dryRunPublish(plan, io, (error) =>
+						provisionalPublish(args, cwd, error),
+					);
+				}
+				return await runWrite(plan, io, yes, cwd);
+			}
+			default:
+				throw new UsageError(
+					`unknown command "${verb}" — \`magus market --help\` lists the commands`,
+				);
+		}
+	} catch (error) {
+		if (error instanceof UsageError) {
+			const result = errorResult(
+				`market ${verb || "?"}`,
+				new MarketError("other", error.message, "`magus market --help`", 2),
+			);
+			if (io.json) console.log(JSON.stringify(result));
+			else console.error(`magus market: ${error.message}`);
+			return 2;
+		}
+		const result = errorResult(`market ${verb}`, error);
+		emit(result, io);
+		return exitCodeFor(result);
+	}
+}