claude-launchpad 0.1.1 → 0.2.1

package/dist/cli.js

@@ -3,7 +3,7 @@
 // src/cli.ts
 import { Command as Command5 } from "commander";
 import { access as access7 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/commands/init/index.ts
 import { Command } from "commander";
@@ -324,9 +324,9 @@ async function fileExists(path) {
   }
 }
 async function globExists(dir, pattern) {
-  const { readdir: readdir3 } = await import("fs/promises");
+  const { readdir: readdir4 } = await import("fs/promises");
   try {
-    const entries = await readdir3(dir);
+    const entries = await readdir4(dir);
     return entries.some((e) => e.endsWith(pattern.replace("*", "")));
   } catch {
     return false;
@@ -947,34 +947,34 @@ async function analyzeSettings(config) {
     });
     return { name: "Settings", issues, score: 40 };
   }
-  const plugins = config.settings.enabledPlugins;
-  if (!plugins || Object.keys(plugins).length === 0) {
+  const hooks = config.settings.hooks;
+  if (!hooks || Object.keys(hooks).length === 0) {
     issues.push({
       analyzer: "Settings",
-      severity: "low",
-      message: "No plugins enabled",
-      fix: "Consider enabling plugins for enhanced capabilities"
+      severity: "medium",
+      message: "settings.json has no hooks configured",
+      fix: "Run `claude-launchpad doctor --fix` to generate hooks"
     });
   }
-  const permissions = config.settings.permissions;
-  if (!permissions) {
+  const plugins = config.settings.enabledPlugins;
+  if (!plugins || Object.keys(plugins).length === 0) {
     issues.push({
       analyzer: "Settings",
-      severity: "low",
-      message: "No permission rules configured",
-      fix: "Add permission rules to control which tools Claude can use automatically"
+      severity: "info",
+      message: "No plugins enabled \u2014 plugins are optional but can add capabilities"
     });
   }
-  const env = config.settings.env;
-  if (!env) {
+  const allowedTools = config.settings.allowedTools;
+  if (allowedTools && allowedTools.length > 0 && config.hooks.length === 0) {
     issues.push({
       analyzer: "Settings",
-      severity: "info",
-      message: "No environment variables defined in settings",
-      fix: "Define env vars in settings.json for consistent development environments"
+      severity: "medium",
+      message: "Tools auto-allowed without any hooks \u2014 no safety net for dangerous operations",
+      fix: "Add PreToolUse hooks for security or remove allowedTools to use interactive prompting"
     });
   }
-  const score = Math.max(0, 100 - issues.length * 15);
+  const actionableCount = issues.filter((i) => i.severity !== "info").length;
+  const score = Math.max(0, 100 - actionableCount * 20);
   return { name: "Settings", issues, score };
 }
 
@@ -1266,6 +1266,12 @@ async function applyFixes(issues, projectRoot) {
   return { fixed, skipped };
 }
 async function tryFix(issue, root, detected) {
+  if (issue.analyzer === "Hooks" && issue.message.includes("No hooks configured")) {
+    const a = await addEnvProtectionHook(root);
+    const b = await addAutoFormatHook(root, detected);
+    const c = await addForcePushProtection(root);
+    return a || b || c;
+  }
   if (issue.analyzer === "Hooks" && issue.message.includes(".env file protection")) {
     return addEnvProtectionHook(root);
   }
@@ -1434,9 +1440,93 @@ async function writeSettingsJson(root, settings) {
   await writeFile2(join4(dir, "settings.json"), JSON.stringify(settings, null, 2) + "\n");
 }
 
+// src/commands/doctor/watcher.ts
+import { watch } from "fs";
+import { join as join5 } from "path";
+async function watchConfig(projectRoot) {
+  const claudeDir = join5(projectRoot, ".claude");
+  const claudeMd = join5(projectRoot, "CLAUDE.md");
+  const claudeignore = join5(projectRoot, ".claudeignore");
+  await runAndDisplay(projectRoot);
+  log.blank();
+  log.info("Watching for changes... (Ctrl+C to stop)");
+  log.blank();
+  let debounce = null;
+  const onChange = () => {
+    if (debounce) clearTimeout(debounce);
+    debounce = setTimeout(async () => {
+      console.clear();
+      await runAndDisplay(projectRoot);
+      log.blank();
+      log.info("Watching for changes... (Ctrl+C to stop)");
+      log.blank();
+    }, 300);
+  };
+  try {
+    watch(claudeDir, { recursive: true }, onChange);
+  } catch {
+  }
+  try {
+    watch(claudeMd, onChange);
+  } catch {
+  }
+  try {
+    watch(claudeignore, onChange);
+  } catch {
+  }
+  await new Promise(() => {
+  });
+}
+async function runAndDisplay(projectRoot) {
+  console.log("\x1B[36m\x1B[1m  Claude Launchpad\x1B[0m");
+  console.log("\x1B[2m  Scaffold \xB7 Diagnose \xB7 Evaluate\x1B[0m");
+  log.blank();
+  const config = await parseClaudeConfig(projectRoot);
+  if (config.claudeMdContent === null && config.settings === null) {
+    log.error("No Claude Code configuration found.");
+    return;
+  }
+  const results = await Promise.all([
+    analyzeBudget(config),
+    analyzeQuality(config),
+    analyzeSettings(config),
+    analyzeHooks(config),
+    analyzeRules(config),
+    analyzePermissions(config),
+    analyzeMcp(config)
+  ]);
+  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;
+  }
+  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, issue.fix);
+  }
+  log.info(`${actionable.length} issue(s) found. Fix critical/high first.`);
+}
+
 // 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) => {
