skissue 0.1.21 → 0.1.23

package/README.md

@@ -324,7 +324,7 @@ npm run check:all
 
 This repo uses a three-workflow CI/CD pipeline:
 
-1. **PR & push** — [`ci.yml`](.github/workflows/ci.yml) runs `npm run verify` (TypeScript, ESLint, Prettier, tests, harness, harness score, build)
+1. **PR & push** — [`ci.yml`](.github/workflows/ci.yml) runs `npm run verify` (TypeScript, ESLint, Prettier, tests with coverage thresholds, harness, harness score, build)
 2. **Green main** — [`version-and-release.yml`](.github/workflows/version-and-release.yml) bumps the patch version, tags, and creates a GitHub Release
 3. **Tag push** — [`publish.yml`](.github/workflows/publish.yml) runs `npm publish --access public`
 
@@ -371,17 +371,17 @@ skillsRoot: .agents/skills
 git clone https://github.com/midyan/skissue.git
 cd skissue
 npm install          # also enables Husky git hooks via prepare
-npm run verify       # typecheck + lint + format + test + harness + harness score + build
+npm run verify       # typecheck + lint + format + test:coverage + harness + harness score + build
 ```
 
-| Script                  | What it does                                                                  |
-| ----------------------- | ----------------------------------------------------------------------------- |
-| `npm run dev -- <args>` | Run CLI from source via tsx                                                   |
-| `npm run verify`        | Full pipeline: tsc, eslint, prettier, vitest, check:all, harness score, build |
-| `npm run build`         | Production build via esbuild                                                  |
-| `npm test`              | Run vitest                                                                    |
-| `npm run check:all`     | Harness runner (hard skill checks)                                            |
-| `npm run repo-verify`   | Same as verify, with explicit skill discovery output                          |
+| Script                  | What it does                                                                           |
+| ----------------------- | -------------------------------------------------------------------------------------- |
+| `npm run dev -- <args>` | Run CLI from source via tsx                                                            |
+| `npm run verify`        | Full pipeline: tsc, eslint, prettier, vitest+coverage, check:all, harness score, build |
+| `npm run build`         | Production build via esbuild                                                           |
+| `npm test`              | Run vitest                                                                             |
+| `npm run check:all`     | Harness runner (hard skill checks)                                                     |
+| `npm run repo-verify`   | Same as verify, with explicit skill discovery output                                   |
 
 ### Project structure
 

package/dist/entry.js

@@ -864,9 +864,9 @@ async function runInit(cwd) {
 }
 
 // src/commands/install.ts
-import chalk3 from "chalk";
-import ora from "ora";
-import { join as join6 } from "node:path";
+import chalk4 from "chalk";
+import ora2 from "ora";
+import { join as join7 } from "node:path";
 
 // src/lockfile.ts
 import { readFile as readFile2, writeFile as writeFile3, mkdir as mkdir5 } from "node:fs/promises";
@@ -915,44 +915,85 @@ function removeSkillLock(lock, skillId) {
   return { ...lock, skills };
 }
 
-// src/registry/resolve.ts
-import { readFile as readFile3 } from "node:fs/promises";
+// src/registry/catalog.ts
+import { access as access2, readFile as readFile3, readdir } from "node:fs/promises";
+import { constants } from "node:fs";
 import { join as join4 } from "node:path";
 import { z as z3 } from "zod";
 var RegistryJsonSchema = z3.object({
   skills: z3.record(z3.string(), z3.string()).optional()
 }).passthrough();
-async function resolveSkillPath(registryRepoRoot, skillId) {
+async function listRegistrySkillIds(registryRepoRoot) {
+  const ids = /* @__PURE__ */ new Set();
   const registryFile = join4(registryRepoRoot, "registry.json");
+  try {
+    const raw = await readFile3(registryFile, "utf8");
+    const parsed = JSON.parse(raw);
+    const reg = RegistryJsonSchema.safeParse(parsed);
+    if (reg.success && reg.data.skills) {
+      for (const id of Object.keys(reg.data.skills)) {
+        if (id.trim()) ids.add(id);
+      }
+    }
+  } catch {
+  }
+  const registryDir = join4(registryRepoRoot, "registry");
+  try {
+    const entries = await readdir(registryDir, { withFileTypes: true });
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      const id = e.name;
+      if (!id.trim()) continue;
+      const skillRoot = join4(registryDir, id);
+      try {
+        await access2(join4(skillRoot, "SKILL.md"), constants.R_OK);
+        ids.add(id);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return [...ids].sort((a, b) => a.localeCompare(b));
+}
+
+// src/registry/resolve.ts
+import { readFile as readFile4 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+import { z as z4 } from "zod";
+var RegistryJsonSchema2 = z4.object({
+  skills: z4.record(z4.string(), z4.string()).optional()
+}).passthrough();
+async function resolveSkillPath(registryRepoRoot, skillId) {
+  const registryFile = join5(registryRepoRoot, "registry.json");
   let raw;
   try {
-    raw = await readFile3(registryFile, "utf8");
+    raw = await readFile4(registryFile, "utf8");
   } catch {
-    return { skillPath: join4("registry", skillId).replace(/\\/g, "/"), source: "convention" };
+    return { skillPath: join5("registry", skillId).replace(/\\/g, "/"), source: "convention" };
   }
   const parsed = JSON.parse(raw);
-  const reg = RegistryJsonSchema.safeParse(parsed);
+  const reg = RegistryJsonSchema2.safeParse(parsed);
   if (!reg.success || !reg.data.skills) {
-    return { skillPath: join4("registry", skillId).replace(/\\/g, "/"), source: "convention" };
+    return { skillPath: join5("registry", skillId).replace(/\\/g, "/"), source: "convention" };
   }
   const mapped = reg.data.skills[skillId];
   if (mapped !== void 0 && mapped.length > 0) {
     return { skillPath: normalizeRelPath(mapped), source: "registry.json" };
   }
-  return { skillPath: join4("registry", skillId).replace(/\\/g, "/"), source: "convention" };
+  return { skillPath: join5("registry", skillId).replace(/\\/g, "/"), source: "convention" };
 }
 function normalizeRelPath(p4) {
   return p4.replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+$/, "");
 }
 
 // src/io.ts
-import { access as access2, cp, rm as rm2 } from "node:fs/promises";
-import { constants } from "node:fs";
-import { join as join5 } from "node:path";
+import { access as access3, cp, rm as rm2 } from "node:fs/promises";
+import { constants as constants2 } from "node:fs";
+import { join as join6 } from "node:path";
 async function assertSkillMdPresent(skillSourceDir) {
-  const p4 = join5(skillSourceDir, "SKILL.md");
+  const p4 = join6(skillSourceDir, "SKILL.md");
   try {
-    await access2(p4, constants.R_OK);
+    await access3(p4, constants2.R_OK);
   } catch {
     throw new Error(`Expected SKILL.md in skill path: ${skillSourceDir}`);
   }
@@ -962,10 +1003,50 @@ async function copySkillTree(fromDir, toDir) {
   await cp(fromDir, toDir, { recursive: true, force: true });
 }
 
+// src/commands/uninstall.ts
+import chalk3 from "chalk";
+import ora from "ora";
+import { rm as rm3 } from "node:fs/promises";
+async function uninstallSkillQuiet(cwd, skillId) {
+  const config = await loadConfig(cwd);
+  const dest = skillInstallPath(cwd, config.skillsRoot, skillId);
+  await rm3(dest, { recursive: true, force: true });
+  const lock = await readLockOrEmpty(cwd);
+  if (lock.skills[skillId]) {
+    await writeLock(cwd, removeSkillLock(lock, skillId));
+  }
+}
+async function runUninstall(cwd, skillId) {
+  const spin = ora(`Removing ${skillId}`).start();
+  try {
+    const lockBefore = await readLockOrEmpty(cwd);
+    await uninstallSkillQuiet(cwd, skillId);
+    if (!lockBefore.skills[skillId]) {
+      spin.stopAndPersist({
+        symbol: chalk3.yellow("\u26A0"),
+        text: chalk3.yellow(`No lock entry for ${skillId}; removed directory if present.`)
+      });
+    } else {
+      spin.succeed(chalk3.green(`Uninstalled ${skillId}`));
+    }
+  } catch (err) {
+    spin.fail(chalk3.red(err instanceof Error ? err.message : String(err)));
+    throw err;
+  }
+}
+
 // src/commands/install.ts
-async function installSkillFromCheckout(cwd, config, repoPath, head, skillId) {
+async function installSkillFromCheckout(cwd, config, repoPath, head, skillId, catalogIds) {
+  if (!catalogIds.has(skillId)) {
+    const lock2 = await readLockOrEmpty(cwd);
+    if (lock2.skills[skillId]) {
+      await uninstallSkillQuiet(cwd, skillId);
+      return { outcome: "removed", skillId };
+    }
+    throw new Error(`Skill "${skillId}" is not in the registry.`);
+  }
   const { skillPath } = await resolveSkillPath(repoPath, skillId);
-  const src = join6(repoPath, skillPath);
+  const src = join7(repoPath, skillPath);
   await assertSkillMdPresent(src);
   const dest = skillInstallPath(cwd, config.skillsRoot, skillId);
   await copySkillTree(src, dest);
@@ -977,17 +1058,26 @@ async function installSkillFromCheckout(cwd, config, repoPath, head, skillId) {
     ref
   });
   await writeLock(cwd, next);
-  return dest;
+  return { outcome: "installed", dest };
 }
 async function runInstall(cwd, skillId) {
   const config = await loadConfig(cwd);
-  const spin = ora(`Resolving registry and installing ${skillId}`).start();
+  const spin = ora2(`Resolving registry and installing ${skillId}`).start();
   try {
     const { path: repoPath, head } = await ensureRegistryCheckout(cwd, config);
-    const dest = await installSkillFromCheckout(cwd, config, repoPath, head, skillId);
-    spin.succeed(chalk3.green(`Installed ${skillId} \u2192 ${dest}`));
+    const catalogIds = new Set(await listRegistrySkillIds(repoPath));
+    const result = await installSkillFromCheckout(cwd, config, repoPath, head, skillId, catalogIds);
+    if (result.outcome === "removed") {
+      spin.succeed(
+        chalk4.yellow(
+          `Removed ${skillId} \u2014 no longer in the registry (was still installed locally).`
+        )
+      );
+    } else {
+      spin.succeed(chalk4.green(`Installed ${skillId} \u2192 ${result.dest}`));
+    }
   } catch (err) {
-    spin.fail(chalk3.red(err instanceof Error ? err.message : String(err)));
+    spin.fail(chalk4.red(err instanceof Error ? err.message : String(err)));
     throw err;
   }
 }
@@ -998,55 +1088,45 @@ async function runInstallMany(cwd, skillIds, options) {
   if (options?.checkout) {
     ({ path: repoPath, head } = options.checkout);
   } else {
-    const prep = ora("Preparing registry\u2026").start();
+    const prep = ora2("Preparing registry\u2026").start();
     try {
       const c = await ensureRegistryCheckout(cwd, config);
       repoPath = c.path;
       head = c.head;
-      prep.succeed(chalk3.green("Registry ready."));
+      prep.succeed(chalk4.green("Registry ready."));
     } catch (err) {
-      prep.fail(chalk3.red(err instanceof Error ? err.message : String(err)));
+      prep.fail(chalk4.red(err instanceof Error ? err.message : String(err)));
       throw err;
     }
   }
+  const catalogIds = new Set(await listRegistrySkillIds(repoPath));
   for (const skillId of skillIds) {
-    const spin = ora(`Installing ${skillId}\u2026`).start();
+    const spin = ora2(`Installing ${skillId}\u2026`).start();
     try {
-      const dest = await installSkillFromCheckout(cwd, config, repoPath, head, skillId);
-      spin.succeed(chalk3.green(`Installed ${skillId} \u2192 ${dest}`));
+      const result = await installSkillFromCheckout(
+        cwd,
+        config,
+        repoPath,
+        head,
+        skillId,
+        catalogIds
+      );
+      if (result.outcome === "removed") {
+        spin.succeed(
+          chalk4.yellow(
+            `Removed ${skillId} \u2014 no longer in the registry (was still installed locally).`
+          )
+        );
+      } else {
+        spin.succeed(chalk4.green(`Installed ${skillId} \u2192 ${result.dest}`));
+      }
     } catch (err) {
-      spin.fail(chalk3.red(err instanceof Error ? err.message : String(err)));
+      spin.fail(chalk4.red(err instanceof Error ? err.message : String(err)));
       throw err;
     }
   }
 }
 
-// src/commands/uninstall.ts
-import chalk4 from "chalk";
-import ora2 from "ora";
-import { rm as rm3 } from "node:fs/promises";
-async function runUninstall(cwd, skillId) {
-  const config = await loadConfig(cwd);
-  const spin = ora2(`Removing ${skillId}`).start();
-  try {
-    const dest = skillInstallPath(cwd, config.skillsRoot, skillId);
-    await rm3(dest, { recursive: true, force: true });
-    const lock = await readLockOrEmpty(cwd);
-    if (!lock.skills[skillId]) {
-      spin.stopAndPersist({
-        symbol: chalk4.yellow("\u26A0"),
-        text: chalk4.yellow(`No lock entry for ${skillId}; removed directory if present.`)
-      });
-    } else {
-      await writeLock(cwd, removeSkillLock(lock, skillId));
-      spin.succeed(chalk4.green(`Uninstalled ${skillId}`));
-    }
-  } catch (err) {
-    spin.fail(chalk4.red(err instanceof Error ? err.message : String(err)));
-    throw err;
-  }
-}
-
 // src/commands/list.ts
 import chalk5 from "chalk";
 async function runList(cwd) {
@@ -1186,47 +1266,6 @@ function printSkillIssueBanner(version) {
   console.log("");
 }
 
-// src/registry/catalog.ts
-import { access as access3, readFile as readFile4, readdir } from "node:fs/promises";
-import { constants as constants2 } from "node:fs";
-import { join as join7 } from "node:path";
-import { z as z4 } from "zod";
-var RegistryJsonSchema2 = z4.object({
-  skills: z4.record(z4.string(), z4.string()).optional()
-}).passthrough();
-async function listRegistrySkillIds(registryRepoRoot) {
-  const ids = /* @__PURE__ */ new Set();
-  const registryFile = join7(registryRepoRoot, "registry.json");
-  try {
-    const raw = await readFile4(registryFile, "utf8");
-    const parsed = JSON.parse(raw);
-    const reg = RegistryJsonSchema2.safeParse(parsed);
-    if (reg.success && reg.data.skills) {
-      for (const id of Object.keys(reg.data.skills)) {
-        if (id.trim()) ids.add(id);
-      }
-    }
-  } catch {
-  }
-  const registryDir = join7(registryRepoRoot, "registry");
-  try {
-    const entries = await readdir(registryDir, { withFileTypes: true });
-    for (const e of entries) {
-      if (!e.isDirectory()) continue;
-      const id = e.name;
-      if (!id.trim()) continue;
-      const skillRoot = join7(registryDir, id);
-      try {
-        await access3(join7(skillRoot, "SKILL.md"), constants2.R_OK);
-        ids.add(id);
-      } catch {
-      }
-    }
-  } catch {
-  }
-  return [...ids].sort((a, b) => a.localeCompare(b));
-}
-
 // src/commands/manage.ts
 var MAIN_MENU_DOUBLE_ESCAPE_MS = 1200;
 async function promptMainMenuSelect(availableCount, installedCount) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skissue",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -41,7 +41,7 @@
     "check:registry": "tsx harness/validate-registry/hard/index.ts",
     "check:all": "tsx harness/runner.ts",
     "check:harness-score": "tsx harness/report-harness-score/hard/index.ts",
-    "verify": "tsc --noEmit && npm run lint && npm run format:check && npm test && npm run check:all && npm run check:harness-score && npm run build",
+    "verify": "tsc --noEmit && npm run lint && npm run format:check && npm run test:coverage && npm run check:all && npm run check:harness-score && npm run build",
     "repo-verify": "tsx harness/repo-verify/hard/index.ts",
     "prepublishOnly": "npm run build",
     "prepare": "husky || node -e \"process.exit(0)\""