claudeup 4.18.0 → 4.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "4.18.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);
+  });
+});

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

@@ -6,6 +6,7 @@ import {
   tokenizePosixAliasBody,
   argsToFlagValues,
   renderAlias,
+  renderArgsAsTokens,
 } from "../services/alias-shell-writer";
 import { defaultAliasConfig } from "../services/alias-store";
 
@@ -295,6 +296,97 @@ describe("round-trip: render → parse → enabled subset matches", () => {
   });
 });
 
+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();

package/src/__tests__/alias-shell-writer.test.ts

@@ -92,7 +92,14 @@ describe("renderArgs", () => {
       enabled: true,
       values: ["plugin:claudish@magus", "plugin:dev@magus"],
     };
+    // Enabling dev-load also forces --channels to emit (the render-time union),
+    // since a dev-loaded channel must be on the channels list to run. --channels
+    // comes first (catalog order), then the repeated dev-load pairs.
     expect(renderArgs(c)).toEqual([
+      "--channels",
+      "plugin:claudish@magus",
+      "--channels",
+      "plugin:dev@magus",
       "--dangerously-load-development-channels",
       "plugin:claudish@magus",
       "--dangerously-load-development-channels",

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

@@ -3,10 +3,20 @@ import {
   defaultAliasConfig,
   defaultValueFor,
   validateAliasName,
+  derivedChannelValues,
+  withoutDerivedChannel,
+  listValues,
+  CHANNELS_FLAG_ID,
+  DEVLOAD_FLAG_ID,
   DEFAULT_ALIAS_NAME,
+  type FlagValue,
 } from "../services/alias-store";
 import { ALIAS_FLAGS } from "../data/alias-flags";
 
+function textList(values: string[], enabled = true): FlagValue {
+  return { kind: "text-list", enabled, values };
+}
+
 describe("defaultAliasConfig", () => {
   it("seeds every known flag with a sane default and the default alias name", () => {
     const c = defaultAliasConfig();
@@ -64,6 +74,73 @@ describe("defaultValueFor", () => {
   });
 });
 
+describe("derivedChannelValues (derive-on-display model)", () => {
+  it("returns dev-load values when the dev-load flag is enabled", () => {
+    const flags: Record<string, FlagValue> = {
+      [DEVLOAD_FLAG_ID]: textList(["plugin:claudish@magus"], true),
+      [CHANNELS_FLAG_ID]: textList([], false),
+    };
+    expect(derivedChannelValues(flags)).toEqual(["plugin:claudish@magus"]);
+  });
+
+  it("returns nothing when the dev-load flag is DISABLED", () => {
+    const flags: Record<string, FlagValue> = {
+      [DEVLOAD_FLAG_ID]: textList(["plugin:claudish@magus"], false),
+      [CHANNELS_FLAG_ID]: textList([], false),
+    };
+    expect(derivedChannelValues(flags)).toEqual([]);
+  });
+
+  it("returns nothing when the dev-load flag is absent", () => {
+    expect(derivedChannelValues({})).toEqual([]);
+  });
+
+  it("does NOT read from channels.values (provenance stays separate)", () => {
+    // channels holds OWN values; dev-load is the only derived source.
+    const flags: Record<string, FlagValue> = {
+      [CHANNELS_FLAG_ID]: textList(["plugin:own@m"], true),
+      [DEVLOAD_FLAG_ID]: textList(["plugin:dev@m"], true),
+    };
+    expect(derivedChannelValues(flags)).toEqual(["plugin:dev@m"]);
+    // channels.values is untouched — own only.
+    expect(listValues(flags[CHANNELS_FLAG_ID])).toEqual(["plugin:own@m"]);
+  });
+});
+
+describe("withoutDerivedChannel (delete-through to dev-load)", () => {
+  it("removes the value from dev-load, NOT from channels.values", () => {
+    const flags: Record<string, FlagValue> = {
+      [CHANNELS_FLAG_ID]: textList(["plugin:own@m"], true),
+      [DEVLOAD_FLAG_ID]: textList(["plugin:dev@m", "plugin:keep@m"], true),
+    };
+    const next = withoutDerivedChannel(flags, "plugin:dev@m");
+    expect(listValues(next[DEVLOAD_FLAG_ID])).toEqual(["plugin:keep@m"]);
+    // channels.values untouched — the deletion landed on the source flag.
+    expect(listValues(next[CHANNELS_FLAG_ID])).toEqual(["plugin:own@m"]);
+  });
+
+  it("disables dev-load when its last value is removed", () => {
+    const flags: Record<string, FlagValue> = {
+      [DEVLOAD_FLAG_ID]: textList(["plugin:only@m"], true),
+    };
+    const next = withoutDerivedChannel(flags, "plugin:only@m");
+    expect(next[DEVLOAD_FLAG_ID]).toEqual({
+      kind: "text-list",
+      enabled: false,
+      values: [],
+    });
+  });
+
+  it("is a no-op when the value isn't present", () => {
+    const flags: Record<string, FlagValue> = {
+      [DEVLOAD_FLAG_ID]: textList(["plugin:a@m"], true),
+    };
+    expect(listValues(withoutDerivedChannel(flags, "nope")[DEVLOAD_FLAG_ID])).toEqual([
+      "plugin:a@m",
+    ]);
+  });
+});
+
 describe("validateAliasName", () => {
   it("accepts safe identifiers", () => {
     expect(validateAliasName("c")).toBeNull();