archondev 0.1.0 → 1.2.0

package/dist/chunk-JBKFAD4M.js

@@ -0,0 +1,650 @@
+import {
+  ArchitectAgent,
+  createAtom
+} from "./chunk-MOZHC2GX.js";
+import {
+  loadConfig
+} from "./chunk-WCCBJSNI.js";
+
+// src/cli/bug.ts
+import chalk from "chalk";
+import { existsSync as existsSync3 } from "fs";
+import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join3 } from "path";
+import { createInterface } from "readline";
+
+// src/core/bugs/manager.ts
+import { existsSync } from "fs";
+import { readFile, writeFile, mkdir, readdir } from "fs/promises";
+import { join } from "path";
+import * as yaml from "yaml";
+var BUGS_DIR = "bugs";
+var bugCounter = 0;
+function generateBugId() {
+  bugCounter++;
+  return `BUG-${String(bugCounter).padStart(3, "0")}`;
+}
+async function initializeBugCounter(projectPath) {
+  const bugsDir = join(projectPath, BUGS_DIR);
+  if (!existsSync(bugsDir)) {
+    bugCounter = 0;
+    return;
+  }
+  const files = await readdir(bugsDir);
+  const bugFiles = files.filter((f) => f.startsWith("BUG-") && f.endsWith(".yaml"));
+  let maxId = 0;
+  for (const file of bugFiles) {
+    const match = file.match(/BUG-(\d+)\.yaml/);
+    if (match?.[1]) {
+      const id = parseInt(match[1], 10);
+      if (id > maxId) {
+        maxId = id;
+      }
+    }
+  }
+  bugCounter = maxId;
+}
+var BugManager = class {
+  projectPath;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  async initialize() {
+    await initializeBugCounter(this.projectPath);
+    const bugsDir = join(this.projectPath, BUGS_DIR);
+    if (!existsSync(bugsDir)) {
+      await mkdir(bugsDir, { recursive: true });
+    }
+  }
+  async createBug(input) {
+    const now = /* @__PURE__ */ new Date();
+    const id = generateBugId();
+    const bug = {
+      id,
+      title: input.title,
+      description: input.description,
+      stepsToReproduce: input.stepsToReproduce,
+      expectedBehavior: input.expectedBehavior,
+      actualBehavior: input.actualBehavior,
+      severity: input.severity,
+      affectedComponents: [],
+      triageResult: null,
+      rcaResult: null,
+      atomId: null,
+      status: "REPORTED",
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.saveBug(bug);
+    return bug;
+  }
+  async saveBug(bug) {
+    const bugsDir = join(this.projectPath, BUGS_DIR);
+    if (!existsSync(bugsDir)) {
+      await mkdir(bugsDir, { recursive: true });
+    }
+    const bugFile = join(bugsDir, `${bug.id}.yaml`);
+    const content = yaml.stringify(this.serializeBug(bug));
+    await writeFile(bugFile, content);
+  }
+  async loadBug(bugId) {
+    const bugFile = join(this.projectPath, BUGS_DIR, `${bugId}.yaml`);
+    if (!existsSync(bugFile)) {
+      return null;
+    }
+    const content = await readFile(bugFile, "utf-8");
+    const data = yaml.parse(content);
+    return this.deserializeBug(data);
+  }
+  async listBugs() {
+    const bugsDir = join(this.projectPath, BUGS_DIR);
+    if (!existsSync(bugsDir)) {
+      return [];
+    }
+    const files = await readdir(bugsDir);
+    const bugs = [];
+    for (const file of files) {
+      if (file.endsWith(".yaml")) {
+        const bugId = file.replace(".yaml", "");
+        const bug = await this.loadBug(bugId);
+        if (bug) {
+          bugs.push(bug);
+        }
+      }
+    }
+    return bugs.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+  }
+  async updateTriageResult(bugId, triageResult) {
+    const bug = await this.loadBug(bugId);
+    if (!bug) {
+      return null;
+    }
+    bug.triageResult = triageResult;
+    bug.affectedComponents = triageResult.affectedComponents;
+    bug.status = "TRIAGED";
+    bug.updatedAt = /* @__PURE__ */ new Date();
+    await this.saveBug(bug);
+    return bug;
+  }
+  async updateRCAResult(bugId, rcaResult) {
+    const bug = await this.loadBug(bugId);
+    if (!bug) {
+      return null;
+    }
+    bug.rcaResult = rcaResult;
+    bug.status = "ANALYZED";
+    bug.updatedAt = /* @__PURE__ */ new Date();
+    await this.saveBug(bug);
+    return bug;
+  }
+  async linkAtom(bugId, atomId) {
+    const bug = await this.loadBug(bugId);
+    if (!bug) {
+      return null;
+    }
+    bug.atomId = atomId;
+    bug.status = "IN_PROGRESS";
+    bug.updatedAt = /* @__PURE__ */ new Date();
+    await this.saveBug(bug);
+    return bug;
+  }
+  serializeBug(bug) {
+    return {
+      id: bug.id,
+      title: bug.title,
+      description: bug.description,
+      stepsToReproduce: bug.stepsToReproduce,
+      expectedBehavior: bug.expectedBehavior,
+      actualBehavior: bug.actualBehavior,
+      severity: bug.severity,
+      affectedComponents: bug.affectedComponents,
+      triageResult: bug.triageResult,
+      rcaResult: bug.rcaResult,
+      atomId: bug.atomId,
+      status: bug.status,
+      createdAt: bug.createdAt.toISOString(),
+      updatedAt: bug.updatedAt.toISOString()
+    };
+  }
+  deserializeBug(data) {
+    return {
+      id: data["id"],
+      title: data["title"],
+      description: data["description"],
+      stepsToReproduce: data["stepsToReproduce"],
+      expectedBehavior: data["expectedBehavior"],
+      actualBehavior: data["actualBehavior"],
+      severity: data["severity"],
+      affectedComponents: data["affectedComponents"],
+      triageResult: data["triageResult"],
+      rcaResult: data["rcaResult"],
+      atomId: data["atomId"],
+      status: data["status"],
+      createdAt: new Date(data["createdAt"]),
+      updatedAt: new Date(data["updatedAt"])
+    };
+  }
+};
+
+// src/core/bugs/triage.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var AutoTriage = class {
+  architecture;
+  constructor(architecture) {
+    this.architecture = architecture ?? null;
+  }
+  async analyzeBug(bug) {
+    const keywords = this.extractKeywords(bug);
+    const affectedComponents = this.identifyAffectedComponents(bug, keywords);
+    const relatedFiles = this.identifyRelatedFiles(bug, keywords);
+    const estimatedSeverity = this.estimateSeverity(bug, affectedComponents);
+    const suggestedPriority = this.calculatePriority(estimatedSeverity, affectedComponents.length);
+    const confidence = this.calculateConfidence(keywords, affectedComponents);
+    return {
+      affectedComponents,
+      estimatedSeverity,
+      suggestedPriority,
+      keywords,
+      relatedFiles,
+      confidence
+    };
+  }
+  extractKeywords(bug) {
+    const text = [
+      bug.title,
+      bug.description,
+      ...bug.stepsToReproduce,
+      bug.expectedBehavior,
+      bug.actualBehavior
+    ].join(" ").toLowerCase();
+    const commonPatterns = [
+      "error",
+      "crash",
+      "fail",
+      "broken",
+      "null",
+      "undefined",
+      "timeout",
+      "hang",
+      "freeze",
+      "slow",
+      "memory",
+      "leak",
+      "security",
+      "auth",
+      "login",
+      "permission",
+      "access",
+      "database",
+      "api",
+      "network",
+      "connection",
+      "socket",
+      "file",
+      "path",
+      "directory",
+      "config",
+      "env",
+      "cli",
+      "command",
+      "parse",
+      "validation",
+      "schema"
+    ];
+    const foundKeywords = [];
+    for (const pattern of commonPatterns) {
+      if (text.includes(pattern)) {
+        foundKeywords.push(pattern);
+      }
+    }
+    const technicalTerms = text.match(/\b[A-Z][a-zA-Z]+(?:Error|Exception|Failure|Handler|Manager|Service|Client|Agent)\b/gi);
+    if (technicalTerms) {
+      foundKeywords.push(...technicalTerms.map((t) => t.toLowerCase()));
+    }
+    const filePatterns = text.match(/\b[\w/-]+\.(ts|js|json|yaml|md)\b/gi);
+    if (filePatterns) {
+      foundKeywords.push(...filePatterns);
+    }
+    return [...new Set(foundKeywords)];
+  }
+  identifyAffectedComponents(bug, keywords) {
+    if (!this.architecture) {
+      return this.inferComponentsFromKeywords(keywords);
+    }
+    const text = [
+      bug.title,
+      bug.description,
+      ...bug.stepsToReproduce
+    ].join(" ").toLowerCase();
+    const affected = [];
+    for (const component of this.architecture.components) {
+      if (this.componentMatchesBug(component, text, keywords)) {
+        affected.push(component.id);
+      }
+    }
+    if (affected.length === 0) {
+      return this.inferComponentsFromKeywords(keywords);
+    }
+    return affected;
+  }
+  componentMatchesBug(component, text, keywords) {
+    if (text.includes(component.name.toLowerCase())) {
+      return true;
+    }
+    if (text.includes(component.id.toLowerCase())) {
+      return true;
+    }
+    for (const path of component.paths) {
+      const pathParts = path.split("/").filter((p) => p && p !== "*");
+      for (const part of pathParts) {
+        if (text.includes(part.toLowerCase())) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  inferComponentsFromKeywords(keywords) {
+    const componentMap = {
+      "cli": ["cli", "command", "parse", "prompt"],
+      "agents": ["agent", "architect", "sentinel", "executor", "planner"],
+      "core": ["core", "parser", "validation", "schema"],
+      "database": ["database", "db", "supabase", "query", "sql"],
+      "api": ["api", "endpoint", "route", "request", "response"],
+      "auth": ["auth", "login", "permission", "token", "session"]
+    };
+    const inferred = [];
+    for (const [component, patterns] of Object.entries(componentMap)) {
+      for (const pattern of patterns) {
+        if (keywords.includes(pattern)) {
+          inferred.push(component);
+          break;
+        }
+      }
+    }
+    return [...new Set(inferred)];
+  }
+  identifyRelatedFiles(bug, keywords) {
+    const files = [];
+    const filePatterns = keywords.filter((k) => k.match(/\.(ts|js|json|yaml|md)$/i));
+    files.push(...filePatterns);
+    for (const keyword of keywords) {
+      if (keyword === "cli") {
+        files.push("src/cli/");
+      } else if (keyword === "agent" || keyword === "architect" || keyword === "sentinel") {
+        files.push("src/agents/");
+      } else if (keyword === "parser" || keyword === "schema") {
+        files.push("src/core/parser/");
+      } else if (keyword === "database" || keyword === "db") {
+        files.push("src/db/");
+      }
+    }
+    return [...new Set(files)];
+  }
+  estimateSeverity(bug, affectedComponents) {
+    const criticalKeywords = ["security", "auth", "data loss", "corruption", "crash"];
+    const highKeywords = ["error", "fail", "broken", "cannot", "unable"];
+    const mediumKeywords = ["slow", "timeout", "unexpected", "incorrect"];
+    const text = [bug.title, bug.description, bug.actualBehavior].join(" ").toLowerCase();
+    for (const keyword of criticalKeywords) {
+      if (text.includes(keyword)) {
+        return "CRITICAL";
+      }
+    }
+    if (bug.severity === "CRITICAL" || bug.severity === "HIGH") {
+      return bug.severity;
+    }
+    const hasHighKeyword = highKeywords.some((k) => text.includes(k));
+    const hasManyComponents = affectedComponents.length > 2;
+    if (hasHighKeyword && hasManyComponents) {
+      return "HIGH";
+    }
+    if (hasHighKeyword || hasManyComponents) {
+      return "MEDIUM";
+    }
+    if (mediumKeywords.some((k) => text.includes(k))) {
+      return "MEDIUM";
+    }
+    return "LOW";
+  }
+  calculatePriority(severity, componentCount) {
+    const severityScore = {
+      CRITICAL: 1,
+      HIGH: 2,
+      MEDIUM: 5,
+      LOW: 10
+    };
+    let priority = severityScore[severity];
+    priority = Math.max(1, priority - componentCount);
+    return priority;
+  }
+  calculateConfidence(keywords, affectedComponents) {
+    let confidence = 0.5;
+    if (keywords.length > 3) {
+      confidence += 0.2;
+    }
+    if (affectedComponents.length > 0) {
+      confidence += 0.2;
+    }
+    if (keywords.some((k) => k.match(/\.(ts|js)$/))) {
+      confidence += 0.1;
+    }
+    return Math.min(1, confidence);
+  }
+};
+async function loadArchitectureForTriage(projectPath) {
+  const archPath = join2(projectPath, "ARCHITECTURE.md");
+  if (!existsSync2(archPath)) {
+    return null;
+  }
+  try {
+    const { ArchitectureParser } = await import("./parser-M4DI7A24.js");
+    const parser = new ArchitectureParser(archPath);
+    const result = await parser.parse();
+    return result.success ? result.schema ?? null : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/cli/bug.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()
+  };
+}
+function parseSeverity(input) {
+  const normalized = input.toUpperCase().trim();
+  if (normalized === "LOW" || normalized === "MEDIUM" || normalized === "HIGH" || normalized === "CRITICAL") {
+    return normalized;
+  }
+  return null;
+}
+async function bugReport(title, options) {
+  const prompt = createPrompt();
+  const projectPath = process.cwd();
+  try {
+    console.log(chalk.blue("\n\u{1F4CB} Bug Report: ") + chalk.bold(title));
+    console.log(chalk.dim("\u2500".repeat(40)));
+    const description = await prompt.ask(chalk.cyan("Description: "));
+    console.log(chalk.cyan("Steps to reproduce (enter each step, empty line to finish):"));
+    const stepsToReproduce = [];
+    let stepNum = 1;
+    let step = await prompt.ask(chalk.dim(`  ${stepNum}. `));
+    while (step.trim() !== "") {
+      stepsToReproduce.push(step.trim());
+      stepNum++;
+      step = await prompt.ask(chalk.dim(`  ${stepNum}. `));
+    }
+    if (stepsToReproduce.length === 0) {
+      stepsToReproduce.push("No steps provided");
+    }
+    const expectedBehavior = await prompt.ask(chalk.cyan("Expected behavior: "));
+    const actualBehavior = await prompt.ask(chalk.cyan("Actual behavior: "));
+    let severity = null;
+    while (!severity) {
+      const severityInput = await prompt.ask(chalk.cyan("Severity (LOW/MEDIUM/HIGH/CRITICAL): "));
+      severity = parseSeverity(severityInput);
+      if (!severity) {
+        console.log(chalk.yellow("Invalid severity. Please enter LOW, MEDIUM, HIGH, or CRITICAL."));
+      }
+    }
+    const manager = new BugManager(projectPath);
+    await manager.initialize();
+    const bug = await manager.createBug({
+      title,
+      description,
+      stepsToReproduce,
+      expectedBehavior,
+      actualBehavior,
+      severity
+    });
+    console.log(chalk.green(`
+\u2705 Bug created: ${bug.id}`));
+    console.log(chalk.blue("\n\u{1F50D} Running automated triage..."));
+    const architecture = await loadArchitectureForTriage(projectPath);
+    const triage = new AutoTriage(architecture ?? void 0);
+    const triageResult = await triage.analyzeBug(bug);
+    await manager.updateTriageResult(bug.id, triageResult);
+    console.log(chalk.dim("\nTriage Results:"));
+    console.log(chalk.dim(`  Affected Components: ${triageResult.affectedComponents.join(", ") || "Unknown"}`));
+    console.log(chalk.dim(`  Estimated Severity: ${triageResult.estimatedSeverity}`));
+    console.log(chalk.dim(`  Suggested Priority: ${triageResult.suggestedPriority}`));
+    console.log(chalk.dim(`  Confidence: ${(triageResult.confidence * 100).toFixed(0)}%`));
+    if (triageResult.keywords.length > 0) {
+      console.log(chalk.dim(`  Keywords: ${triageResult.keywords.slice(0, 5).join(", ")}`));
+    }
+    let rcaResult = null;
+    if (!options.skipRca) {
+      const config = await loadConfig();
+      const hasApiKey = !!process.env["ANTHROPIC_API_KEY"] || config.tier === "BYOK";
+      if (hasApiKey) {
+        console.log(chalk.blue("\n\u{1F52C} Generating Root Cause Analysis..."));
+        try {
+          rcaResult = await generateRCA(bug.id, bug.title, bug.description, bug.actualBehavior, triageResult.affectedComponents);
+          await manager.updateRCAResult(bug.id, rcaResult);
+          console.log(chalk.dim("\nRoot Cause Analysis:"));
+          console.log(chalk.dim(`  Likely Cause: ${rcaResult.likelyCause}`));
+          console.log(chalk.dim(`  Suggested Fix: ${rcaResult.suggestedFix}`));
+          console.log(chalk.dim(`  Complexity: ${rcaResult.complexity}`));
+          if (rcaResult.affectedFiles.length > 0) {
+            console.log(chalk.dim(`  Affected Files: ${rcaResult.affectedFiles.slice(0, 3).join(", ")}`));
+          }
+        } catch (error) {
+          console.log(chalk.yellow(`
+\u26A0 RCA generation failed: ${error instanceof Error ? error.message : "Unknown error"}`));
+          console.log(chalk.dim("Continuing without RCA..."));
+        }
+      } else {
+        console.log(chalk.yellow("\n\u26A0 No API key configured. Skipping RCA."));
+        console.log(chalk.dim('Set ANTHROPIC_API_KEY or use "archon keys add anthropic"'));
+      }
+    }
+    console.log(chalk.blue("\n\u{1F4E6} Creating fix atom..."));
+    const acceptanceCriteria = [
+      `Bug ${bug.id} is fixed`,
+      "Regression test added to prevent recurrence",
+      "Typecheck passes",
+      "All tests pass"
+    ];
+    if (rcaResult) {
+      acceptanceCriteria.push(`Fix addresses: ${rcaResult.likelyCause}`);
+    }
+    const atom = createAtom({
+      title: `Fix ${bug.id}: ${bug.title}`,
+      description: buildAtomDescription(bug.id, bug.description, bug.actualBehavior, rcaResult),
+      goals: [`Fix bug ${bug.id}`],
+      acceptanceCriteria,
+      ownershipPaths: rcaResult?.affectedFiles ?? triageResult.relatedFiles,
+      priority: triageResult.suggestedPriority,
+      tags: ["bug-fix", bug.id],
+      metadata: { bugId: bug.id }
+    });
+    await saveAtom(atom);
+    await manager.linkAtom(bug.id, atom.externalId);
+    console.log(chalk.green(`
+\u2705 Atom created: ${atom.externalId}`));
+    console.log(chalk.dim(`   Linked to: ${bug.id}`));
+    console.log(chalk.bold("\n\u{1F4CB} Summary"));
+    console.log(chalk.dim("\u2500".repeat(40)));
+    console.log(`Bug ID: ${chalk.cyan(bug.id)}`);
+    console.log(`Atom ID: ${chalk.cyan(atom.externalId)}`);
+    console.log(`Severity: ${formatSeverity(bug.severity)}`);
+    console.log(`Status: ${chalk.yellow("IN_PROGRESS")}`);
+    console.log(chalk.dim("\nNext steps:"));
+    console.log(chalk.dim(`  - Plan: archon plan ${atom.externalId} --continue`));
+    console.log(chalk.dim(`  - Execute: archon execute ${atom.externalId}`));
+  } finally {
+    prompt.close();
+  }
+}
+function formatSeverity(severity) {
+  switch (severity) {
+    case "CRITICAL":
+      return chalk.red.bold(severity);
+    case "HIGH":
+      return chalk.red(severity);
+    case "MEDIUM":
+      return chalk.yellow(severity);
+    case "LOW":
+      return chalk.green(severity);
+  }
+}
+function buildAtomDescription(bugId, description, actualBehavior, rcaResult) {
+  const parts = [
+    `Fix for ${bugId}`,
+    "",
+    `**Problem:** ${description}`,
+    "",
+    `**Actual Behavior:** ${actualBehavior}`
+  ];
+  if (rcaResult) {
+    parts.push("");
+    parts.push(`**Root Cause:** ${rcaResult.likelyCause}`);
+    parts.push("");
+    parts.push(`**Suggested Fix:** ${rcaResult.suggestedFix}`);
+  }
+  return parts.join("\n");
+}
+async function generateRCA(bugId, title, description, actualBehavior, affectedComponents) {
+  const architect = new ArchitectAgent();
+  const prompt = buildRCAPrompt(bugId, title, description, actualBehavior, affectedComponents);
+  const dummyAtom = createAtom({
+    title: `RCA for ${bugId}`,
+    acceptanceCriteria: ["Identify root cause"]
+  });
+  const dummyArchitecture = {
+    version: "1.0.0",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    profile: "balanced",
+    strictMode: false,
+    systemGoals: [],
+    components: [],
+    invariants: [],
+    protectedPaths: [],
+    cautiousPaths: [],
+    temporaryOverrides: [],
+    environments: {},
+    rawYaml: {},
+    markdownBody: ""
+  };
+  const response = await architect.generatePlan(dummyAtom, dummyArchitecture, {
+    codebasePatterns: [`Bug analysis for ${bugId}`]
+  });
+  return parseRCAResponse(response.reasoning, response.plan);
+}
+function buildRCAPrompt(bugId, title, description, actualBehavior, affectedComponents) {
+  return [
+    `# Root Cause Analysis for ${bugId}`,
+    "",
+    `**Title:** ${title}`,
+    `**Description:** ${description}`,
+    `**Actual Behavior:** ${actualBehavior}`,
+    `**Affected Components:** ${affectedComponents.join(", ") || "Unknown"}`,
+    "",
+    "Analyze this bug and identify:",
+    "1. The likely root cause",
+    "2. Which files are probably affected",
+    "3. A suggested fix approach",
+    "4. Risk assessment for the fix",
+    "5. Complexity estimate (LOW/MEDIUM/HIGH)"
+  ].join("\n");
+}
+function parseRCAResponse(reasoning, plan) {
+  return {
+    likelyCause: reasoning || "Unable to determine root cause",
+    affectedFiles: plan.files_to_modify,
+    suggestedFix: plan.steps.join("; ") || "Further investigation needed",
+    riskAssessment: plan.risks.join("; ") || "No specific risks identified",
+    complexity: normalizeComplexity(plan.estimated_complexity),
+    reasoning
+  };
+}
+function normalizeComplexity(value) {
+  const normalized = value?.toUpperCase();
+  if (normalized === "LOW" || normalized === "MEDIUM" || normalized === "HIGH") {
+    return normalized;
+  }
+  return "MEDIUM";
+}
+async function saveAtom(atom) {
+  const atomsDir = join3(process.cwd(), ATOMS_DIR);
+  if (!existsSync3(atomsDir)) {
+    await mkdir2(atomsDir, { recursive: true });
+  }
+  const atomFile = join3(atomsDir, `${atom.externalId}.json`);
+  await writeFile2(atomFile, JSON.stringify(atom, null, 2));
+}
+
+export {
+  bugReport
+};