magus-cli 0.0.0-placeholder → 7.1.0

package/src/ui/adapters/cliToolsAdapter.ts

@@ -0,0 +1,176 @@
+/**
+ * A CLI Tools row, built from the SAME probe facts and the SAME classifier
+ * `magus update` plans with.
+ *
+ * The screen used to carry its own probe — a shell `which`, `npm view` per
+ * tool, and a private comparator that read "1.2.3-beta" as "1.2.3" — so the
+ * row and the CLI could disagree about the same tool. Now the row's state is
+ * `classifyTool(spec, facts)`, and for a tool the active profile declares the
+ * spec IS the profile's (`specForCatalogTool`), so the two cannot differ.
+ *
+ * The same goes for the COMMANDS: a declared tool's row builds them with
+ * `binCommandForState`, the rule `magus update`'s apply path uses, so the
+ * row's target and the row's key can never aim at different versions.
+ *
+ * Pure: no IO, no React. The screen gathers facts; this only assembles.
+ */
+
+import type { CliTool } from "../../data/cli-tools.js";
+import {
+	cliToolInstall,
+	cliToolUpdate,
+} from "../../services/cli-tool-commands.js";
+import {
+	type InstallInfo,
+	type ToolFacts,
+	type ToolStatus,
+	classifyTool,
+} from "../../services/tool-probe.js";
+import { binCommandForState } from "../../services/toolchain.js";
+import type { BinRequirement, ResolvedBin } from "../../types/index.js";
+import type { Command } from "../../utils/command-utils.js";
+import type { StatusTone } from "../renderers/pluginStatusText.js";
+
+export interface CliToolRow {
+	tool: CliTool;
+	/** The requirement the tool was probed through (closure → detected → catalogue). */
+	spec: BinRequirement;
+	/** True until facts arrive. */
+	checking: boolean;
+	/** Null while checking. */
+	status: ToolStatus | null;
+	install?: InstallInfo;
+	/**
+	 * What Enter runs for an installed tool. For a tool the active profile
+	 * declares this is the SAME command `magus update` would run for the
+	 * same row (pin included); otherwise the DETECTED method's updater, so it
+	 * names the installer the row was probed through.
+	 */
+	updateCommand?: Command;
+	/** What Enter runs for a tool that is not installed. */
+	installCommand: Command;
+}
+
+/**
+ * Did this spec come from the resolver's closure — i.e. does the active profile
+ * declare this tool?
+ *
+ * `ResolvedBin` is `BinRequirement` plus `sources`, and only the resolver adds
+ * them, so the provenance travels with the spec itself rather than being
+ * re-derived here (which would be a second copy of `specForCatalogTool`'s
+ * branch 1, free to disagree with it).
+ */
+function declaredSpec(spec: BinRequirement): ResolvedBin | null {
+	const candidate = spec as ResolvedBin;
+	return Array.isArray(candidate.sources) ? candidate : null;
+}
+
+export function buildToolRow(
+	tool: CliTool,
+	spec: BinRequirement,
+	facts: ToolFacts | undefined,
+	install?: InstallInfo,
+): CliToolRow {
+	const declared = declaredSpec(spec);
+	// A declared tool installs at its pin, the way `magus update` does; the
+	// catalogue entry has no pin to honour.
+	const installCommand =
+		(declared && binCommandForState("install", null, declared)) ||
+		cliToolInstall(tool);
+	const base = { tool, spec, installCommand, ...(install ? { install } : {}) };
+	if (!facts) return { ...base, checking: true, status: null };
+	const status = classifyTool(spec, facts);
+	const updateCommand = updateCommandFor(tool, declared, status, install);
+	return {
+		...base,
+		checking: false,
+		status,
+		...(updateCommand ? { updateCommand } : {}),
+	};
+}
+
+/**
+ * The command the row's key runs, from the same rule as the row's state.
+ *
+ * A declared tool goes through `binCommandForState` — the CLI apply path's own
+ * builder over the PROFILE's requirement — so a row whose target is the pin
+ * installs the pin. Building `@latest` here (what this used to do, always) let
+ * the TUI overshoot a pin the CLI hits exactly, and the tool then classified
+ * `unknown / ahead-of-pin` for good: magus never downgrades.
+ *
+ * An undeclared catalogue tool keeps the screen's own rule, "follow how it IS
+ * installed": there is no pin to honour, and `pnpm`/`yarn` have no
+ * `BinInstaller` counterpart to hand the shared builder.
+ */
+function updateCommandFor(
+	tool: CliTool,
+	declared: ResolvedBin | null,
+	status: ToolStatus,
+	install: InstallInfo | undefined,
+): Command | undefined {
+	if (!isInstalled(status)) return undefined;
+	if (declared) {
+		return binCommandForState("upgrade", status.target, declared) ?? undefined;
+	}
+	if (!install) return undefined;
+	return cliToolUpdate(tool, install.primary, install.brewFormula) ?? undefined;
+}
+
+/** On PATH, as far as the probe could tell. */
+export function isInstalled(status: ToolStatus | null): boolean {
+	return status !== null && status.state !== "install";
+}
+
+/** A version for display, with exactly one leading "v". */
+export function displayVersion(v: string): string {
+	return `v${v.replace(/^v/i, "")}`;
+}
+
+export interface CliToolStatusText {
+	/** Text after the version, with its leading space; "" for nothing to say. */
+	suffix: string;
+	tone: StatusTone;
+}
+
+/**
+ * The row's status words. An `unknown` shows its note verbatim — the same
+ * string `magus update` prints for that tool.
+ */
+export function cliToolStatusText(row: CliToolRow): CliToolStatusText {
+	const { status } = row;
+	if (row.checking || !status) return { suffix: " ...", tone: "muted" };
+	switch (status.state) {
+		case "unknown":
+			return {
+				suffix: ` ? ${status.note ?? "cannot tell whether it is current"}`,
+				tone: "warning",
+			};
+		case "upgrade":
+			return {
+				suffix: status.target
+					? ` → ${displayVersion(status.target)}`
+					: " update available",
+				tone: "warning",
+			};
+		case "install":
+		case "current":
+			return { suffix: "", tone: "muted" };
+	}
+}
+
+/** Header counts, from the rows' states. */
+export function countToolRows(rows: readonly CliToolRow[]): {
+	installed: number;
+	updates: number;
+	unverified: number;
+} {
+	let installed = 0;
+	let updates = 0;
+	let unverified = 0;
+	for (const row of rows) {
+		if (isInstalled(row.status)) installed++;
+		if (row.status?.state === "upgrade") updates++;
+		if (row.status?.state === "unknown") unverified++;
+	}
+	return { installed, updates, unverified };
+}

