magus-cli 0.0.0-placeholder → 7.0.0

package/src/data/marketplaces.ts

@@ -0,0 +1,278 @@
+import type { LocalMarketplace } from "../services/local-marketplace.js";
+import type { Marketplace } from "../types/index.js";
+import { formatMarketplaceName } from "../utils/string-utils.js";
+
+/**
+ * Known repo aliases — GitHub redirects the old repo to the new one,
+ * so these should be treated as identical for deduplication.
+ */
+const REPO_ALIASES: Record<string, string> = {
+	"madappgang/claude-code": "madappgang/magus",
+};
+
+/** Normalize a repo string through known aliases. */
+function normalizeRepo(repo: string): string {
+	const lower = repo.toLowerCase();
+	return REPO_ALIASES[lower] || lower;
+}
+
+/**
+ * Deprecated marketplace names that should be hidden if the canonical
+ * marketplace is already present.  Maps deprecated name → canonical name.
+ */
+export const deprecatedMarketplaces: Record<string, string> = {
+	"mag-claude-plugins": "magus",
+	"MadAppGang-claude-code": "magus",
+	superpowers: "superpowers-marketplace",
+};
+
+export const defaultMarketplaces: Marketplace[] = [
+	{
+		name: "magus",
+		displayName: "Magus",
+		source: {
+			source: "github",
+			repo: "MadAppGang/magus",
+		},
+		description:
+			"Professional plugins for frontend, backend, and code analysis",
+		official: false,
+		featured: true, // Always show plugins (expanded by default)
+		owned: true, // Ours: always listed, sorted to the top
+	},
+	{
+		name: "magus-marketing",
+		displayName: "Magus Marketing",
+		source: {
+			source: "github",
+			repo: "MadAppGang/magus-marketing",
+		},
+		description: "AI image generation and video editing plugins",
+		official: false,
+		owned: true, // Ours: always listed even when uninstalled, sorted to the top
+		// Not featured: a niche channel, so keep it collapsed by default.
+	},
+	{
+		name: "magus-alpha",
+		displayName: "Magus Alpha",
+		source: {
+			source: "github",
+			repo: "MadAppGang/magus-alpha",
+		},
+		description:
+			"Experimental plugins with evolving interfaces — may change or be withdrawn without notice",
+		official: false,
+		owned: true, // Ours: always listed even when uninstalled, sorted to the top
+		// Not featured: experimental, so keep it collapsed by default.
+	},
+	{
+		name: "claude-plugins-official",
+		displayName: "Anthropic Official",
+		source: {
+			source: "github",
+			repo: "anthropics/claude-plugins-official",
+		},
+		description:
+			"Official Anthropic-managed directory of high quality Claude Code plugins",
+		official: true,
+	},
+	{
+		name: "superpowers-marketplace",
+		displayName: "Superpowers",
+		source: {
+			source: "github",
+			repo: "obra/superpowers-marketplace",
+		},
+		description: "Curated Claude Code plugins for skills and workflows",
+		featured: true,
+	},
+	// Community marketplaces. Each `name` MUST equal the upstream
+	// .claude-plugin/marketplace.json "name" field — plugin ids are built as
+	// `${plugin.name}@${marketplaceName}`, so a mismatch here breaks install
+	// with a "not found in marketplace" error rather than anything obvious.
+	//
+	// All carry `featured` because that is the only flag that makes a
+	// third-party marketplace visible: the gate in plugin-manager is
+	// `configured || official || featured || owned`, and an unflagged entry is
+	// just a name→repo mapping for auto-recovery. `official` means Anthropic
+	// and `owned` means MadAppGang, so neither applies.
+	{
+		name: "mattpocock",
+		displayName: "Matt Pocock",
+		source: {
+			source: "github",
+			repo: "mattpocock/skills",
+		},
+		description:
+			"Agent skills for real engineering — grilling, spec and ticket flows, TDD, code review, domain modelling",
+		featured: true,
+	},
+	{
+		name: "ecc",
+		displayName: "Everything Claude Code",
+		source: {
+			source: "github",
+			repo: "affaan-m/everything-claude-code",
+		},
+		description:
+			"Operator layer for agent harnesses — 68 agents, 286 skills, and command shims",
+		featured: true,
+	},
+	{
+		name: "ponytail",
+		displayName: "Ponytail",
+		source: {
+			source: "github",
+			repo: "DietrichGebert/ponytail",
+		},
+		description:
+			"Pushes the agent toward the smallest solution that works — YAGNI, and the standard library before custom code",
+		featured: true,
+	},
+	{
+		name: "addy-agent-skills",
+		displayName: "Addy Osmani Skills",
+		source: {
+			source: "github",
+			repo: "addyosmani/agent-skills",
+		},
+		description: "Production-grade engineering skills for AI coding agents",
+		featured: true,
+	},
+	{
+		name: "humanizer",
+		displayName: "Humanizer",
+		source: {
+			source: "github",
+			repo: "blader/humanizer",
+		},
+		description: "Removes signs of AI-generated writing from text",
+		featured: true,
+	},
+	{
+		name: "opendesign",
+		displayName: "OpenDesign",
+		source: {
+			source: "github",
+			repo: "manalkaff/opendesign",
+		},
+		description:
+			"Designs and redesigns frontend UI and marketing graphics, routing to specialist skills per artifact type",
+		featured: true,
+	},
+	// A community port, deliberately, because the original cannot be installed.
+	// pstack is published by Cursor in cursor/plugins, whose manifests all live
+	// under `.cursor-plugin/` — measured over the whole tree: 61 `.cursor-plugin`
+	// files, 0 `.claude-plugin` files. Claude Code reads
+	// `.claude-plugin/marketplace.json` only, so `claude plugin marketplace add
+	// cursor/plugins` cannot resolve it. Same reason github/spec-kit is absent.
+	//
+	// Of the ports that relocate the manifest, this is the most starred: 95
+	// against pstack-claude's 94. backnotprop/pstack has more (140) but carries
+	// no Claude manifest either, and peadar/pstack (261) is an unrelated C
+	// stack-trace tool.
+	{
+		name: "open-pstack",
+		displayName: "pstack",
+		source: {
+			source: "github",
+			repo: "ericlitman/open-pstack",
+		},
+		description:
+			"Rigorous, parallelizable agent workflows that favour going deep before going fast. Community port of Cursor's pstack",
+		featured: true,
+	},
+	{
+		name: "claude-code-plugins",
+		displayName: "Anthropic Deprecated",
+		source: {
+			source: "github",
+			repo: "anthropics/claude-code",
+		},
+		description:
+			"Legacy demo plugins from Anthropic (deprecated - use Official instead)",
+		official: true,
+		deprecated: true,
+	},
+];
+
+export function getMarketplaceByName(name: string): Marketplace | undefined {
+	return defaultMarketplaces.find((m) => m.name === name);
+}
+
+// Get all available marketplaces from local cache + hardcoded defaults
+// Local cache is primary source of truth, defaults are fallback
+// Deduplicates by normalized repo URL to avoid showing same marketplace twice
+export function getAllMarketplaces(
+	localMarketplaces?: Map<string, LocalMarketplace>,
+): Marketplace[] {
+	const all = new Map<string, Marketplace>();
+	const seenRepos = new Set<string>();
+
+	// Primary source: local cache (what's actually cloned)
+	if (localMarketplaces) {
+		for (const [name, local] of localMarketplaces) {
+			const repo = normalizeRepo(local.gitRepo || "");
+
+			// Skip deprecated marketplaces if their canonical replacement exists
+			// (or will be added from defaults)
+			const canonical = deprecatedMarketplaces[name];
+			if (canonical) {
+				// If canonical already in the map or in defaults, skip this entry
+				if (
+					all.has(canonical) ||
+					defaultMarketplaces.some((m) => m.name === canonical)
+				) {
+					continue;
+				}
+			}
+
+			// Skip if another marketplace already claimed this repo URL
+			if (repo && seenRepos.has(repo)) continue;
+			if (repo) seenRepos.add(repo);
+
+			// Check if this marketplace has defaults (for official/featured flags)
+			const defaultMp = defaultMarketplaces.find((m) => m.name === name);
+
+			all.set(name, {
+				name,
+				// Prefer default displayName over stale local clone data
+				displayName:
+					defaultMp?.displayName || local.name || formatMarketplaceName(name),
+				source: {
+					source: "github" as const,
+					repo: defaultMp?.source.repo || local.gitRepo || "",
+				},
+				description: defaultMp?.description || local.description || "",
+				official:
+					defaultMp?.official ?? repo.toLowerCase().includes("anthropics/"),
+				featured: defaultMp?.featured,
+				deprecated: defaultMp?.deprecated,
+				owned: defaultMp?.owned,
+			});
+		}
+	}
+
+	// Fallback: hardcoded defaults (only if their repo isn't already represented)
+	for (const mp of defaultMarketplaces) {
+		const repo = normalizeRepo(mp.source.repo || "");
+		if (!all.has(mp.name) && !seenRepos.has(repo)) {
+			all.set(mp.name, mp);
+			if (repo) seenRepos.add(repo);
+		}
+	}
+
+	// Sort: Magus first, deprecated last, then alphabetically
+	return Array.from(all.values()).sort((a, b) => {
+		// Magus (MadAppGang) always first
+		const aIsMag = a.source.repo?.toLowerCase().includes("madappgang/");
+		const bIsMag = b.source.repo?.toLowerCase().includes("madappgang/");
+		if (aIsMag && !bIsMag) return -1;
+		if (!aIsMag && bIsMag) return 1;
+		// Deprecated entries always last
+		if (a.deprecated && !b.deprecated) return 1;
+		if (!a.deprecated && b.deprecated) return -1;
+		// Then alphabetically by display name
+		return (a.displayName || a.name).localeCompare(b.displayName || b.name);
+	});
+}

