archondev 0.1.0 → 1.1.0

package/dist/chunk-A7QU6JC6.js

@@ -0,0 +1,119 @@
+// src/utils/index.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function generateId(prefix) {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  const id = `${timestamp}-${random}`;
+  return prefix ? `${prefix}-${id}` : id;
+}
+
+// src/agents/clients/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+var MAX_RETRIES = 3;
+var RETRY_DELAY_MS = 1e3;
+var MODEL_PRICING = {
+  "claude-opus-4-5-20250514": { input: 15, output: 75 },
+  "claude-sonnet-4-20250514": { input: 3, output: 15 },
+  "claude-haiku-3-5-20241022": { input: 0.25, output: 1.25 },
+  // Fallback defaults
+  "claude-opus": { input: 15, output: 75 },
+  "claude-sonnet": { input: 3, output: 15 },
+  "claude-haiku": { input: 0.25, output: 1.25 }
+};
+var AnthropicClient = class {
+  client;
+  config;
+  constructor(config, apiKey) {
+    const key = apiKey ?? process.env["ANTHROPIC_API_KEY"];
+    if (!key) {
+      throw new Error("ANTHROPIC_API_KEY is required");
+    }
+    this.client = new Anthropic({ apiKey: key });
+    this.config = config;
+  }
+  /**
+   * Send a message and get a response
+   */
+  async chat(systemPrompt, userMessage, options) {
+    let lastError = null;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        const response = await this.client.messages.create({
+          model: this.config.model,
+          max_tokens: options?.maxTokens ?? this.config.maxTokens ?? 4096,
+          temperature: options?.temperature ?? this.config.temperature ?? 0.7,
+          system: systemPrompt,
+          messages: [{ role: "user", content: userMessage }]
+        });
+        const textContent = response.content.find((c) => c.type === "text");
+        const text = textContent && "text" in textContent ? textContent.text : "";
+        const usage = this.calculateUsage(
+          response.usage.input_tokens,
+          response.usage.output_tokens
+        );
+        return {
+          content: text,
+          usage,
+          model: response.model,
+          stopReason: response.stop_reason ?? "end_turn"
+        };
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (lastError.message.includes("401") || lastError.message.includes("authentication")) {
+          throw lastError;
+        }
+        if (attempt < MAX_RETRIES - 1) {
+          await sleep(RETRY_DELAY_MS * Math.pow(2, attempt));
+        }
+      }
+    }
+    throw lastError ?? new Error("Unknown error");
+  }
+  /**
+   * Calculate token usage and costs
+   */
+  calculateUsage(inputTokens, outputTokens) {
+    const pricing = this.getPricing();
+    const baseCost = inputTokens / 1e6 * pricing.input + outputTokens / 1e6 * pricing.output;
+    return {
+      inputTokens,
+      outputTokens,
+      totalTokens: inputTokens + outputTokens,
+      baseCost,
+      markedUpCost: baseCost * 1.1
+      // 10% markup for PRO tier
+    };
+  }
+  getPricing() {
+    const pricing = MODEL_PRICING[this.config.model];
+    if (pricing) return pricing;
+    for (const [key, value] of Object.entries(MODEL_PRICING)) {
+      if (this.config.model.includes(key.replace("claude-", ""))) {
+        return value;
+      }
+    }
+    return { input: 3, output: 15 };
+  }
+};
+function getDefaultModel(role) {
+  switch (role) {
+    case "architect":
+      return "claude-sonnet-4-20250514";
+    case "sentinel":
+      return "claude-sonnet-4-20250514";
+    case "executor":
+      return "claude-sonnet-4-20250514";
+    case "reviewer":
+      return "claude-sonnet-4-20250514";
+    default:
+      return "claude-sonnet-4-20250514";
+  }
+}
+
+export {
+  generateId,
+  AnthropicClient,
+  getDefaultModel
+};

package/dist/chunk-BL5TX2UW.js

