claudeup 6.2.0 → 6.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "6.2.0",
+  "version": "6.2.1",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -64,8 +64,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "claudeup-darwin-arm64": "6.2.0",
-    "claudeup-darwin-x64": "6.2.0",
-    "claudeup-linux-x64": "6.2.0"
+    "claudeup-darwin-arm64": "6.2.1",
+    "claudeup-darwin-x64": "6.2.1",
+    "claudeup-linux-x64": "6.2.1"
   }
 }

package/src/__tests__/go-module.test.ts

@@ -0,0 +1,43 @@
+/**
+ * goBinaryName: the one rule for turning a Go module path into the binary
+ * `go install` produces. Both consumers (plugin-setup's Go path and
+ * plugin-requires' `setup.go` branch) are tested through their own surfaces;
+ * this file pins the rule itself.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { goBinaryName } from "../utils/go-module.js";
+
+describe("goBinaryName", () => {
+	test("takes the last segment of a v0/v1 module path", () => {
+		expect(goBinaryName("github.com/MadAppGang/tmux-mcp")).toBe("tmux-mcp");
+	});
+
+	test("strips a trailing /v2 major-version suffix before taking the name", () => {
+		expect(goBinaryName("github.com/MadAppGang/tmux-mcp/v2")).toBe("tmux-mcp");
+	});
+
+	test("strips multi-digit suffixes (/v10, /v42)", () => {
+		expect(goBinaryName("github.com/x/tool/v10")).toBe("tool");
+		expect(goBinaryName("github.com/x/tool/v42")).toBe("tool");
+	});
+
+	test("a segment that merely starts with v2 is a name, not a suffix", () => {
+		expect(goBinaryName("github.com/x/v2tool")).toBe("v2tool");
+	});
+
+	test("v0 and v1 are never path suffixes, so they stay as names", () => {
+		// Nobody names a binary this, but the rule must not invent an exception.
+		expect(goBinaryName("github.com/x/v1")).toBe("v1");
+		expect(goBinaryName("github.com/x/v0")).toBe("v0");
+	});
+
+	test("a suffix in the middle of the path is not trailing and is kept", () => {
+		expect(goBinaryName("github.com/x/repo/v2/cmd/cli")).toBe("cli");
+	});
+
+	test("single-segment and empty inputs pass through", () => {
+		expect(goBinaryName("mytool")).toBe("mytool");
+		expect(goBinaryName("")).toBe("");
+	});
+});

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

@@ -69,6 +69,46 @@ describe("parsePluginRequires — setup block (the established convention)", ()
 		expect(tmux.formula).toBe("tmux");
 	});
 
+	// Negative control for the /vN fix: basename(base) yields "v2" here, so
+	// without the go-module helper this test FAILS on `name`.
+	test("terminal's v2 pin: /v2 is the module's major version, not the binary", () => {
+		const r = parsePluginRequires({
+			name: "terminal",
+			setup: { go: ["github.com/MadAppGang/tmux-mcp/v2@v2.0.0"] },
+		});
+		expect(r.bin).toEqual([
+			{
+				name: "tmux-mcp",
+				via: "go",
+				module: "github.com/MadAppGang/tmux-mcp/v2",
+				version: "v2.0.0",
+				check: "tmux-mcp --version",
+			},
+		]);
+	});
+
+	// One manifest per spec: entries are keyed by binary name, so a v1 and a v2
+	// pin of the same module in ONE setup would (correctly) collapse to one.
+	test.each([
+		[
+			"github.com/MadAppGang/tmux-mcp@v1.7.1",
+			{ name: "tmux-mcp", module: "github.com/MadAppGang/tmux-mcp", version: "v1.7.1" },
+		],
+		[
+			"github.com/MadAppGang/tmux-mcp/v2",
+			{ name: "tmux-mcp", module: "github.com/MadAppGang/tmux-mcp/v2", version: undefined },
+		],
+		[
+			"github.com/x/v2tool@v1.0.0",
+			{ name: "v2tool", module: "github.com/x/v2tool", version: "v1.0.0" },
+		],
+	])("go spec %s → name/module/version", (spec, expected) => {
+		const r = parsePluginRequires({ setup: { go: [spec] } });
+		expect(
+			r.bin!.map((b) => ({ name: b.name, module: b.module, version: b.version })),
+		).toEqual([expected]);
+	});
+
 	test("browser-use's setup: pip packages", () => {
 		const r = parsePluginRequires({
 			name: "browser-use",

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

@@ -86,6 +86,7 @@ const {
 	extractGoVersion,
 	extractBinaryName,
 	parseAtSpec,
+	parseGoSpec,
 	parsePipSpec,
 	goDepNeedsInstall,
 	goDepDecision,
@@ -127,6 +128,89 @@ describe("extractGoBinaryName", () => {
 	it("handles empty string gracefully", () => {
 		expect(extractGoBinaryName("")).toBe("");
 	});
+
+	// Negative control for the /vN fix: a plain basename returns "v2" here.
+	// Without the go-module helper wired in, this test FAILS.
+	it("names the binary after the module, not its /v2 major-version suffix", () => {
+		expect(
+			extractGoBinaryName("github.com/MadAppGang/tmux-mcp/v2@v2.0.0"),
+		).toBe("tmux-mcp");
+	});
+
+	it("strips the /v2 suffix from an unpinned module path too", () => {
+		expect(extractGoBinaryName("github.com/MadAppGang/tmux-mcp/v2")).toBe(
+			"tmux-mcp",
+		);
+	});
+
+	it("keeps a name that merely starts with v2", () => {
+		expect(extractGoBinaryName("github.com/x/v2tool@v1.0.0")).toBe("v2tool");
+	});
+});
+
+// ---------------------------------------------------------------------------
+// 1b. parseGoSpec — the Go-specific view over parseAtSpec
+// ---------------------------------------------------------------------------
+
+describe("parseGoSpec", () => {
+	it("v1 module: name and pinned version", () => {
+		expect(parseGoSpec("github.com/MadAppGang/tmux-mcp@v1.7.1")).toEqual({
+			spec: "github.com/MadAppGang/tmux-mcp@v1.7.1",
+			name: "tmux-mcp",
+			version: "v1.7.1",
+		});
+	});
+
+	it("v2 module: the /v2 suffix is not the name, the version survives", () => {
+		expect(parseGoSpec("github.com/MadAppGang/tmux-mcp/v2@v2.0.0")).toEqual({
+			spec: "github.com/MadAppGang/tmux-mcp/v2@v2.0.0",
+			name: "tmux-mcp",
+			version: "v2.0.0",
+		});
+	});
+
+	it("v2 module without a pin: name resolved, version null", () => {
+		expect(parseGoSpec("github.com/MadAppGang/tmux-mcp/v2")).toEqual({
+			spec: "github.com/MadAppGang/tmux-mcp/v2",
+			name: "tmux-mcp",
+			version: null,
+		});
+	});
+
+	it("a segment that starts with v2 is a real name", () => {
+		expect(parseGoSpec("github.com/x/v2tool@v1.0.0")).toEqual({
+			spec: "github.com/x/v2tool@v1.0.0",
+			name: "v2tool",
+			version: "v1.0.0",
+		});
+	});
+
+	it("@latest is unpinned, same as parseAtSpec", () => {
+		expect(parseGoSpec("github.com/MadAppGang/tmux-mcp/v2@latest")).toEqual({
+			spec: "github.com/MadAppGang/tmux-mcp/v2@latest",
+			name: "tmux-mcp",
+			version: null,
+		});
+	});
+
+	// Terminal 5.0.0 contract cases (test plan Area 3, C5 and C6). They live
+	// here rather than in their own file because any test file that imports
+	// plugin-setup.js ahead of the mock.module seam above bakes the real
+	// execFile into promisify() and fails the installPluginDeps suites.
+	it("C5: a /v10 suffix is stripped in full, not only its first digit", () => {
+		const { name, version } = parseGoSpec("github.com/x/tool/v10@v10.1.0");
+		expect({ name, version }).toEqual({ name: "tool", version: "v10.1.0" });
+	});
+
+	it("C6: /v1 is never a Go major-version suffix, so it stays the name", () => {
+		const { name, version } = parseGoSpec("github.com/x/tool/v1@v1.0.0");
+		expect({ name, version }).toEqual({ name: "v1", version: "v1.0.0" });
+	});
+
+	it("C6 control: the same shape at /v2 is a suffix and is stripped", () => {
+		const { name, version } = parseGoSpec("github.com/x/tool/v2@v2.0.0");
+		expect({ name, version }).toEqual({ name: "tool", version: "v2.0.0" });
+	});
 });
 
 // ---------------------------------------------------------------------------
@@ -295,6 +379,14 @@ describe("extractGoVersion", () => {
 	it("returns null when unpinned", () => {
 		expect(extractGoVersion("github.com/user/tool")).toBeNull();
 	});
+	it("reads the pin behind a /v2 module path", () => {
+		expect(
+			extractGoVersion("github.com/MadAppGang/tmux-mcp/v2@v2.0.0"),
+		).toBe("v2.0.0");
+	});
+	it("a /v2 module path with no pin is unpinned, not pinned to v2", () => {
+		expect(extractGoVersion("github.com/MadAppGang/tmux-mcp/v2")).toBeNull();
+	});
 });
 
 describe("goDepNeedsInstall — version awareness", () => {
@@ -666,6 +758,16 @@ describe("parseAtSpec", () => {
 		expect(parseAtSpec("tool@latest").version).toBeNull();
 	});
 
+	it("does NOT apply the Go /vN rule — an npm scope may be named v2", () => {
+		// The Go major-version strip lives in parseGoSpec only; folding it in
+		// here would turn this scoped npm package into "@scope".
+		expect(parseAtSpec("@scope/v2@1.0.0")).toEqual({
+			spec: "@scope/v2@1.0.0",
+			name: "v2",
+			version: "1.0.0",
+		});
+	});
+
 	it("treats a bare name as unpinned", () => {
 		expect(parseAtSpec("tool")).toEqual({
 			spec: "tool",

package/src/services/content-drift.ts

@@ -7,7 +7,7 @@
  * invisible. No update is offered, and the only cure is a reinstall — which is
  * exactly the "plugin says installed but its skills are missing" report.
  *
- * This is not a hypothetical. `publish-dist.sh` force-pushes a rebuilt tree, so
+ * This is not a hypothetical. `publish-dist.sh` pushes a rebuilt tree, so
  * same-version-different-content is a normal outcome of the release process.
  * Measured on 2026-08-06: `cache/magus/dev/3.0.1/skills` held
  * {audit, tui-progress} while `marketplaces/magus/plugins/dev/skills` held

package/src/services/local-marketplace.ts

@@ -113,11 +113,13 @@ function getGitRemote(marketplacePath: string): string | undefined {
  * Names of the skills under `skillsDir`, recursing through grouping directories.
  *
  * A skill is a directory holding a SKILL.md, and it may sit one or more levels
- * down: dev groups its 43 skills under `skills/frontend/`, `skills/backend/`
- * and so on, and mattpocock groups its 37 under `skills/engineering/`. Reading
- * only the top level counted the *groups* — dev reported 9 skills against 43 on
- * disk, mattpocock 5 against 37 — and that count is what the plugin detail
- * panel prints.
+ * down: dev nests its skills by category under `skills/frontend/`,
+ * `skills/backend/` and so on, and mattpocock groups its 37 under
+ * `skills/engineering/`. Reading only the top level counted the *groups* — dev
+ * once reported 9 skills against 43 on disk, mattpocock 5 against 37 — and that
+ * count is what the plugin detail panel prints. dev also ships a `knowledge/`
+ * tree beside `skills/`: reference manuals reached by path, holding no SKILL.md
+ * and registering nothing, so this scan correctly never sees them.
  *
  * Depth is capped because this runs over every plugin of every cloned
  * marketplace on each list load, and a skill nested four levels below `skills/`

package/src/services/plugin-requires.ts

@@ -15,6 +15,7 @@ import type {
 	BinRequirement,
 	PluginRequires,
 } from "../types/index.js";
+import { goBinaryName } from "../utils/go-module.js";
 import { parsePluginId } from "../utils/string-utils.js";
 import { getLocalMarketplacesInfo } from "./plugin-manager.js";
 
@@ -98,15 +99,19 @@ function parseSetup(setup: unknown): BinRequirement[] {
 	pkgManager("npm");
 	pkgManager("pip");
 
+	// Not basename(): a Go module's trailing /vN is its major version, not the
+	// binary. `tmux-mcp/v2` installs `tmux-mcp`; naming it `v2` here made every
+	// downstream presence check look for a binary that never exists.
 	for (const spec of (s.go as string[] | undefined) ?? []) {
 		if (typeof spec !== "string") continue;
 		const { base, version } = splitVersion(spec);
+		const name = goBinaryName(base);
 		bins.push({
-			name: basename(base),
+			name,
 			via: "go",
 			module: base,
 			version,
-			check: `${basename(base)} --version`,
+			check: `${name} --version`,
 		});
 	}
 	for (const spec of (s.brew as string[] | undefined) ?? []) {

package/src/services/plugin-setup.ts

@@ -33,6 +33,7 @@ import { constants as fsConstants } from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { which } from "../utils/command-utils.js";
+import { goBinaryName } from "../utils/go-module.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -392,14 +393,32 @@ async function installCargoPackages(
 	}
 }
 
+/**
+ * {@link parseAtSpec} for a Go module spec.
+ *
+ * Same split, but the name comes from {@link goBinaryName}: Go's `/vN`
+ * major-version suffix is part of the module path, not the binary, so
+ * "github.com/MadAppGang/tmux-mcp/v2@v2.0.0" installs `tmux-mcp`, not `v2`.
+ * The generic parser cannot do this — an npm scope may legitimately be `v2`.
+ */
+export function parseGoSpec(spec: string): ParsedSpec {
+	const parsed = parseAtSpec(spec);
+	// Same separator rule as parseAtSpec: a leading `@` is never a version.
+	const at = spec.lastIndexOf("@");
+	const modulePath = at > 0 ? spec.slice(0, at) : spec;
+	return { ...parsed, name: goBinaryName(modulePath) };
+}
+
 /**
  * Extract binary name from a Go module path.
- * The binary name is the last path segment before @version.
- * e.g., "github.com/MadAppGang/tmux-mcp@latest" → "tmux-mcp"
- *       "github.com/user/tool" → "tool"
+ * The binary name is the last path segment before @version, minus any /vN
+ * major-version suffix.
+ * e.g., "github.com/MadAppGang/tmux-mcp@latest"    → "tmux-mcp"
+ *       "github.com/MadAppGang/tmux-mcp/v2@v2.0.0" → "tmux-mcp"
+ *       "github.com/user/tool"                      → "tool"
  */
 export function extractGoBinaryName(pkg: string): string {
-	return parseAtSpec(pkg).name;
+	return parseGoSpec(pkg).name;
 }
 
 /**
@@ -409,7 +428,7 @@ export function extractGoBinaryName(pkg: string): string {
  *       "github.com/user/tool"                  → null
  */
 export function extractGoVersion(pkg: string): string | null {
-	return parseAtSpec(pkg).version;
+	return parseGoSpec(pkg).version;
 }
 
 /** Normalize a semver-ish string for comparison: trim and drop a leading "v". */
