magus-cli 7.13.0 → 7.14.1

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

@@ -88,10 +88,17 @@ import {
 	filesUnder,
 	installLines,
 	installStep,
+	pluginViewAt,
 	readPlugin,
 	versionFiles,
 	versionLine,
 } from "./market-ops-content.js";
+import {
+	NEW_PLUGIN_VERSION,
+	newPluginLayout,
+	refreshStep,
+	writeNewPlugin,
+} from "./market-ops-plugin.js";
 
 // ─── skill add ───────────────────────────────────────────────────────────────
 
@@ -100,6 +107,13 @@ export interface SkillAddArgs {
 	plugin: string;
 	from: "project" | "global";
 	keepLocal: boolean;
+	/**
+	 * Create the plugin, in the same commit, when the marketplace has none of
+	 * that name. Without it a missing plugin is `not-found`.
+	 */
+	createPlugin?: boolean;
+	/** The new plugin's description; read only when it is created. */
+	description?: string;
 }
 
 export function skillFolder(
@@ -169,7 +183,34 @@ export async function planSkillAdd(
 				`${where} has no skill named ${args.skill}`,
 			);
 		}
-		const view = await readPlugin(args.plugin);
+		const ref = await resolvePluginRef(args.plugin);
+		const snapNow = await freshSnapshot(ref.m);
+		const manifestNow = await manifestAt(snapNow, ref.m.name);
+		const exists = pluginEntries(manifestNow).some(
+			(p) => p.name === ref.plugin,
+		);
+		if (!exists && !args.createPlugin) {
+			throw new MarketError(
+				"not-found",
+				`${ref.m.name} has no plugin named ${ref.plugin}`,
+				"`magus market list` shows its plugins; add --create-plugin to create it with this skill",
+			);
+		}
+		// A plugin created here starts at its first version: nothing to bump.
+		const layout = exists
+			? null
+			: newPluginLayout(ref.m, snapNow, manifestNow, ref.plugin);
+		const view: PluginView = layout
+			? {
+					m: ref.m,
+					snap: snapNow,
+					manifest: manifestNow,
+					plugin: ref.plugin,
+					dir: layout.dir,
+					pluginJsonPath: layout.pluginJsonPath,
+					pluginJson: null,
+				}
+			: await pluginViewAt(ref.m, snapNow, manifestNow, ref.plugin);
 		const { m, snap, plugin, dir } = view;
 		const skillDir = joinRel(dir, "skills", args.skill);
 		if (filesUnder(snap, skillDir).length > 0) {
@@ -179,7 +220,9 @@ export async function planSkillAdd(
 				"to send your edits to it, use `magus market publish`",
 			);
 		}
