spirewise 1.0.0 → 1.0.1

package/README.md

@@ -2,46 +2,73 @@
 
 Installable **Agent Skills** for copywriting — generate ready-to-paste copy for
 your **F6S** and **LinkedIn** company pages, with strict character-limit safety.
-Works with **GitHub Copilot**, **Claude Code**, and **Cursor**.
+
+One command installs the skills into **all your AI agents at once** —
+**GitHub Copilot, Claude Code, Cursor, Windsurf, Codex CLI, Gemini CLI** — each in
+its correct folder and format. It asks whether to install for the **current
+project** or **globally** for every project.
 
 ## Install
 
-No clone needed — run it with `npx`:
+No clone needed:
 
 ```bash
-# install every skill
-npx spirewise install --all
+npx spirewise install
+```
 
-# install a single skill
-npx spirewise install f6s-copywriting
+You'll be asked where to install:
 
-# install several
-npx spirewise install f6s-copywriting linkedin-copywriting
+```
+==> Where should the skills be installed?
+  1) Workspace   (this folder only — the current project directory)
+  2) Global      (your home folders, all projects)
+  3) Both
+```
 
-# interactive picker
-npx spirewise install
+Skip the prompt with a scope flag:
 
-# list what's available
-npx spirewise list
+```bash
+npx spirewise install --workspace   # this folder only (current project)
+npx spirewise install --global      # all projects (home folders)
+npx spirewise install --both        # both
 ```
 
 Or install the CLI globally:
 
 ```bash
 npm install -g spirewise
-spirewise install --all
+spirewise install --both
 ```
 
-## Choose the target agent / folder
+## What gets installed where
+
+| Agent | Project 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 |
+
+Rule-based agents (Cursor, Windsurf) get a single rule file generated from the
+skill; the rest get the full `SKILL.md` folder.
+
+## Narrow it down
 
 ```bash
-spirewise install --all --agent claude    # ~/.claude/skills  (default)
-spirewise install --all --agent copilot   # ~/.copilot/skills
-spirewise install --all --agent cursor    # ~/.cursor/skills
-spirewise install --all --target ./skills # any custom folder
+# 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
 ```
 
-Run `spirewise --help` for all options.
+Run `npx spirewise --help` for all options.
 
 ## Skills included
 
@@ -63,6 +90,18 @@ Once installed, just ask your agent:
 The agent follows the skill: gathers your company details, writes the `.txt`
 file in the right folder, and confirms all character counts stay under limit.
 
+## No Node? Use the shell installer
+
+```bash
+# from a clone
+./install.sh --both
+
+# remote
+curl -fsSL https://raw.githubusercontent.com/spirerise/spirewise/main/install.sh | bash -s -- --both
+```
+
+It mirrors the CLI: all agents, project/global scope prompt, `--agent` filter.
+
 ## License
 
 MIT

package/bin/cli.js

@@ -2,24 +2,30 @@
 'use strict';
 
 /**
- * spirewise — install copywriting Agent Skills into your AI agent.
+ * spirewise — install copywriting Agent Skills into ALL your AI agents at once.
+ *
+ * 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).
  *
  * Usage:
- *   npx spirewise list
- *   npx spirewise install --all
- *   npx spirewise install f6s-copywriting
- *   npx spirewise install f6s-copywriting linkedin-copywriting
- *   npx spirewise install                       (interactive picker)
- *   npx spirewise install --agent cursor --all
- *   npx spirewise install --target ./my/skills --all
+ *   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
  */
 
 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');
+const HOME = process.env.HOME || process.env.USERPROFILE || os.homedir();
 
 const c = {
   reset: '\x1b[0m', blue: '\x1b[1;34m', green: '\x1b[1;32m',
@@ -30,14 +36,50 @@ const ok = (m) => console.log(`${c.green} ok${c.reset} ${m}`);
 const warn = (m) => console.error(`${c.yellow}  !${c.reset} ${m}`);
 const die = (m) => { console.error(`${c.red}err${c.reset} ${m}`); process.exit(1); };
 
-const AGENT_DIRS = {
-  claude: path.join(os_home(), '.claude', 'skills'),
-  copilot: path.join(os_home(), '.copilot', 'skills'),
-  cursor: path.join(os_home(), '.cursor', 'skills'),
+/**
+ * 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.
+ */
+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',
+  },
 };
 