@@ -641,7 +660,7 @@ export async function binaryDepDecision(
 
 /** {@link binaryDepDecision} for a Go module path. */
 export async function goDepDecision(pkg: string): Promise<GoDepDecision> {
-	return binaryDepDecision(parseAtSpec(pkg), getGoInstallDir);
+	return binaryDepDecision(parseGoSpec(pkg), getGoInstallDir);
 }
 
 /**

package/src/utils/go-module.ts

@@ -0,0 +1,36 @@
+/**
+ * Go module path → installed binary name.
+ *
+ * `go install` names the binary after the last path element of the module
+ * path, EXCEPT when that element is a major-version suffix: the module
+ * `github.com/MadAppGang/tmux-mcp/v2` installs `tmux-mcp`, not `v2`. Taking a
+ * plain basename therefore points every later check at a binary that never
+ * exists — presence probes fail, so the module is reinstalled on every run,
+ * doctor reports it missing, and the pin comparison never runs at all.
+ *
+ * Only the Go rule lives here. npm and cargo share the `name@version` syntax
+ * but not the suffix convention — an npm scoped package can legitimately be
+ * called `@scope/v2` — so this must not be folded into the generic spec parser.
+ */
+
+/**
+ * Trailing major-version suffix per the Go modules spec: `/vN` with N >= 2.
+ * Anchored to the END of the path with nothing after `vN`, so a segment that
+ * merely starts with "v2" (`github.com/x/v2tool`) is a real name, not a suffix.
+ * v0 and v1 are never written as a path suffix. The alternation, not a plain
+ * `[2-9][0-9]*`, because that shorthand rejects v10–v19 — a first digit of 1
+ * is only excluded when it is the ONLY digit.
+ */
+const MAJOR_VERSION_SUFFIX = /\/v(?:[2-9]|[1-9][0-9]+)$/;
+
+/**
+ * The binary `go install <modulePath>` produces.
+ *
+ * Takes the MODULE PATH — the part before any `@version` — so callers that
+ * hold a full `path@version` spec split it first. An empty or single-segment
+ * input is returned unchanged.
+ */
+export function goBinaryName(modulePath: string): string {
+	const withoutSuffix = modulePath.replace(MAJOR_VERSION_SUFFIX, "");
+	return withoutSuffix.split("/").pop() || withoutSuffix;
+}