magus-cli 0.0.0-placeholder → 7.1.0

package/src/opentui.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Type declarations for OpenTUI React
+ *
+ * These declarations extend OpenTUI's types to be compatible with React 19's
+ * more permissive return types. React 19 allows components to return ReactNode
+ * (which includes undefined), while OpenTUI's intrinsic elements expect
+ * ReactElement | null.
+ */
+
+import type { RGBA } from "@opentui/core";
+import type { ReactNode } from "react";
+
+/**
+ * What OpenTUI actually accepts for a colour: a CSS string OR an RGBA, which is
+ * how adaptive colours are expressed (RGBA.defaultForeground(), RGBA.fromIndex()).
+ * These declarations previously said `string`, which made the terminal-resolved
+ * forms a type error and quietly pushed every call site towards absolute hex.
+ */
+type ColorProp = string | RGBA;
+
+declare global {
+	namespace JSX {
+		interface IntrinsicElements {
+			box: BoxProps & { children?: ReactNode };
+			text: TextProps & { children?: ReactNode };
+			input: InputProps;
+			select: SelectProps;
+			"tab-select": TabSelectProps;
+			scrollbox: ScrollboxProps & { children?: ReactNode };
+			"ascii-font": AsciiFontProps;
+			code: CodeProps;
+			"line-number": LineNumberProps;
+			diff: DiffProps;
+			br: Record<string, never>;
+			strong: { children?: ReactNode };
+			em: { children?: ReactNode };
+			u: { children?: ReactNode };
+			dim: { children?: ReactNode };
+			a: { href?: string; children?: ReactNode };
+			span: { fg?: ColorProp; bg?: ColorProp; children?: ReactNode };
+		}
+	}
+}
+
+interface BaseBoxProps {
+	// Borders
+	border?: boolean;
+	borderStyle?: "single" | "double" | "rounded" | "bold";
+	borderColor?: ColorProp;
+	title?: string;
+	titleAlignment?: "left" | "center" | "right";
+
+	// Colors
+	backgroundColor?: ColorProp;
+
+	// Layout (Flexbox)
+	flexDirection?: "row" | "column";
+	justifyContent?:
+		| "flex-start"
+		| "flex-end"
+		| "center"
+		| "space-between"
+		| "space-around";
+	alignItems?: "flex-start" | "flex-end" | "center" | "stretch";
+	flexWrap?: "wrap" | "nowrap";
+	gap?: number;
+
+	// Spacing
+	padding?: number;
+	paddingTop?: number;
+	paddingBottom?: number;
+	paddingLeft?: number;
+	paddingRight?: number;
+	margin?: number;
+	marginTop?: number;
+	marginBottom?: number;
+	marginLeft?: number;
+	marginRight?: number;
+
+	// Dimensions
+	width?: number | `${number}%` | "auto";
+	height?: number | `${number}%` | "auto";
+	minWidth?: number;
+	minHeight?: number;
+	maxWidth?: number;
+	maxHeight?: number;
+	flexGrow?: number;
+	flexShrink?: number;
+	flexBasis?: number | `${number}%` | "auto";
+
+	// Overflow
+	overflow?: "hidden" | "visible";
+
+	// Events
+	onMouseDown?: (e: MouseEvent) => void;
+	onMouseUp?: (e: MouseEvent) => void;
+	onMouseMove?: (e: MouseEvent) => void;
+}
+
+interface BoxProps extends BaseBoxProps {
+	children?: ReactNode;
+}
+
+interface TextProps {
+	content?: string;
+	fg?: ColorProp;
+	bg?: ColorProp;
+	selectable?: boolean;
+	children?: ReactNode;
+}
+
+interface InputProps {
+	value?: string;
+	onChange?: (value: string) => void;
+	onInput?: (value: string) => void;
+	onSubmit?: ((value: string) => void) | undefined;
+	placeholder?: string;
+	focused?: boolean;
+	width?: number;
+	backgroundColor?: ColorProp;
+	textColor?: ColorProp;
+	cursorColor?: ColorProp;
+	focusedBackgroundColor?: ColorProp;
+}
+
+interface SelectOption {
+	name: string;
+	description?: string;
+	value?: string;
+}
+
+interface SelectProps {
+	options: SelectOption[];
+	onChange?: (index: number, option: SelectOption) => void;
+	onSelect?: (index: number, option: SelectOption) => void;
+	selectedIndex?: number;
+	focused?: boolean;
+	showScrollIndicator?: boolean;
+	height?: number;
+}
+
+interface TabSelectProps {
+	options: { name: string; description?: string }[];
+	onChange?: (index: number, option: { name: string }) => void;
+	tabWidth?: number;
+	focused?: boolean;
+}
+
+interface ScrollboxProps {
+	focused?: boolean;
+	height?: number | `${number}%` | "auto";
+	scrollY?: boolean;
+	scrollX?: boolean;
+	style?: {
+		rootOptions?: Record<string, unknown>;
+		wrapperOptions?: Record<string, unknown>;
+		viewportOptions?: Record<string, unknown>;
+		contentOptions?: Record<string, unknown>;
+		scrollbarOptions?: {
+			showArrows?: boolean;
+			trackOptions?: {
+				foregroundColor?: ColorProp;
+				backgroundColor?: ColorProp;
+			};
+		};
+	};
+	children?: ReactNode;
+}
+
+interface AsciiFontProps {
+	text: string;
+	font?: "tiny" | "block" | "slick" | "shade";
+	color?: ColorProp;
+}
+
+interface CodeProps {
+	code: string;
+	language?: string;
+	showLineNumbers?: boolean;
+	highlightLines?: number[];
+}
+
+interface LineNumberProps {
+	code: string;
+	language?: string;
+	startLine?: number;
+	highlightedLines?: number[];
+	diagnostics?: { line: number; severity: string; message: string }[];
+}
+
+interface DiffProps {
+	oldCode: string;
+	newCode: string;
+	language?: string;
+	mode?: "unified" | "split";
+	showLineNumbers?: boolean;
+}
+
+interface MouseEvent {
+	x: number;
+	y: number;
+	button: number;
+}

