magus-cli 7.11.8 → 7.12.1

package/src/__tests__/alias-env-adoption.test.ts

@@ -0,0 +1,475 @@
+import { describe, expect, it } from "bun:test";
+import {
+	argsToFlagValuesWithLeftovers,
+	findAdoptableAlias,
+	parseAliasFromRc,
+	parseAliasLine,
+	parseManagedBlock,
+	renderAlias,
+	renderArgsAsTokens,
+} from "../services/alias-shell-writer";
+import type { AliasConfig, FlagValue } from "../services/alias-store";
+
+const assignment = "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1";
+const modes = ["tmux", "iterm2", "in-process", "auto"];
+
+function combinedFlags(): Record<string, FlagValue> {
+	return {
+		"agent-teams": { kind: "select", enabled: true, value: "tmux" },
+		autocompact: { kind: "text", enabled: true, value: "200k" },
+	};
+}
+
+const forms: Array<{
+	name: string;
+	envLauncher: boolean;
+	line: (body: string) => string;
+}> = [
+	{ name: "POSIX", envLauncher: false, line: (body) => `alias crew='${body}'` },
+	// The env launcher is a body form; the parser contract uses POSIX alias lines.
+	{
+		name: "POSIX with env launcher",
+		envLauncher: true,
+		line: (body) => `alias crew='${body}'`,
+	},
+];
+
+function commandBody(
+	envLauncher: boolean,
+	env: string[],
+	argv: string[],
+): string {
+	return [
+		...(envLauncher && env.length > 0 ? ["env"] : []),
+		...env,
+		"claude",
+		...argv,
+	].join(" ");
+}
+
+describe("single agent-team parse rows", () => {
+	type ParseRow = {
+		name: string;
+		env: string[];
+		argv: string[];
+		flags: () => Record<string, FlagValue>;
+		leftovers: string[];
+	};
+	const rows: ParseRow[] = [
+		...modes.map(
+			(mode): ParseRow => ({
+				name: `assignment and ${mode} argv become one select`,
+				env: [assignment],
+				argv: ["--teammate-mode", mode],
+				flags: () => ({
+					"agent-teams": { kind: "select", enabled: true, value: mode },
+				}),
+				leftovers: [],
+			}),
+		),
+		{
+			name: "assignment alone defaults to auto",
+			env: [assignment],
+			argv: [],
+			flags: () => ({
+				"agent-teams": { kind: "select", enabled: true, value: "auto" },
+			}),
+			leftovers: [],
+		},
+		...modes.map(
+			(mode): ParseRow => ({
+				name: `${mode} argv alone remains leftovers`,
+				env: [],
+				argv: ["--teammate-mode", mode],
+				flags: () => ({}),
+				leftovers: ["--teammate-mode", mode],
+			}),
+		),
+	];
+
+	for (const row of rows) {
+		it(`TEST-24 REQ-12 REQ-14 maps tokens so ${row.name}`, () => {
+			const args = [...row.env, ...row.argv];
+
+			expect(argsToFlagValuesWithLeftovers(args)).toEqual({
+				flags: row.flags(),
+				leftovers: [...row.leftovers],
+			});
+		});
+
+		for (const form of forms) {
+			it(`TEST-25 REQ-11 REQ-12 REQ-14 parses ${form.name} so ${row.name}`, () => {
+				const line = form.line(
+					commandBody(form.envLauncher, row.env, row.argv),
+				);
+
+				const parsed = parseAliasLine(line);
+
+				expect(parsed).toEqual({
+					aliasName: "crew",
+					args: [...row.env, ...row.argv],
+				});
+				if (parsed === null) {
+					throw new Error("Expected a parsed claude alias");
+				}
+				expect(argsToFlagValuesWithLeftovers(parsed.args)).toEqual({
+					flags: row.flags(),
+					leftovers: [...row.leftovers],
+				});
+			});
+		}
+	}
+});
+
+describe("managed assignment-prefixed alias parsing", () => {
+	const examples = [
+		{
+			name: "POSIX known assignment",
+			line: `alias crew='${assignment} claude --teammate-mode tmux --autocompact 200k'`,
+			args: [assignment, "--teammate-mode", "tmux", "--autocompact", "200k"],
+		},
+		{
+			name: "POSIX alias with env launcher",
+			line: `alias crew='env ${assignment} claude --teammate-mode tmux --autocompact 200k'`,
+			args: [assignment, "--teammate-mode", "tmux", "--autocompact", "200k"],
+		},
+		{
+			name: "POSIX unknown before known assignment",
+			line: `alias crew='EXTRA=keep ${assignment} claude --autocompact 200k'`,
+			args: ["EXTRA=keep", assignment, "--autocompact", "200k"],
+		},
+		{
+			name: "POSIX env launcher with unknown after known assignment",
+			line: `alias crew='env ${assignment} EXTRA=a=b claude --teammate-mode tmux'`,
+			args: [assignment, "EXTRA=a=b", "--teammate-mode", "tmux"],
+		},
+	];
+
+	for (const example of examples) {
+		it(`TEST-15 REQ-11 preserves env-first tokens for ${example.name}`, () => {
+			const block = [
+				"# >>> magus managed alias >>>",
+				example.line,
+				"# <<< magus managed alias <<<",
+				"",
+			].join("\n");
+			const expected = { aliasName: "crew", args: [...example.args] };
+
+			expect(parseAliasLine(example.line)).toEqual(expected);
+			expect(parseManagedBlock(block)).toEqual(expected);
+		});
+	}
+});
+
+describe("assignment mapping and leftovers", () => {
+	const mappingCases: Array<{
+		name: string;
+		args: string[];
+		flags: () => Record<string, FlagValue>;
+		leftovers: string[];
+	}> = [
+		{
+			name: "known assignment and all new argv options",
+			args: [assignment, "--teammate-mode", "tmux", "--autocompact", "200k"],
+			flags: combinedFlags,
+			leftovers: [],
+		},
+		{
+			name: "unknown assignment before the known one",
+			args: [
+				"EXTRA=keep",
+				assignment,
+				"--teammate-mode",
+				"tmux",
+				"--autocompact",
+				"200k",
+			],
+			flags: combinedFlags,
+			leftovers: ["EXTRA=keep"],
+		},
+		{
+			name: "unknown assignments after the known one",
+			args: [
+				assignment,
+				"EMPTY=",
+				"EXTRA=a=b",
+				"--teammate-mode",
+				"tmux",
+				"--autocompact",
+				"200k",
+			],
+			flags: combinedFlags,
+			leftovers: ["EMPTY=", "EXTRA=a=b"],
+		},
+		{
+			name: "unknown assignments on both sides of the known one",
+			args: [
+				"FIRST=one",
+				assignment,
+				"EMPTY=",
+				"EXTRA=a=b",
+				"--teammate-mode",
+				"tmux",
+				"--autocompact",
+				"200k",
+			],
+			flags: combinedFlags,
+			leftovers: ["FIRST=one", "EMPTY=", "EXTRA=a=b"],
+		},
+		{
+			name: "known env name with a different value",
+			args: ["CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=0", "--ide"],
+			flags: () => ({ ide: { kind: "boolean", enabled: true } }),
+			leftovers: ["CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=0"],
+		},
+	];
+
+	for (const example of mappingCases) {
+		it(`TEST-16 REQ-12 retains every unmatched token for ${example.name}`, () => {
+			const args = [...example.args];
+
+			expect(argsToFlagValuesWithLeftovers(args)).toEqual({
+				flags: example.flags(),
+				leftovers: [...example.leftovers],
+			});
+		});
+	}
+
+	it("TEST-17 REQ-12 keeps an assignment after an argv flag as a leftover rather than enabling teams", () => {
+		const args = ["--ide", assignment];
+
+		expect(argsToFlagValuesWithLeftovers(args)).toEqual({
+			flags: { ide: { kind: "boolean", enabled: true } },
+			leftovers: [assignment],
+		});
+	});
+
+	it("TEST-17 REQ-12 retains an argv assignment without losing an earlier recognized env assignment", () => {
+		const args = [assignment, "--ide", "EXTRA=keep"];
+
+		expect(argsToFlagValuesWithLeftovers(args)).toEqual({
+			flags: {
+				"agent-teams": { kind: "select", enabled: true, value: "auto" },
+				ide: { kind: "boolean", enabled: true },
+			},
+			leftovers: ["EXTRA=keep"],
+		});
+	});
+
+	it("TEST-17 REQ-12 leaves an assignment used as a text value inside that text flag", () => {
+		const args = ["--append-system-prompt", assignment];
+
+		expect(argsToFlagValuesWithLeftovers(args)).toEqual({
+			flags: {
+				"append-system-prompt": {
+					kind: "text",
+					enabled: true,
+					value: assignment,
+				},
+			},
+			leftovers: [],
+		});
+	});
+});
+
+describe("safe adoption of assignment-prefixed aliases", () => {
+	type LosslessCase = {
+		name: string;
+		env: string[];
+		argv: string[];
+		flags: () => Record<string, FlagValue>;
+		renderedArgs: string[];
+	};
+	const losslessCases: LosslessCase[] = [
+		{
+			name: "context size only",
+			env: [],
+			argv: ["--autocompact", "200k"],
+			flags: () => ({
+				autocompact: { kind: "text", enabled: true, value: "200k" },
+			}),
+			renderedArgs: ["--autocompact", "200k"],
+		},
+		{
+			name: "agent teams assignment alone as auto",
+			env: [assignment],
+			argv: [],
+			flags: () => ({
+				"agent-teams": { kind: "select", enabled: true, value: "auto" },
+			}),
+			renderedArgs: [assignment, "--teammate-mode", "auto"],
+		},
+		{
+			name: "all new options",
+			env: [assignment],
+			argv: ["--teammate-mode", "tmux", "--autocompact", "200k"],
+			flags: combinedFlags,
+			renderedArgs: [
+				assignment,
+				"--autocompact",
+				"200k",
+				"--teammate-mode",
+				"tmux",
+			],
+		},
+		...modes.map(
+			(mode): LosslessCase => ({
+				name: `agent teams with explicit ${mode} mode`,
+				env: [assignment],
+				argv: ["--teammate-mode", mode],
+				flags: () => ({
+					"agent-teams": { kind: "select", enabled: true, value: mode },
+				}),
+				renderedArgs: [assignment, "--teammate-mode", mode],
+			}),
+		),
+	];
+
+	const unknownCases: Array<{
+		name: string;
+		env: string[];
+		argv: string[];
+		flags: () => Record<string, FlagValue>;
+		leftovers: string[];
+	}> = [
+		{
+			name: "an unknown assignment alone",
+			env: ["EXTRA=keep"],
+			argv: ["--ide"],
+			flags: () => ({ ide: { kind: "boolean", enabled: true } }),
+			leftovers: ["EXTRA=keep"],
+		},
+		{
+			name: "an empty-valued unknown assignment before known teams",
+			env: ["EMPTY=", assignment],
+			argv: ["--teammate-mode", "tmux", "--autocompact", "200k"],
+			flags: combinedFlags,
+			leftovers: ["EMPTY="],
+		},
+		{
+			name: "an unknown assignment containing another equals sign after known teams",
+			env: [assignment, "EXTRA=a=b"],
+			argv: ["--teammate-mode", "tmux", "--autocompact", "200k"],
+			flags: combinedFlags,
+			leftovers: ["EXTRA=a=b"],
+		},
+		{
+			name: "unknown assignments on both sides of known teams in their original order",
+			env: ["FIRST=one", assignment, "EMPTY=", "EXTRA=a=b"],
+			argv: ["--teammate-mode", "tmux", "--autocompact", "200k"],
+			flags: combinedFlags,
+			leftovers: ["FIRST=one", "EMPTY=", "EXTRA=a=b"],
+		},
+		{
+			name: "a known assignment name with an unsupported value",
+			env: ["CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=0"],
+			argv: ["--ide"],
+			flags: () => ({ ide: { kind: "boolean", enabled: true } }),
+			leftovers: ["CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=0"],
+		},
+	];
+
+	for (const form of forms) {
+		for (const example of losslessCases) {
+			it(`TEST-18 REQ-11 REQ-13 adopts ${example.name} losslessly in ${form.name}`, () => {
+				const line = form.line(
+					commandBody(form.envLauncher, example.env, example.argv),
+				);
+				const rc = `# personal aliases\n${line}\n# end aliases\n`;
+				const expectedFlags = example.flags();
+
+				const adopted = findAdoptableAlias(rc);
+
+				expect(adopted).toEqual({
+					name: "crew",
+					flags: expectedFlags,
+					lineRange: [1, 1],
+					leftovers: [],
+					lossless: true,
+					rawLine: line,
+					others: [],
+				});
+				if (adopted === null) {
+					throw new Error("Expected a lossless adoptable alias");
+				}
+				const config: AliasConfig = {
+					aliasName: adopted.name,
+					flags: adopted.flags,
+				};
+				const renderedArgs = renderArgsAsTokens(config);
+				expect(renderedArgs).toEqual(example.renderedArgs);
+				expect(argsToFlagValuesWithLeftovers(renderedArgs)).toEqual({
+					flags: expectedFlags,
+					leftovers: [],
+				});
+				expect(parseAliasFromRc(renderAlias(config, "bash").block)).toEqual({
+					aliasName: "crew",
+					flags: expectedFlags,
+				});
+			});
+		}
+
+		for (const example of unknownCases) {
+			it(`TEST-19 REQ-11 REQ-12 REQ-13 preserves ${example.name} as a leftover in ${form.name}`, () => {
+				const line = form.line(
+					commandBody(form.envLauncher, example.env, example.argv),
+				);
+				const rc = `# personal aliases\n${line}\n# end aliases\n`;
+
+				const adopted = findAdoptableAlias(rc);
+
+				expect(adopted).toEqual({
+					name: "crew",
+					flags: example.flags(),
+					lineRange: [1, 1],
+					leftovers: [...example.leftovers],
+					lossless: false,
+					rawLine: line,
+					others: [],
+				});
+			});
+		}
+
+		it(`TEST-20 REQ-13 REQ-14 refuses lossless adoption of orphan teammate-mode in ${form.name}`, () => {
+			const line = form.line("claude --teammate-mode tmux");
+
+			const adopted = findAdoptableAlias(`${line}\n`);
+
+			expect(adopted).toEqual({
+				name: "crew",
+				flags: {},
+				lineRange: [0, 0],
+				leftovers: ["--teammate-mode", "tmux"],
+				lossless: false,
+				rawLine: line,
+				others: [],
+			});
+		});
+
+		it(`TEST-26 REQ-12 REQ-13 REQ-14 keeps context size but refuses lossless argv-only teams in ${form.name}`, () => {
+			const line = form.line("claude --teammate-mode tmux --autocompact 200k");
+
+			const adopted = findAdoptableAlias(`${line}\n`);
+
+			expect(adopted).toEqual({
+				name: "crew",
+				flags: {
+					autocompact: { kind: "text", enabled: true, value: "200k" },
+				},
+				lineRange: [0, 0],
+				leftovers: ["--teammate-mode", "tmux"],
+				lossless: false,
+				rawLine: line,
+				others: [],
+			});
+		});
+
+		it(`TEST-21 REQ-11 rejects an assignment-prefixed non-claude alias in ${form.name}`, () => {
+			const prefix = form.envLauncher ? "env " : "";
+			const line = form.line(`${prefix + assignment} other-command --ide`);
+
+			expect(parseAliasLine(line)).toBeNull();
+			expect(findAdoptableAlias(`${line}\n`)).toBeNull();
+		});
+	}
+});

