skillrepo 3.2.0 → 4.0.0

package/src/test/lib/sync.test.mjs

@@ -528,3 +528,160 @@ describe("runSync — orphan cleanup", () => {
     assert.ok(existsSync(join(root, "recoverable.tmp", "SKILL.md")));
   });
 });
+
+// ── runSync — cohort placement classification ──────────────────────────
+//
+// Coverage gap from the QA cross-PR review (#1252): the cohort vendors
+// (cursor / windsurf / gemini / codex / cline / copilot) all share the
+// `agentsProject` placement target via the registry. Cross-vendor
+// re-syncs and partial-vendor re-syncs were unverified — these tests
+// lock the `isAnyTargetPresent` resolution that distinguishes added-vs-
+// updated for cohort-only writes, plus tombstone scoping when only
+// part of a multi-vendor original write is asked to be removed.
+
+describe("runSync — cohort placement classification", () => {
+  beforeEach(setupServer);
+  afterEach(teardownServer);
+
+  it("re-sync with a different cohort vendor classifies as updated, not added", async () => {
+    // First sync writes via vendors: ["cursor"] → the cohort target
+    // resolves to `agentsProject` → `.agents/skills/<name>/`.
+    server.setLibraryResponse({
+      skills: [makeSkill("shared")],
+      removals: [],
+      syncedAt: "2025-01-01T00:00:00Z",
+    });
+    const first = await runSync({
+      serverUrl,
+      apiKey: VALID_KEY,
+      vendors: ["cursor"],
+    });
+    assert.equal(first.added, 1);
+
+    // Confirm the cohort dir was actually written (not a coincidental
+    // pass via some other path).
+    const cohortDir = resolvePlacementDir("agentsProject", "shared");
+    assert.ok(existsSync(join(cohortDir, "SKILL.md")), "cohort dir must exist after first sync");
+
+    // Clear the .last-sync state so the second sync isn't 304-short-
+    // circuited — we want the writeSkillDir path to actually run so
+    // isAnyTargetPresent classifies the existing dir as "updated".
+    rmSync(globalLastSyncPath(), { force: true });
+
+    // Second sync via vendors: ["windsurf"]. Both cursor and windsurf
+    // resolve to `agentsProject` per the registry, so the existing
+    // `.agents/skills/shared/` should be detected as already-on-disk
+    // and the summary must report updated:1, added:0.
+    server.setLibraryResponse({
+      skills: [makeSkill("shared", "v2")],
+      removals: [],
+      syncedAt: "2025-01-02T00:00:00Z",
+    });
+    const second = await runSync({
+      serverUrl,
+      apiKey: VALID_KEY,
+      vendors: ["windsurf"],
+    });
+    assert.equal(
+      second.updated,
+      1,
+      "cross-cohort vendor re-sync must classify as updated (both resolve to .agents/skills/)",
+    );
+    assert.equal(second.added, 0, "must NOT classify as added when target dir already exists");
+  });
+
+  it("claudeCode + cohort then claudeCode-only leaves the cohort copy untouched", async () => {
+    // First sync writes to BOTH .claude/skills/ and .agents/skills/
+    server.setLibraryResponse({
+      skills: [makeSkill("dual")],
+      removals: [],
+      syncedAt: "2025-01-01T00:00:00Z",
+    });
+    await runSync({
+      serverUrl,
+      apiKey: VALID_KEY,
+      vendors: ["claudeCode", "cursor"],
+    });
+
+    const claudeDir = resolvePlacementDir("claudeProject", "dual");
+    const cohortDir = resolvePlacementDir("agentsProject", "dual");
+    assert.ok(existsSync(join(claudeDir, "SKILL.md")), "claude dir must exist");
+    assert.ok(existsSync(join(cohortDir, "SKILL.md")), "cohort dir must exist");
+
+    // Capture the cohort SKILL.md mtime + content before the second
+    // sync so we can confirm it was NOT touched. Use content rather
+    // than mtime because mtime granularity is filesystem-dependent
+    // and can be a flake source on fast machines.
+    const cohortBefore = readFileSync(join(cohortDir, "SKILL.md"), "utf-8");
+
+    rmSync(globalLastSyncPath(), { force: true });
+
+    // Second sync targets ONLY claudeCode. The cohort copy is not
+    // re-written and is not removed — vendor-scoped writes don't
+    // touch other vendors' targets.
+    server.setLibraryResponse({
+      skills: [makeSkill("dual", "claude-only-update")],
+      removals: [],
+      syncedAt: "2025-01-02T00:00:00Z",
+    });
+    await runSync({
+      serverUrl,
+      apiKey: VALID_KEY,
+      vendors: ["claudeCode"],
+    });
+
+    // Cohort dir content unchanged — it survives the partial-vendor
+    // re-sync untouched.
+    assert.ok(existsSync(join(cohortDir, "SKILL.md")), "cohort dir must survive partial re-sync");
+    const cohortAfter = readFileSync(join(cohortDir, "SKILL.md"), "utf-8");
+    assert.equal(cohortAfter, cohortBefore, "cohort SKILL.md must not be rewritten");
+
+    // Claude dir DID get updated.
+    const claudeAfter = readFileSync(join(claudeDir, "SKILL.md"), "utf-8");
+    assert.match(claudeAfter, /claude-only-update/);
+  });
+
+  it("tombstone via cohort vendor removes from .agents/skills/ but leaves .claude/skills/", async () => {
+    // Pre-write to BOTH targets via a multi-vendor first sync.
+    server.setLibraryResponse({
+      skills: [makeSkill("doomed")],
+      removals: [],
+      syncedAt: "2025-01-01T00:00:00Z",
+    });
+    await runSync({
+      serverUrl,
+      apiKey: VALID_KEY,
+      vendors: ["claudeCode", "cursor"],
+    });
+
+    const claudeDir = resolvePlacementDir("claudeProject", "doomed");
+    const cohortDir = resolvePlacementDir("agentsProject", "doomed");
+    assert.ok(existsSync(claudeDir));
+    assert.ok(existsSync(cohortDir));
+
+    rmSync(globalLastSyncPath(), { force: true });
+
+    // Apply a tombstone with vendors: ["cursor"] only. Vendor-scoped
+    // tombstones map to the cohort target (.agents/skills/) and must
+    // NOT delete the Claude target — only the explicit vendor scope
+    // is touched. This locks the "vendor-scoped removal isn't a
+    // footgun" behavior.
+    server.setLibraryResponse({
+      skills: [],
+      removals: [{ owner: "alice", name: "doomed", removedAt: "2025-01-02T00:00:00Z" }],
+      syncedAt: "2025-01-02T00:00:00Z",
+    });
+    const result = await runSync({
+      serverUrl,
+      apiKey: VALID_KEY,
+      vendors: ["cursor"],
+    });
+
+    assert.equal(result.removed, 1);
+    assert.ok(!existsSync(cohortDir), "cohort dir must be removed by the cursor-scoped tombstone");
+    assert.ok(
+      existsSync(claudeDir),
+      "Claude Code dir must NOT be removed by a cursor-scoped tombstone — vendor scoping protects untargeted dirs",
+    );
+  });
+});

