spirewise 1.0.3 → 1.1.0

package/README.md

@@ -10,66 +10,77 @@ project** or **globally** for every project.
 
 ## Install
 
-No clone needed:
+No clone needed — just run:
 
 ```bash
-npx spirewise install
+npx spirewise
 ```
 
-You'll be asked where to install:
+You get a **full-screen interactive picker** with three steps:
 
 ```
-==> Where should the skills be installed?
-  1) Workspace   (this folder only — the current project directory)
-  2) Global      (your home folders, all projects)
-  3) Both
+══════════════════ Step 1/3 · Select skills ══════════════════
+   ❯ ◉  f6s-copywriting        Generate F6S startup/company profile copy…
+     ◉  linkedin-copywriting   Generate LinkedIn Company Page copy…
+
+  ↑/↓ move · space toggle · a all/none · enter confirm · esc cancel
 ```
 
-Skip the prompt with a scope flag:
+Step 1 picks **skills**, step 2 picks **agents** (checkbox lists — move with
+↑/↓, toggle with **space**, **a** for all/none), step 3 picks **scope**
+(Workspace / Global / Both). Press **enter** to confirm each step.
+
+### Or drive it with flags (skips the matching step)
+
+```bash
+-s,  --skills <a,b>    skills to install     (default: all / pick)
+-a,  --agents <a,b>    agents to target      (default: all / pick)   alias: --agent
+-sc, --scope  <s>      workspace | global | both
+     --workspace | --global | --both          scope shortcuts
+```
 
 ```bash
-npx spirewise install --workspace   # this folder only (current project)
-npx spirewise install --global      # all projects (home folders)
-npx spirewise install --both        # both
+npx spirewise -sc both                                   # pick skills+agents, scope both
+npx spirewise -s f6s-copywriting -a claude,cursor -sc workspace
+npx spirewise --global                                   # pick skills+agents, scope global
 ```
 
 Or install the CLI globally:
 
 ```bash
 npm install -g spirewise
-spirewise install --both
+spirewise -sc both
 ```
 
 ## What gets installed where
 
-| Agent | Project folder | Global folder | Format |
-|-------|----------------|---------------|--------|
+| Agent | Workspace folder | Global folder | Format |
+|-------|------------------|---------------|--------|
 | Claude Code | `.claude/skills/` | `~/.claude/skills/` | SKILL.md |
 | GitHub Copilot | `.github/skills/` | `~/.copilot/skills/` | SKILL.md |
 | Cursor | `.cursor/rules/` | `~/.cursor/rules/` | `.mdc` rule |
 | Windsurf | `.windsurf/rules/` | `~/.codeium/windsurf/global_rules/` | `.md` rule |
 | Codex CLI | `.codex/skills/` | `~/.codex/skills/` | SKILL.md |
 | Gemini CLI | `.gemini/skills/` | `~/.gemini/skills/` | SKILL.md |
+| OpenCode | `.opencode/skills/` | `~/.config/opencode/skills/` | SKILL.md |
+| Cline | `.clinerules/` | `~/.clinerules/` | `.md` rule |
+| Roo Code | `.roo/rules/` | `~/.roo/rules/` | `.md` rule |
+| Kilo Code | `.kilocode/rules/` | `~/.kilocode/rules/` | `.md` rule |
+| Continue | `.continue/rules/` | `~/.continue/rules/` | `.md` rule |
+| Amp | `.amp/rules/` | `~/.config/amp/rules/` | `.md` rule |
 
-Rule-based agents (Cursor, Windsurf) get a single rule file generated from the
-skill; the rest get the full `SKILL.md` folder.
+Rule-based agents get a single rule file generated from the skill; the rest get
+the full `SKILL.md` folder. (Newer tools' folders are best-effort conventions —
+edit the `AGENTS` registry at the top of `bin/cli.js` if any differ.)
 
-## Narrow it down
+## Inspect
 
 ```bash
-# only some agents
-npx spirewise install --both --agent claude,cursor
-
-# only some skills
-npx spirewise install f6s-copywriting --global
-
-# inspect
 npx spirewise list        # available skills
 npx spirewise agents      # supported agents + their folders
+npx spirewise --help      # all options
 ```
 
-Run `npx spirewise --help` for all options.
-
 ## Skills included
 
 | Skill | Output file | Purpose |

package/bin/cli.js

