skillrepo 4.8.0 → 4.8.2

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

@@ -4,13 +4,27 @@
 
 import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, existsSync, writeFileSync } from "node:fs";
+import {
+  mkdtempSync,
+  mkdirSync,
+  rmSync,
+  existsSync,
+  writeFileSync,
+  chmodSync,
+} 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 { writeLastSync, readLastSync } from "../../lib/sync.mjs";
+import {
+  CliError,
+  EXIT_VALIDATION,
+  EXIT_AUTH,
+  EXIT_SCOPE,
+  EXIT_NETWORK,
+} from "../../lib/errors.mjs";
 import { createMockServer } from "../e2e/mock-server.mjs";
 import { createCaptureStream } from "../helpers/capture-stream.mjs";
 import {
@@ -241,3 +255,208 @@ describe("runRemove — error paths", () => {
     );
   });
 });
+
+// ── Coverage gap closure: --agent vectors + transport errors ───────────
+//
+// `remove` shares `requireVendorTargets` with add/get and the same
+// http.mjs error mapping. These lock the vectors that were untested at
+// the command layer: the `--agent none` no-op rejection (exit 5), the
+// vendor-scoped local delete (only the cursor `.agents/skills/` placement
+// is removed, the claude placement survives), and the network-failure
+// exit 1. `removeSkillFromLibrary` is a single-shot (no retry) DELETE, so
+// a connection refusal surfaces immediately as networkError.
+describe("runRemove — --agent flag + transport error paths", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("rejects --agent none with a validation error (no targets to delete from)", async () => {
+    await assert.rejects(
+      () =>
+        runRemove(
+          ["--key", VALID_KEY, "--url", serverUrl, "--agent", "none", "@alice/pdf-helper"],
+          { stdout },
+        ),
+      (err) =>
+        err instanceof CliError &&
+        err.exitCode === EXIT_VALIDATION &&
+        /--agent none has no effect on `skillrepo remove`/.test(err.message),
+    );
+  });
+
+  it("--agent cursor performs a vendor-scoped delete: only the .agents/skills/ placement is removed", async () => {
+    // Seed the SAME skill into BOTH the cursor (.agents/skills/) and the
+    // claude (.claude/skills/) placements.
+    writeSkillDir(makeSkill("alice", "pdf-helper"), { vendors: ["cursor"] });
+    writeSkillDir(makeSkill("alice", "pdf-helper"), { vendors: ["claudeCode"] });
+    const agentsDir = resolvePlacementDir("agentsProject", "pdf-helper");
+    const claudeDir = resolvePlacementDir("claudeProject", "pdf-helper");
+    assert.ok(existsSync(agentsDir), "precondition: cursor placement exists");
+    assert.ok(existsSync(claudeDir), "precondition: claude placement exists");
+
+    // Default server response is 200 removed. --agent cursor scopes the
+    // local delete to the cohort target only.
+    await runRemove(
+      ["--key", VALID_KEY, "--url", serverUrl, "--agent", "cursor", "@alice/pdf-helper"],
+      { stdout },
+    );
+
+    // The cursor placement is gone …
+    assert.ok(!existsSync(agentsDir), "--agent cursor must delete the .agents/skills/ placement");
+    // … but the claude placement is untouched (proves the scoping; a
+    // regression that deleted every placement would fail here).
+    assert.ok(
+      existsSync(claudeDir),
+      "--agent cursor must NOT delete the claude placement",
+    );
+  });
+
+  it("network failure exits 1 (network)", async () => {
+    // Connection-refused on the DELETE call → safeFetch wraps it as
+    // networkError (exit 1). removeSkillFromLibrary does not retry.
+    await assert.rejects(
+      () =>
+        runRemove(
+          ["--key", VALID_KEY, "--url", "http://127.0.0.1:1", "@alice/pdf-helper"],
+          { stdout },
+        ),
+      (err) => err instanceof CliError && err.exitCode === EXIT_NETWORK,
+    );
+  });
+
+  it("removed + 2 local placements → pluralized 'directories' summary", async () => {
+    // Branch coverage: every prior test deletes exactly ONE directory,
+    // so the plural side of `director{y|ies}` on the
+    // `wasRemovedFromLibrary && localCount > 0` summary (remove.mjs
+    // line ~160) was never exercised. Seed the SAME skill into two
+    // distinct placement dirs (claude → .claude/skills/, cursor →
+    // .agents/skills/) and remove with both targets so localCount === 2.
+    writeSkillDir(makeSkill("alice", "pdf-helper"), { vendors: ["claudeCode"] });
+    writeSkillDir(makeSkill("alice", "pdf-helper"), { vendors: ["cursor"] });
+    const claudeDir = resolvePlacementDir("claudeProject", "pdf-helper");
+    const agentsDir = resolvePlacementDir("agentsProject", "pdf-helper");
+    assert.ok(existsSync(claudeDir) && existsSync(agentsDir), "precondition: both placements exist");
+
+    // Default server response is 200 removed.
+    await runRemove(
+      ["--key", VALID_KEY, "--url", serverUrl, "--agent", "claude,cursor", "@alice/pdf-helper"],
+      { stdout },
+    );
+
+    assert.ok(!existsSync(claudeDir) && !existsSync(agentsDir), "both placements deleted");
+    assert.match(
+      stdout.text(),
+      /deleted 2 local directories/,
+      "two removed dirs must pluralize as 'directories'",
+    );
+  });
+
+  // NOTE: the `io.stdout ?? process.stdout` default (remove.mjs line 59) is
+  // intentionally NOT unit-tested. The only way to exercise it is to stub
+  // `process.stdout.write` across an `await`, which collides with node:test's
+  // TAP-over-stdout IPC and DEADLOCKS the runner (a Windows-only hang that
+  // burned a 10-minute CI job). See capture-stream.mjs's docstring. The
+  // default is a one-token defensive fallback; it isn't worth that pattern.
+
+  it("not-in-library + 2 local placements → pluralized 'directories' summary", async () => {
+    // Plural side of the OTHER summary branch (remove.mjs line ~176):
+    // the 404 not-in-library path with more than one local placement.
+    writeSkillDir(makeSkill("alice", "orphan"), { vendors: ["claudeCode"] });
+    writeSkillDir(makeSkill("alice", "orphan"), { vendors: ["cursor"] });
+
+    server.setRemoveResponse("alice", "orphan", {
+      status: 404,
+      body: { code: "not_in_library" },
+    });
+
+    await runRemove(
+      ["--key", VALID_KEY, "--url", serverUrl, "--agent", "claude,cursor", "@alice/orphan"],
+      { stdout },
+    );
+
+    assert.ok(!existsSync(resolvePlacementDir("claudeProject", "orphan")));
+    assert.ok(!existsSync(resolvePlacementDir("agentsProject", "orphan")));
+    assert.match(
+      stdout.text(),
+      /wasn't in your library — deleted 2 local directories/,
+      "two removed dirs on the not-in-library path must pluralize as 'directories'",
+    );
+  });
+});
+
+// ── Coverage gap closure: the deleteLastSyncEntry catch swallow ─────────
+//
+// remove.mjs step 2.5 wraps `deleteLastSyncEntry` in try/catch and
+// swallows any throw (lines 121-125): a stale `.last-sync` baseline is
+// recoverable via the next `update`, so a write failure there must NOT
+// fail the command after the user's primary intent (skill gone from
+// library + disk) was already honored.
+//
+// The catch runs ONLY when `deleteLastSyncEntry` throws, which requires
+// readLastSync to SUCCEED (a valid `.last-sync` WITH this skill's entry)
+// AND writeLastSync to FAIL. We force the write failure by making the
+// `~/.claude/skillrepo/` directory read+execute only (0o555): the read
+// succeeds (the file is already there) but the atomic write's temp-file
+// creation inside that dir fails with EACCES.
+describe("runRemove — deleteLastSyncEntry write failure is swallowed", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("does not fail the command when purging the .last-sync entry throws (POSIX)", async (t) => {
+    if (process.platform === "win32") {
+      // chmod 0o555 does not block writes on Windows (the mode bits
+      // don't map to the ACL layer — see fs-utils.mjs writeFileAtomic),
+      // so this fault-injection technique can't reproduce the EACCES.
+      // Skipped rather than silently passing for the wrong reason.
+      t.skip("chmod does not gate writes on win32");
+      return;
+    }
+
+    // Seed a valid `.last-sync` that contains this skill's entry so
+    // readLastSync succeeds and the key IS present (both preconditions
+    // for deleteLastSyncEntry to reach its writeLastSync call).
+    writeLastSync({
+      etag: "etag-1",
+      syncedAt: new Date().toISOString(),
+      skills: {
+        "alice/pdf-helper": { version: "1.0.0", shas: { "SKILL.md": "x" } },
+      },
+    });
+    assert.ok(
+      readLastSync().skills["alice/pdf-helper"],
+      "precondition: .last-sync must carry the skill entry",
+    );
+
+    // Pre-write the local skill so the happy-path delete still reports
+    // success (proving the command completed despite the swallowed throw).
+    writeSkillDir(makeSkill("alice", "pdf-helper"), { vendors: ["claudeCode"] });
+    const dir = resolvePlacementDir("claudeProject", "pdf-helper");
+    assert.ok(existsSync(dir));
+
+    // Make the `.last-sync` parent dir read+execute only so the atomic
+    // temp-file write fails with EACCES → writeLastSync throws →
+    // deleteLastSyncEntry throws → remove.mjs's catch swallows it.
+    const skillrepoDir = join(process.env.HOME, ".claude", "skillrepo");
+    chmodSync(skillrepoDir, 0o555);
+    try {
+      // Default server response is 200 removed. Must resolve (not reject)
+      // — the swallowed throw must not surface to the caller.
+      await assert.doesNotReject(
+        runRemove(
+          ["--key", VALID_KEY, "--url", serverUrl, "@alice/pdf-helper"],
+          { stdout },
+        ),
+      );
+    } finally {
+      // Restore write perms so teardown's rmSync can clean the sandbox.
+      chmodSync(skillrepoDir, 0o755);
+    }
+
+    // The command still reported success and deleted the local files.
+    assert.ok(!existsSync(dir), "local files must still be deleted");
+    assert.match(
+      stdout.text(),
+      /Removed @alice\/pdf-helper from your library/,
+      "the command must report success despite the swallowed .last-sync write failure",
+    );
+  });
+});

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

