claude-code-starter 0.15.0 → 0.16.0

package/dist/cli.js

@@ -6,15 +6,15 @@ 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,96 +502,13 @@ function countSourceFiles(rootDir, _languages) {
   return count;
 }
 
-// src/generator.ts
-import fs2 from "fs";
-import path2 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 });
-  }
-}
-function generateSettings(stack) {
-  const permissions = ["Read(**)", "Edit(**)", "Write(.claude/**)", "Bash(git:*)"];
-  const pkgManagers = ["npm", "yarn", "pnpm", "bun", "npx"];
-  for (const pm of pkgManagers) {
-    permissions.push(`Bash(${pm}:*)`);
-  }
-  if (stack.languages.includes("typescript") || stack.languages.includes("javascript")) {
-    permissions.push("Bash(node:*)", "Bash(tsc:*)");
-  }
-  if (stack.languages.includes("python")) {
-    permissions.push(
-      "Bash(python:*)",
-      "Bash(pip:*)",
-      "Bash(poetry:*)",
-      "Bash(pytest:*)",
-      "Bash(uvicorn:*)"
-    );
-  }
-  if (stack.languages.includes("go")) {
-    permissions.push("Bash(go:*)");
-  }
-  if (stack.languages.includes("rust")) {
-    permissions.push("Bash(cargo:*)", "Bash(rustc:*)");
-  }
-  if (stack.languages.includes("ruby")) {
-    permissions.push("Bash(ruby:*)", "Bash(bundle:*)", "Bash(rails:*)", "Bash(rake:*)");
-  }
-  if (stack.testingFramework) {
-    const testCommands = {
-      jest: ["jest:*"],
-      vitest: ["vitest:*"],
-      playwright: ["playwright:*"],
-      cypress: ["cypress:*"],
-      pytest: ["pytest:*"],
-      rspec: ["rspec:*"]
-    };
-    const cmds = testCommands[stack.testingFramework];
-    if (cmds) {
-      permissions.push(...cmds.map((c) => `Bash(${c})`));
-    }
-  }
-  if (stack.linter) {
-    permissions.push(`Bash(${stack.linter}:*)`);
-  }
-  if (stack.formatter) {
-    permissions.push(`Bash(${stack.formatter}:*)`);
-  }
-  permissions.push(
-    "Bash(ls:*)",
-    "Bash(mkdir:*)",
-    "Bash(cat:*)",
-    "Bash(echo:*)",
-    "Bash(grep:*)",
-    "Bash(find:*)"
-  );
-  if (stack.hasDocker) {
-    permissions.push("Bash(docker:*)", "Bash(docker-compose:*)");
-  }
-  const settings = {
-    $schema: "https://json.schemastore.org/claude-code-settings.json",
-    permissions: {
-      allow: [...new Set(permissions)]
-      // Deduplicate
-    }
-  };
-  return {
-    path: ".claude/settings.json",
-    content: JSON.stringify(settings, null, 2)
-  };
-}
-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);
-}
+// src/extras.ts
+import pc from "picocolors";
+import prompts from "prompts";
 
 // src/hooks.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs2 from "fs";