package/src/lib/detect-ides.mjs

@@ -1,44 +0,0 @@
-/**
- * IDE auto-detection.
- * Checks for IDE-specific directories/files in the project and home dir.
- */
-
-import { pathExists } from "./fs-utils.mjs";
-import * as paths from "./paths.mjs";
-
-/**
- * @typedef {Object} DetectedIdes
- * @property {boolean} claudeCode
- * @property {boolean} cursor
- * @property {boolean} windsurf
- * @property {boolean} vscode
- */
-
-/**
- * Detect which IDEs are configured in the current project.
- * @returns {DetectedIdes}
- */
-export function detectIdes() {
-  return {
-    claudeCode:
-      pathExists(paths.claudeMcpJson()) ||
-      pathExists(paths.claudeDir()),
-    cursor: pathExists(paths.cursorDir()),
-    windsurf: pathExists(paths.windsurfDir()),
-    vscode: pathExists(paths.vscodeDir()),
-  };
-}
-
-/**
- * Format detected IDEs as a human-readable list.
- * @param {DetectedIdes} detected
- * @returns {{ name: string; detected: boolean }[]}
- */
-export function formatDetectedIdes(detected) {
-  return [
-    { name: "Claude Code", key: "claudeCode", detected: detected.claudeCode },
-    { name: "Cursor", key: "cursor", detected: detected.cursor },
-    { name: "Windsurf", key: "windsurf", detected: detected.windsurf },
-    { name: "VS Code + Copilot", key: "vscode", detected: detected.vscode },
-  ];
-}

package/src/test/detect-ides.test.mjs

@@ -1,65 +0,0 @@
-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";
-
-let originalCwd;
-let tempDir;
-
-beforeEach(() => {
-  originalCwd = process.cwd;
-  tempDir = mkdtempSync(join(tmpdir(), "cli-test-"));
-  process.cwd = () => tempDir;
-});
-
-afterEach(() => {
-  process.cwd = originalCwd;
-  rmSync(tempDir, { recursive: true, force: true });
-});
-
-describe("IDE detection", () => {
-  it("detects Claude Code from .claude/ directory", async () => {
-    const { detectIdes } = await import("../lib/detect-ides.mjs");
-    mkdirSync(join(tempDir, ".claude"));
-
-    const result = detectIdes();
-    assert.equal(result.claudeCode, true);
-  });
-
-  it("detects Cursor from .cursor/ directory", async () => {
-    const { detectIdes } = await import("../lib/detect-ides.mjs");
-    mkdirSync(join(tempDir, ".cursor"));
-
-    const result = detectIdes();
-    assert.equal(result.cursor, true);
-  });
-
-  it("detects VS Code from .vscode/ directory", async () => {
-    const { detectIdes } = await import("../lib/detect-ides.mjs");
-    mkdirSync(join(tempDir, ".vscode"));
-
-    const result = detectIdes();
-    assert.equal(result.vscode, true);
-  });
-
-  it("returns all false when no IDE directories exist", async () => {
-    const { detectIdes } = await import("../lib/detect-ides.mjs");
-
-    const result = detectIdes();
-    assert.equal(result.claudeCode, false);
-    assert.equal(result.cursor, false);
-    assert.equal(result.vscode, false);
-    // windsurf depends on home dir, skip assertion
-  });
-
-  // PR4 cross-review cleanup: the old v2.0.0 `getDetectedIdeKeys`
-  // helper with a "default to claudeCode + cursor when nothing
-  // detected" fallback was dead code — the plan explicitly
-  // removed the silent fallback in PR3b, and no command called
-  // this helper. It was exported and had tests asserting the
-  // v2.0.0 behavior, which contradicted the actual v3.0.0 code
-  // path. Deleted; init now refuses with a --ide hint when
-  // nothing is detected (see the "refuses with clear error when
-  // no IDE detected and no --ide flag" test in init.test.mjs).
-});