package/src/__tests__/alias-option-compatibility.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from "bun:test";
+import {
+	type ShellKind,
+	renderAlias,
+	renderArgsAsTokens,
+	renderEnv,
+} from "../services/alias-shell-writer";
+import {
+	type AliasConfig,
+	type FlagValue,
+	defaultAliasConfig,
+} from "../services/alias-store";
+
+const shells: ShellKind[] = ["bash", "zsh", "fish"];
+
+describe("alias output when the new options are not enabled", () => {
+	const establishedCases: Array<{
+		name: string;
+		flags: () => Record<string, FlagValue>;
+		tokens: string[];
+		posixLine: string;
+		fishLine: string;
+	}> = [
+		{
+			name: "plain claude alias",
+			flags: () => ({}),
+			tokens: [],
+			posixLine: "alias c='claude'",
+			fishLine: "alias c 'claude'",
+		},
+		{
+			name: "ide-only alias",
+			flags: () => ({ ide: { kind: "boolean", enabled: true } }),
+			tokens: ["--ide"],
+			posixLine: "alias c='claude --ide'",
+			fishLine: "alias c 'claude '--ide''",
+		},
+	];
+
+	for (const shell of shells) {
+		for (const example of establishedCases) {
+			it(`TEST-22 REQ-10 preserves established ${example.name} bytes on ${shell} with absent or disabled new options`, () => {
+				const absent: AliasConfig = {
+					aliasName: "c",
+					flags: example.flags(),
+				};
+				const disabled: AliasConfig = {
+					aliasName: "c",
+					flags: {
+						...example.flags(),
+						autocompact: { kind: "text", enabled: false, value: "200k" },
+						"agent-teams": { kind: "boolean", enabled: false },
+						"teammate-mode": { kind: "select", enabled: false, value: "tmux" },
+					},
+				};
+
+				const absentOutput = renderAlias(absent, shell);
+				const disabledOutput = renderAlias(disabled, shell);
+
+				expect(absentOutput.shell).toBe(shell);
+				expect(disabledOutput).toEqual(absentOutput);
+				expect(
+					absentOutput.block
+						.split("\n")
+						.filter((line) => line.startsWith("alias ")),
+				).toEqual([shell === "fish" ? example.fishLine : example.posixLine]);
+				expect(
+					absentOutput.block.startsWith("# >>> magus managed alias >>>\n"),
+				).toBe(true);
+				expect(
+					absentOutput.block.endsWith("# <<< magus managed alias <<<\n"),
+				).toBe(true);
+				expect(renderEnv(absent)).toEqual([]);
+				expect(renderEnv(disabled)).toEqual([]);
+				expect(renderArgsAsTokens(absent)).toEqual([...example.tokens]);
+				expect(renderArgsAsTokens(disabled)).toEqual([...example.tokens]);
+			});
+		}
+
+		it(`TEST-23 REQ-10 leaves all new options off in the default ${shell} alias`, () => {
+			const config = defaultAliasConfig();
+			const emptyConfig: AliasConfig = { aliasName: "c", flags: {} };
+
+			expect(config.aliasName).toBe("c");
+			expect(renderEnv(config)).toEqual([]);
+			expect(renderArgsAsTokens(config)).toEqual([]);
+			expect(renderAlias(config, shell)).toEqual(
+				renderAlias(emptyConfig, shell),
+			);
+		});
+	}
+});