archondev 0.1.0 → 1.2.0

package/README.md

@@ -1,75 +1,108 @@
 # ArchonDev
 
-**Local-first AI-powered development governance**
+**AI Development Governance — Stop Babysitting Your AI Agent**
 
-ArchonDev brings architectural governance to AI-assisted development. It ensures your AI coding assistants (Cursor, Copilot, Claude, etc.) respect codebase boundaries, follow coding standards, and never violate critical invariants.
+## Two Ways to Use ArchonDev
 
-## Installation
+### Option 1: Full CLI (Recommended)
+The complete AI development system. It manages your entire development process so you can focus on the big picture — not constantly correcting your AI.
 
 ```bash
-npm install -g archondev
-```
+# macOS/Linux:
+npm install -g archondev && archon
 
-## Quick Start
+# Windows PowerShell:
+npm install -g archondev; archon
+```
 
-```bash
-# Initialize ArchonDev in your project
-archon init
+**What you get:**
+- AI that reads and respects your architecture before writing code
+- Adversarial planning (Architect proposes, Sentinel critiques)
+- Automatic quality gates before changes are applied
+- Learning persistence — mistakes are remembered and avoided
+- Bug reporting with root cause analysis
+- AI-powered code review for any codebase
+- Multi-provider key support with adversarial features
 
-# Create a work item (atom) with AI-powered planning
-archon plan "Add user authentication with JWT"
+### Option 2: Lite Package
+Copy governance files into any project. Works with your existing AI tools (Cursor, Claude Code, Windsurf, VS Code + Copilot).
 
-# Execute the plan with quality gates
-archon execute ATOM-001
-```
+[Download Lite Packages →](https://archondev.io/download)
 
-## How It Works
+**What you get:**
+- ARCHITECTURE.md template with best practices
+- IDE-specific rule files (.cursorrules, CLAUDE.md, etc.)
+- Progress tracking templates
+- Works with any AI coding assistant
 
-1. **Architecture as Input** - Define your system boundaries, invariants, and protected paths in `ARCHITECTURE.md`
-2. **Adversarial Planning** - An Architect agent creates plans, a Sentinel agent critiques them
-3. **Governed Execution** - Changes are validated against your architecture before being applied
-4. **Learning Persistence** - Insights are captured in `progress.txt` for future sessions
+---
 
 ## Commands
 
 | Command | Description |
 |---------|-------------|
-| `archon init` | Initialize ArchonDev in your project |
-| `archon plan <description>` | Create a new atom with AI planning |
-| `archon execute <atom-id>` | Execute a planned atom |
-| `archon list` | List all atoms |
-| `archon show <atom-id>` | Show atom details |
-| `archon status` | Show current user and project status |
-| `archon login` | Authenticate with ArchonDev |
-| `archon keys add <provider>` | Add API key for BYOK tier |
-| `archon bug report <title>` | Report a bug with RCA |
-| `archon promote <atom-id>` | Promote atom to higher environment |
-
-## Tiers
-
-| Tier | Price | Features |
-|------|-------|----------|
-| **Free** | $0 | 100 atoms/month, basic models (Haiku, Flash, GPT-4 Mini) |
-| **BYOK** | $0 | Unlimited atoms, use your own API keys |
-| **Pro** | $29/mo | Premium models (Opus, Sonnet), $50 credits included |
-
-## Light Packages
-
-Don't need the full CLI? Download governance templates for your IDE:
-
-- [Cursor Package](https://archondev.io/downloads/cursor-package.zip)
-- [Windsurf Package](https://archondev.io/downloads/windsurf-package.zip)
-- [VS Code + Copilot Package](https://archondev.io/downloads/vscode-copilot-package.zip)
-- [Claude Code / Amp Package](https://archondev.io/downloads/claude-amp-package.zip)
+| `archon` | Interactive mode — just run and follow prompts |
+| `archon init` | Initialize in your project |
+| `archon plan <description>` | Create a work item with AI planning |
+| `archon execute <atom-id>` | Execute with quality gates |
+| `archon list` | List all work items |
+| `archon show <atom-id>` | Show details |
+| `archon watch` | Live TUI dashboard with status and credits |
+| `archon bug report <title>` | Bug report with root cause analysis |
+| `archon review init` | Initialize AI-powered code review |
+| `archon review analyze` | Scan project and populate review tasks |
+| `archon review run` | Run AI review on pending tasks |
+| `archon credits` | View credit balance |
+| `archon credits add` | Purchase credits |
+| `archon credits budget` | Set monthly budget and alerts |
+| `archon keys add <provider>` | Add your own API key — BYOK (Bring Your Own Key) |
+| `archon keys list` | Show configured API keys by provider |
+| `archon preferences` | View/set model preferences |
+| `archon models` | List available AI models |
+
+## Pricing
+
+| Tier | Cost | What You Get |
+|------|------|--------------|
+| **Free** | $0 | 10,000 atoms/month, fast models (Haiku, Flash, GPT-4 Mini) |
+| **Credits** | Pay as you go | All models, 10% service fee, deposit any amount |
+| **BYOK** (Bring Your Own Key) | $0 | Use your own API keys, unlimited usage |
+
+No subscriptions. No commitments. Start free.
 
-## Documentation
+## How It Works
 
-Full documentation at [https://archondev.io](https://archondev.io)
+1. **Define Your Rules** — Create ARCHITECTURE.md with boundaries and invariants
+2. **AI Reads Rules First** — Every session starts by understanding your architecture
+3. **Changes Are Validated** — Quality gates check code before it's applied
+4. **Learnings Persist** — Insights saved for future sessions
 
-## License
+## Working with Existing Projects
+
+Have a project created by another AI agent? ArchonDev can review it first, then govern future changes.
+
+```bash
+# Step 1: Review existing code
+cd your-existing-project
+archon review init        # Create local review database
+archon review analyze     # Scan project structure
+archon review run --all   # AI reviews all features
+archon review export > review-report.md
+
+# Step 2: Set up governance
+archon init --analyze     # Creates ARCHITECTURE.md
+
+# Step 3: Fix issues with governed workflow
+archon plan "fix critical issues from review"
+archon execute <atom-id>
+```
+
+The CLI detects existing projects and suggests this workflow automatically.
+
+## Documentation
 
-MIT
+[archondev.io](https://archondev.io)
 
 ---
 
-*Powered by ArchonDev - AI Development Governance by Jumping Ahead Corp.*
+*ArchonDev by Jumping Ahead Corp.*

package/dist/auth-2QIFQZTL.js

@@ -0,0 +1,12 @@
+import {
+  login,
+  logout,
+  status
+} from "./chunk-CAYCSBNX.js";
+import "./chunk-WCCBJSNI.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  login,
+  logout,
+  status
+};

package/dist/bug-DXLBBW3U.js

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

package/dist/{chunk-R6IMTNKV.js → chunk-2CFO5GVH.js}

@@ -1,35 +1,3 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
 // src/core/parser/parser.ts
 import { readFile } from "fs/promises";
 import { existsSync } from "fs";
@@ -382,8 +350,5 @@ var ArchitectureParser = class {
 };
 
 export {
-  __require,
-  __commonJS,
-  __toESM,
   ArchitectureParser
 };

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-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
+};