package/src/services/active-closure.ts

@@ -0,0 +1,117 @@
+/**
+ * Which profile is in effect for a project, and what it resolves to.
+ *
+ * `magus update` and the TUI must judge a plugin against the SAME pin, or
+ * the same plugin in the same project reads differently in each. They used to
+ * pick the profile in different ways — the CLI inline, the TUI not at all (it
+ * judged everything against "latest") — so an exact pin could never agree.
+ * Both now choose through {@link selectProfileId} over the same manifest and
+ * the same active-profile symlink.
+ *
+ * Read-only. Unlike the CLI's `ensureManifest`, nothing here bootstraps a
+ * manifest: a screen opening must never author a file a team commits.
+ *
+ * NOTHING HERE PRINTS — it runs under the CLI's live region and inside the TUI.
+ */
+
+import type {
+	BinRequirement,
+	ProfileManifest,
+	ResolvedClosure,
+} from "../types/index.js";
+import { readManifest, validateManifest } from "./manifest.js";
+import { resolveProfile } from "./resolver.js";
+import { activeProfile } from "./symlink-manager.js";
+
+/**
+ * The profile to use: the explicit one, else the active one, else the only one.
+ *
+ * Each candidate counts only if the manifest defines it. A stale active-profile
+ * symlink naming a profile that was since removed would otherwise be chosen and
+ * then fail to resolve, even when the manifest has exactly one profile and the
+ * answer is unambiguous.
+ */
+export function selectProfileId(
+	profileIds: readonly string[],
+	explicit: string | undefined,
+	active: string | null,
+): string | null {
+	if (explicit !== undefined && profileIds.includes(explicit)) return explicit;
+	if (active !== null && profileIds.includes(active)) return active;
+	if (profileIds.length === 1) return profileIds[0] ?? null;
+	return null;
+}
+
+export interface ActiveClosure {
+	profileId: string;
+	closure: ResolvedClosure;
+}
+
+export interface ActiveClosureDeps {
+	readManifest(projectPath: string): Promise<ProfileManifest>;
+	activeProfile(projectPath: string): Promise<string | null>;
+	resolveProfile(
+		manifest: ProfileManifest,
+		id: string,
+		opts?: {
+			binResolver?: (pluginId: string) => Promise<BinRequirement[]>;
+		},
+	): Promise<ResolvedClosure>;
+}
+
+const REAL_DEPS: ActiveClosureDeps = {
+	readManifest,
+	activeProfile,
+	resolveProfile,
+};
+
+export interface LoadActiveClosureOptions {
+	/**
+	 * false → `resolveProfile` gets a resolver that returns no requirements, so
+	 * no plugin's `plugin.json` is read and `closure.bins` holds only the
+	 * profile's own `cliTools` entries. Default true.
+	 *
+	 * The Plugins screen needs only `closure.plugins`. The default resolver
+	 * locates and reads every declared plugin's `plugin.json`, which is work the
+	 * screen would pay on every fetch for a field it never reads.
+	 */
+	resolveBins?: boolean;
+	deps?: Partial<ActiveClosureDeps>;
+}
+
+const NO_BINS = async (): Promise<BinRequirement[]> => [];
+
+/**
+ * The active profile's closure for a project.
+ *
+ * Null when there is no manifest, an invalid one, or no profile that can be
+ * selected without an explicit choice. Never throws: a caller that gets null
+ * judges against "latest" and says so, which is better than a screen that fails
+ * to load over a profile it only needed for pins.
+ */
+export async function loadActiveClosure(
+	projectPath: string,
+	opts: LoadActiveClosureOptions = {},
+): Promise<ActiveClosure | null> {
+	const deps: ActiveClosureDeps = { ...REAL_DEPS, ...opts.deps };
+	try {
+		const manifest = await deps.readManifest(projectPath);
+		if (validateManifest(manifest).length > 0) return null;
+
+		const profileId = selectProfileId(
+			Object.keys(manifest.profiles),
+			undefined,
+			await deps.activeProfile(projectPath),
+		);
+		if (profileId === null) return null;
+
+		const closure = await deps.resolveProfile(
+			manifest,
+			profileId,
+			opts.resolveBins === false ? { binResolver: NO_BINS } : {},
+		);
+		return { profileId, closure };
+	} catch {
+		return null;
+	}
+}