@@ -0,0 +1,91 @@
+import {
+  listLocalAtoms
+} from "./chunk-4NZPAEKS.js";
+
+// src/cli/list.ts
+import chalk from "chalk";
+var STATUS_COLORS = {
+  DRAFT: chalk.gray,
+  READY: chalk.blue,
+  IN_PROGRESS: chalk.yellow,
+  TESTING: chalk.cyan,
+  DONE: chalk.green,
+  FAILED: chalk.red,
+  BLOCKED: chalk.magenta
+};
+async function list(options) {
+  const atoms = await listLocalAtoms();
+  if (atoms.length === 0) {
+    console.log(chalk.dim("No atoms found."));
+    console.log(chalk.dim("Create one with: archon plan <description>"));
+    return;
+  }
+  let filteredAtoms = atoms;
+  if (options.status) {
+    const statusFilter = options.status.toUpperCase();
+    filteredAtoms = atoms.filter((a) => a.status === statusFilter);
+    if (filteredAtoms.length === 0) {
+      console.log(chalk.dim(`No atoms with status "${options.status}" found.`));
+      return;
+    }
+  }
+  const sortBy = options.sortBy ?? "priority";
+  filteredAtoms.sort((a, b) => {
+    switch (sortBy) {
+      case "priority":
+        return a.priority - b.priority;
+      case "created":
+        return new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
+      case "updated":
+        return new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime();
+      case "status":
+        return a.status.localeCompare(b.status);
+      default:
+        return a.priority - b.priority;
+    }
+  });
+  console.log("");
+  console.log(
+    chalk.bold(
+      padRight("ID", 12) + padRight("Title", 40) + padRight("Status", 14) + padRight("Priority", 10) + "Created"
+    )
+  );
+  console.log(chalk.dim("\u2500".repeat(90)));
+  for (const atom of filteredAtoms) {
+    const colorFn = STATUS_COLORS[atom.status] ?? chalk.white;
+    const createdDate = formatDate(atom.createdAt);
+    console.log(
+      padRight(atom.externalId, 12) + padRight(truncate(atom.title, 38), 40) + colorFn(padRight(atom.status, 14)) + padRight(String(atom.priority), 10) + chalk.dim(createdDate)
+    );
+  }
+  console.log(chalk.dim("\u2500".repeat(90)));
+  const statusCounts = countByStatus(filteredAtoms);
+  const summaryParts = [];
+  for (const [status, count] of Object.entries(statusCounts)) {
+    const colorFn = STATUS_COLORS[status] ?? chalk.white;
+    summaryParts.push(`${count} ${colorFn(status.toLowerCase())}`);
+  }
+  console.log(`Showing ${filteredAtoms.length} atom(s): ${summaryParts.join(", ")}`);
+}
+function padRight(str, width) {
+  return str.padEnd(width);
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.substring(0, maxLen - 1) + "\u2026";
+}
+function formatDate(date) {
+  const d = typeof date === "string" ? new Date(date) : date;
+  return d.toISOString().split("T")[0] ?? "";
+}
+function countByStatus(atoms) {
+  const counts = {};
+  for (const atom of atoms) {
+    counts[atom.status] = (counts[atom.status] ?? 0) + 1;
+  }
+  return counts;
+}
+
+export {
+  list
+};

package/dist/chunk-CAYCSBNX.js

