archondev 0.1.0 → 1.2.0

package/dist/chunk-MOZHC2GX.js

@@ -0,0 +1,351 @@
+import {
+  AnthropicClient,
+  generateId,
+  getDefaultModel
+} from "./chunk-A7QU6JC6.js";
+
+// src/core/atoms/types.ts
+var ATOM_TRANSITIONS = {
+  DRAFT: ["READY"],
+  READY: ["IN_PROGRESS", "BLOCKED"],
+  IN_PROGRESS: ["TESTING", "FAILED"],
+  TESTING: ["DONE", "FAILED"],
+  DONE: [],
+  // Terminal state
+  FAILED: ["IN_PROGRESS", "BLOCKED"],
+  // Can retry or escalate
+  BLOCKED: ["READY"]
+  // Can unblock and retry
+};
+var MAX_RETRIES = 3;
+
+// src/core/atoms/atoms.ts
+var MAX_RETRIES2 = MAX_RETRIES;
+var atomCounter = 0;
+function generateAtomId() {
+  atomCounter++;
+  return `ATOM-${String(atomCounter).padStart(3, "0")}`;
+}
+function createAtom(input, context) {
+  const now = /* @__PURE__ */ new Date();
+  const externalId = generateAtomId();
+  return {
+    id: generateId("atom"),
+    externalId,
+    title: input.title,
+    description: input.description ?? null,
+    goals: input.goals ?? [],
+    acceptanceCriteria: input.acceptanceCriteria,
+    ownershipPaths: input.ownershipPaths ?? [],
+    status: "DRAFT",
+    priority: input.priority ?? 100,
+    plan: null,
+    diffContract: null,
+    retryCount: 0,
+    errorMessage: null,
+    tags: input.tags ?? [],
+    metadata: input.metadata ?? {},
+    context: context ?? {},
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function validateAtom(atom) {
+  const errors = [];
+  if (!atom.title || atom.title.trim() === "") {
+    errors.push({
+      field: "title",
+      message: "Title is required",
+      code: "REQUIRED"
+    });
+  }
+  if (!atom.acceptanceCriteria || atom.acceptanceCriteria.length === 0) {
+    errors.push({
+      field: "acceptanceCriteria",
+      message: "At least one acceptance criterion is required",
+      code: "REQUIRED"
+    });
+  }
+  atom.acceptanceCriteria.forEach((criterion, index) => {
+    if (typeof criterion !== "string" || criterion.trim() === "") {
+      errors.push({
+        field: `acceptanceCriteria[${index}]`,
+        message: "Acceptance criterion must be a non-empty string",
+        code: "INVALID_FORMAT"
+      });
+    }
+  });
+  if (atom.priority < 0) {
+    errors.push({
+      field: "priority",
+      message: "Priority must be a non-negative number",
+      code: "INVALID_VALUE"
+    });
+  }
+  const validStatuses = [
+    "DRAFT",
+    "READY",
+    "IN_PROGRESS",
+    "TESTING",
+    "DONE",
+    "FAILED",
+    "BLOCKED"
+  ];
+  if (!validStatuses.includes(atom.status)) {
+    errors.push({
+      field: "status",
+      message: `Invalid status: ${atom.status}`,
+      code: "INVALID_VALUE"
+    });
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function validateTransition(currentStatus, newStatus) {
+  const allowedTransitions = ATOM_TRANSITIONS[currentStatus];
+  if (!allowedTransitions) {
+    return {
+      valid: false,
+      errors: [
+        {
+          field: "status",
+          message: `Unknown current status: ${currentStatus}`,
+          code: "INVALID_VALUE"
+        }
+      ]
+    };
+  }
+  if (!allowedTransitions.includes(newStatus)) {
+    return {
+      valid: false,
+      errors: [
+        {
+          field: "status",
+          message: `Cannot transition from ${currentStatus} to ${newStatus}. Allowed: ${allowedTransitions.join(", ") || "none"}`,
+          code: "INVALID_TRANSITION"
+        }
+      ]
+    };
+  }
+  return { valid: true, errors: [] };
+}
+function transitionAtom(atom, newStatus, errorMessage) {
+  const validation = validateTransition(atom.status, newStatus);
+  if (!validation.valid) {
+    const error = validation.errors[0];
+    throw new Error(error?.message ?? "Invalid transition");
+  }
+  const now = /* @__PURE__ */ new Date();
+  const updates = {
+    status: newStatus,
+    updatedAt: now
+  };
+  if (newStatus === "FAILED") {
+    updates.retryCount = atom.retryCount + 1;
+    updates.errorMessage = errorMessage ?? null;
+    if (updates.retryCount >= MAX_RETRIES2) {
+      updates.status = "BLOCKED";
+    }
+  }
+  if (newStatus === "IN_PROGRESS" && atom.status === "FAILED") {
+    updates.errorMessage = null;
+  }
+  return { ...atom, ...updates };
+}
+
+// src/agents/architect.ts
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+var SYSTEM_PROMPT = `You are the Architect, an expert software engineer responsible for creating detailed implementation plans.
+
+Your role:
+- Analyze the atom's goals and acceptance criteria
+- Review the architecture constraints and boundaries
+- Generate a step-by-step implementation plan
+- Identify files to modify and potential risks
+- Consider learnings from previous iterations
+
+Output your plan in the following JSON format:
+{
+  "steps": ["Step 1: ...", "Step 2: ...", ...],
+  "files_to_modify": ["path/to/file1.ts", "path/to/file2.ts", ...],
+  "dependencies": ["dependency1", "dependency2", ...],
+  "risks": ["Risk 1: ...", "Risk 2: ...", ...],
+  "estimated_complexity": "LOW" | "MEDIUM" | "HIGH",
+  "reasoning": "Brief explanation of your approach..."
+}
+
+Guidelines:
+- Keep steps atomic and verifiable
+- List ALL files that will be modified
+- Identify any external dependencies needed
+- Flag security, performance, or breaking change risks
+- Be conservative with complexity estimates`;
+var ArchitectAgent = class {
+  client;
+  config;
+  constructor(config, apiKey) {
+    this.config = {
+      provider: "anthropic",
+      model: config?.model ?? getDefaultModel("architect"),
+      maxTokens: config?.maxTokens ?? 4096,
+      temperature: config?.temperature ?? 0.7
+    };
+    this.client = new AnthropicClient(this.config, apiKey);
+  }
+  /**
+   * Generate an implementation plan for an atom
+   */
+  async generatePlan(atom, architecture, context) {
+    const userMessage = await this.buildPrompt(atom, architecture, context);
+    const response = await this.client.chat(SYSTEM_PROMPT, userMessage, {
+      temperature: 0.7,
+      maxTokens: 4096
+    });
+    const plan = this.parsePlanResponse(response.content);
+    return {
+      plan,
+      reasoning: this.extractReasoning(response.content),
+      usage: response.usage
+    };
+  }
+  /**
+   * Build the prompt with all necessary context
+   */
+  async buildPrompt(atom, architecture, context) {
+    const parts = [];
+    parts.push("# Atom to Implement");
+    parts.push(`**Title:** ${atom.title}`);
+    parts.push(`**Description:** ${atom.description ?? "No description"}`);
+    parts.push("");
+    parts.push("**Goals:**");
+    atom.goals.forEach((g, i) => parts.push(`${i + 1}. ${g}`));
+    parts.push("");
+    parts.push("**Acceptance Criteria:**");
+    atom.acceptanceCriteria.forEach((ac, i) => parts.push(`${i + 1}. ${ac}`));
+    parts.push("");
+    if (atom.ownershipPaths.length > 0) {
+      parts.push("**Ownership Paths (files this atom can modify):**");
+      atom.ownershipPaths.forEach((p) => parts.push(`- ${p}`));
+      parts.push("");
+    }
+    parts.push("# Architecture Constraints");
+    parts.push(`**Profile:** ${architecture.profile}`);
+    parts.push(`**Strict Mode:** ${architecture.strictMode}`);
+    parts.push("");
+    if (architecture.components.length > 0) {
+      parts.push("**Components:**");
+      architecture.components.forEach((c) => {
+        parts.push(`- ${c.name} (${c.id}): ${c.paths.join(", ")}`);
+      });
+      parts.push("");
+    }
+    if (architecture.invariants.length > 0) {
+      parts.push("**Invariants (rules that must NOT be violated):**");
+      architecture.invariants.forEach((inv) => {
+        parts.push(`- [${inv.severity}] ${inv.rule}`);
+      });
+      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 (context?.codebasePatterns && context.codebasePatterns.length > 0) {
+      parts.push("# Codebase Patterns (from previous iterations)");
+      context.codebasePatterns.forEach((p) => parts.push(`- ${p}`));
+      parts.push("");
+    }
+    if (context?.recentLearnings && context.recentLearnings.length > 0) {
+      parts.push("# Recent Learnings");
+      context.recentLearnings.slice(0, 5).forEach((l) => parts.push(`- ${l}`));
+      parts.push("");
+    }
+    if (context?.progressPath && existsSync(context.progressPath)) {
+      try {
+        const progressContent = await readFile(context.progressPath, "utf-8");
+        const patterns = this.extractCodebasePatterns(progressContent);
+        if (patterns.length > 0) {
+          parts.push("# Additional Codebase Patterns (from progress.txt)");
+          patterns.forEach((p) => parts.push(`- ${p}`));
+          parts.push("");
+        }
+      } catch {
+      }
+    }
+    parts.push("# Instructions");
+    parts.push("Generate a detailed implementation plan for this atom.");
+    parts.push("Ensure your plan respects all architecture constraints.");
+    parts.push("Output your response as valid JSON.");
+    return parts.join("\n");
+  }
+  /**
+   * Parse the plan from AI response
+   */
+  parsePlanResponse(content) {
+    const jsonMatch = content.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      throw new Error("Failed to parse plan: no JSON found in response");
+    }
+    try {
+      const parsed = JSON.parse(jsonMatch[0]);
+      return {
+        steps: parsed.steps ?? [],
+        files_to_modify: parsed.files_to_modify ?? [],
+        dependencies: parsed.dependencies ?? [],
+        risks: parsed.risks ?? [],
+        estimated_complexity: this.normalizeComplexity(parsed.estimated_complexity)
+      };
+    } catch (error) {
+      throw new Error(`Failed to parse plan JSON: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  normalizeComplexity(value) {
+    const normalized = value?.toUpperCase();
+    if (normalized === "LOW" || normalized === "MEDIUM" || normalized === "HIGH") {
+      return normalized;
+    }
+    return "MEDIUM";
+  }
+  extractReasoning(content) {
+    try {
+      const jsonMatch = content.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        return parsed.reasoning ?? "";
+      }
+    } catch {
+    }
+    return "";
+  }
+  extractCodebasePatterns(progressContent) {
+    const patterns = [];
+    const lines = progressContent.split("\n");
+    let inPatternsSection = false;
+    for (const line of lines) {
+      if (line.includes("## Codebase Patterns")) {
+        inPatternsSection = true;
+        continue;
+      }
+      if (line.startsWith("## ") && inPatternsSection) {
+        break;
+      }
+      if (inPatternsSection && line.startsWith("- ")) {
+        patterns.push(line.substring(2).trim());
+      }
+    }
+    return patterns;
+  }
+};
+
+export {
+  createAtom,
+  validateAtom,
+  transitionAtom,
+  ArchitectAgent
+};

package/dist/chunk-PK3OQVBG.js

@@ -0,0 +1,91 @@
+import {
+  listLocalAtoms
+} from "./chunk-EDP55FCI.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-QGM4M3NI.js

@@ -0,0 +1,37 @@
+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
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};