@@ -9,7 +9,7 @@ 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 { CliError, EXIT_VALIDATION, EXIT_AUTH, EXIT_NETWORK } from "../../lib/errors.mjs";
 import { createMockServer } from "../e2e/mock-server.mjs";
 import { createCaptureStream } from "../helpers/capture-stream.mjs";
 import {
@@ -160,6 +160,194 @@ describe("runSearch — happy path", () => {
     await runSearch(["--key", VALID_KEY, "--url", serverUrl, "--limit", "1", "test"], { stdout });
     assert.match(stdout.text(), /Showing 1 of 100/);
   });
+
+  it("--json --semantic sets semantic:true / semanticSupported:false and writes NO note to stderr", async () => {
+    // In JSON mode runSearch writes the structured object and returns
+    // BEFORE the `if (semantic)` stderr-note branch (search.mjs ~83-111).
+    // So a script consuming --json sees the no-op surfaced in the JSON
+    // fields, and stderr stays clean (no human-prose note interleaved
+    // with machine output). Assert BOTH halves of the contract.
+    server.setSearchResponse({
+      skills: [makeResult("alice", "pdf-helper")],
+      pagination: { total: 1, limit: 20, offset: 0 },
+    });
+    await runSearch(
+      ["--key", VALID_KEY, "--url", serverUrl, "--json", "--semantic", "pdf"],
+      { stdout, stderr },
+    );
+    const json = JSON.parse(stdout.text());
+    assert.equal(json.semantic, true);
+    assert.equal(json.semanticSupported, false);
+    // The non-JSON branch is the ONLY place the note is emitted, so
+    // JSON mode must leave stderr empty of it.
+    assert.doesNotMatch(stderr.text(), /reserved for v1\.1/);
+    assert.equal(stderr.text(), "");
+  });
+
+  it("missing pagination → footer total falls back to the number of skills shown", async () => {
+    // Regression guard for the #1923 search-undercount fix. The production
+    // server route normally emits `pagination: {total,...}`
+    // (src/app/api/v1/skills/search/route.ts), but a pagination-less
+    // response used to make `search` print "0 results" beneath a visible
+    // row: searchSkills (http.mjs) defaulted absent pagination to
+    // `{ total: 0, ... }`, fabricating a zero count. http.mjs now defaults
+    // `total` to `skills.length` (http.mjs ~1129), so a pagination-less
+    // response renders the honest count. This asserts the corrected
+    // behavior (1 row ⇒ "1 result", never "0 results"); it goes RED again
+    // only if that normalization regresses.
+    server.setSearchResponse({
+      skills: [makeResult("alice", "only-one", 42)],
+      pagination: null,
+    });
+    await runSearch(["--key", VALID_KEY, "--url", serverUrl, "solo"], { stdout });
+    const out = stdout.text();
+    // Must not crash and must render the row.
+    assert.match(out, /only-one/);
+    // One skill shown → exactly one result reported.
+    assert.match(out, /\b1 result\b/);
+    // And it must NOT under-report as zero.
+    assert.doesNotMatch(out, /\b0 results\b/);
+  });
+
+  it("renders an em-dash for a result with a non-number install count", async () => {
+    // formatInstallCount (search.mjs ~178) returns "—" for anything
+    // that isn't a finite number. A result whose `installs` is null
+    // must render the dash in that column, not "null"/"0"/NaN.
+    const result = makeResult("alice", "no-installs", 0);
+    result.installs = null;
+    server.setSearchResponse({
+      skills: [result],
+      pagination: { total: 1, limit: 20, offset: 0 },
+    });
+    await runSearch(["--key", VALID_KEY, "--url", serverUrl, "test"], { stdout });
+    const out = stdout.text();
+    assert.match(out, /no-installs/);
+    assert.match(out, /—/);
+    // Sanity: the raw null must not have leaked into the table.
+    assert.doesNotMatch(out, /\bnull\b/);
+  });
+
+  it("truncates a description longer than the 60-char column budget", async () => {
+    // truncate (search.mjs ~185) returns the input unchanged when it
+    // fits, but slices to n-1 chars + "…" when it exceeds the budget.
+    // The existing happy-path results all use the short
+    // `${name} description` string (< 60 chars), so only the no-op arm
+    // ran. A >60-char description exercises the truncating arm.
+    const result = makeResult("alice", "verbose", 10);
+    result.description = "x".repeat(200);
+    server.setSearchResponse({
+      skills: [result],
+      pagination: { total: 1, limit: 20, offset: 0 },
+    });
+    await runSearch(["--key", VALID_KEY, "--url", serverUrl, "test"], { stdout });
+    const out = stdout.text();
+    assert.match(out, /verbose/);
+    // The ellipsis marker proves the truncating branch ran.
+    assert.match(out, /…/);
+  });
+
+  it("renders the em-dash version + empty description for a result missing both", async () => {
+    // printTable (search.mjs ~135/137) falls back to "—" when
+    // `s.version` is empty and to "" when `s.description` is empty.
+    // The makeResult helper always supplies both, so the false sides
+    // of those `||` defaults never ran. A result with empty version
+    // and description exercises them.
+    const result = makeResult("alice", "bare", 5);
+    result.version = "";
+    result.description = "";
+    server.setSearchResponse({
+      skills: [result],
+      pagination: { total: 1, limit: 20, offset: 0 },
+    });
+    await runSearch(["--key", VALID_KEY, "--url", serverUrl, "test"], { stdout });
+    const out = stdout.text();
+    assert.match(out, /bare/);
+    // Version column shows the em-dash placeholder.
+    assert.match(out, /—/);
+  });
+});
+
+// ── streamColumns coverage ──────────────────────────────────────────────
+//
+// streamColumns (search.mjs ~168) mirrors list.mjs: it reads the injected
+// stream's numeric `.columns` first, then falls back to
+// process.stdout.columns, then to a 100-col default. The happy-path tests
+// use the plain capture stream (no `.columns`) with process.stdout.columns
+// unset in the test runner, so only the final `return 100` default ran.
+// These two tests cover the first two arms.
+
+/** A capture stream that carries a fixed numeric column width. */
+function createWidthCaptureStream(columns = 120) {
+  const stream = createCaptureStream();
+  stream.columns = columns;
+  return stream;
+}
+
+describe("runSearch — streamColumns", () => {
+  beforeEach(setup);
+  afterEach(teardown);
+
+  it("uses the injected stream's .columns when present", async () => {
+    const wideStdout = createWidthCaptureStream(120);
+    server.setSearchResponse({
+      skills: [makeResult("alice", "pdf-helper", 500)],
+      pagination: { total: 1, limit: 20, offset: 0 },
+    });
+    await runSearch(["--key", VALID_KEY, "--url", serverUrl, "pdf"], {
+      stdout: wideStdout,
+    });
+    // First streamColumns arm (out.columns numeric > 0) ran; table still
+    // renders correctly.
+    assert.match(wideStdout.text(), /pdf-helper/);
+  });
+
+  it("falls back to the 100-col default for a narrow (<=60) terminal width", async () => {
+    // computeColWidths (search.mjs ~155) uses `terminalColumns > 60 ?
+    // Math.min(..., 120) : 100`. A stream reporting a width <= 60
+    // exercises the `: 100` arm — the narrow-terminal floor — which the
+    // wide-stream and default-path tests don't reach.
+    const narrowStdout = createWidthCaptureStream(40);
+    server.setSearchResponse({
+      skills: [makeResult("alice", "pdf-helper", 500)],
+      pagination: { total: 1, limit: 20, offset: 0 },
+    });
+    await runSearch(["--key", VALID_KEY, "--url", serverUrl, "pdf"], {
+      stdout: narrowStdout,
+    });
+    assert.match(narrowStdout.text(), /pdf-helper/);
+  });
+});
+
+describe("runSearch — streamColumns process.stdout fallback", () => {
+  let stdoutColumnsSnapshot;
+  let hadOwnColumns;
+
+  beforeEach(async () => {
+    await setup();
+    // The injected capture stream has no `.columns`, so streamColumns
+    // falls through to process.stdout.columns. Force a numeric value
+    // there for the duration of this test to cover that second arm.
+    hadOwnColumns = Object.prototype.hasOwnProperty.call(process.stdout, "columns");
+    stdoutColumnsSnapshot = process.stdout.columns;
+    process.stdout.columns = 90;
+  });
+  afterEach(async () => {
+    if (hadOwnColumns) {
+      process.stdout.columns = stdoutColumnsSnapshot;
+    } else {
+      delete process.stdout.columns;
+    }
+    await teardown();
+  });
+
+  it("uses process.stdout.columns when the injected stream has none", async () => {
+    server.setSearchResponse({
+      skills: [makeResult("alice", "pdf-helper", 500)],
+      pagination: { total: 1, limit: 20, offset: 0 },
+    });
+    await runSearch(["--key", VALID_KEY, "--url", serverUrl, "pdf"], { stdout });
+    assert.match(stdout.text(), /pdf-helper/);
+  });
 });
 
 describe("runSearch — error paths", () => {
@@ -207,4 +395,18 @@ describe("runSearch — error paths", () => {
       (err) => err instanceof CliError && err.exitCode === EXIT_AUTH,
     );
   });
+
+  it("rejects with a network CliError when GET /skills/search returns 500", async () => {
+    // search goes straight to searchSkills — no prior validate call —
+    // so the one-shot forced status fires on the search GET itself.
+    // searchSkills uses retry:true, but 500 is NOT transient
+    // (TRANSIENT_STATUS_CODES = 429/502/503/504), so withRetry
+    // returns it immediately and mapErrorResponse maps `status >= 500`
+    // to networkError → EXIT_NETWORK (exit 1). Real mapped value.
+    server.setForcedStatus(500, { error: "boom" });
+    await assert.rejects(
+      () => runSearch(["--key", VALID_KEY, "--url", serverUrl, "test"], { stdout, stderr }),
+      (err) => err instanceof CliError && err.exitCode === EXIT_NETWORK,
+    );
+  });
 });