claude-launchpad 0.1.0

package/dist/cli.js

@@ -0,0 +1,2026 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command as Command5 } from "commander";
+import { access as access7 } from "fs/promises";
+import { join as join8 } from "path";
+
+// src/commands/init/index.ts
+import { Command } from "commander";
+import { input, confirm } from "@inquirer/prompts";
+import { writeFile, mkdir, readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/lib/output.ts
+import chalk from "chalk";
+var colors = {
+  success: chalk.green,
+  error: chalk.red,
+  warn: chalk.yellow,
+  info: chalk.cyan,
+  dim: chalk.dim,
+  bold: chalk.bold,
+  score: (score) => {
+    if (score >= 80) return chalk.green.bold(`${score}%`);
+    if (score >= 60) return chalk.yellow.bold(`${score}%`);
+    return chalk.red.bold(`${score}%`);
+  },
+  severity: (sev) => {
+    const map = {
+      critical: chalk.bgRed.white.bold,
+      high: chalk.red.bold,
+      medium: chalk.yellow,
+      low: chalk.cyan,
+      info: chalk.dim
+    };
+    return map[sev](` ${sev.toUpperCase()} `);
+  }
+};
+var log = {
+  success: (msg) => console.log(`  ${chalk.green("\u2713")} ${msg}`),
+  error: (msg) => console.log(`  ${chalk.red("\u2717")} ${msg}`),
+  warn: (msg) => console.log(`  ${chalk.yellow("!")} ${msg}`),
+  step: (msg) => console.log(`  ${chalk.cyan("\u2192")} ${msg}`),
+  info: (msg) => console.log(`  ${chalk.dim("\xB7")} ${msg}`),
+  blank: () => console.log()
+};
+function printBanner() {
+  log.blank();
+  console.log(chalk.cyan.bold("  Claude Launchpad"));
+  console.log(chalk.dim("  Scaffold \xB7 Diagnose \xB7 Evaluate"));
+  log.blank();
+}
+function printScoreCard(label, score, max = 100) {
+  const pct = Math.round(score / max * 100);
+  const bar = renderBar(pct, 20);
+  console.log(`  ${chalk.bold(label.padEnd(22))} ${bar} ${colors.score(pct).padStart(12)}`);
+}
+function renderBar(pct, width) {
+  const filled = Math.round(pct / 100 * width);
+  const empty = width - filled;
+  const color = pct >= 80 ? chalk.green : pct >= 60 ? chalk.yellow : chalk.red;
+  return color("\u2501".repeat(filled)) + chalk.dim("\u2500".repeat(empty));
+}
+function printIssue(severity, analyzer, message, fix) {
+  const tag = colors.severity(severity);
+  console.log(`  ${tag} ${chalk.bold(analyzer)}`);
+  console.log(`    ${message}`);
+  if (fix) {
+    console.log(`    ${chalk.dim("Fix:")} ${chalk.dim(fix)}`);
+  }
+  console.log();
+}
+
+// src/lib/detect.ts
+import { readFile, access } from "fs/promises";
+import { join, basename } from "path";
+async function detectProject(root) {
+  const name = basename(root);
+  const [pkgJson, goMod, pyProject, gemfile, cargo, pubspec, composerJson, pomXml, buildGradle, packageSwift, mixExs, csproj, lockfiles] = await Promise.all([
+    readJsonOrNull(join(root, "package.json")),
+    fileExists(join(root, "go.mod")),
+    readFileOrNull(join(root, "pyproject.toml")),
+    fileExists(join(root, "Gemfile")),
+    fileExists(join(root, "Cargo.toml")),
+    fileExists(join(root, "pubspec.yaml")),
+    readJsonOrNull(join(root, "composer.json")),
+    fileExists(join(root, "pom.xml")),
+    fileExists(join(root, "build.gradle")) || fileExists(join(root, "build.gradle.kts")),
+    fileExists(join(root, "Package.swift")),
+    fileExists(join(root, "mix.exs")),
+    globExists(root, "*.csproj"),
+    detectLockfiles(root)
+  ]);
+  const manifests = {
+    pkgJson,
+    goMod,
+    pyProject,
+    gemfile,
+    cargo,
+    pubspec,
+    composerJson,
+    pomXml,
+    buildGradle,
+    packageSwift,
+    mixExs,
+    csproj
+  };
+  const language = detectLanguage(manifests);
+  const framework = detectFramework(manifests);
+  const packageManager = detectPackageManager(manifests, lockfiles);
+  const scripts = detectScripts({ pkgJson, pyProject, goMod, gemfile, composerJson, language });
+  return {
+    name,
+    language,
+    framework,
+    packageManager,
+    hasTests: scripts.testCommand !== null,
+    hasLinter: scripts.lintCommand !== null,
+    hasFormatter: scripts.formatCommand !== null,
+    ...scripts
+  };
+}
+function detectLanguage(m) {
+  if (m.pkgJson?.devDependencies?.typescript || m.pkgJson?.dependencies?.typescript) return "TypeScript";
+  if (m.pkgJson) return "JavaScript";
+  if (m.goMod) return "Go";
+  if (m.pyProject) return "Python";
+  if (m.gemfile) return "Ruby";
+  if (m.cargo) return "Rust";
+  if (m.pubspec) return "Dart";
+  if (m.composerJson) return "PHP";
+  if (m.buildGradle) return "Kotlin";
+  if (m.pomXml) return "Java";
+  if (m.packageSwift) return "Swift";
+  if (m.mixExs) return "Elixir";
+  if (m.csproj) return "C#";
+  return null;
+}
+function detectFramework(m) {
+  const deps = { ...m.pkgJson?.dependencies, ...m.pkgJson?.devDependencies };
+  if (deps.next) return "Next.js";
+  if (deps.nuxt) return "Nuxt";
+  if (deps.svelte || deps["@sveltejs/kit"]) return "SvelteKit";
+  if (deps.astro) return "Astro";
+  if (deps["@angular/core"]) return "Angular";
+  if (deps.remix || deps["@remix-run/react"]) return "Remix";
+  if (deps.vue) return "Vue";
+  if (deps.react && !deps.next) return "React";
+  if (deps.express) return "Express";
+  if (deps.fastify) return "Fastify";
+  if (deps.hono) return "Hono";
+  if (deps.nestjs || deps["@nestjs/core"]) return "NestJS";
+  if (m.pyProject) {
+    if (m.pyProject.includes("fastapi")) return "FastAPI";
+    if (m.pyProject.includes("django")) return "Django";
+    if (m.pyProject.includes("flask")) return "Flask";
+  }
+  if (m.composerJson) {
+    const phpDeps = { ...m.composerJson.require, ...m.composerJson["require-dev"] };
+    if (phpDeps["laravel/framework"]) return "Laravel";
+    if (phpDeps["symfony/framework-bundle"]) return "Symfony";
+  }
+  if (m.gemfile) return "Rails";
+  if (m.buildGradle) return "Gradle";
+  if (m.pomXml) return "Maven";
+  return null;
+}
+async function detectLockfiles(root) {
+  const [pnpmLock, yarnLock, bunLock, npmLock] = await Promise.all([
+    fileExists(join(root, "pnpm-lock.yaml")),
+    fileExists(join(root, "yarn.lock")),
+    fileExists(join(root, "bun.lockb")),
+    fileExists(join(root, "package-lock.json"))
+  ]);
+  return { pnpmLock, yarnLock, bunLock, npmLock };
+}
+function detectPackageManager(m, lockfiles) {
+  if (m.pkgJson) {
+    const pm = m.pkgJson.packageManager;
+    if (pm?.startsWith("pnpm")) return "pnpm";
+    if (pm?.startsWith("yarn")) return "yarn";
+    if (pm?.startsWith("bun")) return "bun";
+    if (pm?.startsWith("npm")) return "npm";
+    if (lockfiles.pnpmLock) return "pnpm";
+    if (lockfiles.yarnLock) return "yarn";
+    if (lockfiles.bunLock) return "bun";
+    if (lockfiles.npmLock) return "npm";
+    return "npm";
+  }
+  if (m.goMod) return "go modules";
+  if (m.pyProject) {
+    if (m.pyProject.includes("[tool.uv]")) return "uv";
+    if (m.pyProject.includes("[tool.poetry]")) return "poetry";
+    return "pip";
+  }
+  if (m.gemfile) return "bundler";
+  if (m.cargo) return "cargo";
+  if (m.composerJson) return "composer";
+  return null;
+}
+function detectScripts(m) {
+  const scripts = m.pkgJson?.scripts ?? {};
+  if (m.pkgJson) {
+    return {
+      devCommand: scripts.dev ? `${pmRun(m.pkgJson)} dev` : null,
+      buildCommand: scripts.build ? `${pmRun(m.pkgJson)} build` : null,
+      testCommand: scripts.test ? `${pmRun(m.pkgJson)} test` : null,
+      lintCommand: scripts.lint ? `${pmRun(m.pkgJson)} lint` : null,
+      formatCommand: scripts.format ? `${pmRun(m.pkgJson)} format` : null
+    };
+  }
+  if (m.language === "Go") {
+    return {
+      devCommand: "go run .",
+      buildCommand: "go build .",
+      testCommand: "go test ./...",
+      lintCommand: "golangci-lint run",
+      formatCommand: "gofmt -w ."
+    };
+  }
+  if (m.language === "Python") {
+    const runner = m.pyProject?.includes("[tool.uv]") ? "uv run" : "python -m";
+    return {
+      devCommand: null,
+      buildCommand: null,
+      testCommand: `${runner} pytest`,
+      lintCommand: `${runner} ruff check .`,
+      formatCommand: `${runner} ruff format .`
+    };
+  }
+  if (m.gemfile) {
+    return {
+      devCommand: "bin/dev",
+      buildCommand: null,
+      testCommand: "bin/rails test",
+      lintCommand: "bin/rubocop",
+      formatCommand: null
+    };
+  }
+  if (m.language === "PHP") {
+    return {
+      devCommand: "php artisan serve",
+      buildCommand: null,
+      testCommand: "php artisan test",
+      lintCommand: "vendor/bin/phpstan analyse",
+      formatCommand: "vendor/bin/pint"
+    };
+  }
+  if (m.language === "Rust") {
+    return {
+      devCommand: "cargo run",
+      buildCommand: "cargo build",
+      testCommand: "cargo test",
+      lintCommand: "cargo clippy",
+      formatCommand: "cargo fmt"
+    };
+  }
+  if (m.language === "Java" || m.language === "Kotlin") {
+    return {
+      devCommand: null,
+      buildCommand: "mvn package",
+      testCommand: "mvn test",
+      lintCommand: null,
+      formatCommand: null
+    };
+  }
+  if (m.language === "Swift") {
+    return {
+      devCommand: null,
+      buildCommand: "swift build",
+      testCommand: "swift test",
+      lintCommand: "swiftlint",
+      formatCommand: "swift-format format -r ."
+    };
+  }
+  if (m.language === "Elixir") {
+    return {
+      devCommand: "mix phx.server",
+      buildCommand: "mix compile",
+      testCommand: "mix test",
+      lintCommand: "mix credo",
+      formatCommand: "mix format"
+    };
+  }
+  if (m.language === "C#") {
+    return {
+      devCommand: "dotnet run",
+      buildCommand: "dotnet build",
+      testCommand: "dotnet test",
+      lintCommand: null,
+      formatCommand: "dotnet format"
+    };
+  }
+  return { devCommand: null, buildCommand: null, testCommand: null, lintCommand: null, formatCommand: null };
+}
+function pmRun(pkg) {
+  const pm = pkg.packageManager;
+  if (pm?.startsWith("pnpm")) return "pnpm";
+  if (pm?.startsWith("yarn")) return "yarn";
+  if (pm?.startsWith("bun")) return "bun";
+  return "npm run";
+}
+async function readJsonOrNull(path) {
+  try {
+    const content = await readFile(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function readFileOrNull(path) {
+  try {
+    return await readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function globExists(dir, pattern) {
+  const { readdir: readdir3 } = await import("fs/promises");
+  try {
+    const entries = await readdir3(dir);
+    return entries.some((e) => e.endsWith(pattern.replace("*", "")));
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/init/generators/claude-md.ts
+function generateClaudeMd(options, detected) {
+  const sections = [];
+  sections.push(`# ${options.name}`);
+  if (options.description) {
+    sections.push("", options.description);
+  }
+  sections.push("", "## Stack");
+  if (detected.language) {
+    const items = [];
+    if (detected.framework) items.push(`- **Framework**: ${detected.framework}`);
+    items.push(`- **Language**: ${detected.language}`);
+    if (detected.packageManager) items.push(`- **Package Manager**: ${detected.packageManager}`);
+    sections.push(items.join("\n"));
+  } else {
+    sections.push("<!-- TODO: Define your tech stack -->");
+  }
+  sections.push("", "## Commands");
+  const commands = [];
+  if (detected.devCommand) commands.push(`- Dev: \`${detected.devCommand}\``);
+  if (detected.buildCommand) commands.push(`- Build: \`${detected.buildCommand}\``);
+  if (detected.testCommand) commands.push(`- Test: \`${detected.testCommand}\``);
+  if (detected.lintCommand) commands.push(`- Lint: \`${detected.lintCommand}\``);
+  if (detected.formatCommand) commands.push(`- Format: \`${detected.formatCommand}\``);
+  if (commands.length > 0) {
+    sections.push(commands.join("\n"));
+  } else {
+    sections.push("<!-- TODO: Add your dev/build/test commands -->");
+  }
+  sections.push("", `## Session Start
+- ALWAYS read @TASKS.md first \u2014 it tracks progress across sessions
+- Check the Session Log at the bottom of TASKS.md for where we left off
+- Update TASKS.md as you complete work`);
+  sections.push("", `## Conventions
+- Git: Conventional commits (\`feat:\`, \`fix:\`, \`docs:\`, \`refactor:\`, \`test:\`, \`chore:\`)`);
+  sections.push("", `## Off-Limits
+- Never hardcode secrets \u2014 use environment variables
+- Never write to \`.env\` files
+- Never expose internal error details in API responses`);
+  sections.push("", `## Key Decisions
+<!-- Record architectural decisions as you make them -->`);
+  return sections.join("\n") + "\n";
+}
+
+// src/commands/init/generators/tasks-md.ts
+function generateTasksMd(options) {
+  return `# ${options.name} \u2014 Task Tracker
+
+> Claude: Read this at session start. Keep this file SHORT \u2014 only current state matters.
+> Rules: (1) Only show current + next sprint tasks. (2) Completed sprints get one summary line. (3) Session log: max 3 lines per session, keep only last 3 sessions. (4) Target: under 80 lines total.
+
+## Completed Sprints
+
+## Current Sprint: Sprint 1 \u2014 Setup
+
+### In Progress
+
+### To Do
+- [ ] Project scaffolding and environment setup
+- [ ] Core feature implementation
+- [ ] Test infrastructure
+
+### Done
+
+## Next Sprint: Sprint 2 \u2014 Core Features
+- [ ] ...
+
+## Session Log
+<!-- Keep last 3 sessions only. Max 3 lines each. -->
+`;
+}
+
+// src/commands/init/generators/settings.ts
+function generateSettings(detected) {
+  const preToolUse = [];
+  const postToolUse = [];
+  preToolUse.push({
+    matcher: "Read|Write|Edit",
+    hooks: [{
+      type: "command",
+      command: `echo "$TOOL_INPUT_FILE_PATH" | grep -qE '\\.(env|env\\..*)$' && ! echo "$TOOL_INPUT_FILE_PATH" | grep -q '.env.example' && echo 'BLOCKED: .env files contain secrets \u2014 use .env.example for documentation' && exit 1; exit 0`
+    }]
+  });
+  const formatHook = buildFormatHook(detected);
+  if (formatHook) {
+    postToolUse.push(formatHook);
+  }
+  const hooks = {};
+  if (preToolUse.length > 0) hooks.PreToolUse = preToolUse;
+  if (postToolUse.length > 0) hooks.PostToolUse = postToolUse;
+  return Object.keys(hooks).length > 0 ? { hooks } : {};
+}
+function buildFormatHook(detected) {
+  if (!detected.language) return null;
+  const formatters = {
+    TypeScript: {
+      extensions: ["ts", "tsx"],
+      command: detected.formatCommand ?? "npx prettier --write"
+    },
+    JavaScript: {
+      extensions: ["js", "jsx"],
+      command: detected.formatCommand ?? "npx prettier --write"
+    },
+    Python: {
+      extensions: ["py"],
+      command: detected.formatCommand ?? "ruff format"
+    },
+    Go: {
+      extensions: ["go"],
+      command: "gofmt -w"
+    },
+    Rust: {
+      extensions: ["rs"],
+      command: "rustfmt"
+    },
+    Ruby: {
+      extensions: ["rb"],
+      command: "rubocop -A"
+    },
+    Dart: {
+      extensions: ["dart"],
+      command: "dart format"
+    },
+    PHP: {
+      extensions: ["php"],
+      command: detected.formatCommand ?? "vendor/bin/pint"
+    },
+    Kotlin: {
+      extensions: ["kt", "kts"],
+      command: "ktlint -F"
+    },
+    Java: {
+      extensions: ["java"],
+      command: "google-java-format -i"
+    },
+    Swift: {
+      extensions: ["swift"],
+      command: "swift-format format -i"
+    },
+    Elixir: {
+      extensions: ["ex", "exs"],
+      command: "mix format"
+    },
+    "C#": {
+      extensions: ["cs"],
+      command: "dotnet format"
+    }
+  };
+  const config = formatters[detected.language];
+  if (!config) return null;
+  const extChecks = config.extensions.map((ext) => `[ "$ext" = "${ext}" ]`).join(" || ");
+  return {
+    matcher: "Write|Edit",
+    hooks: [{
+      type: "command",
+      command: `ext=\${TOOL_INPUT_FILE_PATH##*.}; (${extChecks}) && ${config.command} "$TOOL_INPUT_FILE_PATH" 2>/dev/null; exit 0`
+    }]
+  };
+}
+
+// src/commands/init/generators/claudeignore.ts
+function generateClaudeignore(detected) {
+  const sections = ["# Generated by claude-launchpad"];
+  sections.push(`
+# Dependencies
+node_modules/
+.pnp/
+.yarn/
+
+# Build output
+dist/
+build/
+out/
+.next/
+.nuxt/
+.output/
+.svelte-kit/
+.vercel/
+.turbo/
+
+# Package manager
+pnpm-lock.yaml
+package-lock.json
+yarn.lock
+bun.lockb
+
+# IDE & OS
+.vscode/
+.idea/
+*.swp
+*.swo
+.DS_Store
+Thumbs.db
+
+# Test & coverage
+coverage/
+.nyc_output/
+__snapshots__/
+
+# Environment (should never be read)
+.env
+.env.*
+!.env.example`);
+  const lang = detected.language;
+  if (lang === "Python") {
+    sections.push(`
+# Python
+__pycache__/
+*.pyc
+*.pyo
+.venv/
+venv/
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+*.egg-info/`);
+  }
+  if (lang === "Go") {
+    sections.push(`
+# Go
+bin/
+vendor/`);
+  }
+  if (lang === "Rust") {
+    sections.push(`
+# Rust
+target/
+Cargo.lock`);
+  }
+  if (lang === "Ruby") {
+    sections.push(`
+# Ruby
+vendor/bundle/
+.bundle/
+tmp/
+log/`);
+  }
+  if (lang === "Java" || lang === "Kotlin") {
+    sections.push(`
+# JVM
+target/
+build/
+.gradle/
+*.class
+*.jar`);
+  }
+  if (lang === "Dart") {
+    sections.push(`
+# Dart/Flutter
+.dart_tool/
+.packages
+build/`);
+  }
+  if (lang === "PHP") {
+    sections.push(`
+# PHP
+vendor/
+composer.lock`);
+  }
+  if (lang === "C#") {
+    sections.push(`
+# .NET
+bin/
+obj/
+*.dll`);
+  }
+  if (lang === "Elixir") {
+    sections.push(`
+# Elixir
+_build/
+deps/
+.elixir_ls/`);
+  }
+  if (lang === "Swift") {
+    sections.push(`
+# Swift
+.build/
+DerivedData/
+*.xcuserdata`);
+  }
+  return sections.join("\n") + "\n";
+}
+
+// src/commands/init/index.ts
+function createInitCommand() {
+  return new Command("init").description("Set up Claude Code configuration for any project").option("-n, --name <name>", "Project name").option("-y, --yes", "Accept all defaults").action(async (opts) => {
+    printBanner();
+    const root = process.cwd();
+    log.step("Detecting project...");
+    const detected = await detectProject(root);
+    if (detected.language) {
+      log.success(`Found ${detected.framework ?? detected.language} project`);
+      if (detected.packageManager) log.info(`Package manager: ${detected.packageManager}`);
+      if (detected.devCommand) log.info(`Dev command: ${detected.devCommand}`);
+      if (detected.testCommand) log.info(`Test command: ${detected.testCommand}`);
+    } else {
+      log.warn("Could not detect project type \u2014 generating minimal config");
+    }
+    log.blank();
+    const name = opts.name ?? detected.name ?? await input({
+      message: "Project name:",
+      validate: (v) => v.trim().length > 0 ? true : "Name cannot be empty"
+    });
+    const description = opts.yes ? "" : await input({
+      message: "One-line description (optional):"
+    });
+    const options = { name: name.trim(), description: description.trim() };
+    const hasClaudeMd = await fileExists2(join2(root, "CLAUDE.md"));
+    if (hasClaudeMd && !opts.yes) {
+      const overwrite = await confirm({
+        message: "CLAUDE.md already exists. Overwrite?",
+        default: false
+      });
+      if (!overwrite) {
+        log.info("Keeping existing CLAUDE.md");
+        log.step("Tip: run `claude-launchpad doctor` to check your existing config");
+        return;
+      }
+    }
+    await scaffold(root, options, detected);
+  });
+}
+async function scaffold(root, options, detected) {
+  log.step("Generating configuration...");
+  const claudeMd = generateClaudeMd(options, detected);
+  const tasksMd = generateTasksMd(options);
+  const settings = generateSettings(detected);
+  const claudeignore = generateClaudeignore(detected);
+  await mkdir(join2(root, ".claude"), { recursive: true });
+  const settingsPath = join2(root, ".claude", "settings.json");
+  const mergedSettings = await mergeSettings(settingsPath, settings);
+  const claudeignorePath = join2(root, ".claudeignore");
+  const hasClaudeignore = await fileExists2(claudeignorePath);
+  const writes = [
+    writeFile(join2(root, "CLAUDE.md"), claudeMd),
+    writeFile(join2(root, "TASKS.md"), tasksMd),
+    writeFile(settingsPath, JSON.stringify(mergedSettings, null, 2) + "\n")
+  ];
+  if (!hasClaudeignore) {
+    writes.push(writeFile(claudeignorePath, claudeignore));
+  }
+  await Promise.all(writes);
+  log.success("Generated CLAUDE.md");
+  log.success("Generated TASKS.md");
+  log.success("Generated .claude/settings.json (merged with existing)");
+  if (!hasClaudeignore) {
+    log.success("Generated .claudeignore");
+  }
+  log.blank();
+  log.success("Done! Run `claude` to start.");
+  log.info("Run `claude-launchpad doctor` to check your config quality.");
+  log.blank();
+}
+async function fileExists2(path) {
+  try {
+    await readFile2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function mergeSettings(existingPath, generated) {
+  try {
+    const existing = JSON.parse(await readFile2(existingPath, "utf-8"));
+    const existingHooks = existing.hooks ?? {};
+    const generatedHooks = generated.hooks ?? {};
+    const mergedHooks = { ...existingHooks };
+    for (const [event, hookList] of Object.entries(generatedHooks)) {
+      if (!mergedHooks[event]) {
+        mergedHooks[event] = hookList;
+      }
+    }
+    return {
+      ...existing,
+      ...generated,
+      hooks: Object.keys(mergedHooks).length > 0 ? mergedHooks : void 0
+    };
+  } catch {
+    return generated;
+  }
+}
+
+// src/commands/doctor/index.ts
+import { Command as Command2 } from "commander";
+
+// src/lib/parser.ts
+import { readFile as readFile3, readdir, access as access2 } from "fs/promises";
+import { join as join3, resolve } from "path";
+var CLAUDE_MD = "CLAUDE.md";
+var CLAUDE_DIR = ".claude";
+var SETTINGS_FILE = "settings.json";
+var RULES_DIR = "rules";
+async function parseClaudeConfig(projectRoot) {
+  const root = resolve(projectRoot);
+  const claudeDir = join3(root, CLAUDE_DIR);
+  const [claudeMd, settings, hooks, rules, mcpServers, skills] = await Promise.all([
+    readClaudeMd(root),
+    readSettings(claudeDir),
+    readHooks(claudeDir),
+    readRules(claudeDir),
+    readMcpServers(claudeDir),
+    readSkills(claudeDir)
+  ]);
+  const instructionCount = claudeMd ? countInstructions(claudeMd) : 0;
+  return {
+    claudeMdPath: claudeMd !== null ? join3(root, CLAUDE_MD) : null,
+    claudeMdContent: claudeMd,
+    claudeMdInstructionCount: instructionCount,
+    settingsPath: settings !== null ? join3(claudeDir, SETTINGS_FILE) : null,
+    settings,
+    hooks,
+    rules,
+    mcpServers,
+    skills
+  };
+}
+async function readClaudeMd(root) {
+  return readFileOrNull2(join3(root, CLAUDE_MD));
+}
+function countInstructions(content) {
+  const lines = content.split("\n");
+  let count = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    if (trimmed.startsWith("<!--") && trimmed.endsWith("-->")) continue;
+    if (trimmed.startsWith("```")) continue;
+    if (/^#{1,6}\s+\S/.test(trimmed)) continue;
+    count++;
+  }
+  return count;
+}
+async function readSettings(claudeDir) {
+  const raw = await readFileOrNull2(join3(claudeDir, SETTINGS_FILE));
+  if (raw === null) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function readHooks(claudeDir) {
+  const settingsRaw = await readFileOrNull2(join3(claudeDir, SETTINGS_FILE));
+  if (settingsRaw === null) return [];
+  try {
+    const settings = JSON.parse(settingsRaw);
+    const hooks = settings.hooks;
+    if (!hooks || typeof hooks !== "object") return [];
+    const result = [];
+    for (const [event, hookList] of Object.entries(hooks)) {
+      if (!Array.isArray(hookList)) continue;
+      for (const group of hookList) {
+        const g = group;
+        const matcher = g.matcher;
+        const nestedHooks = g.hooks;
+        if (Array.isArray(nestedHooks)) {
+          for (const hook of nestedHooks) {
+            const h = hook;
+            result.push({
+              event,
+              type: h.type ?? "command",
+              matcher,
+              command: h.command
+            });
+          }
+        } else {
+          result.push({
+            event,
+            type: g.type ?? "command",
+            matcher,
+            command: g.command
+          });
+        }
+      }
+    }
+    return result;
+  } catch {
+    return [];
+  }
+}
+async function readRules(claudeDir) {
+  const rulesDir = join3(claudeDir, RULES_DIR);
+  return listFilesRecursive(rulesDir, ".md");
+}
+async function readMcpServers(claudeDir) {
+  const settingsRaw = await readFileOrNull2(join3(claudeDir, SETTINGS_FILE));
+  if (settingsRaw === null) return [];
+  try {
+    const settings = JSON.parse(settingsRaw);
+    const servers = settings.mcpServers;
+    if (!servers || typeof servers !== "object") return [];
+    const result = [];
+    for (const [name, config] of Object.entries(servers)) {
+      const c = config;
+      result.push({
+        name,
+        transport: c.transport ?? "stdio",
+        command: c.command,
+        url: c.url
+      });
+    }
+    return result;
+  } catch {
+    return [];
+  }
+}
+async function readSkills(claudeDir) {
+  const commandsDir = join3(claudeDir, "commands");
+  const skillsDir = join3(claudeDir, "skills");
+  const [commands, skills] = await Promise.all([
+    listFilesRecursive(commandsDir, ".md"),
+    listFilesRecursive(skillsDir, ".md")
+  ]);
+  return [...commands, ...skills];
+}
+async function readFileOrNull2(path) {
+  try {
+    return await readFile3(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function listFilesRecursive(dir, ext) {
+  try {
+    await access2(dir);
+  } catch {
+    return [];
+  }
+  const results = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join3(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await listFilesRecursive(fullPath, ext);
+      results.push(...nested);
+    } else if (entry.name.endsWith(ext)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+// src/commands/doctor/analyzers/budget.ts
+var BUDGET_WARN = 120;
+var BUDGET_DANGER = 150;
+var BUDGET_CRITICAL = 200;
+async function analyzeBudget(config) {
+  const issues = [];
+  const count = config.claudeMdInstructionCount;
+  if (config.claudeMdContent === null) {
+    issues.push({
+      analyzer: "Budget",
+      severity: "high",
+      message: "No CLAUDE.md found",
+      fix: "Run `claude-launchpad init` or create CLAUDE.md manually"
+    });
+    return { name: "Instruction Budget", issues, score: 0 };
+  }
+  if (count === 0) {
+    issues.push({
+      analyzer: "Budget",
+      severity: "medium",
+      message: "CLAUDE.md exists but has no actionable instructions",
+      fix: "Add project-specific instructions to CLAUDE.md"
+    });
+    return { name: "Instruction Budget", issues, score: 30 };
+  }
+  if (count > BUDGET_CRITICAL) {
+    issues.push({
+      analyzer: "Budget",
+      severity: "critical",
+      message: `${count} instructions \u2014 way over the ~150 budget. Compliance drops significantly past 150.`,
+      fix: "Move detailed rules to .claude/rules/*.md files. Keep CLAUDE.md to essential project identity."
+    });
+  } else if (count > BUDGET_DANGER) {
+    issues.push({
+      analyzer: "Budget",
+      severity: "high",
+      message: `${count} instructions \u2014 over the ~150 budget. Claude may start ignoring lower-priority rules.`,
+      fix: "Move verbose sections (conventions, off-limits details) to .claude/rules/ files."
+    });
+  } else if (count > BUDGET_WARN) {
+    issues.push({
+      analyzer: "Budget",
+      severity: "medium",
+      message: `${count} instructions \u2014 approaching the ~150 budget.`,
+      fix: "Consider moving some rules to .claude/rules/ to leave headroom."
+    });
+  }
+  let score;
+  if (count <= BUDGET_WARN) {
+    score = 100;
+  } else if (count <= BUDGET_DANGER) {
+    score = 100 - Math.round((count - BUDGET_WARN) / (BUDGET_DANGER - BUDGET_WARN) * 30);
+  } else if (count <= BUDGET_CRITICAL) {
+    score = 70 - Math.round((count - BUDGET_DANGER) / (BUDGET_CRITICAL - BUDGET_DANGER) * 40);
+  } else {
+    score = Math.max(0, 30 - Math.round((count - BUDGET_CRITICAL) / 5));
+  }
+  return { name: "Instruction Budget", issues, score };
+}
+
+// src/commands/doctor/analyzers/settings.ts
+async function analyzeSettings(config) {
+  const issues = [];
+  if (config.settings === null) {
+    issues.push({
+      analyzer: "Settings",
+      severity: "medium",
+      message: "No .claude/settings.json found",
+      fix: "Run `claude-launchpad init` or create .claude/settings.json"
+    });
+    return { name: "Settings", issues, score: 40 };
+  }
+  const plugins = config.settings.enabledPlugins;
+  if (!plugins || Object.keys(plugins).length === 0) {
+    issues.push({
+      analyzer: "Settings",
+      severity: "low",
+      message: "No plugins enabled",
+      fix: "Consider enabling plugins for enhanced capabilities"
+    });
+  }
+  const permissions = config.settings.permissions;
+  if (!permissions) {
+    issues.push({
+      analyzer: "Settings",
+      severity: "low",
+      message: "No permission rules configured",
+      fix: "Add permission rules to control which tools Claude can use automatically"
+    });
+  }
+  const env = config.settings.env;
+  if (!env) {
+    issues.push({
+      analyzer: "Settings",
+      severity: "info",
+      message: "No environment variables defined in settings",
+      fix: "Define env vars in settings.json for consistent development environments"
+    });
+  }
+  const score = Math.max(0, 100 - issues.length * 15);
+  return { name: "Settings", issues, score };
+}
+
+// src/commands/doctor/analyzers/hooks.ts
+async function analyzeHooks(config) {
+  const issues = [];
+  const hooks = config.hooks;
+  if (hooks.length === 0) {
+    issues.push({
+      analyzer: "Hooks",
+      severity: "medium",
+      message: "No hooks configured \u2014 CLAUDE.md rules are advisory (~80% compliance), hooks are 100%",
+      fix: "Add PostToolUse hooks for auto-formatting and PreToolUse for security gates"
+    });
+    return { name: "Hooks", issues, score: 30 };
+  }
+  const formatPatterns = ["format", "prettier", "gofmt", "rustfmt", "rubocop", "pint", "ktlint", "swift-format", "dotnet format"];
+  const hasPostFormat = hooks.some(
+    (h) => h.event === "PostToolUse" && h.matcher?.includes("Write") && formatPatterns.some((p) => h.command?.includes(p))
+  );
+  if (!hasPostFormat) {
+    issues.push({
+      analyzer: "Hooks",
+      severity: "low",
+      message: "No auto-format hook found",
+      fix: "Add a PostToolUse hook that runs your formatter on Write|Edit"
+    });
+  }
+  const hasEnvProtection = hooks.some(
+    (h) => h.event === "PreToolUse" && h.command?.includes(".env")
+  );
+  if (!hasEnvProtection) {
+    issues.push({
+      analyzer: "Hooks",
+      severity: "medium",
+      message: "No .env file protection hook \u2014 Claude could read or write secrets in .env files",
+      fix: "Add a PreToolUse hook on Read|Write|Edit that blocks access to .env files"
+    });
+  }
+  const hasPreToolUse = hooks.some((h) => h.event === "PreToolUse");
+  if (!hasPreToolUse) {
+    issues.push({
+      analyzer: "Hooks",
+      severity: "medium",
+      message: "No PreToolUse hooks \u2014 this is your security enforcement layer",
+      fix: "Add PreToolUse hooks for file protection and dangerous command blocking"
+    });
+  }
+  const score = Math.max(0, 100 - issues.length * 20);
+  return { name: "Hooks", issues, score };
+}
+
+// src/commands/doctor/analyzers/rules.ts
+import { readFile as readFile4 } from "fs/promises";
+import { basename as basename2 } from "path";
+async function analyzeRules(config) {
+  const issues = [];
+  if (config.rules.length === 0) {
+    issues.push({
+      analyzer: "Rules",
+      severity: "low",
+      message: "No .claude/rules/ files found",
+      fix: "Move detailed conventions from CLAUDE.md to .claude/rules/*.md (auto-loaded, saves budget)"
+    });
+    return { name: "Rules", issues, score: 60 };
+  }
+  for (const rulePath of config.rules) {
+    try {
+      const content = await readFile4(rulePath, "utf-8");
+      const trimmed = content.trim();
+      if (trimmed.length === 0) {
+        issues.push({
+          analyzer: "Rules",
+          severity: "low",
+          message: `Empty rule file: ${basename2(rulePath)}`,
+          fix: `Add content to ${basename2(rulePath)} or delete it`
+        });
+      } else if (trimmed.length < 20) {
+        issues.push({
+          analyzer: "Rules",
+          severity: "info",
+          message: `Very short rule file (${trimmed.length} chars): ${basename2(rulePath)}`
+        });
+      }
+    } catch {
+      issues.push({
+        analyzer: "Rules",
+        severity: "low",
+        message: `Could not read rule file: ${basename2(rulePath)}`
+      });
+    }
+  }
+  const score = Math.max(0, 100 - issues.length * 10);
+  return { name: "Rules", issues, score };
+}
+
+// src/commands/doctor/analyzers/permissions.ts
+async function analyzePermissions(config) {
+  const issues = [];
+  const hasBashSecurity = config.hooks.some(
+    (h) => h.event === "PreToolUse" && (h.matcher?.includes("Bash") || !h.matcher)
+  );
+  const bashAllowed = config.settings?.allowedTools;
+  const hasBashAutoAllow = bashAllowed?.some(
+    (t) => typeof t === "string" && t.toLowerCase().includes("bash")
+  );
+  if (hasBashAutoAllow && !hasBashSecurity) {
+    issues.push({
+      analyzer: "Permissions",
+      severity: "high",
+      message: "Bash is auto-allowed without a security hook \u2014 dangerous commands could run unchecked",
+      fix: "Add a PreToolUse hook for Bash that blocks destructive commands (rm -rf, git push --force)"
+    });
+  }
+  const hasForceProtection = config.hooks.some(
+    (h) => h.event === "PreToolUse" && h.command?.includes("force")
+  );
+  if (!hasForceProtection) {
+    issues.push({
+      analyzer: "Permissions",
+      severity: "low",
+      message: "No force-push protection hook",
+      fix: "Add a PreToolUse hook that warns on `git push --force` commands"
+    });
+  }
+  if (config.claudeMdContent) {
+    const hasOffLimits = config.claudeMdContent.includes("## Off-Limits") || config.claudeMdContent.includes("## off-limits");
+    if (!hasOffLimits) {
+      issues.push({
+        analyzer: "Permissions",
+        severity: "medium",
+        message: "No Off-Limits section in CLAUDE.md \u2014 Claude has no guardrails beyond defaults",
+        fix: "Add an ## Off-Limits section with project-specific restrictions"
+      });
+    }
+  }
+  const score = Math.max(0, 100 - issues.length * 20);
+  return { name: "Permissions", issues, score };
+}
+
+// src/commands/doctor/analyzers/mcp.ts
+import { access as access3 } from "fs/promises";
+async function analyzeMcp(config) {
+  const issues = [];
+  const servers = config.mcpServers;
+  if (servers.length === 0) {
+    issues.push({
+      analyzer: "MCP",
+      severity: "info",
+      message: "No MCP servers configured \u2014 Claude can't connect to external tools",
+      fix: "Add MCP servers in .claude/settings.json for GitHub, database, docs, etc."
+    });
+    return { name: "MCP Servers", issues, score: 50 };
+  }
+  for (const server of servers) {
+    if (server.transport === "stdio" && !server.command) {
+      issues.push({
+        analyzer: "MCP",
+        severity: "high",
+        message: `MCP server "${server.name}" uses stdio transport but has no command`,
+        fix: `Add a "command" field to the "${server.name}" MCP server config`
+      });
+    }
+    if ((server.transport === "sse" || server.transport === "http") && !server.url) {
+      issues.push({
+        analyzer: "MCP",
+        severity: "high",
+        message: `MCP server "${server.name}" uses ${server.transport} transport but has no URL`,
+        fix: `Add a "url" field to the "${server.name}" MCP server config`
+      });
+    }
+    if (server.transport === "stdio" && server.command) {
+      const executable = server.command.split(" ")[0];
+      if (executable.startsWith("/") || executable.startsWith("./")) {
+        try {
+          await access3(executable);
+        } catch {
+          issues.push({
+            analyzer: "MCP",
+            severity: "medium",
+            message: `MCP server "${server.name}" command not found: ${executable}`,
+            fix: `Verify the path exists or install the required package`
+          });
+        }
+      }
+    }
+  }
+  const score = Math.max(0, 100 - issues.filter((i) => i.severity !== "info").length * 25);
+  return { name: "MCP Servers", issues, score };
+}
+
+// src/commands/doctor/analyzers/quality.ts
+var ESSENTIAL_SECTIONS = [
+  { pattern: /^##\s+Stack/m, name: "Stack", why: "Claude performs worse without knowing the tech stack" },
+  { pattern: /^##\s+Commands/m, name: "Commands", why: "Claude guesses wrong without explicit dev/build/test commands" },
+  { pattern: /^##\s+Session Start/m, name: "Session Start", why: "Without this, Claude won't read TASKS.md or maintain continuity" },
+  { pattern: /^##\s+Off.?Limits/m, name: "Off-Limits", why: "Without guardrails, Claude has no boundaries beyond defaults" },
+  { pattern: /^##\s+(Architecture|Project Structure)/m, name: "Architecture/Structure", why: "Claude makes better decisions when it understands the codebase shape" }
+];
+var VAGUE_PATTERNS = [
+  { pattern: /write (good|clean|quality|nice) code/i, label: "write good code" },
+  { pattern: /be (careful|thorough|diligent)/i, label: "be careful" },
+  { pattern: /follow best practices/i, label: "follow best practices" },
+  { pattern: /make sure (everything|it) works/i, label: "make sure it works" }
+];
+var SECRET_PATTERNS = [
+  { pattern: /sk-[a-zA-Z0-9]{20,}/, label: "OpenAI API key" },
+  { pattern: /ghp_[a-zA-Z0-9]{36}/, label: "GitHub personal token" },
+  { pattern: /AKIA[0-9A-Z]{16}/, label: "AWS access key" },
+  { pattern: /xoxb-[0-9]+-[a-zA-Z0-9]+/, label: "Slack bot token" }
+];
+async function analyzeQuality(config) {
+  const issues = [];
+  const content = config.claudeMdContent;
+  if (content === null) {
+    issues.push({
+      analyzer: "Quality",
+      severity: "high",
+      message: "No CLAUDE.md found",
+      fix: "Run `claude-launchpad init` to generate one"
+    });
+    return { name: "CLAUDE.md Quality", issues, score: 0 };
+  }
+  let sectionsFound = 0;
+  for (const section of ESSENTIAL_SECTIONS) {
+    if (section.pattern.test(content)) {
+      sectionsFound++;
+    } else {
+      issues.push({
+        analyzer: "Quality",
+        severity: "medium",
+        message: `Missing "## ${section.name}" section \u2014 ${section.why}`,
+        fix: `Add a ## ${section.name} section to CLAUDE.md`
+      });
+    }
+  }
+  for (const vague of VAGUE_PATTERNS) {
+    if (vague.pattern.test(content)) {
+      issues.push({
+        analyzer: "Quality",
+        severity: "low",
+        message: `Vague instruction detected: "${vague.label}" \u2014 zero signal, wastes budget`,
+        fix: "Replace with specific, actionable instructions"
+      });
+    }
+  }
+  for (const secret of SECRET_PATTERNS) {
+    if (secret.pattern.test(content)) {
+      issues.push({
+        analyzer: "Quality",
+        severity: "critical",
+        message: `Possible ${secret.label} found in CLAUDE.md \u2014 secrets must never be in config files`,
+        fix: "Remove the secret immediately and rotate it"
+      });
+    }
+  }
+  const todoCount = (content.match(/<!--\s*TODO/gi) ?? []).length;
+  if (todoCount > 3) {
+    issues.push({
+      analyzer: "Quality",
+      severity: "medium",
+      message: `${todoCount} TODO placeholders \u2014 CLAUDE.md is mostly unfinished`,
+      fix: "Fill in the TODO sections or remove them"
+    });
+  }
+  const criticals = issues.filter((i) => i.severity === "critical").length;
+  const highs = issues.filter((i) => i.severity === "high").length;
+  const mediums = issues.filter((i) => i.severity === "medium").length;
+  const lows = issues.filter((i) => i.severity === "low").length;
+  const score = Math.max(0, 100 - criticals * 40 - highs * 30 - mediums * 15 - lows * 5);
+  return { name: "CLAUDE.md Quality", issues, score };
+}
+
+// src/commands/doctor/fixer.ts
+import { readFile as readFile5, writeFile as writeFile2, mkdir as mkdir2, access as access4 } from "fs/promises";
+import { join as join4 } from "path";
+async function applyFixes(issues, projectRoot) {
+  const detected = await detectProject(projectRoot);
+  let fixed = 0;
+  let skipped = 0;
+  for (const issue of issues) {
+    const applied = await tryFix(issue, projectRoot, detected);
+    if (applied) {
+      fixed++;
+    } else {
+      skipped++;
+    }
+  }
+  return { fixed, skipped };
+}
+async function tryFix(issue, root, detected) {
+  if (issue.analyzer === "Hooks" && issue.message.includes(".env file protection")) {
+    return addEnvProtectionHook(root);
+  }
+  if (issue.analyzer === "Hooks" && issue.message.includes("auto-format")) {
+    return addAutoFormatHook(root, detected);
+  }
+  if (issue.analyzer === "Hooks" && issue.message.includes("No PreToolUse")) {
+    return addEnvProtectionHook(root);
+  }
+  if (issue.analyzer === "Quality" && issue.message.includes("Architecture")) {
+    return addClaudeMdSection(root, "## Architecture", "<!-- TODO: Describe your codebase structure. Run `claude-launchpad enhance` to auto-fill this. -->");
+  }
+  if (issue.analyzer === "Quality" && issue.message.includes("Off-Limits")) {
+    return addClaudeMdSection(root, "## Off-Limits", "- Never hardcode secrets \u2014 use environment variables\n- Never write to `.env` files\n- Never expose internal error details in API responses");
+  }
+  if (issue.analyzer === "Quality" && issue.message.includes("Commands")) {
+    return addClaudeMdSection(root, "## Commands", "<!-- TODO: Add your dev/build/test commands -->");
+  }
+  if (issue.analyzer === "Quality" && issue.message.includes("Stack")) {
+    const stackContent = detected.language ? `- **Language**: ${detected.language}${detected.framework ? `
+- **Framework**: ${detected.framework}` : ""}${detected.packageManager ? `
+- **Package Manager**: ${detected.packageManager}` : ""}` : "<!-- TODO: Define your tech stack -->";
+    return addClaudeMdSection(root, "## Stack", stackContent);
+  }
+  if (issue.analyzer === "Quality" && issue.message.includes("Session Start")) {
+    return addClaudeMdSection(root, "## Session Start", "- ALWAYS read @TASKS.md first \u2014 it tracks progress across sessions\n- Update TASKS.md as you complete work");
+  }
+  if (issue.analyzer === "Rules" && issue.message.includes("No .claude/rules/")) {
+    return createStarterRules(root);
+  }
+  if (issue.analyzer === "Permissions" && issue.message.includes("force-push")) {
+    return addForcePushProtection(root);
+  }
+  return false;
+}
+async function addEnvProtectionHook(root) {
+  const settings = await readSettingsJson(root);
+  const hooks = settings.hooks ?? {};
+  const preToolUse = hooks.PreToolUse ?? [];
+  const alreadyHas = preToolUse.some((g) => {
+    const nested = g.hooks;
+    return nested?.some((h) => String(h.command ?? "").includes(".env"));
+  });
+  if (alreadyHas) return false;
+  preToolUse.push({
+    matcher: "Read|Write|Edit",
+    hooks: [{
+      type: "command",
+      command: `echo "$TOOL_INPUT_FILE_PATH" | grep -qE '\\.(env|env\\..*)$' && ! echo "$TOOL_INPUT_FILE_PATH" | grep -q '.env.example' && echo 'BLOCKED: .env files contain secrets' && exit 1; exit 0`
+    }]
+  });
+  settings.hooks = { ...hooks, PreToolUse: preToolUse };
+  await writeSettingsJson(root, settings);
+  log.success("Added .env file protection hook (PreToolUse)");
+  return true;
+}
+async function addAutoFormatHook(root, detected) {
+  if (!detected.language) return false;
+  const formatters = {
+    TypeScript: { extensions: ["ts", "tsx"], command: detected.formatCommand ?? "npx prettier --write" },
+    JavaScript: { extensions: ["js", "jsx"], command: detected.formatCommand ?? "npx prettier --write" },
+    Python: { extensions: ["py"], command: detected.formatCommand ?? "ruff format" },
+    Go: { extensions: ["go"], command: "gofmt -w" },
+    Rust: { extensions: ["rs"], command: "rustfmt" },
+    Ruby: { extensions: ["rb"], command: "rubocop -A" },
+    PHP: { extensions: ["php"], command: detected.formatCommand ?? "vendor/bin/pint" }
+  };
+  const config = formatters[detected.language];
+  if (!config) return false;
+  const settings = await readSettingsJson(root);
+  const hooks = settings.hooks ?? {};
+  const postToolUse = hooks.PostToolUse ?? [];
+  const alreadyHas = postToolUse.some((g) => {
+    const nested = g.hooks;
+    return nested?.some((h) => String(h.command ?? "").includes("format"));
+  });
+  if (alreadyHas) return false;
+  const extChecks = config.extensions.map((ext) => `[ "$ext" = "${ext}" ]`).join(" || ");
+  postToolUse.push({
+    matcher: "Write|Edit",
+    hooks: [{
+      type: "command",
+      command: `ext=\${TOOL_INPUT_FILE_PATH##*.}; (${extChecks}) && ${config.command} "$TOOL_INPUT_FILE_PATH" 2>/dev/null; exit 0`
+    }]
+  });
+  settings.hooks = { ...hooks, PostToolUse: postToolUse };
+  await writeSettingsJson(root, settings);
+  log.success(`Added auto-format hook (PostToolUse \u2192 ${config.command})`);
+  return true;
+}
+async function addForcePushProtection(root) {
+  const settings = await readSettingsJson(root);
+  const hooks = settings.hooks ?? {};
+  const preToolUse = hooks.PreToolUse ?? [];
+  const alreadyHas = preToolUse.some((g) => {
+    const nested = g.hooks;
+    return nested?.some((h) => String(h.command ?? "").includes("force"));
+  });
+  if (alreadyHas) return false;
+  preToolUse.push({
+    matcher: "Bash",
+    hooks: [{
+      type: "command",
+      command: `echo "$TOOL_INPUT_COMMAND" | grep -qE 'push.*--force|push.*-f' && echo 'WARNING: Force push detected \u2014 this can destroy remote history' && exit 1; exit 0`
+    }]
+  });
+  settings.hooks = { ...hooks, PreToolUse: preToolUse };
+  await writeSettingsJson(root, settings);
+  log.success("Added force-push protection hook (PreToolUse \u2192 Bash)");
+  return true;
+}
+async function addClaudeMdSection(root, heading, content) {
+  const claudeMdPath = join4(root, "CLAUDE.md");
+  let existing;
+  try {
+    existing = await readFile5(claudeMdPath, "utf-8");
+  } catch {
+    return false;
+  }
+  if (existing.includes(heading)) return false;
+  const keyDecisionsIdx = existing.indexOf("## Key Decisions");
+  const insertAt = keyDecisionsIdx > -1 ? keyDecisionsIdx : existing.length;
+  const section = `
+${heading}
+${content}
+
+`;
+  const updated = existing.slice(0, insertAt) + section + existing.slice(insertAt);
+  await writeFile2(claudeMdPath, updated);
+  log.success(`Added "${heading}" section to CLAUDE.md`);
+  return true;
+}
+async function createStarterRules(root) {
+  const rulesDir = join4(root, ".claude", "rules");
+  try {
+    await access4(rulesDir);
+    return false;
+  } catch {
+  }
+  await mkdir2(rulesDir, { recursive: true });
+  await writeFile2(
+    join4(rulesDir, "conventions.md"),
+    `# Project Conventions
+
+- Use conventional commits (feat:, fix:, docs:, refactor:, test:, chore:)
+- Keep files under 400 lines, functions under 50 lines
+- Handle errors explicitly \u2014 no empty catch blocks
+- Validate input at system boundaries
+`
+  );
+  log.success("Created .claude/rules/conventions.md with starter rules");
+  return true;
+}
+async function readSettingsJson(root) {
+  const path = join4(root, ".claude", "settings.json");
+  try {
+    const content = await readFile5(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function writeSettingsJson(root, settings) {
+  const dir = join4(root, ".claude");
+  await mkdir2(dir, { recursive: true });
+  await writeFile2(join4(dir, "settings.json"), JSON.stringify(settings, null, 2) + "\n");
+}
+
+// src/commands/doctor/index.ts
+function createDoctorCommand() {
+  return new Command2("doctor").description("Diagnose your Claude Code configuration and report issues").option("-p, --path <path>", "Project root path", process.cwd()).option("--json", "Output as JSON").option("--min-score <n>", "Exit non-zero if overall score is below this threshold (for CI)").option("--fix", "Auto-apply deterministic fixes for detected issues").action(async (opts) => {
+    printBanner();
+    log.step("Scanning Claude Code configuration...");
+    log.blank();
+    const config = await parseClaudeConfig(opts.path);
+    if (config.claudeMdContent === null && config.settings === null) {
+      log.error("No Claude Code configuration found in this directory.");
+      log.info("Run `claude-launchpad init` to set up a project, or cd into a configured project.");
+      process.exit(1);
+    }
+    const results = await Promise.all([
+      analyzeBudget(config),
+      analyzeQuality(config),
+      analyzeSettings(config),
+      analyzeHooks(config),
+      analyzeRules(config),
+      analyzePermissions(config),
+      analyzeMcp(config)
+    ]);
+    if (opts.json) {
+      const overallScore = Math.round(
+        results.reduce((sum, r) => sum + r.score, 0) / results.length
+      );
+      console.log(JSON.stringify({ overallScore, analyzers: results, timestamp: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+      return;
+    }
+    renderReport(results);
+    if (opts.fix) {
+      const allIssues = results.flatMap((r) => r.issues);
+      const fixable = allIssues.filter((i) => i.severity !== "info");
+      if (fixable.length > 0) {
+        log.blank();
+        log.step("Applying fixes...");
+        log.blank();
+        const { fixed, skipped } = await applyFixes(fixable, opts.path);
+        log.blank();
+        if (fixed > 0) {
+          log.success(`Applied ${fixed} fix(es). Run \`claude-launchpad doctor\` again to see your new score.`);
+        }
+        if (skipped > 0) {
+          log.info(`${skipped} issue(s) require manual intervention.`);
+        }
+      }
+    }
+    if (opts.minScore) {
+      const overallScore = Math.round(
+        results.reduce((sum, r) => sum + r.score, 0) / results.length
+      );
+      const threshold = parseInt(opts.minScore, 10);
+      if (overallScore < threshold) {
+        process.exit(1);
+      }
+    }
+  });
+}
+function renderReport(results) {
+  const overallScore = Math.round(
+    results.reduce((sum, r) => sum + r.score, 0) / results.length
+  );
+  for (const result of results) {
+    printScoreCard(result.name, result.score);
+  }
+  log.blank();
+  printScoreCard("Overall", overallScore);
+  log.blank();
+  const allIssues = results.flatMap((r) => r.issues);
+  const actionable = allIssues.filter((i) => i.severity !== "info");
+  if (actionable.length === 0) {
+    log.success("No issues found. Your configuration looks solid.");
+    return;
+  }
+  for (const issue of sortBySeverity(actionable)) {
+    printIssue(issue.severity, issue.analyzer, issue.message, issue.fix);
+  }
+  log.info(`${actionable.length} issue(s) found. Fix critical/high first.`);
+}
+function sortBySeverity(issues) {
+  const order = { critical: 0, high: 1, medium: 2, low: 3, info: 4 };
+  return [...issues].sort((a, b) => (order[a.severity] ?? 4) - (order[b.severity] ?? 4));
+}
+
+// src/commands/eval/index.ts
+import { Command as Command3 } from "commander";
+import ora from "ora";
+import chalk2 from "chalk";
+
+// src/commands/eval/loader.ts
+import { readFile as readFile6, readdir as readdir2, access as access5 } from "fs/promises";
+import { join as join5, resolve as resolve2, dirname } from "path";
+import { fileURLToPath } from "url";
+import { parse as parseYaml } from "yaml";
+
+// src/commands/eval/schema.ts
+function validateScenario(raw, filePath) {
+  if (!raw || typeof raw !== "object") {
+    throw new ScenarioError(filePath, "Scenario must be a YAML object");
+  }
+  const obj = raw;
+  const name = requireString(obj, "name", filePath);
+  const description = requireString(obj, "description", filePath);
+  const prompt = requireString(obj, "prompt", filePath);
+  const setup = validateSetup(obj.setup, filePath);
+  const checks = validateChecks(obj.checks, filePath);
+  const passingScore = requireNumber(obj, "passingScore", filePath);
+  const runs = optionalNumber(obj, "runs") ?? 3;
+  return { name, description, setup, prompt, checks, passingScore, runs };
+}
+function validateSetup(raw, filePath) {
+  if (!raw || typeof raw !== "object") {
+    throw new ScenarioError(filePath, '"setup" must be an object with a "files" array');
+  }
+  const obj = raw;
+  const files = obj.files;
+  if (!Array.isArray(files)) {
+    throw new ScenarioError(filePath, '"setup.files" must be an array');
+  }
+  const validatedFiles = files.map((f, i) => {
+    if (!f || typeof f !== "object") {
+      throw new ScenarioError(filePath, `setup.files[${i}] must be an object`);
+    }
+    const file = f;
+    if (typeof file.path !== "string" || typeof file.content !== "string") {
+      throw new ScenarioError(filePath, `setup.files[${i}] must have "path" and "content" strings`);
+    }
+    return { path: file.path, content: file.content };
+  });
+  const instructions = typeof obj.instructions === "string" ? obj.instructions : void 0;
+  return { files: validatedFiles, instructions };
+}
+function validateChecks(raw, filePath) {
+  if (!Array.isArray(raw) || raw.length === 0) {
+    throw new ScenarioError(filePath, '"checks" must be a non-empty array');
+  }
+  return raw.map((c, i) => {
+    if (!c || typeof c !== "object") {
+      throw new ScenarioError(filePath, `checks[${i}] must be an object`);
+    }
+    const check = c;
+    const validTypes = ["grep", "file-exists", "file-absent", "custom"];
+    if (!validTypes.includes(check.type)) {
+      throw new ScenarioError(filePath, `checks[${i}].type must be one of: ${validTypes.join(", ")}`);
+    }
+    if (typeof check.target !== "string") {
+      throw new ScenarioError(filePath, `checks[${i}].target must be a string`);
+    }
+    const validExpect = ["present", "absent"];
+    if (!validExpect.includes(check.expect)) {
+      throw new ScenarioError(filePath, `checks[${i}].expect must be "present" or "absent"`);
+    }
+    if (typeof check.points !== "number" || check.points < 0) {
+      throw new ScenarioError(filePath, `checks[${i}].points must be a non-negative number`);
+    }
+    if (typeof check.label !== "string") {
+      throw new ScenarioError(filePath, `checks[${i}].label must be a string`);
+    }
+    return {
+      type: check.type,
+      pattern: typeof check.pattern === "string" ? check.pattern : void 0,
+      target: check.target,
+      expect: check.expect,
+      points: check.points,
+      label: check.label
+    };
+  });
+}
+function requireString(obj, key, filePath) {
+  if (typeof obj[key] !== "string" || obj[key] === "") {
+    throw new ScenarioError(filePath, `"${key}" must be a non-empty string`);
+  }
+  return obj[key];
+}
+function requireNumber(obj, key, filePath) {
+  if (typeof obj[key] !== "number") {
+    throw new ScenarioError(filePath, `"${key}" must be a number`);
+  }
+  return obj[key];
+}
+function optionalNumber(obj, key) {
+  if (obj[key] === void 0) return void 0;
+  if (typeof obj[key] !== "number") return void 0;
+  return obj[key];
+}
+var ScenarioError = class extends Error {
+  constructor(filePath, message) {
+    super(`Invalid scenario ${filePath}: ${message}`);
+    this.name = "ScenarioError";
+  }
+};
+
+// src/commands/eval/loader.ts
+async function findScenariosDir() {
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  const devPath = resolve2(thisDir, "../../../scenarios");
+  if (await dirExists(devPath)) return devPath;
+  const bundledPath = resolve2(thisDir, "../scenarios");
+  if (await dirExists(bundledPath)) return bundledPath;
+  const rootPath = resolve2(thisDir, "../../scenarios");
+  if (await dirExists(rootPath)) return rootPath;
+  return devPath;
+}
+async function dirExists(path) {
+  try {
+    await access5(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadScenarios(options) {
+  const { suite, customPath } = options;
+  const scenarioDir = customPath ? resolve2(customPath) : await findScenariosDir();
+  const dirs = suite ? [join5(scenarioDir, suite)] : await getSubdirectories(scenarioDir);
+  const allDirs = [scenarioDir, ...dirs];
+  const scenarios = [];
+  for (const dir of allDirs) {
+    const files = await listYamlFiles(dir);
+    for (const file of files) {
+      try {
+        const content = await readFile6(file, "utf-8");
+        const raw = parseYaml(content);
+        const scenario = validateScenario(raw, file);
+        scenarios.push(scenario);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.warn(`  Warning: Skipping ${file}: ${msg}`);
+      }
+    }
+  }
+  return scenarios;
+}
+async function getSubdirectories(dir) {
+  try {
+    const entries = await readdir2(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => join5(dir, e.name));
+  } catch {
+    return [];
+  }
+}
+async function listYamlFiles(dir) {
+  try {
+    const entries = await readdir2(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && (e.name.endsWith(".yaml") || e.name.endsWith(".yml"))).map((e) => join5(dir, e.name));
+  } catch {
+    return [];
+  }
+}
+
+// src/commands/eval/runner.ts
+import { mkdir as mkdir3, writeFile as writeFile3, readFile as readFile7, rm, cp } from "fs/promises";
+import { join as join6, dirname as dirname2 } from "path";
+import { tmpdir } from "os";
+import { randomUUID } from "crypto";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var exec = promisify(execFile);
+async function runScenario(scenario, options) {
+  const sandboxDir = join6(tmpdir(), `claude-eval-${randomUUID()}`);
+  try {
+    await mkdir3(sandboxDir, { recursive: true });
+    for (const file of scenario.setup.files) {
+      const filePath = join6(sandboxDir, file.path);
+      await mkdir3(dirname2(filePath), { recursive: true });
+      await writeFile3(filePath, file.content);
+    }
+    const claudeDir = join6(options.projectRoot, ".claude");
+    const sandboxClaudeDir = join6(sandboxDir, ".claude");
+    try {
+      await cp(claudeDir, sandboxClaudeDir, { recursive: true });
+    } catch {
+    }
+    if (scenario.setup.instructions) {
+      await writeFile3(
+        join6(sandboxDir, "CLAUDE.md"),
+        `# Eval Scenario
+
+${scenario.setup.instructions}
+`
+      );
+    }
+    await exec("git", ["init", "-q"], { cwd: sandboxDir });
+    await exec("git", ["add", "-A"], { cwd: sandboxDir });
+    await exec("git", [
+      "-c",
+      "user.name=eval",
+      "-c",
+      "user.email=eval@test",
+      "commit",
+      "-q",
+      "-m",
+      "eval setup"
+    ], { cwd: sandboxDir });
+    await runClaude(sandboxDir, scenario.prompt, options.timeout);
+    const checkResults = await evaluateChecks(scenario.checks, sandboxDir);
+    const score = checkResults.filter((c) => c.passed).reduce((sum, c) => sum + c.points, 0);
+    const maxScore = scenario.checks.reduce((sum, c) => sum + c.points, 0);
+    return {
+      scenario: scenario.name,
+      score,
+      maxScore,
+      passed: score >= scenario.passingScore,
+      checks: checkResults
+    };
+  } finally {
+    if (options.debug) {
+      console.log(`  DEBUG: Sandbox preserved at ${sandboxDir}`);
+    } else {
+      await rm(sandboxDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+  }
+}
+async function runScenarioWithRetries(scenario, options) {
+  const results = [];
+  for (let i = 0; i < scenario.runs; i++) {
+    const result = await runScenario(scenario, options);
+    results.push(result);
+  }
+  const sorted = [...results].sort((a, b) => a.score - b.score);
+  return sorted[Math.floor(sorted.length / 2)];
+}
+async function runClaude(cwd, prompt, timeout) {
+  try {
+    return await exec(
+      "claude",
+      [
+        "-p",
+        prompt,
+        "--output-format",
+        "text",
+        "--max-turns",
+        "20",
+        "--dangerously-skip-permissions",
+        "--allowedTools",
+        "Read",
+        "Write",
+        "Edit",
+        "Bash",
+        "Glob",
+        "Grep"
+      ],
+      {
+        cwd,
+        timeout,
+        maxBuffer: 10 * 1024 * 1024
+      }
+    );
+  } catch (error) {
+    if (error && typeof error === "object" && "stdout" in error) {
+      return {
+        stdout: String(error.stdout ?? ""),
+        stderr: String(error.stderr ?? "")
+      };
+    }
+    throw error;
+  }
+}
+async function evaluateChecks(checks, sandboxDir) {
+  const results = [];
+  for (const check of checks) {
+    const passed = await evaluateSingleCheck(check, sandboxDir);
+    results.push({ label: check.label, passed, points: check.points });
+  }
+  return results;
+}
+async function evaluateSingleCheck(check, sandboxDir) {
+  switch (check.type) {
+    case "grep": {
+      if (!check.pattern) return false;
+      try {
+        const content = await readFile7(join6(sandboxDir, check.target), "utf-8");
+        const found = new RegExp(check.pattern).test(content);
+        return check.expect === "present" ? found : !found;
+      } catch {
+        return check.expect === "absent";
+      }
+    }
+    case "file-exists": {
+      try {
+        await readFile7(join6(sandboxDir, check.target));
+        return check.expect === "present";
+      } catch {
+        return check.expect === "absent";
+      }
+    }
+    case "file-absent": {
+      try {
+        await readFile7(join6(sandboxDir, check.target));
+        return check.expect === "absent";
+      } catch {
+        return check.expect === "present";
+      }
+    }
+    case "custom":
+      return false;
+    default:
+      return false;
+  }
+}
+
+// src/commands/eval/index.ts
+function createEvalCommand() {
+  return new Command3("eval").description("Test your Claude Code config against eval scenarios").option("-s, --suite <suite>", "Eval suite to run (e.g., security, conventions, workflow)").option("-p, --path <path>", "Project root path", process.cwd()).option("--scenarios <path>", "Custom scenarios directory").option("--runs <n>", "Runs per scenario (default: 3)", "3").option("--timeout <ms>", "Timeout per run in ms (default: 120000)", "120000").option("--json", "Output as JSON").option("--debug", "Keep sandbox directories for inspection").action(async (opts) => {
+    printBanner();
+    const claudeAvailable = await checkClaudeCli();
+    if (!claudeAvailable) {
+      log.error("Claude CLI not found. Install it: https://docs.anthropic.com/en/docs/claude-code");
+      log.info("The eval command runs Claude headless against scenarios \u2014 it requires the CLI.");
+      process.exit(1);
+    }
+    log.step("Loading eval scenarios...");
+    const scenarios = await loadScenarios({
+      suite: opts.suite,
+      customPath: opts.scenarios
+    });
+    if (scenarios.length === 0) {
+      log.warn("No matching scenarios found.");
+      if (opts.suite) {
+        log.info(`Check that the suite "${opts.suite}" exists in the scenarios directory.`);
+      }
+      return;
+    }
+    log.success(`Loaded ${scenarios.length} scenario(s)`);
+    log.blank();
+    const runs = parseInt(opts.runs, 10);
+    const timeout = parseInt(opts.timeout, 10);
+    const results = [];
+    for (const scenario of scenarios) {
+      const spinner = ora({
+        text: `Running: ${scenario.name} (${runs} run${runs > 1 ? "s" : ""})`,
+        prefixText: "  "
+      }).start();
+      try {
+        const result = await runScenarioWithRetries(
+          { ...scenario, runs },
+          { projectRoot: opts.path, timeout, debug: opts.debug }
+        );
+        results.push(result);
+        if (result.passed) {
+          spinner.succeed(`${scenario.name}  ${result.score}/${result.maxScore}`);
+        } else {
+          spinner.fail(`${scenario.name}  ${result.score}/${result.maxScore}`);
+        }
+      } catch (error) {
+        spinner.fail(`${scenario.name}  ERROR`);
+        const msg = error instanceof Error ? error.message : String(error);
+        log.error(`  ${msg}`);
+        results.push({
+          scenario: scenario.name,
+          score: 0,
+          maxScore: scenario.checks.reduce((s, c) => s + c.points, 0),
+          passed: false,
+          checks: scenario.checks.map((c) => ({ label: c.label, passed: false, points: c.points }))
+        });
+      }
+    }
+    log.blank();
+    if (opts.json) {
+      const overallScore = results.reduce((s, r) => s + r.score, 0);
+      const overallMax = results.reduce((s, r) => s + r.maxScore, 0);
+      console.log(JSON.stringify({
+        results,
+        overallScore,
+        overallMax,
+        passed: overallScore >= overallMax * 0.8,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }, null, 2));
+      return;
+    }
+    renderEvalReport(results);
+  });
+}
+function renderEvalReport(results) {
+  for (const result of results) {
+    const icon = result.passed ? chalk2.green("\u2713") : chalk2.red("\u2717");
+    const status = result.passed ? chalk2.green("PASS") : chalk2.red("FAIL");
+    const score = `${result.score}/${result.maxScore}`;
+    console.log(`  ${icon} ${chalk2.bold(result.scenario)}  ${score}  ${status}`);
+    const failedChecks = result.checks.filter((c) => !c.passed);
+    for (const check of failedChecks) {
+      console.log(`    ${chalk2.dim("\u2500")} ${chalk2.dim(check.label)}`);
+    }
+  }
+  log.blank();
+  const totalScore = results.reduce((s, r) => s + r.score, 0);
+  const totalMax = results.reduce((s, r) => s + r.maxScore, 0);
+  const pct = totalMax > 0 ? Math.round(totalScore / totalMax * 100) : 0;
+  printScoreCard("Config Eval Score", pct);
+  log.blank();
+  const passed = results.filter((r) => r.passed).length;
+  const failed = results.length - passed;
+  if (failed === 0) {
+    log.success(`All ${passed} scenario(s) passed.`);
+  } else {
+    log.warn(`${passed} passed, ${failed} failed out of ${results.length} scenario(s).`);
+  }
+}
+async function checkClaudeCli() {
+  const { execFile: execFile3 } = await import("child_process");
+  const { promisify: promisify3 } = await import("util");
+  const exec2 = promisify3(execFile3);
+  try {
+    await exec2("claude", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/enhance/index.ts
+import { Command as Command4 } from "commander";
+import { spawn, execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { access as access6 } from "fs/promises";
+import { join as join7 } from "path";
+var execAsync = promisify2(execFile2);
+var ENHANCE_PROMPT = `Read CLAUDE.md and the project's codebase, then update CLAUDE.md to fill in missing or incomplete sections:
+
+1. **## Architecture** or **## Project Structure** \u2014 describe the actual codebase structure (directories, key files, data flow)
+2. **## Conventions** \u2014 add project-specific patterns you observe (naming, imports, state management, API patterns)
+3. **## Off-Limits** \u2014 add guardrails based on what you see (protected files, patterns to avoid, things that should never change)
+4. **## Key Decisions** \u2014 document any architectural decisions visible in the code
+
+Rules:
+- Keep CLAUDE.md under 150 instructions (lines of actionable content)
+- Don't remove existing content \u2014 only add or improve
+- Be specific to THIS project, not generic advice
+- Use bullet points, not paragraphs`;
+function createEnhanceCommand() {
+  return new Command4("enhance").description("Use Claude to analyze your codebase and complete CLAUDE.md").option("-p, --path <path>", "Project root path", process.cwd()).action(async (opts) => {
+    printBanner();
+    const root = opts.path;
+    const claudeMdPath = join7(root, "CLAUDE.md");
+    try {
+      await access6(claudeMdPath);
+    } catch {
+      log.error("No CLAUDE.md found. Run `claude-launchpad init` first.");
+      process.exit(1);
+    }
+    try {
+      await execAsync("claude", ["--version"]);
+    } catch {
+      log.error("Claude CLI not found. Install it: https://docs.anthropic.com/en/docs/claude-code");
+      process.exit(1);
+    }
+    log.step("Launching Claude to enhance your CLAUDE.md...");
+    log.blank();
+    const child = spawn(
+      "claude",
+      [ENHANCE_PROMPT],
+      { cwd: root, stdio: "inherit" }
+    );
+    await new Promise((resolve3) => {
+      child.on("close", (code) => resolve3(code ?? 0));
+    });
+    log.blank();
+    log.success("Run `claude-launchpad doctor` to check your updated score.");
+  });
+}
+
+// src/cli.ts
+var program = new Command5().name("claude-launchpad").description("CLI toolkit that makes Claude Code setups measurably good").version("0.1.0").action(async () => {
+  const hasConfig = await fileExists3(join8(process.cwd(), "CLAUDE.md")) || await fileExists3(join8(process.cwd(), ".claude", "settings.json"));
+  if (hasConfig) {
+    await program.commands.find((c) => c.name() === "doctor")?.parseAsync([], { from: "user" });
+  } else {
+    printBanner();
+    log.info("No Claude Code config found in this directory.");
+    log.blank();
+    log.step("Run `claude-launchpad init` to set up your project");
+    log.step("Run `claude-launchpad doctor` to diagnose an existing config");
+    log.step("Run `claude-launchpad eval` to test your config quality");
+    log.blank();
+  }
+});
+program.addCommand(createInitCommand());
+program.addCommand(createDoctorCommand());
+program.addCommand(createEnhanceCommand());
+program.addCommand(createEvalCommand());
+program.parse();
+async function fileExists3(path) {
+  try {
+    await access7(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+//# sourceMappingURL=cli.js.map