kairn-cli 1.0.0 → 1.2.0

package/dist/cli.js

@@ -1,5 +1,5 @@
 // src/cli.ts
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 
 // src/commands/init.ts
 import { Command } from "commander";
@@ -29,7 +29,17 @@ async function ensureDirs() {
 async function loadConfig() {
   try {
     const data = await fs.readFile(CONFIG_PATH, "utf-8");
-    return JSON.parse(data);
+    const raw = JSON.parse(data);
+    if (raw.anthropic_api_key && !raw.provider) {
+      return {
+        provider: "anthropic",
+        api_key: raw.anthropic_api_key,
+        model: "claude-sonnet-4-6",
+        default_runtime: "claude-code",
+        created_at: raw.created_at || (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    return raw;
   } catch {
     return null;
   }
@@ -44,9 +54,9 @@ var PROVIDER_MODELS = {
   anthropic: {
     name: "Anthropic",
     models: [
-      { name: "Claude Sonnet 4 (recommended \u2014 fast, cheap)", value: "claude-sonnet-4-20250514" },
-      { name: "Claude Opus 4 (highest quality)", value: "claude-opus-4-20250514" },
-      { name: "Claude Haiku 3.5 (fastest, cheapest)", value: "claude-3-5-haiku-20241022" }
+      { name: "Claude Sonnet 4.6 (recommended \u2014 fast, smart)", value: "claude-sonnet-4-6" },
+      { name: "Claude Opus 4.6 (highest quality)", value: "claude-opus-4-6" },
+      { name: "Claude Haiku 4.5 (fastest, cheapest)", value: "claude-haiku-4-5-20251001" }
     ]
   },
   openai: {
@@ -70,7 +80,7 @@ async function verifyKey(provider, apiKey, model) {
     if (provider === "anthropic") {
       const client = new Anthropic({ apiKey });
       await client.messages.create({
-        model: "claude-3-5-haiku-20241022",
+        model: "claude-haiku-4-5-20251001",
         max_tokens: 10,
         messages: [{ role: "user", content: "ping" }]
       });
@@ -514,11 +524,23 @@ async function writeEnvironment(spec, targetDir) {
 }
 function summarizeSpec(spec, registry) {
   const pluginCommands = [];
+  const envSetup = [];
   for (const selected of spec.tools) {
     const tool = registry.find((t) => t.id === selected.tool_id);
-    if (tool?.install.plugin_command) {
+    if (!tool) continue;
+    if (tool.install.plugin_command) {
       pluginCommands.push(tool.install.plugin_command);
     }
+    if (tool.env_vars) {
+      for (const ev of tool.env_vars) {
+        envSetup.push({
+          toolName: tool.name,
+          envVar: ev.name,
+          description: ev.description,
+          signupUrl: tool.signup_url
+        });
+      }
+    }
   }
   return {
     toolCount: spec.tools.length,
@@ -526,7 +548,8 @@ function summarizeSpec(spec, registry) {
     ruleCount: Object.keys(spec.harness.rules || {}).length,
     skillCount: Object.keys(spec.harness.skills || {}).length,
     agentCount: Object.keys(spec.harness.agents || {}).length,
-    pluginCommands
+    pluginCommands,
+    envSetup
   };
 }
 
@@ -619,8 +642,22 @@ var describeCommand = new Command2("describe").description("Describe your workfl
   for (const file of written) {
     console.log(chalk2.dim(`    ${file}`));
   }
+  if (summary.envSetup.length > 0) {
+    console.log(chalk2.yellow("\n  API keys needed (set these environment variables):\n"));
+    const seen = /* @__PURE__ */ new Set();
+    for (const env of summary.envSetup) {
+      if (seen.has(env.envVar)) continue;
+      seen.add(env.envVar);
+      console.log(chalk2.bold(`    export ${env.envVar}="your-key-here"`));
+      console.log(chalk2.dim(`      ${env.description}`));
+      if (env.signupUrl) {
+        console.log(chalk2.dim(`      Get one at: ${env.signupUrl}`));
+      }
+      console.log("");
+    }
+  }
   if (summary.pluginCommands.length > 0) {
-    console.log(chalk2.yellow("\n  Install plugins by running these in Claude Code:"));
+    console.log(chalk2.yellow("  Install plugins by running these in Claude Code:"));
     for (const cmd of summary.pluginCommands) {
       console.log(chalk2.bold(`    ${cmd}`));
     }
@@ -780,13 +817,437 @@ var updateRegistryCommand = new Command5("update-registry").description("Fetch t
   }
 });
 
+// src/commands/optimize.ts
+import { Command as Command6 } from "commander";
+import { confirm as confirm2 } from "@inquirer/prompts";
+import chalk6 from "chalk";
+import fs9 from "fs/promises";
+import path9 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+
+// src/scanner/scan.ts
+import fs8 from "fs/promises";
+import path8 from "path";
+async function fileExists(p) {
+  try {
+    await fs8.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJsonSafe(p) {
+  try {
+    const data = await fs8.readFile(p, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+async function readFileSafe(p) {
+  try {
+    return await fs8.readFile(p, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function listDirSafe(p) {
+  try {
+    const entries = await fs8.readdir(p);
+    return entries.filter((e) => !e.startsWith("."));
+  } catch {
+    return [];
+  }
+}
+function detectFramework(deps) {
+  const frameworks = [
+    [["next"], "Next.js"],
+    [["nuxt"], "Nuxt"],
+    [["@remix-run/node", "@remix-run/react"], "Remix"],
+    [["svelte", "@sveltejs/kit"], "SvelteKit"],
+    [["express"], "Express"],
+    [["fastify"], "Fastify"],
+    [["hono"], "Hono"],
+    [["react", "react-dom"], "React"],
+    [["vue"], "Vue"],
+    [["angular"], "Angular"],
+    [["django"], "Django"],
+    [["flask"], "Flask"],
+    [["fastapi"], "FastAPI"],
+    [["@supabase/supabase-js"], "Supabase"],
+    [["prisma", "@prisma/client"], "Prisma"],
+    [["drizzle-orm"], "Drizzle"],
+    [["tailwindcss"], "Tailwind CSS"]
+  ];
+  const detected = [];
+  for (const [packages, name] of frameworks) {
+    if (packages.some((pkg) => deps.includes(pkg))) {
+      detected.push(name);
+    }
+  }
+  return detected.length > 0 ? detected.join(" + ") : null;
+}
+function detectLanguage(dir, keyFiles) {
+  if (keyFiles.some((f) => f === "tsconfig.json")) return "TypeScript";
+  if (keyFiles.some((f) => f === "package.json")) return "JavaScript";
+  if (keyFiles.some((f) => f === "pyproject.toml" || f === "setup.py" || f === "requirements.txt")) return "Python";
+  if (keyFiles.some((f) => f === "Cargo.toml")) return "Rust";
+  if (keyFiles.some((f) => f === "go.mod")) return "Go";
+  if (keyFiles.some((f) => f === "Gemfile")) return "Ruby";
+  return null;
+}
+function extractEnvKeys(content) {
+  const keys = [];
+  for (const line of content.split("\n")) {
+    const match = line.match(/^([A-Z][A-Z0-9_]*)=/);
+    if (match) keys.push(match[1]);
+  }
+  return keys;
+}
+async function scanProject(dir) {
+  const pkg = await readJsonSafe(path8.join(dir, "package.json"));
+  const deps = pkg?.dependencies ? Object.keys(pkg.dependencies) : [];
+  const devDeps = pkg?.devDependencies ? Object.keys(pkg.devDependencies) : [];
+  const allDeps = [...deps, ...devDeps];
+  const scripts = pkg?.scripts || {};
+  const rootFiles = await listDirSafe(dir);
+  const keyFiles = rootFiles.filter(
+    (f) => [
+      "package.json",
+      "tsconfig.json",
+      "pyproject.toml",
+      "setup.py",
+      "requirements.txt",
+      "Cargo.toml",
+      "go.mod",
+      "Gemfile",
+      "docker-compose.yml",
+      "Dockerfile",
+      ".env.example",
+      ".env",
+      "README.md",
+      "CLAUDE.md"
+    ].includes(f)
+  );
+  const language = detectLanguage(dir, keyFiles);
+  const framework = detectFramework(allDeps);
+  const typescript = keyFiles.includes("tsconfig.json") || allDeps.includes("typescript");
+  const testCommand = scripts.test && scripts.test !== 'echo "Error: no test specified" && exit 1' ? scripts.test : null;
+  const hasTests = testCommand !== null || await fileExists(path8.join(dir, "tests")) || await fileExists(path8.join(dir, "__tests__")) || await fileExists(path8.join(dir, "test"));
+  const buildCommand = scripts.build || null;
+  const lintCommand = scripts.lint || null;
+  const hasSrc = await fileExists(path8.join(dir, "src"));
+  const hasDocker = await fileExists(path8.join(dir, "docker-compose.yml")) || await fileExists(path8.join(dir, "Dockerfile"));
+  const hasCi = await fileExists(path8.join(dir, ".github/workflows"));
+  const hasEnvFile = await fileExists(path8.join(dir, ".env")) || await fileExists(path8.join(dir, ".env.example"));
+  let envKeys = [];
+  const envExample = await readFileSafe(path8.join(dir, ".env.example"));
+  if (envExample) {
+    envKeys = extractEnvKeys(envExample);
+  }
+  const claudeDir = path8.join(dir, ".claude");
+  const hasClaudeDir = await fileExists(claudeDir);
+  let existingClaudeMd = null;
+  let existingSettings = null;
+  let existingMcpConfig = null;
+  let existingCommands = [];
+  let existingRules = [];
+  let existingSkills = [];
+  let existingAgents = [];
+  let mcpServerCount = 0;
+  let claudeMdLineCount = 0;
+  if (hasClaudeDir) {
+    existingClaudeMd = await readFileSafe(path8.join(claudeDir, "CLAUDE.md"));
+    if (existingClaudeMd) {
+      claudeMdLineCount = existingClaudeMd.split("\n").length;
+    }
+    existingSettings = await readJsonSafe(path8.join(claudeDir, "settings.json"));
+    existingMcpConfig = await readJsonSafe(path8.join(dir, ".mcp.json"));
+    if (existingMcpConfig?.mcpServers) {
+      mcpServerCount = Object.keys(existingMcpConfig.mcpServers).length;
+    }
+    existingCommands = (await listDirSafe(path8.join(claudeDir, "commands"))).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
+    existingRules = (await listDirSafe(path8.join(claudeDir, "rules"))).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
+    existingSkills = await listDirSafe(path8.join(claudeDir, "skills"));
+    existingAgents = (await listDirSafe(path8.join(claudeDir, "agents"))).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
+  }
+  const name = pkg?.name || path8.basename(dir);
+  const description = pkg?.description || "";
+  return {
+    name,
+    description,
+    directory: dir,
+    language,
+    framework,
+    typescript,
+    dependencies: deps,
+    devDependencies: devDeps,
+    scripts,
+    hasTests,
+    testCommand,
+    buildCommand,
+    lintCommand,
+    hasSrc,
+    hasDocker,
+    hasCi,
+    hasEnvFile,
+    envKeys,
+    hasClaudeDir,
+    existingClaudeMd,
+    existingSettings,
+    existingMcpConfig,
+    existingCommands,
+    existingRules,
+    existingSkills,
+    existingAgents,
+    mcpServerCount,
+    claudeMdLineCount,
+    keyFiles
+  };
+}
+
+// src/commands/optimize.ts
+async function loadRegistry3() {
+  const __filename = fileURLToPath4(import.meta.url);
+  const __dirname = path9.dirname(__filename);
+  const candidates = [
+    path9.resolve(__dirname, "../registry/tools.json"),
+    path9.resolve(__dirname, "../src/registry/tools.json"),
+    path9.resolve(__dirname, "../../src/registry/tools.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      const data = await fs9.readFile(candidate, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("Could not find tools.json registry");
+}
+function buildProfileSummary(profile) {
+  const lines = [];
+  lines.push(`Project: ${profile.name}`);
+  if (profile.description) lines.push(`Description: ${profile.description}`);
+  if (profile.language) lines.push(`Language: ${profile.language}`);
+  if (profile.framework) lines.push(`Framework: ${profile.framework}`);
+  if (profile.dependencies.length > 0) {
+    lines.push(`Dependencies: ${profile.dependencies.join(", ")}`);
+  }
+  if (profile.testCommand) lines.push(`Test command: ${profile.testCommand}`);
+  if (profile.buildCommand) lines.push(`Build command: ${profile.buildCommand}`);
+  if (profile.lintCommand) lines.push(`Lint command: ${profile.lintCommand}`);
+  if (profile.hasDocker) lines.push("Has Docker configuration");
+  if (profile.hasCi) lines.push("Has CI/CD (GitHub Actions)");
+  if (profile.envKeys.length > 0) {
+    lines.push(`Env keys needed: ${profile.envKeys.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function buildAuditSummary(profile) {
+  const lines = [];
+  lines.push(`
+Existing .claude/ harness found:`);
+  lines.push(`  CLAUDE.md: ${profile.claudeMdLineCount} lines${profile.claudeMdLineCount > 200 ? " (\u26A0 over 200 \u2014 may degrade adherence)" : ""}`);
+  lines.push(`  MCP servers: ${profile.mcpServerCount}`);
+  lines.push(`  Commands: ${profile.existingCommands.length > 0 ? profile.existingCommands.map((c) => `/project:${c}`).join(", ") : "none"}`);
+  lines.push(`  Rules: ${profile.existingRules.length > 0 ? profile.existingRules.join(", ") : "none"}`);
+  lines.push(`  Skills: ${profile.existingSkills.length > 0 ? profile.existingSkills.join(", ") : "none"}`);
+  lines.push(`  Agents: ${profile.existingAgents.length > 0 ? profile.existingAgents.join(", ") : "none"}`);
+  return lines.join("\n");
+}
+function buildOptimizeIntent(profile) {
+  const parts = [];
+  parts.push("## Project Profile (scanned from actual codebase)\n");
+  parts.push(buildProfileSummary(profile));
+  if (profile.hasClaudeDir) {
+    parts.push(buildAuditSummary(profile));
+    if (profile.existingClaudeMd) {
+      parts.push(`
+## Existing CLAUDE.md Content
+
+${profile.existingClaudeMd}`);
+    }
+    parts.push(`
+## Task
+`);
+    parts.push("Analyze this existing Claude Code environment and generate an OPTIMIZED version.");
+    parts.push("Preserve what works. Fix what's wrong. Add what's missing. Remove what's bloat.");
+    parts.push("Key optimizations to consider:");
+    parts.push("- Is CLAUDE.md under 100 lines? If not, move detail to rules/ or docs/");
+    parts.push("- Are the right MCP servers selected for these dependencies?");
+    parts.push("- Are there missing slash commands (help, tasks, plan, test, commit)?");
+    parts.push("- Are security rules present?");
+    parts.push("- Is there a continuity rule for session memory?");
+    parts.push("- Are there unnecessary MCP servers adding context bloat?");
+    if (profile.claudeMdLineCount > 200) {
+      parts.push(`- CLAUDE.md is ${profile.claudeMdLineCount} lines \u2014 needs aggressive trimming`);
+    }
+    if (!profile.existingCommands.includes("help")) {
+      parts.push("- Missing /project:help command");
+    }
+    if (!profile.existingRules.includes("security")) {
+      parts.push("- Missing security rules");
+    }
+  } else {
+    parts.push(`
+## Task
+`);
+    parts.push("Generate an optimal Claude Code environment for this existing project.");
+    parts.push("Use the scanned project profile \u2014 this is a real codebase, not a description.");
+    parts.push("The environment should match the actual tech stack, dependencies, and workflows.");
+  }
+  return parts.join("\n");
+}
+var optimizeCommand = new Command6("optimize").description("Scan an existing project and generate or optimize its Claude Code environment").option("-y, --yes", "Skip confirmation prompts").option("--audit-only", "Only audit the existing harness, don't generate changes").action(async (options) => {
+  const config = await loadConfig();
+  if (!config) {
+    console.log(
+      chalk6.red("\n  No config found. Run ") + chalk6.bold("kairn init") + chalk6.red(" first.\n")
+    );
+    process.exit(1);
+  }
+  const targetDir = process.cwd();
+  console.log(chalk6.dim("\n  Scanning project..."));
+  const profile = await scanProject(targetDir);
+  console.log(chalk6.cyan("\n  Project Profile\n"));
+  if (profile.language) console.log(chalk6.dim(`  Language:   ${profile.language}`));
+  if (profile.framework) console.log(chalk6.dim(`  Framework:  ${profile.framework}`));
+  console.log(chalk6.dim(`  Dependencies: ${profile.dependencies.length}`));
+  if (profile.testCommand) console.log(chalk6.dim(`  Tests:      ${profile.testCommand}`));
+  if (profile.buildCommand) console.log(chalk6.dim(`  Build:      ${profile.buildCommand}`));
+  if (profile.hasDocker) console.log(chalk6.dim("  Docker:     yes"));
+  if (profile.hasCi) console.log(chalk6.dim("  CI/CD:      yes"));
+  if (profile.envKeys.length > 0) console.log(chalk6.dim(`  Env keys:   ${profile.envKeys.join(", ")}`));
+  if (profile.hasClaudeDir) {
+    console.log(chalk6.yellow("\n  Existing .claude/ harness detected\n"));
+    console.log(chalk6.dim(`  CLAUDE.md:  ${profile.claudeMdLineCount} lines${profile.claudeMdLineCount > 200 ? chalk6.yellow(" \u26A0 bloated") : chalk6.green(" \u2713")}`));
+    console.log(chalk6.dim(`  MCP servers: ${profile.mcpServerCount}`));
+    console.log(chalk6.dim(`  Commands:   ${profile.existingCommands.length > 0 ? profile.existingCommands.map((c) => c).join(", ") : "none"}`));
+    console.log(chalk6.dim(`  Rules:      ${profile.existingRules.length > 0 ? profile.existingRules.join(", ") : "none"}`));
+    console.log(chalk6.dim(`  Skills:     ${profile.existingSkills.length > 0 ? profile.existingSkills.join(", ") : "none"}`));
+    console.log(chalk6.dim(`  Agents:     ${profile.existingAgents.length > 0 ? profile.existingAgents.join(", ") : "none"}`));
+    const issues = [];
+    if (profile.claudeMdLineCount > 200) issues.push("CLAUDE.md over 200 lines \u2014 move detail to rules/ or docs/");
+    if (!profile.existingCommands.includes("help")) issues.push("Missing /project:help command");
+    if (!profile.existingRules.includes("security")) issues.push("Missing security rules");
+    if (!profile.existingRules.includes("continuity")) issues.push("Missing continuity rule for session memory");
+    if (profile.mcpServerCount > 8) issues.push(`${profile.mcpServerCount} MCP servers \u2014 may cause context bloat`);
+    if (profile.mcpServerCount === 0 && profile.dependencies.length > 0) issues.push("No MCP servers configured");
+    if (profile.hasTests && !profile.existingCommands.includes("test")) issues.push("Has tests but no /project:test command");
+    if (!profile.existingCommands.includes("tasks")) issues.push("Missing /project:tasks command");
+    if (issues.length > 0) {
+      console.log(chalk6.yellow("\n  Issues Found:\n"));
+      for (const issue of issues) {
+        console.log(chalk6.yellow(`    \u26A0 ${issue}`));
+      }
+    } else {
+      console.log(chalk6.green("\n  \u2713 No obvious issues found"));
+    }
+    if (options.auditOnly) {
+      console.log(chalk6.dim("\n  Audit complete. Run without --audit-only to generate optimized environment.\n"));
+      return;
+    }
+    if (!options.yes) {
+      console.log("");
+      const proceed = await confirm2({
+        message: "Generate optimized environment? This will overwrite existing .claude/ files.",
+        default: false
+      });
+      if (!proceed) {
+        console.log(chalk6.dim("\n  Aborted.\n"));
+        return;
+      }
+    }
+  } else {
+    console.log(chalk6.dim("\n  No existing .claude/ directory found \u2014 generating from scratch.\n"));
+    if (!options.yes) {
+      const proceed = await confirm2({
+        message: "Generate Claude Code environment for this project?",
+        default: true
+      });
+      if (!proceed) {
+        console.log(chalk6.dim("\n  Aborted.\n"));
+        return;
+      }
+    }
+  }
+  const intent = buildOptimizeIntent(profile);
+  let spec;
+  try {
+    spec = await compile(intent, (msg) => {
+      process.stdout.write(`\r  ${chalk6.dim(msg)}                    `);
+    });
+    process.stdout.write("\r                                              \r");
+  } catch (err) {
+    process.stdout.write("\r                                              \r");
+    const msg = err instanceof Error ? err.message : String(err);
+    console.log(chalk6.red(`
+  Optimization failed: ${msg}
+`));
+    process.exit(1);
+  }
+  const registry = await loadRegistry3();
+  const summary = summarizeSpec(spec, registry);
+  console.log(chalk6.green("  \u2713 Environment compiled\n"));
+  console.log(chalk6.cyan("  Name: ") + spec.name);
+  console.log(chalk6.cyan("  Tools: ") + summary.toolCount);
+  console.log(chalk6.cyan("  Commands: ") + summary.commandCount);
+  console.log(chalk6.cyan("  Rules: ") + summary.ruleCount);
+  console.log(chalk6.cyan("  Skills: ") + summary.skillCount);
+  console.log(chalk6.cyan("  Agents: ") + summary.agentCount);
+  if (spec.tools.length > 0) {
+    console.log(chalk6.dim("\n  Selected tools:"));
+    for (const tool of spec.tools) {
+      const regTool = registry.find((t) => t.id === tool.tool_id);
+      const name = regTool?.name || tool.tool_id;
+      console.log(chalk6.dim(`    - ${name}: ${tool.reason}`));
+    }
+  }
+  if (summary.pluginCommands.length > 0) {
+    console.log(chalk6.yellow("\n  Plugins to install manually:"));
+    for (const cmd of summary.pluginCommands) {
+      console.log(chalk6.yellow(`    ${cmd}`));
+    }
+  }
+  const written = await writeEnvironment(spec, targetDir);
+  console.log(chalk6.green("\n  \u2713 Environment written\n"));
+  for (const file of written) {
+    console.log(chalk6.dim(`    ${file}`));
+  }
+  if (summary.envSetup.length > 0) {
+    console.log(chalk6.yellow("\n  API keys needed (set these environment variables):\n"));
+    const seen = /* @__PURE__ */ new Set();
+    for (const env of summary.envSetup) {
+      if (seen.has(env.envVar)) continue;
+      seen.add(env.envVar);
+      console.log(chalk6.bold(`    export ${env.envVar}="your-key-here"`));
+      console.log(chalk6.dim(`      ${env.description}`));
+      if (env.signupUrl) {
+        console.log(chalk6.dim(`      Get one at: ${env.signupUrl}`));
+      }
+      console.log("");
+    }
+  }
+  if (summary.pluginCommands.length > 0) {
+    console.log(chalk6.yellow("  Install plugins by running these in Claude Code:"));
+    for (const cmd of summary.pluginCommands) {
+      console.log(chalk6.bold(`    ${cmd}`));
+    }
+  }
+  console.log(
+    chalk6.cyan("\n  Ready! Run ") + chalk6.bold("claude") + chalk6.cyan(" to start.\n")
+  );
+});
+
 // src/cli.ts
-var program = new Command6();
+var program = new Command7();
 program.name("kairn").description(
   "Compile natural language intent into optimized Claude Code environments"
-).version("0.1.0");
+).version("1.0.0");
 program.addCommand(initCommand);
 program.addCommand(describeCommand);
+program.addCommand(optimizeCommand);
 program.addCommand(listCommand);
 program.addCommand(activateCommand);
 program.addCommand(updateRegistryCommand);