claude-launchpad 0.15.2 → 0.16.1

package/dist/chunk-S4WIADYE.js

@@ -0,0 +1,1139 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/fs-utils.ts
+import { readFile, access } from "fs/promises";
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readFileOrNull(path) {
+  try {
+    return await readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function readJsonOrNull(path) {
+  try {
+    const content = await readFile(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/settings.ts
+import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+async function readSettingsJson(root) {
+  const path = join(root, ".claude", "settings.json");
+  try {
+    const content = await readFile2(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function writeSettingsJson(root, settings) {
+  const dir = join(root, ".claude");
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, "settings.json"), JSON.stringify(settings, null, 2) + "\n");
+}
+async function readSettingsLocalJson(root) {
+  const path = join(root, ".claude", "settings.local.json");
+  try {
+    const content = await readFile2(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function writeSettingsLocalJson(root, settings) {
+  const dir = join(root, ".claude");
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, "settings.local.json"), JSON.stringify(settings, null, 2) + "\n");
+}
+
+// src/lib/memory-placement.ts
+import { select } from "@inquirer/prompts";
+function hasMemoryPermissions(settings) {
+  const permissions = settings.permissions;
+  const allow = permissions?.allow ?? [];
+  return allow.some((p) => p.includes("agentic-memory"));
+}
+async function getMemoryPlacement(root, skipPrompt = false) {
+  const local = await readSettingsLocalJson(root);
+  const persisted = local.memoryPlacement;
+  if (persisted === "shared" || persisted === "local") {
+    return persisted;
+  }
+  if (hasMemoryPermissions(local)) {
+    await writeSettingsLocalJson(root, { ...local, memoryPlacement: "local" });
+    return "local";
+  }
+  const shared = await readSettingsJson(root);
+  if (hasMemoryPermissions(shared)) {
+    await writeSettingsLocalJson(root, { ...local, memoryPlacement: "shared" });
+    return "shared";
+  }
+  if (skipPrompt) return "shared";
+  const choice = await select({
+    message: "Where should memory config go?",
+    choices: [
+      { value: "shared", name: "Shared (team sees it) \u2014 CLAUDE.md + settings.json" },
+      { value: "local", name: "Local (only you) \u2014 .claude/CLAUDE.md + settings.local.json" }
+    ]
+  });
+  await writeSettingsLocalJson(root, { ...local, memoryPlacement: choice });
+  return choice;
+}
+
+// src/lib/output.ts
+import chalk from "chalk";
+
+// src/commands/doctor/fixer.ts
+import { readFile as readFile4, writeFile as writeFile2, mkdir as mkdir2, access as access2 } from "fs/promises";
+import { join as join4 } from "path";
+import { homedir } from "os";
+
+// src/lib/detect.ts
+import { join as join2, basename } from "path";
+async function detectProject(root) {
+  const name = basename(root);
+  const [pkgJson, goMod, pyProject, gemfile, cargo, pubspec, composerJson, pomXml, buildGradleGroovy, buildGradleKts, packageSwift, mixExs, csproj, lockfiles] = await Promise.all([
+    readJsonOrNull(join2(root, "package.json")),
+    fileExists(join2(root, "go.mod")),
+    readFileOrNull(join2(root, "pyproject.toml")),
+    fileExists(join2(root, "Gemfile")),
+    fileExists(join2(root, "Cargo.toml")),
+    fileExists(join2(root, "pubspec.yaml")),
+    readJsonOrNull(join2(root, "composer.json")),
+    fileExists(join2(root, "pom.xml")),
+    fileExists(join2(root, "build.gradle")),
+    fileExists(join2(root, "build.gradle.kts")),
+    fileExists(join2(root, "Package.swift")),
+    fileExists(join2(root, "mix.exs")),
+    globExists(root, "*.csproj"),
+    detectLockfiles(root)
+  ]);
+  const buildGradle = buildGradleGroovy || buildGradleKts;
+  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(join2(root, "pnpm-lock.yaml")),
+    fileExists(join2(root, "yarn.lock")),
+    fileExists(join2(root, "bun.lockb")),
+    fileExists(join2(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;
+}
+var LANGUAGE_SCRIPTS = {
+  Go: { devCommand: "go run .", buildCommand: "go build .", testCommand: "go test ./...", lintCommand: "golangci-lint run", formatCommand: "gofmt -w ." },
+  Ruby: { devCommand: "bin/dev", buildCommand: null, testCommand: "bin/rails test", lintCommand: "bin/rubocop", formatCommand: null },
+  PHP: { devCommand: "php artisan serve", buildCommand: null, testCommand: "php artisan test", lintCommand: "vendor/bin/phpstan analyse", formatCommand: "vendor/bin/pint" },
+  Rust: { devCommand: "cargo run", buildCommand: "cargo build", testCommand: "cargo test", lintCommand: "cargo clippy", formatCommand: "cargo fmt" },
+  Java: { devCommand: null, buildCommand: "mvn package", testCommand: "mvn test", lintCommand: null, formatCommand: null },
+  Kotlin: { devCommand: null, buildCommand: "mvn package", testCommand: "mvn test", lintCommand: null, formatCommand: null },
+  Swift: { devCommand: null, buildCommand: "swift build", testCommand: "swift test", lintCommand: "swiftlint", formatCommand: "swift-format format -r ." },
+  Elixir: { devCommand: "mix phx.server", buildCommand: "mix compile", testCommand: "mix test", lintCommand: "mix credo", formatCommand: "mix format" },
+  "C#": { devCommand: "dotnet run", buildCommand: "dotnet build", testCommand: "dotnet test", lintCommand: null, formatCommand: "dotnet format" }
+};
+function detectScripts(m) {
+  if (m.pkgJson) {
+    const scripts = m.pkgJson.scripts ?? {};
+    const run = pmRun(m.pkgJson);
+    return {
+      devCommand: scripts.dev ? `${run} dev` : null,
+      buildCommand: scripts.build ? `${run} build` : null,
+      testCommand: scripts.test ? `${run} test` : null,
+      lintCommand: scripts.lint ? `${run} lint` : null,
+      formatCommand: scripts.format ? `${run} format` : null
+    };
+  }
+  if (m.language === "Python") {
+    const r = m.pyProject?.includes("[tool.uv]") ? "uv run" : "python -m";
+    return { devCommand: null, buildCommand: null, testCommand: `${r} pytest`, lintCommand: `${r} ruff check .`, formatCommand: `${r} ruff format .` };
+  }
+  if (m.language && LANGUAGE_SCRIPTS[m.language]) {
+    return LANGUAGE_SCRIPTS[m.language];
+  }
+  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 globExists(dir, pattern) {
+  const { readdir } = await import("fs/promises");
+  try {
+    const entries = await readdir(dir);
+    return entries.some((e) => e.endsWith(pattern.replace("*", "")));
+  } catch {
+    return false;
+  }
+}
+
+// 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/generators/skill-enhance.ts
+var ENHANCE_SKILL_VERSION = 5;
+function generateEnhanceSkill() {
+  return [
+    "---",
+    "name: lp-enhance",
+    "description: |",
+    "  AI-improve your CLAUDE.md based on codebase analysis. Fills in architecture, conventions, guardrails, and suggests hooks and MCP servers.",
+    '  TRIGGER when: user runs /lp-enhance, asks to "improve CLAUDE.md", "fill in architecture", or after major refactors.',
+    "  DO NOT TRIGGER when: user is editing CLAUDE.md manually, doing normal coding, or running doctor/eval.",
+    "allowed-tools: Read, Glob, Grep, Edit, Write",
+    "argument-hint: (no arguments needed)",
+    "---",
+    "",
+    `<!-- lp-enhance-version: ${ENHANCE_SKILL_VERSION} -->`,
+    "",
+    "# lp-enhance - AI-powered CLAUDE.md improver",
+    "",
+    "Read CLAUDE.md and the project's codebase, then update CLAUDE.md to fill in missing or incomplete sections.",
+    "",
+    "## Phase 1: Research",
+    "",
+    "1. Read CLAUDE.md (if it exists)",
+    "2. Read .claude/settings.json (hooks, permissions, MCP)",
+    "3. Read .claude/rules/*.md (existing rules)",
+    "4. Read .claudeignore (if it exists)",
+    "5. Scan src/ directory structure (top-level dirs, key files)",
+    "6. Read package.json / go.mod / pyproject.toml for stack detection",
+    "7. Check for monorepo indicators (workspaces, nx.json, lerna.json)",
+    "8. Check scenarios/ directory for existing eval scenarios",
+    "",
+    "**Done when:** you have a mental model of the stack, architecture, and existing config.",
+    "",
+    "## Phase 2: Plan",
+    "",
+    "Count current CLAUDE.md actionable lines. Budget is 200 lines max. Plan which sections to add or improve:",
+    "",
+    "1. **## Stack** - detect language, framework, package manager",
+    "2. **## Architecture** - 3-5 bullets describing codebase shape",
+    "3. **## Conventions** - max 8 key patterns. Overflow to .claude/rules/conventions.md",
+    "4. **## Off-Limits** - max 8 guardrails specific to this project",
+    "5. **## Memory** - ONLY if agentic-memory is configured in settings.json. Max 6 bullets.",
+    "6. **## Key Decisions** - only decisions that affect how Claude works in this codebase",
+    "",
+    "7. **Skill Authoring** - if .claude/rules/conventions.md lacks a Skill Authoring section, plan to add one",
+    "",
+    "If any section would exceed 8 bullets, plan a .claude/rules/ file for the overflow.",
+    "",
+    "**Done when:** you know exactly what to add/change and the line count stays under 200.",
+    "",
+    "## Phase 3: Execute",
+    "",
+    "Edit CLAUDE.md with the planned changes. Then:",
+    "",
+    "1. Create or update .claude/rules/ files for overflow content",
+    "2. Generate path-scoped rules if the project has distinct areas (see below)",
+    "3. Review .claudeignore and print suggestions (see below)",
+    "4. Generate 2-3 custom eval scenarios in scenarios/custom/ (see below)",
+    "5. Verify line count is under 200",
+    "",
+    "**Rules:**",
+    "- Don't remove existing content, only add or improve",
+    "- Be specific to THIS project, not generic advice",
+    "- Use bullet points, not paragraphs",
+    "",
+    "## Phase 4: Verify",
+    "",
+    "1. Run `claude-launchpad doctor` to check the score improved",
+    "2. Print suggested hooks (exact JSON) for .claude/settings.json but don't modify it",
+    "3. Print suggested MCP servers if external services detected (Postgres, Redis, Stripe, etc.)",
+    '4. If eval scenarios were generated, print: "Run this in your terminal (not inside Claude Code): `claude-launchpad eval --scenarios scenarios/ --runs 1`"',
+    "",
+    "**Done when:** doctor score is equal or higher, suggestions printed, eval scenarios created if applicable.",
+    "",
+    "## Path-scoped rules generation",
+    "",
+    "Scan the project structure and generate focused .claude/rules/ files with paths: frontmatter. These load ONLY when Claude works on matching files, saving context tokens.",
+    "",
+    "**How to detect areas:**",
+    "1. List top-level directories under src/ (or equivalent). Each distinct area (api, components, lib, tests) is a candidate.",
+    "2. Check for monorepo indicators: workspaces in package.json, pnpm-workspace.yaml, nx.json, lerna.json. Each workspace is a candidate.",
+    "3. Check for docs/, tests/, scripts/ as separate scopes.",
+    "",
+    "**For each detected area, create a rules file with this format:**",
+    "",
+    "---",
+    'paths: ["src/api/**"]',
+    "---",
+    "# API Rules",
+    "- Validate all request input with zod schemas",
+    "- Return typed error responses, never throw raw errors",
+    "- Keep route handlers under 30 lines",
+    "",
+    "**Stack-specific patterns to include:**",
+    `- Next.js app/: "Use Server Components by default, add 'use client' only when needed"`,
+    '- API routes / src/api/: "Validate input at boundaries, typed error responses"',
+    '- React components: "Colocate components near usage, props interface above component"',
+    '- Tests: "One assertion per test when possible, descriptive test names"',
+    '- Database / prisma/ / drizzle/: "Never write raw SQL, use the ORM, migrations required"',
+    '- Docs: "No em dashes, max 3 sentences per paragraph, code examples required"',
+    "",
+    "**When NOT to generate:**",
+    "- Small projects with < 5 source files (one conventions.md is enough)",
+    "- Projects where all code is in one flat directory",
+    "- If path-scoped rules already exist, don't overwrite them",
+    "",
+    "**Monorepo handling:**",
+    "- Each package gets its own rules file: .claude/rules/packages-<name>.md",
+    "- Suggest claudeMdExcludes in settings.json to skip irrelevant package CLAUDE.md files",
+    "",
+    "## Skill authoring conventions",
+    "",
+    "If .claude/rules/conventions.md exists but has no Skill Authoring section, add this:",
+    "",
+    "## Skill Authoring",
+    "",
+    "When creating Claude Code skills (.claude/skills/*/SKILL.md):",
+    "",
+    "- Add TRIGGER when / DO NOT TRIGGER when clauses in the description for auto-invocation",
+    "- Add allowed-tools in frontmatter to restrict tool access (e.g. Read, Glob, Grep for read-only skills)",
+    "- Add argument-hint in frontmatter showing the expected input format",
+    '- Structure as phases: Research, Plan, Execute, Verify with "Done when:" success criteria per phase',
+    "- Handle edge cases and preconditions before execution",
+    "",
+    "## Hook review",
+    "",
+    "Review .claude/settings.json hooks:",
+    "- If you see project-specific patterns that deserve hooks, suggest them",
+    "- If no PostCompact hook exists, suggest one that re-injects TASKS.md",
+    "- If no SessionStart hook exists, suggest one that injects TASKS.md",
+    "- DO NOT modify settings.json directly. Print exact JSON to add.",
+    "",
+    "## .claudeignore review",
+    "",
+    "Read .claudeignore and check if the patterns make sense for the detected stack:",
+    "",
+    "**Always flag:**",
+    "- Missing node_modules/ (JS/TS projects)",
+    "- Missing __pycache__/ or .venv/ (Python projects)",
+    "- Missing target/ (Rust/Java projects)",
+    "- Missing .env / .env.* patterns",
+    "- Missing lock files (pnpm-lock.yaml, package-lock.json, yarn.lock, etc.)",
+    "- Missing coverage/ directory",
+    "- Large generated files that waste context (*.min.js, *.map, migrations/)",
+    "",
+    "**Never flag:**",
+    "- Patterns the user clearly added intentionally",
+    "- Test fixtures or seed data (might be needed for context)",
+    "",
+    "If .claudeignore is missing entirely, create one with sensible defaults for the detected stack.",
+    "If it exists but has gaps, print suggested additions. Do NOT modify it directly.",
+    "",
+    "## Eval scenario generation",
+    "",
+    "After improving CLAUDE.md, generate 2-3 custom eval scenarios that test whether Claude follows the project's specific rules. Write them as YAML files in scenarios/ at the project root.",
+    "",
+    "**Scenario YAML format:**",
+    "```yaml",
+    "name: custom/scenario-name",
+    "description: What this scenario tests",
+    "setup:",
+    "  files:",
+    "    - path: src/example.ts",
+    "      content: |",
+    "        // Starter file that tempts Claude to break a rule",
+    "  instructions: |",
+    "    The specific rule from CLAUDE.md being tested.",
+    'prompt: "A task that would tempt Claude to break the rule"',
+    "checks:",
+    "  - type: grep",
+    '    pattern: "expected_pattern"',
+    "    target: src/example.ts",
+    "    expect: present",
+    "    points: 5",
+    "    label: What this check verifies",
+    "  - type: file-exists",
+    "    target: path/to/expected/file",
+    "    expect: present",
+    "    points: 5",
+    "    label: What this check verifies",
+    "passingScore: 7",
+    "runs: 3",
+    "```",
+    "",
+    "**How to choose scenarios:**",
+    "1. Pick the 2-3 most important rules from ## Off-Limits and ## Conventions",
+    "2. Design a task that naturally tempts Claude to break each rule",
+    "3. Write checks that verify compliance (grep for patterns, file-exists for structure)",
+    "",
+    "**Check types available:** `grep` (pattern in file), `file-exists` (present/absent), `max-lines` (file length)",
+    "",
+    "**Examples of good custom scenarios:**",
+    '- Off-limits says "never use any" \u2192 task asks to build types, check for no `any` keyword',
+    '- Convention says "max 400 lines per file" \u2192 task asks to generate a large module, check line count',
+    '- Off-limits says "no raw SQL" \u2192 task asks to add a query, check for ORM usage',
+    "",
+    "**Skip if:** scenarios/ already has 3+ YAML files, or CLAUDE.md has no project-specific rules worth testing.",
+    "",
+    "## Other advanced configuration",
+    "",
+    "- If the project uses external APIs, suggest sandbox.network.allowedDomains",
+    "- If you detect a monorepo, suggest claudeMdExcludes in settings.json"
+  ].join("\n");
+}
+
+// src/commands/doctor/fixer-memory.ts
+import { readFile as readFile3 } from "fs/promises";
+import { join as join3 } from "path";
+async function addPlacementHook(root, placement, event, dedupKeyword, entry, prepend, successMsg) {
+  const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
+  const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
+  const settings = await read(root);
+  const hooks = settings.hooks ?? {};
+  const hookList = hooks[event] ?? [];
+  const alreadyHas = hookList.some((g) => {
+    const nested = g.hooks;
+    return nested?.some((h) => String(h.command ?? "").includes(dedupKeyword));
+  });
+  if (alreadyHas) return false;
+  hooks[event] = prepend ? [entry, ...hookList] : [...hookList, entry];
+  settings.hooks = hooks;
+  await write(root, settings);
+  log.success(successMsg);
+  return true;
+}
+async function disableAutoMemory(root, placement) {
+  const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
+  const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
+  const settings = await read(root);
+  if (settings.autoMemoryEnabled === false) return false;
+  settings.autoMemoryEnabled = false;
+  await write(root, settings);
+  const target = placement === "local" ? "settings.local.json" : "settings.json";
+  log.success(`Set autoMemoryEnabled: false in ${target}`);
+  return true;
+}
+async function addMemoryToolPermissions(root, placement) {
+  const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
+  const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
+  const settings = await read(root);
+  const permissions = settings.permissions ?? {};
+  const allow = permissions.allow ?? [];
+  const tools = [
+    "mcp__agentic-memory__memory_store",
+    "mcp__agentic-memory__memory_search",
+    "mcp__agentic-memory__memory_recent",
+    "mcp__agentic-memory__memory_forget",
+    "mcp__agentic-memory__memory_relate",
+    "mcp__agentic-memory__memory_stats",
+    "mcp__agentic-memory__memory_update"
+  ];
+  const missing = tools.filter((t) => !allow.includes(t));
+  if (missing.length === 0) return false;
+  settings.permissions = { ...permissions, allow: [...allow, ...missing] };
+  await write(root, settings);
+  const target = placement === "local" ? "settings.local.json" : "settings.json";
+  log.success(`Added agentic-memory MCP tool permissions to ${target}`);
+  return true;
+}
+async function addSessionStartPullHook(root, placement) {
+  const target = placement === "local" ? "settings.local.json" : "settings.json";
+  return addPlacementHook(root, placement, "SessionStart", "memory pull", {
+    matcher: "startup",
+    hooks: [{ type: "command", command: "claude-launchpad memory pull -y 2>/dev/null; exit 0" }]
+  }, true, `Added SessionStart hook for memory sync to ${target}`);
+}
+async function addSessionEndPushHook(root, placement) {
+  const target = placement === "local" ? "settings.local.json" : "settings.json";
+  return addPlacementHook(root, placement, "SessionEnd", "memory push", {
+    hooks: [{ type: "command", command: "claude-launchpad memory push -y >/dev/null 2>&1 & exit 0" }]
+  }, false, `Added SessionEnd hook for memory sync to ${target}`);
+}
+async function removeStaleStopHook(root) {
+  const settings = await readSettingsJson(root);
+  const hooks = settings.hooks;
+  if (!hooks?.Stop) return false;
+  const stopHooks = hooks.Stop;
+  const filtered = stopHooks.filter((h) => {
+    const innerHooks = h.hooks;
+    return !innerHooks?.some(
+      (ih) => typeof ih.command === "string" && ih.command.includes("memory extract")
+    );
+  });
+  if (filtered.length === stopHooks.length) return false;
+  const updated = filtered.length === 0 ? (({ Stop: _, ...rest }) => rest)(hooks) : { ...hooks, Stop: filtered };
+  settings.hooks = updated;
+  await writeSettingsJson(root, settings);
+  log.success("Removed deprecated Stop hook (memory extract)");
+  return true;
+}
+async function addAllowedMcpServers(root, placement) {
+  const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
+  const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
+  const settings = await read(root);
+  if (settings.allowedMcpServers) return false;
+  const other = placement === "local" ? await readSettingsJson(root) : await readSettingsLocalJson(root);
+  if (other.allowedMcpServers) return false;
+  const serverNames = /* @__PURE__ */ new Set();
+  const settingsServers = settings.mcpServers;
+  if (settingsServers && typeof settingsServers === "object") {
+    for (const name of Object.keys(settingsServers)) serverNames.add(name);
+  }
+  const mcpJsonPath = join3(root, ".mcp.json");
+  try {
+    const mcpJson = JSON.parse(await readFile3(mcpJsonPath, "utf-8"));
+    const mcpServers = mcpJson.mcpServers;
+    if (mcpServers && typeof mcpServers === "object") {
+      for (const name of Object.keys(mcpServers)) serverNames.add(name);
+    }
+  } catch {
+  }
+  if (serverNames.size === 0) return false;
+  settings.allowedMcpServers = [...serverNames].map(
+    (name) => ({ serverName: name })
+  );
+  await write(root, settings);
+  const target = placement === "local" ? "settings.local.json" : "settings.json";
+  log.success(`Added allowedMcpServers from configured servers to ${target}`);
+  return true;
+}
+
+// src/commands/doctor/fixer.ts
+async function applyFixes(issues, projectRoot) {
+  const detected = await detectProject(projectRoot);
+  const hasMemoryIssues = issues.some((i) => i.analyzer === "Memory");
+  const placement = hasMemoryIssues ? await getMemoryPlacement(projectRoot) : "shared";
+  let fixed = 0;
+  let skipped = 0;
+  for (const issue of issues) {
+    const applied = await tryFix(issue, projectRoot, detected, placement);
+    if (applied) {
+      fixed++;
+    } else {
+      skipped++;
+    }
+  }
+  return { fixed, skipped };
+}
+var FIX_TABLE = [
+  { analyzer: "Hooks", match: "No hooks configured", fix: async (root, detected) => {
+    const a = await addEnvProtectionHook(root);
+    const b = await addAutoFormatHook(root, detected);
+    const c = await addForcePushProtection(root);
+    const d = await addSessionStartHook(root);
+    return a || b || c || d;
+  } },
+  { analyzer: "Hooks", match: ".env file protection", fix: (root) => addEnvProtectionHook(root) },
+  { analyzer: "Hooks", match: "auto-format", fix: (root, detected) => addAutoFormatHook(root, detected) },
+  { analyzer: "Hooks", match: "No PreToolUse", fix: (root) => addEnvProtectionHook(root) },
+  { analyzer: "Quality", match: "Architecture", fix: (root) => addClaudeMdSection(root, "## Architecture", "<!-- TODO: Describe your codebase structure. Run `/lp-enhance` to auto-fill this. -->") },
+  { analyzer: "Quality", match: "Off-Limits", fix: (root) => addClaudeMdSection(root, "## Off-Limits", "- Never hardcode secrets - use environment variables\n- Never write to `.env` files\n- Never expose internal error details in API responses") },
+  { analyzer: "Quality", match: "Commands", fix: (root) => addClaudeMdSection(root, "## Commands", "<!-- TODO: Add your dev/build/test commands -->") },
+  { analyzer: "Quality", match: "Stack", fix: (root, detected) => {
+    const content = 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", content);
+  } },
+  { analyzer: "Quality", match: "Session Start", fix: (root) => addClaudeMdSection(root, "## Session Start", "- ALWAYS read @TASKS.md first - it tracks progress across sessions\n- Update TASKS.md as you complete work") },
+  { analyzer: "Quality", match: "Backlog", fix: (root) => addClaudeMdSection(root, "## Backlog", "- When a feature is discussed but deferred, add it to BACKLOG.md immediately\n- Never leave future ideas only in TASKS.md or conversation \u2014 they get lost\n- BACKLOG.md is the single source of truth for parked features") },
+  { analyzer: "Rules", match: "No BACKLOG.md", fix: (root) => createBacklogMd(root) },
+  { analyzer: "Rules", match: "No .claudeignore", fix: (root, detected) => createClaudeignore(root, detected) },
+  { analyzer: "Rules", match: "No .claude/rules/", fix: (root) => createStarterRules(root) },
+  { analyzer: "Hooks", match: "PostCompact", fix: (root) => addPostCompactHook(root) },
+  { analyzer: "Permissions", match: "force-push", fix: (root) => addForcePushProtection(root) },
+  { analyzer: "Permissions", match: "Credential files not blocked", fix: (root) => addCredentialDenyRules(root) },
+  { analyzer: "Permissions", match: "Bypass permissions mode", fix: (root) => addBypassDisable(root) },
+  { analyzer: "Permissions", match: "Sandbox not enabled", fix: (root) => addSandboxSettings(root) },
+  { analyzer: "Permissions", match: ".env is protected by hooks but not in .claudeignore", fix: (root) => addEnvToClaudeignore(root) },
+  { analyzer: "Rules", match: "No /lp-enhance skill", fix: (root) => createEnhanceSkill(root) },
+  { analyzer: "Rules", match: "lp-enhance skill is outdated", fix: (root) => updateEnhanceSkill(root) },
+  { analyzer: "Settings", match: "Deprecated includeCoAuthoredBy", fix: (root) => migrateAttribution(root) },
+  { analyzer: "Hooks", match: "SessionStart", fix: (root) => addSessionStartHook(root) },
+  { analyzer: "Memory", match: "Deprecated Stop hook", fix: (root) => removeStaleStopHook(root) },
+  { analyzer: "Memory", match: "autoMemoryEnabled not disabled", fix: (root, _det, placement) => disableAutoMemory(root, placement) },
+  { analyzer: "Memory", match: "MCP tool permission", fix: (root, _det, placement) => addMemoryToolPermissions(root, placement) },
+  { analyzer: "MCP", match: "no allowedMcpServers", fix: (root, _det, placement) => addAllowedMcpServers(root, placement) },
+  { analyzer: "Memory", match: "SessionStart hook to auto-pull", fix: (root, _det, placement) => addSessionStartPullHook(root, placement) },
+  { analyzer: "Memory", match: "SessionEnd hook to auto-push", fix: (root, _det, placement) => addSessionEndPushHook(root, placement) },
+  { analyzer: "Memory", match: "CLAUDE.md missing memory guidance", fix: (root, _det, placement) => {
+    const content = "Use agentic-memory to persist knowledge across sessions:\n- Memories are automatically injected at session start\n- STORE IMMEDIATELY when: a dependency strategy changes, an architecture decision is made, a convention is established, a bug pattern is discovered, or a feature is killed/added\n- Use memory_search before memory_store to check for duplicates\n- NEVER store credentials, API keys, tokens, or secrets in memories";
+    const target = placement === "local" ? join4(root, ".claude", "CLAUDE.md") : void 0;
+    return addClaudeMdSection(root, "## Memory", content, target);
+  } }
+];
+function hasAutoFix(issue) {
+  return FIX_TABLE.some(
+    (e) => e.analyzer === issue.analyzer && issue.message.includes(e.match)
+  );
+}
+async function tryFix(issue, root, detected, placement) {
+  const entry = FIX_TABLE.find(
+    (e) => e.analyzer === issue.analyzer && issue.message.includes(e.match)
+  );
+  return entry ? entry.fix(root, detected, placement) : false;
+}
+async function addHook(root, event, dedupKeyword, entry, successMsg) {
+  const settings = await readSettingsJson(root);
+  const hooks = settings.hooks ?? {};
+  const hookList = hooks[event] ?? [];
+  const alreadyHas = hookList.some((g) => {
+    const nested = g.hooks;
+    return nested?.some((h) => String(h.command ?? "").includes(dedupKeyword));
+  });
+  if (alreadyHas) return false;
+  hookList.push(entry);
+  settings.hooks = { ...hooks, [event]: hookList };
+  await writeSettingsJson(root, settings);
+  log.success(successMsg);
+  return true;
+}
+async function addEnvProtectionHook(root) {
+  return addHook(root, "PreToolUse", ".env", {
+    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`
+    }]
+  }, "Added .env file protection hook (PreToolUse)");
+}
+async function addAutoFormatHook(root, detected) {
+  if (!detected.language) return false;
+  const formatters = {
+    TypeScript: { extensions: ["ts", "tsx"], command: "npx prettier --write" },
+    JavaScript: { extensions: ["js", "jsx"], command: "npx prettier --write" },
+    Python: { extensions: ["py"], command: "ruff format" },
+    Go: { extensions: ["go"], command: "gofmt -w" },
+    Rust: { extensions: ["rs"], command: "rustfmt" },
+    Ruby: { extensions: ["rb"], command: "rubocop -A" },
+    PHP: { extensions: ["php"], command: "vendor/bin/pint" }
+  };
+  const config = formatters[detected.language];
+  if (!config) return false;
+  const extChecks = config.extensions.map((ext) => `[ "$ext" = "${ext}" ]`).join(" || ");
+  return addHook(root, "PostToolUse", "format", {
+    matcher: "Write|Edit",
+    hooks: [{
+      type: "command",
+      command: `ext=\${TOOL_INPUT_FILE_PATH##*.}; (${extChecks}) && ${config.command} "$TOOL_INPUT_FILE_PATH" 2>/dev/null; exit 0`
+    }]
+  }, `Added auto-format hook (PostToolUse \u2192 ${config.command})`);
+}
+async function addForcePushProtection(root) {
+  return addHook(root, "PreToolUse", "force", {
+    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`
+    }]
+  }, "Added force-push protection hook (PreToolUse \u2192 Bash)");
+}
+async function addPostCompactHook(root) {
+  return addHook(root, "PostCompact", "TASKS.md", {
+    matcher: "",
+    hooks: [{
+      type: "command",
+      command: "cat TASKS.md 2>/dev/null; exit 0"
+    }]
+  }, "Added PostCompact hook (re-injects TASKS.md after compaction)");
+}
+async function addSessionStartHook(root) {
+  return addHook(root, "SessionStart", "TASKS.md", {
+    matcher: "startup|resume",
+    hooks: [{
+      type: "command",
+      command: "cat TASKS.md 2>/dev/null; exit 0"
+    }]
+  }, "Added SessionStart hook (injects TASKS.md at startup)");
+}
+async function migrateAttribution(root) {
+  const settings = await readSettingsJson(root);
+  if (settings.includeCoAuthoredBy === void 0) return false;
+  const { includeCoAuthoredBy: _, ...rest } = settings;
+  const updated = { ...rest, attribution: { commit: "", pr: "" } };
+  await writeSettingsJson(root, updated);
+  log.success("Migrated includeCoAuthoredBy \u2192 attribution object");
+  return true;
+}
+async function addCredentialDenyRules(root) {
+  const settings = await readSettingsJson(root);
+  const permissions = settings.permissions ?? {};
+  const deny = permissions.deny ?? [];
+  const toAdd = ["Read(~/.ssh/*)", "Read(~/.aws/*)", "Read(~/.npmrc)"];
+  const missing = toAdd.filter((p) => !deny.includes(p));
+  if (missing.length === 0) return false;
+  settings.permissions = { ...permissions, deny: [...deny, ...missing] };
+  await writeSettingsJson(root, settings);
+  log.success("Added credential deny rules (SSH, AWS, npm)");
+  return true;
+}
+async function addBypassDisable(root) {
+  const settings = await readSettingsJson(root);
+  if (settings.disableBypassPermissionsMode === "disable") return false;
+  settings.disableBypassPermissionsMode = "disable";
+  await writeSettingsJson(root, settings);
+  log.success("Added disableBypassPermissionsMode: disable");
+  return true;
+}
+async function addSandboxSettings(root) {
+  const settings = await readSettingsJson(root);
+  const sandbox = settings.sandbox;
+  if (sandbox?.enabled === true) return false;
+  settings.sandbox = { enabled: true, failIfUnavailable: true };
+  await writeSettingsJson(root, settings);
+  log.success("Enabled sandbox with failIfUnavailable");
+  return true;
+}
+async function addEnvToClaudeignore(root) {
+  const ignorePath = join4(root, ".claudeignore");
+  let content;
+  try {
+    content = await readFile4(ignorePath, "utf-8");
+  } catch {
+    return false;
+  }
+  const lines = content.split("\n").map((l) => l.trim());
+  if (lines.some((l) => l === ".env" || l === ".env.*" || l === ".env*")) return false;
+  await writeFile2(ignorePath, content.trimEnd() + "\n.env\n.env.*\n");
+  log.success("Added .env to .claudeignore");
+  return true;
+}
+async function addClaudeMdSection(root, heading, content, targetPath) {
+  const claudeMdPath = targetPath ?? join4(root, "CLAUDE.md");
+  let existing;
+  try {
+    existing = await readFile4(claudeMdPath, "utf-8");
+  } catch {
+    if (!targetPath) return false;
+    await mkdir2(join4(root, ".claude"), { recursive: true });
+    existing = "# Local Claude Config\n";
+  }
+  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);
+  const label = targetPath ? ".claude/CLAUDE.md" : "CLAUDE.md";
+  log.success(`Added "${heading}" section to ${label}`);
+  return true;
+}
+async function createBacklogMd(root) {
+  const backlogPath = join4(root, "BACKLOG.md");
+  try {
+    await access2(backlogPath);
+    return false;
+  } catch {
+  }
+  const name = root.split("/").pop() ?? "Project";
+  await writeFile2(backlogPath, `# ${name} - Backlog
+
+> Features discussed but deferred. Pick up when relevant.
+> Priority: P0 = next sprint, P1 = soon, P2 = when relevant.
+`);
+  log.success("Generated BACKLOG.md");
+  return true;
+}
+async function createClaudeignore(root, detected) {
+  const ignorePath = join4(root, ".claudeignore");
+  try {
+    await access2(ignorePath);
+    return false;
+  } catch {
+  }
+  const content = generateClaudeignore(detected);
+  await writeFile2(ignorePath, content);
+  log.success("Generated .claudeignore with language-specific ignore patterns");
+  return true;
+}
+async function createStarterRules(root) {
+  const rulesDir = join4(root, ".claude", "rules");
+  try {
+    await access2(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 createEnhanceSkill(root) {
+  const skillDir = join4(root, ".claude", "skills", "lp-enhance");
+  const skillPath = join4(skillDir, "SKILL.md");
+  const globalPath = join4(homedir(), ".claude", "skills", "lp-enhance", "SKILL.md");
+  const legacyProject = join4(root, ".claude", "commands", "lp-enhance.md");
+  const legacyGlobal = join4(homedir(), ".claude", "commands", "lp-enhance.md");
+  if (await fileExists(skillPath) || await fileExists(globalPath) || await fileExists(legacyProject) || await fileExists(legacyGlobal)) return false;
+  await mkdir2(skillDir, { recursive: true });
+  await writeFile2(skillPath, generateEnhanceSkill());
+  log.success("Generated /lp-enhance skill (.claude/skills/lp-enhance/)");
+  return true;
+}
+async function updateEnhanceSkill(root) {
+  const projectPath = join4(root, ".claude", "skills", "lp-enhance", "SKILL.md");
+  const globalPath = join4(homedir(), ".claude", "skills", "lp-enhance", "SKILL.md");
+  const targetPath = await fileExists(projectPath) ? projectPath : await fileExists(globalPath) ? globalPath : null;
+  if (!targetPath) return false;
+  await writeFile2(targetPath, generateEnhanceSkill());
+  log.success("Updated /lp-enhance skill to latest version");
+  return true;
+}
+
+// src/lib/output.ts
+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 \xB7 Remember"));
+  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) {
+  const sevLabel = {
+    critical: chalk.bgRed.white.bold(" CRIT "),
+    high: chalk.red.bold("HIGH"),
+    medium: chalk.yellow("MED "),
+    low: chalk.dim("LOW "),
+    info: chalk.dim("INFO")
+  };
+  console.log(`   ${sevLabel[severity]}  ${message}`);
+}
+function renderDoctorReport(results, options) {
+  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 { overallScore, actionableCount: 0 };
+  }
+  const sorted = [...actionable].sort((a, b) => {
+    const order = { critical: 0, high: 1, medium: 2, low: 3, info: 4 };
+    return (order[a.severity] ?? 4) - (order[b.severity] ?? 4);
+  });
+  for (const issue of sorted) {
+    printIssue(issue.severity, issue.analyzer, issue.message);
+  }
+  log.blank();
+  if (options?.afterFix) {
+    log.info(`${actionable.length} remaining issue(s) require manual intervention.`);
+  } else {
+    const fixable = actionable.filter((i) => hasAutoFix(i));
+    if (fixable.length > 0) {
+      log.info(`${actionable.length} issue(s). Run ${chalk.bold("--fix")} to auto-repair or ${chalk.bold("--fix --dry-run")} to preview.`);
+    } else {
+      log.info(`${actionable.length} issue(s) require manual intervention.`);
+    }
+  }
+  return { overallScore, actionableCount: actionable.length };
+}
+
+export {
+  __export,
+  fileExists,
+  readFileOrNull,
+  detectProject,
+  generateClaudeignore,
+  ENHANCE_SKILL_VERSION,
+  generateEnhanceSkill,
+  readSettingsJson,
+  writeSettingsJson,
+  readSettingsLocalJson,
+  writeSettingsLocalJson,
+  getMemoryPlacement,
+  applyFixes,
+  log,
+  printBanner,
+  printScoreCard,
+  renderDoctorReport
+};
+//# sourceMappingURL=chunk-S4WIADYE.js.map