archondev 1.1.0 → 1.2.0

package/dist/bug-DXLBBW3U.js

@@ -2,8 +2,8 @@ import {
   bugReport
 } from "./chunk-JBKFAD4M.js";
 import "./chunk-MOZHC2GX.js";
-import "./chunk-WCCBJSNI.js";
 import "./chunk-A7QU6JC6.js";
+import "./chunk-WCCBJSNI.js";
 import "./chunk-QGM4M3NI.js";
 export {
   bugReport

package/dist/{chunk-4NZPAEKS.js → chunk-EDP55FCI.js}

@@ -6,19 +6,22 @@ import {
   createAtom,
   validateAtom
 } from "./chunk-MOZHC2GX.js";
-import {
-  isAuthenticated
-} from "./chunk-WCCBJSNI.js";
 import {
   AnthropicClient,
   getDefaultModel
 } from "./chunk-A7QU6JC6.js";
+import {
+  KeyManager
+} from "./chunk-SMR7JQK6.js";
+import {
+  isAuthenticated
+} from "./chunk-WCCBJSNI.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 { existsSync } from "fs";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
 import { createInterface } from "readline";
 
 // src/agents/sentinel.ts
@@ -277,400 +280,6 @@ var AdversarialPlanner = class {
   }
 };
 
-// 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() {
@@ -692,8 +301,8 @@ async function plan(description, options) {
       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)) {
+    const archPath = join(process.cwd(), "ARCHITECTURE.md");
+    if (!existsSync(archPath)) {
       console.error(chalk.red('ARCHITECTURE.md not found. Run "archon init" first.'));
       process.exit(1);
     }
@@ -724,8 +333,8 @@ Atom created: ${atom.externalId}`));
     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");
+      const keyManager = new KeyManager();
+      const storedKey = await keyManager.getKey("anthropic");
       if (storedKey) {
         apiKey = storedKey;
       }
@@ -835,24 +444,24 @@ function displayPlan(plan2) {
   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 atomsDir = join(process.cwd(), ATOMS_DIR);
+  if (!existsSync(atomsDir)) {
+    await mkdir(atomsDir, { recursive: true });
   }
-  const atomFile = join2(atomsDir, `${atom.externalId}.json`);
-  await writeFile2(atomFile, JSON.stringify(atom, null, 2));
+  const atomFile = join(atomsDir, `${atom.externalId}.json`);
+  await writeFile(atomFile, JSON.stringify(atom, null, 2));
 }
 async function loadAtom(atomId) {
-  const atomFile = join2(process.cwd(), ATOMS_DIR, `${atomId}.json`);
-  if (!existsSync2(atomFile)) {
+  const atomFile = join(process.cwd(), ATOMS_DIR, `${atomId}.json`);
+  if (!existsSync(atomFile)) {
     return null;
   }
-  const content = await readFile2(atomFile, "utf-8");
+  const content = await readFile(atomFile, "utf-8");
   return JSON.parse(content);
 }
 async function listLocalAtoms() {
-  const atomsDir = join2(process.cwd(), ATOMS_DIR);
-  if (!existsSync2(atomsDir)) {
+  const atomsDir = join(process.cwd(), ATOMS_DIR);
+  if (!existsSync(atomsDir)) {
     return [];
   }
   const { readdir } = await import("fs/promises");
@@ -870,8 +479,6 @@ async function listLocalAtoms() {
 }
 
 export {
-  keyManager,
-  KeyValidator,
   plan,
   loadAtom,
   listLocalAtoms

package/dist/{chunk-QPYDPMUV.js → chunk-I4ZVNLNO.js}

@@ -1,6 +1,6 @@
 import {
   loadAtom
-} from "./chunk-4NZPAEKS.js";
+} from "./chunk-EDP55FCI.js";
 import {
   ArchitectureParser
 } from "./chunk-2CFO5GVH.js";

package/dist/chunk-IMZN36GC.js

@@ -0,0 +1,159 @@
+import {
+  KeyValidator,
+  keyManager
+} from "./chunk-SMR7JQK6.js";
+import {
+  loadConfig,
+  saveConfig
+} from "./chunk-WCCBJSNI.js";
+
+// src/cli/keys.ts
+import chalk from "chalk";
+import ora from "ora";
+import { createInterface } from "readline";
+var VALID_PROVIDERS = ["anthropic", "openai", "google"];
+function isValidProvider(provider) {
+  return VALID_PROVIDERS.includes(provider);
+}
+async function promptForKey(provider) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    const providerName = provider.charAt(0).toUpperCase() + provider.slice(1);
+    rl.question(`Enter your ${providerName} API key: `, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function addKey(provider, options = {}) {
+  if (!isValidProvider(provider)) {
+    console.error(chalk.red(`Invalid provider: ${provider}`));
+    console.log(chalk.dim(`Valid providers: ${VALID_PROVIDERS.join(", ")}`));
+    process.exit(1);
+  }
+  const label = options.label ?? "default";
+  const apiKey = await promptForKey(provider);
+  if (!apiKey) {
+    console.error(chalk.red("API key cannot be empty"));
+    process.exit(1);
+  }
+  const spinner = ora("Validating API key...").start();
+  const validator = new KeyValidator();
+  const validationResult = await validator.validateKey(provider, apiKey);
+  if (!validationResult.valid) {
+    spinner.fail(chalk.red(`API key validation failed: ${validationResult.error}`));
+    process.exit(1);
+  }
+  spinner.text = "Encrypting and storing API key...";
+  const result = await keyManager.addKey(provider, apiKey, label);
+  if (!result.success) {
+    spinner.fail(chalk.red(`Failed to store key: ${result.error}`));
+    process.exit(1);
+  }
+  const config = await loadConfig();
+  if (config.tier === "FREE") {
+    await saveConfig({ ...config, tier: "BYOK" });
+    spinner.succeed(chalk.green(`API key for ${provider} (${label}) added successfully!`));
+    console.log(chalk.blue("Your tier has been upgraded to BYOK (Bring Your Own Key)"));
+    console.log(chalk.dim("You now have access to all models and unlimited atoms."));
+  } else {
+    spinner.succeed(chalk.green(`API key for ${provider} (${label}) added successfully!`));
+  }
+  const adversarialStatus = await keyManager.getAdversarialStatus();
+  if (adversarialStatus.enabled) {
+    console.log(chalk.green(`\u2713 ${adversarialStatus.message}`));
+  } else {
+    console.log(chalk.yellow(`\u25CB ${adversarialStatus.message}`));
+  }
+}
+async function listKeys() {
+  const spinner = ora("Loading configured keys...").start();
+  const keys = await keyManager.listKeys();
+  spinner.stop();
+  if (keys.length === 0) {
+    console.log(chalk.yellow("No API keys configured"));
+    console.log(chalk.dim("Run `archon keys add <provider>` to add a key"));
+    console.log(chalk.dim(`Available providers: ${VALID_PROVIDERS.join(", ")}`));
+    return;
+  }
+  console.log(chalk.green("Configured API keys:"));
+  console.log();
+  const byProvider = {};
+  for (const key of keys) {
+    if (!byProvider[key.provider]) {
+      byProvider[key.provider] = [];
+    }
+    byProvider[key.provider]?.push(key);
+  }
+  for (const [provider, providerKeys] of Object.entries(byProvider)) {
+    console.log(chalk.blue(`  ${provider.toUpperCase()}`));
+    for (const key of providerKeys ?? []) {
+      const addedDate = new Date(key.createdAt).toLocaleDateString();
+      const primaryBadge = key.isPrimary ? chalk.green(" [primary]") : "";
+      console.log(`    \u2022 ${key.label}${primaryBadge} ${chalk.dim(`(added ${addedDate})`)}`);
+    }
+  }
+  console.log();
+  const adversarialStatus = await keyManager.getAdversarialStatus();
+  if (adversarialStatus.enabled) {
+    console.log(chalk.green(`\u2713 ${adversarialStatus.message}`));
+  } else {
+    console.log(chalk.yellow(`\u25CB ${adversarialStatus.message}`));
+  }
+  console.log();
+  console.log(chalk.dim("Note: API keys are stored locally with encryption"));
+}
+async function removeKey(provider, options = {}) {
+  if (!isValidProvider(provider)) {
+    console.error(chalk.red(`Invalid provider: ${provider}`));
+    console.log(chalk.dim(`Valid providers: ${VALID_PROVIDERS.join(", ")}`));
+    process.exit(1);
+  }
+  const label = options.label;
+  const labelMsg = label ? ` (${label})` : "";
+  const spinner = ora(`Removing API key for ${provider}${labelMsg}...`).start();
+  const result = await keyManager.removeKey(provider, label);
+  if (!result.success) {
+    spinner.fail(chalk.red(result.error ?? "Failed to remove key"));
+    process.exit(1);
+  }
+  const hasRemainingKeys = await keyManager.hasAnyKey();
+  if (!hasRemainingKeys) {
+    const config = await loadConfig();
+    if (config.tier === "BYOK") {
+      await saveConfig({ ...config, tier: "FREE" });
+      spinner.succeed(chalk.green(`API key for ${provider}${labelMsg} removed`));
+      console.log(chalk.yellow("No API keys remaining. Tier reverted to FREE."));
+      return;
+    }
+  }
+  spinner.succeed(chalk.green(`API key for ${provider}${labelMsg} removed`));
+  const adversarialStatus = await keyManager.getAdversarialStatus();
+  if (!adversarialStatus.enabled && adversarialStatus.providerCount > 0) {
+    console.log(chalk.yellow(`\u25CB ${adversarialStatus.message}`));
+  }
+}
+async function setPrimaryKey(provider, label) {
+  if (!isValidProvider(provider)) {
+    console.error(chalk.red(`Invalid provider: ${provider}`));
+    console.log(chalk.dim(`Valid providers: ${VALID_PROVIDERS.join(", ")}`));
+    process.exit(1);
+  }
+  const spinner = ora(`Setting primary key for ${provider} to "${label}"...`).start();
+  const result = await keyManager.setPrimary(provider, label);
+  if (!result.success) {
+    spinner.fail(chalk.red(result.error ?? "Failed to set primary key"));
+    process.exit(1);
+  }
+  spinner.succeed(chalk.green(`Primary key for ${provider} set to "${label}"`));
+}
+
+export {
+  addKey,
+  listKeys,
+  removeKey,
+  setPrimaryKey
+};

package/dist/{chunk-BL5TX2UW.js → chunk-PK3OQVBG.js}

@@ -1,6 +1,6 @@
 import {
   listLocalAtoms
-} from "./chunk-4NZPAEKS.js";
+} from "./chunk-EDP55FCI.js";
 
 // src/cli/list.ts
 import chalk from "chalk";