skillrepo 2.0.0 → 3.0.0

package/src/test/commands/list.test.mjs

@@ -0,0 +1,172 @@
+/**
+ * Unit/integration tests for src/commands/list.mjs (PR2 of #646).
+ */
+
+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 { runList } from "../../commands/list.mjs";
+import { CliError, EXIT_AUTH } from "../../lib/errors.mjs";
+import { createMockServer } from "../e2e/mock-server.mjs";
+import { createCaptureStream } from "../helpers/capture-stream.mjs";
+
+let sandbox;
+let server;
+let serverUrl;
+let originalCwd;
+let originalHome;
+let stdout;
+const VALID_KEY = "sk_live_test";
+
+function makeSkill(owner, name, version = "1.0.0", description = `${name} description`) {
+  return {
+    owner,
+    name,
+    version,
+    description,
+    files: [], // list ignores files
+    updatedAt: "2025-01-01T12:00:00Z",
+  };
+}
+
+async function setup() {
+  sandbox = mkdtempSync(join(tmpdir(), "cli-cmd-list-"));
+  mkdirSync(join(sandbox, "project"), { recursive: true });
+  mkdirSync(join(sandbox, "home"), { recursive: true });
+  originalCwd = process.cwd();
+  originalHome = process.env.HOME;
+  process.chdir(join(sandbox, "project"));
+  process.env.HOME = join(sandbox, "home");
+  delete process.env.SKILLREPO_ACCESS_KEY;
+
+  server = createMockServer({});
+  const port = await server.start();
+  serverUrl = `http://127.0.0.1:${port}`;
+
+  stdout = createCaptureStream();
+}
+
+async function teardown() {
+  if (server) await server.stop();
+  process.chdir(originalCwd);
+  process.env.HOME = originalHome;
+  if (sandbox) rmSync(sandbox, { recursive: true, force: true });
+  server = null;
+}
+
+describe("runList — happy path", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("renders a table when the library has skills", async () => {
+    server.setLibraryResponse({
+      skills: [
+        makeSkill("alice", "pdf-helper"),
+        makeSkill("bob", "code-review"),
+      ],
+      removals: [],
+      syncedAt: "x",
+    });
+    await runList(["--key", VALID_KEY, "--url", serverUrl], { stdout });
+    const out = stdout.text();
+    assert.match(out, /pdf-helper/);
+    assert.match(out, /code-review/);
+    assert.match(out, /2 skills in your library/);
+  });
+
+  it("sorts alphabetically by owner then name", async () => {
+    server.setLibraryResponse({
+      skills: [
+        makeSkill("zeta", "later"),
+        makeSkill("alice", "second"),
+        makeSkill("alice", "first"),
+      ],
+      removals: [],
+      syncedAt: "x",
+    });
+    await runList(["--key", VALID_KEY, "--url", serverUrl], { stdout });
+    const out = stdout.text();
+    // alice/first before alice/second before zeta/later
+    const firstIdx = out.indexOf("first");
+    const secondIdx = out.indexOf("second");
+    const laterIdx = out.indexOf("later");
+    assert.ok(firstIdx >= 0 && secondIdx >= 0 && laterIdx >= 0);
+    assert.ok(firstIdx < secondIdx);
+    assert.ok(secondIdx < laterIdx);
+  });
+
+  it("--json outputs structured array", async () => {
+    server.setLibraryResponse({
+      skills: [makeSkill("alice", "pdf-helper", "2.1.0")],
+      removals: [],
+      syncedAt: "x",
+    });
+    await runList(["--key", VALID_KEY, "--url", serverUrl, "--json"], { stdout });
+    const json = JSON.parse(stdout.text());
+    assert.equal(json.length, 1);
+    assert.equal(json[0].owner, "alice");
+    assert.equal(json[0].name, "pdf-helper");
+    assert.equal(json[0].version, "2.1.0");
+  });
+
+  it("--json output is sorted by owner+name", async () => {
+    server.setLibraryResponse({
+      skills: [
+        makeSkill("zeta", "x"),
+        makeSkill("alice", "z"),
+        makeSkill("alice", "a"),
+      ],
+      removals: [],
+      syncedAt: "x",
+    });
+    await runList(["--key", VALID_KEY, "--url", serverUrl, "--json"], { stdout });
+    const json = JSON.parse(stdout.text());
+    assert.deepEqual(
+      json.map((s) => `${s.owner}/${s.name}`),
+      ["alice/a", "alice/z", "zeta/x"],
+    );
+  });
+
+  it("renders empty state with helpful hint", async () => {
+    server.setLibraryResponse({ skills: [], removals: [], syncedAt: "x" });
+    await runList(["--key", VALID_KEY, "--url", serverUrl], { stdout });
+    const out = stdout.text();
+    assert.match(out, /library is empty/);
+    assert.match(out, /skillrepo add/);
+  });
+
+  it("--json on empty library outputs []", async () => {
+    server.setLibraryResponse({ skills: [], removals: [], syncedAt: "x" });
+    await runList(["--key", VALID_KEY, "--url", serverUrl, "--json"], { stdout });
+    const json = JSON.parse(stdout.text());
+    assert.deepEqual(json, []);
+  });
+
+  it("truncates long descriptions in the table", async () => {
+    const longDesc = "a".repeat(200);
+    server.setLibraryResponse({
+      skills: [makeSkill("alice", "x", "1.0", longDesc)],
+      removals: [],
+      syncedAt: "x",
+    });
+    await runList(["--key", VALID_KEY, "--url", serverUrl], { stdout });
+    const out = stdout.text();
+    // Should contain the ellipsis marker
+    assert.match(out, /…/);
+  });
+});
+
+describe("runList — error paths", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("throws authError when no credentials", async () => {
+    await assert.rejects(
+      () => runList([]),
+      (err) => err instanceof CliError && err.exitCode === EXIT_AUTH,
+    );
+  });
+});

