claudeup 4.16.0 → 4.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "4.16.0",
+  "version": "4.18.0",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",

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

@@ -0,0 +1,317 @@
+import { describe, it, expect } from "bun:test";
+import {
+  parseManagedBlock,
+  parseAliasLine,
+  parseAliasFromRc,
+  tokenizePosixAliasBody,
+  argsToFlagValues,
+  renderAlias,
+} 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("# >>> claudeup managed alias >>>\nalias c='claude'\n")).toBeNull();
+  });
+
+  it("extracts a minimal block with no args", () => {
+    const text =
+      "# >>> claudeup managed alias >>>\n" +
+      "alias c='claude'\n" +
+      "# <<< claudeup 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" +
+      "# >>> claudeup managed alias >>>\n" +
+      "alias cc='claude --ide'\n" +
+      "# <<< claudeup 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("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 =
+      "# >>> claudeup managed alias >>>\n" +
+      "alias c='claude --ide --effort high'\n" +
+      "# <<< claudeup 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",
+    });
+  });
+});