+import path2 from "path";
 var HOOK_SCRIPT = String.raw`#!/usr/bin/env node
 /**
  * Block Dangerous Commands - PreToolUse Hook for Bash
@@ -804,38 +711,394 @@ if (require.main === module) {
   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 = path3.join(rootDir, ".claude", "hooks");
-  const hookPath = path3.join(hooksDir, "block-dangerous-commands.js");
-  const settingsPath = path3.join(rootDir, ".claude", "settings.json");
-  fs3.mkdirSync(hooksDir, { recursive: true });
-  fs3.writeFileSync(hookPath, HOOK_SCRIPT);
-  fs3.chmodSync(hookPath, 493);
+  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 = fs3.existsSync(settingsPath) ? JSON.parse(fs3.readFileSync(settingsPath, "utf-8")) : {};
-    existing.hooks = {
-      ...existing.hooks,
-      PreToolUse: [
+    const existing = fs2.existsSync(settingsPath) ? JSON.parse(fs2.readFileSync(settingsPath, "utf-8")) : {};
+    const newEntry = {
+      matcher: "Bash",
+      hooks: [
         {
-          matcher: "Bash",
-          hooks: [
-            {
-              type: "command",
-              command: "node .claude/hooks/block-dangerous-commands.js"
-            }
-          ]
+          type: "command",
+          command: "node .claude/hooks/block-dangerous-commands.js"
         }
       ]
     };
-    fs3.writeFileSync(settingsPath, JSON.stringify(existing, null, 2));
+    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) {
+    fs3.mkdirSync(path3.join(rootDir, dir), { recursive: true });
+  }
+}
+function generateSettings(stack) {
+  const permissions = ["Read(**)", "Edit(**)", "Write(.claude/**)", "Bash(git:*)"];
+  const pkgManagers = ["npm", "yarn", "pnpm", "bun", "npx"];
+  for (const pm of pkgManagers) {
+    permissions.push(`Bash(${pm}:*)`);
+  }
+  if (stack.languages.includes("typescript") || stack.languages.includes("javascript")) {
+    permissions.push("Bash(node:*)", "Bash(tsc:*)");
+  }
+  if (stack.languages.includes("python")) {
+    permissions.push(
+      "Bash(python:*)",
+      "Bash(pip:*)",
+      "Bash(poetry:*)",
+      "Bash(pytest:*)",
+      "Bash(uvicorn:*)"
+    );
+  }
+  if (stack.languages.includes("go")) {
+    permissions.push("Bash(go:*)");
+  }
+  if (stack.languages.includes("rust")) {
+    permissions.push("Bash(cargo:*)", "Bash(rustc:*)");
+  }
+  if (stack.languages.includes("ruby")) {
+    permissions.push("Bash(ruby:*)", "Bash(bundle:*)", "Bash(rails:*)", "Bash(rake:*)");
+  }
+  if (stack.testingFramework) {
+    const testCommands = {
+      jest: ["jest:*"],
+      vitest: ["vitest:*"],
+      playwright: ["playwright:*"],
+      cypress: ["cypress:*"],
+      pytest: ["pytest:*"],
+      rspec: ["rspec:*"]
+    };
+    const cmds = testCommands[stack.testingFramework];
+    if (cmds) {
+      permissions.push(...cmds.map((c) => `Bash(${c})`));
+    }
+  }
+  if (stack.linter) {
+    permissions.push(`Bash(${stack.linter}:*)`);
+  }
+  if (stack.formatter) {
+    permissions.push(`Bash(${stack.formatter}:*)`);
+  }
+  permissions.push(
+    "Bash(ls:*)",
+    "Bash(mkdir:*)",
+    "Bash(cat:*)",
+    "Bash(echo:*)",
+    "Bash(grep:*)",
+    "Bash(find:*)"
+  );
+  if (stack.hasDocker) {
+    permissions.push("Bash(docker:*)", "Bash(docker-compose:*)");
+  }
+  const settings = {
+    $schema: "https://json.schemastore.org/claude-code-settings.json",
+    permissions: {
+      allow: [...new Set(permissions)]
+      // Deduplicate
+    }
+  };
+  return {
+    path: ".claude/settings.json",
+    content: JSON.stringify(settings, null, 2)
+  };
+}
+function writeSettings(rootDir, stack) {
+  const { path: settingsPath, content } = generateSettings(stack);
+  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}
@@ -859,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
@@ -878,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 = [];
@@ -1633,14 +1933,17 @@ function validateArtifacts(rootDir) {
     const files = walkMdFiles(claudeDir).filter((f) => !f.endsWith("CLAUDE.md"));
     for (const filePath of files) {
       result.filesChecked++;
-      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);
+      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);
         }
-        result.changes.push(...changes);
+      } catch {
       }
     }
   } catch {
@@ -1668,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:
@@ -1692,53 +1995,53 @@ ${pc.bold("WHAT IT DOES")}
      - Rules matching your code style
      - 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();
@@ -1814,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?",
@@ -1825,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?",
@@ -1846,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?",
@@ -1981,7 +2284,6 @@ function getLinterFormatterChoices(lang) {
     return [
       { title: "Biome", value: "biome" },
       { title: "ESLint + Prettier", value: "eslint" },
-      { title: "ESLint", value: "eslint" },
       { title: "None", value: null }
     ];
   }
@@ -2112,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({
@@ -2132,6 +2434,8 @@ function runClaudeAnalysis(projectDir, projectInfo) {
       "claude",
       [
         "-p",
+        "--verbose",
+        "--output-format=stream-json",
         "--allowedTools",
         "Read",
         "--allowedTools",
@@ -2148,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);
@@ -2160,6 +2499,9 @@ 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);
       }
     });
@@ -2195,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);
@@ -2223,62 +2565,77 @@ 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?",
-        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(
-      pc.gray(
+      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(
@@ -2299,23 +2656,13 @@ async function main() {
   console.log();
   if (args.interactive) {
     console.log();
-    const { installSafetyHook } = await prompts({
-      type: "confirm",
-      name: "installSafetyHook",
-      message: "Add a safety hook to block dangerous commands? (git push, rm -rf, etc.)",
-      initial: true
-    });
-    if (installSafetyHook) {
-      installHook(projectDir);
-      console.log(pc.green("  + .claude/hooks/block-dangerous-commands.js"));
-      console.log(pc.gray("    Blocks destructive Bash commands before execution"));
-    }
+    await promptExtras(projectDir);
   }
   console.log();
-  console.log(`${pc.cyan("Next step:")} Run ${pc.bold("claude")} to start working!`);
+  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/"
     )
   );
@@ -2324,7 +2671,7 @@ try {
   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.15.0",
+  "version": "0.16.0",
   "description": "A lightweight starter kit for AI-assisted development with Claude Code",
   "keywords": [
     "claude",