magus-cli 7.4.0 → 7.5.0

package/README.md

@@ -43,7 +43,6 @@ install [profile]           Install a profile's plugins, binaries, skills and
                             it. No argument = every profile.
   --check                   Report drift only, write nothing (CI gate)
   --yes, -y                 Skip the confirmation prompt
-  --force                   Discard unsynced local edits instead of refusing
 update [profile]            Bring the ACTIVE profile up to date: install what it
                             declares but this machine lacks, and advance every
                             "latest" pin to the newest published version.
@@ -52,10 +51,10 @@ update [profile]            Bring the ACTIVE profile up to date: install what it
   --yes, -y                 Skip the confirmation prompt
 profile list                Show every profile; ● marks the active one
 profile show <name>         Print a profile's fully resolved closure
-profile switch <name>       Repoint the active profile — offline, no reinstall
+profile switch <name>       Make <name> active: render its settings.json,
+                            .mcp.json and models.json, install its skills
 profile init                Write .claude/profiles.json from this project's setup
-profile sync                Promote local edits back into .claude/profiles.json
-doctor [--fix]              Check binary deps, profile symlinks, conventions
+doctor [--fix]              Check binary deps, the active profile, conventions
 
 claude [args...]            Check for plugin updates (1h cache), then run claude
   --force, -f               Force the update check
@@ -248,13 +247,15 @@ written. `force-for-plugin` is never set either — that would override your own
 
 | Path | Owner | What magus does |
 |---|---|---|
-| `.claude/profiles.json` | you, committed | reads it; `profile sync` writes to it |
-| `.claude/_profiles/<name>/` | magus, gitignored | generated build output |
-| `.claude/settings.json` | Claude Code | in profile mode, a symlink into `_profiles/` |
+| `.claude/profiles.json` | you, committed | the one source of truth; records every change to the live config |
+| `.claude/profiles/active.json` | magus, gitignored | which profile is active, and what magus last wrote |
+| `.claude/settings.json` | magus + Claude Code, gitignored | in profile mode, rendered from the active profile; Claude Code's edits are recorded back into it |
+| `.claude/models.json` | magus, gitignored | in profile mode, rendered from the active profile's routing |
+| `.claude/skills/<name>/` | magus or you | a skill the active profile lists is installed and gitignored by magus; any other folder is yours and is never touched |
 | `.claude/settings.local.json` | you, gitignored | env values collected during install |
 | `.claude/style.json` | you, committed | the project's declared style — written on apply |
 | `.claude/output-styles/composed*.md` | magus, committed | the generated style Claude Code reads |
-| `.mcp.json` | Claude Code | in profile mode, a symlink into `_profiles/` |
+| `.mcp.json` | magus + Claude Code, gitignored | in profile mode, rendered from the active profile; Claude Code's edits are recorded back into it |
 | `~/.claude/plugins/*` | Claude Code | never written directly — always via the `claude` CLI |
 
 magus never hand-edits Claude Code's own registries

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magus-cli",
-  "version": "7.4.0",
+  "version": "7.5.0",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -64,8 +64,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "magus-cli-darwin-arm64": "7.4.0",
-    "magus-cli-darwin-x64": "7.4.0",
-    "magus-cli-linux-x64": "7.4.0"
+    "magus-cli-darwin-arm64": "7.5.0",
+    "magus-cli-darwin-x64": "7.5.0",
+    "magus-cli-linux-x64": "7.5.0"
   }
 }

package/src/__tests__/blind/c19-paste-routing.test.ts

