claudeup 4.17.0 → 4.19.0

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

@@ -0,0 +1,163 @@
+import { describe, it, expect } from "bun:test";
+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();
+    expect(c.aliasName).toBe(DEFAULT_ALIAS_NAME);
+    expect(c.aliasName).toBe("c");
+    expect(c.flags["dangerously-skip-permissions"]).toEqual({
+      kind: "boolean",
+      enabled: false,
+    });
+    expect(c.flags["chrome"]).toEqual({ kind: "tri-state", state: "unset" });
+    expect(c.flags["effort"]).toEqual({
+      kind: "select",
+      enabled: false,
+      value: "low",
+    });
+    expect(c.flags["dangerously-load-development-channels"]).toEqual({
+      kind: "text-list",
+      enabled: false,
+      values: ["plugin:claudish@magus"],
+    });
+    expect(c.flags["debug"]).toEqual({
+      kind: "multi-with-custom",
+      enabled: false,
+      picked: [],
+      custom: [],
+    });
+  });
+
+  it("covers every flag in the catalog", () => {
+    const c = defaultAliasConfig();
+    for (const flag of ALIAS_FLAGS) {
+      expect(c.flags[flag.id]).toBeDefined();
+    }
+  });
+});
+
+describe("defaultValueFor", () => {
+  it("returns the right default for each kind", () => {
+    const ide = ALIAS_FLAGS.find((f) => f.id === "ide")!;
+    expect(defaultValueFor(ide)).toEqual({ kind: "boolean", enabled: false });
+
+    const chrome = ALIAS_FLAGS.find((f) => f.id === "chrome")!;
+    expect(defaultValueFor(chrome)).toEqual({
+      kind: "tri-state",
+      state: "unset",
+    });
+
+    const debug = ALIAS_FLAGS.find((f) => f.id === "debug")!;
+    expect(defaultValueFor(debug)).toEqual({
+      kind: "multi-with-custom",
+      enabled: false,
+      picked: [],
+      custom: [],
+    });
+  });
+});
+
+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();
+    expect(validateAliasName("claude")).toBeNull();
+    expect(validateAliasName("cc-yolo_2")).toBeNull();
+    expect(validateAliasName("_underscore")).toBeNull();
+  });
+
+  it("rejects empty, leading-digit, and special-char names", () => {
+    expect(validateAliasName("")).toMatch(/empty/);
+    expect(validateAliasName("9live")).toMatch(/letter/);
+    expect(validateAliasName("c laude")).toMatch(/letters/);
+    expect(validateAliasName("c'")).toMatch(/letters/);
+    expect(validateAliasName("c=d")).toMatch(/letters/);
+  });
+
+  it("rejects pathologically long names", () => {
+    expect(validateAliasName("a".repeat(64))).toMatch(/long/);
+  });
+});

