claude-code-starter 0.14.1 → 0.16.0

package/dist/cli.js

@@ -2,19 +2,19 @@
 
 // src/cli.ts
 import { execSync, spawn } from "child_process";
-import fs3 from "fs";
-import path3 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import { fileURLToPath } from "url";
 import ora from "ora";
-import pc from "picocolors";
-import prompts from "prompts";
+import pc2 from "picocolors";
+import prompts2 from "prompts";
 
 // src/analyzer.ts
 import fs from "fs";
 import path from "path";
 function analyzeRepository(rootDir) {
   const techStack = detectTechStack(rootDir);
-  const fileCount = countSourceFiles(rootDir, techStack.languages);
+  const fileCount = countSourceFiles(rootDir);
   const packageJson = readPackageJson(rootDir);
   return {
     isExisting: fileCount > 0,
@@ -37,7 +37,7 @@ function detectTechStack(rootDir) {
   const linter = detectLinter(packageJson, files);
   const formatter = detectFormatter(packageJson, files);
   const bundler = detectBundler(packageJson, files);
-  const isMonorepo = detectMonorepo(rootDir, files, packageJson);
+  const isMonorepo = detectMonorepo(files, packageJson);
   const hasDocker = files.includes("Dockerfile") || files.includes("docker-compose.yml") || files.includes("docker-compose.yaml");
   const { hasCICD, cicdPlatform } = detectCICD(rootDir, files);
   const { hasClaudeConfig, existingClaudeFiles } = detectExistingClaudeConfig(rootDir);
@@ -59,6 +59,12 @@ function detectTechStack(rootDir) {
     existingClaudeFiles
   };
 }
+function getAllDeps(packageJson) {
+  return {
+    ...packageJson.dependencies || {},
+    ...packageJson.devDependencies || {}
+  };
+}
 function readPackageJson(rootDir) {
   const packageJsonPath = path.join(rootDir, "package.json");
   if (!fs.existsSync(packageJsonPath)) return null;
@@ -271,10 +277,7 @@ function detectPackageManager(files) {
 }
 function detectTestingFramework(packageJson, files) {
   if (packageJson) {
-    const allDeps = {
-      ...packageJson.dependencies || {},
-      ...packageJson.devDependencies || {}
-    };
+    const allDeps = getAllDeps(packageJson);
     if (allDeps.vitest) return "vitest";
     if (allDeps.jest) return "jest";
     if (allDeps.mocha) return "mocha";
@@ -286,7 +289,8 @@ function detectTestingFramework(packageJson, files) {
   if (files.includes("pytest.ini") || files.includes("conftest.py")) return "pytest";
   if (files.includes("go.mod")) return "go-test";
   if (files.includes("Cargo.toml")) return "rust-test";
-  if (files.includes("Gemfile")) return "rspec";
+  if (files.includes(".rspec")) return "rspec";
+  if (files.includes("Gemfile") && files.includes("spec")) return "rspec";
   return null;
 }
 function detectLinter(packageJson, files) {
@@ -297,10 +301,7 @@ function detectLinter(packageJson, files) {
   }
   if (files.includes("biome.json") || files.includes("biome.jsonc")) return "biome";
   if (packageJson) {
-    const allDeps = {
-      ...packageJson.dependencies || {},
-      ...packageJson.devDependencies || {}
-    };
+    const allDeps = getAllDeps(packageJson);
     if (allDeps.eslint) return "eslint";
     if (allDeps["@biomejs/biome"]) return "biome";
   }
@@ -316,16 +317,12 @@ function detectFormatter(packageJson, files) {
   }
   if (files.includes("biome.json") || files.includes("biome.jsonc")) return "biome";
   if (packageJson) {
-    const allDeps = {
-      ...packageJson.dependencies || {},
-      ...packageJson.devDependencies || {}
-    };
+    const allDeps = getAllDeps(packageJson);
     if (allDeps.prettier) return "prettier";
     if (allDeps["@biomejs/biome"]) return "biome";
   }
-  if (files.includes("pyproject.toml")) {
-    return "black";
-  }
+  if (files.includes("ruff.toml") || files.includes(".ruff.toml")) return "ruff";
+  if (files.includes("pyproject.toml")) return "black";
   return null;
 }
 function detectBundler(packageJson, files) {
@@ -335,10 +332,7 @@ function detectBundler(packageJson, files) {
   if (files.some((f) => f.startsWith("rollup.config"))) return "rollup";
   if (files.some((f) => f.startsWith("esbuild"))) return "esbuild";
   if (packageJson) {
-    const allDeps = {
-      ...packageJson.dependencies || {},
-      ...packageJson.devDependencies || {}
-    };
+    const allDeps = getAllDeps(packageJson);
     if (allDeps.vite) return "vite";
     if (allDeps.webpack) return "webpack";
     if (allDeps.tsup) return "tsup";
@@ -350,16 +344,12 @@ function detectBundler(packageJson, files) {
   }
   return null;
 }
-function detectMonorepo(rootDir, files, packageJson) {
+function detectMonorepo(files, packageJson) {
   if (files.includes("pnpm-workspace.yaml")) return true;
   if (files.includes("lerna.json")) return true;
   if (files.includes("nx.json")) return true;
   if (files.includes("turbo.json")) return true;
   if (packageJson?.workspaces) return true;
-  const packagesDir = path.join(rootDir, "packages");
-  const appsDir = path.join(rootDir, "apps");
-  if (fs.existsSync(packagesDir) && fs.statSync(packagesDir).isDirectory()) return true;
-  if (fs.existsSync(appsDir) && fs.statSync(appsDir).isDirectory()) return true;
   return false;
 }
 function detectCICD(rootDir, files) {
@@ -435,7 +425,7 @@ function listSourceFilesShallow(rootDir, extensions) {
   scan(rootDir, 0);
   return files;
 }
-function countSourceFiles(rootDir, _languages) {
+function countSourceFiles(rootDir) {
   const extensions = [
     // JavaScript/TypeScript
     ".js",
@@ -512,13 +502,518 @@ function countSourceFiles(rootDir, _languages) {
   return count;
 }
 
-// src/generator.ts
+// src/extras.ts
+import pc from "picocolors";
+import prompts from "prompts";
+
+// src/hooks.ts
 import fs2 from "fs";
 import path2 from "path";
+var HOOK_SCRIPT = String.raw`#!/usr/bin/env node
+/**
+ * Block Dangerous Commands - PreToolUse Hook for Bash
+ * Blocks dangerous patterns before execution.
+ *
+ * SAFETY_LEVEL: 'critical' | 'high' | 'strict'
+ *   critical - Only catastrophic: rm -rf ~, dd to disk, fork bombs
+ *   high     - + risky: force push main, secrets exposure, git reset --hard
+ *   strict   - + cautionary: any force push, sudo rm, docker prune
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const SAFETY_LEVEL = 'high';
+
+const PATTERNS = [
+  // CRITICAL — Catastrophic, unrecoverable
+
+  // Filesystem destruction
+  { level: 'critical', id: 'rm-home',          regex: /\brm\s+(-.+\s+)*["']?~\/?["']?(\s|$|[;&|])/,                        reason: 'rm targeting home directory' },
+  { level: 'critical', id: 'rm-home-var',      regex: /\brm\s+(-.+\s+)*["']?\$HOME["']?(\s|$|[;&|])/,                      reason: 'rm targeting $HOME' },
+  { level: 'critical', id: 'rm-home-trailing', regex: /\brm\s+.+\s+["']?(~\/?|\$HOME)["']?(\s*$|[;&|])/,                   reason: 'rm with trailing ~/ or $HOME' },
+  { level: 'critical', id: 'rm-root',          regex: /\brm\s+(-.+\s+)*\/(\*|\s|$|[;&|])/,                                 reason: 'rm targeting root filesystem' },
+  { level: 'critical', id: 'rm-system',        regex: /\brm\s+(-.+\s+)*\/(etc|usr|var|bin|sbin|lib|boot|dev|proc|sys)(\/|\s|$)/, reason: 'rm targeting system directory' },
+  { level: 'critical', id: 'rm-cwd',           regex: /\brm\s+(-.+\s+)*(\.\/?|\*|\.\/\*)(\s|$|[;&|])/,                     reason: 'rm deleting current directory contents' },
+
+  // Disk operations
+  { level: 'critical', id: 'dd-disk',          regex: /\bdd\b.+of=\/dev\/(sd[a-z]|nvme|hd[a-z]|vd[a-z]|xvd[a-z])/,         reason: 'dd writing to disk device' },
+  { level: 'critical', id: 'mkfs',             regex: /\bmkfs(\.\w+)?\s+\/dev\/(sd[a-z]|nvme|hd[a-z]|vd[a-z])/,            reason: 'mkfs formatting disk' },
+  { level: 'critical', id: 'fdisk',            regex: /\b(fdisk|wipefs|parted)\s+\/dev\//,                                   reason: 'disk partitioning/wiping operation' },
+
+  // Shell exploits
+  { level: 'critical', id: 'fork-bomb',        regex: /:\(\)\s*\{.*:\s*\|\s*:.*&/,                                         reason: 'fork bomb detected' },
+
+  // Git — history destruction
+  { level: 'critical', id: 'git-filter',       regex: /\bgit\s+(filter-branch|filter-repo)\b/,                              reason: 'git history rewriting blocked' },
+  { level: 'critical', id: 'git-reflog-exp',   regex: /\bgit\s+(reflog\s+expire|gc\s+--prune|prune)\b/,                     reason: 'removes git recovery safety net' },
+
+  // HIGH — Significant risk, data loss, security exposure
+
+  // Remote code execution
+  { level: 'high', id: 'curl-pipe-sh',         regex: /\b(curl|wget)\b.+\|\s*(ba)?sh\b/,                                   reason: 'piping URL to shell (RCE risk)' },
+
+  // Git — destructive operations
+  { level: 'high', id: 'git-force-main',       regex: /\bgit\s+push\b(?!.+--force-with-lease).+(--force|-f)\b.+\b(main|master)\b/, reason: 'force push to main/master' },
+  { level: 'high', id: 'git-reset-hard',       regex: /\bgit\s+reset\s+--hard/,                                            reason: 'git reset --hard loses uncommitted work' },
+  { level: 'high', id: 'git-clean-f',          regex: /\bgit\s+clean\s+(-\w*f|-f)/,                                        reason: 'git clean -f deletes untracked files' },
+  { level: 'high', id: 'git-no-verify',        regex: /\bgit\b.+--no-verify/,                                              reason: '--no-verify skips safety hooks' },
+  { level: 'high', id: 'git-stash-destruct',   regex: /\bgit\s+stash\s+(drop|clear|pop)\b/,                                reason: 'destructive git stash operation' },
+  { level: 'high', id: 'git-branch-D',         regex: /\bgit\s+branch\s+(-D|--delete\s+--force)\b/,                        reason: 'git branch -D force-deletes branch' },
+  { level: 'high', id: 'git-checkout-force',   regex: /\bgit\s+checkout\s+(-f|--\s+\.)/,                                   reason: 'git checkout -f/-- . discards changes' },
+  { level: 'high', id: 'git-restore-destruct', regex: /\bgit\s+restore\s+(--staged\s+--worktree|\.)/,                      reason: 'git restore discards changes' },
+  { level: 'high', id: 'git-update-ref',       regex: /\bgit\s+(update-ref|symbolic-ref|replace)\b/,                       reason: 'git ref manipulation blocked' },
+  { level: 'high', id: 'git-config-global',    regex: /\bgit\s+config\s+--(global|system)\b/,                              reason: 'git global/system config blocked' },
+  { level: 'high', id: 'git-tag-delete',       regex: /\bgit\s+tag\s+(-d|--delete)\b/,                                    reason: 'git tag deletion blocked' },
+
+  // Git — write operations (user handles manually)
+  { level: 'high', id: 'git-push',             regex: /\bgit\s+push\b/,                                                    reason: 'git push blocked — user handles manually' },
+  { level: 'high', id: 'git-pull',             regex: /\bgit\s+pull\b/,                                                    reason: 'git pull blocked — user handles manually' },
+  { level: 'high', id: 'git-fetch',            regex: /\bgit\s+fetch\b/,                                                   reason: 'git fetch blocked — user handles manually' },
+  { level: 'high', id: 'git-clone',            regex: /\bgit\s+clone\b/,                                                   reason: 'git clone blocked — user handles manually' },
+  { level: 'high', id: 'git-add',              regex: /\bgit\s+(add|stage)\b/,                                             reason: 'git add/stage blocked — user handles manually' },
+  { level: 'high', id: 'git-commit',           regex: /\bgit\s+commit\b/,                                                  reason: 'git commit blocked — user handles manually' },
+  { level: 'high', id: 'git-merge',            regex: /\bgit\s+merge\b/,                                                   reason: 'git merge blocked — user handles manually' },
+  { level: 'high', id: 'git-rebase',           regex: /\bgit\s+rebase\b/,                                                  reason: 'git rebase blocked — user handles manually' },
+  { level: 'high', id: 'git-reset',            regex: /\bgit\s+reset\b/,                                                   reason: 'git reset blocked — user handles manually' },
+  { level: 'high', id: 'git-remote-mod',       regex: /\bgit\s+remote\s+(add|set-url|remove)\b/,                           reason: 'git remote modification blocked' },
+  { level: 'high', id: 'git-submodule',        regex: /\bgit\s+submodule\s+(add|update)\b/,                                reason: 'git submodule operation blocked' },
+
+  // Credentials & secrets
+  { level: 'high', id: 'chmod-777',            regex: /\bchmod\b.+\b777\b/,                                                reason: 'chmod 777 is a security risk' },
+  { level: 'high', id: 'cat-env',              regex: /\b(cat|less|head|tail|more)\s+\.env\b/,                             reason: 'reading .env file exposes secrets' },
+  { level: 'high', id: 'cat-secrets',          regex: /\b(cat|less|head|tail|more)\b.+(credentials|secrets?|\.pem|\.key|id_rsa|id_ed25519)/i, reason: 'reading secrets file' },
+  { level: 'high', id: 'env-dump',             regex: /\b(printenv|^env)\s*([;&|]|$)/,                                     reason: 'env dump may expose secrets' },
+  { level: 'high', id: 'echo-secret',          regex: /\becho\b.+\$\w*(SECRET|KEY|TOKEN|PASSWORD|API_|PRIVATE)/i,          reason: 'echoing secret variable' },
+  { level: 'high', id: 'rm-ssh',               regex: /\brm\b.+\.ssh\/(id_|authorized_keys|known_hosts)/,                  reason: 'deleting SSH keys' },
+  { level: 'high', id: 'security-keychain',    regex: /\bsecurity\s+find-generic-password\b/,                              reason: 'keychain access blocked' },
+  { level: 'high', id: 'gpg-export-secret',    regex: /\bgpg\s+--export-secret-keys\b/,                                   reason: 'GPG secret key export blocked' },
+  { level: 'high', id: 'history-cmd',          regex: /\bhistory\b/,                                                       reason: 'history may expose secrets' },
+
+  // Destructive system commands
+  { level: 'high', id: 'elevated-priv',        regex: /\b(sudo|doas|pkexec)\b/,                                            reason: 'elevated privilege command blocked' },
+  { level: 'high', id: 'su-cmd',               regex: /\bsu\b/,                                                            reason: 'su (switch user) blocked' },
+  { level: 'high', id: 'chmod-R',              regex: /\bchmod\s+(-\w*R|-R)/,                                              reason: 'recursive chmod blocked' },
+  { level: 'high', id: 'chown-R',              regex: /\bchown\s+(-\w*R|-R)/,                                              reason: 'recursive chown blocked' },
+  { level: 'high', id: 'kill-all',             regex: /\bkill\s+-9\s+-1\b/,                                                reason: 'kill all processes blocked' },
+  { level: 'high', id: 'killall',              regex: /\b(killall|pkill\s+-9)\b/,                                          reason: 'mass process killing blocked' },
+  { level: 'high', id: 'truncate-zero',        regex: /\btruncate\s+-s\s*0\b/,                                             reason: 'truncating file to zero blocked' },
+  { level: 'high', id: 'empty-file',           regex: /\bcat\s+\/dev\/null\s*>/,                                           reason: 'emptying file via /dev/null blocked' },
+  { level: 'high', id: 'crontab-r',            regex: /\bcrontab\s+-r/,                                                    reason: 'removes all cron jobs' },
+
+  // Docker
+  { level: 'high', id: 'docker-vol-rm',        regex: /\bdocker\s+volume\s+(rm|prune)/,                                    reason: 'docker volume deletion loses data' },
+  { level: 'high', id: 'docker-push',          regex: /\bdocker\s+push\b/,                                                 reason: 'docker push blocked' },
+  { level: 'high', id: 'docker-rm-all',        regex: /\bdocker\s+rm\s+-f\b.+\$\(docker\s+ps/,                             reason: 'docker rm all containers blocked' },
+  { level: 'high', id: 'docker-sys-prune-a',   regex: /\bdocker\s+system\s+prune\s+-a/,                                    reason: 'docker system prune -a blocked' },
+  { level: 'high', id: 'docker-compose-destr', regex: /\bdocker[\s-]compose\s+down\s+(-v|--rmi)/,                           reason: 'docker-compose destructive down blocked' },
+
+  // Publishing & deployment
+  { level: 'high', id: 'npm-publish',          regex: /\bnpm\s+(publish|unpublish|deprecate)\b/,                            reason: 'npm publishing blocked' },
+  { level: 'high', id: 'npm-audit-force',      regex: /\bnpm\s+audit\s+fix\s+--force\b/,                                   reason: 'npm audit fix --force can break deps' },
+  { level: 'high', id: 'cargo-publish',        regex: /\bcargo\s+publish\b/,                                               reason: 'cargo publish blocked' },
+  { level: 'high', id: 'pip-twine-upload',     regex: /\b(pip|twine)\s+upload\b/,                                          reason: 'Python package upload blocked' },
+  { level: 'high', id: 'gem-push',             regex: /\bgem\s+push\b/,                                                    reason: 'gem push blocked' },
+  { level: 'high', id: 'pod-push',             regex: /\bpod\s+trunk\s+push\b/,                                            reason: 'pod trunk push blocked' },
+  { level: 'high', id: 'vercel-prod',          regex: /\bvercel\b.+--prod/,                                                reason: 'vercel production deploy blocked' },
+  { level: 'high', id: 'netlify-prod',         regex: /\bnetlify\s+deploy\b.+--prod/,                                      reason: 'netlify production deploy blocked' },
+  { level: 'high', id: 'fly-deploy',           regex: /\bfly\s+deploy\b/,                                                  reason: 'fly deploy blocked' },
+  { level: 'high', id: 'firebase-deploy',      regex: /\bfirebase\s+deploy\b/,                                             reason: 'firebase deploy blocked' },
+  { level: 'high', id: 'terraform',            regex: /\bterraform\s+(apply|destroy)\b/,                                   reason: 'terraform apply/destroy blocked' },
+  { level: 'high', id: 'pulumi-cdktf',         regex: /\b(pulumi|cdktf)\s+destroy\b/,                                      reason: 'infrastructure destroy blocked' },
+  { level: 'high', id: 'kubectl-mutate',       regex: /\bkubectl\s+(apply|delete|drain)\b/,                                reason: 'kubectl mutating operation blocked' },
+  { level: 'high', id: 'kubectl-scale-zero',   regex: /\bkubectl\s+scale\b.+--replicas=0/,                                 reason: 'kubectl scale to zero blocked' },
+  { level: 'high', id: 'helm-ops',             regex: /\bhelm\s+(install|uninstall|upgrade)\b/,                             reason: 'helm operation blocked' },
+  { level: 'high', id: 'heroku',               regex: /\bheroku\b/,                                                        reason: 'heroku command blocked' },
+  { level: 'high', id: 'eb-terminate',         regex: /\beb\s+terminate\b/,                                                reason: 'eb terminate blocked' },
+  { level: 'high', id: 'serverless-remove',    regex: /\bserverless\s+remove\b/,                                           reason: 'serverless remove blocked' },
+  { level: 'high', id: 'cap-prod-deploy',      regex: /\bcap\s+production\s+deploy\b/,                                     reason: 'production deploy blocked' },
+  { level: 'high', id: 'cloud-delete',         regex: /\b(aws\s+cloudformation\s+delete-stack|gcloud\s+projects\s+delete|az\s+group\s+delete)\b/, reason: 'cloud resource deletion blocked' },
+
+  // Network & infrastructure
+  { level: 'high', id: 'curl-mutating',        regex: /\bcurl\b.+-X\s*(POST|PUT|DELETE|PATCH)\b/,                          reason: 'mutating HTTP request blocked' },
+  { level: 'high', id: 'ssh-remote',           regex: /\bssh\s/,                                                           reason: 'SSH remote connection blocked' },
+  { level: 'high', id: 'scp-remote',           regex: /\bscp\s/,                                                           reason: 'SCP remote copy blocked' },
+  { level: 'high', id: 'rsync-delete',         regex: /\brsync\b.+--delete/,                                               reason: 'rsync --delete blocked' },
+  { level: 'high', id: 'firewall',             regex: /\b(iptables\s+-F|ufw\s+disable)\b/,                                 reason: 'firewall manipulation blocked' },
+  { level: 'high', id: 'network-kill',         regex: /\bifconfig\s+\w+\s+down\b/,                                         reason: 'network interface down blocked' },
+  { level: 'high', id: 'route-delete',         regex: /\broute\s+del\s+default\b/,                                         reason: 'default route deletion blocked' },
+
+  // Database
+  { level: 'high', id: 'sql-drop',             regex: /\b(DROP\s+(DATABASE|TABLE)|TRUNCATE\s+TABLE)\b/i,                   reason: 'SQL drop/truncate blocked' },
+  { level: 'high', id: 'sql-mass-delete',      regex: /\bDELETE\s+FROM\b.+\bWHERE\s+1\s*=\s*1/i,                          reason: 'SQL mass delete blocked' },
+  { level: 'high', id: 'redis-flush',          regex: /\bredis-cli\s+(FLUSHALL|FLUSHDB)\b/,                                reason: 'redis flush blocked' },
+  { level: 'high', id: 'orm-reset',            regex: /\b(prisma\s+migrate\s+reset|rails\s+db:(drop|reset)|django\s+flush)\b/, reason: 'ORM database reset blocked' },
+  { level: 'high', id: 'alembic-downgrade',    regex: /\balembic\s+downgrade\s+base\b/,                                    reason: 'alembic downgrade base blocked' },
+  { level: 'high', id: 'mongo-drop',           regex: /\bmongosh\b.+dropDatabase/,                                         reason: 'MongoDB drop database blocked' },
+
+  // STRICT — Cautionary, context-dependent
+  { level: 'strict', id: 'git-checkout-dot',    regex: /\bgit\s+checkout\s+\./,                                             reason: 'git checkout . discards changes' },
+  { level: 'strict', id: 'docker-prune',        regex: /\bdocker\s+(system|image)\s+prune/,                                 reason: 'docker prune removes images' },
+];
+
+const LEVELS = { critical: 1, high: 2, strict: 3 };
+const EMOJIS = { critical: '\u{1F6A8}', high: '\u26D4', strict: '\u26A0\uFE0F' };
+const LOG_DIR = path.join(process.env.HOME || '/tmp', '.claude', 'hooks-logs');
+
+function log(data) {
+  try {
+    if (!fs.existsSync(LOG_DIR)) fs.mkdirSync(LOG_DIR, { recursive: true });
+    const file = path.join(LOG_DIR, new Date().toISOString().slice(0, 10) + '.jsonl');
+    fs.appendFileSync(file, JSON.stringify({ ts: new Date().toISOString(), ...data }) + '\n');
+  } catch {}
+}
+
+function checkCommand(cmd, safetyLevel) {
+  safetyLevel = safetyLevel || SAFETY_LEVEL;
+  const threshold = LEVELS[safetyLevel] || 2;
+  for (const p of PATTERNS) {
+    if (LEVELS[p.level] <= threshold && p.regex.test(cmd)) {
+      return { blocked: true, pattern: p };
+    }
+  }
+  return { blocked: false, pattern: null };
+}
+
+async function main() {
+  let input = '';
+  for await (const chunk of process.stdin) input += chunk;
+
+  try {
+    const data = JSON.parse(input);
+    const { tool_name, tool_input, session_id, cwd, permission_mode } = data;
+    if (tool_name !== 'Bash') return console.log('{}');
+
+    const cmd = tool_input?.command || '';
+    const result = checkCommand(cmd);
+
+    if (result.blocked) {
+      const p = result.pattern;
+      log({ level: 'BLOCKED', id: p.id, priority: p.level, cmd, session_id, cwd, permission_mode });
+      return console.log(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'deny',
+          permissionDecisionReason: EMOJIS[p.level] + ' [' + p.id + '] ' + p.reason
+        }
+      }));
+    }
+    console.log('{}');
+  } catch (e) {
+    log({ level: 'ERROR', error: e.message });
+    console.log('{}');
+  }
+}
+
+if (require.main === module) {
+  main();
+} else {
+  module.exports = { PATTERNS, LEVELS, SAFETY_LEVEL, checkCommand };
+}
+`;
+function checkHookStatus(rootDir) {
+  const homeDir = process.env.HOME || "";
+  const projectScriptPath = path2.join(rootDir, ".claude", "hooks", "block-dangerous-commands.js");
+  const globalScriptPath = path2.join(homeDir, ".claude", "hooks", "block-dangerous-commands.js");
+  const result = {
+    projectInstalled: false,
+    globalInstalled: false,
+    projectMatchesOurs: false,
+    globalMatchesOurs: false
+  };
+  if (fs2.existsSync(projectScriptPath)) {
+    result.projectInstalled = true;
+    const content = fs2.readFileSync(projectScriptPath, "utf-8");
+    result.projectMatchesOurs = content.trim() === HOOK_SCRIPT.trim();
+  }
+  if (fs2.existsSync(globalScriptPath)) {
+    result.globalInstalled = true;
+    const content = fs2.readFileSync(globalScriptPath, "utf-8");
+    result.globalMatchesOurs = content.trim() === HOOK_SCRIPT.trim();
+  }
+  return result;
+}
+function installHook(rootDir) {
+  const hooksDir = path2.join(rootDir, ".claude", "hooks");
+  const hookPath = path2.join(hooksDir, "block-dangerous-commands.js");
+  const settingsPath = path2.join(rootDir, ".claude", "settings.json");
+  fs2.mkdirSync(hooksDir, { recursive: true });
+  fs2.writeFileSync(hookPath, HOOK_SCRIPT);
+  fs2.chmodSync(hookPath, 493);
+  try {
+    const existing = fs2.existsSync(settingsPath) ? JSON.parse(fs2.readFileSync(settingsPath, "utf-8")) : {};
+    const newEntry = {
+      matcher: "Bash",
+      hooks: [
+        {
+          type: "command",
+          command: "node .claude/hooks/block-dangerous-commands.js"
+        }
+      ]
+    };
+    const existingPreToolUse = Array.isArray(existing.hooks?.PreToolUse) ? existing.hooks.PreToolUse : [];
+    const alreadyInstalled = existingPreToolUse.some(
+      (e) => Array.isArray(e.hooks) && e.hooks.some((h) => h.command?.includes("block-dangerous-commands.js"))
+    );
+    existing.hooks = {
+      ...existing.hooks,
+      PreToolUse: alreadyInstalled ? existingPreToolUse : [...existingPreToolUse, newEntry]
+    };
+    fs2.writeFileSync(settingsPath, JSON.stringify(existing, null, 2));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error";
+    console.error(`  Warning: could not patch settings.json (${msg}) \u2014 add hook config manually`);
+  }
+}
+function installHookGlobal() {
+  const homeDir = process.env.HOME || "";
+  const hooksDir = path2.join(homeDir, ".claude", "hooks");
+  const hookPath = path2.join(hooksDir, "block-dangerous-commands.js");
+  const settingsPath = path2.join(homeDir, ".claude", "settings.json");
+  fs2.mkdirSync(hooksDir, { recursive: true });
+  fs2.writeFileSync(hookPath, HOOK_SCRIPT);
+  fs2.chmodSync(hookPath, 493);
+  try {
+    const existing = fs2.existsSync(settingsPath) ? JSON.parse(fs2.readFileSync(settingsPath, "utf-8")) : {};
+    const newEntry = {
+      matcher: "Bash",
+      hooks: [{ type: "command", command: "node ~/.claude/hooks/block-dangerous-commands.js" }]
+    };
+    const existingPreToolUse = Array.isArray(existing.hooks?.PreToolUse) ? existing.hooks.PreToolUse : [];
+    const alreadyInstalled = existingPreToolUse.some(
+      (e) => Array.isArray(e.hooks) && e.hooks.some((h) => h.command?.includes("block-dangerous-commands.js"))
+    );
+    existing.hooks = {
+      ...existing.hooks,
+      PreToolUse: alreadyInstalled ? existingPreToolUse : [...existingPreToolUse, newEntry]
+    };
+    fs2.writeFileSync(settingsPath, JSON.stringify(existing, null, 2));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error";
+    console.error(`  Warning: could not patch settings.json (${msg}) \u2014 add hook config manually`);
+  }
+}
+var STATUSLINE_SCRIPT = [
+  "#!/usr/bin/env bash",
+  "# Claude Code statusline \u2014 portable, no runtime dependency beyond jq",
+  "",
+  "set -euo pipefail",
+  "",
+  "# Colors (using $'...' so escapes resolve at assignment, not at output time)",
+  "RST=$'\\033[0m'",
+  "CYAN=$'\\033[36m'",
+  "MAGENTA=$'\\033[35m'",
+  "BLUE=$'\\033[34m'",
+  "GREEN=$'\\033[32m'",
+  "YELLOW=$'\\033[33m'",
+  "RED=$'\\033[31m'",
+  "",
+  "# Read JSON from stdin (Claude Code pipes session data)",
+  'INPUT="$(cat)"',
+  "",
+  "# Parse fields with jq",
+  `CWD="$(echo "$INPUT" | jq -r '.workspace.current_dir // .cwd // ""')"`,
+  'PROJECT="$(basename "$CWD")"',
+  `SESSION_ID="$(echo "$INPUT" | jq -r '.session_id // empty')"`,
+  `SESSION_NAME="$(echo "$INPUT" | jq -r '.session_name // empty')"`,
+  `REMAINING="$(echo "$INPUT" | jq -r '.context_window.remaining_percentage // empty')"`,
+  `MODEL="$(echo "$INPUT" | jq -r '.model.display_name // empty')"`,
+  "",
+  "# Line 1: [user] project [on branch]",
+  'LINE1=""',
+  'if [[ -n "${SSH_CONNECTION:-}" ]]; then',
+  '    LINE1+="${BLUE}$(whoami)${RST} "',
+  "fi",
+  'LINE1+="${CYAN}${PROJECT}${RST}"',
+  "",
+  'BRANCH="$(git branch --show-current 2>/dev/null || git rev-parse --short HEAD 2>/dev/null || true)"',
+  'if [[ -n "$BRANCH" ]]; then',
+  '    LINE1+=" on ${MAGENTA}\u{1F331} ${BRANCH}${RST}"',
+  "fi",
+  "",
+  "# Line 2: session + context + model",
+  'PARTS=""',
+  'if [[ -n "$SESSION_ID" ]]; then',
+  '    if [[ -n "$SESSION_NAME" ]]; then',
+  '        PARTS+="${MAGENTA}${SESSION_NAME} \xB7 sid: ${SESSION_ID}${RST}"',
+  "    else",
+  '        PARTS+="${MAGENTA}sid: ${SESSION_ID}${RST}"',
+  "    fi",
+  "fi",
+  "",
+  'if [[ -n "$REMAINING" ]]; then',
+  '    RND="${REMAINING%%.*}"',
+  "    if (( RND < 20 )); then",
+  '        CTX_COLOR="$RED"',
+  "    elif (( RND < 50 )); then",
+  '        CTX_COLOR="$YELLOW"',
+  "    else",
+  '        CTX_COLOR="$GREEN"',
+  "    fi",
+  '    [[ -n "$PARTS" ]] && PARTS+=" "',
+  '    PARTS+="${CTX_COLOR}[ctx: ${RND}%]${RST}"',
+  "fi",
+  "",
+  'if [[ -n "$MODEL" ]]; then',
+  '    [[ -n "$PARTS" ]] && PARTS+=" "',
+  '    PARTS+="[${CYAN}${MODEL}${RST}]"',
+  "fi",
+  "",
+  'echo "$LINE1"',
+  'echo "$PARTS"'
+].join("\n");
+function checkStatuslineStatus(rootDir) {
+  const homeDir = process.env.HOME || "";
+  const projectScriptPath = path2.join(rootDir, ".claude", "config", "statusline-command.sh");
+  const globalScriptPath = path2.join(homeDir, ".claude", "config", "statusline-command.sh");
+  const projectSettingsPath = path2.join(rootDir, ".claude", "settings.json");
+  const globalSettingsPath = path2.join(homeDir, ".claude", "settings.json");
+  const result = {
+    projectInstalled: false,
+    globalInstalled: false,
+    projectMatchesOurs: false,
+    globalMatchesOurs: false
+  };
+  try {
+    if (fs2.existsSync(projectSettingsPath)) {
+      const settings = JSON.parse(fs2.readFileSync(projectSettingsPath, "utf-8"));
+      if (settings.statusLine?.command) {
+        result.projectInstalled = true;
+        if (fs2.existsSync(projectScriptPath)) {
+          const content = fs2.readFileSync(projectScriptPath, "utf-8");
+          result.projectMatchesOurs = content.trim() === STATUSLINE_SCRIPT.trim();
+        }
+      }
+    }
+  } catch {
+  }
+  try {
+    if (fs2.existsSync(globalSettingsPath)) {
+      const settings = JSON.parse(fs2.readFileSync(globalSettingsPath, "utf-8"));
+      if (settings.statusLine?.command) {
+        result.globalInstalled = true;
+        if (fs2.existsSync(globalScriptPath)) {
+          const content = fs2.readFileSync(globalScriptPath, "utf-8");
+          result.globalMatchesOurs = content.trim() === STATUSLINE_SCRIPT.trim();
+        }
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+function installStatusline(rootDir) {
+  const configDir = path2.join(rootDir, ".claude", "config");
+  const scriptPath = path2.join(configDir, "statusline-command.sh");
+  const settingsPath = path2.join(rootDir, ".claude", "settings.json");
+  fs2.mkdirSync(configDir, { recursive: true });
+  fs2.writeFileSync(scriptPath, STATUSLINE_SCRIPT);
+  fs2.chmodSync(scriptPath, 493);
+  patchSettings(settingsPath, {
+    statusLine: { type: "command", command: "bash .claude/config/statusline-command.sh" }
+  });
+}
+function installStatuslineGlobal() {
+  const homeDir = process.env.HOME || "";
+  const configDir = path2.join(homeDir, ".claude", "config");
+  const scriptPath = path2.join(configDir, "statusline-command.sh");
+  const settingsPath = path2.join(homeDir, ".claude", "settings.json");
+  fs2.mkdirSync(configDir, { recursive: true });
+  fs2.writeFileSync(scriptPath, STATUSLINE_SCRIPT);
+  fs2.chmodSync(scriptPath, 493);
+  patchSettings(settingsPath, {
+    statusLine: { type: "command", command: "bash ~/.claude/config/statusline-command.sh" }
+  });
+}
+function patchSettings(settingsPath, patch) {
+  try {
+    const existing = fs2.existsSync(settingsPath) ? JSON.parse(fs2.readFileSync(settingsPath, "utf-8")) : {};
+    Object.assign(existing, patch);
+    fs2.writeFileSync(settingsPath, JSON.stringify(existing, null, 2));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error";
+    console.error(
+      `  Warning: could not patch settings.json (${msg}) \u2014 add statusLine config manually`
+    );
+  }
+}
+
+// src/extras.ts
+var EXTRAS = [
+  {
+    id: "safety-hook",
+    name: "Safety hook",
+    description: "Block dangerous commands (git push, rm -rf, etc.)",
+    checkStatus: checkHookStatus,
+    installProject: installHook,
+    installGlobal: installHookGlobal,
+    projectPath: ".claude/hooks/block-dangerous-commands.js",
+    globalPath: "~/.claude/hooks/block-dangerous-commands.js"
+  },
+  {
+    id: "statusline",
+    name: "Custom statusline",
+    description: "Shows project, branch, context, model",
+    checkStatus: checkStatuslineStatus,
+    installProject: installStatusline,
+    installGlobal: installStatuslineGlobal,
+    projectPath: ".claude/config/statusline-command.sh",
+    globalPath: "~/.claude/config/statusline-command.sh"
+  }
+];
+async function promptExtras(projectDir) {
+  for (const extra of EXTRAS) {
+    const status = extra.checkStatus(projectDir);
+    if (status.projectMatchesOurs || status.globalMatchesOurs) {
+      continue;
+    }
+    if (status.projectInstalled || status.globalInstalled) {
+      const where = status.globalInstalled ? "globally" : "in this project";
+      const { action } = await prompts({
+        type: "select",
+        name: "action",
+        message: `A different ${extra.name.toLowerCase()} is already configured ${where}. Replace it?`,
+        choices: [
+          { title: "Install for this project only", value: "project" },
+          { title: "Install globally (all projects)", value: "global" },
+          { title: "Skip \u2014 keep existing", value: "skip" }
+        ],
+        initial: 2
+      });
+      applyAction(action, extra, projectDir);
+    } else {
+      const { action } = await prompts({
+        type: "select",
+        name: "action",
+        message: `Add ${extra.name.toLowerCase()}? (${extra.description})`,
+        choices: [
+          { title: "Install for this project only", value: "project" },
+          { title: "Install globally (all projects)", value: "global" },
+          { title: "Skip", value: "skip" }
+        ],
+        initial: 0
+      });
+      applyAction(action, extra, projectDir);
+    }
+  }
+}
+function applyAction(action, extra, projectDir) {
+  if (action === "project") {
+    extra.installProject(projectDir);
+    console.log(pc.green(`  + ${extra.projectPath}`));
+  } else if (action === "global") {
+    extra.installGlobal();
+    console.log(pc.green(`  + ${extra.globalPath} (global)`));
+  }
+}
+
+// src/generator.ts
+import fs3 from "fs";
+import path3 from "path";
 function ensureDirectories(rootDir) {
   const dirs = [".claude", ".claude/skills", ".claude/agents", ".claude/rules", ".claude/commands"];
   for (const dir of dirs) {
-    fs2.mkdirSync(path2.join(rootDir, dir), { recursive: true });
+    fs3.mkdirSync(path3.join(rootDir, dir), { recursive: true });
   }
 }
 function generateSettings(stack) {
@@ -593,16 +1088,17 @@ function generateSettings(stack) {
 }
 function writeSettings(rootDir, stack) {
   const { path: settingsPath, content } = generateSettings(stack);
-  const fullPath = path2.join(rootDir, settingsPath);
-  const dir = path2.dirname(fullPath);
-  fs2.mkdirSync(dir, { recursive: true });
-  fs2.writeFileSync(fullPath, content);
+  const fullPath = path3.join(rootDir, settingsPath);
+  const dir = path3.dirname(fullPath);
+  fs3.mkdirSync(dir, { recursive: true });
+  fs3.writeFileSync(fullPath, content);
 }
 
 // src/prompt.ts
-function getAnalysisPrompt(projectInfo) {
+function getAnalysisPrompt(projectInfo, options = { claudeMdMode: "replace", existingClaudeMd: null }) {
   const context = buildContextSection(projectInfo);
   const templateVars = buildTemplateVariables(projectInfo);
+  const claudeMdInstructions = buildClaudeMdInstructions(options);
   return `${ANALYSIS_PROMPT}
 
 ${SKILLS_PROMPT}
@@ -626,15 +1122,17 @@ ${context}
 
 ${templateVars}
 
+${claudeMdInstructions}
+
 ---
 
 ## Execute Now
 
 1. Read this entire prompt to understand all phases
 2. Execute Phase 1 completely - read files, analyze code, gather all data
-3. Execute Phase 2 - generate the CLAUDE.md (max 120 lines) using only discovered information
+${options.claudeMdMode === "keep" ? `3. Skip CLAUDE.md generation \u2014 the existing file is being kept as-is` : options.claudeMdMode === "improve" ? `3. Execute Phase 2 \u2014 IMPROVE the existing CLAUDE.md (see Improvement Mode instructions above)` : `3. Execute Phase 2 - generate the CLAUDE.md (max 120 lines) using only discovered information`}
 4. Execute Phase 3 - verify quality before writing
-5. Use the Write tool to create \`.claude/CLAUDE.md\` with the final content
+${options.claudeMdMode === "keep" ? `5. Skip writing CLAUDE.md \u2014 it is being preserved` : `5. Use the Write tool to create \`.claude/CLAUDE.md\` with the final content`}
 6. Execute Phase 4 - generate ALL skill files (4 core + framework-specific if detected)
 7. Execute Phase 5 - generate agent files
 8. Execute Phase 6 - generate rule files
@@ -645,6 +1143,41 @@ ${templateVars}
 Do NOT output file contents to stdout. Write all files to disk using the Write tool.
 Generate ALL files in a single pass \u2014 do not stop after CLAUDE.md.`;
 }
+function buildClaudeMdInstructions(options) {
+  if (options.claudeMdMode === "keep") {
+    return `---
+
+## CLAUDE.md Mode: KEEP
+
+The user chose to keep their existing CLAUDE.md unchanged.
+**Do NOT read, modify, or overwrite \`.claude/CLAUDE.md\`.**
+Generate all other files (skills, agents, rules, commands) normally.
+Use the existing CLAUDE.md as the source of truth for cross-references.`;
+  }
+  if (options.claudeMdMode === "improve" && options.existingClaudeMd) {
+    return `---
+
+## CLAUDE.md Mode: IMPROVE
+
+The user has an existing CLAUDE.md and wants it improved, not replaced.
+Here is the current content:
+
+\`\`\`markdown
+${options.existingClaudeMd}
+\`\`\`
+
+### Improvement Rules
+
+1. **Preserve all manually-added content** \u2014 sections, notes, and custom rules the user wrote
+2. **Enhance with discovered information** \u2014 fill gaps, add missing sections, improve specificity
+3. **Fix generic content** \u2014 replace boilerplate with project-specific details found during Phase 1
+4. **Update stale references** \u2014 fix file paths, commands, or patterns that no longer match the codebase
+5. **Respect the 120-line cap** \u2014 if the file is already near the limit, prioritize density over additions
+6. **Keep the user's structure** \u2014 if they organized sections differently from the template, keep their layout
+7. **Do NOT remove content you don't understand** \u2014 if a section seems custom or domain-specific, preserve it`;
+  }
+  return "";
+}
 function buildContextSection(projectInfo) {
   const { name, description, techStack, fileCount } = projectInfo;
   const lines = [];
@@ -1272,10 +1805,157 @@ Body: This command delegates to the code-reviewer agent for thorough review.
 3. If the agent is unavailable, perform a lightweight review: run the linter and check for obvious issues
 Do NOT duplicate the code-reviewer agent's checklist here \u2014 the agent has the full review criteria.`;
 
+// src/validator.ts
+import fs4 from "fs";
+import path4 from "path";
+function extractCommands(claudeMd) {
+  const commands = [];
+  const match = claudeMd.match(/## Common Commands[\s\S]*?```(?:bash)?\n([\s\S]*?)```/);
+  if (!match) return commands;
+  for (const line of match[1].split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const cmd = trimmed.split(/\s+#/)[0].trim();
+    if (cmd.length > 3) commands.push(cmd);
+  }
+  return commands;
+}
+function extractConventionFingerprints(claudeMd) {
+  const fingerprints = [];
+  const startIdx = claudeMd.indexOf("## Code Conventions");
+  if (startIdx === -1) return fingerprints;
+  const rest = claudeMd.slice(startIdx + "## Code Conventions".length);
+  const nextHeading = rest.match(/\n## [A-Z]/);
+  const section = nextHeading ? claudeMd.slice(startIdx, startIdx + "## Code Conventions".length + nextHeading.index) : claudeMd.slice(startIdx);
+  for (const kw of ["camelCase", "PascalCase", "kebab-case", "snake_case"]) {
+    if (section.includes(kw)) fingerprints.push(kw);
+  }
+  if (/\bnamed exports?\b/i.test(section)) fingerprints.push("named export");
+  if (/\bdefault exports?\b/i.test(section)) fingerprints.push("default export");
+  if (section.includes("import type")) fingerprints.push("import type");
+  for (const kw of [".skip()", ".only()", "console.log"]) {
+    if (section.includes(kw)) fingerprints.push(kw);
+  }
+  return fingerprints;
+}
+var RULE_WORDS = /\b(verify|check|ensure|always|never|must|should|avoid)\b/i;
+function isConventionDuplication(line, fingerprints) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#") || trimmed.includes("CLAUDE.md")) return false;
+  if (!/^[-*]\s/.test(trimmed)) return false;
+  const matchCount = fingerprints.filter((fp) => trimmed.includes(fp)).length;
+  if (matchCount >= 2) return true;
+  if (matchCount === 1 && RULE_WORDS.test(trimmed)) return true;
+  return false;
+}
+function findLiteralCommand(line, commands) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#") || trimmed.includes("CLAUDE.md")) return null;
+  for (const cmd of commands) {
+    if (trimmed.includes(cmd)) return cmd;
+  }
+  return null;
+}
+function separateFrontmatter(content) {
+  const match = content.match(/^---\n[\s\S]*?\n---(?:\n|$)/);
+  if (!match) {
+    return { frontmatter: "", body: content };
+  }
+  return {
+    frontmatter: match[0],
+    body: content.slice(match[0].length)
+  };
+}
+function processFile(filePath, commands, fingerprints) {
+  const content = fs4.readFileSync(filePath, "utf-8");
+  const { frontmatter, body } = separateFrontmatter(content);
+  const lines = body.split("\n");
+  const changes = [];
+  const newLines = [];
+  let inCodeBlock = false;
+  for (const line of lines) {
+    if (line.trim().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      newLines.push(line);
+      continue;
+    }
+    if (inCodeBlock) {
+      newLines.push(line);
+      continue;
+    }
+    if (isConventionDuplication(line, fingerprints)) {
+      changes.push({ file: filePath, original: line.trim(), replacement: null });
+      continue;
+    }
+    const cmd = findLiteralCommand(line, commands);
+    if (cmd) {
+      const newLine = line.replace(cmd, "see Common Commands in CLAUDE.md");
+      changes.push({ file: filePath, original: line.trim(), replacement: newLine.trim() });
+      newLines.push(newLine);
+      continue;
+    }
+    newLines.push(line);
+  }
+  if (changes.length > 0) {
+    fs4.writeFileSync(filePath, frontmatter + newLines.join("\n"));
+  }
+  return changes;
+}
+function walkMdFiles(dir) {
+  const files = [];
+  if (!fs4.existsSync(dir)) return files;
+  const entries = fs4.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path4.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...walkMdFiles(fullPath));
+    } else if (entry.name.endsWith(".md")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function validateArtifacts(rootDir) {
+  const result = {
+    filesChecked: 0,
+    filesModified: 0,
+    duplicationsRemoved: 0,
+    changes: []
+  };
+  const claudeMdPath = path4.join(rootDir, ".claude", "CLAUDE.md");
+  if (!fs4.existsSync(claudeMdPath)) return result;
+  try {
+    const claudeMd = fs4.readFileSync(claudeMdPath, "utf-8");
+    const commands = extractCommands(claudeMd);
+    const fingerprints = extractConventionFingerprints(claudeMd);
+    if (commands.length === 0 && fingerprints.length === 0) return result;
+    const claudeDir = path4.join(rootDir, ".claude");
+    const files = walkMdFiles(claudeDir).filter((f) => !f.endsWith("CLAUDE.md"));
+    for (const filePath of files) {
+      result.filesChecked++;
+      try {
+        const changes = processFile(filePath, commands, fingerprints);
+        if (changes.length > 0) {
+          result.filesModified++;
+          result.duplicationsRemoved += changes.length;
+          for (const change of changes) {
+            change.file = path4.relative(rootDir, filePath);
+          }
+          result.changes.push(...changes);
+        }
+      } catch {
+      }
+    }
+  } catch {
+    return result;
+  }
+  return result;
+}
+
 // src/cli.ts
-var __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
+var __dirname2 = path5.dirname(fileURLToPath(import.meta.url));
 var VERSION = JSON.parse(
-  fs3.readFileSync(path3.join(__dirname2, "..", "package.json"), "utf-8")
+  fs5.readFileSync(path5.join(__dirname2, "..", "package.json"), "utf-8")
 ).version;
 function parseArgs(args) {
   return {
@@ -1291,21 +1971,21 @@ function getVersion() {
 }
 function showHelp() {
   console.log(`
-${pc.cyan("Claude Code Starter")} v${VERSION}
+${pc2.cyan("Claude Code Starter")} v${VERSION}
 
 Bootstrap intelligent Claude Code configurations for any repository.
 
-${pc.bold("USAGE")}
+${pc2.bold("USAGE")}
   npx claude-code-starter [OPTIONS]
 
-${pc.bold("OPTIONS")}
+${pc2.bold("OPTIONS")}
   -h, --help          Show this help message
   -v, --version       Show version number
   -f, --force         Force overwrite existing .claude files
   -y, --no-interactive  Skip interactive prompts (use defaults)
   -V, --verbose       Show detailed output
 
-${pc.bold("WHAT IT DOES")}
+${pc2.bold("WHAT IT DOES")}
   1. Analyzes your repository's tech stack
   2. Launches Claude CLI to deeply analyze your codebase
   3. Generates all .claude/ configuration files:
@@ -1313,55 +1993,55 @@ ${pc.bold("WHAT IT DOES")}
      - Skills for your frameworks and workflows
      - Agents for code review and testing
      - Rules matching your code style
-     - Commands for task management
+     - Commands for analysis and code review
 
-${pc.bold("REQUIREMENTS")}
+${pc2.bold("REQUIREMENTS")}
   Claude CLI must be installed: https://claude.ai/download
 
-${pc.bold("MORE INFO")}
+${pc2.bold("MORE INFO")}
   https://github.com/cassmtnr/claude-code-starter
 `);
 }
 function showBanner() {
   console.log();
-  console.log(pc.bold("Claude Code Starter") + pc.gray(` v${VERSION}`));
-  console.log(pc.gray("Intelligent AI-Assisted Development Setup"));
+  console.log(pc2.bold("Claude Code Starter") + pc2.gray(` v${VERSION}`));
+  console.log(pc2.gray("Intelligent AI-Assisted Development Setup"));
   console.log();
 }
 function showTechStack(projectInfo, verbose) {
   const { techStack } = projectInfo;
-  console.log(pc.bold("Tech Stack"));
+  console.log(pc2.bold("Tech Stack"));
   console.log();
   if (techStack.primaryLanguage) {
-    console.log(`  ${pc.bold("Language:")} ${formatLanguage(techStack.primaryLanguage)}`);
+    console.log(`  ${pc2.bold("Language:")} ${formatLanguage(techStack.primaryLanguage)}`);
   }
   if (techStack.primaryFramework) {
-    console.log(`  ${pc.bold("Framework:")} ${formatFramework(techStack.primaryFramework)}`);
+    console.log(`  ${pc2.bold("Framework:")} ${formatFramework(techStack.primaryFramework)}`);
   }
   if (techStack.packageManager) {
-    console.log(`  ${pc.bold("Package Manager:")} ${techStack.packageManager}`);
+    console.log(`  ${pc2.bold("Package Manager:")} ${techStack.packageManager}`);
   }
   if (techStack.testingFramework) {
-    console.log(`  ${pc.bold("Testing:")} ${techStack.testingFramework}`);
+    console.log(`  ${pc2.bold("Testing:")} ${techStack.testingFramework}`);
   }
   if (verbose) {
     if (techStack.linter) {
-      console.log(`  ${pc.bold("Linter:")} ${techStack.linter}`);
+      console.log(`  ${pc2.bold("Linter:")} ${techStack.linter}`);
     }
     if (techStack.formatter) {
-      console.log(`  ${pc.bold("Formatter:")} ${techStack.formatter}`);
+      console.log(`  ${pc2.bold("Formatter:")} ${techStack.formatter}`);
     }
     if (techStack.bundler) {
-      console.log(`  ${pc.bold("Bundler:")} ${techStack.bundler}`);
+      console.log(`  ${pc2.bold("Bundler:")} ${techStack.bundler}`);
     }
     if (techStack.isMonorepo) {
-      console.log(`  ${pc.bold("Monorepo:")} yes`);
+      console.log(`  ${pc2.bold("Monorepo:")} yes`);
     }
     if (techStack.hasDocker) {
-      console.log(`  ${pc.bold("Docker:")} yes`);
+      console.log(`  ${pc2.bold("Docker:")} yes`);
     }
     if (techStack.hasCICD) {
-      console.log(`  ${pc.bold("CI/CD:")} ${techStack.cicdPlatform}`);
+      console.log(`  ${pc2.bold("CI/CD:")} ${techStack.cicdPlatform}`);
     }
   }
   console.log();
@@ -1437,9 +2117,9 @@ async function promptNewProject(args) {
   if (!args.interactive) {
     return null;
   }
-  console.log(pc.yellow("New project detected - let's set it up!"));
+  console.log(pc2.yellow("New project detected - let's set it up!"));
   console.log();
-  const descResponse = await prompts({
+  const descResponse = await prompts2({
     type: "text",
     name: "description",
     message: "What are you building?",
@@ -1448,7 +2128,7 @@ async function promptNewProject(args) {
   if (!descResponse.description) {
     return null;
   }
-  const langResponse = await prompts({
+  const langResponse = await prompts2({
     type: "select",
     name: "primaryLanguage",
     message: "Primary language?",
@@ -1469,34 +2149,34 @@ async function promptNewProject(args) {
   });
   const lang = langResponse.primaryLanguage || "typescript";
   const fwChoices = frameworkChoices[lang] || defaultFrameworkChoices;
-  const fwResponse = await prompts({
+  const fwResponse = await prompts2({
     type: "select",
     name: "framework",
     message: "Framework?",
     choices: fwChoices
   });
   const pmChoices = getPackageManagerChoices(lang);
-  const pmResponse = await prompts({
+  const pmResponse = await prompts2({
     type: "select",
     name: "packageManager",
     message: "Package manager?",
     choices: pmChoices
   });
   const testChoices = getTestingFrameworkChoices(lang);
-  const testResponse = await prompts({
+  const testResponse = await prompts2({
     type: "select",
     name: "testingFramework",
     message: "Testing framework?",
     choices: testChoices
   });
   const lintChoices = getLinterFormatterChoices(lang);
-  const lintResponse = await prompts({
+  const lintResponse = await prompts2({
     type: "select",
     name: "linter",
     message: "Linter/Formatter?",
     choices: lintChoices
   });
-  const typeResponse = await prompts({
+  const typeResponse = await prompts2({
     type: "select",
     name: "projectType",
     message: "Project type?",
@@ -1604,7 +2284,6 @@ function getLinterFormatterChoices(lang) {
     return [
       { title: "Biome", value: "biome" },
       { title: "ESLint + Prettier", value: "eslint" },
-      { title: "ESLint", value: "eslint" },
       { title: "None", value: null }
     ];
   }
@@ -1735,12 +2414,12 @@ function checkClaudeCli() {
     return false;
   }
 }
-function runClaudeAnalysis(projectDir, projectInfo) {
+function runClaudeAnalysis(projectDir, projectInfo, options = { claudeMdMode: "replace", existingClaudeMd: null }) {
   return new Promise((resolve) => {
-    const prompt = getAnalysisPrompt(projectInfo);
-    console.log(pc.cyan("Launching Claude for deep project analysis..."));
+    const prompt = getAnalysisPrompt(projectInfo, options);
+    console.log(pc2.cyan("Launching Claude for deep project analysis..."));
     console.log(
-      pc.gray("Claude will read your codebase and generate all .claude/ configuration files")
+      pc2.gray("Claude will read your codebase and generate all .claude/ configuration files")
     );
     console.log();
     const spinner = ora({
@@ -1755,6 +2434,8 @@ function runClaudeAnalysis(projectDir, projectInfo) {
       "claude",
       [
         "-p",
+        "--verbose",
+        "--output-format=stream-json",
         "--allowedTools",
         "Read",
         "--allowedTools",
@@ -1771,8 +2452,43 @@ function runClaudeAnalysis(projectDir, projectInfo) {
         stdio: ["pipe", "pipe", "pipe"]
       }
     );
+    let stdoutBuffer = "";
+    child.stdout.on("data", (chunk) => {
+      stdoutBuffer += chunk.toString();
+      const lines = stdoutBuffer.split("\n");
+      stdoutBuffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const event = JSON.parse(line);
+          if (event.type === "assistant" && Array.isArray(event.message?.content)) {
+            for (const block of event.message.content) {
+              if (block.type === "tool_use" && block.name && block.input) {
+                const toolName = block.name;
+                const toolInput = block.input;
+                const filePath = toolInput.file_path || toolInput.path || toolInput.pattern || "";
+                const shortPath = filePath.split("/").slice(-2).join("/");
+                const action = toolName === "Write" || toolName === "Edit" ? "Writing" : "Reading";
+                if (shortPath) {
+                  spinner.text = `${action} ${shortPath}...`;
+                } else {
+                  spinner.text = `Using ${toolName}...`;
+                }
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    child.stdin.on("error", () => {
+    });
     child.stdin.write(prompt);
     child.stdin.end();
+    let stderrOutput = "";
+    child.stderr.on("data", (chunk) => {
+      stderrOutput += chunk.toString();
+    });
     child.on("error", (err) => {
       spinner.fail(`Failed to launch Claude CLI: ${err.message}`);
       resolve(false);
@@ -1783,23 +2499,26 @@ function runClaudeAnalysis(projectDir, projectInfo) {
         resolve(true);
       } else {
         spinner.fail(`Claude exited with code ${code}`);
+        if (stderrOutput.trim()) {
+          console.error(pc2.gray(stderrOutput.trim()));
+        }
         resolve(false);
       }
     });
   });
 }
 function getGeneratedFiles(projectDir) {
-  const claudeDir = path3.join(projectDir, ".claude");
+  const claudeDir = path5.join(projectDir, ".claude");
   const files = [];
   function walk(dir) {
-    if (!fs3.existsSync(dir)) return;
-    const entries = fs3.readdirSync(dir, { withFileTypes: true });
+    if (!fs5.existsSync(dir)) return;
+    const entries = fs5.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path3.join(dir, entry.name);
+      const fullPath = path5.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
       } else {
-        files.push(path3.relative(projectDir, fullPath));
+        files.push(path5.relative(projectDir, fullPath));
       }
     }
   }
@@ -1818,7 +2537,7 @@ async function main() {
   }
   showBanner();
   const projectDir = process.cwd();
-  console.log(pc.gray("Analyzing repository..."));
+  console.log(pc2.gray("Analyzing repository..."));
   console.log();
   const projectInfo = analyzeRepository(projectDir);
   showTechStack(projectInfo, args.verbose);
@@ -1846,63 +2565,86 @@ async function main() {
       projectInfo.description = preferences.description;
     }
   } else {
-    console.log(pc.gray(`Existing project with ${projectInfo.fileCount} source files`));
+    console.log(pc2.gray(`Existing project with ${projectInfo.fileCount} source files`));
     console.log();
   }
-  if (projectInfo.techStack.hasClaudeConfig && !args.force) {
-    console.log(pc.yellow("Existing .claude/ configuration detected"));
-    console.log();
-    if (args.interactive) {
-      const { proceed } = await prompts({
-        type: "confirm",
-        name: "proceed",
-        message: "Update existing configuration? (preserves task state)",
-        initial: true
+  let claudeMdMode = "replace";
+  let existingClaudeMd = null;
+  const claudeMdPath = path5.join(projectDir, ".claude", "CLAUDE.md");
+  if (fs5.existsSync(claudeMdPath)) {
+    existingClaudeMd = fs5.readFileSync(claudeMdPath, "utf-8");
+    if (args.force) {
+      claudeMdMode = "replace";
+    } else if (args.interactive) {
+      console.log(pc2.yellow("Existing CLAUDE.md detected"));
+      console.log();
+      const { mode } = await prompts2({
+        type: "select",
+        name: "mode",
+        message: "How should we handle the existing CLAUDE.md?",
+        choices: [
+          { title: "Improve \u2014 scan and enhance the existing file", value: "improve" },
+          { title: "Replace \u2014 generate a new one from scratch", value: "replace" },
+          { title: "Keep \u2014 leave CLAUDE.md as-is, regenerate other files", value: "keep" }
+        ],
+        initial: 0
       });
-      if (!proceed) {
-        console.log(pc.gray("Cancelled. Use --force to overwrite."));
+      if (mode === void 0) {
+        console.log(pc2.gray("Cancelled."));
         process.exit(0);
       }
+      claudeMdMode = mode;
     }
     console.log();
   }
   if (!checkClaudeCli()) {
-    console.error(pc.red("Claude CLI is required but not found."));
-    console.error(pc.gray("Install it from: https://claude.ai/download"));
+    console.error(pc2.red("Claude CLI is required but not found."));
+    console.error(pc2.gray("Install it from: https://claude.ai/download"));
     process.exit(1);
   }
-  console.log(pc.gray("Setting up .claude/ directory structure..."));
+  console.log(pc2.gray("Setting up .claude/ directory structure..."));
   console.log();
   writeSettings(projectDir, projectInfo.techStack);
   ensureDirectories(projectDir);
-  console.log(pc.green("Created:"));
-  console.log(pc.green("  + .claude/settings.json"));
+  console.log(pc2.green("Created:"));
+  console.log(pc2.green("  + .claude/settings.json"));
   console.log();
-  const success = await runClaudeAnalysis(projectDir, projectInfo);
+  const success = await runClaudeAnalysis(projectDir, projectInfo, {
+    claudeMdMode,
+    existingClaudeMd: claudeMdMode === "improve" ? existingClaudeMd : null
+  });
   if (!success) {
-    console.error(pc.red("Claude analysis failed. Please try again."));
+    console.error(pc2.red("Claude analysis failed. Please try again."));
     process.exit(1);
   }
+  const validation = validateArtifacts(projectDir);
+  if (validation.duplicationsRemoved > 0) {
+    console.log(
+      pc2.gray(
+        `  Deduplication: removed ${validation.duplicationsRemoved} redundancies from ${validation.filesModified} files`
+      )
+    );
+  }
   const generatedFiles = getGeneratedFiles(projectDir);
   console.log();
-  console.log(pc.green(`Done! (${generatedFiles.length} files)`));
+  console.log(pc2.green(`Done! (${generatedFiles.length} files)`));
   console.log();
-  console.log(pc.bold("Generated for your stack:"));
+  console.log(pc2.bold("Generated for your stack:"));
   const skills = generatedFiles.filter((f) => f.includes("/skills/"));
   const agents = generatedFiles.filter((f) => f.includes("/agents/"));
   const rules = generatedFiles.filter((f) => f.includes("/rules/"));
   const commands = generatedFiles.filter((f) => f.includes("/commands/"));
   if (generatedFiles.some((f) => f.endsWith("CLAUDE.md"))) {
-    console.log(pc.cyan("  CLAUDE.md (deep analysis by Claude)"));
+    console.log(pc2.cyan("  CLAUDE.md (deep analysis by Claude)"));
   }
   if (skills.length > 0) {
     console.log(
-      `  ${skills.length} skills (${skills.map((s) => path3.basename(s, ".md")).join(", ")})`
+      `  ${skills.length} skills (${skills.map((s) => path5.basename(s, ".md")).join(", ")})`
     );
   }
   if (agents.length > 0) {
     console.log(
-      `  ${agents.length} agents (${agents.map((a) => path3.basename(a, ".md")).join(", ")})`
+      `  ${agents.length} agents (${agents.map((a) => path5.basename(a, ".md")).join(", ")})`
     );
   }
   if (rules.length > 0) {
@@ -1912,19 +2654,24 @@ async function main() {
     console.log(`  ${commands.length} commands`);
   }
   console.log();
-  console.log(`${pc.cyan("Next step:")} Run ${pc.bold("claude")} to start working!`);
+  if (args.interactive) {
+    console.log();
+    await promptExtras(projectDir);
+  }
+  console.log();
+  console.log(`${pc2.cyan("Next step:")} Run ${pc2.bold("claude")} to start working!`);
   console.log();
   console.log(
-    pc.gray(
+    pc2.gray(
       "Your .claude/ files were generated by deep analysis - review them with: ls -la .claude/"
     )
   );
 }
 try {
-  const isMain = process.argv[1] && fs3.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+  const isMain = process.argv[1] && fs5.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
   if (isMain) {
     main().catch((err) => {
-      console.error(pc.red("Error:"), err.message);
+      console.error(pc2.red("Error:"), err.message);
       if (process.env.DEBUG) {
         console.error(err.stack);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-starter",
-  "version": "0.14.1",
+  "version": "0.16.0",
   "description": "A lightweight starter kit for AI-assisted development with Claude Code",
   "keywords": [
     "claude",