@@ -2,26 +2,25 @@
 'use strict';
 
 /**
- * spirewise — install copywriting Agent Skills into ALL your AI agents at once.
+ * spirewise — install copywriting Agent Skills into your AI agents.
  *
- * Installs into each agent's correct folder, in the format that agent expects,
- * and asks whether to install for THIS project (cwd) or GLOBALLY (home dirs).
+ * Run with no flags for a full-screen interactive picker:
+ *   npx spirewise               (or: npx spirewise install)
  *
- * Usage:
- *   npx spirewise install                 # interactive: pick scope, install all
- *   npx spirewise install --project       # this project only
- *   npx spirewise install --global        # global (home) only
- *   npx spirewise install --both          # project + global
- *   npx spirewise install --agent claude,cursor   # restrict agents
- *   npx spirewise install f6s-copywriting          # restrict skills
- *   npx spirewise list                    # list skills
- *   npx spirewise agents                  # list supported agents + folders
+ * Or drive everything from flags (skips the matching picker step):
+ *   -s,  --skills  <a,b>   skills to install   (default: all)
+ *   -a,  --agents  <a,b>   agents to target    (default: all)   alias: --agent
+ *   -sc, --scope   <s>     workspace | global | both
+ *        --workspace|--global|--both   scope shortcuts
+ *
+ * Other commands:
+ *   npx spirewise list      list skills
+ *   npx spirewise agents    list supported agents + folders
  */
 
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const readline = require('readline');
 
 const PKG_ROOT = path.resolve(__dirname, '..');
 const SKILLS_DIR = path.join(PKG_ROOT, 'skills');
@@ -34,8 +33,7 @@ const RAW = {
   red: '\x1b[1;31m', cyan: '\x1b[1;36m', magenta: '\x1b[1;35m',
 };
 const paint = (code, s) => (USE_COLOR ? `${code}${s}${RAW.reset}` : s);
-const c = USE_COLOR
-  ? RAW
+const c = USE_COLOR ? RAW
   : { reset: '', bold: '', dim: '', blue: '', green: '', yellow: '', red: '', cyan: '', magenta: '' };
 
 const info = (m) => console.log(`${c.blue}==>${c.reset} ${m}`);
