claude-launchpad 0.4.3 → 0.5.1

package/README.md

@@ -81,7 +81,7 @@ The core of the tool. Runs 7 analyzers against your `.claude/` directory and `CL
 | **Settings** | No hooks configured, dangerous tool access without safety nets |
 | **Hooks** | Missing auto-format on save, no .env file protection, no security gates, no PostCompact hook |
 | **Rules** | Dead rule files, stale references, empty configs |
-| **Permissions** | Bash auto-allowed without security hooks, no force-push protection |
+| **Permissions** | Credential file exposure (~/.ssh, ~/.aws, ~/.npmrc), blanket Bash approval, bypass mode unprotected, sandbox disabled, .env gap between hooks and .claudeignore, no force-push protection |
 | **MCP Servers** | Invalid transport configs, missing commands/URLs |
 
 Output looks like this:
@@ -132,7 +132,7 @@ Detects your project and generates Claude Code config that fits. No templates, n
 **What you get (6 files):**
 - `CLAUDE.md` — your stack, commands, conventions, guardrails, memory management instructions
 - `TASKS.md` — sprint tracking, session continuity, deferred issues parking
-- `.claude/settings.json` — `$schema` for IDE autocomplete, `permissions.deny` for security, hooks for .env protection + destructive command blocking + auto-format + PostCompact context re-injection
+- `.claude/settings.json` — `$schema` for IDE autocomplete, `permissions.deny` for credential + secret protection, sandbox enabled, bypass mode disabled, hooks for .env protection + destructive command blocking + auto-format + PostCompact context re-injection
 - `.claude/.gitignore` — prevents local settings and plans from being committed
 - `.claudeignore` — language-specific ignore patterns
 - `.claude/rules/conventions.md` — language-specific starter rules
@@ -154,23 +154,11 @@ Stays under the 120-instruction budget. Overflows detailed content to `.claude/r
 The part nobody else has built. Runs Claude against real test scenarios and scores the results.
 
 ```bash
-# Run only security tests (4 scenarios)
-claude-launchpad eval --suite security
-
-# Run only convention tests (5 scenarios)
-claude-launchpad eval --suite conventions
-
-# Run only workflow tests (2 scenarios)
-claude-launchpad eval --suite workflow
-
-# Run everything (11 scenarios)
+# Interactive mode — pick suite, runs, and model
 claude-launchpad eval
 
-# Use a cheaper model
-claude-launchpad eval --suite security --model haiku
-
-# One run per scenario (fastest)
-claude-launchpad eval --suite security --runs 1
+# Or pass flags directly
+claude-launchpad eval --suite security --runs 1 --model haiku
 ```
 
 Each scenario creates an isolated sandbox with your full Claude Code config (settings.json, rules, hooks, .claudeignore) copied in, runs Claude with a task, and checks if your configuration made Claude follow the rules:
@@ -192,9 +180,9 @@ Results are saved to `.claude/eval/` as structured markdown — you can feed the
 
 | Suite | Scenarios | What it tests |
 |---|---|---|
-| `security` | 4 | SQL injection, .env protection, secret exposure, input validation |
+| `security` | 6 | SQL injection, .env protection, secret exposure, input validation, credential read, sandbox escape |
 | `conventions` | 5 | Error handling, immutability, file size, naming, no hardcoded values |
-| `workflow` | 2 | Git conventions, session continuity |
+| `workflow` | 4 | Git conventions, session continuity, memory persistence, deferred tracking |
 
 **All eval flags:**
 
