skillrepo 3.2.0 → 4.0.0

package/src/test/lib/paths.test.mjs

@@ -1,9 +1,9 @@
 /**
- * Unit tests for the new paths.mjs exports added in PR1 of #646.
+ * Unit tests for the skill placement path resolvers in paths.mjs.
  *
  * The pre-existing exports (claudeMcpJson, cursorMcpJson, etc.) are
  * exercised indirectly by the existing mergers tests; this file
- * focuses on the new skill placement + gitignore exports.
+ * focuses on the skill placement + gitignore exports.
  */
 
 import { describe, it, beforeEach, afterEach } from "node:test";
@@ -15,10 +15,14 @@ import { tmpdir, homedir } from "node:os";
 import {
   claudeSkillsProject,
   claudeSkillsGlobal,
-  projectSkillsFallback,
-  projectSkillsFallbackRoot,
   claudeSkillsProjectRoot,
   claudeSkillsGlobalRoot,
+  agentsSkillsProject,
+  agentsSkillsProjectRoot,
+  agentsSkillsGlobal,
+  agentsSkillsGlobalRoot,
+  windsurfSkillsGlobal,
+  windsurfSkillsGlobalRoot,
   gitignorePath,
 } from "../../lib/paths.mjs";
 import {
@@ -59,28 +63,60 @@ describe("paths.mjs — skill placement targets", () => {
 
   it("claudeSkillsGlobal is under HOME/.claude/skills/<name>", () => {
     const dir = claudeSkillsGlobal("pdf-helper");
-    // homedir() reads HOME on POSIX so respects our sandbox
     assert.equal(dir, join(homedir(), ".claude", "skills", "pdf-helper"));
   });
 
-  it("projectSkillsFallback is under cwd/skills/<name>", () => {
-    const dir = projectSkillsFallback("pdf-helper");
-    assert.equal(dir, join(process.cwd(), "skills", "pdf-helper"));
-  });
-
   it("claudeSkillsProjectRoot is the parent of project-local skills", () => {
-    const root = claudeSkillsProjectRoot();
-    assert.equal(root, join(process.cwd(), ".claude", "skills"));
+    assert.equal(
+      claudeSkillsProjectRoot(),
+      join(process.cwd(), ".claude", "skills"),
+    );
   });
 
   it("claudeSkillsGlobalRoot is the parent of personal skills", () => {
-    const root = claudeSkillsGlobalRoot();
-    assert.equal(root, join(homedir(), ".claude", "skills"));
+    assert.equal(claudeSkillsGlobalRoot(), join(homedir(), ".claude", "skills"));
+  });
+
+  it("agentsSkillsProject is under cwd/.agents/skills/<name>", () => {
+    assert.equal(
+      agentsSkillsProject("pdf-helper"),
+      join(process.cwd(), ".agents", "skills", "pdf-helper"),
+    );
+  });
+
+  it("agentsSkillsProjectRoot is the parent of cohort skills", () => {
+    assert.equal(
+      agentsSkillsProjectRoot(),
+      join(process.cwd(), ".agents", "skills"),
+    );
+  });
+
+  it("agentsSkillsGlobal is under HOME/.agents/skills/<name>", () => {
+    assert.equal(
+      agentsSkillsGlobal("pdf-helper"),
+      join(homedir(), ".agents", "skills", "pdf-helper"),
+    );
+  });
+
+  it("agentsSkillsGlobalRoot is the parent of personal cohort skills", () => {
+    assert.equal(
+      agentsSkillsGlobalRoot(),
+      join(homedir(), ".agents", "skills"),
+    );
+  });
+
+  it("windsurfSkillsGlobal is under HOME/.codeium/windsurf/skills/<name>", () => {
+    assert.equal(
+      windsurfSkillsGlobal("pdf-helper"),
+      join(homedir(), ".codeium", "windsurf", "skills", "pdf-helper"),
+    );
   });
 
-  it("projectSkillsFallbackRoot is the parent of fallback skills", () => {
-    const root = projectSkillsFallbackRoot();
-    assert.equal(root, join(process.cwd(), "skills"));
+  it("windsurfSkillsGlobalRoot is the parent of Windsurf personal skills", () => {
+    assert.equal(
+      windsurfSkillsGlobalRoot(),
+      join(homedir(), ".codeium", "windsurf", "skills"),
+    );
   });
 
   it("gitignorePath is at cwd/.gitignore", () => {

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