magus-cli 7.13.0 → 7.14.0

package/src/ui/market/useMarketState.ts

@@ -2,7 +2,8 @@
  * The market screens' state and actions.
  *
  * Reading is read-only: the overview (`marketOverview`), this project's skill
- * copies (`marketStatus`) and the installs (`installedVersionAt`)
+ * 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
@@ -14,13 +15,16 @@
 
 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 {
@@ -36,6 +40,8 @@ import {
 import {
 	type MarketOverviewEntry,
 	applyMarketPlan,
+	companyPluginNames,
+	companySkillNames,
 	errorResult,
 	marketFetch,
 	marketOverview,
@@ -44,6 +50,7 @@ import {
 import { installedVersionAt } from "../../services/market-publish.js";
 import type {
 	InstallScope,
+	LocalItem,
 	MarketResult,
 	PlanAnswer,
 	SkillStatusRow,
@@ -51,10 +58,11 @@ import type {
 import {
 	type ScopeVersions,
 	marketFailureReport,
+	plural,
 	resultNote,
 } from "../adapters/marketAdapter.js";
 import { useApp, useFailurePopup, useModal } from "../state/AppContext.js";
-import type { AsyncData } from "../state/types.js";
+import { type AsyncData, asyncValue } from "../state/types.js";
 
 export type MarketRoute =
 	| { screen: "marketplaces" }
@@ -66,6 +74,8 @@ export interface MarketData {
 	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"];
@@ -95,11 +105,16 @@ async function readInstalls(
 /** Everything the screens draw, read without writing anything. */
 async function readMarketData(cwd: string): Promise<MarketData> {
 	const marketplaces = await marketOverview();
-	const [status, installs] = await Promise.all([
+	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 };
+	return { marketplaces, status, installs, local };
 }
 
 /** What a confirmed action is, for its dialog and its failure popup. */
@@ -302,6 +317,14 @@ export function useMarketState() {
 			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",
@@ -325,7 +348,7 @@ export function useMarketState() {
 				title: `Create ${owner}/${repo}?`,
 				subject: `${owner}/${repo}`,
 			},
-			() => planCreate({ repo: `${owner}/${repo}`, visibility }),
+			() => planCreate({ repo: `${owner}/${repo}`, visibility, company }),
 		);
 	}, [modal, runPlanned, showFailures]);
 
@@ -352,8 +375,124 @@ export function useMarketState() {
 		[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 = (
@@ -541,6 +680,8 @@ export function useMarketState() {
 		create,
 		connect,
 		remove,
+		addLocal,
+		publishPlugin,
 		newPlugin,
 		deletePlugin,
 		addSkill,

package/src/utils/display-path.ts

@@ -0,0 +1,33 @@
+/**
+ * display-path.ts — a folder as a person reads it: relative to the project
+ * when it is inside it, `~/…` when it is under the home folder, else as is.
+ * For display only; JSON and every file operation keep the absolute path.
+ */
+
+import os from "node:os";
+import path from "node:path";
+
+/** `child` is `parent` itself or somewhere under it. */
+function within(parent: string, child: string): string | null {
+	const rel = path.relative(parent, child);
+	if (rel === "") return "";
+	if (rel.startsWith("..") || path.isAbsolute(rel)) return null;
+	return rel;
+}
+
+/**
+ * `abs` shortened for display: `.claude/skills/greet` inside `cwd`,
+ * `~/.claude/skills/team-tools` under the home folder, otherwise unchanged.
+ * The home folder is `$HOME` when set, as Claude Code and the shell read it.
+ */
+export function displayPath(
+	abs: string,
+	cwd: string,
+	home: string = process.env.HOME || os.homedir(),
+): string {
+	const inProject = within(path.resolve(cwd), path.resolve(abs));
+	if (inProject !== null) return inProject === "" ? "." : inProject;
+	const inHome = home ? within(path.resolve(home), path.resolve(abs)) : null;
+	if (inHome !== null) return inHome === "" ? "~" : `~/${inHome}`;
+	return abs;
+}