package/src/__tests__/gitignore-fixer.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtemp, rm, writeFile, readFile } from "node:fs/promises";
+import { mkdtemp, rm, writeFile, readFile, mkdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { spawnSync } from "node:child_process";
@@ -50,6 +50,8 @@ describe("applySafeFixes", () => {
     expect(content).toContain(".env");
     expect(content).toContain(".mnemex/");
     expect(content).toContain("# Added by claudeup");
+    expect(content).toContain("Environment files commonly contain");
+    expect(content).toContain("Local memory/index data");
   });
 
   it("creates .gitignore if absent", async () => {
@@ -151,6 +153,67 @@ describe("applyDestructiveFix", () => {
     expect(ls.stdout).toContain(".mcp.json");
   });
 
+  it("adds unignore exceptions when a parent rule ignores a tracked path", async () => {
+    await mkdir(join(repo, ".claude"), { recursive: true });
+    await writeFile(join(repo, ".claude", "settings.json"), "{}");
+    await writeFile(join(repo, ".gitignore"), "/*\n");
+
+    const r = await applyDestructiveFix(repo, {
+      kind: "ignored-but-should-track",
+      path: ".claude/settings.json",
+      source: "builtin",
+      severity: "destructive",
+    });
+    expect(r.applied).toBe(true);
+
+    const ignore = await readFile(join(repo, ".gitignore"), "utf8");
+    expect(ignore).toContain("!/.claude/");
+    expect(ignore).toContain("!/.claude/settings.json");
+    expect(ignore).toContain("Team Claude settings should be committed");
+
+    const ls = git(repo, "ls-files");
+    expect(ls.stdout).toContain(".claude/settings.json");
+  });
+
+  it("does not fail when making an absent tracked path trackable", async () => {
+    await writeFile(join(repo, ".gitignore"), "/*\n");
+
+    const r = await applyDestructiveFix(repo, {
+      kind: "ignored-but-should-track",
+      path: "plugin.json",
+      source: "builtin",
+      severity: "destructive",
+    });
+    expect(r.applied).toBe(true);
+    expect(r.message).toContain("does not exist yet");
+
+    const ignore = await readFile(join(repo, ".gitignore"), "utf8");
+    expect(ignore).toContain("!/plugin.json");
+  });
+
+  it("uses the managed rule pattern when untracking child violations", async () => {
+    await mkdir(join(repo, "logs"), { recursive: true });
+    await writeFile(join(repo, "logs", "app.log"), "x");
+    git(repo, "add", "logs/app.log");
+    git(repo, "commit", "-q", "-m", "add log");
+
+    const r = await applyDestructiveFix(
+      repo,
+      {
+        kind: "tracked-but-should-ignore",
+        path: "logs/app.log",
+        source: "builtin",
+        severity: "destructive",
+      },
+      "logs/",
+    );
+    expect(r.applied).toBe(true);
+
+    const ignore = await readFile(join(repo, ".gitignore"), "utf8");
+    expect(ignore).toContain("logs/");
+    expect(ignore).not.toMatch(/^logs\/app\.log$/m);
+  });
+
   it("stages an untracked file", async () => {
     await writeFile(join(repo, ".mcp.json"), "{}");
     const r = await applyDestructiveFix(repo, {

package/src/__tests__/gitignore-prerun.test.ts

@@ -69,7 +69,7 @@ describe("formatPrerunWarning", () => {
   it("returns a warning string when violations exist", () => {
     const w = formatPrerunWarning({ violationCount: 3, warnings: [] });
     expect(w).not.toBeNull();
-    expect(w).toContain("3 gitignore");
-    expect(w).toContain("Gitignore tab");
+    expect(w).toContain("3 git state");
+    expect(w).toContain("Git State tab");
   });
 });

package/src/__tests__/gitignore-service.test.ts

@@ -6,6 +6,7 @@ import { spawnSync } from "node:child_process";
 import {
   loadGitignoreState,
   applyTemplate,
+  ensureProjectManifestForEdit,
 } from "../services/gitignore-service";
 
 function git(cwd: string, ...args: string[]): void {
@@ -91,3 +92,44 @@ describe("applyTemplate", () => {
     );
   });
 });
+
+describe("ensureProjectManifestForEdit", () => {
+  let projectDir: string;
+
+  beforeEach(async () => {
+    projectDir = await mkdtemp(join(tmpdir(), "gitig-edit-"));
+  });
+
+  afterEach(async () => {
+    await rm(projectDir, { recursive: true, force: true });
+  });
+
+  it("creates an editable project manifest from resolved rules", async () => {
+    const path = await ensureProjectManifestForEdit(projectDir, {
+      rules: [
+        { pattern: ".env", action: "ignore", source: "builtin" },
+        { pattern: ".mcp.json", action: "track", source: "builtin" },
+      ],
+      conflicts: [],
+    });
+
+    expect(path).toBe(join(projectDir, ".claude", "gitignore.json"));
+    const written = JSON.parse(await readFile(path, "utf8"));
+    expect(written.ignore).toEqual([".env"]);
+    expect(written.track).toEqual([".mcp.json"]);
+  });
+
+  it("keeps an existing non-empty project manifest", async () => {
+    const path = join(projectDir, ".claude", "gitignore.json");
+    await mkdir(join(projectDir, ".claude"), { recursive: true });
+    await writeFile(path, JSON.stringify({ ignore: ["custom"], track: [] }));
+
+    await ensureProjectManifestForEdit(projectDir, {
+      rules: [{ pattern: ".env", action: "ignore", source: "builtin" }],
+      conflicts: [],
+    });
+
+    const written = JSON.parse(await readFile(path, "utf8"));
+    expect(written.ignore).toEqual(["custom"]);
+  });
+});

package/src/__tests__/marketplaces.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "bun:test";
+import {
+	defaultMarketplaces,
+	deprecatedMarketplaces,
+	getAllMarketplaces,
+} from "../data/marketplaces.js";
+import type { LocalMarketplace } from "../services/local-marketplace.js";
+
+describe("marketplaces", () => {
+	it("uses the canonical Superpowers marketplace by default", () => {
+		const superpowers = defaultMarketplaces.find(
+			(mp) => mp.name === "superpowers-marketplace",
+		);
+
+		expect(superpowers).toBeDefined();
+		expect(superpowers?.displayName).toBe("Superpowers");
+		expect(superpowers?.source.repo).toBe("obra/superpowers-marketplace");
+		expect(superpowers?.featured).toBe(true);
+		expect(deprecatedMarketplaces.superpowers).toBe("superpowers-marketplace");
+	});
+
+	it("hides stale local superpowers entries behind the canonical marketplace", () => {
+		const local = new Map<string, LocalMarketplace>([
+			[
+				"superpowers",
+				{
+					name: "superpowers-dev",
+					description: "Development marketplace",
+					gitRepo: "obra/superpowers",
+					plugins: [],
+				},
+			],
+		]);
+
+		const names = getAllMarketplaces(local).map((mp) => mp.name);
+
+		expect(names).toContain("superpowers-marketplace");
+		expect(names).not.toContain("superpowers");
+	});
+});

package/src/__tests__/plugin-manager-fallback.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import {
+  resolveMarketplacePlugins,
+  clearMarketplaceCache,
+} from "../services/marketplace-fetcher";
+import type {
+  LocalMarketplace,
+  LocalMarketplacePlugin,
+} from "../services/local-marketplace";
+
+/**
+ * Regression coverage for the "deprecated everything" bug.
+ *
+ * When `fetchMarketplacePlugins` returns an empty list (network down,
+ * repo moved, GitHub blocked, etc.), the orphan-detection loop in
+ * `getAvailablePlugins` would flag every installed plugin as
+ * `isOrphaned: true` and the UI rendered them all as "deprecated".
+ *
+ * `resolveMarketplacePlugins` adds the local-marketplace cache as a
+ * fallback so installed plugins keep rendering with their real metadata
+ * even when the machine is offline.
+ */
+
+function buildLocalMarketplace(
+  name: string,
+  plugins: LocalMarketplacePlugin[],
+): LocalMarketplace {
+  return { name, description: "", plugins };
+}
+
+describe("resolveMarketplacePlugins — offline fallback", () => {
+  beforeEach(() => {
+    // Session-level cache could otherwise carry over a previous test's
+    // successful fetch and short-circuit the fallback path.
+    clearMarketplaceCache();
+  });
+
+  it("falls back to the local cache when the remote fetch returns empty", async () => {
+    const local = new Map<string, LocalMarketplace>([
+      [
+        "magus",
+        buildLocalMarketplace("magus", [
+          {
+            name: "code-analysis",
+            version: "5.3.0",
+            description: "Codebase investigation tools",
+            category: "development",
+            author: { name: "Jack Rudenko" },
+          },
+          {
+            name: "dev",
+            version: "2.7.0",
+            description: "Dev workflow",
+          },
+        ]),
+      ],
+    ]);
+
+    // An invalid repo string short-circuits `fetchMarketplacePlugins` to
+    // `[]` without any network call, simulating the offline case.
+    const resolved = await resolveMarketplacePlugins(
+      "magus",
+      "not a valid repo string",
+      local,
+    );
+
+    expect(resolved).toHaveLength(2);
+    expect(resolved.map((p) => p.name).sort()).toEqual([
+      "code-analysis",
+      "dev",
+    ]);
+    const codeAnalysis = resolved.find((p) => p.name === "code-analysis");
+    expect(codeAnalysis?.version).toBe("5.3.0");
+    expect(codeAnalysis?.description).toBe("Codebase investigation tools");
+    expect(codeAnalysis?.category).toBe("development");
+    expect(codeAnalysis?.author?.name).toBe("Jack Rudenko");
+  });
+
+  it("returns empty when both remote and cache are empty", async () => {
+    const local = new Map<string, LocalMarketplace>();
+    const resolved = await resolveMarketplacePlugins(
+      "magus",
+      "not a valid repo string",
+      local,
+    );
+    expect(resolved).toEqual([]);
+  });
+
+  it("returns empty when remote fails AND cache exists but has no plugins", async () => {
+    const local = new Map<string, LocalMarketplace>([
+      ["magus", buildLocalMarketplace("magus", [])],
+    ]);
+    const resolved = await resolveMarketplacePlugins(
+      "magus",
+      "not a valid repo string",
+      local,
+    );
+    expect(resolved).toEqual([]);
+  });
+
+  it("does not consult the cache when the remote returns plugins", async () => {
+    // We can't easily exercise the success branch without a live network,
+    // but we can verify that a cache entry for a DIFFERENT marketplace
+    // doesn't bleed into the requested one.
+    const local = new Map<string, LocalMarketplace>([
+      [
+        "other-marketplace",
+        buildLocalMarketplace("other-marketplace", [
+          { name: "should-not-leak", version: "0.0.1", description: "" },
+        ]),
+      ],
+    ]);
+    const resolved = await resolveMarketplacePlugins(
+      "magus",
+      "not a valid repo string",
+      local,
+    );
+    expect(resolved).toEqual([]);
+  });
+});

package/src/__tests__/plugin-setup.test.ts

@@ -73,6 +73,8 @@ mock.module("node:child_process", () => ({
 // Import AFTER mocks are set up
 const {
 	extractGoBinaryName,
+	extractGoVersion,
+	goDepNeedsInstall,
 	installPluginDeps,
 	checkMissingDeps,
 } = await import("../services/plugin-setup.js");
@@ -259,6 +261,115 @@ describe("checkMissingDeps — go packages", () => {
 	});
 });
 
+// ---------------------------------------------------------------------------
+// 4b. Version-aware go dependencies — a bumped plugin must pull the new binary
+// ---------------------------------------------------------------------------
+
+describe("extractGoVersion", () => {
+	it("returns the pinned version", () => {
+		expect(
+			extractGoVersion("github.com/MadAppGang/tmux-mcp@v1.6.2"),
+		).toBe("v1.6.2");
+	});
+	it("returns null for @latest (a moving target)", () => {
+		expect(
+			extractGoVersion("github.com/MadAppGang/tmux-mcp@latest"),
+		).toBeNull();
+	});
+	it("returns null when unpinned", () => {
+		expect(extractGoVersion("github.com/user/tool")).toBeNull();
+	});
+});
+
+describe("goDepNeedsInstall — version awareness", () => {
+	beforeEach(() => {
+		availableBinaries = new Set(["go"]);
+		execResults = new Map();
+	});
+
+	it("reinstalls when the pinned version differs from the installed one", async () => {
+		availableBinaries.add("tmux-mcp");
+		execResults.set("tmux-mcp --version", { stdout: "v1.6.1", stderr: "" });
+
+		expect(
+			await goDepNeedsInstall("github.com/MadAppGang/tmux-mcp@v1.6.2"),
+		).toBe(true);
+	});
+
+	it("skips when the installed version matches the pin (v-prefix insensitive)", async () => {
+		availableBinaries.add("tmux-mcp");
+		execResults.set("tmux-mcp --version", { stdout: "1.6.2", stderr: "" });
+
+		expect(
+			await goDepNeedsInstall("github.com/MadAppGang/tmux-mcp@v1.6.2"),
+		).toBe(false);
+	});
+
+	it("reinstalls when the binary can't report its version", async () => {
+		availableBinaries.add("tmux-mcp");
+		execResults.set("tmux-mcp --version", {
+			stdout: "",
+			stderr: "flag provided but not defined: -version",
+			error: true,
+		});
+
+		expect(
+			await goDepNeedsInstall("github.com/MadAppGang/tmux-mcp@v1.6.2"),
+		).toBe(true);
+	});
+
+	it("installs when the binary is absent", async () => {
+		expect(
+			await goDepNeedsInstall("github.com/MadAppGang/tmux-mcp@v1.6.2"),
+		).toBe(true);
+	});
+
+	it("leaves an unpinned (@latest) present binary alone", async () => {
+		availableBinaries.add("tmux-mcp");
+		expect(
+			await goDepNeedsInstall("github.com/MadAppGang/tmux-mcp@latest"),
+		).toBe(false);
+	});
+});
+
+describe("checkMissingDeps — pinned go version mismatch", () => {
+	beforeEach(() => {
+		availableBinaries = new Set(["go", "tmux-mcp"]);
+		execResults = new Map();
+	});
+
+	it("reports a present-but-outdated pinned binary as missing", async () => {
+		execResults.set("tmux-mcp --version", { stdout: "v1.6.1", stderr: "" });
+
+		const missing = await checkMissingDeps({
+			go: ["github.com/MadAppGang/tmux-mcp@v1.6.2"],
+		});
+
+		expect(missing.go).toEqual(["github.com/MadAppGang/tmux-mcp@v1.6.2"]);
+	});
+});
+
+describe("installPluginDeps — reinstalls an outdated pinned go binary", () => {
+	beforeEach(() => {
+		availableBinaries = new Set(["go", "tmux-mcp"]);
+		execResults = new Map();
+	});
+
+	it("runs go install when the pinned version is newer than installed", async () => {
+		execResults.set("tmux-mcp --version", { stdout: "v1.6.1", stderr: "" });
+		execResults.set("/usr/bin/go install", { stdout: "", stderr: "" });
+
+		const result = await installPluginDeps({
+			go: ["github.com/MadAppGang/tmux-mcp@v1.6.2"],
+		});
+
+		expect(result.installed).toContain(
+			"go:github.com/MadAppGang/tmux-mcp@v1.6.2",
+		);
+		expect(result.skipped).toHaveLength(0);
+	});
+});
+
 // ---------------------------------------------------------------------------
 // 5. checkMissingDeps tests — required binaries
 // ---------------------------------------------------------------------------

package/src/__tests__/useGitignoreModal.test.ts

@@ -31,7 +31,7 @@ describe("buildGitignoreModal", () => {
     expect(dismissed).toBe(true);
   });
 
-  it("shows '(no safe-fixable entries)' label when safeCount is 0", () => {
+  it("shows no missing entries label when safeCount is 0", () => {
     const modal = buildGitignoreModal({
       violationCount: 2,
       safeCount: 0,
@@ -40,7 +40,7 @@ describe("buildGitignoreModal", () => {
       onDismiss: () => {},
     });
     if (modal.type !== "select") throw new Error("type guard");
-    expect(modal.options[0].label).toContain("no safe-fixable");
+    expect(modal.options[0].label).toContain("no missing .gitignore");
   });
 
   it("includes violation count in the message", () => {