@@ -58,60 +56,30 @@ const BANNER = [
 function banner() {
   console.log('');
   for (const line of BANNER) console.log(paint(RAW.cyan, line));
-  const tag = `   Agent Skills · F6S & LinkedIn copywriting${PKG_VERSION ? '  ·  v' + PKG_VERSION : ''}`;
-  console.log(paint(RAW.magenta, tag));
+  console.log(paint(RAW.magenta, `   Agent Skills · F6S & LinkedIn copywriting${PKG_VERSION ? '  ·  v' + PKG_VERSION : ''}`));
   console.log('');
 }
 
-let STEP_TOTAL = 4;
-function step(n, msg) {
-  console.log(`${paint(RAW.cyan, '  ▸')} ${paint(RAW.bold, `Step ${n}/${STEP_TOTAL}`)}  ${msg}`);
-}
-function substep(msg) {
-  console.log(`      ${paint(RAW.green, '✓')} ${msg}`);
-}
-
-function box(lines) {
-  const vis = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
-  const width = Math.max(...lines.map((l) => vis(l).length));
-  const top = '  ┌' + '─'.repeat(width + 2) + '┐';
-  const bot = '  └' + '─'.repeat(width + 2) + '┘';
-  console.log(paint(RAW.green, top));
-  for (const l of lines) console.log(paint(RAW.green, '  │ ') + l + ' '.repeat(width - vis(l).length) + paint(RAW.green, ' │'));
-  console.log(paint(RAW.green, bot));
-}
-
 /**
  * Agent registry. `format`:
  *   - 'skill': copy the skill folder verbatim (SKILL.md + any files)
  *   - 'rule' : write one rule file derived from SKILL.md (ext required)
- * `project` is resolved from cwd; `global` uses ~ for the home directory.
+ * `project` resolves from cwd; `global` uses ~ for the home directory.
+ * Newer tools' folders are best-effort conventions — edit freely.
  */
 const AGENTS = {
-  claude: {
-    label: 'Claude Code', format: 'skill',
-    project: '.claude/skills', global: '~/.claude/skills',
-  },
-  copilot: {
-    label: 'GitHub Copilot', format: 'skill',
-    project: '.github/skills', global: '~/.copilot/skills',
-  },
-  cursor: {
-    label: 'Cursor', format: 'rule', ext: '.mdc',
-    project: '.cursor/rules', global: '~/.cursor/rules',
-  },
-  windsurf: {
-    label: 'Windsurf', format: 'rule', ext: '.md',
-    project: '.windsurf/rules', global: '~/.codeium/windsurf/global_rules',
-  },
-  codex: {
-    label: 'Codex CLI', format: 'skill',
-    project: '.codex/skills', global: '~/.codex/skills',
-  },
-  gemini: {
-    label: 'Gemini CLI', format: 'skill',
-    project: '.gemini/skills', global: '~/.gemini/skills',
-  },
+  claude:   { label: 'Claude Code',    format: 'skill',           project: '.claude/skills',   global: '~/.claude/skills' },
+  copilot:  { label: 'GitHub Copilot', format: 'skill',           project: '.github/skills',   global: '~/.copilot/skills' },
+  cursor:   { label: 'Cursor',         format: 'rule', ext: '.mdc', project: '.cursor/rules',  global: '~/.cursor/rules' },
+  windsurf: { label: 'Windsurf',       format: 'rule', ext: '.md', project: '.windsurf/rules', global: '~/.codeium/windsurf/global_rules' },
+  codex:    { label: 'Codex CLI',      format: 'skill',           project: '.codex/skills',    global: '~/.codex/skills' },
+  gemini:   { label: 'Gemini CLI',     format: 'skill',           project: '.gemini/skills',   global: '~/.gemini/skills' },
+  opencode: { label: 'OpenCode',       format: 'skill',           project: '.opencode/skills', global: '~/.config/opencode/skills' },
+  cline:    { label: 'Cline',          format: 'rule', ext: '.md', project: '.clinerules',     global: '~/.clinerules' },
+  roo:      { label: 'Roo Code',       format: 'rule', ext: '.md', project: '.roo/rules',      global: '~/.roo/rules' },
+  kilocode: { label: 'Kilo Code',      format: 'rule', ext: '.md', project: '.kilocode/rules', global: '~/.kilocode/rules' },
+  continue: { label: 'Continue',       format: 'rule', ext: '.md', project: '.continue/rules', global: '~/.continue/rules' },
+  amp:      { label: 'Amp',            format: 'rule', ext: '.md', project: '.amp/rules',      global: '~/.config/amp/rules' },
 };
 
 function expandHome(p) {
@@ -119,26 +87,21 @@ function expandHome(p) {
   if (p.startsWith('~/')) return path.join(HOME, p.slice(2));
   return p;
 }
-
 function resolveTarget(agent, scope) {
   const rel = scope === 'project' ? agent.project : agent.global;
-  return scope === 'project'
-    ? path.resolve(process.cwd(), rel)
-    : path.resolve(expandHome(rel));
+  return scope === 'project' ? path.resolve(process.cwd(), rel) : path.resolve(expandHome(rel));
 }
 
 function availableSkills() {
   if (!fs.existsSync(SKILLS_DIR)) return [];
   return fs.readdirSync(SKILLS_DIR, { withFileTypes: true })
     .filter((d) => d.isDirectory() && fs.existsSync(path.join(SKILLS_DIR, d.name, 'SKILL.md')))
-    .map((d) => d.name)
-    .sort();
+    .map((d) => d.name).sort();
 }
 
 function readSkill(name) {
   const raw = fs.readFileSync(path.join(SKILLS_DIR, name, 'SKILL.md'), 'utf8');
-  let description = name;
-  let body = raw;
+  let description = name, body = raw;
   const m = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
   if (m) {
     body = m[2];
@@ -147,14 +110,19 @@ function readSkill(name) {
   }
   return { description, body: body.replace(/^\s+/, '') };
 }
+function skillHint(name) {
+  try {
+    const d = readSkill(name).description;
+    const first = d.split('. ')[0];
+    return first.length > 52 ? first.slice(0, 49) + '…' : first;
+  } catch (_) { return ''; }
+}
 
 function copyDir(src, dest) {
   fs.mkdirSync(dest, { recursive: true });
   for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-    const s = path.join(src, entry.name);
-    const d = path.join(dest, entry.name);
-    if (entry.isDirectory()) copyDir(s, d);
-    else fs.copyFileSync(s, d);
+    const s = path.join(src, entry.name), d = path.join(dest, entry.name);
+    if (entry.isDirectory()) copyDir(s, d); else fs.copyFileSync(s, d);
   }
 }
 
@@ -165,87 +133,147 @@ function installToAgent(agentKey, agent, scope, skills) {
     if (agent.format === 'skill') {
       const dest = path.join(targetDir, skill);
       copyDir(path.join(SKILLS_DIR, skill), dest);
-      console.log(`      ${paint(RAW.green, '✓')} ${paint(RAW.bold, agent.label)} ${c.dim}(${scope})${c.reset} ${skill} ${c.dim}→ ${dest}${c.reset}`);
+      console.log(`      ${paint(RAW.green, '✓')} ${paint(RAW.bold, agent.label)} ${c.dim}(${scope === 'project' ? 'workspace' : scope})${c.reset} ${skill} ${c.dim}→ ${dest}${c.reset}`);
     } else {
       const { description, body } = readSkill(skill);
       const front = `---\ndescription: ${description}\nalwaysApply: false\n---\n\n`;
       const file = path.join(targetDir, skill + (agent.ext || '.md'));
       fs.writeFileSync(file, front + body);
-      console.log(`      ${paint(RAW.green, '✓')} ${paint(RAW.bold, agent.label)} ${c.dim}(${scope})${c.reset} ${skill} ${c.dim}→ ${file}${c.reset}`);
+      console.log(`      ${paint(RAW.green, '✓')} ${paint(RAW.bold, agent.label)} ${c.dim}(${scope === 'project' ? 'workspace' : scope})${c.reset} ${skill} ${c.dim}→ ${file}${c.reset}`);
     }
   }
 }
 
-function usage() {
-  console.log(`spirewise — install copywriting Agent Skills into all your AI agents
-
-Usage:
-  spirewise install [skill ...] [options]
-  spirewise list
-  spirewise agents
-
-Scope (where to install):
-  --workspace           Install only into this folder / current project (alias: --project)
-  --global              Install only into global/home folders
-  --both                Install into both workspace and global
-  (no scope flag -> you are asked interactively)
-
-Selection:
-  [skill ...]           Limit to named skills (default: all)
-  --agent <a,b>         Limit to named agents (default: all)
-
-Other:
-  -h, --help            Show this help
+function box(lines) {
+  const vis = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+  const width = Math.max(...lines.map((l) => vis(l).length));
+  console.log(paint(RAW.green, '  ┌' + '─'.repeat(width + 2) + '┐'));
+  for (const l of lines) console.log(paint(RAW.green, '  │ ') + l + ' '.repeat(width - vis(l).length) + paint(RAW.green, ' │'));
+  console.log(paint(RAW.green, '  └' + '─'.repeat(width + 2) + '┘'));
+}
 
-Supported agents:
-${Object.entries(AGENTS).map(([k, a]) => `  - ${k} (${a.label})`).join('\n')}
+// --- Interactive full-width selector ---------------------------------------
+function interactiveSelect({ title, subtitle, items, multi = true, preselected = [] }) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin, stdout = process.stdout;
+    if (!stdin.isTTY) { resolve(null); return; }
+
+    let index = 0;
+    const selected = new Set();
+    if (multi) items.forEach((it, i) => { if (preselected.includes(it.value)) selected.add(i); });
+    else { const pi = items.findIndex((it) => preselected.includes(it.value)); if (pi >= 0) index = pi; }
+
+    const cols = () => stdout.columns || 80;
+    let lastLines = 0;
+
+    const bar = (text) => {
+      const w = cols(), label = ` ${text} `;
+      const side = Math.max(0, w - label.length), left = Math.floor(side / 2);
+      return paint(RAW.cyan, '═'.repeat(left) + label + '═'.repeat(side - left));
+    };
+
+    function render() {
+      const lines = ['', bar(title)];
+      if (subtitle) lines.push(paint(RAW.dim, '  ' + subtitle));
+      lines.push('');
+      items.forEach((it, i) => {
+        const cur = i === index ? paint(RAW.cyan, '❯') : ' ';
+        const mark = multi ? (selected.has(i) ? paint(RAW.green, '◉') : paint(RAW.dim, '◯'))
+                           : (i === index ? paint(RAW.green, '◉') : paint(RAW.dim, '◯'));
+        const label = i === index ? paint(RAW.bold, it.label) : it.label;
+        const hint = it.hint ? paint(RAW.dim, '  ' + it.hint) : '';
+        lines.push(`   ${cur} ${mark}  ${label}${hint}`);
+      });
+      lines.push('');
+      lines.push(paint(RAW.dim, '  ' + (multi
+        ? '↑/↓ move · space toggle · a all/none · enter confirm · esc cancel'
+        : '↑/↓ move · enter confirm · esc cancel')));
+      if (lastLines > 0) stdout.write(`\x1b[${lastLines}A`);
+      stdout.write('\x1b[0J' + lines.join('\n') + '\n');
+      lastLines = lines.length;
+    }
 
-Skills:
-${availableSkills().map((s) => '  - ' + s).join('\n') || '  (none found)'}
+    function cleanup() {
+      try { stdin.setRawMode(false); } catch (_) {}
+      stdin.pause();
+      stdin.removeListener('data', onData);
+    }
+    const finish = (r) => { cleanup(); resolve(r); };
+
+    function onData(s) {
+      if (s === '\x03' || s === '\x1b' || s === 'q') return finish(null);          // ctrl-c / esc / q
+      if (s === '\r' || s === '\n') {
+        return finish(multi ? items.filter((_, i) => selected.has(i)).map((it) => it.value) : items[index].value);
+      }
+      if (s === '\x1b[A' || s === 'k') { index = (index - 1 + items.length) % items.length; return render(); }
+      if (s === '\x1b[B' || s === 'j') { index = (index + 1) % items.length; return render(); }
+      if (multi && s === ' ') { selected.has(index) ? selected.delete(index) : selected.add(index); return render(); }
+      if (multi && (s === 'a' || s === 'A')) {
+        if (selected.size === items.length) selected.clear(); else items.forEach((_, i) => selected.add(i));
+        return render();
+      }
+      if (!multi && s === ' ') return finish(items[index].value);
+    }
 
-Examples:
-  npx spirewise install --both
-  npx spirewise install --project --agent claude,cursor
-  npx spirewise install f6s-copywriting --global
-`);
+    stdin.setRawMode(true); stdin.resume(); stdin.setEncoding('utf8');
+    stdin.on('data', onData);
+    render();
+  });
 }
 
