claudeup 4.17.0 → 4.19.0

package/package.json

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

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

@@ -0,0 +1,364 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, rm, writeFile, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  tokenizeGeneralAliasBody,
+  findAdoptableAlias,
+  spliceManagedBlockAtRange,
+  renderAlias,
+  writeAliasToShell,
+  argsToFlagValuesWithLeftovers,
+  type AdoptableAlias,
+  type ShellTarget,
+} from "../services/alias-shell-writer";
+import { defaultAliasConfig } from "../services/alias-store";
+
+// ─── tokenizeGeneralAliasBody ──────────────────────────────────────────────
+
+describe("tokenizeGeneralAliasBody", () => {
+  it("splits bare words on whitespace", () => {
+    expect(tokenizeGeneralAliasBody("claude --ide --effort high")).toEqual([
+      "claude",
+      "--ide",
+      "--effort",
+      "high",
+    ]);
+  });
+
+  it("treats single-quoted runs as literal (spaces preserved)", () => {
+    expect(
+      tokenizeGeneralAliasBody("claude --append-system-prompt 'be terse'"),
+    ).toEqual(["claude", "--append-system-prompt", "be terse"]);
+  });
+
+  it("treats double-quoted runs as literal", () => {
+    expect(
+      tokenizeGeneralAliasBody('claude --append-system-prompt "be terse"'),
+    ).toEqual(["claude", "--append-system-prompt", "be terse"]);
+  });
+
+  it("joins adjacent quoted + bare pieces into one token", () => {
+    // `foo' bar'baz` → one shell word `foo barbaz`
+    expect(tokenizeGeneralAliasBody("claude foo' bar'baz")).toEqual([
+      "claude",
+      "foo barbaz",
+    ]);
+  });
+
+  it("bails (null) on unterminated quotes", () => {
+    expect(tokenizeGeneralAliasBody("claude 'unterminated")).toBeNull();
+    expect(tokenizeGeneralAliasBody('claude "unterminated')).toBeNull();
+  });
+
+  it("bails (null) on shell substitutions and variables", () => {
+    expect(tokenizeGeneralAliasBody("claude --foo $(date)")).toBeNull();
+    expect(tokenizeGeneralAliasBody("claude --foo `date`")).toBeNull();
+    expect(tokenizeGeneralAliasBody("claude --foo $HOME")).toBeNull();
+    // Even inside double quotes — we don't expand, so we can't round-trip it.
+    expect(tokenizeGeneralAliasBody('claude --foo "$HOME/x"')).toBeNull();
+  });
+});
+
+// ─── argsToFlagValuesWithLeftovers ─────────────────────────────────────────
+
+describe("argsToFlagValuesWithLeftovers", () => {
+  it("reports no leftovers when every token is recognized", () => {
+    const { leftovers } = argsToFlagValuesWithLeftovers([
+      "--dangerously-skip-permissions",
+      "--effort",
+      "high",
+    ]);
+    expect(leftovers).toEqual([]);
+  });
+
+  it("records an unknown bare flag as a leftover", () => {
+    const { leftovers } = argsToFlagValuesWithLeftovers(["--ide", "--unknown"]);
+    expect(leftovers).toEqual(["--unknown"]);
+  });
+
+  it("records an unknown flag AND its consumed value", () => {
+    const { leftovers } = argsToFlagValuesWithLeftovers([
+      "--model",
+      "opus",
+      "--ide",
+    ]);
+    expect(leftovers).toEqual(["--model", "opus"]);
+  });
+
+  it("recognizes order-independently (no false leftovers on reorder)", () => {
+    // catalog order is ide(154) before effort(173); user wrote them reversed
+    const { flags, leftovers } = argsToFlagValuesWithLeftovers([
+      "--effort",
+      "high",
+      "--ide",
+    ]);
+    expect(leftovers).toEqual([]);
+    expect(flags["ide"]).toEqual({ kind: "boolean", enabled: true });
+    expect(flags["effort"]).toEqual({
+      kind: "select",
+      enabled: true,
+      value: "high",
+    });
+  });
+});
+
+// ─── findAdoptableAlias ────────────────────────────────────────────────────
+
+describe("findAdoptableAlias", () => {
+  it("returns null when there's no claude-wrapping alias", () => {
+    const rc = "export PATH=$PATH:/usr/local/bin\nalias ll='ls -la'\n";
+    expect(findAdoptableAlias(rc)).toBeNull();
+  });
+
+  it("detects a single-quoted hand-written claude alias and parses its flags", () => {
+    const rc =
+      "# rc\nalias c='claude --dangerously-skip-permissions'\nexport X=1\n";
+    const a = findAdoptableAlias(rc);
+    expect(a).not.toBeNull();
+    expect(a!.name).toBe("c");
+    expect(a!.flags["dangerously-skip-permissions"]).toEqual({
+      kind: "boolean",
+      enabled: true,
+    });
+    expect(a!.lineRange).toEqual([1, 1]);
+    expect(a!.leftovers).toEqual([]);
+    expect(a!.lossless).toBe(true);
+  });
+
+  it("detects a double-quoted hand-written claude alias", () => {
+    const rc = 'alias cc="claude --ide"\n';
+    const a = findAdoptableAlias(rc);
+    expect(a).not.toBeNull();
+    expect(a!.name).toBe("cc");
+    expect(a!.flags["ide"]).toEqual({ kind: "boolean", enabled: true });
+    expect(a!.lossless).toBe(true);
+  });
+
+  it("marks an alias with an uncatalogued flag as NOT lossless and lists the leftover", () => {
+    const rc = "alias c='claude --ide --model opus'\n";
+    const a = findAdoptableAlias(rc);
+    expect(a).not.toBeNull();
+    // The flags we DID recognize are imported for the user to see.
+    expect(a!.flags["ide"]).toEqual({ kind: "boolean", enabled: true });
+    // But the alias is not safe to absorb — its original line must be kept.
+    expect(a!.lossless).toBe(false);
+    expect(a!.leftovers).toEqual(["--model", "opus"]);
+  });
+
+  it("is lossless regardless of flag ordering or quote style (round-trip-safe)", () => {
+    const rc = "alias c='claude --effort high --ide'\n";
+    const a = findAdoptableAlias(rc);
+    expect(a!.lossless).toBe(true);
+    expect(a!.leftovers).toEqual([]);
+  });
+
+  it("skips indented (non-top-level) alias lines", () => {
+    const rc = "my_func() {\n  alias c='claude --ide'\n}\n";
+    expect(findAdoptableAlias(rc)).toBeNull();
+  });
+
+  it("ignores an alias inside the managed block", () => {
+    const rc =
+      "# >>> claudeup managed alias >>>\nalias c='claude --ide'\n# <<< claudeup managed alias <<<\n";
+    expect(findAdoptableAlias(rc)).toBeNull();
+  });
+
+  it("picks the first top-level claude alias and notes the others", () => {
+    const rc =
+      "alias c='claude --ide'\nalias cc='claude --worktree'\n";
+    const a = findAdoptableAlias(rc);
+    expect(a!.name).toBe("c");
+    expect(a!.others).toEqual(["alias cc='claude --worktree'"]);
+  });
+
+  it("bails on a claude alias whose body contains a substitution", () => {
+    // Can't round-trip a $(...) — not adoptable at all.
+    const rc = "alias c='claude --append-system-prompt $(cat ~/p.txt)'\n";
+    expect(findAdoptableAlias(rc)).toBeNull();
+  });
+});
+
+// ─── spliceManagedBlockAtRange ─────────────────────────────────────────────
+
+describe("spliceManagedBlockAtRange", () => {
+  const block =
+    "# >>> claudeup managed alias >>>\nalias c='claude --ide'\n# <<< claudeup managed alias <<<\n";
+
+  it("replaces the adopted line in place (no duplicate alias)", () => {
+    const rc = "# header\nalias c='claude --dangerously-skip-permissions'\nexport X=1\n";
+    const result = spliceManagedBlockAtRange(rc, block, [1, 1]);
+    // The old hand-written line is gone; the block sits where it was.
+    expect(result).not.toContain(
+      "alias c='claude --dangerously-skip-permissions'",
+    );
+    expect(result).toContain("# >>> claudeup managed alias >>>");
+    expect(result).toContain("# header");
+    expect(result).toContain("export X=1");
+    // Exactly one `alias c=` line.
+    const count = (result.match(/^alias c=/gm) ?? []).length;
+    expect(count).toBe(1);
+  });
+
+  it("falls back to append when the range is out of bounds", () => {
+    const rc = "alias g='git'\n";
+    const result = spliceManagedBlockAtRange(rc, block, [99, 99]);
+    expect(result).toContain("alias g='git'");
+    expect(result).toContain("# >>> claudeup managed alias >>>");
+  });
+});
+
+// ─── End-to-end: adopt → write yields a single, clean managed block ─────────
+
+describe("adoption end-to-end", () => {
+  it("lossless adoption: parse → render → splice-at-range = one alias, original gone", () => {
+    const rc =
+      "# my zshrc\nexport EDITOR=vim\nalias c='claude --dangerously-skip-permissions'\n# eof\n";
+    const a = findAdoptableAlias(rc) as AdoptableAlias;
+    expect(a.lossless).toBe(true);
+
+    // Build a config from the adopted name + flags and render the block.
+    const config = defaultAliasConfig();
+    config.aliasName = a.name;
+    config.flags = { ...config.flags, ...a.flags };
+    const rendered = renderAlias(config, "zsh");
+
+    const next = spliceManagedBlockAtRange(rc, rendered.block, a.lineRange);
+
+    // Original hand-written line removed.
+    expect(next).not.toContain(
+      "alias c='claude --dangerously-skip-permissions'\n# eof",
+    );
+    // Managed block present with the same flag.
+    expect(next).toContain("# >>> claudeup managed alias >>>");
+    expect(next).toContain("--dangerously-skip-permissions");
+    // Exactly one `alias c=` and surrounding content intact.
+    expect((next.match(/^alias c=/gm) ?? []).length).toBe(1);
+    expect(next).toContain("export EDITOR=vim");
+    expect(next).toContain("# eof");
+  });
+});
+
+// ─── writeAliasToShell honors adoptLineRange (file I/O) ─────────────────────
+
+describe("writeAliasToShell — adoption path", () => {
+  let home: string;
+
+  beforeEach(async () => {
+    home = await mkdtemp(join(tmpdir(), "alias-adopt-write-"));
+  });
+
+  afterEach(async () => {
+    await rm(home, { recursive: true, force: true });
+  });
+
+  it("replaces the adopted line in place — never leaves a duplicate alias", async () => {
+    const path = join(home, ".zshrc");
+    // A real-world rc: hand-written `alias c=` plus surrounding content.
+    await writeFile(
+      path,
+      "export EDITOR=vim\nalias c='claude --dangerously-skip-permissions'\nalias g='git'\n",
+      "utf8",
+    );
+    const rc = await readFile(path, "utf8");
+    const a = findAdoptableAlias(rc) as AdoptableAlias;
+    expect(a.lossless).toBe(true);
+
+    const config = defaultAliasConfig();
+    config.aliasName = a.name;
+    config.flags = { ...config.flags, ...a.flags };
+
+    const target: ShellTarget = {
+      kind: "zsh",
+      path,
+      exists: true,
+      isDefault: true,
+    };
+    await writeAliasToShell(config, target, { adoptLineRange: a.lineRange });
+
+    const written = await readFile(path, "utf8");
+    // Original hand-written line removed.
+    expect(written).not.toContain(
+      "alias c='claude --dangerously-skip-permissions'\nalias g=",
+    );
+    // Managed block now owns the alias.
+    expect(written).toContain("# >>> claudeup managed alias >>>");
+    expect(written).toContain("--dangerously-skip-permissions");
+    // Exactly ONE `alias c=` definition (the whole point).
+    expect((written.match(/^alias c=/gm) ?? []).length).toBe(1);
+    // Surrounding lines preserved.
+    expect(written).toContain("export EDITOR=vim");
+    expect(written).toContain("alias g='git'");
+  });
+
+  it("not-lossless: managed block under a DISTINCT name never shadows the surviving original", async () => {
+    // The not-lossless UI path keeps the original line and writes the managed
+    // block under a name distinct from the original (no adoptLineRange). This
+    // test pins the no-shadow outcome at the service layer: two differently-
+    // named aliases coexist, and the original keeps ALL its tokens.
+    const path = join(home, ".zshrc");
+    await writeFile(
+      path,
+      "export EDITOR=vim\nalias c='claude --dangerously-skip-permissions --model opus'\nalias g='git'\n",
+      "utf8",
+    );
+    const a = findAdoptableAlias(await readFile(path, "utf8")) as AdoptableAlias;
+    expect(a.lossless).toBe(false);
+    expect(a.leftovers).toEqual(["--model", "opus"]);
+
+    // Managed block uses a DIFFERENT name (mirrors pickDistinctName → "cm").
+    const config = defaultAliasConfig();
+    config.aliasName = "cm";
+    config.flags = { ...config.flags, ...a.flags };
+    const target: ShellTarget = {
+      kind: "zsh",
+      path,
+      exists: true,
+      isDefault: true,
+    };
+    // No adoptLineRange — the original line must be left untouched.
+    await writeAliasToShell(config, target, {});
+
+    const written = await readFile(path, "utf8");
+    // The original `alias c=` survives, complete with --model opus.
+    expect(written).toContain(
+      "alias c='claude --dangerously-skip-permissions --model opus'",
+    );
+    // The managed block uses the distinct name.
+    expect(written).toContain("alias cm='claude --dangerously-skip-permissions'");
+    // Exactly one of each name — no duplicate, no same-name shadow.
+    expect((written.match(/^alias c=/gm) ?? []).length).toBe(1);
+    expect((written.match(/^alias cm=/gm) ?? []).length).toBe(1);
+  });
+
+  it("a SECOND write (range still passed) doesn't double the block — markers win", async () => {
+    const path = join(home, ".zshrc");
+    await writeFile(
+      path,
+      "alias c='claude --ide'\n",
+      "utf8",
+    );
+    const a = findAdoptableAlias(await readFile(path, "utf8")) as AdoptableAlias;
+    const config = defaultAliasConfig();
+    config.aliasName = a.name;
+    config.flags = { ...config.flags, ...a.flags };
+    const target: ShellTarget = {
+      kind: "zsh",
+      path,
+      exists: true,
+      isDefault: true,
+    };
+    // First write absorbs the line.
+    await writeAliasToShell(config, target, { adoptLineRange: a.lineRange });
+    // Second write with the SAME stale range — a managed block now exists, so
+    // the writer must ignore the range and splice by markers (idempotent).
+    await writeAliasToShell(config, target, { adoptLineRange: a.lineRange });
+
+    const written = await readFile(path, "utf8");
+    const beginCount = (
+      written.match(/# >>> claudeup managed alias >>>/g) ?? []
+    ).length;
+    expect(beginCount).toBe(1);
+    expect((written.match(/^alias c=/gm) ?? []).length).toBe(1);
+  });
+});