clauderc 1.0.0

package/bin/cli.js

@@ -0,0 +1,802 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, cpSync, readdirSync, readFileSync, writeFileSync, renameSync } from 'fs';
+import { join, dirname, sep, basename } from 'path';
+import { fileURLToPath } from 'url';
+import { homedir, platform } from 'os';
+import { createInterface } from 'readline';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TEMPLATES_DIR = join(__dirname, '..', 'templates');
+const CLAUDE_DIR = join(homedir(), '.claude');
+const MANIFEST_FILE = join(CLAUDE_DIR, '.clauderc.json');
+const IS_WINDOWS = platform() === 'win32';
+
+const VERSION = '1.0.0';
+const AUTHOR = {
+  name: 'Matheus Kindrazki',
+  github: 'https://github.com/matheuskindrazki',
+  repo: 'https://github.com/matheuskindrazki/clauderc',
+  twitter: 'https://x.com/kindraScript',
+};
+
+// Windows-compatible colors
+const supportsColors = process.stdout.isTTY &&
+  (process.env.FORCE_COLOR !== '0') &&
+  (IS_WINDOWS ? process.env.TERM !== 'dumb' : true);
+
+const c = supportsColors ? {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
+  red: '\x1b[31m',
+  dim: '\x1b[2m',
+  bold: '\x1b[1m',
+  underline: '\x1b[4m',
+} : {
+  reset: '', green: '', yellow: '', blue: '', cyan: '', magenta: '', red: '', dim: '', bold: '', underline: '',
+};
+
+const log = {
+  info: (msg) => console.log(`  ${c.blue}info${c.reset}  ${msg}`),
+  success: (msg) => console.log(`  ${c.green}done${c.reset}  ${msg}`),
+  warn: (msg) => console.log(`  ${c.yellow}skip${c.reset}  ${msg}`),
+  error: (msg) => console.log(`  ${c.red}fail${c.reset}  ${msg}`),
+  add: (msg) => console.log(`  ${c.green} +${c.reset}    ${msg}`),
+  update: (msg) => console.log(`  ${c.cyan} ~${c.reset}    ${msg}`),
+  remove: (msg) => console.log(`  ${c.red} -${c.reset}    ${msg}`),
+};
+
+function banner() {
+  console.log(`
+  ${c.cyan}${c.bold}╔═══════════════════════════════════════════════════════════╗${c.reset}
+  ${c.cyan}${c.bold}║${c.reset}                                                           ${c.cyan}${c.bold}║${c.reset}
+  ${c.cyan}${c.bold}║${c.reset}   ${c.bold}clauderc${c.reset}                                                ${c.cyan}${c.bold}║${c.reset}
+  ${c.cyan}${c.bold}║${c.reset}   ${c.dim}Best practices for Claude Code - agents, skills & more${c.reset}  ${c.cyan}${c.bold}║${c.reset}
+  ${c.cyan}${c.bold}║${c.reset}                                                           ${c.cyan}${c.bold}║${c.reset}
+  ${c.cyan}${c.bold}╚═══════════════════════════════════════════════════════════╝${c.reset}
+`);
+}
+
+function displayPath(fullPath) {
+  const home = homedir();
+  if (fullPath.startsWith(home)) {
+    const relative = fullPath.slice(home.length);
+    return IS_WINDOWS ? `%USERPROFILE%${relative}` : `~${relative}`;
+  }
+  return fullPath;
+}
+
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+// Manifest functions
+function loadPackageManifest() {
+  const manifestPath = join(TEMPLATES_DIR, 'manifest.json');
+  if (!existsSync(manifestPath)) return null;
+  return JSON.parse(readFileSync(manifestPath, 'utf-8'));
+}
+
+function loadInstalledManifest() {
+  if (!existsSync(MANIFEST_FILE)) return null;
+  try {
+    return JSON.parse(readFileSync(MANIFEST_FILE, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function saveInstalledManifest(manifest) {
+  writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
+}
+
+function getSourcePath(fileKey) {
+  if (fileKey.startsWith('templates/')) {
+    return join(TEMPLATES_DIR, 'project-setup', fileKey.replace('templates/project-setup/', ''));
+  }
+  return join(TEMPLATES_DIR, fileKey);
+}
+
+function getDestPath(fileKey) {
+  return join(CLAUDE_DIR, fileKey);
+}
+
+function isNewer(v1, v2) {
+  const parse = (v) => (v || '0.0.0').split('.').map(Number);
+  const [a1, b1, c1] = parse(v1);
+  const [a2, b2, c2] = parse(v2);
+  if (a1 !== a2) return a1 > a2;
+  if (b1 !== b2) return b1 > b2;
+  return c1 > c2;
+}
+
+function backupFile(filePath) {
+  if (existsSync(filePath)) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const backupPath = `${filePath}.backup-${timestamp}`;
+    renameSync(filePath, backupPath);
+    return backupPath;
+  }
+  return null;
+}
+
+function copyFile(src, dest, options = {}) {
+  const { backup = false, dryRun = false } = options;
+  ensureDir(dirname(dest));
+
+  let backupPath = null;
+  if (backup && existsSync(dest) && !dryRun) {
+    backupPath = backupFile(dest);
+  }
+
+  if (!dryRun) {
+    cpSync(src, dest);
+  }
+  return backupPath;
+}
+
+function showFooter() {
+  console.log(`
+  ${c.dim}─────────────────────────────────────────────────────────────${c.reset}
+
+  ${c.bold}Created by ${c.cyan}${AUTHOR.name}${c.reset}
+
+  ${c.dim}GitHub:${c.reset}  ${c.underline}${AUTHOR.repo}${c.reset}
+  ${c.dim}Twitter:${c.reset} ${c.underline}${AUTHOR.twitter}${c.reset}
+
+  ${c.yellow}★${c.reset} ${c.dim}If this helped you, consider giving it a star!${c.reset}
+  ${c.dim}─────────────────────────────────────────────────────────────${c.reset}
+`);
+}
+
+function showSuccessBanner(stats) {
+  const { created, updated, skipped } = stats;
+
+  console.log(`
+  ${c.green}${c.bold}╔═══════════════════════════════════════════════════════════╗${c.reset}
+  ${c.green}${c.bold}║${c.reset}                                                           ${c.green}${c.bold}║${c.reset}
+  ${c.green}${c.bold}║${c.reset}   ${c.green}${c.bold}✓ Setup Complete!${c.reset}                                      ${c.green}${c.bold}║${c.reset}
+  ${c.green}${c.bold}║${c.reset}                                                           ${c.green}${c.bold}║${c.reset}
+  ${c.green}${c.bold}║${c.reset}   ${c.green}+${created} created${c.reset}  ${c.cyan}~${updated} updated${c.reset}  ${c.yellow}○${skipped} skipped${c.reset}                  ${c.green}${c.bold}║${c.reset}
+  ${c.green}${c.bold}║${c.reset}                                                           ${c.green}${c.bold}║${c.reset}
+  ${c.green}${c.bold}╚═══════════════════════════════════════════════════════════╝${c.reset}
+
+  ${c.bold}Try these commands in Claude Code:${c.reset}
+
+    ${c.cyan}Ask Claude:${c.reset} "Use project-setup-wizard to configure this project"
+    ${c.cyan}Slash commands:${c.reset} /test, /lint, /verify, /pr
+
+`);
+}
+
+function listInstalled() {
+  banner();
+
+  const installed = loadInstalledManifest();
+  const pkg = loadPackageManifest();
+
+  console.log(`  ${c.bold}Installed Components${c.reset}\n`);
+
+  if (installed) {
+    console.log(`  ${c.dim}Version:${c.reset} ${c.cyan}${installed.version}${c.reset}`);
+    console.log(`  ${c.dim}Installed:${c.reset} ${new Date(installed.installedAt).toLocaleDateString()}`);
+    if (pkg && isNewer(pkg.version, installed.version)) {
+      console.log(`  ${c.yellow}${c.bold}Update available: v${pkg.version}${c.reset}`);
+      console.log(`  ${c.dim}Run${c.reset} npx clauderc update`);
+    }
+    console.log();
+  }
+
+  const components = [
+    { name: 'Agents', path: join(CLAUDE_DIR, 'agents') },
+    { name: 'Skills', path: join(CLAUDE_DIR, 'skills') },
+    { name: 'Commands', path: join(CLAUDE_DIR, 'commands') },
+    { name: 'Templates', path: join(CLAUDE_DIR, 'templates') },
+  ];
+
+  for (const comp of components) {
+    console.log(`  ${c.bold}${comp.name}${c.reset}`);
+
+    if (!existsSync(comp.path)) {
+      console.log(`    ${c.dim}(none)${c.reset}\n`);
+      continue;
+    }
+
+    const entries = readdirSync(comp.path, { withFileTypes: true });
+    let found = false;
+
+    for (const entry of entries) {
+      if (entry.name.startsWith('.')) continue;
+
+      if (entry.isDirectory() && comp.name === 'Skills') {
+        const skillFile = join(comp.path, entry.name, 'SKILL.md');
+        if (existsSync(skillFile)) {
+          console.log(`    ${c.green}●${c.reset} ${entry.name}`);
+          found = true;
+        }
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+        console.log(`    ${c.green}●${c.reset} ${entry.name.replace('.md', '')}`);
+        found = true;
+      } else if (entry.isDirectory()) {
+        console.log(`    ${c.green}●${c.reset} ${entry.name}/`);
+        found = true;
+      }
+    }
+
+    if (!found) {
+      console.log(`    ${c.dim}(none)${c.reset}`);
+    }
+    console.log();
+  }
+
+  showFooter();
+}
+
+function init(options = {}) {
+  const { force = false, dryRun = false } = options;
+
+  banner();
+
+  const pkg = loadPackageManifest();
+  if (!pkg) {
+    log.error('Package manifest not found');
+    process.exit(1);
+  }
+
+  const installed = loadInstalledManifest();
+
+  console.log(`  ${c.bold}Installing Claude Code Setup${c.reset}\n`);
+  console.log(`  ${c.dim}Version:${c.reset}  ${c.cyan}v${pkg.version}${c.reset}`);
+  console.log(`  ${c.dim}Path:${c.reset}     ${c.cyan}${displayPath(CLAUDE_DIR)}${c.reset}`);
+  if (installed) {
+    console.log(`  ${c.dim}Previous:${c.reset} v${installed.version}`);
+  }
+  console.log();
+
+  if (dryRun) {
+    console.log(`  ${c.yellow}${c.bold}DRY RUN${c.reset} - No files will be modified\n`);
+  }
+
+  // Create base directories
+  const dirs = ['agents', 'skills', 'commands', 'templates'];
+  for (const dir of dirs) {
+    ensureDir(join(CLAUDE_DIR, dir));
+  }
+
+  let created = 0, updated = 0, skipped = 0;
+  const newManifest = {
+    version: pkg.version,
+    installedAt: new Date().toISOString(),
+    files: {}
+  };
+
+  console.log(`  ${c.bold}Files${c.reset}\n`);
+
+  for (const [fileKey, fileMeta] of Object.entries(pkg.files)) {
+    const srcPath = getSourcePath(fileKey);
+    const destPath = getDestPath(fileKey);
+    const displayDest = displayPath(destPath);
+
+    if (!existsSync(srcPath)) {
+      continue;
+    }
+
+    const destExists = existsSync(destPath);
+    const installedVersion = installed?.files?.[fileKey]?.version;
+    const needsUpdate = !installedVersion || isNewer(fileMeta.version, installedVersion);
+
+    if (!destExists) {
+      copyFile(srcPath, destPath, { dryRun });
+      log.add(`${displayDest}`);
+      created++;
+    } else if (force || needsUpdate) {
+      copyFile(srcPath, destPath, { backup: true, dryRun });
+      log.update(`${displayDest}`);
+      updated++;
+    } else {
+      log.warn(`${displayDest} ${c.dim}(up to date)${c.reset}`);
+      skipped++;
+    }
+
+    newManifest.files[fileKey] = {
+      version: fileMeta.version,
+      installedAt: new Date().toISOString()
+    };
+  }
+
+  if (!dryRun) {
+    saveInstalledManifest(newManifest);
+  }
+
+  console.log();
+  showSuccessBanner({ created, updated, skipped });
+
+  if (skipped > 0 && !force) {
+    console.log(`  ${c.dim}Tip: Use${c.reset} --force ${c.dim}to overwrite existing files${c.reset}\n`);
+  }
+
+  showFooter();
+}
+
+function update(options = {}) {
+  const { dryRun = false } = options;
+
+  banner();
+
+  const pkg = loadPackageManifest();
+  if (!pkg) {
+    log.error('Package manifest not found');
+    process.exit(1);
+  }
+
+  const installed = loadInstalledManifest();
+
+  if (!installed) {
+    console.log(`  ${c.yellow}No installation found. Running init...${c.reset}\n`);
+    return init(options);
+  }
+
+  console.log(`  ${c.bold}Updating Claude Code Setup${c.reset}\n`);
+  console.log(`  ${c.dim}Current:${c.reset} v${installed.version}`);
+  console.log(`  ${c.dim}Latest:${c.reset}  v${pkg.version}`);
+  console.log();
+
+  if (!isNewer(pkg.version, installed.version)) {
+    console.log(`  ${c.green}${c.bold}✓ Already up to date!${c.reset}\n`);
+    showFooter();
+    return;
+  }
+
+  if (dryRun) {
+    console.log(`  ${c.yellow}${c.bold}DRY RUN${c.reset} - No files will be modified\n`);
+  }
+
+  // Show changelog
+  const relevantChanges = pkg.changelog?.filter(ch => isNewer(ch.version, installed.version)) || [];
+  if (relevantChanges.length > 0) {
+    console.log(`  ${c.bold}What's New${c.reset}\n`);
+    for (const change of relevantChanges) {
+      console.log(`  ${c.cyan}v${change.version}${c.reset} ${c.dim}(${change.date})${c.reset}`);
+      if (change.changes.added?.length) {
+        change.changes.added.forEach(a => console.log(`    ${c.green}+${c.reset} ${a}`));
+      }
+      if (change.changes.changed?.length) {
+        change.changes.changed.forEach(ch => console.log(`    ${c.cyan}~${c.reset} ${ch}`));
+      }
+      if (change.changes.removed?.length) {
+        change.changes.removed.forEach(r => console.log(`    ${c.red}-${c.reset} ${r}`));
+      }
+    }
+    console.log();
+  }
+
+  // Calculate changes
+  const installedFiles = new Set(Object.keys(installed.files || {}));
+  const packageFiles = new Set(Object.keys(pkg.files));
+
+  const toAdd = [...packageFiles].filter(f => !installedFiles.has(f));
+  const toRemove = [...installedFiles].filter(f => !packageFiles.has(f));
+  const toUpdate = [...packageFiles].filter(f => {
+    if (!installedFiles.has(f)) return false;
+    return isNewer(pkg.files[f]?.version, installed.files[f]?.version);
+  });
+
+  console.log(`  ${c.bold}Files${c.reset}\n`);
+
+  let added = 0, updated = 0, removed = 0;
+  const newManifest = {
+    version: pkg.version,
+    installedAt: new Date().toISOString(),
+    updatedFrom: installed.version,
+    files: {}
+  };
+
+  // Add new files
+  for (const fileKey of toAdd) {
+    const srcPath = getSourcePath(fileKey);
+    const destPath = getDestPath(fileKey);
+    if (!existsSync(srcPath)) continue;
+
+    copyFile(srcPath, destPath, { dryRun });
+    log.add(`${displayPath(destPath)}`);
+    added++;
+    newManifest.files[fileKey] = { version: pkg.files[fileKey].version, installedAt: new Date().toISOString() };
+  }
+
+  // Update changed files
+  for (const fileKey of toUpdate) {
+    const srcPath = getSourcePath(fileKey);
+    const destPath = getDestPath(fileKey);
+    if (!existsSync(srcPath)) continue;
+
+    const backupPath = copyFile(srcPath, destPath, { backup: true, dryRun });
+    log.update(`${displayPath(destPath)}`);
+    if (backupPath) {
+      console.log(`         ${c.dim}backup: ${displayPath(backupPath)}${c.reset}`);
+    }
+    updated++;
+    newManifest.files[fileKey] = {
+      version: pkg.files[fileKey].version,
+      installedAt: new Date().toISOString(),
+      updatedFrom: installed.files[fileKey]?.version
+    };
+  }
+
+  // Keep unchanged files
+  for (const fileKey of packageFiles) {
+    if (!toAdd.includes(fileKey) && !toUpdate.includes(fileKey)) {
+      newManifest.files[fileKey] = installed.files[fileKey];
+    }
+  }
+
+  // Note deprecated files
+  for (const fileKey of toRemove) {
+    log.remove(`${fileKey} ${c.dim}(deprecated - delete manually if not needed)${c.reset}`);
+    removed++;
+  }
+
+  if (!dryRun) {
+    saveInstalledManifest(newManifest);
+  }
+
+  console.log();
+  showSuccessBanner({ created: added, updated, skipped: 0 });
+
+  if (removed > 0) {
+    console.log(`  ${c.yellow}Note:${c.reset} ${removed} file(s) deprecated. Delete manually if not needed.\n`);
+  }
+
+  showFooter();
+}
+
+function showChangelog() {
+  banner();
+
+  const pkg = loadPackageManifest();
+  if (!pkg?.changelog) {
+    log.error('Changelog not found');
+    return;
+  }
+
+  const installed = loadInstalledManifest();
+
+  console.log(`  ${c.bold}Changelog${c.reset}\n`);
+
+  for (const change of pkg.changelog) {
+    const isCurrent = installed?.version === change.version;
+    const marker = isCurrent ? ` ${c.green}● installed${c.reset}` : '';
+
+    console.log(`  ${c.cyan}${c.bold}v${change.version}${c.reset}${marker} ${c.dim}(${change.date})${c.reset}`);
+
+    if (change.changes.added?.length) {
+      change.changes.added.forEach(a => console.log(`    ${c.green}+${c.reset} ${a}`));
+    }
+    if (change.changes.changed?.length) {
+      change.changes.changed.forEach(ch => console.log(`    ${c.cyan}~${c.reset} ${ch}`));
+    }
+    if (change.changes.removed?.length) {
+      change.changes.removed.forEach(r => console.log(`    ${c.red}-${c.reset} ${r}`));
+    }
+    if (change.changes.deprecated?.length) {
+      change.changes.deprecated.forEach(d => console.log(`    ${c.yellow}!${c.reset} ${d}`));
+    }
+    console.log();
+  }
+
+  showFooter();
+}
+
+// ============================================================
+// PROJECT COMMAND - Setup .claude/ in current project
+// ============================================================
+
+import { STACKS, MONOREPO_TOOLS, CI_PLATFORMS } from '../src/stacks.js';
+import { detectStack, generateCommands } from '../src/detector.js';
+
+function createPrompt() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return {
+    ask: (q) => new Promise(r => rl.question(q, a => r(a.trim()))),
+    confirm: async (q) => {
+      const a = await new Promise(r => rl.question(`${q} (Y/n): `, r));
+      return a.toLowerCase() !== 'n';
+    },
+    close: () => rl.close(),
+  };
+}
+
+function generateClaudeMd(config) {
+  const { projectName, stack, commands, customRules } = config;
+  let content = `# ${projectName}\n\n## Stack\n`;
+
+  if (stack.stacks.length > 0) content += `- **Language**: ${stack.stacks.map(s => s.name).join(', ')}\n`;
+  if (stack.framework) content += `- **Framework**: ${stack.framework.name}\n`;
+  if (stack.packageManager) content += `- **Package Manager**: ${stack.packageManager.name}\n`;
+  if (stack.monorepo) content += `- **Monorepo**: ${stack.monorepo.name}\n`;
+
+  content += `\n## Commands\n\n\`\`\`bash\n`;
+  if (commands.setup) content += `# Setup\n${commands.setup}\n\n`;
+  if (commands.dev) content += `# Development\n${commands.dev}\n\n`;
+  if (commands.test) content += `# Test\n${commands.test}\n\n`;
+  if (commands.lint) content += `# Lint\n${commands.lint}\n\n`;
+  if (commands.build) content += `# Build\n${commands.build}\n\n`;
+  if (commands.verify) content += `# Full verification\n${commands.verify}\n`;
+  content += `\`\`\`\n\n`;
+
+  content += `## Workflow\n\n### Plan Mode\nUse Plan Mode (Shift+Tab 2x) for:\n- Refactoring > 3 files\n- New feature implementation\n- Architecture changes\n\n`;
+  content += `### Verification\n- ALWAYS run tests before committing\n- NEVER skip tests without explicit approval\n`;
+
+  if (customRules?.length > 0) {
+    content += `\n## Project Rules\n\n${customRules.map(r => `- ${r}`).join('\n')}\n`;
+  }
+
+  content += `\n## Documentation\n@README.md\n`;
+  return content;
+}
+
+function generateProjectSettings(config) {
+  const { stack, commands } = config;
+  const pm = stack.packageManager?.name || 'npm';
+  const allowedCommands = ['Bash(git:*)', 'Bash(gh:*)'];
+
+  // Add package manager
+  const pmCommands = { bun: 'bun', pnpm: 'pnpm', yarn: 'yarn', npm: 'npm', poetry: 'poetry', cargo: 'cargo' };
+  if (pmCommands[pm]) allowedCommands.push(`Bash(${pmCommands[pm]}:*)`);
+
+  // Add stack-specific
+  const stackId = stack.stacks[0]?.id;
+  const stackCommands = {
+    go: ['go', 'golangci-lint'],
+    rust: ['cargo'],
+    python: ['pytest', 'ruff', 'mypy', 'python'],
+    dotnet: ['dotnet'],
+    elixir: ['mix'],
+    ruby: ['bundle', 'rails'],
+    php: ['composer', 'php'],
+    java: ['mvn', 'gradle'],
+  };
+  (stackCommands[stackId] || []).forEach(cmd => allowedCommands.push(`Bash(${cmd}:*)`));
+
+  const settings = { permissions: { allow: allowedCommands } };
+
+  if (commands.format || commands.lint) {
+    settings.hooks = {
+      PostToolUse: [{
+        matcher: 'Edit|Write',
+        hooks: [{ type: 'command', command: `${commands.format || commands.lint} || true` }],
+      }],
+    };
+  }
+
+  return settings;
+}
+
+function generateCommandFile(name, commands, stackName) {
+  const templates = {
+    test: `# Run tests\n\n\`\`\`bash\n${commands.test || '# Configure test command'}\n\`\`\``,
+    lint: `# Lint code\n\n\`\`\`bash\n${commands.lint || '# Configure lint command'}\n\`\`\``,
+    verify: `# Full verification\n\nRuns lint, test, and build.\n\n\`\`\`bash\n${commands.verify || '# Configure verify command'}\n\`\`\``,
+    setup: `# Setup project\n\n\`\`\`bash\n${commands.setup || '# Configure setup command'}\n\`\`\``,
+    pr: `# Create Pull Request\n\n1. Run /verify\n2. Commit changes\n3. Push to remote\n4. Create PR with \`gh pr create\``,
+  };
+  return templates[name] || '';
+}
+
+async function projectSetup(options = {}) {
+  const { dryRun = false } = options;
+  const projectPath = process.cwd();
+  const projectName = basename(projectPath);
+
+  banner();
+  console.log(`  ${c.bold}Project Setup Wizard${c.reset}\n`);
+  console.log(`  ${c.dim}Project:${c.reset} ${c.cyan}${projectName}${c.reset}`);
+  console.log(`  ${c.dim}Path:${c.reset}    ${projectPath}\n`);
+
+  console.log(`  ${c.bold}Analyzing...${c.reset}\n`);
+
+  const stack = detectStack(projectPath);
+  const commands = generateCommands(stack);
+
+  // Show detection
+  console.log(`  ${c.bold}Detected Stack${c.reset}\n`);
+  if (stack.stacks.length > 0) {
+    console.log(`    Language:        ${c.green}${stack.stacks.map(s => s.name).join(', ')}${c.reset}`);
+  } else {
+    console.log(`    Language:        ${c.yellow}Not detected${c.reset}`);
+  }
+  if (stack.framework) console.log(`    Framework:       ${c.green}${stack.framework.name}${c.reset}`);
+  if (stack.packageManager) console.log(`    Package Manager: ${c.green}${stack.packageManager.name}${c.reset}`);
+  if (stack.monorepo) console.log(`    Monorepo:        ${c.green}${stack.monorepo.name}${c.reset}`);
+  if (stack.ci) console.log(`    CI/CD:           ${c.green}${stack.ci.name}${c.reset}`);
+
+  console.log(`\n  ${c.bold}Generated Commands${c.reset}\n`);
+  if (commands.setup) console.log(`    ${c.dim}setup:${c.reset}  ${commands.setup}`);
+  if (commands.dev) console.log(`    ${c.dim}dev:${c.reset}    ${commands.dev}`);
+  if (commands.test) console.log(`    ${c.dim}test:${c.reset}   ${commands.test}`);
+  if (commands.lint) console.log(`    ${c.dim}lint:${c.reset}   ${commands.lint}`);
+  if (commands.build) console.log(`    ${c.dim}build:${c.reset}  ${commands.build}`);
+
+  const prompt = createPrompt();
+
+  try {
+    console.log('');
+    const confirmed = await prompt.confirm('  Proceed with this configuration?');
+
+    if (!confirmed) {
+      console.log(`\n  ${c.yellow}Setup cancelled.${c.reset}\n`);
+      prompt.close();
+      return;
+    }
+
+    // Custom rules
+    console.log(`\n  ${c.dim}Add project-specific rules (empty to skip):${c.reset}\n`);
+    const customRules = [];
+    let rule = await prompt.ask('    Rule: ');
+    while (rule) {
+      customRules.push(rule);
+      rule = await prompt.ask('    Rule: ');
+    }
+
+    prompt.close();
+
+    const config = { projectName, stack, commands, customRules };
+    const claudeDir = join(projectPath, '.claude');
+
+    if (dryRun) {
+      console.log(`\n  ${c.yellow}DRY RUN${c.reset} - Would create:\n`);
+      console.log('    CLAUDE.md');
+      console.log('    .claude/settings.json');
+      console.log('    .claude/commands/test.md');
+      console.log('    .claude/commands/lint.md');
+      console.log('    .claude/commands/verify.md');
+      console.log('    .claude/commands/setup.md');
+      console.log('    .claude/commands/pr.md\n');
+      return;
+    }
+
+    // Create files
+    mkdirSync(join(claudeDir, 'commands'), { recursive: true });
+
+    const stackName = stack.stacks[0]?.name || 'Project';
+    const files = [
+      { path: 'CLAUDE.md', content: generateClaudeMd(config) },
+      { path: '.claude/settings.json', content: JSON.stringify(generateProjectSettings(config), null, 2) },
+      { path: '.claude/commands/test.md', content: generateCommandFile('test', commands, stackName) },
+      { path: '.claude/commands/lint.md', content: generateCommandFile('lint', commands, stackName) },
+      { path: '.claude/commands/verify.md', content: generateCommandFile('verify', commands, stackName) },
+      { path: '.claude/commands/setup.md', content: generateCommandFile('setup', commands, stackName) },
+      { path: '.claude/commands/pr.md', content: generateCommandFile('pr', commands, stackName) },
+    ];
+
+    console.log(`\n  ${c.bold}Creating files${c.reset}\n`);
+    for (const file of files) {
+      writeFileSync(join(projectPath, file.path), file.content);
+      console.log(`    ${c.green}+${c.reset} ${file.path}`);
+    }
+
+    console.log(`
+  ${c.green}${c.bold}╔═══════════════════════════════════════════════════════════╗${c.reset}
+  ${c.green}${c.bold}║${c.reset}                                                           ${c.green}${c.bold}║${c.reset}
+  ${c.green}${c.bold}║${c.reset}   ${c.green}${c.bold}✓ Project Setup Complete!${c.reset}                              ${c.green}${c.bold}║${c.reset}
+  ${c.green}${c.bold}║${c.reset}                                                           ${c.green}${c.bold}║${c.reset}
+  ${c.green}${c.bold}╚═══════════════════════════════════════════════════════════╝${c.reset}
+
+  ${c.bold}Next steps:${c.reset}
+
+    1. Review ${c.cyan}CLAUDE.md${c.reset} and adjust as needed
+    2. Commit ${c.cyan}.claude/${c.reset} to your repository
+    3. Use ${c.cyan}/test${c.reset}, ${c.cyan}/lint${c.reset}, ${c.cyan}/verify${c.reset} in Claude Code
+
+`);
+    showFooter();
+
+  } catch (error) {
+    prompt.close();
+    throw error;
+  }
+}
+
+function showHelp() {
+  banner();
+
+  console.log(`  ${c.bold}Usage${c.reset}
+
+    npx clauderc ${c.cyan}<command>${c.reset} [options]
+
+  ${c.bold}Commands${c.reset}
+
+    ${c.cyan}init${c.reset}        Install global components (~/.claude/)
+    ${c.cyan}project${c.reset}     Setup current project (.claude/ + CLAUDE.md)
+    ${c.cyan}update${c.reset}      Update global components to latest version
+    ${c.cyan}list${c.reset}        Show installed components
+    ${c.cyan}changelog${c.reset}   Show version history
+    ${c.cyan}help${c.reset}        Show this message
+
+  ${c.bold}Options${c.reset}
+
+    ${c.yellow}--force, -f${c.reset}   Overwrite all files
+    ${c.yellow}--dry-run${c.reset}     Preview changes without applying
+
+  ${c.bold}Examples${c.reset}
+
+    ${c.dim}# First time global setup${c.reset}
+    npx clauderc init
+
+    ${c.dim}# Setup current project (interactive)${c.reset}
+    npx clauderc project
+
+    ${c.dim}# Update global components${c.reset}
+    npx clauderc update
+
+  ${c.bold}Two-Level Setup${c.reset}
+
+    ${c.cyan}Global (~/.claude/)${c.reset}
+    ├── agents/         ${c.dim}# Reusable agents${c.reset}
+    ├── skills/         ${c.dim}# Reusable skills${c.reset}
+    ├── commands/       ${c.dim}# Default commands${c.reset}
+    └── templates/      ${c.dim}# Templates for project setup${c.reset}
+
+    ${c.cyan}Project (.claude/)${c.reset}
+    ├── commands/       ${c.dim}# Project-specific commands${c.reset}
+    ├── settings.json   ${c.dim}# Permissions & hooks${c.reset}
+    └── CLAUDE.md       ${c.dim}# Project context for Claude${c.reset}
+
+  ${c.bold}Supported Stacks${c.reset}
+
+    Node.js/TypeScript, Python, Go, Rust, Java/Kotlin,
+    PHP, Ruby, C#/.NET, Elixir, Swift, Dart/Flutter
+
+`);
+  showFooter();
+}
+
+// Check Node.js version
+const nodeVersion = process.versions.node.split('.').map(Number);
+if (nodeVersion[0] < 16 || (nodeVersion[0] === 16 && nodeVersion[1] < 7)) {
+  console.error(`\n  ${c.red}Error:${c.reset} Node.js 16.7+ required (you have ${process.versions.node})\n`);
+  process.exit(1);
+}
+
+// Parse arguments
+const args = process.argv.slice(2);
+const command = args.find(a => !a.startsWith('-')) || 'help';
+const flags = {
+  force: args.includes('--force') || args.includes('-f'),
+  dryRun: args.includes('--dry-run'),
+};
+
+switch (command) {
+  case 'init':
+  case 'install':
+    init({ force: flags.force, dryRun: flags.dryRun });
+    break;
+  case 'project':
+  case 'setup':
+    projectSetup({ dryRun: flags.dryRun });
+    break;
+  case 'update':
+  case 'upgrade':
+    update({ dryRun: flags.dryRun });
+    break;
+  case 'list':
+  case 'ls':
+    listInstalled();
+    break;
+  case 'changelog':
+  case 'changes':
+    showChangelog();
+    break;
+  case 'help':
+  case '--help':
+  case '-h':
+  default:
+    showHelp();
+    break;
+}