+// --- args -------------------------------------------------------------------
+function splitList(v) { return String(v).split(',').map((s) => s.trim()).filter(Boolean); }
+
 function parseArgs(argv) {
-  const o = { scope: null, agents: null, skills: [] };
+  const o = { scope: null, agents: null, skills: null, positional: [] };
+  const norm = (s) => (s === 'project' || s === 'workspace' || s === 'local') ? 'project' : s;
   for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
-    if (a === '--project' || a === '--workspace' || a === '--local') o.scope = 'project';
-    else if (a === '--global') o.scope = 'global';
-    else if (a === '--both') o.scope = 'both';
-    else if (a === '--scope') o.scope = (argv[++i] || die('--scope needs a value'));
-    else if (a === '--agent' || a === '--agents') o.agents = (argv[++i] || die('--agent needs a value')).split(',').map((s) => s.trim()).filter(Boolean);
-    else if (a === '-h' || a === '--help') { usage(); process.exit(0); }
-    else if (a.startsWith('-')) die(`Unknown option: ${a}`);
-    else o.skills.push(a);
+    let a = argv[i], val = null;
+    if (a.startsWith('--') && a.includes('=')) { const idx = a.indexOf('='); val = a.slice(idx + 1); a = a.slice(0, idx); }
+    const next = () => (val !== null ? val : argv[++i]);
+    switch (a) {
+      case '-s': case '--skills': o.skills = splitList(next() || die('--skills needs a value')); break;
+      case '-a': case '--agents': case '--agent': o.agents = splitList(next() || die('--agents needs a value')); break;
+      case '-sc': case '--scope': o.scope = norm((next() || die('--scope needs a value')).toLowerCase()); break;
+      case '--workspace': case '--project': case '--local': o.scope = 'project'; break;
+      case '--global': o.scope = 'global'; break;
+      case '--both': o.scope = 'both'; break;
+      case '-h': case '--help': usage(); process.exit(0); break;
+      default:
+        if (a.startsWith('-')) die(`Unknown option: ${a}`);
+        o.positional.push(a);
+    }
   }
