magus-cli 7.11.8 → 7.12.1

package/package.json

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

package/src/__tests__/alias-agent-teams.test.ts

@@ -0,0 +1,281 @@
+import { describe, expect, it } from "bun:test";
+import { ALIAS_FLAGS, FLAG_GROUPS, getFlagById } from "../data/alias-flags";
+import {
+	type ShellKind,
+	parseAliasFromRc,
+	renderAlias,
+	renderArgs,
+	renderArgsAsTokens,
+	renderEnv,
+} from "../services/alias-shell-writer";
+import { type AliasConfig, defaultValueFor } from "../services/alias-store";
+
+const assignment = "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1";
+const shells: ShellKind[] = ["bash", "zsh", "fish"];
+const modes = ["tmux", "iterm2", "in-process", "auto"];
+
+function expectAliasLine(
+	block: string,
+	shell: ShellKind,
+	envEnabled: boolean,
+	argv: string[],
+	aliasName = "c",
+) {
+	const lines = block.split("\n").filter((line) => line.startsWith("alias "));
+	const prefix = envEnabled
+		? `${(shell === "fish" ? "env " : "") + assignment} claude`
+		: "claude";
+	const bareArgs = argv.length === 0 ? "" : ` ${argv.join(" ")}`;
+
+	expect(lines).toHaveLength(1);
+	if (shell === "fish") {
+		const quotedArgs =
+			argv.length === 0 ? "" : ` ${argv.map((arg) => `'${arg}'`).join(" ")}`;
+		expect(lines).toEqual([`alias ${aliasName} '${prefix}${quotedArgs}'`]);
+	} else {
+		expect(lines).toEqual([`alias ${aliasName}='${prefix}${bareArgs}'`]);
+	}
+}
+
+describe("agent teams catalog", () => {
+	it("TEST-7 REQ-1 REQ-4 exposes one env-backed select and the Agent teams group", () => {
+		expect(getFlagById("agent-teams")).toMatchObject({
+			id: "agent-teams",
+			label: "Agent teams",
+			kind: "select",
+			env: assignment,
+			flag: "--teammate-mode",
+			group: "agents",
+		});
+		expect(FLAG_GROUPS.filter((group) => group.id === "agents")).toEqual([
+			{ id: "agents", label: "Agent teams" },
+		]);
+		expect(
+			ALIAS_FLAGS.filter((flag) => flag.id === "agent-teams"),
+		).toHaveLength(1);
+		expect(
+			ALIAS_FLAGS.filter(
+				(flag) => flag.kind === "boolean" && flag.env !== undefined,
+			),
+		).toEqual([]);
+	});
+
+	it("TEST-8 REQ-4 exposes the ordered teammate choices without a dependency", () => {
+		const flag = getFlagById("agent-teams");
+
+		expect(flag.options?.map((option) => option.value)).toEqual([
+			"tmux",
+			"iterm2",
+			"in-process",
+			"auto",
+		]);
+		expect(flag.requires).toBeUndefined();
+	});
+
+	it("TEST-22 REQ-1 REQ-4 has no separate teammate-mode catalog entry", () => {
+		expect(ALIAS_FLAGS.filter((flag) => flag.id === "teammate-mode")).toEqual(
+			[],
+		);
+	});
+
+	it("TEST-23 REQ-1 REQ-4 defaults agent teams to a disabled tmux select", () => {
+		const flag = getFlagById("agent-teams");
+
+		expect(defaultValueFor(flag)).toEqual({
+			kind: "select",
+			enabled: false,
+			value: "tmux",
+		});
+	});
+});
+
+describe("environment and argv separation", () => {
+	for (const state of ["enabled", "disabled", "missing"] as const) {
+		it(`TEST-9 REQ-1 REQ-6 REQ-7 REQ-9 separates env from argv when agent teams is ${state}`, () => {
+			const config: AliasConfig = { aliasName: "c", flags: {} };
+			if (state !== "missing") {
+				config.flags["agent-teams"] = {
+					kind: "select",
+					enabled: state === "enabled",
+					value: "tmux",
+				};
+			}
+			const expectedEnv = state === "enabled" ? [assignment] : [];
+			const expectedArgv =
+				state === "enabled" ? ["--teammate-mode", "tmux"] : [];
+
+			expect(renderEnv(config)).toEqual(expectedEnv);
+			expect(renderArgs(config)).toEqual(
+				expectedArgv.map((text) => ({ kind: "literal", text })),
+			);
+			expect(renderArgsAsTokens(config)).toEqual([
+				...expectedEnv,
+				...expectedArgv,
+			]);
+		});
+	}
+});
+
+describe("agent teams shell output and POSIX round-trips", () => {
+	// Fish rendering is covered; the parse-back contract uses POSIX alias lines.
+	for (const shell of shells) {
+		it(`TEST-10 REQ-8 REQ-13 renders automatic agent teams with env before claude on ${shell}`, () => {
+			const config: AliasConfig = {
+				aliasName: "c",
+				flags: {
+					"agent-teams": { kind: "select", enabled: true, value: "auto" },
+				},
+			};
+
+			const rendered = renderAlias(config, shell);
+
+			expect(rendered.shell).toBe(shell);
+			expectAliasLine(rendered.block, shell, true, ["--teammate-mode", "auto"]);
+			if (shell !== "fish") {
+				expect(parseAliasFromRc(rendered.block)).toEqual({
+					aliasName: "c",
+					flags: {
+						"agent-teams": { kind: "select", enabled: true, value: "auto" },
+					},
+				});
+			}
+		});
+
+		for (const mode of modes) {
+			it(`TEST-11 REQ-4 REQ-6 REQ-7 REQ-8 REQ-9 REQ-13 ${shell === "fish" ? "renders " : "renders and round-trips "}${mode} teammates on ${shell}`, () => {
+				const config: AliasConfig = {
+					aliasName: "c",
+					flags: {
+						"agent-teams": { kind: "select", enabled: true, value: mode },
+					},
+				};
+
+				const rendered = renderAlias(config, shell);
+
+				expect(renderEnv(config)).toEqual([assignment]);
+				expect(renderArgs(config)).toEqual([
+					{ kind: "literal", text: "--teammate-mode" },
+					{ kind: "literal", text: mode },
+				]);
+				expect(renderArgsAsTokens(config)).toEqual([
+					assignment,
+					"--teammate-mode",
+					mode,
+				]);
+				expectAliasLine(rendered.block, shell, true, ["--teammate-mode", mode]);
+				if (shell !== "fish") {
+					expect(parseAliasFromRc(rendered.block)).toEqual({
+						aliasName: "c",
+						flags: {
+							"agent-teams": { kind: "select", enabled: true, value: mode },
+						},
+					});
+				}
+			});
+		}
+
+		for (const state of ["missing", "disabled"] as const) {
+			it(`TEST-12 REQ-14 omits both team outputs with ${state} agent teams but keeps context size on ${shell}`, () => {
+				const config: AliasConfig = {
+					aliasName: "c",
+					flags: {
+						autocompact: { kind: "text", enabled: true, value: "200k" },
+					},
+				};
+				const withoutTeams = structuredClone(config);
+				if (state === "disabled") {
+					config.flags["agent-teams"] = {
+						kind: "select",
+						enabled: false,
+						value: "tmux",
+					};
+				}
+				const original = structuredClone(config);
+
+				const rendered = renderAlias(config, shell);
+
+				expect(rendered).toEqual(renderAlias(withoutTeams, shell));
+				expect(renderEnv(config)).toEqual([]);
+				expect(renderArgs(config)).toEqual([
+					{ kind: "literal", text: "--autocompact" },
+					{ kind: "literal", text: "200k" },
+				]);
+				expect(renderArgsAsTokens(config)).toEqual(["--autocompact", "200k"]);
+				expectAliasLine(rendered.block, shell, false, [
+					"--autocompact",
+					"200k",
+				]);
+				if (shell !== "fish") {
+					expect(parseAliasFromRc(rendered.block)).toEqual({
+						aliasName: "c",
+						flags: {
+							autocompact: { kind: "text", enabled: true, value: "200k" },
+						},
+					});
+				}
+				expect(config).toEqual(original);
+			});
+		}
+
+		it(`TEST-13 REQ-4 REQ-7 REQ-8 REQ-13 omits both outputs for disabled agent teams on ${shell}`, () => {
+			const config: AliasConfig = {
+				aliasName: "c",
+				flags: {
+					"agent-teams": { kind: "select", enabled: false, value: "tmux" },
+				},
+			};
+			const withoutTeams: AliasConfig = { aliasName: "c", flags: {} };
+
+			const rendered = renderAlias(config, shell);
+
+			expect(rendered).toEqual(renderAlias(withoutTeams, shell));
+			expect(renderEnv(config)).toEqual([]);
+			expect(renderArgs(config)).toEqual([]);
+			expect(renderArgsAsTokens(config)).toEqual([]);
+			expectAliasLine(rendered.block, shell, false, []);
+			if (shell !== "fish") {
+				expect(parseAliasFromRc(rendered.block)).toEqual({
+					aliasName: "c",
+					flags: {},
+				});
+			}
+		});
+
+		it(`TEST-14 REQ-6 REQ-7 REQ-8 REQ-9 REQ-13 renders agent teams after context size with env first on ${shell}`, () => {
+			const config: AliasConfig = {
+				aliasName: "crew",
+				flags: {
+					"agent-teams": { kind: "select", enabled: true, value: "tmux" },
+					autocompact: { kind: "text", enabled: true, value: "200k" },
+				},
+			};
+			const contextIndex = ALIAS_FLAGS.findIndex(
+				(flag) => flag.id === "autocompact",
+			);
+			const teamsIndex = ALIAS_FLAGS.findIndex(
+				(flag) => flag.id === "agent-teams",
+			);
+			expect(contextIndex).toBeGreaterThanOrEqual(0);
+			expect(teamsIndex).toBeGreaterThan(contextIndex);
+			const argv = ["--autocompact", "200k", "--teammate-mode", "tmux"];
+
+			const rendered = renderAlias(config, shell);
+
+			expect(renderEnv(config)).toEqual([assignment]);
+			expect(renderArgs(config)).toEqual(
+				argv.map((text) => ({ kind: "literal", text })),
+			);
+			expect(renderArgsAsTokens(config)).toEqual([assignment, ...argv]);
+			expectAliasLine(rendered.block, shell, true, argv, "crew");
+			if (shell !== "fish") {
+				expect(parseAliasFromRc(rendered.block)).toEqual({
+					aliasName: "crew",
+					flags: {
+						"agent-teams": { kind: "select", enabled: true, value: "tmux" },
+						autocompact: { kind: "text", enabled: true, value: "200k" },
+					},
+				});
+			}
+		});
+	}
+});

