kairn-cli 1.0.0

package/dist/cli.js

@@ -0,0 +1,794 @@
+// src/cli.ts
+import { Command as Command6 } from "commander";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import { password, select } from "@inquirer/prompts";
+import chalk from "chalk";
+import Anthropic from "@anthropic-ai/sdk";
+import OpenAI from "openai";
+import { execFileSync } from "child_process";
+
+// src/config.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+var KAIRN_DIR = path.join(os.homedir(), ".kairn");
+var CONFIG_PATH = path.join(KAIRN_DIR, "config.json");
+var ENVS_DIR = path.join(KAIRN_DIR, "envs");
+function getConfigPath() {
+  return CONFIG_PATH;
+}
+function getEnvsDir() {
+  return ENVS_DIR;
+}
+async function ensureDirs() {
+  await fs.mkdir(KAIRN_DIR, { recursive: true });
+  await fs.mkdir(ENVS_DIR, { recursive: true });
+}
+async function loadConfig() {
+  try {
+    const data = await fs.readFile(CONFIG_PATH, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+async function saveConfig(config) {
+  await ensureDirs();
+  await fs.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+}
+
+// src/commands/init.ts
+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" }
+    ]
+  },
+  openai: {
+    name: "OpenAI",
+    models: [
+      { name: "GPT-4o (recommended)", value: "gpt-4o" },
+      { name: "GPT-4o mini (faster, cheaper)", value: "gpt-4o-mini" },
+      { name: "o3 (reasoning)", value: "o3" }
+    ]
+  },
+  google: {
+    name: "Google Gemini",
+    models: [
+      { name: "Gemini 2.5 Flash (recommended)", value: "gemini-2.5-flash-preview-05-20" },
+      { name: "Gemini 2.5 Pro (highest quality)", value: "gemini-2.5-pro-preview-05-06" }
+    ]
+  }
+};
+async function verifyKey(provider, apiKey, model) {
+  try {
+    if (provider === "anthropic") {
+      const client = new Anthropic({ apiKey });
+      await client.messages.create({
+        model: "claude-3-5-haiku-20241022",
+        max_tokens: 10,
+        messages: [{ role: "user", content: "ping" }]
+      });
+      return true;
+    } else if (provider === "openai") {
+      const client = new OpenAI({ apiKey });
+      await client.chat.completions.create({
+        model: "gpt-4o-mini",
+        max_tokens: 10,
+        messages: [{ role: "user", content: "ping" }]
+      });
+      return true;
+    } else if (provider === "google") {
+      const client = new OpenAI({
+        apiKey,
+        baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/"
+      });
+      await client.chat.completions.create({
+        model: "gemini-2.5-flash-preview-05-20",
+        max_tokens: 10,
+        messages: [{ role: "user", content: "ping" }]
+      });
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function detectClaudeCode() {
+  try {
+    execFileSync("which", ["claude"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var initCommand = new Command("init").description("Set up Kairn with your API key").action(async () => {
+  console.log(chalk.cyan("\n  Kairn Setup\n"));
+  const existing = await loadConfig();
+  if (existing) {
+    console.log(
+      chalk.yellow("  Config already exists at ") + chalk.dim(getConfigPath())
+    );
+    console.log(chalk.yellow("  Running setup will overwrite it.\n"));
+  }
+  const provider = await select({
+    message: "LLM provider",
+    choices: [
+      { name: "Anthropic (Claude) \u2014 recommended", value: "anthropic" },
+      { name: "OpenAI (GPT)", value: "openai" },
+      { name: "Google (Gemini)", value: "google" }
+    ]
+  });
+  const providerInfo = PROVIDER_MODELS[provider];
+  const model = await select({
+    message: "Compilation model",
+    choices: providerInfo.models
+  });
+  const apiKey = await password({
+    message: `${providerInfo.name} API key`,
+    mask: "*"
+  });
+  if (!apiKey) {
+    console.log(chalk.red("\n  No API key provided. Aborting."));
+    process.exit(1);
+  }
+  console.log(chalk.dim("\n  Verifying API key..."));
+  const valid = await verifyKey(provider, apiKey, model);
+  if (!valid) {
+    console.log(
+      chalk.red("  Invalid API key. Check your key and try again.")
+    );
+    process.exit(1);
+  }
+  console.log(chalk.green("  \u2713 API key verified"));
+  const config = {
+    provider,
+    api_key: apiKey,
+    model,
+    default_runtime: "claude-code",
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await saveConfig(config);
+  console.log(
+    chalk.green("  \u2713 Config saved to ") + chalk.dim(getConfigPath())
+  );
+  console.log(
+    chalk.dim(`  \u2713 Provider: ${providerInfo.name}, Model: ${model}`)
+  );
+  const hasClaude = detectClaudeCode();
+  if (hasClaude) {
+    console.log(chalk.green("  \u2713 Claude Code detected"));
+  } else {
+    console.log(
+      chalk.yellow(
+        "  \u26A0 Claude Code not found. Install it: npm install -g @anthropic-ai/claude-code"
+      )
+    );
+  }
+  console.log(
+    chalk.cyan("\n  Ready! Run ") + chalk.bold("kairn describe") + chalk.cyan(" to create your first environment.\n")
+  );
+});
+
+// src/commands/describe.ts
+import { Command as Command2 } from "commander";
+import { input, confirm } from "@inquirer/prompts";
+import chalk2 from "chalk";
+import fs4 from "fs/promises";
+import path4 from "path";
+
+// src/compiler/compile.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import { fileURLToPath } from "url";
+import crypto from "crypto";
+import Anthropic2 from "@anthropic-ai/sdk";
+import OpenAI2 from "openai";
+
+// src/compiler/prompt.ts
+var SYSTEM_PROMPT = `You are the Kairn environment compiler. Your job is to generate a minimal, optimal Claude Code agent environment from a user's natural language description of what they want their agent to do.
+
+You will receive:
+1. The user's intent (what they want to build/do)
+2. A tool registry (available MCP servers, plugins, and hooks)
+
+You must output a JSON object matching the EnvironmentSpec schema.
+
+## Core Principles
+
+- **Minimalism over completeness.** Fewer, well-chosen tools beat many generic ones. Each MCP server costs 500-2000 context tokens.
+- **Workflow-specific, not generic.** Every instruction, command, and rule must relate to the user's actual workflow.
+- **Concise CLAUDE.md.** Under 100 lines. No generic text like "be helpful." Include build/test commands, reference docs/ and skills/.
+- **Security by default.** Always include deny rules for destructive commands and secret file access.
+
+## What You Must Always Include
+
+1. A concise, workflow-specific \`claude_md\` (the CLAUDE.md content)
+2. A \`/project:help\` command that explains the environment
+3. A \`/project:tasks\` command for task management via TODO.md
+4. A \`docs/TODO.md\` file for continuity
+5. A \`docs/DECISIONS.md\` file for architectural decisions
+6. A \`docs/LEARNINGS.md\` file for non-obvious discoveries
+7. A \`rules/continuity.md\` rule encouraging updates to DECISIONS.md and LEARNINGS.md
+8. A \`rules/security.md\` rule with essential security instructions
+9. settings.json with deny rules for \`rm -rf\`, \`curl|sh\`, reading \`.env\` and \`secrets/\`
+
+## Tool Selection Rules
+
+- Only select tools directly relevant to the described workflow
+- Prefer free tools (auth: "none") when quality is comparable
+- Tier 1 tools (Context7, Sequential Thinking, security-guidance) should be included in most environments
+- For tools requiring API keys (auth: "api_key"), use \${ENV_VAR} syntax \u2014 never hardcode keys
+- Maximum 6-8 MCP servers to avoid context bloat
+- Include a \`reason\` for each selected tool explaining why it fits this workflow
+
+## For Code Projects, Additionally Include
+
+- \`/project:plan\` command (plan before coding)
+- \`/project:review\` command (review changes)
+- \`/project:test\` command (run and fix tests)
+- \`/project:commit\` command (conventional commits)
+- A TDD skill if testing is relevant
+- A reviewer agent (read-only, Sonnet model)
+
+## For Research Projects, Additionally Include
+
+- \`/project:research\` command (deep research on a topic)
+- \`/project:summarize\` command (summarize findings)
+- A research-synthesis skill
+- A researcher agent
+
+## For Content/Writing Projects, Additionally Include
+
+- \`/project:draft\` command (write first draft)
+- \`/project:edit\` command (review and improve writing)
+- A writing-workflow skill
+
+## Output Schema
+
+Return ONLY valid JSON matching this structure:
+
+\`\`\`json
+{
+  "name": "short-kebab-case-name",
+  "description": "One-line description of the environment",
+  "tools": [
+    { "tool_id": "id-from-registry", "reason": "why this tool fits" }
+  ],
+  "harness": {
+    "claude_md": "The full CLAUDE.md content (under 100 lines)",
+    "settings": {
+      "permissions": {
+        "allow": ["Bash(npm run *)", "Read", "Write", "Edit"],
+        "deny": ["Bash(rm -rf *)", "Bash(curl * | sh)", "Read(./.env)", "Read(./secrets/**)"]
+      }
+    },
+    "mcp_config": {
+      "server-name": { "command": "npx", "args": ["..."], "env": {} }
+    },
+    "commands": {
+      "help": "markdown content for /project:help",
+      "tasks": "markdown content for /project:tasks"
+    },
+    "rules": {
+      "continuity": "markdown content for continuity rule",
+      "security": "markdown content for security rule"
+    },
+    "skills": {
+      "skill-name/SKILL": "markdown content with YAML frontmatter"
+    },
+    "agents": {
+      "agent-name": "markdown content with YAML frontmatter"
+    },
+    "docs": {
+      "TODO": "# TODO\\n\\n- [ ] First task based on workflow",
+      "DECISIONS": "# Decisions\\n\\nArchitectural decisions for this project.",
+      "LEARNINGS": "# Learnings\\n\\nNon-obvious discoveries and gotchas."
+    }
+  }
+}
+\`\`\`
+
+Do not include any text outside the JSON object. Do not wrap in markdown code fences.`;
+
+// src/compiler/compile.ts
+async function loadRegistry() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path2.dirname(__filename);
+  const candidates = [
+    path2.resolve(__dirname, "../registry/tools.json"),
+    path2.resolve(__dirname, "../src/registry/tools.json"),
+    path2.resolve(__dirname, "../../src/registry/tools.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      const data = await fs2.readFile(candidate, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("Could not find tools.json registry");
+}
+function buildUserMessage(intent, registry) {
+  const registrySummary = registry.map(
+    (t) => `- ${t.id} (${t.type}, tier ${t.tier}, auth: ${t.auth}): ${t.description} [best_for: ${t.best_for.join(", ")}]`
+  ).join("\n");
+  return `## User Intent
+
+${intent}
+
+## Available Tool Registry
+
+${registrySummary}
+
+Generate the EnvironmentSpec JSON now.`;
+}
+function parseSpecResponse(text) {
+  let cleaned = text.trim();
+  if (cleaned.startsWith("```")) {
+    cleaned = cleaned.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+  }
+  const jsonMatch = cleaned.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error(
+      "LLM response did not contain valid JSON. Try again or use a different model."
+    );
+  }
+  try {
+    return JSON.parse(jsonMatch[0]);
+  } catch (err) {
+    throw new Error(
+      `Failed to parse LLM response as JSON: ${err instanceof Error ? err.message : String(err)}
+Response started with: ${cleaned.slice(0, 200)}...`
+    );
+  }
+}
+function classifyError(err, provider) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const status = err?.status;
+  const code = err?.code;
+  if (code === "ECONNREFUSED" || code === "ENOTFOUND" || code === "ETIMEDOUT") {
+    return `Network error: could not reach ${provider} API. Check your internet connection.`;
+  }
+  if (status === 401 || msg.includes("invalid") && msg.includes("key")) {
+    return `Invalid API key for ${provider}. Run \`kairn init\` to reconfigure.`;
+  }
+  if (status === 403) {
+    return `Access denied by ${provider}. Your API key may lack permissions for this model.`;
+  }
+  if (status === 429 || msg.includes("rate limit") || msg.includes("quota")) {
+    return `Rate limited by ${provider}. Wait a moment and try again, or switch to a cheaper model with \`kairn init\`.`;
+  }
+  if (status === 404 || msg.includes("not found") || msg.includes("does not exist")) {
+    return `Model not found on ${provider}. Run \`kairn init\` to select a valid model.`;
+  }
+  if (status === 529 || status === 503 || msg.includes("overloaded")) {
+    return `${provider} is temporarily overloaded. Try again in a few seconds.`;
+  }
+  if (msg.includes("token") && (msg.includes("limit") || msg.includes("exceed"))) {
+    return `Request too large for the selected model. Try a shorter workflow description.`;
+  }
+  if (msg.includes("billing") || msg.includes("payment") || msg.includes("insufficient")) {
+    return `Billing issue with your ${provider} account. Check your account dashboard.`;
+  }
+  return `${provider} API error: ${msg}`;
+}
+async function callLLM(config, userMessage) {
+  if (config.provider === "anthropic") {
+    const client = new Anthropic2({ apiKey: config.api_key });
+    try {
+      const response = await client.messages.create({
+        model: config.model,
+        max_tokens: 8192,
+        system: SYSTEM_PROMPT,
+        messages: [{ role: "user", content: userMessage }]
+      });
+      const textBlock = response.content.find((block) => block.type === "text");
+      if (!textBlock || textBlock.type !== "text") {
+        throw new Error("No text response from compiler LLM");
+      }
+      return textBlock.text;
+    } catch (err) {
+      throw new Error(classifyError(err, "Anthropic"));
+    }
+  } else if (config.provider === "openai" || config.provider === "google") {
+    const providerName = config.provider === "google" ? "Google" : "OpenAI";
+    const clientOptions = { apiKey: config.api_key };
+    if (config.provider === "google") {
+      clientOptions.baseURL = "https://generativelanguage.googleapis.com/v1beta/openai/";
+    }
+    const client = new OpenAI2(clientOptions);
+    try {
+      const response = await client.chat.completions.create({
+        model: config.model,
+        max_tokens: 8192,
+        messages: [
+          { role: "system", content: SYSTEM_PROMPT },
+          { role: "user", content: userMessage }
+        ]
+      });
+      const text = response.choices[0]?.message?.content;
+      if (!text) {
+        throw new Error("No text response from compiler LLM");
+      }
+      return text;
+    } catch (err) {
+      throw new Error(classifyError(err, providerName));
+    }
+  }
+  throw new Error(`Unsupported provider: ${config.provider}. Run \`kairn init\` to reconfigure.`);
+}
+async function compile(intent, onProgress) {
+  const config = await loadConfig();
+  if (!config) {
+    throw new Error("No config found. Run `kairn init` first.");
+  }
+  onProgress?.("Loading tool registry...");
+  const registry = await loadRegistry();
+  onProgress?.(`Compiling with ${config.provider} (${config.model})...`);
+  const userMessage = buildUserMessage(intent, registry);
+  const responseText = await callLLM(config, userMessage);
+  onProgress?.("Parsing environment spec...");
+  const parsed = parseSpecResponse(responseText);
+  const spec = {
+    id: `env_${crypto.randomUUID()}`,
+    intent,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...parsed
+  };
+  await ensureDirs();
+  const envPath = path2.join(getEnvsDir(), `${spec.id}.json`);
+  await fs2.writeFile(envPath, JSON.stringify(spec, null, 2), "utf-8");
+  return spec;
+}
+
+// src/adapter/claude-code.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+async function writeFile(filePath, content) {
+  await fs3.mkdir(path3.dirname(filePath), { recursive: true });
+  await fs3.writeFile(filePath, content, "utf-8");
+}
+async function writeEnvironment(spec, targetDir) {
+  const claudeDir = path3.join(targetDir, ".claude");
+  const written = [];
+  if (spec.harness.claude_md) {
+    const p = path3.join(claudeDir, "CLAUDE.md");
+    await writeFile(p, spec.harness.claude_md);
+    written.push(".claude/CLAUDE.md");
+  }
+  if (spec.harness.settings && Object.keys(spec.harness.settings).length > 0) {
+    const p = path3.join(claudeDir, "settings.json");
+    await writeFile(p, JSON.stringify(spec.harness.settings, null, 2));
+    written.push(".claude/settings.json");
+  }
+  if (spec.harness.mcp_config && Object.keys(spec.harness.mcp_config).length > 0) {
+    const p = path3.join(targetDir, ".mcp.json");
+    const mcpContent = { mcpServers: spec.harness.mcp_config };
+    await writeFile(p, JSON.stringify(mcpContent, null, 2));
+    written.push(".mcp.json");
+  }
+  if (spec.harness.commands) {
+    for (const [name, content] of Object.entries(spec.harness.commands)) {
+      const p = path3.join(claudeDir, "commands", `${name}.md`);
+      await writeFile(p, content);
+      written.push(`.claude/commands/${name}.md`);
+    }
+  }
+  if (spec.harness.rules) {
+    for (const [name, content] of Object.entries(spec.harness.rules)) {
+      const p = path3.join(claudeDir, "rules", `${name}.md`);
+      await writeFile(p, content);
+      written.push(`.claude/rules/${name}.md`);
+    }
+  }
+  if (spec.harness.skills) {
+    for (const [skillPath, content] of Object.entries(spec.harness.skills)) {
+      const p = path3.join(claudeDir, "skills", `${skillPath}.md`);
+      await writeFile(p, content);
+      written.push(`.claude/skills/${skillPath}.md`);
+    }
+  }
+  if (spec.harness.agents) {
+    for (const [name, content] of Object.entries(spec.harness.agents)) {
+      const p = path3.join(claudeDir, "agents", `${name}.md`);
+      await writeFile(p, content);
+      written.push(`.claude/agents/${name}.md`);
+    }
+  }
+  if (spec.harness.docs) {
+    for (const [name, content] of Object.entries(spec.harness.docs)) {
+      const p = path3.join(claudeDir, "docs", `${name}.md`);
+      await writeFile(p, content);
+      written.push(`.claude/docs/${name}.md`);
+    }
+  }
+  return written;
+}
+function summarizeSpec(spec, registry) {
+  const pluginCommands = [];
+  for (const selected of spec.tools) {
+    const tool = registry.find((t) => t.id === selected.tool_id);
+    if (tool?.install.plugin_command) {
+      pluginCommands.push(tool.install.plugin_command);
+    }
+  }
+  return {
+    toolCount: spec.tools.length,
+    commandCount: Object.keys(spec.harness.commands || {}).length,
+    ruleCount: Object.keys(spec.harness.rules || {}).length,
+    skillCount: Object.keys(spec.harness.skills || {}).length,
+    agentCount: Object.keys(spec.harness.agents || {}).length,
+    pluginCommands
+  };
+}
+
+// src/commands/describe.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+async function loadRegistry2() {
+  const __filename = fileURLToPath2(import.meta.url);
+  const __dirname = path4.dirname(__filename);
+  const candidates = [
+    path4.resolve(__dirname, "../registry/tools.json"),
+    path4.resolve(__dirname, "../src/registry/tools.json"),
+    path4.resolve(__dirname, "../../src/registry/tools.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      const data = await fs4.readFile(candidate, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("Could not find tools.json registry");
+}
+var describeCommand = new Command2("describe").description("Describe your workflow and generate a Claude Code environment").argument("[intent]", "What you want your agent to do").option("-y, --yes", "Skip confirmation prompt").action(async (intentArg, options) => {
+  const config = await loadConfig();
+  if (!config) {
+    console.log(
+      chalk2.red("\n  No config found. Run ") + chalk2.bold("kairn init") + chalk2.red(" first.\n")
+    );
+    process.exit(1);
+  }
+  const intent = intentArg || await input({
+    message: "What do you want your agent to do?"
+  });
+  if (!intent.trim()) {
+    console.log(chalk2.red("\n  No description provided. Aborting.\n"));
+    process.exit(1);
+  }
+  console.log("");
+  let spec;
+  try {
+    spec = await compile(intent, (msg) => {
+      process.stdout.write(`\r  ${chalk2.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(chalk2.red(`
+  Compilation failed: ${msg}
+`));
+    process.exit(1);
+  }
+  const registry = await loadRegistry2();
+  const summary = summarizeSpec(spec, registry);
+  console.log(chalk2.green("\n  \u2713 Environment compiled\n"));
+  console.log(chalk2.cyan("  Name: ") + spec.name);
+  console.log(chalk2.cyan("  Description: ") + spec.description);
+  console.log(chalk2.cyan("  Tools: ") + summary.toolCount);
+  console.log(chalk2.cyan("  Commands: ") + summary.commandCount);
+  console.log(chalk2.cyan("  Rules: ") + summary.ruleCount);
+  console.log(chalk2.cyan("  Skills: ") + summary.skillCount);
+  console.log(chalk2.cyan("  Agents: ") + summary.agentCount);
+  if (spec.tools.length > 0) {
+    console.log(chalk2.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(chalk2.dim(`    - ${name}: ${tool.reason}`));
+    }
+  }
+  if (summary.pluginCommands.length > 0) {
+    console.log(chalk2.yellow("\n  Plugins to install manually:"));
+    for (const cmd of summary.pluginCommands) {
+      console.log(chalk2.yellow(`    ${cmd}`));
+    }
+  }
+  console.log("");
+  const proceed = options.yes || await confirm({
+    message: "Generate environment in current directory?",
+    default: true
+  });
+  if (!proceed) {
+    console.log(chalk2.dim("\n  Aborted. Environment saved to ~/.kairn/envs/\n"));
+    return;
+  }
+  const targetDir = process.cwd();
+  const written = await writeEnvironment(spec, targetDir);
+  console.log(chalk2.green("\n  \u2713 Environment written\n"));
+  for (const file of written) {
+    console.log(chalk2.dim(`    ${file}`));
+  }
+  if (summary.pluginCommands.length > 0) {
+    console.log(chalk2.yellow("\n  Install plugins by running these in Claude Code:"));
+    for (const cmd of summary.pluginCommands) {
+      console.log(chalk2.bold(`    ${cmd}`));
+    }
+  }
+  console.log(
+    chalk2.cyan("\n  Ready! Run ") + chalk2.bold("claude") + chalk2.cyan(" to start.\n")
+  );
+});
+
+// src/commands/list.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import fs5 from "fs/promises";
+import path5 from "path";
+var listCommand = new Command3("list").description("Show saved environments").action(async () => {
+  const envsDir = getEnvsDir();
+  let files;
+  try {
+    files = await fs5.readdir(envsDir);
+  } catch {
+    console.log(chalk3.dim("\n  No environments yet. Run ") + chalk3.bold("kairn describe") + chalk3.dim(" to create one.\n"));
+    return;
+  }
+  const jsonFiles = files.filter((f) => f.endsWith(".json"));
+  if (jsonFiles.length === 0) {
+    console.log(chalk3.dim("\n  No environments yet. Run ") + chalk3.bold("kairn describe") + chalk3.dim(" to create one.\n"));
+    return;
+  }
+  console.log(chalk3.cyan("\n  Saved Environments\n"));
+  for (const file of jsonFiles) {
+    try {
+      const data = await fs5.readFile(path5.join(envsDir, file), "utf-8");
+      const spec = JSON.parse(data);
+      const date = new Date(spec.created_at).toLocaleDateString();
+      const toolCount = spec.tools?.length ?? 0;
+      console.log(chalk3.bold(`  ${spec.name}`));
+      console.log(chalk3.dim(`    ${spec.description}`));
+      console.log(
+        chalk3.dim(`    ${date} \xB7 ${toolCount} tools \xB7 ${spec.id}`)
+      );
+      console.log("");
+    } catch {
+    }
+  }
+});
+
+// src/commands/activate.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+import fs6 from "fs/promises";
+import path6 from "path";
+var activateCommand = new Command4("activate").description("Re-deploy a saved environment to the current directory").argument("<env_id>", "Environment ID (from kairn list)").action(async (envId) => {
+  const envsDir = getEnvsDir();
+  let files;
+  try {
+    files = await fs6.readdir(envsDir);
+  } catch {
+    console.log(chalk4.red("\n  No saved environments found.\n"));
+    process.exit(1);
+  }
+  const match = files.find(
+    (f) => f === `${envId}.json` || f.startsWith(envId)
+  );
+  if (!match) {
+    console.log(chalk4.red(`
+  Environment "${envId}" not found.`));
+    console.log(chalk4.dim("  Run kairn list to see saved environments.\n"));
+    process.exit(1);
+  }
+  const data = await fs6.readFile(path6.join(envsDir, match), "utf-8");
+  const spec = JSON.parse(data);
+  console.log(chalk4.cyan(`
+  Activating: ${spec.name}`));
+  console.log(chalk4.dim(`  ${spec.description}
+`));
+  const targetDir = process.cwd();
+  const written = await writeEnvironment(spec, targetDir);
+  console.log(chalk4.green("  \u2713 Environment written\n"));
+  for (const file of written) {
+    console.log(chalk4.dim(`    ${file}`));
+  }
+  console.log(
+    chalk4.cyan("\n  Ready! Run ") + chalk4.bold("claude") + chalk4.cyan(" to start.\n")
+  );
+});
+
+// src/commands/update-registry.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+import fs7 from "fs/promises";
+import path7 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var REGISTRY_URL = "https://raw.githubusercontent.com/ashtonperlroth/kairn/main/src/registry/tools.json";
+async function getLocalRegistryPath() {
+  const __filename = fileURLToPath3(import.meta.url);
+  const __dirname = path7.dirname(__filename);
+  const candidates = [
+    path7.resolve(__dirname, "../registry/tools.json"),
+    path7.resolve(__dirname, "../src/registry/tools.json"),
+    path7.resolve(__dirname, "../../src/registry/tools.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      await fs7.access(candidate);
+      return candidate;
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("Could not find local tools.json registry");
+}
+var updateRegistryCommand = new Command5("update-registry").description("Fetch the latest tool registry from GitHub").option("--url <url>", "Custom registry URL").action(async (options) => {
+  const url = options.url || REGISTRY_URL;
+  console.log(chalk5.dim(`
+  Fetching registry from ${url}...`));
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      console.log(
+        chalk5.red(`  Failed to fetch registry: ${response.status} ${response.statusText}`)
+      );
+      console.log(
+        chalk5.dim("  The remote registry may not be available yet.")
+      );
+      console.log(
+        chalk5.dim("  Your local registry is still active.\n")
+      );
+      return;
+    }
+    const text = await response.text();
+    let tools;
+    try {
+      tools = JSON.parse(text);
+      if (!Array.isArray(tools)) throw new Error("Not an array");
+      if (tools.length === 0) throw new Error("Empty registry");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(chalk5.red(`  Invalid registry format: ${msg}
+`));
+      return;
+    }
+    const registryPath = await getLocalRegistryPath();
+    const backupPath = registryPath + ".bak";
+    try {
+      await fs7.copyFile(registryPath, backupPath);
+    } catch {
+    }
+    await fs7.writeFile(registryPath, JSON.stringify(tools, null, 2), "utf-8");
+    console.log(chalk5.green(`  \u2713 Registry updated: ${tools.length} tools`));
+    console.log(chalk5.dim(`  Saved to: ${registryPath}`));
+    console.log(chalk5.dim(`  Backup: ${backupPath}
+`));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.log(chalk5.red(`  Network error: ${msg}`));
+    console.log(chalk5.dim("  Your local registry is still active.\n"));
+  }
+});
+
+// src/cli.ts
+var program = new Command6();
+program.name("kairn").description(
+  "Compile natural language intent into optimized Claude Code environments"
+).version("0.1.0");
+program.addCommand(initCommand);
+program.addCommand(describeCommand);
+program.addCommand(listCommand);
+program.addCommand(activateCommand);
+program.addCommand(updateRegistryCommand);
+program.parse();
+//# sourceMappingURL=cli.js.map