+  if (!o.skills && o.positional.length) o.skills = o.positional;
   return o;
 }
 
-function ask(question) {
-  return new Promise((resolve) => {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    rl.question(question, (ans) => { rl.close(); resolve(ans.trim()); });
-  });
-}
+function usage() {
+  console.log(`spirewise — install copywriting Agent Skills into your AI agents
 
-async function promptScope() {
-  if (!process.stdin.isTTY) {
-    warn('No terminal detected; defaulting scope to "project". Use --global or --both to change.');
-    return 'project';
-  }
-  info('Where should the skills be installed?');
-  console.log('  1) Workspace   (this folder only — the current project directory)');
-  console.log('  2) Global      (your home folders — applies to all projects)');
-  console.log('  3) Both');
-  const ans = (await ask('  Choose 1/2/3 [1]: ')).toLowerCase();
-  if (ans === '2' || ans === 'global') return 'global';
-  if (ans === '3' || ans === 'both') return 'both';
-  return 'project';
+Usage:
+  spirewise [install] [options]      run interactive picker for anything not set
+  spirewise list                     list available skills
+  spirewise agents                   list supported agents + folders
+
+Options:
+  -s,  --skills <a,b>    skills to install            (default: all / pick)
+  -a,  --agents <a,b>    agents to target             (default: all / pick)  alias: --agent
+  -sc, --scope  <s>      workspace | global | both    (default: pick)
+       --workspace | --global | --both   scope shortcuts
+  -h,  --help
+
+Agents:
+${Object.entries(AGENTS).map(([k, a]) => `  - ${k} (${a.label})`).join('\n')}
+
+Skills:
+${availableSkills().map((s) => '  - ' + s).join('\n') || '  (none found)'}
+
+Examples:
+  npx spirewise                                  # full interactive picker
+  npx spirewise -sc both                         # pick skills+agents, scope=both
+  npx spirewise -s f6s-copywriting -a claude,cursor -sc workspace
+`);
 }
 
 async function main() {
@@ -258,48 +286,75 @@ async function main() {
   if (available.length === 0) die('No skills found in package.');
 
   if (command === 'list') {
-    info('Available skills:');
-    available.forEach((s) => console.log('  - ' + s));
-    return;
+    info('Available skills:'); available.forEach((s) => console.log('  - ' + s)); return;
   }
   if (command === 'agents') {
     info('Supported agents and their folders:');
     for (const [k, a] of Object.entries(AGENTS)) {
-      console.log(`  ${k} (${a.label}) [${a.format}]`);
-      console.log(`      project: ${a.project}`);
-      console.log(`      global:  ${a.global}`);
+      console.log(`  ${paint(RAW.bold, k)} (${a.label}) [${a.format}]`);
+      console.log(`      workspace: ${a.project}`);
+      console.log(`      global:    ${a.global}`);
     }
     return;
   }
 
   const o = parseArgs(argv);
-
+  const tty = process.stdin.isTTY;
   banner();
 
-  step(1, 'Scanning available skills');
-  let skills = o.skills.length ? o.skills : available.slice();
-  for (const s of skills) if (!available.includes(s)) die(`Unknown skill '${s}'. Run "spirewise list".`);
-  substep(`${skills.length} skill(s): ${skills.join(', ')}`);
-
-  step(2, 'Selecting target agents');
-  let agentKeys = Object.keys(AGENTS);
-  if (o.agents) {
-    for (const k of o.agents) if (!AGENTS[k]) die(`Unknown agent '${k}'. Run "spirewise agents".`);
-    agentKeys = o.agents;
-  }
-  substep(`${agentKeys.length} agent(s): ${agentKeys.join(', ')}`);
-
-  step(3, 'Choosing install scope');
-  let scope = o.scope || await promptScope();
+  // 1) SKILLS
+  let skills = o.skills;
+  if (skills) {
+    for (const s of skills) if (!available.includes(s)) die(`Unknown skill '${s}'. Run "spirewise list".`);
+  } else if (tty) {
+    skills = await interactiveSelect({
+      title: 'Step 1/3 · Select skills',
+      subtitle: 'Copy templates to install into your agents',
+      items: available.map((s) => ({ value: s, label: s, hint: skillHint(s) })),
+      multi: true, preselected: available,
+    });
+    if (skills === null) die('Cancelled.');
+    if (!skills.length) die('No skills selected.');
+  } else { warn('No terminal; defaulting to all skills.'); skills = available.slice(); }
+
+  // 2) AGENTS
+  let agentKeys = o.agents;
+  if (agentKeys) {
+    for (const k of agentKeys) if (!AGENTS[k]) die(`Unknown agent '${k}'. Run "spirewise agents".`);
+  } else if (tty) {
+    agentKeys = await interactiveSelect({
+      title: 'Step 2/3 · Select agents',
+      subtitle: 'Each agent gets the skills in its own folder + format',
+      items: Object.entries(AGENTS).map(([k, a]) => ({ value: k, label: a.label, hint: `(${k}) · ${a.format}` })),
+      multi: true, preselected: Object.keys(AGENTS),
+    });
+    if (agentKeys === null) die('Cancelled.');
+    if (!agentKeys.length) die('No agents selected.');
+  } else { warn('No terminal; defaulting to all agents.'); agentKeys = Object.keys(AGENTS); }
+
+  // 3) SCOPE
+  let scope = o.scope;
+  if (!scope && tty) {
+    scope = await interactiveSelect({
+      title: 'Step 3/3 · Select scope',
+      subtitle: 'Where should the skills live?',
+      items: [
+        { value: 'project', label: 'Workspace', hint: 'this folder only — the current project' },
+        { value: 'global',  label: 'Global',    hint: 'your home folders — applies to all projects' },
+        { value: 'both',    label: 'Both',      hint: 'workspace + global' },
+      ],
+      multi: false, preselected: ['project'],
+    });
+    if (scope === null) die('Cancelled.');
+  } else if (!scope) { warn('No terminal; defaulting scope to "workspace".'); scope = 'project'; }
   if (!['project', 'global', 'both'].includes(scope)) die(`Invalid scope '${scope}'.`);
   const scopes = scope === 'both' ? ['project', 'global'] : [scope];
-  substep(`scope: ${paint(RAW.bold, scope === 'project' ? 'workspace' : scope)}`);
 
-  step(4, 'Installing');
+  // INSTALL
+  console.log('');
+  info(`Installing ${paint(RAW.bold, String(skills.length))} skill(s) into ${paint(RAW.bold, String(agentKeys.length))} agent(s) · scope ${paint(RAW.bold, scope === 'project' ? 'workspace' : scope)}`);
   let count = 0;
-  for (const sc of scopes) {
-    for (const k of agentKeys) { installToAgent(k, AGENTS[k], sc, skills); count += skills.length; }
-  }
+  for (const sc of scopes) for (const k of agentKeys) { installToAgent(k, AGENTS[k], sc, skills); count += skills.length; }
 
   console.log('');
   box([
@@ -310,4 +365,9 @@ async function main() {
   console.log('');
 }
 
-main().catch((e) => die(e && e.message ? e.message : String(e)));
+if (require.main === module) {
+  main().catch((e) => die(e && e.message ? e.message : String(e)));
+} else {
+  module.exports = { interactiveSelect, AGENTS, availableSkills, parseArgs };
+}
+

package/install.sh

@@ -30,6 +30,12 @@ AGENTS=(
   "windsurf|Windsurf|rule|.md|.windsurf/rules|HOME/.codeium/windsurf/global_rules"
   "codex|Codex CLI|skill||.codex/skills|HOME/.codex/skills"
   "gemini|Gemini CLI|skill||.gemini/skills|HOME/.gemini/skills"
+  "opencode|OpenCode|skill||.opencode/skills|HOME/.config/opencode/skills"
+  "cline|Cline|rule|.md|.clinerules|HOME/.clinerules"
+  "roo|Roo Code|rule|.md|.roo/rules|HOME/.roo/rules"
+  "kilocode|Kilo Code|rule|.md|.kilocode/rules|HOME/.kilocode/rules"
+  "continue|Continue|rule|.md|.continue/rules|HOME/.continue/rules"
+  "amp|Amp|rule|.md|.amp/rules|HOME/.config/amp/rules"
 )
 
 color() { printf '\033[%sm%s\033[0m' "$1" "$2"; }
@@ -56,21 +62,22 @@ usage() {
 spirewise — install copywriting Agent Skills into all your AI agents.
 
 Usage:
-  install.sh [scope] [--agent a,b] [skill ...]
+  install.sh [scope] [-a agents] [-s skills]
 
 Scope:
-  --workspace install only into this folder / current project (alias: --project)
-  --global    install only into global/home folders
-  --both      install into both
+  -sc, --scope <s>   workspace | global | both
+  --workspace        this folder / current project (alias: --project)
+  --global           global/home folders
+  --both             both
   (no scope -> you are asked interactively)
 
 Selection:
-  [skill ...]       limit to named skills (default: all)
-  --agent <a,b>     limit to named agents (default: all)
-  --list            list available skills
-  -h, --help        show this help
+  -s, --skills <a,b>   limit to named skills (default: all)
+  -a, --agents <a,b>   limit to named agents (default: all)  alias: --agent
+  --list               list available skills
+  -h, --help           show this help
 
-Agents: claude copilot cursor windsurf codex gemini
+Agents: claude copilot cursor windsurf codex gemini opencode cline roo kilocode continue amp
 EOF
 }
 
@@ -182,7 +189,12 @@ while [[ $# -gt 0 ]]; do
     --project|--workspace|--local) SCOPE="project"; shift ;;
     --global)  SCOPE="global"; shift ;;
     --both)    SCOPE="both"; shift ;;
-    --agent|--agents) AGENT_FILTER="${2:?--agent needs a value}"; shift 2 ;;
+    -sc|--scope)
+      v="${2:?--scope needs a value}"; shift 2
+      case "$v" in workspace|project|local) SCOPE="project";; global) SCOPE="global";; both) SCOPE="both";; *) die "Invalid scope '$v'";; esac ;;
+    -a|--agent|--agents) AGENT_FILTER="${2:?--agents needs a value}"; shift 2 ;;
+    -s|--skills)
+      IFS=',' read -r -a _sk <<<"${2:?--skills needs a value}"; SELECTED+=("${_sk[@]}"); shift 2 ;;
     --list)    DO_LIST=true; shift ;;
     -h|--help) usage; exit 0 ;;
     -*)        die "Unknown option: $1" ;;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spirewise",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "Installable Agent Skills for copywriting (F6S & LinkedIn company pages) for GitHub Copilot, Claude Code, and Cursor.",
   "bin": {
     "spirewise": "bin/cli.js"

package/skills/README.md

@@ -31,35 +31,45 @@ LinkedIn company page copy" and it will follow the skill: gather inputs, write t
 
 ## Install via command
 
-The easiest way is the npm CLI — it installs into **all** supported agents at
-once and asks whether to install for the current **project** or **globally**:
+The easiest way is the npm CLI. Run it with no flags for a full-screen
+interactive picker (skills → agents → scope), or pass flags to skip steps:
 
 ```bash
-npx spirewise install            # asks: project / global / both
-npx spirewise install --both     # project + global, all agents
-npx spirewise install --workspace # this folder only (current project)
-npx spirewise install --global   # all projects (home folders)
+npx spirewise                      # interactive picker for everything
+npx spirewise -sc both             # pick skills+agents, scope = both
+npx spirewise -s f6s-copywriting -a claude,cursor -sc workspace
+npx spirewise list                 # list skills
+npx spirewise agents               # agents + folders
 ```
 
-Narrow it down:
+Flags:
 
-```bash
-npx spirewise install --both --agent claude,cursor   # only some agents
-npx spirewise install f6s-copywriting --global        # only some skills
-npx spirewise list                                    # list skills
-npx spirewise agents                                  # agents + folders
 ```
+-s,  --skills <a,b>   skills to install   (default: all / pick)
+-a,  --agents <a,b>   agents to target    (default: all / pick)   alias: --agent
+-sc, --scope  <s>     workspace | global | both
+     --workspace | --global | --both       scope shortcuts
+```
+
+In the picker: **↑/↓** move, **space** toggle, **a** all/none, **enter**
+confirm, **esc** cancel.
 
-Supported agents and their folders (project / global):
+Supported agents and their folders (workspace / global):
 
-| Agent | Project | Global | Format |
-|-------|---------|--------|--------|
+| Agent | Workspace | Global | Format |
+|-------|-----------|--------|--------|
 | Claude Code | `.claude/skills/` | `~/.claude/skills/` | SKILL.md |
 | GitHub Copilot | `.github/skills/` | `~/.copilot/skills/` | SKILL.md |
 | Cursor | `.cursor/rules/` | `~/.cursor/rules/` | `.mdc` |
 | Windsurf | `.windsurf/rules/` | `~/.codeium/windsurf/global_rules/` | `.md` |
 | Codex CLI | `.codex/skills/` | `~/.codex/skills/` | SKILL.md |
 | Gemini CLI | `.gemini/skills/` | `~/.gemini/skills/` | SKILL.md |
+| OpenCode | `.opencode/skills/` | `~/.config/opencode/skills/` | SKILL.md |
+| Cline | `.clinerules/` | `~/.clinerules/` | `.md` |
+| Roo Code | `.roo/rules/` | `~/.roo/rules/` | `.md` |
+| Kilo Code | `.kilocode/rules/` | `~/.kilocode/rules/` | `.md` |
+| Continue | `.continue/rules/` | `~/.continue/rules/` | `.md` |
+| Amp | `.amp/rules/` | `~/.config/amp/rules/` | `.md` |
 
 ### No-Node fallback: `install.sh`