archondev 0.1.0 → 1.1.0

package/dist/chunk-4NZPAEKS.js

@@ -0,0 +1,878 @@
+import {
+  ArchitectureParser
+} from "./chunk-2CFO5GVH.js";
+import {
+  ArchitectAgent,
+  createAtom,
+  validateAtom
+} from "./chunk-MOZHC2GX.js";
+import {
+  isAuthenticated
+} from "./chunk-WCCBJSNI.js";
+import {
+  AnthropicClient,
+  getDefaultModel
+} from "./chunk-A7QU6JC6.js";
+
+// src/cli/plan.ts
+import chalk from "chalk";
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join2 } from "path";
+import { createInterface } from "readline";
+
+// src/agents/sentinel.ts
+var SYSTEM_PROMPT = `You are the Sentinel, a paranoid and skeptical code reviewer responsible for finding issues in implementation plans.
+
+Your role:
+- Critique the Architect's plan with extreme skepticism
+- Identify security vulnerabilities, edge cases, and breaking changes
+- Ensure the plan respects architecture boundaries and invariants
+- Flag any missing steps or incomplete considerations
+- Challenge assumptions and identify risks
+
+You are NOT trying to approve plans. You are trying to find problems.
+
+Output your validation in the following JSON format:
+{
+  "passed": boolean,
+  "issues": [
+    {
+      "severity": "BLOCKER" | "WARNING" | "INFO",
+      "type": "SECURITY" | "ARCHITECTURE" | "PERFORMANCE" | "EDGE_CASE" | "BREAKING_CHANGE" | "MISSING_STEP",
+      "message": "Description of the issue",
+      "suggestion": "How to fix it (optional)"
+    }
+  ],
+  "suggestions": ["General improvement suggestion 1", ...]
+}
+
+Guidelines:
+- BLOCKER issues must be resolved before implementation
+- WARNING issues should be addressed but won't block
+- INFO issues are nice-to-have improvements
+- Be specific and actionable in your feedback
+- Don't approve plans that violate architecture constraints
+- Consider edge cases, error handling, and rollback scenarios`;
+var SentinelAgent = class {
+  client;
+  config;
+  constructor(config, apiKey) {
+    this.config = {
+      provider: "anthropic",
+      model: config?.model ?? getDefaultModel("sentinel"),
+      maxTokens: config?.maxTokens ?? 4096,
+      temperature: config?.temperature ?? 0.3
+      // Lower temperature for more consistent critiques
+    };
+    this.client = new AnthropicClient(this.config, apiKey);
+  }
+  /**
+   * Validate an implementation plan
+   */
+  async validatePlan(atom, plan2, architecture) {
+    const userMessage = this.buildPrompt(atom, plan2, architecture);
+    const response = await this.client.chat(SYSTEM_PROMPT, userMessage, {
+      temperature: 0.3,
+      maxTokens: 4096
+    });
+    return this.parseValidationResponse(response.content, response.usage);
+  }
+  /**
+   * Build the validation prompt
+   */
+  buildPrompt(atom, plan2, architecture) {
+    const parts = [];
+    parts.push("# Atom Being Implemented");
+    parts.push(`**Title:** ${atom.title}`);
+    parts.push(`**Description:** ${atom.description ?? "No description"}`);
+    parts.push("");
+    parts.push("**Acceptance Criteria:**");
+    atom.acceptanceCriteria.forEach((ac, i) => parts.push(`${i + 1}. ${ac}`));
+    parts.push("");
+    parts.push("# Implementation Plan to Validate");
+    parts.push("");
+    parts.push("**Steps:**");
+    plan2.steps.forEach((step, i) => parts.push(`${i + 1}. ${step}`));
+    parts.push("");
+    parts.push("**Files to Modify:**");
+    plan2.files_to_modify.forEach((f) => parts.push(`- ${f}`));
+    parts.push("");
+    parts.push("**Dependencies:**");
+    plan2.dependencies.forEach((d) => parts.push(`- ${d}`));
+    parts.push("");
+    parts.push("**Identified Risks:**");
+    plan2.risks.forEach((r) => parts.push(`- ${r}`));
+    parts.push("");
+    parts.push(`**Estimated Complexity:** ${plan2.estimated_complexity}`);
+    parts.push("");
+    parts.push("# Architecture Constraints");
+    parts.push("");
+    if (architecture.invariants.length > 0) {
+      parts.push("**Invariants (MUST NOT violate):**");
+      architecture.invariants.forEach((inv) => {
+        parts.push(`- [${inv.severity}] ${inv.rule}${inv.scope ? ` (scope: ${inv.scope})` : ""}`);
+      });
+      parts.push("");
+    }
+    if (architecture.protectedPaths.length > 0) {
+      parts.push("**Protected Paths:**");
+      architecture.protectedPaths.forEach((p) => {
+        parts.push(`- ${p.pattern} (${p.level}): ${p.reason}`);
+      });
+      parts.push("");
+    }
+    if (architecture.components.length > 0) {
+      parts.push("**Components & Boundaries:**");
+      architecture.components.forEach((c) => {
+        parts.push(`- ${c.name}: ${c.boundary} (${c.stability})`);
+        if (c.forbiddenImports) {
+          c.forbiddenImports.forEach((fi) => {
+            parts.push(`  - Cannot import: ${fi.pattern}`);
+          });
+        }
+      });
+      parts.push("");
+    }
+    parts.push("# Your Task");
+    parts.push("");
+    parts.push("Critically analyze this plan. Find every possible issue.");
+    parts.push("Consider: security, edge cases, error handling, rollback, performance.");
+    parts.push("Check that all acceptance criteria can be met by this plan.");
+    parts.push("Verify no architecture constraints are violated.");
+    parts.push("");
+    parts.push("Output your validation as valid JSON.");
+    return parts.join("\n");
+  }
+  /**
+   * Parse validation response from AI
+   */
+  parseValidationResponse(content, usage) {
+    const jsonMatch = content.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      throw new Error("Failed to parse validation: no JSON found in response");
+    }
+    try {
+      const parsed = JSON.parse(jsonMatch[0]);
+      const issues = (parsed.issues ?? []).filter((i) => i.message).map((i) => ({
+        severity: this.normalizeSeverity(i.severity),
+        type: this.normalizeType(i.type),
+        message: i.message ?? "",
+        suggestion: i.suggestion
+      }));
+      const hasBlockers = issues.some((i) => i.severity === "BLOCKER");
+      return {
+        passed: hasBlockers ? false : parsed.passed ?? true,
+        issues,
+        suggestions: parsed.suggestions ?? [],
+        usage
+      };
+    } catch (error) {
+      throw new Error(`Failed to parse validation JSON: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  normalizeSeverity(value) {
+    const normalized = value?.toUpperCase();
+    if (normalized === "BLOCKER" || normalized === "WARNING" || normalized === "INFO") {
+      return normalized;
+    }
+    return "WARNING";
+  }
+  normalizeType(value) {
+    const normalized = value?.toUpperCase();
+    if (normalized === "SECURITY" || normalized === "ARCHITECTURE" || normalized === "PERFORMANCE" || normalized === "EDGE_CASE" || normalized === "BREAKING_CHANGE" || normalized === "MISSING_STEP") {
+      return normalized;
+    }
+    return "EDGE_CASE";
+  }
+};
+
+// src/agents/planner.ts
+var DEFAULT_MAX_CYCLES = 3;
+var AdversarialPlanner = class {
+  architect;
+  sentinel;
+  maxCycles;
+  constructor(config) {
+    this.architect = new ArchitectAgent(config?.architectConfig, config?.apiKey);
+    this.sentinel = new SentinelAgent(config?.sentinelConfig, config?.apiKey);
+    this.maxCycles = config?.maxCycles ?? DEFAULT_MAX_CYCLES;
+  }
+  /**
+   * Plan an atom through the adversarial loop
+   */
+  async planAtom(atom, architecture, context) {
+    const iterations = [];
+    const totalUsage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      baseCost: 0,
+      markedUpCost: 0
+    };
+    let currentPlan = null;
+    let approved = false;
+    for (let cycle = 1; cycle <= this.maxCycles; cycle++) {
+      const architectContext = {
+        ...context
+      };
+      if (iterations.length > 0) {
+        const lastIteration2 = iterations[iterations.length - 1];
+        if (lastIteration2) {
+          architectContext.recentLearnings = [
+            ...context?.recentLearnings ?? [],
+            `Previous plan issues (cycle ${cycle - 1}):`,
+            ...lastIteration2.validation.issues.map(
+              (i) => `- [${i.severity}] ${i.message}${i.suggestion ? ` (suggestion: ${i.suggestion})` : ""}`
+            ),
+            ...lastIteration2.validation.suggestions.map((s) => `- Suggestion: ${s}`)
+          ];
+        }
+      }
+      const generatedPlan = await this.architect.generatePlan(atom, architecture, architectContext);
+      currentPlan = generatedPlan.plan;
+      this.accumulateUsage(totalUsage, generatedPlan.usage);
+      const validation = await this.sentinel.validatePlan(atom, currentPlan, architecture);
+      this.accumulateUsage(totalUsage, validation.usage);
+      iterations.push({
+        cycle,
+        plan: currentPlan,
+        reasoning: generatedPlan.reasoning,
+        validation,
+        usage: {
+          inputTokens: generatedPlan.usage.inputTokens + validation.usage.inputTokens,
+          outputTokens: generatedPlan.usage.outputTokens + validation.usage.outputTokens,
+          totalTokens: generatedPlan.usage.totalTokens + validation.usage.totalTokens,
+          baseCost: generatedPlan.usage.baseCost + validation.usage.baseCost,
+          markedUpCost: generatedPlan.usage.markedUpCost + validation.usage.markedUpCost
+        }
+      });
+      if (validation.passed) {
+        approved = true;
+        break;
+      }
+      const hasBlockers = validation.issues.some((i) => i.severity === "BLOCKER");
+      if (!hasBlockers) {
+        approved = true;
+        break;
+      }
+    }
+    const lastIteration = iterations[iterations.length - 1];
+    const blockers = lastIteration?.validation.issues.filter((i) => i.severity === "BLOCKER") ?? [];
+    return {
+      approved,
+      finalPlan: approved ? currentPlan : null,
+      iterations,
+      totalUsage,
+      blockers,
+      escalationReason: approved ? void 0 : `Failed to resolve ${blockers.length} blocking issues after ${this.maxCycles} cycles`
+    };
+  }
+  accumulateUsage(total, addition) {
+    total.inputTokens += addition.inputTokens;
+    total.outputTokens += addition.outputTokens;
+    total.totalTokens += addition.totalTokens;
+    total.baseCost += addition.baseCost;
+    total.markedUpCost += addition.markedUpCost;
+  }
+};
+
+// src/core/keys/manager.ts
+import { homedir as homedir2 } from "os";
+import { join } from "path";
+import { readFile, writeFile, mkdir, chmod } from "fs/promises";
+import { existsSync } from "fs";
+
+// src/core/keys/encryption.ts
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
+import { homedir, hostname, userInfo } from "os";
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 16;
+var AUTH_TAG_LENGTH = 16;
+var SALT_LENGTH = 32;
+var KEY_LENGTH = 32;
+function getDerivedKey(salt) {
+  const machineId = `${hostname()}-${userInfo().username}-${homedir()}`;
+  return scryptSync(machineId, salt, KEY_LENGTH);
+}
+function encrypt(plaintext) {
+  const salt = randomBytes(SALT_LENGTH);
+  const key = getDerivedKey(salt);
+  const iv = randomBytes(IV_LENGTH);
+  const cipher = createCipheriv(ALGORITHM, key, iv);
+  let encrypted = cipher.update(plaintext, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  const authTag = cipher.getAuthTag();
+  const combined = Buffer.concat([
+    salt,
+    iv,
+    authTag,
+    Buffer.from(encrypted, "hex")
+  ]);
+  return combined.toString("base64");
+}
+function decrypt(encryptedData) {
+  const combined = Buffer.from(encryptedData, "base64");
+  const salt = combined.subarray(0, SALT_LENGTH);
+  const iv = combined.subarray(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
+  const authTag = combined.subarray(
+    SALT_LENGTH + IV_LENGTH,
+    SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH
+  );
+  const encrypted = combined.subarray(SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH);
+  const key = getDerivedKey(salt);
+  const decipher = createDecipheriv(ALGORITHM, key, iv);
+  decipher.setAuthTag(authTag);
+  let decrypted = decipher.update(encrypted.toString("hex"), "hex", "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+
+// src/core/keys/manager.ts
+var CONFIG_DIR = join(homedir2(), ".archon");
+var KEYS_FILE = join(CONFIG_DIR, "keys.json");
+var CURRENT_VERSION = 2;
+var KeyManager = class {
+  async ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+      await mkdir(CONFIG_DIR, { recursive: true, mode: 448 });
+    }
+  }
+  async loadKeys() {
+    try {
+      if (!existsSync(KEYS_FILE)) {
+        return { keys: [], version: CURRENT_VERSION };
+      }
+      const content = await readFile(KEYS_FILE, "utf-8");
+      const data = JSON.parse(content);
+      if (data.version === 1 && !Array.isArray(data.keys)) {
+        const oldKeys = data.keys;
+        const newKeys = Object.values(oldKeys).map((k) => ({
+          ...k,
+          label: k.label ?? "default",
+          isPrimary: k.isPrimary ?? true
+        }));
+        const migrated = { keys: newKeys, version: CURRENT_VERSION };
+        await this.saveKeys(migrated);
+        return migrated;
+      }
+      return data;
+    } catch {
+      return { keys: [], version: CURRENT_VERSION };
+    }
+  }
+  async saveKeys(stored) {
+    await this.ensureConfigDir();
+    const content = JSON.stringify(stored, null, 2);
+    await writeFile(KEYS_FILE, content, { mode: 384 });
+    await chmod(KEYS_FILE, 384);
+  }
+  async addKey(provider, apiKey, label = "default") {
+    try {
+      const stored = await this.loadKeys();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const existingIndex = stored.keys.findIndex((k) => k.provider === provider && k.label === label);
+      const providerKeys = stored.keys.filter((k) => k.provider === provider);
+      const isPrimary = providerKeys.length === 0 || existingIndex >= 0 && stored.keys[existingIndex]?.isPrimary === true;
+      const newKey = {
+        provider,
+        encryptedKey: encrypt(apiKey),
+        label,
+        isPrimary,
+        createdAt: now,
+        updatedAt: now
+      };
+      if (existingIndex >= 0) {
+        const existing = stored.keys[existingIndex];
+        if (existing) {
+          newKey.createdAt = existing.createdAt;
+          newKey.isPrimary = existing.isPrimary;
+        }
+        stored.keys[existingIndex] = newKey;
+      } else {
+        stored.keys.push(newKey);
+      }
+      await this.saveKeys(stored);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to save key: ${error instanceof Error ? error.message : "Unknown error"}`
+      };
+    }
+  }
+  async getKey(provider, label) {
+    try {
+      const stored = await this.loadKeys();
+      let keyConfig;
+      if (label) {
+        keyConfig = stored.keys.find((k) => k.provider === provider && k.label === label);
+      } else {
+        keyConfig = stored.keys.find((k) => k.provider === provider && k.isPrimary);
+        if (!keyConfig) {
+          keyConfig = stored.keys.find((k) => k.provider === provider);
+        }
+      }
+      if (!keyConfig) {
+        return null;
+      }
+      return decrypt(keyConfig.encryptedKey);
+    } catch {
+      return null;
+    }
+  }
+  async removeKey(provider, label) {
+    try {
+      const stored = await this.loadKeys();
+      let index;
+      if (label) {
+        index = stored.keys.findIndex((k) => k.provider === provider && k.label === label);
+      } else {
+        index = stored.keys.findIndex((k) => k.provider === provider && k.isPrimary);
+        if (index < 0) {
+          index = stored.keys.findIndex((k) => k.provider === provider);
+        }
+      }
+      if (index < 0) {
+        const labelMsg = label ? ` with label "${label}"` : "";
+        return {
+          success: false,
+          error: `No API key found for provider: ${provider}${labelMsg}`
+        };
+      }
+      const removedKey = stored.keys[index];
+      stored.keys.splice(index, 1);
+      if (removedKey?.isPrimary) {
+        const nextKey = stored.keys.find((k) => k.provider === provider);
+        if (nextKey) {
+          nextKey.isPrimary = true;
+        }
+      }
+      await this.saveKeys(stored);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to remove key: ${error instanceof Error ? error.message : "Unknown error"}`
+      };
+    }
+  }
+  async setPrimary(provider, label) {
+    try {
+      const stored = await this.loadKeys();
+      const targetKey = stored.keys.find((k) => k.provider === provider && k.label === label);
+      if (!targetKey) {
+        return {
+          success: false,
+          error: `No key found for ${provider} with label "${label}"`
+        };
+      }
+      for (const key of stored.keys) {
+        if (key.provider === provider) {
+          key.isPrimary = key.label === label;
+        }
+      }
+      await this.saveKeys(stored);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to set primary: ${error instanceof Error ? error.message : "Unknown error"}`
+      };
+    }
+  }
+  async listProviders() {
+    try {
+      const stored = await this.loadKeys();
+      const providers = /* @__PURE__ */ new Set();
+      for (const key of stored.keys) {
+        providers.add(key.provider);
+      }
+      return Array.from(providers);
+    } catch {
+      return [];
+    }
+  }
+  async listKeys(provider) {
+    try {
+      const stored = await this.loadKeys();
+      if (provider) {
+        return stored.keys.filter((k) => k.provider === provider);
+      }
+      return stored.keys;
+    } catch {
+      return [];
+    }
+  }
+  async hasAnyKey() {
+    const stored = await this.loadKeys();
+    return stored.keys.length > 0;
+  }
+  async getKeyConfig(provider, label) {
+    try {
+      const stored = await this.loadKeys();
+      if (label) {
+        return stored.keys.find((k) => k.provider === provider && k.label === label) ?? null;
+      }
+      return stored.keys.find((k) => k.provider === provider && k.isPrimary) ?? stored.keys.find((k) => k.provider === provider) ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async getAdversarialStatus() {
+    const providers = await this.listProviders();
+    const enabled = providers.length >= 2;
+    if (enabled) {
+      return {
+        enabled: true,
+        providerCount: providers.length,
+        providers,
+        message: `Adversarial features enabled (${providers.length} providers: ${providers.join(", ")})`
+      };
+    } else if (providers.length === 1) {
+      return {
+        enabled: false,
+        providerCount: 1,
+        providers,
+        message: `Adversarial features require keys from 2+ providers. Add another provider to unlock.`
+      };
+    } else {
+      return {
+        enabled: false,
+        providerCount: 0,
+        providers: [],
+        message: `No API keys configured. Add keys from 2+ providers to enable adversarial features.`
+      };
+    }
+  }
+};
+var keyManager = new KeyManager();
+
+// src/core/keys/validator.ts
+var KeyValidator = class {
+  async validateKey(provider, apiKey) {
+    switch (provider) {
+      case "anthropic":
+        return this.validateAnthropicKey(apiKey);
+      case "openai":
+        return this.validateOpenAIKey(apiKey);
+      case "google":
+        return this.validateGoogleKey(apiKey);
+      default:
+        return { valid: false, error: `Unknown provider: ${provider}`, provider };
+    }
+  }
+  async validateAnthropicKey(apiKey) {
+    try {
+      const response = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: "claude-3-haiku-20240307",
+          max_tokens: 1,
+          messages: [{ role: "user", content: "Hi" }]
+        })
+      });
+      if (response.status === 401) {
+        return {
+          valid: false,
+          error: "Invalid API key. Please check your Anthropic API key.",
+          provider: "anthropic"
+        };
+      }
+      if (response.status === 400) {
+        const data = await response.json();
+        if (data.error?.message?.includes("credit")) {
+          return {
+            valid: false,
+            error: "API key valid but no credits. Please add credits to your Anthropic account.",
+            provider: "anthropic"
+          };
+        }
+      }
+      if (response.ok || response.status === 429 || response.status === 404) {
+        return { valid: true, provider: "anthropic" };
+      }
+      return {
+        valid: true,
+        provider: "anthropic"
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        error: `Connection error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        provider: "anthropic"
+      };
+    }
+  }
+  async validateOpenAIKey(apiKey) {
+    try {
+      const response = await fetch("https://api.openai.com/v1/models", {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${apiKey}`
+        }
+      });
+      if (response.status === 401) {
+        return {
+          valid: false,
+          error: "Invalid API key. Please check your OpenAI API key.",
+          provider: "openai"
+        };
+      }
+      if (response.ok) {
+        return { valid: true, provider: "openai" };
+      }
+      return {
+        valid: false,
+        error: `Validation failed with status ${response.status}`,
+        provider: "openai"
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        error: `Connection error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        provider: "openai"
+      };
+    }
+  }
+  async validateGoogleKey(apiKey) {
+    try {
+      const response = await fetch(
+        `https://generativelanguage.googleapis.com/v1/models?key=${apiKey}`,
+        { method: "GET" }
+      );
+      if (response.status === 400 || response.status === 401 || response.status === 403) {
+        return {
+          valid: false,
+          error: "Invalid API key. Please check your Google AI API key.",
+          provider: "google"
+        };
+      }
+      if (response.ok) {
+        return { valid: true, provider: "google" };
+      }
+      return {
+        valid: false,
+        error: `Validation failed with status ${response.status}`,
+        provider: "google"
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        error: `Connection error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        provider: "google"
+      };
+    }
+  }
+};
+
+// src/cli/plan.ts
+var ATOMS_DIR = ".archon/atoms";
+function createPrompt() {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return {
+    ask: (question) => new Promise((resolve) => {
+      rl.question(question, resolve);
+    }),
+    close: () => rl.close()
+  };
+}
+async function plan(description, options) {
+  const prompt = createPrompt();
+  try {
+    if (!await isAuthenticated()) {
+      console.log(chalk.yellow('Not authenticated. Run "archon login" first.'));
+      console.log(chalk.dim("For local development, you can continue without authentication."));
+    }
+    const archPath = join2(process.cwd(), "ARCHITECTURE.md");
+    if (!existsSync2(archPath)) {
+      console.error(chalk.red('ARCHITECTURE.md not found. Run "archon init" first.'));
+      process.exit(1);
+    }
+    console.log(chalk.dim("Parsing ARCHITECTURE.md..."));
+    const parser = new ArchitectureParser(archPath);
+    const parseResult = await parser.parse();
+    if (!parseResult.success || !parseResult.schema) {
+      console.error(chalk.red("Failed to parse ARCHITECTURE.md:"));
+      for (const error of parseResult.errors) {
+        console.error(chalk.red(`  - ${error.message}`));
+      }
+      process.exit(1);
+    }
+    console.log(chalk.dim("Creating atom from description..."));
+    const atomInput = parseAtomDescription(description, options);
+    const atom = createAtom(atomInput);
+    const validation = validateAtom(atom);
+    if (!validation.valid) {
+      console.error(chalk.red("Invalid atom:"));
+      for (const error of validation.errors) {
+        console.error(chalk.red(`  - ${error.field}: ${error.message}`));
+      }
+      process.exit(1);
+    }
+    console.log(chalk.blue(`
+Atom created: ${atom.externalId}`));
+    console.log(chalk.dim(`Title: ${atom.title}`));
+    console.log(chalk.dim(`Acceptance Criteria: ${atom.acceptanceCriteria.length} items`));
+    let apiKey = process.env["ANTHROPIC_API_KEY"];
+    if (!apiKey) {
+      const keyManager2 = new KeyManager();
+      const storedKey = await keyManager2.getKey("anthropic");
+      if (storedKey) {
+        apiKey = storedKey;
+      }
+    }
+    if (!apiKey) {
+      console.log(chalk.yellow("\nNo API key configured. Skipping adversarial planning."));
+      console.log(chalk.dim('Set ANTHROPIC_API_KEY or use "archon keys add anthropic"'));
+      await saveAtom(atom);
+      console.log(chalk.green(`
+Atom saved: ${atom.externalId}`));
+      console.log(chalk.dim(`Next: Configure API key and run "archon plan ${atom.externalId} --continue"`));
+      return;
+    }
+    console.log(chalk.blue("\n\u{1F4CB} Starting adversarial planning..."));
+    console.log(chalk.dim("Architect will generate a plan, Sentinel will validate it.\n"));
+    const planner = new AdversarialPlanner({ apiKey });
+    const planResult = await planner.planAtom(atom, parseResult.schema);
+    if (!planResult.approved) {
+      console.log(chalk.red("\n\u274C Plan not approved after maximum iterations."));
+      console.log(chalk.yellow("Issues found:"));
+      for (const iteration of planResult.iterations) {
+        if (!iteration.validation.passed) {
+          for (const issue of iteration.validation.issues) {
+            console.log(chalk.yellow(`  - [${issue.severity}] ${issue.message}`));
+          }
+        }
+      }
+      const answer2 = await prompt.ask("\nSave as draft anyway? (y/N): ");
+      if (answer2.toLowerCase() !== "y") {
+        console.log(chalk.dim("Atom discarded."));
+        return;
+      }
+    }
+    if (planResult.finalPlan) {
+      console.log(chalk.green("\n\u2705 Plan approved!"));
+      displayPlan(planResult.finalPlan);
+    } else {
+      console.log(chalk.yellow("\nNo approved plan available."));
+    }
+    console.log(chalk.dim(`
+Token usage: ${planResult.totalUsage.inputTokens} input, ${planResult.totalUsage.outputTokens} output`));
+    const answer = await prompt.ask("\nApprove this plan? (y/N/e for edit): ");
+    if (answer.toLowerCase() === "e") {
+      console.log(chalk.yellow("Edit mode not yet implemented. Saving as draft."));
+      atom.status = "DRAFT";
+    } else if (answer.toLowerCase() !== "y") {
+      console.log(chalk.dim("Atom discarded."));
+      return;
+    } else {
+      atom.plan = planResult.finalPlan;
+      atom.status = "READY";
+    }
+    await saveAtom(atom);
+    console.log(chalk.green(`
+\u2705 Atom saved: ${atom.externalId}`));
+    console.log(chalk.dim(`Status: ${atom.status}`));
+    console.log(chalk.dim(`
+Next steps:`));
+    console.log(chalk.dim(`  - Execute: archon execute ${atom.externalId}`));
+    console.log(chalk.dim(`  - View: archon show ${atom.externalId}`));
+  } finally {
+    prompt.close();
+  }
+}
+function parseAtomDescription(description, options) {
+  const parts = description.split(" - ");
+  const title = parts[0]?.trim() ?? description;
+  let acceptanceCriteria = [];
+  if (parts.length > 1) {
+    acceptanceCriteria = (parts[1] ?? "").split(",").map((ac) => ac.trim());
+  }
+  if (acceptanceCriteria.length === 0) {
+    acceptanceCriteria = ["Feature implemented as described", "Typecheck passes", "Tests pass"];
+  }
+  const tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : [];
+  return {
+    title,
+    description: description !== title ? description : void 0,
+    acceptanceCriteria,
+    priority: options.priority ?? 10,
+    tags
+  };
+}
+function displayPlan(plan2) {
+  console.log(chalk.bold("\n\u{1F4DD} Implementation Plan"));
+  console.log(chalk.dim("\u2500".repeat(40)));
+  console.log(chalk.bold("\nSteps:"));
+  plan2.steps.forEach((step, i) => {
+    console.log(`  ${i + 1}. ${step}`);
+  });
+  console.log(chalk.bold("\nFiles to modify:"));
+  for (const file of plan2.files_to_modify) {
+    console.log(`  - ${file}`);
+  }
+  if (plan2.dependencies.length > 0) {
+    console.log(chalk.bold("\nDependencies:"));
+    for (const dep of plan2.dependencies) {
+      console.log(`  - ${dep}`);
+    }
+  }
+  if (plan2.risks.length > 0) {
+    console.log(chalk.bold("\nRisks:"));
+    for (const risk of plan2.risks) {
+      console.log(chalk.yellow(`  \u26A0 ${risk}`));
+    }
+  }
+  console.log(chalk.bold("\nComplexity:"), plan2.estimated_complexity);
+}
+async function saveAtom(atom) {
+  const atomsDir = join2(process.cwd(), ATOMS_DIR);
+  if (!existsSync2(atomsDir)) {
+    await mkdir2(atomsDir, { recursive: true });
+  }
+  const atomFile = join2(atomsDir, `${atom.externalId}.json`);
+  await writeFile2(atomFile, JSON.stringify(atom, null, 2));
+}
+async function loadAtom(atomId) {
+  const atomFile = join2(process.cwd(), ATOMS_DIR, `${atomId}.json`);
+  if (!existsSync2(atomFile)) {
+    return null;
+  }
+  const content = await readFile2(atomFile, "utf-8");
+  return JSON.parse(content);
+}
+async function listLocalAtoms() {
+  const atomsDir = join2(process.cwd(), ATOMS_DIR);
+  if (!existsSync2(atomsDir)) {
+    return [];
+  }
+  const { readdir } = await import("fs/promises");
+  const files = await readdir(atomsDir);
+  const atoms = [];
+  for (const file of files) {
+    if (file.endsWith(".json")) {
+      const atom = await loadAtom(file.replace(".json", ""));
+      if (atom) {
+        atoms.push(atom);
+      }
+    }
+  }
+  return atoms;
+}
+
+export {
+  keyManager,
+  KeyValidator,
+  plan,
+  loadAtom,
+  listLocalAtoms
+};