+  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").option("--watch", "Watch for config changes and re-run automatically").action(async (opts) => {
+    if (opts.watch) {
+      await watchConfig(opts.path);
+      return;
+    }
     printBanner();
     log.step("Scanning Claude Code configuration...");
     log.blank();
@@ -1524,7 +1614,7 @@ 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 { join as join6, resolve as resolve2, dirname } from "path";
 import { fileURLToPath } from "url";
 import { parse as parseYaml } from "yaml";
 
@@ -1574,7 +1664,7 @@ function validateChecks(raw, filePath) {
       throw new ScenarioError(filePath, `checks[${i}] must be an object`);
     }
     const check = c;
-    const validTypes = ["grep", "file-exists", "file-absent", "custom"];
+    const validTypes = ["grep", "file-exists", "file-absent", "max-lines", "custom"];
     if (!validTypes.includes(check.type)) {
       throw new ScenarioError(filePath, `checks[${i}].type must be one of: ${validTypes.join(", ")}`);
     }
@@ -1647,7 +1737,7 @@ async function dirExists(path) {
 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 dirs = suite ? [join6(scenarioDir, suite)] : await getSubdirectories(scenarioDir);
   const allDirs = [scenarioDir, ...dirs];
   const scenarios = [];
   for (const dir of allDirs) {
@@ -1669,7 +1759,7 @@ async function loadScenarios(options) {
 async function getSubdirectories(dir) {
   try {
     const entries = await readdir2(dir, { withFileTypes: true });
-    return entries.filter((e) => e.isDirectory()).map((e) => join5(dir, e.name));
+    return entries.filter((e) => e.isDirectory()).map((e) => join6(dir, e.name));
   } catch {
     return [];
   }
@@ -1677,67 +1767,26 @@ async function getSubdirectories(dir) {
 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));
+    return entries.filter((e) => e.isFile() && (e.name.endsWith(".yaml") || e.name.endsWith(".yml"))).map((e) => join6(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 { mkdir as mkdir3, writeFile as writeFile3, readFile as readFile7, readdir as readdir3, rm } from "fs/promises";
+import { join as join7, 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()}`);
+  const sandboxDir = join7(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
-    };
+    await setupSandbox(sandboxDir, scenario);
+    await runClaudeInSandbox(sandboxDir, scenario.prompt, options.timeout);
+    return await scoreResults(scenario, sandboxDir);
   } finally {
     if (options.debug) {
       console.log(`  DEBUG: Sandbox preserved at ${sandboxDir}`);
@@ -1756,9 +1805,63 @@ async function runScenarioWithRetries(scenario, options) {
   const sorted = [...results].sort((a, b) => a.score - b.score);
   return sorted[Math.floor(sorted.length / 2)];
 }
-async function runClaude(cwd, prompt, timeout) {
+async function setupSandbox(sandboxDir, scenario) {
+  await mkdir3(sandboxDir, { recursive: true });
+  for (const file of scenario.setup.files) {
+    const filePath = join7(sandboxDir, file.path);
+    await mkdir3(dirname2(filePath), { recursive: true });
+    await writeFile3(filePath, file.content);
+  }
+  if (scenario.setup.instructions) {
+    await writeFile3(
+      join7(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 });
+}
+async function runClaudeInSandbox(cwd, prompt, timeout) {
+  try {
+    const sdk = await import("@anthropic-ai/claude-agent-sdk");
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      for await (const _message of sdk.query({
+        prompt,
+        options: {
+          cwd,
+          allowedTools: ["Bash", "Read", "Write", "Edit", "Glob", "Grep"],
+          permissionMode: "dontAsk",
+          settingSources: [],
+          maxTurns: 20,
+          abortController: controller
+        }
+      })) {
+      }
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  } catch {
+    await runClaudeCli(cwd, prompt, timeout);
+  }
+}
+async function runClaudeCli(cwd, prompt, timeout) {
   try {
-    return await exec(
+    await exec(
       "claude",
       [
         "-p",
@@ -1769,29 +1872,34 @@ async function runClaude(cwd, prompt, timeout) {
         "20",
         "--dangerously-skip-permissions",
         "--allowedTools",
+        "Bash",
         "Read",
         "Write",
         "Edit",
-        "Bash",
         "Glob",
         "Grep"
       ],
-      {
-        cwd,
-        timeout,
-        maxBuffer: 10 * 1024 * 1024
-      }
+      { 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 ?? "")
-      };
+      return;
     }
     throw error;
   }
 }
+async function scoreResults(scenario, sandboxDir) {
+  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
+  };
+}
 async function evaluateChecks(checks, sandboxDir) {
   const results = [];
   for (const check of checks) {
@@ -1802,37 +1910,81 @@ async function evaluateChecks(checks, sandboxDir) {
 }
 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 "grep":
+      return checkGrep(check, sandboxDir);
+    case "file-exists":
+      return checkFileExists(check, sandboxDir);
+    case "file-absent":
+      return checkFileAbsent(check, sandboxDir);
+    case "max-lines":
+      return checkMaxLines(check, sandboxDir);
+    case "custom":
+      return false;
+    default:
+      return false;
+  }
+}
+async function checkGrep(check, sandboxDir) {
+  if (!check.pattern) return false;
+  try {
+    const content = await readFile7(join7(sandboxDir, check.target), "utf-8");
+    let found;
+    try {
+      found = new RegExp(check.pattern).test(content);
+    } catch {
+      return false;
     }
-    case "file-exists": {
-      try {
-        await readFile7(join6(sandboxDir, check.target));
-        return check.expect === "present";
-      } catch {
+    return check.expect === "present" ? found : !found;
+  } catch {
+    return check.expect === "absent";
+  }
+}
+async function checkFileExists(check, sandboxDir) {
+  try {
+    await readFile7(join7(sandboxDir, check.target));
+    return check.expect === "present";
+  } catch {
+    return check.expect === "absent";
+  }
+}
+async function checkFileAbsent(check, sandboxDir) {
+  try {
+    await readFile7(join7(sandboxDir, check.target));
+    return check.expect === "absent";
+  } catch {
+    return check.expect === "present";
+  }
+}
+async function checkMaxLines(check, sandboxDir) {
+  const maxLines = parseInt(check.pattern ?? "800", 10);
+  try {
+    const files = await listAllFiles(join7(sandboxDir, check.target));
+    for (const file of files) {
+      const content = await readFile7(file, "utf-8");
+      if (content.split("\n").length > maxLines) {
         return check.expect === "absent";
       }
     }
-    case "file-absent": {
-      try {
-        await readFile7(join6(sandboxDir, check.target));
-        return check.expect === "absent";
-      } catch {
-        return check.expect === "present";
+    return check.expect === "present";
+  } catch {
+    return check.expect === "absent";
+  }
+}
+async function listAllFiles(dir) {
+  const results = [];
+  try {
+    const entries = await readdir3(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join7(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...await listAllFiles(fullPath));
+      } else {
+        results.push(fullPath);
       }
     }
-    case "custom":
-      return false;
-    default:
-      return false;
+  } catch {
   }
+  return results;
 }
 
 // src/commands/eval/index.ts
@@ -1949,7 +2101,7 @@ 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";
+import { join as join8 } 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:
 
@@ -1967,7 +2119,7 @@ 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");
+    const claudeMdPath = join8(root, "CLAUDE.md");
     try {
       await access6(claudeMdPath);
     } catch {
@@ -1996,8 +2148,8 @@ function createEnhanceCommand() {
 }
 
 // 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"));
+var program = new Command5().name("claude-launchpad").description("CLI toolkit that makes Claude Code setups measurably good").version("0.2.1").action(async () => {
+  const hasConfig = await fileExists3(join9(process.cwd(), "CLAUDE.md")) || await fileExists3(join9(process.cwd(), ".claude", "settings.json"));
   if (hasConfig) {
     await program.commands.find((c) => c.name() === "doctor")?.parseAsync([], { from: "user" });
   } else {