package/src/test/commands/remove.test.mjs

@@ -0,0 +1,234 @@
+/**
+ * Unit/integration tests for src/commands/remove.mjs (PR3a of #646).
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, existsSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { runRemove } from "../../commands/remove.mjs";
+import { writeSkillDir, resolvePlacementDir } from "../../lib/file-write.mjs";
+import { CliError, EXIT_VALIDATION, EXIT_AUTH, EXIT_SCOPE } from "../../lib/errors.mjs";
+import { createMockServer } from "../e2e/mock-server.mjs";
+import { createCaptureStream } from "../helpers/capture-stream.mjs";
+
+let sandbox;
+let server;
+let serverUrl;
+let originalCwd;
+let originalHome;
+let stdout;
+const VALID_KEY = "sk_live_test";
+
+function makeSkill(owner, name) {
+  return {
+    owner,
+    name,
+    version: "1.0.0",
+    description: `${name} description`,
+    files: [
+      {
+        path: "SKILL.md",
+        content: `---\nname: ${name}\ndescription: ${name} description\n---\n\nbody\n`,
+        sha256: "x",
+        size: 50,
+        contentType: "text/markdown",
+      },
+    ],
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+async function setup() {
+  sandbox = mkdtempSync(join(tmpdir(), "cli-cmd-remove-"));
+  mkdirSync(join(sandbox, "project"), { recursive: true });
+  mkdirSync(join(sandbox, "home"), { recursive: true });
+  originalCwd = process.cwd();
+  originalHome = process.env.HOME;
+  process.chdir(join(sandbox, "project"));
+  process.env.HOME = join(sandbox, "home");
+  delete process.env.SKILLREPO_ACCESS_KEY;
+
+  server = createMockServer({});
+  const port = await server.start();
+  serverUrl = `http://127.0.0.1:${port}`;
+
+  stdout = createCaptureStream();
+}
+
+async function teardown() {
+  if (server) await server.stop();
+  process.chdir(originalCwd);
+  process.env.HOME = originalHome;
+  if (sandbox) rmSync(sandbox, { recursive: true, force: true });
+  server = null;
+}
+
+describe("runRemove — happy path", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("removes from library AND deletes local files when both exist", async () => {
+    // Pre-write a local skill
+    writeSkillDir(makeSkill("alice", "pdf-helper"), { vendors: ["claudeCode"] });
+    const dir = resolvePlacementDir("claudeProject", "pdf-helper");
+    assert.ok(existsSync(dir));
+
+    // Default server response is 200 removed
+    await runRemove(["--key", VALID_KEY, "--url", serverUrl, "@alice/pdf-helper"], { stdout });
+
+    // Local files gone
+    assert.ok(!existsSync(dir));
+    // Summary reports both actions
+    assert.match(stdout.text(), /Removed @alice\/pdf-helper from your library and deleted 1 local/);
+  });
+
+  it("library updated but no local files (summary reflects)", async () => {
+    // No pre-existing local skill, default 200 removed
+    await runRemove(["--key", VALID_KEY, "--url", serverUrl, "@alice/pdf-helper"], { stdout });
+    assert.match(stdout.text(), /no local files found/);
+  });
+
+  it("404 not-in-library + local files exist → orphan cleanup", async () => {
+    // Pre-write a local skill
+    writeSkillDir(makeSkill("alice", "orphan"), { vendors: ["claudeCode"] });
+
+    // Server says skill isn't in library
+    server.setRemoveResponse("alice", "orphan", {
+      status: 404,
+      body: { error: "Skill is not in your library", code: "not_in_library" },
+    });
+
+    await runRemove(["--key", VALID_KEY, "--url", serverUrl, "@alice/orphan"], { stdout });
+
+    const dir = resolvePlacementDir("claudeProject", "orphan");
+    assert.ok(!existsSync(dir));
+    // Round-1 review: message was "orphaned local" which implies
+    // CLI-managed state. Now the message is more honest about the
+    // fact that we don't know whether the user or a prior CLI run
+    // placed those files.
+    assert.match(stdout.text(), /wasn't in your library — deleted 1 local director/);
+  });
+
+  it("404 not-in-library + no local files → nothing to do", async () => {
+    server.setRemoveResponse("alice", "ghost", {
+      status: 404,
+      body: { code: "not_in_library" },
+    });
+    await runRemove(["--key", VALID_KEY, "--url", serverUrl, "@alice/ghost"], { stdout });
+    assert.match(stdout.text(), /nothing to do/);
+  });
+
+  it("--json outputs removed status with accurate counts", async () => {
+    writeSkillDir(makeSkill("alice", "pdf-helper"), { vendors: ["claudeCode"] });
+
+    await runRemove(
+      ["--key", VALID_KEY, "--url", serverUrl, "--json", "@alice/pdf-helper"],
+      { stdout },
+    );
+
+    const json = JSON.parse(stdout.text());
+    assert.equal(json.action, "removed");
+    assert.equal(json.libraryUpdated, true);
+    assert.equal(json.localDirsRemoved, 1);
+  });
+
+  it("--json outputs not-in-library status on 404", async () => {
+    server.setRemoveResponse("alice", "ghost", {
+      status: 404,
+      body: { code: "not_in_library" },
+    });
+
+    await runRemove(
+      ["--key", VALID_KEY, "--url", serverUrl, "--json", "@alice/ghost"],
+      { stdout },
+    );
+
+    const json = JSON.parse(stdout.text());
+    assert.equal(json.action, "not-in-library");
+    assert.equal(json.libraryUpdated, false);
+  });
+
+  it("cleans .old/ orphans from prior crashes as a pre-flight step", async () => {
+    // Round-1 review: `remove` should call cleanupOrphans for
+    // consistency with get/add/update. Verify that a stale .old/
+    // from a crashed prior write is cleaned when running remove.
+
+    // Set up a live skill + a stale .old/ sibling
+    writeSkillDir(makeSkill("alice", "existing"), { vendors: ["claudeCode"] });
+    const root = join(process.cwd(), ".claude", "skills");
+    mkdirSync(join(root, "ghost.old"));
+    writeFileSync(join(root, "ghost.old", "stale.txt"), "leftover");
+    // Also need a live ghost sibling so the .old is considered cleanable
+    mkdirSync(join(root, "ghost"));
+
+    // Run remove on an unrelated skill
+    await runRemove(["--key", VALID_KEY, "--url", serverUrl, "@alice/existing"], { stdout });
+
+    // The .old/ orphan should be gone (cleanupOrphans ran)
+    assert.ok(!existsSync(join(root, "ghost.old")), "stale .old should be cleaned");
+  });
+
+  it("--global removes from home dir", async () => {
+    writeSkillDir(makeSkill("alice", "pdf-helper"), { global: true });
+    const dir = resolvePlacementDir("claudeGlobal", "pdf-helper");
+    assert.ok(existsSync(dir));
+
+    await runRemove(
+      ["--key", VALID_KEY, "--url", serverUrl, "--global", "@alice/pdf-helper"],
+      { stdout },
+    );
+
+    assert.ok(!existsSync(dir));
+  });
+});
+
+describe("runRemove — error paths", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("rejects missing identifier", async () => {
+    await assert.rejects(
+      () => runRemove(["--key", VALID_KEY, "--url", serverUrl], { stdout }),
+      (err) => err instanceof CliError && err.exitCode === EXIT_VALIDATION,
+    );
+  });
+
+  it("rejects malformed identifier", async () => {
+    await assert.rejects(
+      () => runRemove(["--key", VALID_KEY, "--url", serverUrl, "not-an-identifier"], { stdout }),
+      (err) => err instanceof CliError && err.exitCode === EXIT_VALIDATION,
+    );
+  });
+
+  it("rejects extra positional after identifier", async () => {
+    await assert.rejects(
+      () => runRemove(["--key", VALID_KEY, "--url", serverUrl, "@a/b", "@c/d"], { stdout }),
+      (err) => err instanceof CliError && err.exitCode === EXIT_VALIDATION,
+    );
+  });
+
+  it("403 scope-required exits 4", async () => {
+    server.setRemoveResponse("alice", "scoped", {
+      status: 403,
+      body: { error: "Insufficient scope", code: "scope_required" },
+    });
+    await assert.rejects(
+      () => runRemove(["--key", VALID_KEY, "--url", serverUrl, "@alice/scoped"], { stdout }),
+      (err) => err instanceof CliError && err.exitCode === EXIT_SCOPE,
+    );
+  });
+
+  it("401 auth exits 2", async () => {
+    server.setRemoveResponse("alice", "auth-test", {
+      status: 401,
+      body: { error: "Invalid access key" },
+    });
+    await assert.rejects(
+      () => runRemove(["--key", VALID_KEY, "--url", serverUrl, "@alice/auth-test"], { stdout }),
+      (err) => err instanceof CliError && err.exitCode === EXIT_AUTH,
+    );
+  });
+});

package/src/test/commands/search.test.mjs

@@ -0,0 +1,204 @@
+/**
+ * Unit/integration tests for src/commands/search.mjs (PR2 of #646).
+ */
+
+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 { runSearch } from "../../commands/search.mjs";
+import { CliError, EXIT_VALIDATION, EXIT_AUTH } from "../../lib/errors.mjs";
+import { createMockServer } from "../e2e/mock-server.mjs";
+import { createCaptureStream } from "../helpers/capture-stream.mjs";
+
+let sandbox;
+let server;
+let serverUrl;
+let originalCwd;
+let originalHome;
+let stdout;
+let stderr;
+const VALID_KEY = "sk_live_test";
+
+function makeResult(owner, name, installs = 100) {
+  return {
+    owner,
+    name,
+    description: `${name} description`,
+    version: "1.0.0",
+    license: "MIT",
+    compatibility: null,
+    installs,
+    avgRating: null,
+    safetyGrade: null,
+    publishedAt: "2025-01-01T00:00:00Z",
+  };
+}
+
+async function setup() {
+  sandbox = mkdtempSync(join(tmpdir(), "cli-cmd-search-"));
+  mkdirSync(join(sandbox, "project"), { recursive: true });
+  mkdirSync(join(sandbox, "home"), { recursive: true });
+  originalCwd = process.cwd();
+  originalHome = process.env.HOME;
+  process.chdir(join(sandbox, "project"));
+  process.env.HOME = join(sandbox, "home");
+  delete process.env.SKILLREPO_ACCESS_KEY;
+
+  server = createMockServer({});
+  const port = await server.start();
+  serverUrl = `http://127.0.0.1:${port}`;
+
+  stdout = createCaptureStream();
+  stderr = createCaptureStream();
+}
+
+async function teardown() {
+  if (server) await server.stop();
+  process.chdir(originalCwd);
+  process.env.HOME = originalHome;
+  if (sandbox) rmSync(sandbox, { recursive: true, force: true });
+  server = null;
+}
+
+describe("runSearch — happy path", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("renders results as a table", async () => {
+    server.setSearchResponse({
+      skills: [makeResult("alice", "pdf-helper", 500), makeResult("bob", "code-review", 1200)],
+      pagination: { total: 2, limit: 20, offset: 0 },
+    });
+    await runSearch(["--key", VALID_KEY, "--url", serverUrl, "pdf"], { stdout });
+    const out = stdout.text();
+    assert.match(out, /pdf-helper/);
+    assert.match(out, /code-review/);
+    assert.match(out, /Results for "pdf"/);
+  });
+
+  it("formats install counts with k/M suffixes", async () => {
+    server.setSearchResponse({
+      skills: [makeResult("a", "x", 1500), makeResult("b", "y", 2_500_000)],
+      pagination: { total: 2, limit: 20, offset: 0 },
+    });
+    await runSearch(["--key", VALID_KEY, "--url", serverUrl, "test"], { stdout });
+    const out = stdout.text();
+    assert.match(out, /1\.5k/);
+    assert.match(out, /2\.5M/);
+  });
+
+  it("--json outputs structured result with semanticSupported flag", async () => {
+    server.setSearchResponse({
+      skills: [makeResult("alice", "pdf-helper")],
+      pagination: { total: 1, limit: 20, offset: 0 },
+    });
+    await runSearch(["--key", VALID_KEY, "--url", serverUrl, "--json", "pdf"], { stdout });
+    const json = JSON.parse(stdout.text());
+    assert.equal(json.query, "pdf");
+    assert.equal(json.semanticSupported, false);
+    assert.equal(json.semantic, false);
+    assert.equal(json.results.length, 1);
+  });
+
+  it("--limit passes through to the API", async () => {
+    server.setSearchResponse({
+      skills: [makeResult("alice", "x")],
+      pagination: { total: 1, limit: 50, offset: 0 },
+    });
+    // Just verify no error; the http unit tests cover the URL param wire format
+    await runSearch(["--key", VALID_KEY, "--url", serverUrl, "--limit", "50", "test"], { stdout });
+    assert.match(stdout.text(), /Results for "test"/);
+  });
+
+  it("--semantic emits a warning to stderr but proceeds with keyword search", async () => {
+    server.setSearchResponse({
+      skills: [makeResult("alice", "x")],
+      pagination: { total: 1, limit: 20, offset: 0 },
+    });
+    await runSearch(["--key", VALID_KEY, "--url", serverUrl, "--semantic", "test"], { stdout, stderr });
+    assert.match(stderr.text(), /reserved for v1\.1/);
+    assert.match(stdout.text(), /Results for "test"/);
+  });
+
+  it("--semantic warning fires even when search returns no results", async () => {
+    // Regression for round-1 review finding #7/C4: previously the
+    // warning fired AFTER the empty-results early return, so users
+    // got zero feedback that --semantic was downgraded to keyword
+    // search when no results were found.
+    server.setSearchResponse({
+      skills: [],
+      pagination: { total: 0, limit: 20, offset: 0 },
+    });
+    await runSearch(["--key", VALID_KEY, "--url", serverUrl, "--semantic", "obscure"], { stdout, stderr });
+    assert.match(stderr.text(), /reserved for v1\.1/);
+    assert.match(stdout.text(), /No skills found/);
+  });
+
+  it("renders 'no results' when search returns empty", async () => {
+    server.setSearchResponse({
+      skills: [],
+      pagination: { total: 0, limit: 20, offset: 0 },
+    });
+    await runSearch(["--key", VALID_KEY, "--url", serverUrl, "obscure"], { stdout });
+    assert.match(stdout.text(), /No skills found matching/);
+  });
+
+  it("shows pagination hint when total > shown", async () => {
+    server.setSearchResponse({
+      skills: [makeResult("a", "x")],
+      pagination: { total: 100, limit: 1, offset: 0 },
+    });
+    await runSearch(["--key", VALID_KEY, "--url", serverUrl, "--limit", "1", "test"], { stdout });
+    assert.match(stdout.text(), /Showing 1 of 100/);
+  });
+});
+
+describe("runSearch — error paths", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("rejects missing query", async () => {
+    await assert.rejects(
+      () => runSearch(["--key", VALID_KEY, "--url", serverUrl]),
+      (err) => err instanceof CliError && err.exitCode === EXIT_VALIDATION && /query is required/i.test(err.message),
+    );
+  });
+
+  it("rejects invalid --limit (non-integer)", async () => {
+    await assert.rejects(
+      () => runSearch(["--key", VALID_KEY, "--url", serverUrl, "--limit", "abc", "test"]),
+      (err) => err instanceof CliError && err.exitCode === EXIT_VALIDATION,
+    );
+  });
+
+  it("rejects --limit out of range (101)", async () => {
+    await assert.rejects(
+      () => runSearch(["--key", VALID_KEY, "--url", serverUrl, "--limit", "101", "test"]),
+      (err) => err instanceof CliError && err.exitCode === EXIT_VALIDATION,
+    );
+  });
+
+  it("rejects --limit 0", async () => {
+    await assert.rejects(
+      () => runSearch(["--key", VALID_KEY, "--url", serverUrl, "--limit", "0", "test"]),
+      (err) => err instanceof CliError && err.exitCode === EXIT_VALIDATION,
+    );
+  });
+
+  it("rejects extra positional after query", async () => {
+    await assert.rejects(
+      () => runSearch(["--key", VALID_KEY, "--url", serverUrl, "first", "second"]),
+      (err) => err instanceof CliError && err.exitCode === EXIT_VALIDATION,
+    );
+  });
+
+  it("throws authError when no credentials", async () => {
+    await assert.rejects(
+      () => runSearch(["test"]),
+      (err) => err instanceof CliError && err.exitCode === EXIT_AUTH,
+    );
+  });
+});