-function os_home() {
-  return process.env.HOME || process.env.USERPROFILE || require('os').homedir();
+function expandHome(p) {
+  if (p === '~') return HOME;
+  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));
 }
 
 function availableSkills() {
@@ -48,6 +90,19 @@ function availableSkills() {
     .sort();
 }
 
+function readSkill(name) {
+  const raw = fs.readFileSync(path.join(SKILLS_DIR, name, 'SKILL.md'), 'utf8');
+  let description = name;
+  let body = raw;
+  const m = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (m) {
+    body = m[2];
+    const dm = m[1].match(/description:\s*(?:>-)?\s*([\s\S]*?)(?:\n\w|$)/);
+    if (dm) description = dm[1].replace(/\s+/g, ' ').trim();
+  }
+  return { description, body: body.replace(/^\s+/, '') };
+}
+
 function copyDir(src, dest) {
   fs.mkdirSync(dest, { recursive: true });
   for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
@@ -58,81 +113,100 @@ function copyDir(src, dest) {
   }
 }
 
-function installSkill(skill, targetDir) {
-  const src = path.join(SKILLS_DIR, skill);
-  if (!fs.existsSync(src)) die(`Skill '${skill}' not found in package.`);
-  const dest = path.join(targetDir, skill);
-  copyDir(src, dest);
-  ok(`installed ${skill} ${c.dim}-> ${dest}${c.reset}`);
+function installToAgent(agentKey, agent, scope, skills) {
+  const targetDir = resolveTarget(agent, scope);
+  fs.mkdirSync(targetDir, { recursive: true });
+  for (const skill of skills) {
+    if (agent.format === 'skill') {
+      const dest = path.join(targetDir, skill);
+      copyDir(path.join(SKILLS_DIR, skill), dest);
+      ok(`${agent.label} ${c.dim}(${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);
+      ok(`${agent.label} ${c.dim}(${scope})${c.reset} ${skill} ${c.dim}-> ${file}${c.reset}`);
+    }
+  }
 }
 
 function usage() {
-  console.log(`spirewise — install copywriting Agent Skills
+  console.log(`spirewise — install copywriting Agent Skills into all your AI agents
 
 Usage:
-  spirewise list
   spirewise install [skill ...] [options]
+  spirewise list
+  spirewise agents
 
-Commands:
-  list                  List available skills
-  install               Install skills (default command)
+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)
 
-Options:
-  --all                 Install every available skill
-  --agent <name>        Target agent: claude | copilot | cursor (default: claude)
-  --target <dir>        Install into a specific folder (overrides --agent)
+Selection:
+  [skill ...]           Limit to named skills (default: all)
+  --agent <a,b>         Limit to named agents (default: all)
+
+Other:
   -h, --help            Show this help
 
-Available skills:
+Supported agents:
+${Object.entries(AGENTS).map(([k, a]) => `  - ${k} (${a.label})`).join('\n')}
+
+Skills:
 ${availableSkills().map((s) => '  - ' + s).join('\n') || '  (none found)'}
 
 Examples:
-  npx spirewise install --all
-  npx spirewise install f6s-copywriting
-  npx spirewise install --agent cursor --all
+  npx spirewise install --both
+  npx spirewise install --project --agent claude,cursor
+  npx spirewise install f6s-copywriting --global
 `);
 }
 
 function parseArgs(argv) {
-  const opts = { all: false, agent: 'claude', target: null, skills: [] };
+  const o = { scope: null, agents: null, skills: [] };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
-    if (a === '--all') opts.all = true;
-    else if (a === '--agent') opts.agent = argv[++i] || die('--agent needs a value');
-    else if (a === '--target') opts.target = argv[++i] || die('--target needs a value');
+    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 opts.skills.push(a);
+    else o.skills.push(a);
   }
-  return opts;
+  return o;
 }
 
-function pick(available) {
+function ask(question) {
   return new Promise((resolve) => {
-    if (!process.stdin.isTTY) {
-      die("No skills specified. Use --all or name skills (run in a terminal for the picker).");
-    }
-    info('Select skills to install (space-separated numbers, or "a" for all):');
-    available.forEach((s, i) => console.log(`  ${i + 1}) ${s}`));
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    rl.question('  > ', (answer) => {
-      rl.close();
-      const t = answer.trim().toLowerCase();
-      if (t === 'a') return resolve(available.slice());
-      const chosen = [];
-      for (const tok of t.split(/\s+/)) {
-        const idx = parseInt(tok, 10) - 1;
-        if (idx >= 0 && idx < available.length) chosen.push(available[idx]);
-      }
-      resolve(chosen);
-    });
+    rl.question(question, (ans) => { rl.close(); resolve(ans.trim()); });
   });
 }
 
+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';
+}
+
 async function main() {
   let argv = process.argv.slice(2);
   let command = 'install';
-  if (argv[0] === 'list' || argv[0] === 'install') { command = argv[0]; argv = argv.slice(1); }
+  if (['list', 'install', 'agents'].includes(argv[0])) { command = argv[0]; argv = argv.slice(1); }
   else if (argv[0] === '-h' || argv[0] === '--help') { usage(); return; }
 
   const available = availableSkills();
@@ -143,27 +217,40 @@ async function main() {
     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}`);
+    }
+    return;
+  }
 
-  const opts = parseArgs(argv);
+  const o = parseArgs(argv);
 
-  if (opts.agent && !AGENT_DIRS[opts.agent] && !opts.target) {
-    die(`Unknown agent '${opts.agent}' (use claude | copilot | cursor)`);
+  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;
   }
-  const targetDir = opts.target ? path.resolve(opts.target) : AGENT_DIRS[opts.agent];
 
-  let selected = opts.all ? available.slice() : opts.skills.slice();
-  if (selected.length === 0) selected = await pick(available);
-  if (selected.length === 0) die('Nothing selected.');
+  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".`);
 
-  for (const s of selected) {
-    if (!available.includes(s)) die(`Unknown skill '${s}'. Run "spirewise list" to see options.`);
+  let scope = o.scope || await promptScope();
+  if (!['project', 'global', 'both'].includes(scope)) die(`Invalid scope '${scope}'.`);
+  const scopes = scope === 'both' ? ['project', 'global'] : [scope];
+
+  info(`Installing ${skills.length} skill(s) into ${agentKeys.length} agent(s): ${agentKeys.join(', ')}`);
+  info(`Scope: ${scope}`);
+
+  for (const sc of scopes) {
+    for (const k of agentKeys) installToAgent(k, AGENTS[k], sc, skills);
   }
 
-  info(`Target: ${targetDir}`);
-  fs.mkdirSync(targetDir, { recursive: true });
-  for (const s of selected) installSkill(s, targetDir);
-  ok(`Done. Installed ${selected.length} skill(s).`);
-  info('Restart your agent or reload skills if needed.');
+  ok(`Done. ${skills.length} skill(s) -> ${agentKeys.length} agent(s) (${scopes.join(' + ')}).`);
+  info('Restart your agent or reload skills/rules if needed.');
 }
 
 main().catch((e) => die(e && e.message ? e.message : String(e)));

package/install.sh

@@ -0,0 +1,229 @@
+#!/usr/bin/env bash
+#
+# spirewise — no-Node installer for copywriting Agent Skills.
+# Installs into ALL supported agents, in their correct folders, and asks
+# whether to install for THIS project (cwd) or GLOBALLY (home dirs).
+#
+# Local:   ./install.sh [--project|--global|--both] [--agent a,b] [skill ...]
+# Remote:  curl -fsSL <raw>/install.sh | bash -s -- --both
+#
+# Prefer the npm CLI when Node is available:  npx spirewise install
+#
+set -euo pipefail
+
+# ---- Repo config (used only for remote install) ---------------------------
+REPO_OWNER="${SKILLS_REPO_OWNER:-spirerise}"
+REPO_NAME="${SKILLS_REPO_NAME:-spirewise}"
+REPO_BRANCH="${SKILLS_REPO_BRANCH:-main}"
+SKILLS_SUBDIR="skills"
+# ---------------------------------------------------------------------------
+
+RAW_BASE="https://raw.githubusercontent.com/${REPO_OWNER}/${REPO_NAME}/${REPO_BRANCH}"
+API_BASE="https://api.github.com/repos/${REPO_OWNER}/${REPO_NAME}/contents/${SKILLS_SUBDIR}?ref=${REPO_BRANCH}"
+
+# Agent registry: "key|Label|format|ext|projectDir|globalDir"
+# format = skill (copy SKILL.md folder) | rule (single file from SKILL.md)
+AGENTS=(
+  "claude|Claude Code|skill||.claude/skills|HOME/.claude/skills"
+  "copilot|GitHub Copilot|skill||.github/skills|HOME/.copilot/skills"
+  "cursor|Cursor|rule|.mdc|.cursor/rules|HOME/.cursor/rules"
+  "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"
+)
+
+color() { printf '\033[%sm%s\033[0m' "$1" "$2"; }
+info()  { printf '%s %s\n' "$(color '1;34' '==>')" "$1"; }
+ok()    { printf '%s %s\n' "$(color '1;32' ' ok')" "$1"; }
+warn()  { printf '%s %s\n' "$(color '1;33' '  !')" "$1" >&2; }
+die()   { printf '%s %s\n' "$(color '1;31' 'err')" "$1" >&2; exit 1; }
+
+usage() {
+  cat <<EOF
+spirewise — install copywriting Agent Skills into all your AI agents.
+
+Usage:
+  install.sh [scope] [--agent a,b] [skill ...]
+
+Scope:
+  --workspace install only into this folder / current project (alias: --project)
+  --global    install only into global/home folders
+  --both      install into 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
+
+Agents: claude copilot cursor windsurf codex gemini
+EOF
+}
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" 2>/dev/null && pwd || true)"
+LOCAL_SKILLS_DIR=""
+[[ -n "$SCRIPT_DIR" && -d "$SCRIPT_DIR/$SKILLS_SUBDIR" ]] && LOCAL_SKILLS_DIR="$SCRIPT_DIR/$SKILLS_SUBDIR"
+
+WORK=""
+cleanup() { [[ -n "$WORK" && -d "$WORK" ]] && rm -rf "$WORK"; return 0; }
+trap cleanup EXIT
+
+# Ensure a local copy of every requested skill folder; echo its base dir.
+ensure_skills_dir() {
+  if [[ -n "$LOCAL_SKILLS_DIR" ]]; then
+    printf '%s' "$LOCAL_SKILLS_DIR"; return
+  fi
+  command -v curl >/dev/null || die "curl is required for remote install."
+  WORK="$(mktemp -d)"
+  printf '%s' "$WORK"
+}
+
+list_remote_skills() {
+  curl -fsSL "$API_BASE" \
+    | grep '"name"' | sed -E 's/.*"name": *"([^"]+)".*/\1/' \
+    | while read -r n; do
+        curl -fsI "${RAW_BASE}/${SKILLS_SUBDIR}/${n}/SKILL.md" >/dev/null 2>&1 && echo "$n"
+      done
+}
+
+available_skills() {
+  if [[ -n "$LOCAL_SKILLS_DIR" ]]; then
+    find "$LOCAL_SKILLS_DIR" -maxdepth 2 -name SKILL.md -print0 \
+      | xargs -0 -n1 dirname | xargs -n1 basename | sort
+  else
+    list_remote_skills | sort
+  fi
+}
+
+# Fetch a single SKILL.md into $BASE/<skill>/SKILL.md when remote.
+fetch_skill() {
+  local skill="$1" base="$2"
+  [[ -n "$LOCAL_SKILLS_DIR" ]] && return 0
+  mkdir -p "$base/$skill"
+  curl -fsSL "${RAW_BASE}/${SKILLS_SUBDIR}/${skill}/SKILL.md" -o "$base/$skill/SKILL.md" \
+    || die "Failed to download $skill/SKILL.md"
+}
+
+# Extract the description from a SKILL.md frontmatter (handles folded ">-"/"|").
+skill_description() {
+  awk '
+    /^---[[:space:]]*$/ { c++; next }
+    c==1 {
+      if ($0 ~ /^description:/) {
+        line=$0; sub(/^description:[[:space:]]*/, "", line)
+        if (line ~ /^[>|]-?[+]?[[:space:]]*$/) { folded=1; next }
+        gsub(/^[[:space:]]+|[[:space:]]+$/, "", line); print line; done=1; exit
+      }
+      if (folded) {
+        if ($0 ~ /^[[:space:]]/) {
+          s=$0; gsub(/^[[:space:]]+|[[:space:]]+$/, "", s)
+          out=(out==""?s:out" "s); next
+        }
+        print out; done=1; exit
+      }
+    }
+    END { if (!done && out!="") print out }
+  ' "$1"
+}
+
+# Print SKILL.md body (everything after the closing frontmatter ---).
+skill_body() {
+  awk 'BEGIN{c=0} /^---[[:space:]]*$/{c++; next} c>=2{print}' "$1"
+}
+
+# Resolve a registry dir token (HOME/... -> $HOME/...).
+resolve_dir() {
+  local d="$1"
+  if [[ "$d" == HOME/* ]]; then printf '%s/%s' "$HOME" "${d#HOME/}"; else printf '%s' "$d"; fi
+}
+
+install_for_agent() {
+  local key="$1" label="$2" fmt="$3" ext="$4" dir="$5" scope="$6" base="$7"; shift 7
+  local skills=("$@")
+  mkdir -p "$dir"
+  local s
+  for s in "${skills[@]}"; do
+    fetch_skill "$s" "$base"
+    if [[ "$fmt" == "skill" ]]; then
+      mkdir -p "$dir/$s"
+      cp -R "$base/$s/." "$dir/$s/"
+      ok "$label ($scope) $s -> $dir/$s"
+    else
+      local desc body file
+      desc="$(skill_description "$base/$s/SKILL.md")"
+      file="$dir/$s$ext"
+      { printf -- '---\ndescription: %s\nalwaysApply: false\n---\n\n' "$desc"; skill_body "$base/$s/SKILL.md"; } >"$file"
+      ok "$label ($scope) $s -> $file"
+    fi
+  done
+}
+
+# ---- Parse args ------------------------------------------------------------
+SCOPE=""
+AGENT_FILTER=""
+DO_LIST=false
+SELECTED=()
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --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 ;;
+    --list)    DO_LIST=true; shift ;;
+    -h|--help) usage; exit 0 ;;
+    -*)        die "Unknown option: $1" ;;
+    *)         SELECTED+=("$1"); shift ;;
+  esac
+done
+
+BASE="$(ensure_skills_dir)"
+
+AVAILABLE=()
+while IFS= read -r line; do [[ -n "$line" ]] && AVAILABLE+=("$line"); done < <(available_skills)
+[[ ${#AVAILABLE[@]} -gt 0 ]] || die "No skills found."
+
+if $DO_LIST; then
+  info "Available skills:"; printf '  - %s\n' "${AVAILABLE[@]}"; exit 0
+fi
+
+# Skills: default all.
+[[ ${#SELECTED[@]} -eq 0 ]] && SELECTED=("${AVAILABLE[@]}")
+for s in "${SELECTED[@]}"; do
+  found=false; for a in "${AVAILABLE[@]}"; do [[ "$s" == "$a" ]] && found=true && break; done
+  $found || die "Unknown skill '$s'. Use --list."
+done
+
+# Scope: prompt if not given.
+if [[ -z "$SCOPE" ]]; then
+  if [[ -t 0 ]]; then
+    info "Where should the skills be installed?"
+    echo "  1) Workspace   (this folder only — current project)"
+    echo "  2) Global      (your home folders — all projects)"
+    echo "  3) Both"
+    printf '  Choose 1/2/3 [1]: '
+    read -r ans
+    case "$ans" in 2|global) SCOPE="global";; 3|both) SCOPE="both";; *) SCOPE="project";; esac
+  else
+    warn 'No terminal; defaulting scope to "project". Use --global or --both.'
+    SCOPE="project"
+  fi
+fi
+
+SCOPES=("$SCOPE"); [[ "$SCOPE" == "both" ]] && SCOPES=("project" "global")
+
+info "Installing ${#SELECTED[@]} skill(s) into all matching agents. Scope: $SCOPE"
+
+for sc in "${SCOPES[@]}"; do
+  for entry in "${AGENTS[@]}"; do
+    IFS='|' read -r key label fmt ext pdir gdir <<<"$entry"
+    if [[ -n "$AGENT_FILTER" ]]; then
+      case ",$AGENT_FILTER," in *",$key,"*) ;; *) continue ;; esac
+    fi
+    if [[ "$sc" == "project" ]]; then dir="$(resolve_dir "$pdir")"; else dir="$(resolve_dir "$gdir")"; fi
+    install_for_agent "$key" "$label" "$fmt" "$ext" "$dir" "$sc" "$BASE" "${SELECTED[@]}"
+  done
+done
+
+ok "Done."
+info "Restart your agent or reload skills/rules if needed."

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "spirewise",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Installable Agent Skills for copywriting (F6S & LinkedIn company pages) for GitHub Copilot, Claude Code, and Cursor.",
   "bin": {
     "spirewise": "bin/cli.js"
   },
   "files": [
     "bin/",
-    "skills/"
+    "skills/",
+    "install.sh"
   ],
   "scripts": {
     "test": "node bin/cli.js list"
@@ -29,6 +30,6 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/spirerise/spirewise.git"
+    "url": "git+https://github.com/spirerise/spirewise.git"
   }
 }

package/skills/README.md

@@ -31,34 +31,46 @@ LinkedIn company page copy" and it will follow the skill: gather inputs, write t
 
 ## Install via command
 
-The easiest way is the npm CLI (skills are bundled in the package):
+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**:
 
 ```bash
-npx spirewise install --all                 # install every skill
-npx spirewise install f6s-copywriting       # install just one
-npx spirewise install                       # interactive picker
-npx spirewise list                          # list available skills
+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)
 ```
 
-Target a specific agent or folder:
+Narrow it down:
 
 ```bash
-npx spirewise install --all --agent claude   # ~/.claude/skills (default)
-npx spirewise install --all --agent copilot  # ~/.copilot/skills
-npx spirewise install --all --agent cursor   # ~/.cursor/skills
-npx spirewise install --all --target ./skills
+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
 ```
 
+Supported agents and their folders (project / global):
+
+| Agent | Project | 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 |
+
 ### No-Node fallback: `install.sh`
 
-If you can't use npm, the bundled `install.sh` does the same over `curl`:
+If you can't use npm, the bundled `install.sh` mirrors the CLI over `curl`:
 
 ```bash
 # from a clone
-./install.sh --all
+./install.sh --both
 
 # remote
-curl -fsSL https://raw.githubusercontent.com/spirerise/spirewise/main/install.sh | bash -s -- --all
+curl -fsSL https://raw.githubusercontent.com/spirerise/spirewise/main/install.sh | bash -s -- --both
 ```
 
 Run `./install.sh --help` or `npx spirewise --help` for all options.