-		const { from, to } = bumpFrom(view);
+		const { from, to } = layout
+			? { from: null, to: NEW_PLUGIN_VERSION }
+			: bumpFrom(view);
 		const sets = await readSourceSets(folder, snap.dir, skillDir);
 		if (sets.published.length === 0) {
 			throw new MarketError(
@@ -213,15 +256,40 @@ export async function planSkillAdd(
 					reason: keepReason,
 				}
 			: { scope: copyScope, name: args.skill, action: "removed" };
+		const created = layout
+			? [
+					{ path: MANIFEST, change: "modified" as const },
+					{ path: layout.pluginJsonPath, change: "added" as const },
+				]
+			: versionFiles(view);
 		const files = [
 			...sets.published.map((f) => ({
 				path: joinRel(skillDir, f.path),
 				change: "added" as const,
 			})),
-			...versionFiles(view),
+			...created,
 		];
 		const state: ChangeSpec["state"] & { moved?: boolean } = {};
 		const steps: MarketStep[] = [
+			...(layout
+				? [
+						{
+							id: "edit",
+							label: `wrote ${plugin}`,
+							outside: false,
+							async run(ctx: Parameters<MarketStep["run"]>[0]) {
+								writeNewPlugin(
+									cloneOf(ctx),
+									m,
+									view.manifest,
+									layout,
+									args.description,
+								);
+								return undefined;
+							},
+						} satisfies MarketStep,
+					]
+				: []),
 			{
 				id: "copy",
 				label: `copied ${args.skill} into ${plugin}`,
@@ -246,20 +314,27 @@ export async function planSkillAdd(
 					return undefined;
 				},
 			},
-			bumpStep(view, to),
+			...(layout ? [] : [bumpStep(view, to)]),
 			...changeSteps({
 				label: m.name,
 				source: m.source,
 				branch: snap.branch,
 				target,
-				stage: [skillDir, ...versionFiles(view).map((f) => f.path)],
+				stage: layout
+					? [MANIFEST, dir]
+					: [skillDir, ...versionFiles(view).map((f) => f.path)],
 				files,
-				message: `${plugin}: add ${args.skill} skill (${to})`,
+				message: layout
+					? `${plugin}: create plugin with ${args.skill} skill (${to})`
+					: `${plugin}: add ${args.skill} skill (${to})`,
 				slug: `${plugin}-${to}`,
-				prBody: `Adds the skill \`${args.skill}\` to \`${plugin}\` and bumps it to ${to}.`,
-				verify: { dir: skillDir, files: sets.published },
+				prBody: layout
+					? `Creates the plugin \`${plugin}\` (${to}) in ${m.name} with the skill \`${args.skill}\`.`
+					: `Adds the skill \`${args.skill}\` to \`${plugin}\` and bumps it to ${to}.`,
+				verify: [{ dir: skillDir, files: sets.published }],
 				state,
 			}),
+			...(layout ? [refreshStep(m.name, state)] : []),
 			installStep(view, installs, to, state),
 			{
 				id: "local-copy",
@@ -296,8 +371,14 @@ export async function planSkillAdd(
 			},
 		];
 		const lines = [
-			`Adds the skill ${args.skill} from ${where} to ${pluginId}`,
-			versionLine(plugin, from, to),
+			...(layout
+				? [
+						`Creates the plugin ${plugin} (${to}) in ${m.name}, with the skill ${args.skill} from ${where}, in one commit`,
+					]
+				: [
+						`Adds the skill ${args.skill} from ${where} to ${pluginId}`,
+						versionLine(plugin, from, to),
+					]),
 			`Publishes ${sets.published.length} file${sets.published.length === 1 ? "" : "s"}: ${sets.published.map((f) => f.path).join(", ")}`,
 			...(sets.untrackedFolder
 				? [
@@ -324,6 +405,7 @@ export async function planSkillAdd(
 				from: args.from,
 				keepLocal: args.keepLocal,
 				plugin: pluginId,
+				createPlugin: layout ? { description: args.description ?? null } : null,
 				commit: snap.commit,
 				hash: sets.hash,
 				notPublished: sets.notPublished,
@@ -344,7 +426,7 @@ export async function planSkillAdd(
 			steps,
 			sync: { name: m.name, url: cloneUrl(m.source) },
 			lock: m.name,
-			replan: () => planSkillAdd(args, cwd),
+			replan: () => planSkillAdd({ ...args, plugin: pluginId }, cwd),
 			doneMessage: `${args.skill} is in ${pluginId} ${to}. Takes effect in new sessions, or after /reload-plugins.`,
 		};
 		return { kind: "plan", plan };

package/src/services/market-ops.ts

@@ -31,8 +31,10 @@ import {
 	pluginRelDir,
 	pluginRootOf,
 } from "./market-layout.js";
+import { localItems } from "./market-local.js";
 import {
 	type TrustedRegistration,
+	isGithubSource,
 	listCompanyMarketplaces,
 } from "./market-registry.js";
 import {
@@ -400,6 +402,28 @@ function readJsonFile(file: string): unknown {
 	}
 }
 
+/**
+ * The company a marketplace belongs to: its manifest's `owner.name`, else the
+ * GitHub owner of its source. Undefined for a non-GitHub source whose
+ * manifest names no owner.
+ */
+export function companyOf(
+	manifest: unknown,
+	source: string,
+): string | undefined {
+	const owner =
+		manifest && typeof manifest === "object" && !Array.isArray(manifest)
+			? (manifest as { owner?: unknown }).owner
+			: undefined;
+	const name =
+		owner && typeof owner === "object"
+			? (owner as { name?: unknown }).name
+			: undefined;
+	if (typeof name === "string" && name.trim()) return name.trim();
+	if (isGithubSource(source)) return source.split("/")[0] || undefined;
+	return undefined;
+}
+
 /** The plugins and skills of a marketplace as Claude Code's copy holds them. */
 function rowFor(m: TrustedRegistration): MarketplaceRow {
 	const row: MarketplaceRow = {
@@ -408,10 +432,14 @@ function rowFor(m: TrustedRegistration): MarketplaceRow {
 		scope: "user",
 		plugins: [],
 	};
+	const fallback = companyOf(null, m.source);
+	if (fallback) row.company = fallback;
 	if (!m.location) return row;
 	const manifest = readJsonFile(
 		path.join(m.location, ".claude-plugin", "marketplace.json"),
 	);
+	const company = companyOf(manifest, m.source);
+	if (company) row.company = company;
 	const root = pluginRootOf(manifest);
 	for (const entry of pluginEntries(manifest)) {
 		const dir = pluginDirFor(m.location, entry.source, root);
@@ -443,9 +471,35 @@ function rowFor(m: TrustedRegistration): MarketplaceRow {
 	return row;
 }
 
-/** `market list`: every company marketplace here with its plugins. Read-only. */
-export async function marketList(): Promise<MarketResult> {
+/** Every plugin name among `marketplaces`. */
+export function companyPluginNames(
+	marketplaces: ReadonlyArray<{ plugins: MarketplaceRow["plugins"] }>,
+): Set<string> {
+	return new Set(marketplaces.flatMap((m) => m.plugins.map((p) => p.name)));
+}
+
+/** Every skill name a company plugin among `marketplaces` holds. */
+export function companySkillNames(
+	marketplaces: ReadonlyArray<{ plugins: MarketplaceRow["plugins"] }>,
+): Set<string> {
+	return new Set(
+		marketplaces.flatMap((m) => m.plugins.flatMap((p) => p.skills)),
+	);
+}
+
+/**
+ * `market list`: every company marketplace here with its plugins, and the
+ * skills and plugin folders here that none of them holds. Read-only.
+ */
+export async function marketList(
+	cwd: string = process.cwd(),
+): Promise<MarketResult> {
 	const marketplaces = (await listCompanyMarketplaces()).map(rowFor);
+	const local = await localItems(
+		cwd,
+		companySkillNames(marketplaces),
+		companyPluginNames(marketplaces),
+	);
 	return {
 		command: "market list",
 		outcome: "ok",
@@ -454,6 +508,7 @@ export async function marketList(): Promise<MarketResult> {
 				? "No company marketplaces on this machine"
 				: `${marketplaces.length} company marketplace${marketplaces.length === 1 ? "" : "s"} on this machine`,
 		marketplaces,
+		local,
 		steps: [],
 	};
 }
@@ -480,15 +535,16 @@ export interface MarketOverviewEntry {
 	fix: string;
 	/** The commit the plugins were read at, when a local copy had one. */
 	commit: string | null;
+	/** The company it belongs to, as {@link companyOf} reads it. */
+	company?: string;
 	plugins: MarketplaceRow["plugins"];
 }
 
 /** The plugins of a marketplace snapshot, with their versions and skills. */
 async function pluginsAt(
 	snap: Snapshot,
-	label: string,
+	manifest: Record<string, unknown>,
 ): Promise<MarketplaceRow["plugins"]> {
-	const manifest = await manifestAt(snap, label);
 	const root = pluginRootOf(manifest);
 	const out: MarketplaceRow["plugins"] = [];
 	for (const entry of pluginEntries(manifest)) {
@@ -541,14 +597,22 @@ export async function marketOverview(): Promise<MarketOverviewEntry[]> {
 			commit: state.snapshot?.commit ?? null,
 			plugins: [],
 		};
+		let fromSnapshot = false;
 		if (state.snapshot) {
 			try {
-				entry.plugins = await pluginsAt(state.snapshot, m.name);
+				const manifest = await manifestAt(state.snapshot, m.name);
+				entry.plugins = await pluginsAt(state.snapshot, manifest);
+				const company = companyOf(manifest, m.source);
+				if (company) entry.company = company;
+				fromSnapshot = true;
 			} catch {
-				entry.plugins = rowFor(m).plugins;
+				fromSnapshot = false;
 			}
-		} else {
-			entry.plugins = rowFor(m).plugins;
+		}
+		if (!fromSnapshot) {
+			const row = rowFor(m);
+			entry.plugins = row.plugins;
+			if (row.company) entry.company = row.company;
 		}
 		out.push(entry);
 	}

package/src/services/market-publish.ts

@@ -87,12 +87,21 @@ export async function readSourceSets(
 	folder: string,
 	destRepo: string,
 	destDir: string,
+	/**
+	 * A top-level folder whose own dot-name does not exclude it: a plugin's
+	 * `.claude-plugin`. What lies inside it is judged by the usual rules.
+	 */
+	keepDotDir?: string,
 ): Promise<SourceSets> {
 	const items = inventory(folder);
 	const notPublished: SourceSets["notPublished"] = [];
 	const candidates: string[] = [];
 	for (const item of items) {
-		const shape = excludedByShape(item.path, item.symlink);
+		const judged =
+			keepDotDir && item.path.startsWith(`${keepDotDir}/`)
+				? item.path.slice(keepDotDir.length + 1)
+				: item.path;
+		const shape = excludedByShape(judged, item.symlink);
 		if (shape) notPublished.push({ path: item.path, reason: shape });
 		else candidates.push(item.path);
 	}

package/src/services/market-types.ts

@@ -60,10 +60,29 @@ export type InstallScope = "user" | "project" | "local";
 export interface MarketplaceRow {
 	name: string;
 	repo: string;
+	/**
+	 * The company it belongs to: the manifest's `owner.name`, else the GitHub
+	 * owner of its source. Absent when neither names one.
+	 */
+	company?: string;
 	scope: "user";
 	plugins: Array<{ name: string; version: string; skills: string[] }>;
 }
 
+/**
+ * A skill or plugin folder on this machine that is not part of any company
+ * marketplace: one of this project's or your USER skills, or a plugin folder
+ * among them (one holding `.claude-plugin/plugin.json`).
+ */
+export interface LocalItem {
+	kind: "skill" | "plugin";
+	/** The folder's name; for a plugin, its `plugin.json` name when it has one. */
+	name: string;
+	scope: "project" | "user";
+	/** The folder, absolute. */
+	path: string;
+}
+
 export interface SkillStatusRow {
 	skill: string;
 	from: "project" | "user";
@@ -128,7 +147,11 @@ export interface MarketResult {
 	installs?: InstallRow[];
 	otherProjects?: number;
 	localCopy?: LocalCopy;
+	/** A plugin-wide publish settles one local copy per published skill. */
+	localCopies?: LocalCopy[];
 	marketplaces?: MarketplaceRow[];
+	/** `market list`: skills and plugins on this machine that no marketplace holds. */
+	local?: LocalItem[];
 	skills?: SkillStatusRow[];
 	plan?: string[];
 	steps: StepRecord[];

package/src/services/update-engine.ts

@@ -43,6 +43,7 @@ import { selectProfileId } from "./active-closure.js";
 import type { PluginScope } from "./claude-cli.js";
 import {
 	installPlugin,
+	installedScopeFromAnswer,
 	isNotInstalledAnswer,
 	repairPlugin,
 	uninstallPluginViaCli,
@@ -1508,7 +1509,25 @@ export async function uninstallPluginInScope(
 		}
 	}
 
-	await remove.uninstall(pluginId, scope, projectPath);
+	try {
+		await remove.uninstall(pluginId, scope, projectPath);
+	} catch (error) {
+		if (!isNotInstalledAnswer(error)) throw error;
+		await settleScopeWithNoInstall(
+			pluginId,
+			scope,
+			projectPath,
+			deps,
+			error,
+			profile,
+		);
+		if (scope === "project") {
+			await remove
+				.forgetVersion?.(pluginId, scope, projectPath)
+				.catch(() => {});
+			return;
+		}
+	}
 	if (await remove.isInstalled(pluginId, scope, projectPath)) {
 		throw new Error(`still installed at ${scope.toUpperCase()} scope`);
 	}
@@ -1531,6 +1550,83 @@ export async function uninstallPluginInScope(
 	await recordInProfileOrExplain(deps, projectPath, done);
 }
 
+/**
+ * The half of {@link uninstallPluginInScope} that runs when Claude Code answers
+ * that it holds no install of the plugin at `scope` here, so its uninstall had
+ * nothing to remove.
+ *
+ * At PROJECT the setting that turns the plugin on is the profile render's, so
+ * the profile drops it and the live files are brought back in line with the
+ * profile. USER and LOCAL settings belong to no profile, so nothing is changed
+ * there. Either way the scope is read back afterwards: still installed means
+ * nothing magus owns turns it on, and the refusal names the scope Claude Code
+ * reported, in magus's terms rather than the CLI's text.
+ */
+async function settleScopeWithNoInstall(
+	pluginId: string,
+	scope: PluginScope,
+	projectPath: string,
+	deps: PluginApplyDeps,
+	answer: unknown,
+	profile: string | null | undefined,
+): Promise<void> {
+	const remove = deps.remove;
+	if (!remove) throw new Error("magus cannot remove plugins from here");
+	const name = pluginName(pluginId);
+	const here = scope.toUpperCase();
+
+	let wasListed = false;
+	if (scope === "project") {
+		wasListed = await profileListsPlugin(pluginId, projectPath, profile);
+		if (!(await remove.dropFromProfile(pluginId, projectPath, profile))) {
+			throw new Error(`${name} is still in the profile at ${here} scope`);
+		}
+		await recordInProfileOrExplain(
+			deps,
+			projectPath,
+			`${name} is no longer in the profile`,
+		);
+	}
+
+	if (!(await remove.isInstalled(pluginId, scope, projectPath))) return;
+	// The profile was changed above, so the refusal says so: the user must not
+	// find a plugin gone from the profile with nothing telling them why.
+	const lead = wasListed
+		? `${name} is no longer in the profile, but it is`
+		: `${name} is`;
+	const installedAt = installedScopeFromAnswer(answer);
+	if (installedAt && installedAt !== scope) {
+		const there = installedAt.toUpperCase();
+		throw new Error(
+			`${lead}${wasListed ? " still" : ""} installed at ${there} scope, not ${here} — remove it from ${there}`,
+		);
+	}
+	throw new Error(
+		`${lead} not installed at ${here} scope in this project — remove it from the scope that installed it`,
+	);
+}
+
+/**
+ * Whether `profile` lists the plugin, the profile picked as
+ * `removePluginFromProfile` picks it: undefined means the active one.
+ */
+async function profileListsPlugin(
+	pluginId: string,
+	projectPath: string,
+	profile: string | null | undefined,
+): Promise<boolean> {
+	const manifest = await readManifest(projectPath);
+	const id =
+		profile === undefined
+			? selectProfileId(
+					Object.keys(manifest.profiles),
+					undefined,
+					await activeProfile(projectPath),
+				)
+			: profile;
+	return id ? profileLists(manifest.profiles[id], pluginId) : false;
+}
+
 // -- binaries ----------------------------------------------------------------
 
 /**

package/src/tui-runtime.tsx

@@ -1,8 +1,8 @@
 /**
  * What every magus TUI shares before its first screen: the renderer, the one
  * shutdown owner, Ctrl+C, the OSC 52 copy of a mouse selection, and the light
- * or dark theme. `tui.tsx` (bare `magus`) and `market-tui.tsx` (bare
- * `magus market`) each hand `mountTui` the React tree they draw.
+ * or dark theme. `tui.tsx` (bare `magus`) and `market-tui.tsx` (`magus
+ * edit`) each hand `mountTui` the React tree they draw.
  *
  * Like those two, this module is only ever imported dynamically from
  * `main.tsx`, so nothing on a non-interactive path loads `@opentui/*`.

package/src/types/index.ts

@@ -55,6 +55,8 @@ export interface Marketplace {
 	 * marker and this machine trusts it. Listed above every other marketplace.
 	 */
 	company?: boolean;
+	/** `owner.name` from the marketplace's own manifest, when it names one. */
+	ownerName?: string;
 }
 
 export interface DiscoveredMarketplace {