skillrepo 3.2.0 → 4.0.0

package/src/test/e2e/cli-commands.test.mjs

@@ -432,7 +432,9 @@ describe("CLI E2E — read commands", () => {
   // ── PR3b: init ──────────────────────────────────────────────────
 
   it("init writes config + MCP + runs first sync (happy path)", async () => {
-    // Create a .claude/ marker so detectIdes finds claudeCode
+    // Create a .claude/ marker so detection finds claudeCode (the
+    // Phase 3 picker pre-checks the Claude Code row when its signal
+    // fires).
     mkdirSync(join(tempDir, ".claude"), { recursive: true });
 
     const r = await runCli([
@@ -468,28 +470,52 @@ describe("CLI E2E — read commands", () => {
     assert.equal(json.account.slug, "mock");
   });
 
-  it("init --ide claude works in empty dir (headless CI scenario)", async () => {
+  it("init --agent claude works in empty dir (non-interactive scenario)", async () => {
     const r = await runCli([
       "init",
       "--key", VALID_KEY,
       "--url", `http://127.0.0.1:${port}`,
       "--yes",
-      "--ide", "claude",
+      "--agent", "claude",
     ]);
     assert.equal(r.status, 0, `stderr: ${r.stderr}`);
     assert.ok(existsSync(join(tempDir, ".mcp.json")));
   });
 
-  it("init with no IDEs detected and no --ide exits 5", async () => {
-    // No .claude marker, no --ide flag
-    const r = await runCli([
-      "init",
-      "--key", VALID_KEY,
-      "--url", `http://127.0.0.1:${port}`,
-      "--yes",
-    ]);
-    assert.equal(r.status, 5);
-    assert.match(r.stderr, /No IDEs detected/);
+  it("init in an empty dir under --yes configures both default targets (#1236)", async () => {
+    // Phase 3 (#1236) replaced the "No agent targets detected → refuse"
+    // branch with the two-row picker. Under --yes with no detection
+    // signals, both rows are pre-checked (the spec rationale: writing
+    // a few KB the user didn't strictly need is trivial; CI running
+    // `init --yes` on a fresh clone and writing nothing is broken
+    // automation). The CLI must succeed and configure both targets.
+    //
+    // The env-var clears below force the genuine "no signal" state.
+    // The test host's shell may have CLAUDECODE=1 (Claude Code
+    // session), CURSOR_AGENT=1, etc. — without clearing those, the
+    // subprocess detection would pre-fire, defeating the test.
+    const r = await runCli(
+      [
+        "init",
+        "--key", VALID_KEY,
+        "--url", `http://127.0.0.1:${port}`,
+        "--yes",
+        "--json",
+      ],
+      {
+        CLAUDECODE: "",
+        CURSOR_AGENT: "",
+        CURSOR_CLI: "",
+        GEMINI_CLI: "",
+        CLINE_ACTIVE: "",
+      },
+    );
+    assert.equal(r.status, 0, `stderr: ${r.stderr}`);
+    const json = JSON.parse(r.stdout);
+    assert.equal(json.action, "initialized");
+    // Both targets present: claudeCode + the cohort.
+    assert.ok(json.vendors.includes("claudeCode"));
+    assert.ok(json.vendors.length > 1, "cohort vendors must also be configured");
   });
 
   it("init with 401 from validate exits 2", async () => {

package/src/test/integration/file-write.integration.test.mjs

@@ -108,9 +108,12 @@ describe("file-write.mjs integration — round-trip", () => {
     }
   });
 
-  it("writes to global dir under HOME with --global", () => {
+  it("writes to global dir under HOME with --global --agent claudeCode", () => {
     const skill = multiFileSkill();
-    const result = writeSkillDir(skill, { global: true });
+    const result = writeSkillDir(skill, {
+      global: true,
+      vendors: ["claudeCode"],
+    });
     assert.equal(result.written.length, 1);
     const dir = result.written[0];
     assert.ok(dir.startsWith(process.env.HOME), "should write under HOME");
@@ -190,13 +193,13 @@ describe("file-write.mjs integration — orphan recovery", () => {
 
   it("cleanupOrphans removes injected .tmp/ (with live siblings) and .old/ across all roots", () => {
     // Inject orphans in claudeProject root, claudeGlobal root, and
-    // projectFallback root. .tmp/ entries need a live sibling so the
+    // agentsProject root. .tmp/ entries need a live sibling so the
     // safety invariant doesn't preserve them as recoverable.
     const claudeProjectRoot = join(process.cwd(), ".claude", "skills");
-    const fallbackRoot = join(process.cwd(), "skills");
+    const agentsRoot = join(process.cwd(), ".agents", "skills");
     const globalRoot = join(process.env.HOME, ".claude", "skills");
     mkdirSync(claudeProjectRoot, { recursive: true });
-    mkdirSync(fallbackRoot, { recursive: true });
+    mkdirSync(agentsRoot, { recursive: true });
     mkdirSync(globalRoot, { recursive: true });
 
     // ghost-1: live sibling + .tmp + .old (.tmp gets cleaned because live exists)
@@ -205,8 +208,8 @@ describe("file-write.mjs integration — orphan recovery", () => {
     mkdirSync(join(claudeProjectRoot, "ghost-1.old"));
     writeFileSync(join(claudeProjectRoot, "ghost-1.tmp", "garbage.txt"), "leftover");
 
-    // ghost-2: just a .old/ in the fallback root (.old has no invariant)
-    mkdirSync(join(fallbackRoot, "ghost-2.old"));
+    // ghost-2: just a .old/ in the agents cohort root (.old has no invariant)
+    mkdirSync(join(agentsRoot, "ghost-2.old"));
 
     // ghost-3: live sibling + .tmp in the global root
     mkdirSync(join(globalRoot, "ghost-3"));
@@ -217,7 +220,7 @@ describe("file-write.mjs integration — orphan recovery", () => {
 
     assert.ok(!existsSync(join(claudeProjectRoot, "ghost-1.tmp")));
     assert.ok(!existsSync(join(claudeProjectRoot, "ghost-1.old")));
-    assert.ok(!existsSync(join(fallbackRoot, "ghost-2.old")));
+    assert.ok(!existsSync(join(agentsRoot, "ghost-2.old")));
     assert.ok(!existsSync(join(globalRoot, "ghost-3.tmp")));
     // Live siblings preserved
     assert.ok(existsSync(join(claudeProjectRoot, "ghost-1")));
@@ -272,14 +275,32 @@ describe("file-write.mjs integration — remove + .gitignore", () => {
     }
   });
 
-  it("write to fallback creates .gitignore entry; remove does not delete it", () => {
+  it("write to .agents/skills/ creates .gitignore entry; remove does not delete it", () => {
     writeSkillDir(multiFileSkill(), { vendors: ["cursor"] });
     const giBefore = readFileSync(join(process.cwd(), ".gitignore"), "utf-8");
-    assert.match(giBefore, /\/skills\//);
+    assert.match(giBefore, /\.agents\/skills\//);
 
     removeSkillDir("pdf-helper", { vendors: ["cursor"] });
     const giAfter = readFileSync(join(process.cwd(), ".gitignore"), "utf-8");
     // remove should not touch .gitignore
     assert.equal(giAfter, giBefore);
   });
+
+  it("cohort dedupe end-to-end: vendors=[cursor, windsurf] writes ONE skill", () => {
+    const skill = multiFileSkill();
+    const result = writeSkillDir(skill, { vendors: ["cursor", "windsurf"] });
+    assert.equal(
+      result.written.length,
+      1,
+      "cohort vendors must collapse to a single write",
+    );
+    const dir = result.written[0];
+    assert.ok(
+      dir.includes(join(".agents", "skills", "pdf-helper")),
+      `expected dir under .agents/skills/, got ${dir}`,
+    );
+    for (const file of skill.files) {
+      assert.ok(existsSync(join(dir, file.path)));
+    }
+  });
 });

package/src/test/lib/agent-registry.test.mjs

@@ -0,0 +1,215 @@
+/**
+ * Unit tests for src/lib/agent-registry.mjs (#1234).
+ *
+ * Locks the registry shape: 7 entries, no duplicate keys, no
+ * duplicate aliases, all targets resolvable in
+ * `resolvePlacementDir`. The registry is the single source of truth
+ * for placement decisions; a regression here breaks every downstream
+ * caller (file-write, cli-config, mcp-merge, gitignore).
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  AGENT_REGISTRY,
+  getAgentByKey,
+  getAgentByAlias,
+} from "../../lib/agent-registry.mjs";
+import { resolvePlacementDir } from "../../lib/file-write.mjs";
+import {
+  captureHome,
+  setSandboxHome,
+  restoreHome,
+} from "../helpers/sandbox-home.mjs";
+
+const EXPECTED_KEYS = [
+  "claudeCode",
+  "cursor",
+  "windsurf",
+  "gemini",
+  "codex",
+  "cline",
+  "copilot",
+];
+
+describe("AGENT_REGISTRY — shape", () => {
+  it("contains exactly the seven supported agents", () => {
+    const keys = AGENT_REGISTRY.map((entry) => entry.key);
+    assert.deepEqual(keys.sort(), [...EXPECTED_KEYS].sort());
+  });
+
+  it("each entry has the required fields", () => {
+    for (const entry of AGENT_REGISTRY) {
+      assert.equal(typeof entry.key, "string", `key for ${entry.key}`);
+      assert.equal(typeof entry.displayName, "string", `displayName for ${entry.key}`);
+      assert.ok(Array.isArray(entry.aliases), `aliases for ${entry.key}`);
+      assert.equal(typeof entry.projectTarget, "string", `projectTarget for ${entry.key}`);
+      assert.ok(
+        entry.globalTarget === null || typeof entry.globalTarget === "string",
+        `globalTarget for ${entry.key} must be string|null`,
+      );
+      assert.equal(typeof entry.hasMcp, "boolean", `hasMcp for ${entry.key} must be boolean`);
+      assert.ok(
+        Array.isArray(entry.detectionSignals),
+        `detectionSignals for ${entry.key} must be an array`,
+      );
+      assert.ok(
+        entry.detectionSignals.length > 0,
+        `detectionSignals for ${entry.key} must be non-empty`,
+      );
+    }
+  });
+
+  it("every detection signal has a valid type and a non-empty value", () => {
+    // Locks the DetectionSignal shape: a typo'd `type` would silently
+    // fall through detect-agents.mjs's probe switch and never fire.
+    const VALID_TYPES = new Set(["env", "home", "project"]);
+    for (const entry of AGENT_REGISTRY) {
+      for (const signal of entry.detectionSignals) {
+        assert.ok(
+          VALID_TYPES.has(signal.type),
+          `${entry.key} signal has invalid type "${signal.type}"`,
+        );
+        assert.equal(
+          typeof signal.value,
+          "string",
+          `${entry.key} signal value must be a string`,
+        );
+        assert.ok(
+          signal.value.length > 0,
+          `${entry.key} signal value must be non-empty`,
+        );
+      }
+    }
+  });
+
+  it("hasMcp matches the four-vendor MCP merger inventory", () => {
+    const withMcp = AGENT_REGISTRY.filter((entry) => entry.hasMcp).map((e) => e.key).sort();
+    assert.deepEqual(
+      withMcp,
+      ["claudeCode", "copilot", "cursor", "windsurf"],
+      "hasMcp must reflect which vendors have an MCP merger today",
+    );
+  });
+
+  it("has no duplicate canonical keys", () => {
+    const keys = AGENT_REGISTRY.map((entry) => entry.key);
+    assert.equal(keys.length, new Set(keys).size, "duplicate canonical keys");
+  });
+
+  it("has no duplicate aliases (across all entries)", () => {
+    const allAliases = AGENT_REGISTRY.flatMap((entry) => entry.aliases);
+    assert.equal(
+      allAliases.length,
+      new Set(allAliases).size,
+      "duplicate alias across registry entries",
+    );
+  });
+
+  it("no alias collides with a canonical key from a different entry", () => {
+    for (const entry of AGENT_REGISTRY) {
+      for (const alias of entry.aliases) {
+        const collision = AGENT_REGISTRY.find(
+          (other) => other.key === alias && other.key !== entry.key,
+        );
+        assert.equal(
+          collision,
+          undefined,
+          `alias "${alias}" on "${entry.key}" collides with canonical key of "${collision?.key}"`,
+        );
+      }
+    }
+  });
+
+  it("copilot is the only vendor with no global target", () => {
+    const noGlobal = AGENT_REGISTRY.filter((entry) => entry.globalTarget === null);
+    assert.deepEqual(
+      noGlobal.map((e) => e.key),
+      ["copilot"],
+    );
+  });
+});
+
+describe("getAgentByKey", () => {
+  it("returns the entry for a known canonical key", () => {
+    const entry = getAgentByKey("claudeCode");
+    assert.equal(entry?.key, "claudeCode");
+    assert.equal(entry?.projectTarget, "claudeProject");
+    assert.equal(entry?.globalTarget, "claudeGlobal");
+  });
+
+  it("returns undefined for an unknown key", () => {
+    assert.equal(getAgentByKey("jetbrains"), undefined);
+  });
+
+  it("does not resolve aliases (only canonical keys)", () => {
+    // 'claude' is an alias of 'claudeCode' — getAgentByKey is strict.
+    assert.equal(getAgentByKey("claude"), undefined);
+  });
+});
+
+describe("getAgentByAlias", () => {
+  it("resolves a canonical key to itself", () => {
+    assert.equal(getAgentByAlias("cursor"), "cursor");
+  });
+
+  it("resolves the 'claude' alias to 'claudeCode'", () => {
+    assert.equal(getAgentByAlias("claude"), "claudeCode");
+  });
+
+  it("resolves the 'vscode' alias to 'copilot'", () => {
+    assert.equal(getAgentByAlias("vscode"), "copilot");
+  });
+
+  it("returns null for an unknown name", () => {
+    assert.equal(getAgentByAlias("jetbrains"), null);
+  });
+
+  it("is case-sensitive", () => {
+    assert.equal(getAgentByAlias("CLAUDE"), null);
+  });
+});
+
+describe("AGENT_REGISTRY — placement targets resolve", () => {
+  let sandbox;
+  let originalCwd;
+  /** @type {import("../helpers/sandbox-home.mjs").HomeEnvSnapshot} */
+  let originalHomeEnv;
+
+  beforeEach(() => {
+    sandbox = mkdtempSync(join(tmpdir(), "cli-agent-reg-"));
+    mkdirSync(join(sandbox, "project"), { recursive: true });
+    mkdirSync(join(sandbox, "home"), { recursive: true });
+    originalCwd = process.cwd();
+    originalHomeEnv = captureHome();
+    process.chdir(join(sandbox, "project"));
+    setSandboxHome(join(sandbox, "home"));
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    restoreHome(originalHomeEnv);
+    if (sandbox) rmSync(sandbox, { recursive: true, force: true });
+  });
+
+  it("every projectTarget resolves without throwing", () => {
+    for (const entry of AGENT_REGISTRY) {
+      const dir = resolvePlacementDir(entry.projectTarget, "test-skill");
+      assert.equal(typeof dir, "string");
+      assert.ok(dir.length > 0);
+    }
+  });
+
+  it("every non-null globalTarget resolves without throwing", () => {
+    for (const entry of AGENT_REGISTRY) {
+      if (entry.globalTarget === null) continue;
+      const dir = resolvePlacementDir(entry.globalTarget, "test-skill");
+      assert.equal(typeof dir, "string");
+      assert.ok(dir.length > 0);
+    }
+  });
+});