package/src/data/mcp-servers.ts

@@ -0,0 +1,51 @@
+import type { McpServer } from "../types/index.js";
+
+export function getMcpServersByCategory(
+	servers: McpServer[],
+): Record<string, McpServer[]> {
+	const categories: Record<string, McpServer[]> = {};
+	for (const server of servers) {
+		if (!categories[server.category]) categories[server.category] = [];
+		categories[server.category].push(server);
+	}
+	return categories;
+}
+
+export const categoryOrder = [
+	"browser",
+	"ai",
+	"design",
+	"dev-tools",
+	"cloud",
+	"database",
+	"seo",
+	"productivity",
+];
+
+export function getCategoryDisplayName(category: string): string {
+	const names: Record<string, string> = {
+		browser: "Browser & Automation",
+		ai: "AI & Search",
+		design: "Design & Creative",
+		"dev-tools": "Developer Tools",
+		cloud: "Cloud & Infrastructure",
+		database: "Database",
+		seo: "SEO & Analytics",
+		productivity: "Productivity",
+	};
+	return names[category] || category;
+}
+
+export function getCategoryIcon(category: string): string {
+	const icons: Record<string, string> = {
+		browser: "🌐",
+		ai: "🤖",
+		design: "🎨",
+		"dev-tools": "🛠️",
+		cloud: "☁️",
+		database: "🗄️",
+		seo: "📈",
+		productivity: "📋",
+	};
+	return icons[category] || "📦";
+}

