crewkit 1.1.3 → 1.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crewkit",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "Context engineering framework for AI-assisted development. One command to set up agents, skills, hooks, rules, and memory for your project.",
   "type": "module",
   "bin": {

package/skill/copilot-agent.md

@@ -0,0 +1,142 @@
+---
+name: crewkit-setup
+description: "Scan your codebase and generate a complete context engineering setup: agents, instructions, memory files, and copilot-instructions.md."
+---
+
+# crewkit-setup
+
+Scan the current project and generate a complete context engineering setup tailored to this codebase.
+
+**You are the AI executing this.** Follow each phase in order. Do not ask the user questions. Scan, generate, report.
+
+---
+
+## Phase 1 — Reconnaissance
+
+Scan the project to identify:
+- **Stack & frameworks**: languages, build tools, test frameworks, package managers
+- **Architecture**: monolith/microservices, key directories, entry points
+- **Existing AI context**: any `.github/`, `.ai/`, `CLAUDE.md`, `AGENTS.md` files
+
+Write findings to `.crewkit/scan-phase1-recon.md`.
+
+---
+
+## Phase 2 — Codebase Mapping
+
+Read representative source files (3-5 per layer: models, services, controllers, tests). Identify:
+- Naming conventions, code style
+- Core domain concepts and entities
+- Test patterns and coverage approach
+- CI/CD and build commands
+
+Write findings to `.crewkit/scan-phase2-map.md`.
+
+---
+
+## Phase 3 — Profile Compilation
+
+Synthesize phases 1-2 into a project profile:
+- Stack summary
+- Architecture summary
+- Key commands (build, test, lint)
+- Domain concepts
+- Hard rules to enforce
+
+Write profile to `.crewkit/last-scan.md`.
+
+---
+
+## Phase 4 — File Generation
+
+Generate all files using the profile from `.crewkit/last-scan.md`.
+
+### Step 1 — `.ai/memory/`
+
+Create these files (all in English):
+- `architecture.md` — system design, key components, data flow
+- `conventions.md` — naming rules, patterns, anti-patterns
+- `commands.md` — build, test, lint, run commands with flags
+- `testing.md` — test strategy, frameworks, coverage approach
+- `lessons.md` — known gotchas, non-obvious behaviors
+- `state.md` — current sprint goal, recent changes, open issues
+
+### Step 2 — `.github/copilot-instructions.md`
+
+```markdown
+# [PROJECT NAME] — Copilot Instructions
+
+## Overview
+[1-2 sentences: what the project is, main stack]
+
+**Stack:** [stacks]
+**Architecture:** [key patterns]
+
+---
+
+## Hard rules (apply to every response)
+
+[Numbered list of non-negotiable rules]
+
+Details → `.ai/memory/conventions.md`
+
+---
+
+## Memory
+
+- `.ai/memory/architecture.md` — system design
+- `.ai/memory/conventions.md` — coding conventions
+- `.ai/memory/commands.md` — build/test commands
+- `.ai/memory/lessons.md` — known gotchas
+```
+
+### Step 3 — `.github/instructions/` (per-stack rules)
+
+For each detected stack, create `[stack].instructions.md`:
+```markdown
+---
+applyTo: "**/*.ts"
+---
+[Stack-specific rules: error handling, imports, typing, testing patterns]
+```
+
+### Step 4 — `.github/agents/` (agent definitions)
+
+Create one file per agent: `explorer.agent.md`, `architect.agent.md`, `coder.agent.md`, `tester.agent.md`, `reviewer.agent.md`.
+
+Each file:
+```markdown
+---
+name: [Agent Name]
+description: "[One-line role description]"
+---
+# [Agent Name]
+
+**Role:** [role]
+**Responsibilities:** [responsibilities]
+**Approach:** [how it works]
+**Output:** [what it produces]
+```
+
+---
+
+## Phase 5 — Completion Report
+
+After all files are generated, report to the user:
+
+```
+crewkit-setup complete
+
+Generated:
+  .ai/memory/                    (6 files)
+  .github/copilot-instructions.md
+  .github/instructions/          (per-stack rules)
+  .github/agents/                (5 agents)
+
+Stack detected: [stack]
+Architecture:   [pattern]
+
+Next steps:
+  1. Review .github/copilot-instructions.md — adjust hard rules if needed
+  2. Open Copilot Chat — context is now active
+```

package/skill/cursor-global.md

@@ -0,0 +1,157 @@
+---
+description: "Context engineering setup — scan codebase and generate AI context files (.cursor/rules, AGENTS.md, .ai/memory)"
+alwaysApply: false
+---
+
+# crewkit-setup
+
+Scan the current project and generate a complete context engineering setup tailored to this codebase.
+
+**You are the AI executing this.** Follow each phase in order. Do not ask the user questions. Scan, generate, report.
+
+---
+
+## Phase 1 — Reconnaissance
+
+Scan the project to identify:
+- **Stack & frameworks**: languages, build tools, test frameworks, package managers
+- **Architecture**: monolith/microservices, key directories, entry points
+- **Existing AI context**: any `.cursor/`, `.github/`, `.ai/`, `CLAUDE.md`, `AGENTS.md` files
+
+Write findings to `.crewkit/scan-phase1-recon.md`.
+
+---
+
+## Phase 2 — Codebase Mapping
+
+Read representative source files (3-5 per layer: models, services, controllers, tests). Identify:
+- Naming conventions, code style
+- Core domain concepts and entities
+- Test patterns and coverage approach
+- CI/CD and build commands
+
+Write findings to `.crewkit/scan-phase2-map.md`.
+
+---
+
+## Phase 3 — Profile Compilation
+
+Synthesize phases 1-2 into a project profile:
+- Stack summary
+- Architecture summary
+- Key commands (build, test, lint)
+- Domain concepts
+- Hard rules to enforce
+
+Write profile to `.crewkit/last-scan.md`.
+
+---
+
+## Phase 4 — File Generation
+
+Generate all files using the profile from `.crewkit/last-scan.md`.
+
+### Step 1 — `.ai/memory/`
+
+Create these files (all in English):
+- `architecture.md` — system design, key components, data flow
+- `conventions.md` — naming rules, patterns, anti-patterns
+- `commands.md` — build, test, lint, run commands with flags
+- `testing.md` — test strategy, frameworks, coverage approach
+- `lessons.md` — known gotchas, non-obvious behaviors
+- `state.md` — current sprint goal, recent changes, open issues
+
+### Step 2 — `.cursor/rules/project.md`
+
+```
+---
+description: "Project rules"
+alwaysApply: true
+---
+# [PROJECT NAME] — Project Rules
+
+## Overview
+[1-2 sentences: what the project is, main stack]
+
+**Stack:** [stacks]
+**Architecture:** [key patterns]
+
+---
+
+## Hard rules
+
+[Numbered list of non-negotiable rules from the profile]
+
+---
+
+## Memory
+
+Reference files in `.ai/memory/` for detailed context:
+- `.ai/memory/architecture.md` — system design
+- `.ai/memory/conventions.md` — coding conventions
+- `.ai/memory/commands.md` — build/test commands
+```
+
+### Step 3 — `.cursor/rules/` (per-stack rules)
+
+For each detected stack (e.g., `typescript.md`, `python.md`), generate a rules file with:
+```
+---
+description: "[Stack] coding rules"
+globs: ["**/*.ts"] (or appropriate glob)
+alwaysApply: false
+---
+[Stack-specific rules: error handling, imports, typing, testing patterns]
+```
+
+### Step 4 — `AGENTS.md`
+
+Create a single `AGENTS.md` at the project root with all agents as `##` sections:
+
+```markdown
+# Agents
+
+## Explorer
+Role: Codebase reconnaissance and research.
+[...]
+
+## Architect
+Role: System design and planning.
+[...]
+
+## Coder
+Role: Implementation.
+[...]
+
+## Tester
+Role: Test writing and validation.
+[...]
+
+## Reviewer
+Role: Code review and quality.
+[...]
+```
+
+Each agent section should include: Role, Responsibilities, Approach, Output format.
+
+---
+
+## Phase 5 — Completion Report
+
+After all files are generated, report to the user:
+
+```
+crewkit-setup complete
+
+Generated:
+  .ai/memory/          (6 files)
+  .cursor/rules/       (project.md + per-stack rules)
+  AGENTS.md            (5 agents)
+
+Stack detected: [stack]
+Architecture:   [pattern]
+
+Next steps:
+  1. Review .cursor/rules/project.md — adjust hard rules if needed
+  2. Open Cursor and start coding — context is active
+```

package/skill/packs/analytics/pack.json

@@ -0,0 +1,7 @@
+{
+  "name": "analytics",
+  "description": "Development metrics and post-mortem analysis",
+  "components": {
+    "skills": ["dev-metrics", "retro"]
+  }
+}

package/skill/packs/quality/pack.json

@@ -0,0 +1,7 @@
+{
+  "name": "quality",
+  "description": "Code review, blast radius analysis, and post-mortems",
+  "components": {
+    "skills": ["review-pr", "impact", "retro"]
+  }
+}

package/skill/packs/security/pack.json

@@ -0,0 +1,7 @@
+{
+  "name": "security",
+  "description": "OWASP vulnerability scanning and security hardening",
+  "components": {
+    "skills": ["security-scan"]
+  }
+}

package/src/add.js

@@ -1,45 +1,109 @@
-import { cpSync, mkdirSync, existsSync } from 'node:fs';
+import { cpSync, mkdirSync, existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
+import { CORE_SKILLS } from './constants.js';
 
-const OPTIONAL_SKILLS = ['retro', 'dev-metrics', 'security-scan', 'impact'];
+function getOptionalSkills() {
+  const skillsDir = join(homedir(), '.claude', 'skills', 'crewkit-setup', 'templates', 'skills');
+  if (!existsSync(skillsDir)) return [];
+  return readdirSync(skillsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory() && !CORE_SKILLS.includes(d.name))
+    .map(d => d.name);
+}
 
-export function add(skillName) {
-  if (!skillName) {
-    console.error('Error: skill name is required.');
-    console.log(`\n  Available optional skills:\n${OPTIONAL_SKILLS.map(s => `    - ${s}`).join('\n')}\n`);
+function getAvailablePacks() {
+  const packsDir = join(homedir(), '.claude', 'skills', 'crewkit-setup', 'packs');
+  if (!existsSync(packsDir)) return [];
+  return readdirSync(packsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory() && existsSync(join(packsDir, d.name, 'pack.json')))
+    .map(d => d.name);
+}
+
+function installSkill(skillName) {
+  const sourceDir = join(homedir(), '.claude', 'skills', 'crewkit-setup', 'templates', 'skills', skillName);
+
+  if (!existsSync(sourceDir)) {
+    console.error(`Error: source not found at ${sourceDir}`);
+    console.log('  Make sure crewkit is installed first: npx crewkit install');
     process.exit(1);
   }
 
-  if (!OPTIONAL_SKILLS.includes(skillName)) {
-    console.error(`Error: "${skillName}" is not a known optional skill.`);
-    console.log(`\n  Available optional skills:\n${OPTIONAL_SKILLS.map(s => `    - ${s}`).join('\n')}\n`);
-    process.exit(1);
+  const targetDir = join(process.cwd(), '.claude', 'skills', skillName);
+
+  if (existsSync(targetDir)) {
+    console.log(`  Warning: ${targetDir} already exists. Overwriting.`);
   }
 
-  const source = join(homedir(), '.claude', 'skills', 'crewkit-setup', 'templates', 'skills', skillName, 'SKILL.md');
+  mkdirSync(targetDir, { recursive: true });
+  cpSync(sourceDir, targetDir, { recursive: true, force: true });
+
+  return targetDir;
+}
+
+function installPack(packName) {
+  const packJson = join(homedir(), '.claude', 'skills', 'crewkit-setup', 'packs', packName, 'pack.json');
+  let pack;
+  try {
+    pack = JSON.parse(readFileSync(packJson, 'utf8'));
+  } catch {
+    console.error(`Error: invalid pack.json for "${packName}".`);
+    process.exit(1);
+  }
+  const skills = pack.components?.skills ?? [];
 
-  if (!existsSync(source)) {
-    console.error(`Error: source not found at ${source}`);
+  const templatesDir = join(homedir(), '.claude', 'skills', 'crewkit-setup', 'templates', 'skills');
+  const missing = skills.filter(s => !existsSync(join(templatesDir, s)));
+  if (missing.length) {
+    console.error(`Error: pack "${packName}" references missing skills: ${missing.join(', ')}`);
     console.log('  Make sure crewkit is installed first: npx crewkit install');
     process.exit(1);
   }
 
-  const targetDir = join(process.cwd(), '.claude', 'skills', skillName);
-  const target = join(targetDir, 'SKILL.md');
+  const installed = [];
+  for (const skillName of skills) {
+    const targetDir = installSkill(skillName);
+    installed.push({ name: skillName, path: targetDir });
+  }
 
-  if (existsSync(target)) {
-    console.log(`  Warning: ${target} already exists. Overwriting.`);
+  console.log(`
+  ✓ Pack "${packName}" installed (${installed.length} skill${installed.length !== 1 ? 's' : ''})
+`);
+  for (const { name, path } of installed) {
+    console.log(`    /${name}  →  ${path}`);
   }
+  console.log('');
+}
 
-  mkdirSync(targetDir, { recursive: true });
-  cpSync(source, target);
+export function add(skillName) {
+  const availablePacks = getAvailablePacks();
+  const optionalSkills = getOptionalSkills();
 
-  console.log(`
+  if (!skillName) {
+    console.error('Error: skill name is required.');
+    console.log(`\n  Available packs:\n${availablePacks.map(p => `    - ${p}`).join('\n')}`);
+    console.log(`\n  Available optional skills:\n${optionalSkills.map(s => `    - ${s}`).join('\n')}\n`);
+    process.exit(1);
+  }
+
+  if (availablePacks.includes(skillName)) {
+    installPack(skillName);
+    return;
+  }
+
+  if (optionalSkills.includes(skillName)) {
+    const targetDir = installSkill(skillName);
+    console.log(`
   ✓ Skill "${skillName}" installed
 
-  Copied to: ${target}
+  Copied to: ${targetDir}
 
   Use /${skillName} in Claude Code to run it.
   `);
+    return;
+  }
+
+  console.error(`Error: "${skillName}" is not a known pack or optional skill.`);
+  console.log(`\n  Available packs:\n${availablePacks.map(p => `    - ${p}`).join('\n')}`);
+  console.log(`\n  Available optional skills:\n${optionalSkills.map(s => `    - ${s}`).join('\n')}\n`);
+  process.exit(1);
 }

package/src/cli.js

@@ -1,19 +1,23 @@
 import { install } from './install.js';
 import { update } from './update.js';
 import { add } from './add.js';
+import { list } from './list.js';
 
 const HELP = `
 crewkit — Context engineering for AI-assisted development
 
 Commands:
-  install       Install crewkit skill globally (~/.claude/skills/)
+  install       Install crewkit globally (Claude Code, Copilot, Cursor)
   update        Update to latest version (re-run install)
-  add <skill>   Add an optional skill to the current project
+  add <name>    Add an optional skill or pack to the current project
+  list          List all available skills and packs (core + add-ons)
   help          Show this message
 
 Usage:
   npx crewkit install          # one-time setup
+  npx crewkit list             # see all available skills and packs
   npx crewkit add retro        # add optional skill to project
+  npx crewkit add quality      # add a pack (multiple skills)
   /crewkit-setup               # run in your IDE to scan & calibrate a project
 `;
 
@@ -22,14 +26,18 @@ export function run(args) {
 
   switch (command) {
     case 'install':
-      install();
-      break;
+      install().catch(err => { console.error(err.message); process.exit(1); });
+      return;
+
     case 'update':
-      update();
-      break;
+      update().catch(err => { console.error(err.message); process.exit(1); });
+      return;
     case 'add':
       add(args[1]);
       break;
+    case 'list':
+      list();
+      break;
     case 'help':
     case '--help':
     case '-h':

package/src/constants.js

@@ -0,0 +1 @@
+export const CORE_SKILLS = ['full-workflow', 'hotfix', 'explore-and-plan', 'review-pr'];

package/src/detect.js

@@ -0,0 +1,25 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+export function detectTools() {
+  const tools = [];
+  const home = homedir();
+
+  if (existsSync(join(home, '.claude'))) {
+    const dest = join(home, '.claude', 'skills', 'crewkit-setup');
+    tools.push({ id: 'claude', name: 'Claude Code', dest, versionFile: join(dest, '.version') });
+  }
+
+  if (existsSync(join(home, '.copilot'))) {
+    const dest = join(home, '.copilot', 'agents');
+    tools.push({ id: 'copilot', name: 'GitHub Copilot', dest, versionFile: join(dest, 'crewkit-setup.version') });
+  }
+
+  if (existsSync(join(home, '.cursor'))) {
+    const dest = join(home, '.cursor');
+    tools.push({ id: 'cursor', name: 'Cursor', dest, versionFile: join(dest, 'crewkit-setup.version') });
+  }
+
+  return tools;
+}

package/src/install.js

@@ -1,43 +1,65 @@
-import { cpSync, mkdirSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { cpSync, mkdirSync, readFileSync, writeFileSync, copyFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
-import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
+import { detectTools } from './detect.js';
+import { selectTargets } from './prompt.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-export function install() {
-  const skillSource = join(__dirname, '..', 'skill');
-  const skillDest = join(homedir(), '.claude', 'skills', 'crewkit-setup');
-
-  // Verify source exists
-  if (!existsSync(skillSource)) {
-    console.error('Error: skill/ directory not found. Package may be corrupted.');
-    process.exit(1);
-  }
-
-  // Create destination
-  mkdirSync(skillDest, { recursive: true });
+function readVersion() {
+  return JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8')).version;
+}
 
-  // Copy skill + templates
-  cpSync(skillSource, skillDest, { recursive: true, force: true });
+function installClaude(target, version) {
+  const skillSource = join(__dirname, '..', 'skill');
+  mkdirSync(target.dest, { recursive: true });
+  cpSync(skillSource, target.dest, { recursive: true, force: true });
+  writeFileSync(target.versionFile, version, 'utf8');
+  console.log(`  ✓ Claude Code       →  ${target.dest}`);
+  console.log(`    Run /crewkit-setup in any project\n`);
+}
 
-  // Read version
-  const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
+function installSingleFile(target, templateFile, outputFile, label, hint, version) {
+  const template = join(__dirname, '..', 'skill', templateFile);
+  mkdirSync(target.dest, { recursive: true });
+  copyFileSync(template, join(target.dest, outputFile));
+  writeFileSync(target.versionFile, version, 'utf8');
+  console.log(`  ✓ ${label}  →  ${join(target.dest, outputFile)}`);
+  console.log(`    ${hint}\n`);
+}
 
-  // Write version marker
-  writeFileSync(join(skillDest, '.version'), pkg.version, 'utf8');
+export async function install() {
+  const version = readVersion();
+  const tools = detectTools();
 
-  console.log(`
-  ✓ crewkit v${pkg.version} installed
+  if (tools.length === 0) {
+    console.log(`
+  No supported AI tools detected.
 
-  Skill copied to: ${skillDest}
+  crewkit looks for: ~/.claude, ~/.copilot, ~/.cursor
+  Install one of these tools and re-run.
+    `);
+    process.exit(1);
+  }
 
-  Next: open any project in Claude Code and run:
+  const targets = await selectTargets(tools);
 
-    /crewkit-setup
+  console.log(`\n  Installing crewkit v${version}...\n`);
 
-  This will scan your codebase and generate a complete
-  context engineering setup (agents, skills, hooks, rules, memory).
-  `);
+  for (const target of targets) {
+    switch (target.id) {
+      case 'claude':
+        installClaude(target, version);
+        break;
+      case 'copilot':
+        installSingleFile(target, 'copilot-agent.md', 'crewkit-setup.md',
+          'GitHub Copilot  ', 'Use @crewkit-setup in Copilot CLI or Chat', version);
+        break;
+      case 'cursor':
+        installSingleFile(target, 'cursor-global.md', 'crewkit-setup.md',
+          'Cursor          ', 'Copy to .cursor/rules/ in your projects', version);
+        break;
+    }
+  }
 }

package/src/list.js

@@ -0,0 +1,75 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { CORE_SKILLS } from './constants.js';
+
+function readDescription(skillDir) {
+  const skillMd = join(skillDir, 'SKILL.md');
+  if (!existsSync(skillMd)) return '';
+  const content = readFileSync(skillMd, 'utf8');
+  const match = content.match(/^---[\s\S]*?^description:\s*"?(.+?)"?\s*$/m);
+  if (!match) return '';
+  const desc = match[1].trim();
+  return desc.length > 45 ? desc.slice(0, 44) + '…' : desc;
+}
+
+function getAvailablePacks() {
+  const packsDir = join(homedir(), '.claude', 'skills', 'crewkit-setup', 'packs');
+  if (!existsSync(packsDir)) return [];
+  return readdirSync(packsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory() && existsSync(join(packsDir, d.name, 'pack.json')))
+    .map(d => {
+      try {
+        const pack = JSON.parse(readFileSync(join(packsDir, d.name, 'pack.json'), 'utf8'));
+        return { name: d.name, description: pack.description ?? '', skills: pack.components?.skills ?? [] };
+      } catch {
+        return { name: d.name, description: '(invalid pack.json)', skills: [] };
+      }
+    });
+}
+
+export function list() {
+  const skillsDir = join(homedir(), '.claude', 'skills', 'crewkit-setup', 'templates', 'skills');
+
+  if (!existsSync(skillsDir)) {
+    console.error('Error: crewkit templates not found.');
+    console.log('  Make sure crewkit is installed first: npx crewkit install');
+    process.exit(1);
+  }
+
+  const allDirs = readdirSync(skillsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name);
+
+  const coreSkills = CORE_SKILLS.filter(s => allDirs.includes(s));
+  const addonSkills = allDirs.filter(s => !CORE_SKILLS.includes(s)).sort();
+  const packs = getAvailablePacks();
+
+  const pad = (name, width) => name + ' '.repeat(Math.max(1, width - name.length));
+  const nameWidth = Math.max(...[...coreSkills, ...addonSkills, ...packs.map(p => p.name)].map(s => s.length)) + 2;
+
+  console.log('\ncrewkit — available components\n');
+
+  console.log('  Core skills (installed by /crewkit-setup):');
+  for (const name of coreSkills) {
+    const desc = readDescription(join(skillsDir, name));
+    console.log(`    ${pad(name, nameWidth)}${desc}`);
+  }
+
+  console.log('\n  Add-on skills (install with: npx crewkit add <name>):');
+  for (const name of addonSkills) {
+    const desc = readDescription(join(skillsDir, name));
+    console.log(`    ${pad(name, nameWidth)}${desc}`);
+  }
+
+  if (packs.length > 0) {
+    console.log('\n  Packs (install with: npx crewkit add <name>):');
+    for (const { name, description, skills } of packs) {
+      const desc = description.length > 45 ? description.slice(0, 44) + '…' : description;
+      const contents = skills.length > 0 ? `  [${skills.join(', ')}]` : '';
+      console.log(`    ${pad(name, nameWidth)}${desc}${contents}`);
+    }
+  }
+
+  console.log('');
+}

package/src/prompt.js

@@ -0,0 +1,32 @@
+import { createInterface } from 'node:readline';
+
+function ask(question) {
+  return new Promise(resolve => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, answer => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+export async function selectTargets(tools) {
+  if (tools.length === 0) return [];
+  if (tools.length === 1) return [tools[0]];
+
+  console.log('\n  Multiple AI tools detected. Where do you want to install crewkit?\n');
+  tools.forEach((tool, i) => {
+    console.log(`    [${i + 1}] ${tool.name}`);
+  });
+  console.log(`    [${tools.length + 1}] All of the above`);
+  console.log();
+
+  const answer = await ask('  Your choice: ');
+  const num = parseInt(answer, 10);
+
+  if (num === tools.length + 1) return tools;
+  if (num >= 1 && num <= tools.length) return [tools[num - 1]];
+
+  console.log('  Invalid choice. Installing to all detected tools.');
+  return tools;
+}

package/src/update.js

@@ -1,27 +1,32 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
-import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
+import { detectTools } from './detect.js';
 import { install } from './install.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-export function update() {
-  const versionFile = join(homedir(), '.claude', 'skills', 'crewkit-setup', '.version');
-  const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
+function getInstalledVersion() {
+  for (const tool of detectTools()) {
+    if (existsSync(tool.versionFile)) {
+      return readFileSync(tool.versionFile, 'utf8').trim();
+    }
+  }
+  return 'unknown';
+}
 
+export async function update() {
+  const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
   const newVersion = pkg.version;
-  const currentVersion = existsSync(versionFile)
-    ? readFileSync(versionFile, 'utf8').trim()
-    : 'unknown';
+  const currentVersion = getInstalledVersion();
 
   if (currentVersion === newVersion) {
     console.log(`  Already up to date (v${newVersion})`);
     return;
   }
 
-  install();
+  await install();
 
   const fromLabel = currentVersion === 'unknown' ? 'v0.1 (untracked)' : `v${currentVersion}`;
   console.log(`  Updated: ${fromLabel} → v${newVersion}`);