@ecology91/skills 0.1.4 → 0.1.5

package/README.md

@@ -1,7 +1,7 @@
 # Skills For Real Engineers
 
-[![skills.sh](https://skills.sh/b/ecology9191/skills)](https://skills.sh/ecology9191/skills)
-[![npm](https://img.shields.io/npm/v/@ecology91/skills)](https://www.npmjs.com/package/@ecology91/skills)
+[skills.sh](https://skills.sh/ecology9191/skills)
+[npm](https://www.npmjs.com/package/@ecology91/skills)
 
 Agent skills for doing real engineering with opencode - not vibe coding.
 
@@ -17,26 +17,31 @@ These skills are designed to be small, easy to adapt, and composable. They work
 npx skills@latest add ecology9191/skills -g
 ```
 
-2. Or install from a git checkout or the published npm package:
+1. Or install from a git checkout or the published npm package:
 
 ```bash
 npx --package @ecology91/skills ecology91-skills
 ```
 
-From a git checkout this symlinks into `~/.agents/skills` so edits in the repo are live. From the published package it copies files instead.
+This opens an interactive menu grouped by bucket (`engineering`, `productivity`, `misc`). Toggle a whole category or pick individual skills in one screen. Use `--all` to skip the menu, or `--bucket` / `--skill` for non-interactive partial installs.
 
-3. Force a copy install from a checkout with `--copy`.
+From a git checkout this symlinks into `~/.agents/skills` so edits in the repo are live. From the published package it copies files instead.
 
-OpenCode auto-loads `~/.agents/skills` alongside its own config tree, so one global install works across harnesses.
+```bash
+npx --package @ecology91/skills ecology91-skills --all
+npx --package @ecology91/skills ecology91-skills --bucket engineering --skill tdd
+```
 
-4. Quit and restart your agent so it reloads the skill list.
+1. Force a copy install from a checkout with `--copy`.
 
-5. Run `/setup-agent-skills` in your coding agent. It will:
-   - Ask you which issue tracker you want to use (GitHub, GitLab, Beads, `.scratch`, or another workflow)
-   - Ask you what labels you apply to issues when you triage them (`/triage` uses labels)
-   - Ask you where you want to save any docs we create
+OpenCode auto-loads `~/.agents/skills` alongside its own config tree, so one global install works across harnesses.
 
-6. Bam - you're ready to go.
+1. Quit and restart your agent so it reloads the skill list.
+2. Run `/setup-agent-skills` in your coding agent. It will:
+  - Ask you which issue tracker you want to use (GitHub, GitLab, Beads, `.scratch`, or another workflow)
+  - Ask you what labels you apply to issues when you triage them (`/triage` uses labels)
+  - Ask you where you want to save any docs we create
+3. Bam - you're ready to go.
 
 This repo also includes `opencode.json`, so opencode loads the promoted skill buckets automatically when you open this repo directly.
 
@@ -56,10 +61,10 @@ This is just the same in the AI age. There is a communication gap between you an
 
 **The Fix** is to use:
 
-- [`/grill-me`](./skills/productivity/grill-me/SKILL.md) - for non-code uses
-- [`/grill-with-docs`](./skills/engineering/grill-with-docs/SKILL.md) - same as [`/grill-me`](./skills/productivity/grill-me/SKILL.md), but adds more goodies (see below)
+- `[/grill-me](./skills/productivity/grill-me/SKILL.md)` - for non-code uses
+- `[/grill-with-docs](./skills/engineering/grill-with-docs/SKILL.md)` - same as `[/grill-me](./skills/productivity/grill-me/SKILL.md)`, but adds more goodies (see below)
 
-These are my most popular skills. They help you align with the agent before you get started, and think deeply about the change you're making. Use them _every_ time you want to make a change.
+These are my most popular skills. They help you align with the agent before you get started, and think deeply about the change you're making. Use them *every* time you want to make a change.
 
 ### #2: The Agent Is Way Too Verbose
 
@@ -73,10 +78,7 @@ I felt the same tension with my agents. Agents are usually dropped into a projec
 
 **The Fix** for this is a shared language. It's a document that helps agents decode the jargon used in the project.
 
-<details>
-<summary>
 Example
-</summary>
 
 Here's a before-and-after example. Which one is easier to read?
 
@@ -85,9 +87,9 @@ Here's a before-and-after example. Which one is easier to read?
 
 This concision pays off session after session.
 
-</details>
 
-This is built into [`/grill-with-docs`](./skills/engineering/grill-with-docs/SKILL.md). It's a grilling session, but that helps you build a shared language with the AI, and document hard-to-explain decisions in ADR's.
+
+This is built into `[/grill-with-docs](./skills/engineering/grill-with-docs/SKILL.md)`. It's a grilling session, but that helps you build a shared language with the AI, and document hard-to-explain decisions in ADR's.
 
 It's hard to explain how powerful this is. It might be the single coolest technique in this repo. Try it, and see.
 
@@ -104,7 +106,7 @@ It's hard to explain how powerful this is. It might be the single coolest techni
 >
 > David Thomas & Andrew Hunt, [The Pragmatic Programmer](https://www.amazon.co.uk/Pragmatic-Programmer-Anniversary-Journey-Mastery/dp/B0833F1T3V)
 
-**The Problem**: Let's say that you and the agent are aligned on what to build. What happens when the agent _still_ produces crap?
+**The Problem**: Let's say that you and the agent are aligned on what to build. What happens when the agent *still* produces crap?
 
 It's time to look at your feedback loops. Without feedback on how the code it produces actually runs, the agent will be flying blind.
 
@@ -112,13 +114,13 @@ It's time to look at your feedback loops. Without feedback on how the code it pr
 
 For automated tests, a red-green-refactor loop is critical. This is where the agent writes a failing test first, then fixes the test. This helps give the agent a consistent level of feedback that results in far better code.
 
-I've built a **[`/tdd`](./skills/engineering/tdd/SKILL.md) skill** you can slot into any project. It encourages red-green-refactor and gives the agent plenty of guidance on what makes good and bad tests.
+I've built a `**[/tdd](./skills/engineering/tdd/SKILL.md)` skill** you can slot into any project. It encourages red-green-refactor and gives the agent plenty of guidance on what makes good and bad tests.
 
-For debugging, I've also built a **[`/diagnose`](./skills/engineering/diagnose/SKILL.md)** skill that wraps best debugging practices into a simple loop.
+For debugging, I've also built a `**[/diagnose](./skills/engineering/diagnose/SKILL.md)`** skill that wraps best debugging practices into a simple loop.
 
 ### #4: We Built A Ball Of Mud
 
-> "Invest in the design of the system _every day_."
+> "Invest in the design of the system *every day*."
 >
 > Kent Beck, [Extreme Programming Explained](https://www.amazon.co.uk/Extreme-Programming-Explained-Embrace-Change/dp/0321278658)
 
@@ -132,10 +134,10 @@ For debugging, I've also built a **[`/diagnose`](./skills/engineering/diagnose/S
 
 This is built in to every layer of these skills:
 
-- [`/to-prd`](./skills/engineering/to-prd/SKILL.md) quizzes you about which modules you're touching before creating a PRD
-- [`/zoom-out`](./skills/engineering/zoom-out/SKILL.md) tells the agent to explain code in the context of the whole system
+- `[/to-prd](./skills/engineering/to-prd/SKILL.md)` quizzes you about which modules you're touching before creating a PRD
+- `[/zoom-out](./skills/engineering/zoom-out/SKILL.md)` tells the agent to explain code in the context of the whole system
 
-And crucially, [`/improve-codebase-architecture`](./skills/engineering/improve-codebase-architecture/SKILL.md) helps you rescue a codebase that has become a ball of mud. I recommend running it on your codebase once every few days.
+And crucially, `[/improve-codebase-architecture](./skills/engineering/improve-codebase-architecture/SKILL.md)` helps you rescue a codebase that has become a ball of mud. I recommend running it on your codebase once every few days.
 
 ### Summary
 
@@ -177,3 +179,4 @@ Tools I keep around but rarely use.
 - **[migrate-to-shoehorn](./skills/misc/migrate-to-shoehorn/SKILL.md)** — Migrate test files from `as` type assertions to @total-typescript/shoehorn.
 - **[scaffold-exercises](./skills/misc/scaffold-exercises/SKILL.md)** — Create exercise directory structures with sections, problems, solutions, and explainers.
 - **[setup-pre-commit](./skills/misc/setup-pre-commit/SKILL.md)** — Set up Husky pre-commit hooks with lint-staged, Prettier, type checking, and tests.
+

package/bin/collect-skills.mjs

@@ -0,0 +1,97 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export const buckets = [
+  { id: "engineering", label: "daily code work" },
+  { id: "productivity", label: "daily non-code workflow tools" },
+  { id: "misc", label: "kept around but rarely used" },
+];
+
+const DESCRIPTION_MAX = 80;
+
+function readDescription(skillMdPath) {
+  const content = fs.readFileSync(skillMdPath, "utf8");
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return "";
+
+  for (const line of match[1].split("\n")) {
+    const desc = line.match(/^description:\s*(.+)$/);
+    if (!desc) continue;
+
+    let value = desc[1].trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+
+    const firstLine = value.split("\n")[0].trim();
+    if (firstLine.length <= DESCRIPTION_MAX) return firstLine;
+    return `${firstLine.slice(0, DESCRIPTION_MAX - 1)}…`;
+  }
+
+  return "";
+}
+
+/**
+ * @param {string} root
+ * @param {string} destRoot
+ */
+export function collectSkillsByBucket(root, destRoot) {
+  /** @type {{ id: string, label: string, skills: { name: string, src: string, dest: string, description: string, bucket: string }[] }[]} */
+  const catalog = [];
+
+  for (const bucket of buckets) {
+    const bucketDir = path.join(root, "skills", bucket.id);
+    if (!fs.existsSync(bucketDir)) continue;
+
+    /** @type {{ name: string, src: string, dest: string, description: string, bucket: string }[]} */
+    const skills = [];
+
+    for (const entry of fs.readdirSync(bucketDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+
+      const src = path.join(bucketDir, entry.name);
+      const skillMd = path.join(src, "SKILL.md");
+      if (!fs.existsSync(skillMd)) continue;
+
+      skills.push({
+        name: entry.name,
+        src,
+        dest: path.join(destRoot, entry.name),
+        description: readDescription(skillMd),
+        bucket: bucket.id,
+      });
+    }
+
+    skills.sort((a, b) => a.name.localeCompare(b.name));
+    if (skills.length > 0) {
+      catalog.push({ id: bucket.id, label: bucket.label, skills });
+    }
+  }
+
+  return catalog;
+}
+
+/** @param {{ id: string, label: string, skills: { name: string }[] }[]} catalog */
+export function flattenCatalog(catalog) {
+  return catalog.flatMap((bucket) => bucket.skills);
+}
+
+/** @param {{ name: string, bucket: string }[]} skills */
+export function countByBucket(skills) {
+  /** @type {Record<string, number>} */
+  const counts = {};
+  for (const skill of skills) {
+    counts[skill.bucket] = (counts[skill.bucket] ?? 0) + 1;
+  }
+  return counts;
+}
+
+/** @param {Record<string, number>} counts */
+export function formatBucketCounts(counts) {
+  return Object.entries(counts)
+    .map(([bucket, count]) => `${bucket}: ${count}`)
+    .join(", ");
+}

package/bin/install.mjs

@@ -1,93 +1,179 @@
 #!/usr/bin/env node
-import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import {
+  collectSkillsByBucket,
+  countByBucket,
+  flattenCatalog,
+  formatBucketCounts,
+} from "./collect-skills.mjs";
+import { promptSkillSelection } from "./prompt-skills.mjs";
+import { parseArgs, resolveSelection, skillsFromNames } from "./resolve-selection.mjs";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const buckets = ["engineering", "productivity", "misc"];
-const args = new Set(process.argv.slice(2));
 const destRoot = path.join(os.homedir(), ".agents", "skills");
-const isGitCheckout = fs.existsSync(path.join(root, ".git"));
-const link =
-  args.has("--link") || (isGitCheckout && !args.has("--copy"));
 
-if (args.has("--help") || args.has("-h")) {
-  console.log(`Usage: npx @ecology91/skills [--dry-run] [--copy] [--link]
+function printHelp() {
+  console.log(`Usage: npx @ecology91/skills [options]
 
 Install promoted skills into ~/.agents/skills.
 
 From a git checkout, symlinks by default so local edits are picked up live.
 From the published npm package, copies by default.
 
-  --link  Force symlinks (runs scripts/link-skills.sh)
-  --copy  Force copies instead of symlinks`);
-  process.exit(0);
+Interactive mode (TTY): pick buckets and individual skills in one menu.
+Non-interactive (CI, pipes): installs all promoted skills.
+
+  --dry-run         Print actions without installing
+  --copy            Force copies instead of symlinks
+  --link            Force symlinks
+  --all             Skip menu; install all promoted skills
+  --bucket <ids>    Comma-separated buckets (engineering, productivity, misc)
+  --skill <names>   Comma-separated skill names`);
 }
 
-const dryRun = args.has("--dry-run");
+let parsed;
+try {
+  parsed = parseArgs(process.argv.slice(2));
+} catch (error) {
+  console.error(`error: ${error.message}`);
+  process.exit(1);
+}
 
-function collectSkills() {
-  const skills = [];
+const { flags, values } = parsed;
 
-  for (const bucket of buckets) {
-    const bucketDir = path.join(root, "skills", bucket);
-    if (!fs.existsSync(bucketDir)) continue;
+if (flags.has("--help") || flags.has("-h")) {
+  printHelp();
+  process.exit(0);
+}
 
-    for (const entry of fs.readdirSync(bucketDir, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
+const dryRun = flags.has("--dry-run");
+const isGitCheckout = fs.existsSync(path.join(root, ".git"));
+const link = flags.has("--link") || (isGitCheckout && !flags.has("--copy"));
+const isInteractive =
+  Boolean(process.stdin.isTTY && process.stdout.isTTY) && !flags.has("--all");
 
-      const src = path.join(bucketDir, entry.name);
-      if (!fs.existsSync(path.join(src, "SKILL.md"))) continue;
+const catalog = collectSkillsByBucket(root, destRoot);
+const allSkills = flattenCatalog(catalog);
 
-      skills.push([src, path.join(destRoot, entry.name)]);
-    }
+function assertSafeDest() {
+  if (!fs.lstatSync(destRoot, { throwIfNoEntry: false })?.isSymbolicLink()) {
+    return;
+  }
+
+  const resolved = fs.realpathSync(destRoot);
+  const repoReal = fs.realpathSync(root);
+  if (resolved === repoReal || resolved.startsWith(`${repoReal}${path.sep}`)) {
+    console.error(
+      `error: ${destRoot} is a symlink into this repo (${resolved}).`,
+    );
+    console.error(
+      `Remove it (rm "${destRoot}") and re-run; the installer will recreate it as a real dir.`,
+    );
+    process.exit(1);
   }
+}
 
-  return skills;
+/** @param {{ bucket: string, name: string }[]} skills */
+function groupSkillsByBucket(skills) {
+  /** @type {Map<string, typeof skills>} */
+  const grouped = new Map();
+  for (const skill of skills) {
+    const list = grouped.get(skill.bucket) ?? [];
+    list.push(skill);
+    grouped.set(skill.bucket, list);
+  }
+  return grouped;
 }
 
+/** @param {{ bucket: string, name: string, src: string, dest: string }[]} skills */
 function installCopy(skills) {
-  if (!dryRun) fs.mkdirSync(destRoot, { recursive: true });
+  if (!dryRun) {
+    assertSafeDest();
+    fs.mkdirSync(destRoot, { recursive: true });
+  }
 
-  for (const [src, dest] of skills) {
-    if (dryRun) {
-      console.log(`would install ${path.basename(src)} -> ${dest}`);
-      continue;
+  const grouped = groupSkillsByBucket(skills);
+  for (const [bucket, bucketSkills] of grouped) {
+    console.log(`${bucket} (${bucketSkills.length})`);
+    for (const skill of bucketSkills) {
+      if (dryRun) {
+        console.log(`  would install ${skill.name} -> ${skill.dest}`);
+        continue;
+      }
+
+      fs.rmSync(skill.dest, { recursive: true, force: true });
+      fs.cpSync(skill.src, skill.dest, { recursive: true, force: true });
+      console.log(`  installed ${skill.name} -> ${skill.dest}`);
     }
-
-    fs.rmSync(dest, { recursive: true, force: true });
-    fs.mkdirSync(path.dirname(dest), { recursive: true });
-    fs.cpSync(src, dest, { recursive: true, force: true });
-    console.log(`installed ${path.basename(src)} -> ${dest}`);
   }
 }
 
+/** @param {{ bucket: string, name: string, src: string, dest: string }[]} skills */
 function installLink(skills) {
   if (dryRun) {
-    for (const [src, dest] of skills) {
-      console.log(`would link ${path.basename(src)} -> ${dest} (${src})`);
+    const grouped = groupSkillsByBucket(skills);
+    for (const [bucket, bucketSkills] of grouped) {
+      console.log(`${bucket} (${bucketSkills.length})`);
+      for (const skill of bucketSkills) {
+        console.log(`  would link ${skill.name} -> ${skill.dest} (${skill.src})`);
+      }
     }
     return;
   }
 
-  execFileSync("bash", [path.join(root, "scripts/link-skills.sh")], {
-    stdio: "inherit",
-  });
+  assertSafeDest();
+  fs.mkdirSync(destRoot, { recursive: true });
+
+  const grouped = groupSkillsByBucket(skills);
+  for (const [bucket, bucketSkills] of grouped) {
+    console.log(`${bucket} (${bucketSkills.length})`);
+    for (const skill of bucketSkills) {
+      const stat = fs.lstatSync(skill.dest, { throwIfNoEntry: false });
+      if (stat) {
+        fs.rmSync(skill.dest, { recursive: true, force: true });
+      }
+
+      fs.symlinkSync(skill.src, skill.dest);
+      console.log(`  linked ${skill.name} -> ${skill.src}`);
+    }
+  }
 }
 
-const skills = collectSkills();
+let selectedSkills;
+try {
+  selectedSkills = resolveSelection(catalog, parsed, isInteractive);
+} catch (error) {
+  console.error(`error: ${error.message}`);
+  process.exit(1);
+}
+
+if (selectedSkills === null) {
+  const selectedNames = await promptSkillSelection(catalog);
+  if (selectedNames === null) {
+    process.exit(0);
+  }
+  selectedSkills = skillsFromNames(selectedNames, allSkills);
+}
+
+if (selectedSkills.length === 0) {
+  console.log("No skills selected.");
+  process.exit(0);
+}
 
 if (link) {
-  installLink(skills);
+  installLink(selectedSkills);
+  const verb = dryRun ? "Checked" : "Linked";
   console.log(
-    `${dryRun ? "Checked" : "Linked"} ${skills.length} skills to ~/.agents/skills.`,
+    `${verb} ${selectedSkills.length} skills to ~/.agents/skills (${formatBucketCounts(countByBucket(selectedSkills))}).`,
   );
 } else {
-  installCopy(skills);
+  installCopy(selectedSkills);
+  const verb = dryRun ? "Checked" : "Installed";
   console.log(
-    `${dryRun ? "Checked" : "Installed"} ${skills.length} skills to ~/.agents/skills.`,
+    `${verb} ${selectedSkills.length} skills to ~/.agents/skills (${formatBucketCounts(countByBucket(selectedSkills))}).`,
   );
 }
 

package/bin/prompt-skills.mjs

@@ -0,0 +1,39 @@
+import { cancel, groupMultiselect, intro, isCancel, outro } from "@clack/prompts";
+
+/**
+ * @param {{ id: string, label: string, skills: { name: string, description: string }[] }[]} catalog
+ * @returns {Promise<string[] | null>}
+ */
+export async function promptSkillSelection(catalog) {
+  /** @type {Record<string, { value: string, label: string }[]>} */
+  const options = {};
+  const allNames = [];
+
+  for (const bucket of catalog) {
+    options[`${bucket.id} — ${bucket.label}`] = bucket.skills.map((skill) => ({
+      value: skill.name,
+      label: skill.description
+        ? `${skill.name} — ${skill.description}`
+        : skill.name,
+    }));
+    allNames.push(...bucket.skills.map((skill) => skill.name));
+  }
+
+  intro("ecology91-skills");
+
+  const selected = await groupMultiselect({
+    message: "Select skills to install",
+    selectableGroups: true,
+    options,
+    initialValues: allNames,
+    required: true,
+  });
+
+  if (isCancel(selected)) {
+    cancel("Installation cancelled.");
+    return null;
+  }
+
+  outro(`Selected ${selected.length} skill${selected.length === 1 ? "" : "s"}.`);
+  return selected;
+}

package/bin/resolve-selection.mjs

@@ -0,0 +1,107 @@
+import { buckets } from "./collect-skills.mjs";
+
+const bucketIds = new Set(buckets.map((bucket) => bucket.id));
+
+/**
+ * @param {string[]} argv
+ */
+export function parseArgs(argv) {
+  const flags = new Set();
+  /** @type {Record<string, string>} */
+  const values = {};
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+
+    if (arg === "--bucket" || arg === "--skill") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("-")) {
+        throw new Error(`Missing value for ${arg}`);
+      }
+      values[arg.slice(2)] = value;
+      i++;
+      continue;
+    }
+
+    if (arg.startsWith("-")) {
+      flags.add(arg);
+    }
+  }
+
+  return { flags, values };
+}
+
+/**
+ * @param {string | undefined} raw
+ */
+function splitList(raw) {
+  if (!raw) return [];
+  return raw
+    .split(",")
+    .map((part) => part.trim())
+    .filter(Boolean);
+}
+
+/**
+ * @param {{ id: string, skills: { name: string, bucket: string }[] }[]} catalog
+ * @param {{ flags: Set<string>, values: Record<string, string> }} parsed
+ * @param {boolean} isInteractive
+ */
+export function resolveSelection(catalog, parsed, isInteractive) {
+  const allSkills = catalog.flatMap((bucket) => bucket.skills);
+  const allNames = new Set(allSkills.map((skill) => skill.name));
+  const { flags, values } = parsed;
+
+  const hasExplicitSelection =
+    flags.has("--all") || values.bucket || values.skill || !isInteractive;
+
+  if (hasExplicitSelection) {
+    return filterByFlags(allSkills, values, allNames);
+  }
+
+  return null;
+}
+
+/**
+ * @param {{ name: string, bucket: string }[]} allSkills
+ * @param {Record<string, string>} values
+ * @param {Set<string>} allNames
+ */
+function filterByFlags(allSkills, values, allNames) {
+  const bucketFilter = new Set(splitList(values.bucket));
+  const skillFilter = new Set(splitList(values.skill));
+
+  for (const bucket of bucketFilter) {
+    if (!bucketIds.has(bucket)) {
+      throw new Error(
+        `Unknown bucket "${bucket}". Expected one of: ${[...bucketIds].join(", ")}`,
+      );
+    }
+  }
+
+  for (const skill of skillFilter) {
+    if (!allNames.has(skill)) {
+      throw new Error(`Unknown skill "${skill}".`);
+    }
+  }
+
+  return allSkills.filter((skill) => {
+    if (bucketFilter.size > 0 && !bucketFilter.has(skill.bucket)) {
+      return false;
+    }
+    if (skillFilter.size > 0 && !skillFilter.has(skill.name)) {
+      return false;
+    }
+    return true;
+  });
+}
+
+/**
+ * @param {string[] | null} selectedNames
+ * @param {{ name: string }[]} allSkills
+ */
+export function skillsFromNames(selectedNames, allSkills) {
+  if (!selectedNames || selectedNames.length === 0) return [];
+  const byName = new Map(allSkills.map((skill) => [skill.name, skill]));
+  return selectedNames.map((name) => byName.get(name)).filter(Boolean);
+}

package/bin/resolve-selection.test.mjs

@@ -0,0 +1,60 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { parseArgs, resolveSelection, skillsFromNames } from "./resolve-selection.mjs";
+
+const catalog = [
+  {
+    id: "engineering",
+    label: "daily code work",
+    skills: [
+      { name: "tdd", bucket: "engineering" },
+      { name: "diagnose", bucket: "engineering" },
+    ],
+  },
+  {
+    id: "productivity",
+    label: "daily non-code workflow tools",
+    skills: [{ name: "caveman", bucket: "productivity" }],
+  },
+];
+
+test("parseArgs splits bucket and skill values", () => {
+  const parsed = parseArgs(["--bucket", "engineering", "--skill", "tdd,diagnose"]);
+  assert.equal(parsed.values.bucket, "engineering");
+  assert.equal(parsed.values.skill, "tdd,diagnose");
+});
+
+test("resolveSelection returns all skills when non-interactive", () => {
+  const parsed = parseArgs([]);
+  const selected = resolveSelection(catalog, parsed, false);
+  assert.equal(selected?.length, 3);
+});
+
+test("resolveSelection filters by bucket", () => {
+  const parsed = parseArgs(["--bucket", "engineering"]);
+  const selected = resolveSelection(catalog, parsed, true);
+  assert.deepEqual(
+    selected?.map((skill) => skill.name).sort(),
+    ["diagnose", "tdd"],
+  );
+});
+
+test("resolveSelection intersects bucket and skill filters", () => {
+  const parsed = parseArgs(["--bucket", "engineering", "--skill", "tdd"]);
+  const selected = resolveSelection(catalog, parsed, true);
+  assert.deepEqual(selected?.map((skill) => skill.name), ["tdd"]);
+});
+
+test("resolveSelection rejects unknown bucket", () => {
+  const parsed = parseArgs(["--bucket", "personal"]);
+  assert.throws(
+    () => resolveSelection(catalog, parsed, true),
+    /Unknown bucket "personal"/,
+  );
+});
+
+test("skillsFromNames preserves prompt order", () => {
+  const allSkills = catalog.flatMap((bucket) => bucket.skills);
+  const selected = skillsFromNames(["caveman", "tdd"], allSkills);
+  assert.deepEqual(selected.map((skill) => skill.name), ["caveman", "tdd"]);
+});

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@ecology91/skills",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "opencode agent skills for real engineering workflows.",
   "license": "MIT",
   "type": "module",
+  "dependencies": {
+    "@clack/prompts": "^0.11.0"
+  },
   "bin": {
     "ecology91-skills": "bin/install.mjs"
   },
@@ -37,8 +40,9 @@
     "access": "public"
   },
   "scripts": {
-    "typecheck": "node --check bin/install.mjs && node --check scripts/verify-package-files.mjs",
-    "test": "node bin/install.mjs --dry-run --copy",
+    "typecheck": "node --check bin/install.mjs && node --check bin/collect-skills.mjs && node --check bin/prompt-skills.mjs && node --check bin/resolve-selection.mjs && node --check bin/resolve-selection.test.mjs && node --check scripts/verify-package-files.mjs",
+    "test": "node --test bin/resolve-selection.test.mjs && node bin/install.mjs --dry-run --copy --all",
+    "test:unit": "node --test bin/resolve-selection.test.mjs",
     "link-skills": "./scripts/link-skills.sh",
     "build": "node scripts/verify-package-files.mjs",
     "validate:fast": "npm run typecheck && npm run test",

package/scripts/link-skills.sh

@@ -1,40 +1,5 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-# Links promoted skills in the repository to ~/.agents/skills so they are
-# available globally across agent harnesses (opencode, Cursor, etc.).
-
 REPO="$(cd "$(dirname "$0")/.." && pwd)"
-DEST="$HOME/.agents/skills"
-
-# If the destination is a symlink that resolves into this repo, we'd end up
-# writing the per-skill symlinks back into the repo's own skills/ tree. Detect
-# and bail out instead of polluting the working copy.
-if [ -L "$DEST" ]; then
-  resolved="$(readlink -f "$DEST")"
-  case "$resolved" in
-    "$REPO"|"$REPO"/*)
-      echo "error: $DEST is a symlink into this repo ($resolved)." >&2
-      echo "Remove it (rm \"$DEST\") and re-run; the script will recreate it as a real dir." >&2
-      exit 1
-      ;;
-  esac
-fi
-
-mkdir -p "$DEST"
-
-for bucket in engineering productivity misc; do
-  find "$REPO/skills/$bucket" -name SKILL.md -not -path '*/node_modules/*' -print0
-done |
-while IFS= read -r -d '' skill_md; do
-  src="$(dirname "$skill_md")"
-  name="$(basename "$src")"
-  target="$DEST/$name"
-
-  if [ -e "$target" ] && [ ! -L "$target" ]; then
-    rm -rf "$target"
-  fi
-
-  ln -sfn "$src" "$target"
-  echo "linked $name -> $src"
-done
+exec node "$REPO/bin/install.mjs" --link "$@"