package/src/ui/adapters/modelsAdapter.ts

@@ -0,0 +1,213 @@
+import {
+	BUILT_IN_PRESETS,
+	DEFAULT_PRESET,
+	presetLabel,
+} from "../../data/models-presets.js";
+import {
+	GRADES,
+	type ModelsConfig,
+	type ModelsState,
+	type ModelsStatus,
+	sameRouting,
+} from "../../services/models-core.js";
+
+// ─── Item types ───────────────────────────────────────────────────────────────
+
+/**
+ * The one header row: what is routed right now.
+ *
+ * Not selectable — the cursor skips it, the same way the Styles screen skips a
+ * category label. It carries only what the ROW draws; the drift lines and
+ * warnings behind the counts live on the `ModelsStatus` the detail renderer is
+ * handed, so they are not stored twice and cannot disagree.
+ */
+/**
+ * What the row for a diverged config is called.
+ *
+ * A fixed word, never the file's `preset` string: that string names whatever was last
+ * applied, and a config edited afterwards would wear a built-in's name while not being it.
+ */
+export const CUSTOM_LABEL = "Custom";
+
+export interface ModelsStatusItem {
+	id: string;
+	kind: "status";
+	label: string;
+	state: ModelsState;
+	/** The preset the project's config names, or null when there is none. */
+	preset: string | null;
+	driftCount: number;
+	warningCount: number;
+}
+
+export interface ModelsPresetItem {
+	id: string;
+	kind: "preset";
+	label: string;
+	config: ModelsConfig;
+	/** The routing this project's `models.json` names. */
+	active: boolean;
+	/** What `magus models use` picks when nothing else is chosen. */
+	isDefault: boolean;
+	/** Not one of the built-ins — this project's own, hand-edited config. */
+	custom: boolean;
+}
+
+export type ModelsBrowserItem = ModelsStatusItem | ModelsPresetItem;
+
+// ─── Adapter ──────────────────────────────────────────────────────────────────
+
+export interface BuildModelsItemsArgs {
+	/** What `readModelsStatus` reported, or null before the first read lands. */
+	status: ModelsStatus | null;
+	/** The validated config, or null when there is none (or it failed validation). */
+	config: ModelsConfig | null;
+	query: string;
+	/**
+	 * Presets to offer. Defaults to the shipped set, which is a compile-time
+	 * constant — so building the list still costs no I/O whatsoever.
+	 */
+	presets?: ModelsConfig[];
+}
+
+/**
+ * Does `config` answer to the filter?
+ *
+ * Matched over the preset name AND the models it names, because "sonnet" is the
+ * thing a user actually looks for — the preset names encode which model leads,
+ * not which models appear.
+ */
+function matches(config: ModelsConfig, lowerQuery: string): boolean {
+	if (!lowerQuery) return true;
+	// Both names are searchable: the row SHOWS "Opus with Fable help", and a user who knows
+	// the command types "fable-advisor". Matching only one of them makes the other look like
+	// a missing preset.
+	//
+	// Bound models are searchable too: a project that routes `smart` to `mate1` → `grok-4.6`
+	// is findable by typing `grok`, which is the name its author thinks in. The slot names
+	// come along with the grade models above, so both halves of the binding match.
+	const haystack = [
+		config.preset,
+		presetLabel(config.preset),
+		config.main.model,
+		...GRADES.map((grade) => config.grades[grade].model),
+		...Object.values(config.mates ?? {}).map((binding) => binding.model),
+	]
+		.join(" ")
+		.toLowerCase();
+	return haystack.includes(lowerQuery);
+}
+
+/**
+ * Build the flat list for the Models screen.
+ *
+ * One status header, then one row per preset in the order they ship. Nothing is
+ * grouped: there are four of them and a grade table each, so sections would cost
+ * rows and buy no navigation.
+ *
+ * The header is emitted only when at least one preset row survives the filter. A
+ * header with nothing under it reads as a result, and would leave the empty
+ * state — the one thing that says how to clear the filter — unreachable.
+ */
+export function buildModelsItems({
+	status,
+	config,
+	query,
+	presets = BUILT_IN_PRESETS,
+}: BuildModelsItemsArgs): ModelsBrowserItem[] {
+	if (!status) return [];
+
+	const lowerQuery = query.trim().toLowerCase();
+	const activeName = config?.preset ?? null;
+
+	// DOES THE PROJECT'S OWN CONFIG SAY SOMETHING NO BUILT-IN DOES?
+	//
+	// The test used to be "does it name a preset the built-ins do not", and that missed the
+	// ordinary case entirely. `magus models use opus-lead` writes `preset: "opus-lead"`,
+	// and hand-editing the file afterwards — adding a `mates` block, rebinding an agent —
+	// leaves that name untouched. So the config carrying the mate assignments matched a
+	// built-in by NAME, got no row of its own, and the list rendered the BUILT-IN's contents
+	// under the built-in's label.
+	//
+	// The consequence was not cosmetic: the only config on the machine that can name a mate
+	// was unreachable on screen, so neither the agent table nor the workflow bar could ever
+	// show one, no matter what the file said. `magus models list` printed it correctly the
+	// whole time, which is what made the gap look like a rendering bug rather than a missing
+	// row.
+	//
+	// Compared by CONTENT now, so a project that merely applied a preset still gets one row
+	// (its file and the built-in agree) and a project that changed anything gets two.
+	const builtInNamed = presets.find((preset) => preset.preset === activeName);
+	const projectOwn =
+		config && (!builtInNamed || !sameRouting(config, builtInNamed))
+			? config
+			: null;
+
+	const rows: ModelsPresetItem[] = presets
+		.filter((preset) => matches(preset, lowerQuery))
+		.map((preset) => ({
+			id: `preset:${preset.preset}`,
+			kind: "preset" as const,
+			label: presetLabel(preset.preset),
+			config: preset,
+			// `●` marks WHAT IS RUNNING, and when the project has diverged the built-in of
+			// that name is not it. Leaving the mark on both rows would say two different
+			// routings are simultaneously in force.
+			active: preset.preset === activeName && projectOwn === null,
+			isDefault: preset.preset === DEFAULT_PRESET,
+			custom: false,
+		}));
+
+	// A project whose settings differ from every built-in gets ONE row, called `Custom`.
+	//
+	// Divergence is a THING YOU HAVE, not a fault to warn about. A project can legitimately
+	// run models or efforts no preset ships, and the list's job is to show that as one more
+	// option carrying those settings — selectable, inspectable, with its own tier table and
+	// chart — rather than as a badge saying the config and the settings disagree.
+	//
+	// It is called `Custom` and never the string in the file's `preset` field. That string is
+	// whatever was last applied — `models use opus-lead` writes `opus-lead` and hand-editing
+	// afterwards leaves it — so showing it puts a built-in's name on a row that is not that
+	// built-in.
+	if (projectOwn && matches(projectOwn, lowerQuery)) {
+		rows.push({
+			// `project:` rather than `preset:`, because the name it carries may be a built-in's
+			// and two rows may not share an id.
+			id: `project:${projectOwn.preset}`,
+			kind: "preset",
+			label: CUSTOM_LABEL,
+			config: projectOwn,
+			active: true,
+			isDefault: false,
+			custom: true,
+		});
+	}
+
+	if (rows.length === 0) return [];
+
+	const header: ModelsStatusItem = {
+		id: "status",
+		kind: "status",
+		label: status.preset
+			? `Model tiers: ${status.state} · ${presetLabel(status.preset)}`
+			: `Model tiers: ${status.state}`,
+		state: status.state,
+		preset: status.preset,
+		driftCount: status.drift.length,
+		warningCount: status.warnings.length,
+	};
+
+	return [header, ...rows];
+}
+
+/**
+ * Index of the first row the user can actually land on, or 0 if none.
+ *
+ * The status row is a header, not a choice: every key this screen binds acts on
+ * a preset, so parking the cursor there would make `a` and Enter do nothing on
+ * the row the screen opens with.
+ */
+export function firstSelectableIndex(items: ModelsBrowserItem[]): number {
+	const index = items.findIndex((item) => item.kind !== "status");
+	return index >= 0 ? index : 0;
+}