@@ -0,0 +1,252 @@
+/**
+ * Blind tests — contract C19 (requirement R4.9).
+ *
+ * Written from requirements.md and architecture.md only. A terminal delivers a
+ * paste as ONE event, not as keys, and C19 routes that event through the same
+ * layer order as a keypress. The layers here are stubs that record every
+ * handlePaste() call and the exact text each one received, so "a lower layer
+ * never sees the text" and "the text is passed through unchanged" are observed
+ * directly rather than inferred.
+ */
+import { describe, expect, test } from "bun:test";
+
+const load = () => import("../../ui/input/key-dispatch.js");
+
+type LayerId = "system" | "modal" | "input" | "screen" | "scroll" | "global";
+
+const ORDER: LayerId[] = [
+	"system",
+	"modal",
+	"input",
+	"screen",
+	"scroll",
+	"global",
+];
+
+interface Recorder {
+	/** Layer ids in the order their handlePaste() was called. */
+	calls: LayerId[];
+	/** Every (layer, text) pair a handler actually received. */
+	seen: { id: LayerId; text: string }[];
+	layers: {
+		id: LayerId;
+		active: boolean;
+		handlePaste(text: string): boolean;
+	}[];
+}
+
+/** Build one paste layer per id. `consumes[id]` decides; absent means "never consumes". */
+function stack(
+	consumes: Partial<Record<LayerId, (text: string) => boolean>>,
+	active: Partial<Record<LayerId, boolean>> = {},
+	order: LayerId[] = ORDER,
+): Recorder {
+	const calls: LayerId[] = [];
+	const seen: { id: LayerId; text: string }[] = [];
+	const layers = order.map((id) => ({
+		id,
+		active: active[id] ?? true,
+		handlePaste(text: string): boolean {
+			calls.push(id);
+			seen.push({ id, text });
+			return consumes[id]?.(text) ?? false;
+		},
+	}));
+	return { calls, seen, layers };
+}
+
+const all = () => true;
+const TEXT = "pasted search term";
+
+describe("C19 — dispatchPaste: layer order", () => {
+	test("R4.9 a paste is offered to layers in LAYER_ORDER regardless of array order", async () => {
+		const { dispatchPaste, LAYER_ORDER } = await load();
+		expect([...LAYER_ORDER]).toEqual(ORDER);
+
+		const shuffled: LayerId[] = [
+			"global",
+			"screen",
+			"system",
+			"scroll",
+			"input",
+			"modal",
+		];
+		const r = stack({}, {}, shuffled);
+		expect(dispatchPaste(r.layers, TEXT)).toBeNull();
+		expect(r.calls).toEqual(ORDER);
+	});
+
+	test("R4.9 with every layer consuming in reversed array order, the topmost layer wins alone", async () => {
+		const { dispatchPaste } = await load();
+		const r = stack(
+			{
+				system: all,
+				modal: all,
+				input: all,
+				screen: all,
+				scroll: all,
+				global: all,
+			},
+			{},
+			[...ORDER].reverse(),
+		);
+		expect(dispatchPaste(r.layers, TEXT)).toBe("system");
+		expect(r.calls).toEqual(["system"]);
+	});
+
+	for (const [i, consumer] of ORDER.entries()) {
+		test(`R4.9 when ${consumer} consumes, dispatchPaste returns "${consumer}" and no lower layer sees the text`, async () => {
+			const { dispatchPaste } = await load();
+			// Every layer from the consumer down would also consume — only order decides.
+			const consumes: Partial<Record<LayerId, (text: string) => boolean>> = {};
+			for (const id of ORDER.slice(i)) consumes[id] = all;
+			const r = stack(consumes);
+			expect(dispatchPaste(r.layers, TEXT)).toBe(consumer);
+			expect(r.calls).toEqual(ORDER.slice(0, i + 1));
+			expect(r.seen.map((s) => s.id)).toEqual(ORDER.slice(0, i + 1));
+		});
+	}
+
+	test("R4.9 inactive layers are skipped: their handlePaste() is never called", async () => {
+		const { dispatchPaste } = await load();
+		const r = stack(
+			{ modal: all, input: all, global: all },
+			{ modal: false, input: false },
+		);
+		expect(dispatchPaste(r.layers, TEXT)).toBe("global");
+		expect(r.calls).toEqual(["system", "screen", "scroll", "global"]);
+	});
+
+	test("R4.9 an inactive consumer does not stop the paste: the next active consumer wins", async () => {
+		const { dispatchPaste } = await load();
+		const r = stack({ input: all, screen: all }, { input: false });
+		expect(dispatchPaste(r.layers, TEXT)).toBe("screen");
+		expect(r.calls).toEqual(["system", "modal", "screen"]);
+	});
+
+	test("R4.9 dispatchPaste returns null when no layer consumes, calling each active layer once", async () => {
+		const { dispatchPaste } = await load();
+		const r = stack({});
+		expect(dispatchPaste(r.layers, TEXT)).toBeNull();
+		expect(r.calls).toEqual(ORDER);
+	});
+
+	test("R4.9 missing layers are fine: a stack of only screen and global", async () => {
+		const { dispatchPaste } = await load();
+		const r = stack({ global: all }, {}, ["global", "screen"]);
+		expect(dispatchPaste(r.layers, TEXT)).toBe("global");
+		expect(r.calls).toEqual(["screen", "global"]);
+	});
+
+	test("R4.9 an empty layer list consumes nothing", async () => {
+		const { dispatchPaste } = await load();
+		expect(dispatchPaste([], TEXT)).toBeNull();
+	});
+});
+
+describe("C19 — dispatchPaste: a focused search box takes the paste", () => {
+	test("R4.9 a focused input consumes the paste and the screen below never sees the text", async () => {
+		const { dispatchPaste } = await load();
+		const typed: string[] = [];
+		const r = stack({
+			input: (text) => {
+				typed.push(text);
+				return true;
+			},
+			screen: all,
+			global: all,
+		});
+		expect(dispatchPaste(r.layers, TEXT)).toBe("input");
+		expect(typed).toEqual([TEXT]);
+		expect(r.calls).toEqual(["system", "modal", "input"]);
+		expect(r.seen.some((s) => s.id === "screen")).toBe(false);
+		expect(r.seen.some((s) => s.id === "global")).toBe(false);
+	});
+
+	test("R4.9 with no active input layer, the paste reaches the lower layers in order", async () => {
+		const { dispatchPaste } = await load();
+		const r = stack({ input: all }, { input: false });
+		expect(dispatchPaste(r.layers, TEXT)).toBeNull();
+		expect(r.calls).toEqual(["system", "modal", "screen", "scroll", "global"]);
+		expect(r.seen.every((s) => s.text === TEXT)).toBe(true);
+	});
+
+	test("R4.9 with no input layer in the stack at all, nothing consumes the paste", async () => {
+		const { dispatchPaste } = await load();
+		const r = stack({}, {}, ["system", "modal", "screen", "scroll", "global"]);
+		expect(dispatchPaste(r.layers, TEXT)).toBeNull();
+		expect(r.calls).toEqual(["system", "modal", "screen", "scroll", "global"]);
+	});
+
+	test("R4.9 a modal above the input takes the paste first", async () => {
+		const { dispatchPaste } = await load();
+		const r = stack({ modal: all, input: all });
+		expect(dispatchPaste(r.layers, TEXT)).toBe("modal");
+		expect(r.calls).toEqual(["system", "modal"]);
+	});
+});
+
+describe("C19 — dispatchPaste: empty text", () => {
+	test("R4.9 empty text consumes nothing and returns null", async () => {
+		const { dispatchPaste } = await load();
+		const r = stack({
+			system: all,
+			modal: all,
+			input: all,
+			screen: all,
+			scroll: all,
+			global: all,
+		});
+		expect(dispatchPaste(r.layers, "")).toBeNull();
+	});
+
+	test("R4.9 empty text calls no handler, not even a focused input", async () => {
+		const { dispatchPaste } = await load();
+		const r = stack({ input: all });
+		dispatchPaste(r.layers, "");
+		expect(r.calls).toEqual([]);
+		expect(r.seen).toEqual([]);
+	});
+});
+
+describe("C19 — dispatchPaste: the text passes through unchanged", () => {
+	const PAYLOADS: [string, string][] = [
+		["a plain term", "node_modules"],
+		["leading and trailing spaces", "  spaced term  "],
+		["a single newline", "first line\nsecond line"],
+		["a trailing newline", "term\n"],
+		["CRLF line endings", "one\r\ntwo\r\n"],
+		["several lines", "a\nb\nc\nd"],
+		["a tab", "left\tright"],
+		["unicode accents", "café naïve"],
+		["CJK", "日本語のテキスト"],
+		["emoji", "🚀 ship it 🎉"],
+		["combining marks", "égalité"],
+		["a path with spaces", "/tmp/some dir/file.json"],
+		["JSON-ish punctuation", '{"key": "value", "n": 1}'],
+		["a single space", " "],
+		["a lone newline", "\n"],
+	];
+
+	for (const [label, text] of PAYLOADS) {
+		test(`R4.9 ${label} reaches the consuming layer byte-for-byte`, async () => {
+			const { dispatchPaste } = await load();
+			const got: string[] = [];
+			const r = stack({
+				input: (t) => {
+					got.push(t);
+					return true;
+				},
+			});
+			expect(dispatchPaste(r.layers, text)).toBe("input");
+			expect(got).toEqual([text]);
+		});
+
+		test(`R4.9 ${label} reaches every layer it is offered to unchanged`, async () => {
+			const { dispatchPaste } = await load();
+			const r = stack({});
+			expect(dispatchPaste(r.layers, text)).toBeNull();
+			expect(r.seen).toEqual(ORDER.map((id) => ({ id, text })));
+		});
+	}
+});