package/src/__tests__/alias-autocompact.test.ts

@@ -0,0 +1,169 @@
+import { describe, expect, it } from "bun:test";
+import {
+	AUTOCOMPACT_MAX_TOKENS,
+	AUTOCOMPACT_MIN_TOKENS,
+	getFlagById,
+	parseAutocompactSize,
+	validateAutocompactSize,
+} from "../data/alias-flags";
+import {
+	type ShellKind,
+	parseAliasFromRc,
+	renderAlias,
+	renderArgs,
+	renderArgsAsTokens,
+	renderEnv,
+} from "../services/alias-shell-writer";
+import type { AliasConfig } from "../services/alias-store";
+
+const shells: ShellKind[] = ["bash", "zsh", "fish"];
+
+function expectSizeAlias(block: string, shell: ShellKind, value?: string) {
+	const lines = block.split("\n").filter((line) => line.startsWith("alias "));
+	const args = value === undefined ? "" : ` --autocompact ${value}`;
+
+	expect(lines).toHaveLength(1);
+	if (shell === "fish") {
+		const quotedArgs = value === undefined ? "" : ` '--autocompact' '${value}'`;
+		expect([
+			`alias c 'claude${args}'`,
+			`alias c 'claude${quotedArgs}'`,
+		]).toContain(lines[0]);
+	} else {
+		expect(lines).toEqual([`alias c='claude${args}'`]);
+	}
+}
+
+describe("context window size catalog and validation", () => {
+	it("TEST-1 REQ-2 exposes the context text option and its validator", () => {
+		const flag = getFlagById("autocompact");
+
+		expect(flag).toMatchObject({
+			id: "autocompact",
+			label: "Context window size",
+			kind: "text",
+			flag: "--autocompact",
+			group: "context",
+		});
+		expect(typeof flag.validateValue).toBe("function");
+		expect(flag.env).toBeUndefined();
+	});
+
+	const validSizes: Array<[string, number | "auto"]> = [
+		["auto", "auto"],
+		["AUTO", "auto"],
+		["aUtO", "auto"],
+		["200k", 200000],
+		["1m", 1000000],
+		["200000", 200000],
+		["500", 500000],
+		["100k", 100000],
+		["100000", 100000],
+		["100", 100000],
+		["1000k", 1000000],
+		["1000000", 1000000],
+		["1000", 1000000],
+	];
+
+	for (const [value, expected] of validSizes) {
+		it(`TEST-2 REQ-3 accepts ${JSON.stringify(value)} as ${expected}`, () => {
+			const catalogValidator = getFlagById("autocompact").validateValue;
+
+			expect(parseAutocompactSize(value)).toBe(expected);
+			expect(validateAutocompactSize(value)).toBeNull();
+			expect(catalogValidator?.(value)).toBeNull();
+		});
+	}
+
+	const invalidSizes = [
+		"50k",
+		"2m",
+		"abc",
+		"",
+		"0",
+		"99",
+		"1001",
+		"99k",
+		"1001k",
+		"99999",
+		"1000001",
+	];
+
+	for (const value of invalidSizes) {
+		it(`TEST-3 REQ-3 rejects ${JSON.stringify(value)} with a reason`, () => {
+			const catalogValidator = getFlagById("autocompact").validateValue;
+
+			expect(parseAutocompactSize(value)).toBeUndefined();
+			const reasons = [
+				validateAutocompactSize(value),
+				catalogValidator?.(value),
+			];
+			for (const reason of reasons) {
+				expect(reason).toEqual(expect.any(String));
+				expect(reason).toMatch(/\S/);
+			}
+		});
+	}
+
+	it("TEST-4 REQ-3 exposes the inclusive 100000–1000000 token limits", () => {
+		expect(AUTOCOMPACT_MIN_TOKENS).toBe(100000);
+		expect(AUTOCOMPACT_MAX_TOKENS).toBe(1000000);
+	});
+});
+
+describe("context window size shell output", () => {
+	// Fish rendering is covered; the parse-back contract uses POSIX alias lines.
+	for (const shell of shells) {
+		for (const value of ["auto", "200k", "1m", "200000", "500"]) {
+			it(`TEST-5 REQ-2 REQ-7 REQ-8 REQ-13 ${shell === "fish" ? "renders " : "renders and round-trips "}${value} on ${shell}`, () => {
+				const config: AliasConfig = {
+					aliasName: "c",
+					flags: {
+						autocompact: { kind: "text", enabled: true, value },
+					},
+				};
+
+				const rendered = renderAlias(config, shell);
+
+				expect(rendered.shell).toBe(shell);
+				expect(renderEnv(config)).toEqual([]);
+				expect(renderArgs(config)).toEqual([
+					{ kind: "literal", text: "--autocompact" },
+					{ kind: "literal", text: value },
+				]);
+				expect(renderArgsAsTokens(config)).toEqual(["--autocompact", value]);
+				expectSizeAlias(rendered.block, shell, value);
+				if (shell !== "fish") {
+					expect(parseAliasFromRc(rendered.block)).toEqual({
+						aliasName: "c",
+						flags: {
+							autocompact: { kind: "text", enabled: true, value },
+						},
+					});
+				}
+			});
+		}
+
+		it(`TEST-6 REQ-2 REQ-10 omits a disabled context size on ${shell}`, () => {
+			const config: AliasConfig = {
+				aliasName: "c",
+				flags: {
+					autocompact: { kind: "text", enabled: false, value: "200k" },
+				},
+			};
+
+			const rendered = renderAlias(config, shell);
+
+			expect(renderArgs(config)).toEqual([]);
+			expect(renderArgsAsTokens(config)).toEqual([]);
+			expect(renderEnv(config)).toEqual([]);
+			expectSizeAlias(rendered.block, shell);
+			if (shell !== "fish") {
+				expect(parseAliasFromRc(rendered.block)).toEqual({
+					aliasName: "c",
+					flags: {},
+				});
+			}
+		});
+	}
+});