@@ -241,7 +229,7 @@ Then use `/launchpad:doctor`, `/launchpad:init`, `/launchpad:enhance`, `/launchp
 
 **Doctor** reads your files and runs static analysis. No API calls. No network. No cost.
 
-**Init** scans manifest files (package.json, go.mod, pyproject.toml, etc.), detects your stack, and generates 6 files: CLAUDE.md (with memory management instructions), TASKS.md (with deferred issues section), settings.json (with $schema, permissions.deny, hooks including PostCompact for context re-injection), .claude/.gitignore, .claudeignore, and language-specific rules. Formatter hooks use hardcoded safe commands only.
+**Init** scans manifest files (package.json, go.mod, pyproject.toml, etc.), detects your stack, and generates 6 files: CLAUDE.md (with memory management instructions), TASKS.md (with deferred issues section), settings.json (with credential deny rules, sandbox enabled, bypass mode disabled, hooks including PostCompact), .claude/.gitignore, .claudeignore, and language-specific rules. Formatter hooks use hardcoded safe commands only.
 
 **Enhance** spawns `claude "prompt"` as an interactive child process. You see Claude's full UI. No data passes through the tool — it just launches Claude with a task.
 

package/dist/cli.js

@@ -126,7 +126,7 @@ async function readJsonOrNull(path) {
 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([
+  const [pkgJson, goMod, pyProject, gemfile, cargo, pubspec, composerJson, pomXml, buildGradleGroovy, buildGradleKts, packageSwift, mixExs, csproj, lockfiles] = await Promise.all([
     readJsonOrNull(join(root, "package.json")),
     fileExists(join(root, "go.mod")),
     readFileOrNull(join(root, "pyproject.toml")),
@@ -135,12 +135,14 @@ async function detectProject(root) {
     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, "build.gradle")),
+    fileExists(join(root, "build.gradle.kts")),
     fileExists(join(root, "Package.swift")),
     fileExists(join(root, "mix.exs")),
     globExists(root, "*.csproj"),
     detectLockfiles(root)
   ]);
+  const buildGradle = buildGradleGroovy || buildGradleKts;
   const manifests = {
     pkgJson,
     goMod,
@@ -402,6 +404,13 @@ function generateSettings(detected) {
   if (formatHook) {
     postToolUse.push(formatHook);
   }
+  const sessionStart = [{
+    matcher: "startup|resume",
+    hooks: [{
+      type: "command",
+      command: "cat TASKS.md 2>/dev/null; exit 0"
+    }]
+  }];
   const postCompact = [{
     matcher: "",
     hooks: [{
@@ -410,6 +419,7 @@ function generateSettings(detected) {
     }]
   }];
   const hooks = {};
+  hooks.SessionStart = sessionStart;
   if (preToolUse.length > 0) hooks.PreToolUse = preToolUse;
   if (postToolUse.length > 0) hooks.PostToolUse = postToolUse;
   hooks.PostCompact = postCompact;
@@ -421,10 +431,18 @@ function generateSettings(detected) {
         "Bash(rm -rf ~)",
         "Read(.env)",
         "Read(.env.*)",
-        "Read(secrets/**)"
+        "Read(secrets/**)",
+        "Read(~/.ssh/*)",
+        "Read(~/.aws/*)",
+        "Read(~/.npmrc)"
       ]
     },
-    hooks
+    hooks,
+    disableBypassPermissionsMode: "disable",
+    sandbox: {
+      enabled: true,
+      failIfUnavailable: true
+    }
   };
 }
 var SAFE_FORMATTERS = {
@@ -730,13 +748,14 @@ 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([
+  const [claudeMd, settings, hooks, rules, mcpServers, skills, claudeignore] = await Promise.all([
     readClaudeMd(root),
     readSettings(claudeDir),
     readHooks(claudeDir),
     readRules(claudeDir),
     readMcpServers(claudeDir),
-    readSkills(claudeDir)
+    readSkills(claudeDir),
+    readFileOrNull(join3(root, ".claudeignore"))
   ]);
   const instructionCount = claudeMd ? countInstructions(claudeMd) : 0;
   return {
@@ -748,7 +767,9 @@ async function parseClaudeConfig(projectRoot) {
     hooks,
     rules,
     mcpServers,
-    skills
+    skills,
+    claudeignorePath: claudeignore !== null ? join3(root, ".claudeignore") : null,
+    claudeignoreContent: claudeignore
   };
 }
 async function readClaudeMd(root) {
@@ -797,7 +818,8 @@ async function readHooks(claudeDir) {
               event,
               type: h.type ?? "command",
               matcher,
-              command: h.command
+              command: h.command,
+              timeout: h.timeout
             });
           }
         } else {
@@ -805,7 +827,8 @@ async function readHooks(claudeDir) {
             event,
             type: g.type ?? "command",
             matcher,
-            command: g.command
+            command: g.command,
+            timeout: g.timeout
           });
         }
       }
@@ -968,6 +991,44 @@ async function analyzeSettings(config) {
       fix: "Add PreToolUse hooks for security or remove allowedTools to use interactive prompting"
     });
   }
+  if (config.settings.includeCoAuthoredBy !== void 0) {
+    issues.push({
+      analyzer: "Settings",
+      severity: "low",
+      message: 'Deprecated includeCoAuthoredBy \u2014 use attribution: { commit: "", pr: "" } instead',
+      fix: "Replace includeCoAuthoredBy with the attribution object in settings.json"
+    });
+  }
+  if (!config.settings.claudeMdExcludes) {
+    issues.push({
+      analyzer: "Settings",
+      severity: "info",
+      message: "No claudeMdExcludes configured \u2014 consider adding this if you have a monorepo"
+    });
+  }
+  const broadMatchers = ["Bash", "Write", "Edit", "Read"];
+  const hooksWithoutTimeout = config.hooks.filter(
+    (h) => !h.timeout && broadMatchers.some((m) => h.matcher?.includes(m))
+  );
+  if (hooksWithoutTimeout.length > 0) {
+    issues.push({
+      analyzer: "Settings",
+      severity: "low",
+      message: `${hooksWithoutTimeout.length} hook(s) on broad matchers without timeout \u2014 defaults to 60s per invocation`,
+      fix: "Add timeout (in seconds) to hooks on Bash, Write, Edit, or Read matchers"
+    });
+  }
+  if (config.settings.autoMemoryEnabled === false) {
+    const hasMemorySection = config.claudeMdContent?.includes("## Memory") ?? false;
+    if (!hasMemorySection) {
+      issues.push({
+        analyzer: "Settings",
+        severity: "medium",
+        message: "Auto-memory is disabled with no manual memory strategy in CLAUDE.md",
+        fix: "Re-enable autoMemoryEnabled or add a ## Memory section to CLAUDE.md"
+      });
+    }
+  }
   const actionableCount = issues.filter((i) => i.severity !== "info").length;
   const score = Math.max(0, 100 - actionableCount * 20);
   return { name: "Settings", issues, score };
@@ -1027,7 +1088,16 @@ async function analyzeHooks(config) {
       fix: "Add a PostCompact hook that re-injects TASKS.md after compaction"
     });
   }
-  const score = Math.max(0, 100 - issues.length * 20);
+  const hasSessionStart = hooks.some((h) => h.event === "SessionStart");
+  if (!hasSessionStart) {
+    issues.push({
+      analyzer: "Hooks",
+      severity: "low",
+      message: "No SessionStart hook \u2014 session starts without project context loaded",
+      fix: "Add a SessionStart hook that injects TASKS.md at startup"
+    });
+  }
+  const score = Math.max(0, 100 - issues.length * 15);
   return { name: "Hooks", issues, score };
 }
 
@@ -1088,10 +1158,63 @@ async function analyzeRules(config) {
 // src/commands/doctor/analyzers/permissions.ts
 async function analyzePermissions(config) {
   const issues = [];
+  const settings = config.settings;
+  const permissions = settings?.permissions;
+  const denyList = permissions?.deny ?? [];
+  const allowList = permissions?.allow ?? [];
+  const credentialPatterns = ["Read(~/.ssh/*)", "Read(~/.aws/*)", "Read(~/.npmrc)"];
+  const missingCreds = credentialPatterns.filter((p) => !denyList.includes(p));
+  if (missingCreds.length > 0) {
+    issues.push({
+      analyzer: "Permissions",
+      severity: "high",
+      message: `Credential files not blocked: ${missingCreds.join(", ")} \u2014 Claude can read SSH keys, AWS creds, or npm tokens`,
+      fix: "Add Read(~/.ssh/*), Read(~/.aws/*), Read(~/.npmrc) to permissions.deny"
+    });
+  }
+  const hasBlanketBash = allowList.some((a) => a === "Bash" || a.startsWith("Bash") && !a.includes("("));
+  if (hasBlanketBash) {
+    issues.push({
+      analyzer: "Permissions",
+      severity: "high",
+      message: "Bash is blanket-allowed without pattern restriction \u2014 all shell commands are auto-approved",
+      fix: "Replace blanket Bash with scoped patterns like Bash(npm test) or remove it"
+    });
+  }
+  if (settings?.disableBypassPermissionsMode !== "disable") {
+    issues.push({
+      analyzer: "Permissions",
+      severity: "high",
+      message: "Bypass permissions mode not disabled \u2014 --dangerously-skip-permissions bypasses all checks",
+      fix: 'Add "disableBypassPermissionsMode": "disable" to settings.json'
+    });
+  }
+  const sandbox = settings?.sandbox;
+  if (sandbox?.enabled !== true) {
+    issues.push({
+      analyzer: "Permissions",
+      severity: "medium",
+      message: "Sandbox not enabled \u2014 hooks block tool calls but not subprocess access (e.g. cat .env via Bash)",
+      fix: 'Add "sandbox": { "enabled": true, "failIfUnavailable": true } to settings.json'
+    });
+  }
+  const hasEnvHook = config.hooks.some((h) => h.command?.includes(".env"));
+  if (hasEnvHook && config.claudeignoreContent !== null) {
+    const lines = config.claudeignoreContent.split("\n").map((l) => l.trim());
+    const hasEnvInIgnore = lines.some((l) => l === ".env" || l === ".env.*" || l === ".env*");
+    if (!hasEnvInIgnore) {
+      issues.push({
+        analyzer: "Permissions",
+        severity: "medium",
+        message: ".env is protected by hooks but not in .claudeignore \u2014 cat .env via Bash bypasses hooks",
+        fix: "Add .env to .claudeignore for defense in depth"
+      });
+    }
+  }
   const hasBashSecurity = config.hooks.some(
     (h) => h.event === "PreToolUse" && (h.matcher?.includes("Bash") || !h.matcher)
   );
-  const bashAllowed = config.settings?.allowedTools;
+  const bashAllowed = settings?.allowedTools;
   const hasBashAutoAllow = bashAllowed?.some(
     (t) => typeof t === "string" && t.toLowerCase().includes("bash")
   );
@@ -1100,7 +1223,7 @@ async function analyzePermissions(config) {
       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)"
+      fix: "Add a PreToolUse hook for Bash that blocks destructive commands"
     });
   }
   const hasForceProtection = config.hooks.some(
@@ -1125,7 +1248,7 @@ async function analyzePermissions(config) {
       });
     }
   }
-  const score = Math.max(0, 100 - issues.length * 20);
+  const score = Math.max(0, 100 - issues.length * 15);
   return { name: "Permissions", issues, score };
 }
 
@@ -1303,7 +1426,12 @@ var FIX_TABLE = [
   { analyzer: "Rules", match: "No .claude/rules/", fix: (root) => createStarterRules(root) },
   { analyzer: "Quality", match: "Memory", fix: (root) => addClaudeMdSection(root, "## Memory & Learnings", "Use the built-in memory system to persist knowledge across sessions:\n- **Save immediately** when you discover: a non-obvious fix, a gotcha, an external resource, a decision with context that would be lost, or a known issue to fix later\n- **Categories**: `decision` (why X over Y), `gotcha` (non-obvious pitfall), `deferred` (known issue, not urgent), `reference` (where to find things)\n- **Where**: project memory for this repo, global memory for cross-project learnings\n- **Format**: one fact per memory, include date and why \u2014 not just what\n- **Prune**: check if a memory on this topic exists before saving \u2014 update, don't duplicate\n- Before starting work, check memory for relevant context from previous sessions") },
   { analyzer: "Hooks", match: "PostCompact", fix: (root) => addPostCompactHook(root) },
-  { analyzer: "Permissions", match: "force-push", fix: (root) => addForcePushProtection(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: "Settings", match: "Deprecated includeCoAuthoredBy", fix: (root) => migrateAttribution(root) }
 ];
 async function tryFix(issue, root, detected) {
   const entry = FIX_TABLE.find(
@@ -1405,6 +1533,58 @@ async function addPostCompactHook(root) {
   log.success("Added PostCompact hook (re-injects TASKS.md after compaction)");
   return true;
 }
+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 = join5(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) {
   const claudeMdPath = join5(root, "CLAUDE.md");
   let existing;
@@ -1590,7 +1770,19 @@ function createDoctorCommand() {
         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.`);
