archondev 0.1.0 → 1.2.0

package/dist/chunk-EDP55FCI.js

@@ -0,0 +1,485 @@
+import {
+  ArchitectureParser
+} from "./chunk-2CFO5GVH.js";
+import {
+  ArchitectAgent,
+  createAtom,
+  validateAtom
+} from "./chunk-MOZHC2GX.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 } from "fs";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } 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/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 = join(process.cwd(), "ARCHITECTURE.md");
+    if (!existsSync(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 keyManager = new KeyManager();
+      const storedKey = await keyManager.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 = join(process.cwd(), ATOMS_DIR);
+  if (!existsSync(atomsDir)) {
+    await mkdir(atomsDir, { recursive: true });
+  }
+  const atomFile = join(atomsDir, `${atom.externalId}.json`);
+  await writeFile(atomFile, JSON.stringify(atom, null, 2));
+}
+async function loadAtom(atomId) {
+  const atomFile = join(process.cwd(), ATOMS_DIR, `${atomId}.json`);
+  if (!existsSync(atomFile)) {
+    return null;
+  }
+  const content = await readFile(atomFile, "utf-8");
+  return JSON.parse(content);
+}
+async function listLocalAtoms() {
+  const atomsDir = join(process.cwd(), ATOMS_DIR);
+  if (!existsSync(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 {
+  plan,
+  loadAtom,
+  listLocalAtoms
+};