@@ -0,0 +1,202 @@
+import {
+  clearConfig,
+  loadConfig,
+  saveConfig
+} from "./chunk-WCCBJSNI.js";
+
+// src/cli/auth.ts
+import { createClient } from "@supabase/supabase-js";
+import { createServer } from "http";
+import { URL } from "url";
+import open from "open";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/cli/constants.ts
+var SUPABASE_URL = "https://yjdkcepktrbabmzhcmrt.supabase.co";
+var SUPABASE_ANON_KEY = "sb_publishable_XSGLVPfLZx-HA2uL6xsGCQ_KjAx2TIa";
+var API_URL = "https://archondev-api.fly.dev";
+
+// src/cli/auth.ts
+var CALLBACK_PORT = 54321;
+var CALLBACK_URL = `http://localhost:${CALLBACK_PORT}/callback`;
+function getAuthClient() {
+  return createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
+    auth: {
+      flowType: "pkce"
+    }
+  });
+}
+async function login(provider = "github") {
+  const spinner = ora("Starting authentication...").start();
+  try {
+    const supabase = getAuthClient();
+    const { data, error } = await supabase.auth.signInWithOAuth({
+      provider,
+      options: {
+        redirectTo: CALLBACK_URL,
+        skipBrowserRedirect: true
+      }
+    });
+    if (error) {
+      spinner.fail(chalk.red(`Authentication failed: ${error.message}`));
+      return;
+    }
+    if (!data.url) {
+      spinner.fail(chalk.red("Failed to get authentication URL"));
+      return;
+    }
+    const authResult = await startCallbackServer(data.url, spinner);
+    if (authResult) {
+      const { data: sessionData, error: sessionError } = await supabase.auth.exchangeCodeForSession(
+        authResult.code
+      );
+      if (sessionError) {
+        spinner.fail(chalk.red(`Failed to complete authentication: ${sessionError.message}`));
+        return;
+      }
+      if (sessionData.session) {
+        let userTier = "FREE";
+        try {
+          const { data: profileData } = await supabase.from("user_profiles").select("tier").eq("auth_id", sessionData.user.id).single();
+          const profile = profileData;
+          if (profile?.tier) {
+            userTier = profile.tier;
+          }
+        } catch {
+        }
+        await saveConfig({
+          accessToken: sessionData.session.access_token,
+          refreshToken: sessionData.session.refresh_token,
+          userId: sessionData.user.id,
+          email: sessionData.user.email ?? "",
+          tier: userTier,
+          expiresAt: new Date(sessionData.session.expires_at ?? Date.now() + 36e5).toISOString()
+        });
+        spinner.succeed(chalk.green(`Logged in as ${sessionData.user.email}`));
+        console.log(chalk.dim(`Tier: ${userTier}`));
+      }
+    }
+  } catch (error) {
+    spinner.fail(chalk.red(`Authentication error: ${error instanceof Error ? error.message : "Unknown error"}`));
+  }
+}
+function startCallbackServer(authUrl, spinner) {
+  return new Promise((resolve) => {
+    const server = createServer((req, res) => {
+      const url = new URL(req.url ?? "", `http://localhost:${CALLBACK_PORT}`);
+      if (url.pathname === "/callback") {
+        const code = url.searchParams.get("code");
+        if (code) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+            <!DOCTYPE html>
+            <html>
+              <head><title>ArchonDev - Authentication Successful</title></head>
+              <body style="font-family: system-ui; text-align: center; padding: 50px;">
+                <h1>\u2705 Authentication Successful!</h1>
+                <p>You can close this window and return to the terminal.</p>
+              </body>
+            </html>
+          `);
+          server.close();
+          resolve({ code });
+        } else {
+          const error = url.searchParams.get("error_description") ?? "Authentication failed";
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(`
+            <!DOCTYPE html>
+            <html>
+              <head><title>ArchonDev - Authentication Failed</title></head>
+              <body style="font-family: system-ui; text-align: center; padding: 50px;">
+                <h1>\u274C Authentication Failed</h1>
+                <p>${error}</p>
+              </body>
+            </html>
+          `);
+          server.close();
+          resolve(null);
+        }
+      }
+    });
+    server.listen(CALLBACK_PORT, async () => {
+      spinner.text = "Opening browser for authentication...";
+      try {
+        await open(authUrl);
+        spinner.text = "Waiting for authentication in browser...";
+      } catch {
+        spinner.text = `Please open this URL in your browser:
+${authUrl}`;
+      }
+    });
+    setTimeout(() => {
+      server.close();
+      spinner.fail(chalk.red("Authentication timed out"));
+      resolve(null);
+    }, 5 * 60 * 1e3);
+  });
+}
+async function logout() {
+  const spinner = ora("Logging out...").start();
+  try {
+    const config = await loadConfig();
+    if (config.accessToken) {
+      try {
+        const supabase = getAuthClient();
+        await supabase.auth.signOut();
+      } catch {
+      }
+    }
+    await clearConfig();
+    spinner.succeed(chalk.green("Logged out successfully"));
+  } catch (error) {
+    spinner.fail(chalk.red(`Logout failed: ${error instanceof Error ? error.message : "Unknown error"}`));
+  }
+}
+async function status() {
+  const config = await loadConfig();
+  if (!config.accessToken) {
+    console.log(chalk.yellow("Not logged in"));
+    console.log(chalk.dim("Run `archon login` to authenticate"));
+    return;
+  }
+  if (config.expiresAt) {
+    const expiresAt = new Date(config.expiresAt);
+    if (expiresAt < /* @__PURE__ */ new Date()) {
+      console.log(chalk.yellow("Session expired"));
+      console.log(chalk.dim("Run `archon login` to re-authenticate"));
+      return;
+    }
+  }
+  console.log(chalk.green("\u2713 Authenticated"));
+  console.log();
+  console.log(`  ${chalk.dim("Email:")} ${config.email}`);
+  console.log(`  ${chalk.dim("Tier:")}  ${formatTier(config.tier ?? "FREE")}`);
+  console.log(`  ${chalk.dim("User:")}  ${config.userId}`);
+  if (config.expiresAt) {
+    const expiresAt = new Date(config.expiresAt);
+    const hoursLeft = Math.round((expiresAt.getTime() - Date.now()) / (1e3 * 60 * 60));
+    console.log(`  ${chalk.dim("Session expires in:")} ${hoursLeft} hours`);
+  }
+}
+function formatTier(tier) {
+  switch (tier) {
+    case "FREE":
+      return chalk.gray("FREE");
+    case "CREDITS":
+      return chalk.green("CREDITS (Pay-as-you-go)");
+    case "BYOK":
+      return chalk.blue("BYOK (Bring Your Own Key)");
+    default:
+      return tier;
+  }
+}
+
+export {
+  SUPABASE_URL,
+  SUPABASE_ANON_KEY,
+  API_URL,
+  login,
+  logout,
+  status
+};