+          log.success(`Applied ${fixed} fix(es). Re-scanning...`);
+          log.blank();
+          const updatedConfig = await parseClaudeConfig(opts.path);
+          const updatedResults = await Promise.all([
+            analyzeBudget(updatedConfig),
+            analyzeQuality(updatedConfig),
+            analyzeSettings(updatedConfig),
+            analyzeHooks(updatedConfig),
+            analyzeRules(updatedConfig),
+            analyzePermissions(updatedConfig),
+            analyzeMcp(updatedConfig)
+          ]);
+          renderDoctorReport(updatedResults);
         }
         if (skipped > 0) {
           log.info(`${skipped} issue(s) require manual intervention.`);
@@ -1608,6 +1800,7 @@ function createDoctorCommand() {
 
 // src/commands/eval/index.ts
 import { Command as Command3 } from "commander";
+import { select } from "@inquirer/prompts";
 import ora from "ora";
 import chalk2 from "chalk";
 import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
@@ -2017,6 +2210,35 @@ async function listAllFiles(dir) {
 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").option("--model <model>", "Model to use for eval (e.g., sonnet, haiku, opus)").action(async (opts) => {
     printBanner();
+    const hasFlags = opts.suite || opts.model || opts.runs !== "3" || opts.json || opts.debug;
+    if (!hasFlags) {
+      opts.suite = await select({
+        message: "Suite",
+        choices: [
+          { name: "security (6 scenarios)", value: "security" },
+          { name: "conventions (5 scenarios)", value: "conventions" },
+          { name: "workflow (2 scenarios)", value: "workflow" },
+          { name: "all (13 scenarios)", value: void 0 }
+        ]
+      });
+      opts.runs = await select({
+        message: "Runs per scenario",
+        choices: [
+          { name: "1 \u2014 fast", value: "1" },
+          { name: "3 \u2014 default", value: "3" },
+          { name: "5 \u2014 thorough", value: "5" }
+        ]
+      });
+      opts.model = await select({
+        message: "Model",
+        choices: [
+          { name: "haiku \u2014 cheapest", value: "haiku" },
+          { name: "sonnet \u2014 balanced", value: "sonnet" },
+          { name: "opus \u2014 best", value: "opus" }
+        ]
+      });
+      log.blank();
+    }
     const claudeAvailable = await checkClaudeCli();
     if (!claudeAvailable) {
       log.error("Claude CLI not found. Install it: https://docs.anthropic.com/en/docs/claude-code");
@@ -2203,9 +2425,15 @@ Also review .claude/settings.json hooks:
 - Read the existing hooks in .claude/settings.json
 - If you see project-specific patterns that deserve hooks (e.g., protected directories, test file patterns, migration files), suggest adding them
 - If no PostCompact hook exists, suggest adding one that re-injects TASKS.md after context compaction (critical for session continuity)
+- If no SessionStart hook exists, suggest adding one that injects TASKS.md at session startup
 - DO NOT overwrite existing hooks \u2014 only add new ones that are specific to this project
 - Print hook suggestions at the end with the exact JSON to add, don't modify settings.json directly
 
+Also check for advanced configuration opportunities:
+- If the project has both app code and tests, suggest creating path-scoped .claude/rules/ files with paths: frontmatter (e.g., test conventions only load when editing test files)
+- If the project uses external APIs (Stripe, GitHub, AWS SDKs, etc.), suggest sandbox.network.allowedDomains to restrict outbound traffic
+- If you detect a monorepo (Turborepo, Lerna, pnpm workspaces, multiple package.json), suggest claudeMdExcludes in settings.json
+
 Rules:
 - Don't remove existing content \u2014 only add or improve
 - Be specific to THIS project, not generic advice