skillrepo 3.2.0 → 4.1.0

package/src/test/lib/prompt-multiselect.test.mjs

@@ -0,0 +1,448 @@
+/**
+ * Unit tests for src/lib/prompt-multiselect.mjs (#1236, Phase 3 of #876).
+ *
+ * Coverage scope:
+ *
+ *   - Non-TTY mode (the comma-separated parser): empty input, single
+ *     key, multi key, unknown-key rejection, dedup, override semantics.
+ *
+ *   - TTY mode is exercised lightly. Full keypress simulation requires
+ *     emitting parsed key events into a fake stdin, which is doable
+ *     via the same `Readable` shape Node's keypress parser accepts.
+ *     We exercise the renderer indirectly through one round-trip
+ *     (toggle → enter) to catch wiring regressions, but most TTY
+ *     behavior is covered by the integration test in init.test.mjs
+ *     once the picker is wired in.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { Readable, Writable } from "node:stream";
+
+import { promptMultiSelect } from "../../lib/prompt-multiselect.mjs";
+
+function makeFakeStdin(input) {
+  // A minimal Readable that emits the input as a single chunk and
+  // ends. Node's readline.emitKeypressEvents will not be used in
+  // non-TTY mode — runNonTtyPicker reads raw chunks.
+  const stream = Readable.from([input], { objectMode: false });
+  stream.isTTY = false;
+  return stream;
+}
+
+function makeFakeStdout() {
+  const chunks = [];
+  const stream = new Writable({
+    write(chunk, _enc, cb) {
+      chunks.push(typeof chunk === "string" ? chunk : chunk.toString("utf-8"));
+      cb();
+    },
+  });
+  stream.isTTY = false;
+  stream.text = () => chunks.join("");
+  return stream;
+}
+
+const ITEMS = [
+  { key: "claude", label: "Claude Code", hint: ".claude/skills/", preChecked: true },
+  { key: "agents", label: "Other agents", hint: ".agents/skills/", preChecked: true },
+  { key: "none", label: "None — I'll configure manually", preChecked: false },
+];
+
+// ── Non-TTY: empty input ────────────────────────────────────────────
+
+describe("promptMultiSelect — non-TTY: empty input", () => {
+  it("returns the pre-checked items when stdin is empty (just newline)", async () => {
+    const stdin = makeFakeStdin("\n");
+    const stdout = makeFakeStdout();
+    const result = await promptMultiSelect(
+      { question: "Pick targets:", items: ITEMS },
+      { stdin, stdout, forceTty: false },
+    );
+    assert.deepEqual(result, ["claude", "agents"]);
+  });
+
+  it("returns the pre-checked items when stdin is just whitespace", async () => {
+    const stdin = makeFakeStdin("   \n");
+    const stdout = makeFakeStdout();
+    const result = await promptMultiSelect(
+      { question: "Pick targets:", items: ITEMS },
+      { stdin, stdout, forceTty: false },
+    );
+    assert.deepEqual(result, ["claude", "agents"]);
+  });
+
+  it("returns empty array when no items are pre-checked and input is empty", async () => {
+    const stdin = makeFakeStdin("\n");
+    const stdout = makeFakeStdout();
+    const items = ITEMS.map((it) => ({ ...it, preChecked: false }));
+    const result = await promptMultiSelect(
+      { question: "?", items },
+      { stdin, stdout, forceTty: false },
+    );
+    assert.deepEqual(result, []);
+  });
+});
+
+// ── Non-TTY: explicit input ────────────────────────────────────────
+
+describe("promptMultiSelect — non-TTY: explicit input", () => {
+  it("returns just the requested key for a single-key input", async () => {
+    const stdin = makeFakeStdin("claude\n");
+    const stdout = makeFakeStdout();
+    const result = await promptMultiSelect(
+      { question: "?", items: ITEMS },
+      { stdin, stdout, forceTty: false },
+    );
+    assert.deepEqual(result, ["claude"]);
+  });
+
+  it("parses comma-separated input", async () => {
+    const stdin = makeFakeStdin("claude,agents\n");
+    const stdout = makeFakeStdout();
+    const result = await promptMultiSelect(
+      { question: "?", items: ITEMS },
+      { stdin, stdout, forceTty: false },
+    );
+    assert.deepEqual(result, ["claude", "agents"]);
+  });
+
+  it("trims whitespace around comma-separated tokens", async () => {
+    const stdin = makeFakeStdin(" claude , agents \n");
+    const stdout = makeFakeStdout();
+    const result = await promptMultiSelect(
+      { question: "?", items: ITEMS },
+      { stdin, stdout, forceTty: false },
+    );
+    assert.deepEqual(result, ["claude", "agents"]);
+  });
+
+  it("explicit input overrides pre-checked defaults", async () => {
+    // Both `claude` and `agents` are pre-checked, but the user types
+    // only `none` — the result must be `["none"]`, not the union.
+    const stdin = makeFakeStdin("none\n");
+    const stdout = makeFakeStdout();
+    const result = await promptMultiSelect(
+      { question: "?", items: ITEMS },
+      { stdin, stdout, forceTty: false },
+    );
+    assert.deepEqual(result, ["none"]);
+  });
+
+  it("dedupes repeated keys in input", async () => {
+    const stdin = makeFakeStdin("claude,claude,agents\n");
+    const stdout = makeFakeStdout();
+    const result = await promptMultiSelect(
+      { question: "?", items: ITEMS },
+      { stdin, stdout, forceTty: false },
+    );
+    assert.deepEqual(result, ["claude", "agents"]);
+  });
+
+  it("rejects unknown keys with a clear error listing valid keys", async () => {
+    const stdin = makeFakeStdin("foo\n");
+    const stdout = makeFakeStdout();
+    await assert.rejects(
+      () =>
+        promptMultiSelect(
+          { question: "?", items: ITEMS },
+          { stdin, stdout, forceTty: false },
+        ),
+      (err) =>
+        err instanceof Error &&
+        /Unknown key/.test(err.message) &&
+        /claude/.test(err.message) &&
+        /agents/.test(err.message) &&
+        /none/.test(err.message),
+    );
+  });
+
+  it("rejects when input contains a single unknown alongside valid keys", async () => {
+    const stdin = makeFakeStdin("claude,foo\n");
+    const stdout = makeFakeStdout();
+    await assert.rejects(
+      () =>
+        promptMultiSelect(
+          { question: "?", items: ITEMS },
+          { stdin, stdout, forceTty: false },
+        ),
+      (err) => err instanceof Error && /foo/.test(err.message),
+    );
+  });
+
+  it("handles \\r\\n line endings (Windows-style)", async () => {
+    // Cross-platform check: Windows piped input often arrives with
+    // CRLF. The parser must tolerate both \n and \r\n.
+    const stdin = makeFakeStdin("claude\r\n");
+    const stdout = makeFakeStdout();
+    const result = await promptMultiSelect(
+      { question: "?", items: ITEMS },
+      { stdin, stdout, forceTty: false },
+    );
+    assert.deepEqual(result, ["claude"]);
+  });
+});
+
+// ── Non-TTY: rendered output ────────────────────────────────────────
+
+describe("promptMultiSelect — non-TTY: rendering", () => {
+  it("prints the question and every item", async () => {
+    const stdin = makeFakeStdin("\n");
+    const stdout = makeFakeStdout();
+    await promptMultiSelect(
+      { question: "Pick targets:", items: ITEMS },
+      { stdin, stdout, forceTty: false },
+    );
+    const text = stdout.text();
+    assert.match(text, /Pick targets:/);
+    assert.match(text, /claude/);
+    assert.match(text, /Claude Code/);
+    assert.match(text, /agents/);
+    assert.match(text, /Other agents/);
+    assert.match(text, /none/);
+  });
+
+  it("includes hints in the rendered output", async () => {
+    const stdin = makeFakeStdin("\n");
+    const stdout = makeFakeStdout();
+    await promptMultiSelect(
+      { question: "?", items: ITEMS },
+      { stdin, stdout, forceTty: false },
+    );
+    const text = stdout.text();
+    assert.match(text, /\.claude\/skills\//);
+    assert.match(text, /\.agents\/skills\//);
+  });
+
+  it("renders pre-checked items with [x] and unchecked with [ ]", async () => {
+    const stdin = makeFakeStdin("\n");
+    const stdout = makeFakeStdout();
+    await promptMultiSelect(
+      { question: "?", items: ITEMS },
+      { stdin, stdout, forceTty: false },
+    );
+    const text = stdout.text();
+    // Two pre-checked items: [x] should appear at least twice.
+    const checkedMatches = text.match(/\[x\]/g) ?? [];
+    assert.ok(checkedMatches.length >= 2, "two items should render as [x]");
+    // One unchecked: [ ] should appear at least once.
+    assert.match(text, /\[ \]/);
+  });
+});
+
+// ── TTY mode: keypress simulation ───────────────────────────────────
+//
+// We construct a fake stdin that satisfies the picker's expectations
+// (isTTY=true, setRawMode, pause/resume, on/removeAllListeners) and
+// directly emit "keypress" events. This bypasses readline's keypress
+// parser — which is fine, because we're testing the picker's reaction
+// to parsed events, not the parser itself.
+
+import { EventEmitter } from "node:events";
+
+function makeTtyStdin() {
+  const stdin = new EventEmitter();
+  stdin.isTTY = true;
+  stdin.isRaw = false;
+  stdin.setRawMode = function (raw) {
+    this.isRaw = raw;
+    return this;
+  };
+  stdin.pause = function () {};
+  stdin.resume = function () {};
+  // Drive a sequence of keypress events on the next tick so the picker
+  // has time to register its listener via `stdin.on("keypress", ...)`.
+  stdin.send = (events) => {
+    queueMicrotask(() => {
+      for (const [str, key] of events) {
+        stdin.emit("keypress", str, key);
+      }
+    });
+  };
+  return stdin;
+}
+
+function makeTtyStdout() {
+  const chunks = [];
+  const stream = new Writable({
+    write(chunk, _enc, cb) {
+      chunks.push(typeof chunk === "string" ? chunk : chunk.toString("utf-8"));
+      cb();
+    },
+  });
+  stream.isTTY = true;
+  stream.text = () => chunks.join("");
+  return stream;
+}
+
+describe("promptMultiSelect — TTY: keypress handling", () => {
+  it("returns pre-checked items when user presses enter immediately", async () => {
+    const stdin = makeTtyStdin();
+    const stdout = makeTtyStdout();
+    stdin.send([[null, { name: "return" }]]);
+    const result = await promptMultiSelect(
+      { question: "?", items: ITEMS },
+      { stdin, stdout, forceTty: true },
+    );
+    assert.deepEqual(result, ["claude", "agents"]);
+  });
+
+  it("space toggles the active row off; enter confirms", async () => {
+    const stdin = makeTtyStdin();
+    const stdout = makeTtyStdout();
+    // Cursor starts on index 0 (claude). Space → uncheck claude. Enter.
+    stdin.send([
+      [" ", { name: "space" }],
+      [null, { name: "return" }],
+    ]);
+    const result = await promptMultiSelect(
+      { question: "?", items: ITEMS },
+      { stdin, stdout, forceTty: true },
+    );
+    assert.deepEqual(result, ["agents"]);
+  });
+
+  it("down arrow then space toggles the cohort row off", async () => {
+    const stdin = makeTtyStdin();
+    const stdout = makeTtyStdout();
+    // Down → cursor on agents. Space → uncheck. Enter.
+    stdin.send([
+      [null, { name: "down" }],
+      [" ", { name: "space" }],
+      [null, { name: "return" }],
+    ]);
+    const result = await promptMultiSelect(
+      { question: "?", items: ITEMS },
+      { stdin, stdout, forceTty: true },
+    );
+    assert.deepEqual(result, ["claude"]);
+  });
+
+  it("up arrow wraps from index 0 to the last row", async () => {
+    const stdin = makeTtyStdin();
+    const stdout = makeTtyStdout();
+    // Up from index 0 → wraps to index 2 (none). Space → check none. Enter.
+    stdin.send([
+      [null, { name: "up" }],
+      [" ", { name: "space" }],
+      [null, { name: "return" }],
+    ]);
+    const result = await promptMultiSelect(
+      { question: "?", items: ITEMS },
+      { stdin, stdout, forceTty: true },
+    );
+    // claude + agents pre-checked + none toggled on
+    assert.deepEqual(result, ["claude", "agents", "none"]);
+  });
+
+  it("'a' toggles all items on when at least one is unchecked", async () => {
+    const stdin = makeTtyStdin();
+    const stdout = makeTtyStdout();
+    // ITEMS has none pre-checked false. 'a' → check all. Enter.
+    stdin.send([
+      ["a", { name: "a" }],
+      [null, { name: "return" }],
+    ]);
+    const result = await promptMultiSelect(
+      { question: "?", items: ITEMS },
+      { stdin, stdout, forceTty: true },
+    );
+    assert.deepEqual(result, ["claude", "agents", "none"]);
+  });
+
+  it("'a' clears all when every item is already checked", async () => {
+    const stdin = makeTtyStdin();
+    const stdout = makeTtyStdout();
+    const allPreChecked = ITEMS.map((it) => ({ ...it, preChecked: true }));
+    stdin.send([
+      ["a", { name: "a" }],
+      [null, { name: "return" }],
+    ]);
+    const result = await promptMultiSelect(
+      { question: "?", items: allPreChecked },
+      { stdin, stdout, forceTty: true },
+    );
+    assert.deepEqual(result, []);
+  });
+
+  it("Ctrl+C cancels with a rejection", async () => {
+    const stdin = makeTtyStdin();
+    const stdout = makeTtyStdout();
+    stdin.send([[null, { name: "c", ctrl: true }]]);
+    await assert.rejects(
+      () =>
+        promptMultiSelect(
+          { question: "?", items: ITEMS },
+          { stdin, stdout, forceTty: true },
+        ),
+      /cancelled/i,
+    );
+  });
+
+  it("Ctrl+D cancels with a rejection (does not hang the process)", async () => {
+    // Round-2 review fix: Ctrl+D in raw mode does not close the stream
+    // automatically; without explicit handling the process hangs.
+    const stdin = makeTtyStdin();
+    const stdout = makeTtyStdout();
+    stdin.send([[null, { name: "d", ctrl: true }]]);
+    await assert.rejects(
+      () =>
+        promptMultiSelect(
+          { question: "?", items: ITEMS },
+          { stdin, stdout, forceTty: true },
+        ),
+      /cancelled/i,
+    );
+  });
+
+  it("Esc cancels with a rejection", async () => {
+    const stdin = makeTtyStdin();
+    const stdout = makeTtyStdout();
+    stdin.send([[null, { name: "escape" }]]);
+    await assert.rejects(
+      () =>
+        promptMultiSelect(
+          { question: "?", items: ITEMS },
+          { stdin, stdout, forceTty: true },
+        ),
+      /cancelled/i,
+    );
+  });
+
+  it("restores raw mode to its prior value after enter", async () => {
+    const stdin = makeTtyStdin();
+    const stdout = makeTtyStdout();
+    stdin.isRaw = false;
+    stdin.send([[null, { name: "return" }]]);
+    await promptMultiSelect(
+      { question: "?", items: ITEMS },
+      { stdin, stdout, forceTty: true },
+    );
+    assert.equal(stdin.isRaw, false, "raw mode must be restored");
+  });
+});
+
+// ── Argument validation ─────────────────────────────────────────────
+
+describe("promptMultiSelect — argument validation", () => {
+  it("throws TypeError when items is missing", async () => {
+    await assert.rejects(
+      () => promptMultiSelect({ question: "?" }, {}),
+      TypeError,
+    );
+  });
+
+  it("throws TypeError when items is empty", async () => {
+    await assert.rejects(
+      () => promptMultiSelect({ question: "?", items: [] }, {}),
+      TypeError,
+    );
+  });
+
+  it("throws TypeError when options is missing", async () => {
+    await assert.rejects(
+      () => promptMultiSelect(undefined, {}),
+      TypeError,
+    );
+  });
+});

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",
+    );
+  });
+});