magus-cli 0.0.0-placeholder → 7.0.0

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

@@ -0,0 +1,417 @@
+import { describe, expect, it } from "bun:test";
+import {
+	argsToFlagValues,
+	parseAliasFromRc,
+	parseAliasLine,
+	parseManagedBlock,
+	renderAlias,
+	renderArgsAsTokens,
+	tokenizePosixAliasBody,
+} from "../services/alias-shell-writer";
+import { defaultAliasConfig } from "../services/alias-store";
+
+/**
+ * Parser round-trip tests. The strongest invariant: parse(render(config))
+ * should reproduce the config's enabled flags. We don't compare entire
+ * configs because the parser only produces the *enabled* subset (disabled
+ * defaults aren't in the rc file at all).
+ */
+
+function buildAndParse(
+	mutate: (c: ReturnType<typeof defaultAliasConfig>) => void,
+) {
+	const c = defaultAliasConfig();
+	c.aliasName = "c";
+	mutate(c);
+	const rendered = renderAlias(c, "zsh").block;
+	const parsed = parseAliasFromRc(rendered);
+	return { config: c, rendered, parsed };
+}
+
+describe("parseManagedBlock", () => {
+	it("returns null when no managed block exists", () => {
+		expect(parseManagedBlock("export PATH=...\n")).toBeNull();
+		expect(parseManagedBlock("")).toBeNull();
+	});
+
+	it("returns null when only one marker is present", () => {
+		expect(
+			parseManagedBlock("# >>> magus managed alias >>>\nalias c='claude'\n"),
+		).toBeNull();
+	});
+
+	it("extracts a minimal block with no args", () => {
+		const text =
+			"# >>> magus managed alias >>>\n" +
+			"alias c='claude'\n" +
+			"# <<< magus managed alias <<<\n";
+		const r = parseManagedBlock(text);
+		expect(r).not.toBeNull();
+		expect(r?.aliasName).toBe("c");
+		expect(r?.args).toEqual([]);
+	});
+
+	it("ignores text outside the block", () => {
+		const text =
+			"export FOO=bar\n" +
+			"# >>> magus managed alias >>>\n" +
+			"alias cc='claude --ide'\n" +
+			"# <<< magus managed alias <<<\n" +
+			"alias ll='ls -la'\n";
+		const r = parseManagedBlock(text);
+		expect(r?.aliasName).toBe("cc");
+		expect(r?.args).toEqual(["--ide"]);
+	});
+});
+
+describe("parseAliasLine", () => {
+	it("rejects lines that don't match the managed pattern", () => {
+		expect(parseAliasLine("alias ll='ls -la'")).toBeNull();
+		expect(parseAliasLine("alias =foo")).toBeNull();
+		expect(parseAliasLine("alias c='ls'")).toBeNull(); // not invoking claude
+	});
+
+	it("parses simple bare-flag lines", () => {
+		const r = parseAliasLine(
+			"alias c='claude --ide --dangerously-skip-permissions'",
+		);
+		expect(r?.aliasName).toBe("c");
+		expect(r?.args).toEqual(["--ide", "--dangerously-skip-permissions"]);
+	});
+});
+
+describe("tokenizePosixAliasBody — escape forms", () => {
+	it("splits bare tokens on whitespace", () => {
+		expect(tokenizePosixAliasBody("claude --ide --debug api,hooks")).toEqual([
+			"claude",
+			"--ide",
+			"--debug",
+			"api,hooks",
+		]);
+	});
+
+	it("unescapes the close-escape-reopen sequence for spaces", () => {
+		// `'\''be terse'\''` inside outer quotes becomes the literal token `be terse`.
+		expect(
+			tokenizePosixAliasBody(
+				"claude --append-system-prompt '\\''be terse'\\''",
+			),
+		).toEqual(["claude", "--append-system-prompt", "be terse"]);
+	});
+
+	it("converts a substitution embed back into its template token", () => {
+		expect(
+			tokenizePosixAliasBody(
+				`claude --remote-control-session-name-prefix dev-'"$(basename "$PWD")"'-'"$(date +%d)"'`,
+			),
+		).toEqual([
+			"claude",
+			"--remote-control-session-name-prefix",
+			"dev-{folder}-{day}",
+		]);
+	});
+
+	it("passes through unknown substitution code as the raw $(...) form", () => {
+		expect(
+			tokenizePosixAliasBody(
+				`claude --remote-control-session-name-prefix '"$(whoami)"'`,
+			),
+		).toEqual(["claude", "--remote-control-session-name-prefix", "$(whoami)"]);
+	});
+});
+
+describe("argsToFlagValues", () => {
+	it("returns an empty object for empty args", () => {
+		expect(argsToFlagValues([])).toEqual({});
+	});
+
+	it("marks boolean flags as enabled", () => {
+		const v = argsToFlagValues(["--ide", "--dangerously-skip-permissions"]);
+		expect(v.ide).toEqual({ kind: "boolean", enabled: true });
+		expect(v["dangerously-skip-permissions"]).toEqual({
+			kind: "boolean",
+			enabled: true,
+		});
+	});
+
+	it("recognises tri-state on/off variants", () => {
+		expect(argsToFlagValues(["--chrome"])).toMatchObject({
+			chrome: { kind: "tri-state", state: "on" },
+		});
+		expect(argsToFlagValues(["--no-chrome"])).toMatchObject({
+			chrome: { kind: "tri-state", state: "off" },
+		});
+	});
+
+	it("reads a select flag with a known value", () => {
+		expect(argsToFlagValues(["--effort", "high"])).toMatchObject({
+			effort: { kind: "select", enabled: true, value: "high" },
+		});
+	});
+
+	it("treats a bare --tmux (no variant) as the empty-value select", () => {
+		expect(argsToFlagValues(["--worktree", "--tmux"])).toMatchObject({
+			worktree: { kind: "boolean", enabled: true },
+			tmux: { kind: "select", enabled: true, value: "" },
+		});
+	});
+
+	it("reads multi-with-custom comma-joined tokens, splitting picked vs custom", () => {
+		expect(argsToFlagValues(["--debug", "api,hooks,!file"])).toMatchObject({
+			debug: {
+				kind: "multi-with-custom",
+				enabled: true,
+				picked: ["api", "hooks"],
+				custom: ["!file"],
+			},
+		});
+	});
+
+	it("collects repeated --dangerously-load-development-channels values", () => {
+		expect(
+			argsToFlagValues([
+				"--dangerously-load-development-channels",
+				"plugin:claudish@magus",
+				"--dangerously-load-development-channels",
+				"plugin:dev@magus",
+			]),
+		).toMatchObject({
+			"dangerously-load-development-channels": {
+				kind: "text-list",
+				enabled: true,
+				values: ["plugin:claudish@magus", "plugin:dev@magus"],
+			},
+		});
+	});
+
+	it("reads a text flag's value", () => {
+		expect(
+			argsToFlagValues(["--append-system-prompt", "be terse"]),
+		).toMatchObject({
+			"append-system-prompt": {
+				kind: "text",
+				enabled: true,
+				value: "be terse",
+			},
+		});
+	});
+
+	it("recognises an optional-text flag in bare form (followed by another flag)", () => {
+		expect(argsToFlagValues(["--remote-control", "--ide"])).toMatchObject({
+			"remote-control": { kind: "boolean", enabled: true },
+			ide: { kind: "boolean", enabled: true },
+		});
+	});
+
+	it("silently skips unknown flag/value pairs without corrupting the rest", () => {
+		expect(
+			argsToFlagValues(["--unknown-future", "value", "--ide"]),
+		).toMatchObject({ ide: { kind: "boolean", enabled: true } });
+	});
+});
+
+describe("round-trip: render → parse → enabled subset matches", () => {
+	it("preserves a complex POSIX config end-to-end", () => {
+		const { parsed } = buildAndParse((c) => {
+			c.flags["dangerously-skip-permissions"] = {
+				kind: "boolean",
+				enabled: true,
+			};
+			c.flags.debug = {
+				kind: "multi-with-custom",
+				enabled: true,
+				picked: ["api", "hooks"],
+				custom: ["!file"],
+			};
+			c.flags.effort = { kind: "select", enabled: true, value: "high" };
+			c.flags["dangerously-load-development-channels"] = {
+				kind: "text-list",
+				enabled: true,
+				values: ["plugin:claudish@magus"],
+			};
+			c.flags.worktree = { kind: "boolean", enabled: true };
+			c.flags.tmux = { kind: "select", enabled: true, value: "classic" };
+		});
+		expect(parsed).not.toBeNull();
+		expect(parsed!.aliasName).toBe("c");
+
+		const f = parsed!.flags;
+		expect(f["dangerously-skip-permissions"]).toEqual({
+			kind: "boolean",
+			enabled: true,
+		});
+		expect(f.debug).toEqual({
+			kind: "multi-with-custom",
+			enabled: true,
+			picked: ["api", "hooks"],
+			custom: ["!file"],
+		});
+		expect(f.effort).toEqual({
+			kind: "select",
+			enabled: true,
+			value: "high",
+		});
+		expect(f["dangerously-load-development-channels"]).toEqual({
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:claudish@magus"],
+		});
+		expect(f.worktree).toEqual({ kind: "boolean", enabled: true });
+		expect(f.tmux).toEqual({
+			kind: "select",
+			enabled: true,
+			value: "classic",
+		});
+	});
+
+	it("preserves a templated remote-control prefix", () => {
+		const { parsed } = buildAndParse((c) => {
+			c.flags["remote-control-session-name-prefix"] = {
+				kind: "text",
+				enabled: true,
+				value: "dev-{folder}-{day}",
+			};
+		});
+		expect(parsed!.flags["remote-control-session-name-prefix"]).toEqual({
+			kind: "text",
+			enabled: true,
+			value: "dev-{folder}-{day}",
+		});
+	});
+
+	it("preserves a quoted text value with spaces", () => {
+		const { parsed } = buildAndParse((c) => {
+			c.flags["append-system-prompt"] = {
+				kind: "text",
+				enabled: true,
+				value: "be terse",
+			};
+		});
+		expect(parsed!.flags["append-system-prompt"]).toEqual({
+			kind: "text",
+			enabled: true,
+			value: "be terse",
+		});
+	});
+
+	it("preserves a custom aliasName", () => {
+		const { parsed } = buildAndParse((c) => {
+			c.aliasName = "cc";
+			c.flags.ide = { kind: "boolean", enabled: true };
+		});
+		expect(parsed!.aliasName).toBe("cc");
+		expect(parsed!.flags.ide).toEqual({ kind: "boolean", enabled: true });
+	});
+});
+
+describe("channels: render-time union + parse-time provenance split", () => {
+	// The model: channels.values holds OWN channels only; dev-load values are
+	// unioned into --channels at render time and subtracted back out on parse,
+	// so the two lists stay distinct in storage but merge on the command line.
+
+	it("emits --channels as (own ∪ enabled dev-load), deduped, own-first", () => {
+		const c = defaultAliasConfig();
+		c.flags.channels = {
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:own@m"],
+		};
+		c.flags["dangerously-load-development-channels"] = {
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:dev@m", "plugin:own@m"], // overlap dedupes
+		};
+		const tokens = renderArgsAsTokens(c);
+		// --channels carries own + derived (deduped); dev-load still emits its own.
+		const channelsArgs = tokens
+			.map((t, i) => (tokens[i - 1] === "--channels" ? t : null))
+			.filter(Boolean);
+		expect(channelsArgs).toEqual(["plugin:own@m", "plugin:dev@m"]);
+	});
+
+	it("forces --channels to emit derived values even when own channels is OFF", () => {
+		const c = defaultAliasConfig();
+		c.flags.channels = { kind: "text-list", enabled: false, values: [] };
+		c.flags["dangerously-load-development-channels"] = {
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:dev@m"],
+		};
+		const tokens = renderArgsAsTokens(c);
+		expect(tokens).toContain("--channels");
+		const idx = tokens.indexOf("--channels");
+		expect(tokens[idx + 1]).toBe("plugin:dev@m");
+	});
+
+	it("does NOT emit --channels when both own and dev-load are empty/off", () => {
+		const c = defaultAliasConfig(); // both channels + dev-load default off
+		expect(renderArgsAsTokens(c)).not.toContain("--channels");
+	});
+
+	it("round-trips: derived values do NOT leak into parsed channels.values", () => {
+		const c = defaultAliasConfig();
+		c.aliasName = "c";
+		c.flags.channels = {
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:own@m"],
+		};
+		c.flags["dangerously-load-development-channels"] = {
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:dev@m"],
+		};
+		const rendered = renderAlias(c, "zsh").block;
+		const parsed = parseAliasFromRc(rendered);
+		// channels.values comes back as OWN ONLY — derived was subtracted.
+		expect(parsed!.flags.channels).toEqual({
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:own@m"],
+		});
+		// dev-load round-trips intact (it's the source of truth for derived).
+		expect(parsed!.flags["dangerously-load-development-channels"]).toEqual({
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:dev@m"],
+		});
+	});
+
+	it("round-trips a purely-derived channels list to disabled+empty own", () => {
+		const c = defaultAliasConfig();
+		c.aliasName = "c";
+		// No own channels; only dev-load.
+		c.flags["dangerously-load-development-channels"] = {
+			kind: "text-list",
+			enabled: true,
+			values: ["plugin:dev@m"],
+		};
+		const parsed = parseAliasFromRc(renderAlias(c, "zsh").block);
+		expect(parsed!.flags.channels).toEqual({
+			kind: "text-list",
+			enabled: false,
+			values: [],
+		});
+	});
+});
+
+describe("parseAliasFromRc — entry point", () => {
+	it("returns null on text with no managed block", () => {
+		expect(parseAliasFromRc("export PATH=...\n")).toBeNull();
+	});
+
+	it("returns the alias name + flags for a well-formed block", () => {
+		const text =
+			"# >>> magus managed alias >>>\n" +
+			"alias c='claude --ide --effort high'\n" +
+			"# <<< magus managed alias <<<\n";
+		const r = parseAliasFromRc(text);
+		expect(r?.aliasName).toBe("c");
+		expect(r?.flags.ide).toEqual({ kind: "boolean", enabled: true });
+		expect(r?.flags.effort).toEqual({
+			kind: "select",
+			enabled: true,
+			value: "high",
+		});
+	});
+});