package/src/data/models-presets.ts

@@ -0,0 +1,329 @@
+/**
+ * Built-in presets and the shared agent → tier table.
+ *
+ * Hand-written constants rather than a glob over data files, for the same reason
+ * `src/data/styles/index.ts` hand-lists its embedded presets: a glob cannot resolve at
+ * `bun build --compile` time, and this module has to survive into the compiled binary — the
+ * hook path reads a project's own `models.json`, but `magus models list` and the TUI read
+ * these.
+ *
+ * Tiers name what a subagent is FOR, on one axis: `smart`, `normal`, `cheap`, plus `main` for
+ * the orchestrator. Which model serves each is the PRESET's call, and `smart` is not always
+ * its largest spend: `fable-advisor` sends the judgement calls to a different model (fable at
+ * `medium`) rather than a harder-working one. What holds everywhere is the other half: the
+ * thread dispatching the work is never strictly the biggest spend in the preset.
+ */
+import type { Effort, Grade, ModelsConfig } from "../services/models-core.js";
+
+/**
+ * Which tier each subagent gets, shared by every preset.
+ *
+ * Keys are `subagent_type` strings exactly as the Agent tool receives them: bare names for
+ * Claude Code's built-ins, `plugin:name` for plugin agents. A name absent from this table
+ * falls to the preset's `fallback`, so a newly installed plugin routes sensibly on day one
+ * instead of silently inheriting the orchestrator's model.
+ */
+export const DEFAULT_AGENT_GRADES: Record<string, Grade> = {
+	// `smart` is for JUDGEMENT — work where the agent decides something a person would
+	// argue about, and where being wrong is expensive to undo.
+	Plan: "smart",
+	"dev:architect": "smart",
+	"dev:reviewer": "smart",
+	"dev:debugger": "smart",
+	"multimodel:deep-analyst": "smart",
+
+	// `normal`: transforms material it is GIVEN. Real work, bounded judgement.
+	//
+	// `spec-writer` reads an interview log and writes it up as a spec — the decisions were
+	// made during the interview, and this turns answers into structure. `synthesizer` merges
+	// reviews it is handed into one report against thresholds it is handed. Neither decides
+	// what is true; both were on `smart` because "writes an important document" got confused
+	// with "makes an expensive judgement".
+	"dev:spec-writer": "normal",
+	"dev:aggregator": "normal",
+
+	// Reading a lot is not analysing.
+	//
+	// `analyze` is read-only: it locates implementations, traces a path and reports
+	// file:line. That is high-volume retrieval with light inference — the same shape as
+	// `Explore`, with more structure in the output. It sat on `smart` because "investigates"
+	// sounds like thinking; what it actually does is look.
+	"code-search:analyze": "cheap",
+
+	// Search and bookkeeping: bounded, mechanical, high-volume.
+	Explore: "cheap",
+	"dev:stack-detector": "cheap",
+	"dev:docs": "cheap",
+	"terminal:tui-navigator": "cheap",
+	"statusline-setup": "cheap",
+};
+
+/**
+ * The three workflows the `dev` plugin actually runs, and the agents each one dispatches.
+ *
+ * A single "17 agents" bar counts every agent magus has ever heard of, weighted equally —
+ * which is not how a session spends anything. Nobody runs all seventeen; they run ONE of
+ * these, and what it costs depends on which handful it reaches for. `/dev:investigate`
+ * touching two cheap agents and `/dev:dev` touching five across three tiers are different
+ * answers to "what will this preset cost me", and the lump sum shows neither.
+ *
+ * Read out of `plugins/dev/commands/{dev,debug,investigate}.md` — agents only. Those files
+ * also name skills (`dev:context-detection`, `code-search:investigate`) which are not
+ * dispatched through the Agent tool and so are not routed at all.
+ *
+ * ## `external` — the steps that leave Claude Code, whatever the preset says
+ *
+ * A workflow's use of an outside model is a property of the WORKFLOW, not of the routing
+ * config. `/dev:dev` runs a multi-model plan review at Phase 3 and a multi-model code review
+ * at Phase 5 because its command file says so, and switching from `Sonnet` to `Opus main`
+ * does not change that. So these steps are declared here beside the agents and are drawn
+ * under every preset, rather than being read out of `config.agents` — where they would
+ * appear only for a project that happened to have hand-bound a slot.
+ *
+ * Read out of the same command files:
+ *   `plugins/dev/commands/dev.md:138`  Plan review (external models via claudish) → dev:architect
+ *   `plugins/dev/commands/dev.md:140`  Code review (external models via claudish) → dev:architect
+ *
+ * `debug.md` and `investigate.md` contain no claudish reference at all, so both are empty
+ * here — and that absence is worth drawing, because "this flow stays inside Claude Code" is
+ * exactly as useful to know as the opposite.
+ *
+ * A STEP, not an agent: `dev:architect` appears in `agents` above as well, because the same
+ * agent does the Phase 3 planning on a Claude model. Marking the agent external would be
+ * wrong in both directions — it would move the planning outside and merge the two reviews
+ * into it.
+ */
+export interface WorkflowStep {
+	/** What the phase is called in the command file, for the reader who goes looking. */
+	step: string;
+	/** The agent the step dispatches. Recorded for provenance; routing is claudish's. */
+	agent: string;
+}
+
+export interface Workflow {
+	name: string;
+	agents: string[];
+	external: WorkflowStep[];
+}
+
+export const WORKFLOWS: Workflow[] = [
+	{
+		name: "dev",
+		agents: [
+			"dev:stack-detector",
+			"dev:architect",
+			"dev:developer",
+			"dev:qa-engineer",
+			"dev:reviewer",
+		],
+		external: [
+			{ step: "plan review", agent: "dev:architect" },
+			{ step: "code review", agent: "dev:architect" },
+		],
+	},
+	{
+		name: "debug",
+		agents: [
+			"dev:stack-detector",
+			"code-search:analyze",
+			"dev:debugger",
+			"dev:developer",
+		],
+		external: [],
+	},
+	{
+		name: "investigate",
+		agents: ["code-search:analyze", "dev:researcher"],
+		external: [],
+	},
+];
+
+/**
+ * Agents whose model is a CAPABILITY choice, not a spend choice.
+ *
+ * The three tiers answer "how much model", and that is the wrong question for an agent that
+ * reads images. `designer:review` compares a rendered screen against a reference and
+ * `designer:ui` audits a screenshot for usability: what they need is the model that SEES
+ * best, which is not a point on a cheap-to-smart line and does not move when the preset
+ * changes.
+ *
+ * They are deliberately absent from the tier table above and from this map until the model
+ * is chosen from the live catalogue rather than from memory. Absent means they fall to the
+ * preset's `fallback`, which is a defensible default and an honest one; pinning them to a
+ * model id guessed here is neither.
+ */
+export const VISION_AGENTS = ["designer:review", "designer:ui"] as const;
+
+/**
+ * The effort the external slots run at, per preset.
+ *
+ * A preset cannot say WHICH model serves a mate — a catalogue id shipped in this repo goes
+ * stale, which is the whole reason bindings live in a project's own `mates` block. It can say
+ * how hard that work should try, and that half does not depend on which model answers.
+ *
+ * `xhigh` almost everywhere: a slot is reached for the judgement calls — plan review, code
+ * review — and those are the calls worth spending on whichever model takes them. `Sonnet` is
+ * the exception because it is the economy preset, and a preset whose whole point is to spend
+ * less would be lying if the work it sent outside ignored that.
+ */
+const MATE_EFFORT_DEFAULT: Effort = "xhigh";
+
+function preset(
+	name: string,
+	main: ModelsConfig["main"],
+	grades: ModelsConfig["grades"],
+	mateEffort: Effort = MATE_EFFORT_DEFAULT,
+): ModelsConfig {
+	return {
+		version: 1,
+		preset: name,
+		main,
+		grades,
+		agents: { ...DEFAULT_AGENT_GRADES },
+		fallback: "normal",
+		mateEffort,
+	};
+}
+
+/**
+ * What each preset is CALLED on screen.
+ *
+ * The id (`fable-advisor`) is the machine name: it is what `models use` takes, what lands in
+ * the committed config, and what must never change. The label is what a person reads, and it
+ * says which model leads and which one helps — the thing you actually choose between. Kept
+ * beside the presets rather than in the UI so the CLI and the TUI cannot disagree.
+ */
+export const PRESET_LABELS: Record<string, string> = {
+	"fable-advisor": "Opus with Fable help",
+	"fable-lead": "Fable main",
+	"fable-top": "Fable top",
+	"opus-lead": "Opus main",
+	"sonnet-economy": "Sonnet",
+};
+
+/** The screen name for a preset id, falling back to the id for a hand-edited config. */
+export function presetLabel(id: string): string {
+	return PRESET_LABELS[id] ?? id;
+}
+
+/**
+ * The shipped presets.
+ *
+ * Effort is set per seat and reaches subagents through `modelSettings` — measured by
+ * `benches/agent-model-routing/` (AMR-1), which found alias keys honoured and a routed
+ * subagent running at its model's effort while the main thread kept its own.
+ *
+ * ## Effort belongs to the MODEL, so a preset gets one value per model
+ *
+ * `modelSettings` is keyed by model. Two seats naming the same model therefore cannot carry
+ * different efforts, and the validator rejects that rather than letting one silently win.
+ * That is the only cross-seat rule here: **within one preset, a model appears at exactly one
+ * effort.** Which effort is a per-preset choice — `fable-lead` runs fable at `medium` and
+ * `fable-top` runs it at `xhigh`, and that difference is the whole distinction between them.
+ *
+ * Presets never collide with each other, because only one is ever applied to a project.
+ *
+ * ## The levelling these presets apply
+ *
+ * Each one fixes every model it names at a single effort, which is what makes it writable:
+ *
+ *   opus      xhigh wherever it appears
+ *   fable     medium in `fable-lead`, xhigh in `fable-top`
+ *   sonnet    high in the `cheap` seat, xhigh when it holds the whole preset
+ *   haiku     not used
+ *
+ * A tier therefore differs from its neighbour by MODEL, not by a throttle on one model. That
+ * is not a style choice: a ramp like "fable xhigh on `smart`, fable low on `cheap`" is exactly
+ * what the `modelSettings` keying cannot express.
+ */
+export const BUILT_IN_PRESETS: ModelsConfig[] = [
+	// The default: opus runs everything except the judgement calls, which go to fable.
+	//
+	// Opus takes `main` and `normal` at `xhigh`, fable takes `smart` at its ordinary `medium`,
+	// and sonnet picks up the cheap seat at `high`. The id says what fable DOES here — it
+	// advises on the hard work rather than running the thread.
+	preset(
+		"fable-advisor",
+		{ model: "opus", effort: "xhigh" },
+		{
+			smart: { model: "fable", effort: "medium" },
+			normal: { model: "opus", effort: "xhigh" },
+			cheap: { model: "sonnet", effort: "high" },
+		},
+	),
+
+	// Fable runs everything it can, at its ordinary `medium`, with sonnet on the cheap seat.
+	//
+	// "Fable on the main orchestrator" — the request, literally, extended to the tiers it
+	// dispatches. Paired with `fable-top` below: the same model on `main` and `smart`, one
+	// effort apart.
+	preset(
+		"fable-lead",
+		{ model: "fable", effort: "medium" },
+		{
+			smart: { model: "fable", effort: "medium" },
+			normal: { model: "fable", effort: "medium" },
+			cheap: { model: "sonnet", effort: "high" },
+		},
+	),
+
+	// Fable at full stretch on the thread and the judgement calls; opus does the building.
+	//
+	// `fable-lead` runs fable at `medium` in three seats; this runs it at `xhigh` in two and
+	// hands `normal` — the highest-volume tier, since it is also the `fallback` — to opus.
+	// The difference between the two presets is fable's effort, which is why it has to BE two
+	// presets rather than one with a ramp.
+	preset(
+		"fable-top",
+		{ model: "fable", effort: "xhigh" },
+		{
+			smart: { model: "fable", effort: "xhigh" },
+			normal: { model: "opus", effort: "xhigh" },
+			cheap: { model: "sonnet", effort: "high" },
+		},
+	),
+
+	// Opus everywhere it is reached at all, at `xhigh`; sonnet only on the cheap seat.
+	//
+	// `main`, `smart` and `normal` are one spend decision wearing three names. That is legal
+	// precisely because they agree on effort, and it is the point of the preset rather than a
+	// compromise: the only thing NOT on opus is the searching and transcription.
+	preset(
+		"opus-lead",
+		{ model: "opus", effort: "xhigh" },
+		{
+			smart: { model: "opus", effort: "xhigh" },
+			normal: { model: "opus", effort: "xhigh" },
+			cheap: { model: "sonnet", effort: "high" },
+		},
+	),
+
+	// Sonnet, at `xhigh`, in all four seats.
+	//
+	// This preset deliberately has no tier differentiation: its saving is the model, and the
+	// effort is not throttled on top of it. Every routed agent runs sonnet at `xhigh`,
+	// including `cheap` — so the hook still pins the model (a session started on opus does
+	// not leak into its subagents) while the tier table itself makes no distinction.
+	// The one preset whose mates run at `medium` rather than `xhigh`: an economy preset that
+	// spent freely the moment work left Claude Code would not be one.
+	preset(
+		"sonnet-economy",
+		{ model: "sonnet", effort: "xhigh" },
+		{
+			smart: { model: "sonnet", effort: "xhigh" },
+			normal: { model: "sonnet", effort: "xhigh" },
+			cheap: { model: "sonnet", effort: "xhigh" },
+		},
+		"medium",
+	),
+];
+
+export const DEFAULT_PRESET = "fable-advisor";
+
+export function findPreset(name: string): ModelsConfig | undefined {
+	return BUILT_IN_PRESETS.find((p) => p.preset === name);
+}
+
+export function presetNames(): string[] {
+	return BUILT_IN_PRESETS.map((p) => p.preset);
+}