package/src/services/alias-settings.ts

@@ -0,0 +1,60 @@
+/**
+ * Read/write the managed-alias name in Claude Code's `settings.json`.
+ *
+ * The alias is computer-wide (one name per user), so it lives in
+ * `~/.claude/settings.json` only — no project scope. We store it under a
+ * `magus` namespace to avoid colliding with Claude Code's own keys:
+ *
+ *   {
+ *     "model": "sonnet",
+ *     "magus": {
+ *       "aliasName": "c"
+ *     }
+ *   }
+ *
+ * Flag values are NOT stored here. They live in the shell rc file's managed
+ * block and are read on screen mount via `parseAliasFromRc`.
+ */
+
+import { DEFAULT_ALIAS_NAME, validateAliasName } from "./alias-store.js";
+import { readGlobalSettings, writeGlobalSettings } from "./claude-settings.js";
+
+interface MagusSettings {
+	aliasName?: string;
+}
+
+interface SettingsWithMagus {
+	magus?: MagusSettings;
+	[key: string]: unknown;
+}
+
+/**
+ * Load the user's preferred alias name from `~/.claude/settings.json`.
+ * Returns the default `"c"` when the key is absent or invalid.
+ */
+export async function loadAliasName(): Promise<string> {
+	const settings = (await readGlobalSettings()) as SettingsWithMagus;
+	const stored = settings.magus?.aliasName;
+	if (typeof stored !== "string") return DEFAULT_ALIAS_NAME;
+	if (validateAliasName(stored) !== null) return DEFAULT_ALIAS_NAME;
+	return stored;
+}
+
+/**
+ * Save the alias name to `~/.claude/settings.json`, preserving all other
+ * keys (including unrelated Claude Code settings). No-op without throwing
+ * if the name fails validation — caller should validate first.
+ */
+export async function saveAliasName(name: string): Promise<void> {
+	if (validateAliasName(name) !== null) return;
+	const settings = (await readGlobalSettings()) as SettingsWithMagus;
+	const next: SettingsWithMagus = {
+		...settings,
+		magus: {
+			...(settings.magus ?? {}),
+			aliasName: name,
+		},
+	};
+	// claude-settings.writeGlobalSettings accepts the same shape we received.
+	await writeGlobalSettings(next as Parameters<typeof writeGlobalSettings>[0]);
+}