archondev 0.1.0 → 1.2.0

package/dist/chunk-UDBFDXJI.js

@@ -0,0 +1,696 @@
+import {
+  ReviewDatabase,
+  ReviewService,
+  analyzeProject,
+  featuresToTasks,
+  readArchitectureContext
+} from "./chunk-VKM3HAHW.js";
+
+// src/cli/review.ts
+import chalk from "chalk";
+import ora from "ora";
+function getReviewDb(cwd) {
+  return new ReviewDatabase(cwd);
+}
+function formatStatus(status) {
+  switch (status) {
+    case "pending":
+      return chalk.yellow("\u23F3 pending");
+    case "in_review":
+      return chalk.blue("\u{1F50D} in_review");
+    case "completed":
+      return chalk.green("\u2713 completed");
+    case "needs_fix":
+      return chalk.red("\u26A0 needs_fix");
+    default:
+      return status;
+  }
+}
+function formatPriority(priority) {
+  switch (priority) {
+    case "critical":
+      return chalk.red.bold("CRITICAL");
+    case "high":
+      return chalk.red("HIGH");
+    case "medium":
+      return chalk.yellow("MEDIUM");
+    case "low":
+      return chalk.blue("LOW");
+    case "none":
+      return chalk.green("NONE");
+    default:
+      return chalk.dim("-");
+  }
+}
+async function reviewInit() {
+  const cwd = process.cwd();
+  const db = getReviewDb(cwd);
+  if (db.isInitialized()) {
+    console.log(chalk.yellow("Code review already initialized in this project."));
+    console.log(chalk.dim("Run `archon review status` to see current status."));
+    console.log(chalk.dim("Run `archon review analyze` to re-analyze the project."));
+    return;
+  }
+  const spinner = ora("Initializing code review database...").start();
+  try {
+    db.open();
+    spinner.succeed(chalk.green("Code review initialized!"));
+    console.log();
+    console.log(chalk.dim("Database created at: docs/code-review/review-tasks.db"));
+    console.log();
+    console.log("Next steps:");
+    console.log(chalk.cyan("  archon review analyze") + " - Analyze project and populate review tasks");
+    console.log(chalk.cyan("  archon review status") + "  - Show review progress");
+  } catch (error) {
+    spinner.fail(chalk.red("Failed to initialize database"));
+    console.error(error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  } finally {
+    db.close();
+  }
+}
+async function reviewAnalyze() {
+  const cwd = process.cwd();
+  const spinner = ora("Analyzing project structure...").start();
+  try {
+    const analysis = await analyzeProject(cwd);
+    spinner.text = "Checking documentation...";
+    const missingDocs = [];
+    if (!analysis.hasArchitecture) missingDocs.push("ARCHITECTURE.md");
+    if (!analysis.hasDataDictionary) missingDocs.push("DATA-DICTIONARY.md");
+    if (!analysis.hasDependencies) missingDocs.push("DEPENDENCIES.md");
+    spinner.text = "Reading architecture context...";
+    const archContext = await readArchitectureContext(cwd);
+    spinner.text = "Populating review tasks...";
+    const db = getReviewDb(cwd);
+    db.open();
+    db.clearAllTasks();
+    const tasks = featuresToTasks(analysis.features, archContext ?? void 0);
+    let taskCount = 0;
+    for (const task of tasks) {
+      db.insertTask(task);
+      taskCount++;
+    }
+    db.close();
+    spinner.succeed(chalk.green("Project analyzed!"));
+    console.log();
+    console.log(chalk.blue("Project:") + ` ${analysis.name}`);
+    console.log(chalk.blue("Files scanned:") + ` ${analysis.files.length}`);
+    console.log(chalk.blue("Features found:") + ` ${analysis.features.length}`);
+    console.log(chalk.blue("Review tasks created:") + ` ${taskCount}`);
+    console.log();
+    const sourceFiles = analysis.files.filter((f) => f.type === "source");
+    const testFiles = analysis.files.filter((f) => f.type === "test");
+    console.log(chalk.dim(`  Source files: ${sourceFiles.length}`));
+    console.log(chalk.dim(`  Test files: ${testFiles.length}`));
+    console.log();
+    if (missingDocs.length > 0) {
+      console.log(chalk.yellow("Missing documentation:"));
+      for (const doc of missingDocs) {
+        console.log(chalk.yellow(`  \u25CB ${doc}`));
+      }
+      console.log(chalk.dim("Consider creating these for better review context."));
+      console.log();
+    } else {
+      console.log(chalk.green("\u2713 All documentation present"));
+      console.log();
+    }
+    const categories = /* @__PURE__ */ new Map();
+    for (const feature of analysis.features) {
+      categories.set(feature.category, (categories.get(feature.category) ?? 0) + 1);
+    }
+    console.log(chalk.blue("Categories:"));
+    for (const [category, count] of Array.from(categories.entries()).sort()) {
+      console.log(`  ${category}: ${count} features`);
+    }
+    console.log();
+    console.log("Next steps:");
+    console.log(chalk.cyan("  archon review status") + " - Show review progress");
+    console.log(chalk.cyan("  archon review next") + "   - Get next task to review");
+  } catch (error) {
+    spinner.fail(chalk.red("Analysis failed"));
+    console.error(error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+}
+async function reviewStatus() {
+  const cwd = process.cwd();
+  const db = getReviewDb(cwd);
+  if (!db.isInitialized()) {
+    console.log(chalk.yellow("Code review not initialized."));
+    console.log(chalk.dim("Run `archon review init` to get started."));
+    return;
+  }
+  db.open();
+  const stats = db.getStats();
+  db.close();
+  console.log(chalk.green("Code Review Status"));
+  console.log();
+  const completed = stats.completed + stats.needsFix;
+  const total = stats.total || 1;
+  const progress = Math.round(completed / total * 100);
+  const barWidth = 30;
+  const filledWidth = Math.round(completed / total * barWidth);
+  const bar = "\u2588".repeat(filledWidth) + "\u2591".repeat(barWidth - filledWidth);
+  console.log(chalk.blue("Progress:") + ` [${bar}] ${progress}%`);
+  console.log();
+  console.log(chalk.blue("Tasks:"));
+  console.log(`  Total:      ${stats.total}`);
+  console.log(`  Pending:    ${chalk.yellow(String(stats.pending))}`);
+  console.log(`  In Review:  ${chalk.blue(String(stats.inReview))}`);
+  console.log(`  Completed:  ${chalk.green(String(stats.completed))}`);
+  console.log(`  Needs Fix:  ${chalk.red(String(stats.needsFix))}`);
+  console.log();
+  if (stats.passing > 0 || stats.failing > 0) {
+    console.log(chalk.blue("Results:"));
+    console.log(`  Passing:    ${chalk.green(String(stats.passing))}`);
+    console.log(`  Failing:    ${chalk.red(String(stats.failing))}`);
+    console.log();
+  }
+  if (stats.pending > 0) {
+    console.log(chalk.dim("Run `archon review next` to get the next task."));
+  } else if (stats.needsFix > 0) {
+    console.log(chalk.dim("Run `archon review plan` to generate fix plans."));
+  } else if (stats.total > 0) {
+    console.log(chalk.green("\u2713 All tasks reviewed!"));
+  }
+}
+async function reviewNext() {
+  const cwd = process.cwd();
+  const db = getReviewDb(cwd);
+  if (!db.isInitialized()) {
+    console.log(chalk.yellow("Code review not initialized."));
+    console.log(chalk.dim("Run `archon review init` to get started."));
+    return;
+  }
+  db.open();
+  const task = db.getNextPendingTask();
+  db.close();
+  if (!task) {
+    console.log(chalk.green("No pending tasks!"));
+    console.log(chalk.dim("All tasks have been reviewed."));
+    return;
+  }
+  printTaskDetails(task);
+  console.log();
+  console.log(chalk.blue("Instructions:"));
+  console.log("  1. Review the files listed above");
+  console.log("  2. Compare implementation against expected behavior");
+  console.log("  3. Document any issues found");
+  console.log("  4. Update the task with your findings:");
+  console.log();
+  console.log(chalk.cyan(`  archon review update ${task.id} --status completed --passes true`));
+  console.log("  or");
+  console.log(chalk.cyan(`  archon review update ${task.id} --status needs_fix --issues '[{"type":"bug","severity":"high","description":"..."}]' --fix-plan "..."`));
+}
+async function reviewShow(idStr) {
+  const id = parseInt(idStr, 10);
+  if (isNaN(id)) {
+    console.error(chalk.red("Invalid task ID"));
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  const db = getReviewDb(cwd);
+  if (!db.isInitialized()) {
+    console.log(chalk.yellow("Code review not initialized."));
+    return;
+  }
+  db.open();
+  const task = db.getTask(id);
+  db.close();
+  if (!task) {
+    console.error(chalk.red(`Task ${id} not found`));
+    process.exit(1);
+  }
+  printTaskDetails(task);
+}
+function printTaskDetails(task) {
+  console.log(chalk.green(`Review Task #${task.id}`));
+  console.log();
+  console.log(chalk.blue("Feature:") + ` ${task.featureName}`);
+  console.log(chalk.blue("Category:") + ` ${task.category}${task.subcategory ? `/${task.subcategory}` : ""}`);
+  console.log(chalk.blue("Status:") + ` ${formatStatus(task.status)}`);
+  console.log();
+  if (task.filesToCheck && task.filesToCheck.length > 0) {
+    console.log(chalk.blue("Files to check:"));
+    for (const file of task.filesToCheck.slice(0, 10)) {
+      console.log(`  - ${file}`);
+    }
+    if (task.filesToCheck.length > 10) {
+      console.log(chalk.dim(`  ... and ${task.filesToCheck.length - 10} more`));
+    }
+    console.log();
+  }
+  if (task.expectedBehavior) {
+    console.log(chalk.blue("Expected Behavior:"));
+    console.log(`  ${task.expectedBehavior}`);
+    console.log();
+  }
+  if (task.acceptanceCriteria && task.acceptanceCriteria.length > 0) {
+    console.log(chalk.blue("Acceptance Criteria:"));
+    for (const criterion of task.acceptanceCriteria) {
+      console.log(`  \u2022 ${criterion}`);
+    }
+    console.log();
+  }
+  if (task.architectureContext) {
+    console.log(chalk.blue("Architecture Context:"));
+    console.log(chalk.dim(task.architectureContext.slice(0, 500)));
+    if (task.architectureContext.length > 500) {
+      console.log(chalk.dim("..."));
+    }
+    console.log();
+  }
+  if (task.status === "completed" || task.status === "needs_fix") {
+    console.log(chalk.blue("Review Results:"));
+    console.log(`  Passes: ${task.passesReview ? chalk.green("Yes") : chalk.red("No")}`);
+    console.log(`  Priority: ${formatPriority(task.fixPriority)}`);
+    if (task.issuesFound && task.issuesFound.length > 0) {
+      console.log();
+      console.log(chalk.blue("Issues Found:"));
+      for (const issue of task.issuesFound) {
+        console.log(`  [${issue.severity.toUpperCase()}] ${issue.type}: ${issue.description}`);
+        if (issue.location) {
+          console.log(chalk.dim(`    Location: ${issue.location}`));
+        }
+        if (issue.suggestion) {
+          console.log(chalk.dim(`    Suggestion: ${issue.suggestion}`));
+        }
+      }
+    }
+    if (task.fixPlan) {
+      console.log();
+      console.log(chalk.blue("Fix Plan:"));
+      console.log(`  ${task.fixPlan}`);
+    }
+  }
+  if (task.reviewedBy) {
+    console.log();
+    console.log(chalk.dim(`Reviewed by: ${task.reviewedBy}`));
+    console.log(chalk.dim(`Reviewed at: ${task.reviewedAt}`));
+  }
+}
+async function reviewUpdate(idStr, options) {
+  const id = parseInt(idStr, 10);
+  if (isNaN(id)) {
+    console.error(chalk.red("Invalid task ID"));
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  const db = getReviewDb(cwd);
+  if (!db.isInitialized()) {
+    console.log(chalk.yellow("Code review not initialized."));
+    return;
+  }
+  db.open();
+  const task = db.getTask(id);
+  if (!task) {
+    db.close();
+    console.error(chalk.red(`Task ${id} not found`));
+    process.exit(1);
+  }
+  const validStatuses = ["pending", "in_review", "completed", "needs_fix"];
+  const validPriorities = ["critical", "high", "medium", "low", "none"];
+  if (options.status && !validStatuses.includes(options.status)) {
+    db.close();
+    console.error(chalk.red(`Invalid status. Must be one of: ${validStatuses.join(", ")}`));
+    process.exit(1);
+  }
+  if (options.priority && !validPriorities.includes(options.priority)) {
+    db.close();
+    console.error(chalk.red(`Invalid priority. Must be one of: ${validPriorities.join(", ")}`));
+    process.exit(1);
+  }
+  let parsedIssues;
+  if (options.issues) {
+    try {
+      parsedIssues = JSON.parse(options.issues);
+    } catch {
+      db.close();
+      console.error(chalk.red("Invalid issues JSON format"));
+      process.exit(1);
+    }
+  }
+  const success = db.updateTask(id, {
+    status: options.status,
+    passesReview: options.passes,
+    issuesFound: parsedIssues,
+    fixPlan: options.fixPlan,
+    fixPriority: options.priority,
+    architectureImpact: options.impact,
+    reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    reviewedBy: "cli-user"
+  });
+  db.close();
+  if (success) {
+    console.log(chalk.green(`Task ${id} updated successfully`));
+  } else {
+    console.error(chalk.red("Failed to update task"));
+    process.exit(1);
+  }
+}
+async function reviewList(options) {
+  const cwd = process.cwd();
+  const db = getReviewDb(cwd);
+  if (!db.isInitialized()) {
+    console.log(chalk.yellow("Code review not initialized."));
+    return;
+  }
+  db.open();
+  let tasks;
+  if (options.status) {
+    const validStatuses = ["pending", "in_review", "completed", "needs_fix"];
+    if (!validStatuses.includes(options.status)) {
+      db.close();
+      console.error(chalk.red(`Invalid status. Must be one of: ${validStatuses.join(", ")}`));
+      process.exit(1);
+    }
+    tasks = db.getTasksByStatus(options.status);
+  } else {
+    tasks = db.getAllTasks();
+  }
+  db.close();
+  if (options.category) {
+    tasks = tasks.filter((t) => t.category === options.category);
+  }
+  if (tasks.length === 0) {
+    console.log(chalk.yellow("No tasks found matching criteria."));
+    return;
+  }
+  console.log(chalk.green(`Review Tasks (${tasks.length})`));
+  console.log();
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    if (!byCategory.has(task.category)) {
+      byCategory.set(task.category, []);
+    }
+    byCategory.get(task.category)?.push(task);
+  }
+  for (const [category, categoryTasks] of byCategory) {
+    console.log(chalk.blue(category.toUpperCase()));
+    for (const task of categoryTasks) {
+      const statusStr = formatStatus(task.status);
+      const priorityStr = task.fixPriority ? ` ${formatPriority(task.fixPriority)}` : "";
+      console.log(`  #${task.id} ${task.featureName} ${statusStr}${priorityStr}`);
+    }
+    console.log();
+  }
+}
+async function reviewPlan() {
+  const cwd = process.cwd();
+  const db = getReviewDb(cwd);
+  if (!db.isInitialized()) {
+    console.log(chalk.yellow("Code review not initialized."));
+    return;
+  }
+  db.open();
+  const stats = db.getStats();
+  const tasksNeedingFix = db.getTasksNeedingFix();
+  db.close();
+  if (stats.pending > 0) {
+    console.log(chalk.yellow(`${stats.pending} tasks still pending review.`));
+    console.log(chalk.dim("Complete all reviews before generating fix plan."));
+    console.log(chalk.dim("Run `archon review next` to continue reviewing."));
+    return;
+  }
+  if (tasksNeedingFix.length === 0) {
+    console.log(chalk.green("No fixes needed! All tasks passed review."));
+    return;
+  }
+  console.log(chalk.green("Fix Plan"));
+  console.log();
+  console.log(chalk.dim(`Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`));
+  console.log();
+  const byPriority = /* @__PURE__ */ new Map();
+  for (const task of tasksNeedingFix) {
+    const priority = task.fixPriority ?? "none";
+    if (!byPriority.has(priority)) {
+      byPriority.set(priority, []);
+    }
+    byPriority.get(priority)?.push(task);
+  }
+  const priorityOrder = ["critical", "high", "medium", "low", "none"];
+  for (const priority of priorityOrder) {
+    const priorityTasks = byPriority.get(priority);
+    if (!priorityTasks || priorityTasks.length === 0) continue;
+    console.log(formatPriority(priority) + ` (${priorityTasks.length})`);
+    console.log();
+    for (const task of priorityTasks) {
+      console.log(chalk.blue(`  #${task.id} ${task.featureName}`));
+      if (task.issuesFound && task.issuesFound.length > 0) {
+        console.log(chalk.dim("    Issues:"));
+        for (const issue of task.issuesFound) {
+          console.log(`      - [${issue.severity}] ${issue.description}`);
+        }
+      }
+      if (task.fixPlan) {
+        console.log(chalk.dim("    Fix Plan:"));
+        console.log(`      ${task.fixPlan}`);
+      }
+      if (task.architectureImpact) {
+        console.log(chalk.yellow("    \u26A0 Architecture Impact:"));
+        console.log(`      ${task.architectureImpact}`);
+      }
+      console.log();
+    }
+  }
+  console.log(chalk.blue("Summary:"));
+  console.log(`  Total fixes needed: ${tasksNeedingFix.length}`);
+  console.log(`  Critical: ${byPriority.get("critical")?.length ?? 0}`);
+  console.log(`  High: ${byPriority.get("high")?.length ?? 0}`);
+  console.log(`  Medium: ${byPriority.get("medium")?.length ?? 0}`);
+  console.log(`  Low: ${byPriority.get("low")?.length ?? 0}`);
+  console.log();
+  console.log(chalk.dim("Address critical and high priority issues first."));
+  console.log(chalk.dim("Run `archon review export` to save this report."));
+}
+async function reviewExport(options) {
+  const cwd = process.cwd();
+  const db = getReviewDb(cwd);
+  if (!db.isInitialized()) {
+    console.log(chalk.yellow("Code review not initialized."));
+    return;
+  }
+  db.open();
+  const tasks = db.getAllTasks();
+  const stats = db.getStats();
+  db.close();
+  const analysis = await analyzeProject(cwd);
+  const format = options.format ?? "markdown";
+  if (format === "json") {
+    const report = {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      projectName: analysis.name,
+      projectPath: analysis.path,
+      stats,
+      tasks
+    };
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(`# Code Review Report`);
+    console.log();
+    console.log(`**Project:** ${analysis.name}`);
+    console.log(`**Generated:** ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    console.log();
+    console.log(`## Summary`);
+    console.log();
+    console.log(`| Metric | Value |`);
+    console.log(`|--------|-------|`);
+    console.log(`| Total Tasks | ${stats.total} |`);
+    console.log(`| Completed | ${stats.completed} |`);
+    console.log(`| Needs Fix | ${stats.needsFix} |`);
+    console.log(`| Passing | ${stats.passing} |`);
+    console.log(`| Failing | ${stats.failing} |`);
+    console.log();
+    if (tasks.some((t) => t.status === "needs_fix")) {
+      console.log(`## Issues Found`);
+      console.log();
+      for (const task of tasks.filter((t) => t.status === "needs_fix")) {
+        console.log(`### ${task.featureName} (${task.category})`);
+        console.log();
+        console.log(`**Priority:** ${task.fixPriority ?? "not set"}`);
+        console.log();
+        if (task.issuesFound && task.issuesFound.length > 0) {
+          console.log(`**Issues:**`);
+          for (const issue of task.issuesFound) {
+            console.log(`- [${issue.severity.toUpperCase()}] ${issue.type}: ${issue.description}`);
+          }
+          console.log();
+        }
+        if (task.fixPlan) {
+          console.log(`**Fix Plan:** ${task.fixPlan}`);
+          console.log();
+        }
+      }
+    }
+  }
+}
+async function reviewRun(options) {
+  const cwd = process.cwd();
+  const db = getReviewDb(cwd);
+  if (!db.isInitialized()) {
+    console.log(chalk.yellow("Code review not initialized."));
+    console.log(chalk.dim("Run `archon review init` to get started."));
+    return;
+  }
+  db.open();
+  const stats = db.getStats();
+  db.close();
+  if (stats.pending === 0 && !options.taskId) {
+    console.log(chalk.green("No pending tasks to review."));
+    return;
+  }
+  if (!process.env["ANTHROPIC_API_KEY"]) {
+    console.log(chalk.yellow("ANTHROPIC_API_KEY not set."));
+    console.log(chalk.dim("Set the environment variable or use BYOK with `archon keys add anthropic`."));
+    return;
+  }
+  const service = new ReviewService({
+    projectPath: cwd,
+    apiKey: process.env["ANTHROPIC_API_KEY"],
+    maxFilesPerTask: 10,
+    onTaskStart: (task) => {
+      console.log(chalk.blue(`
+\u{1F50D} Reviewing: ${task.featureName} (#${task.id})`));
+    },
+    onTaskComplete: (task, result) => {
+      if (result.passesReview) {
+        console.log(chalk.green(`  \u2713 PASSED`));
+      } else {
+        console.log(chalk.red(`  \u2717 NEEDS FIX (${result.issues.length} issues)`));
+        for (const issue of result.issues.slice(0, 3)) {
+          console.log(chalk.dim(`    - [${issue.severity}] ${issue.description.slice(0, 60)}...`));
+        }
+      }
+    },
+    onError: (task, error) => {
+      console.log(chalk.red(`  \u2717 ERROR: ${error.message}`));
+    }
+  });
+  try {
+    await service.initialize();
+    if (options.taskId) {
+      const id = parseInt(options.taskId, 10);
+      if (isNaN(id)) {
+        console.error(chalk.red("Invalid task ID"));
+        process.exit(1);
+      }
+      const spinner = ora(`Running AI review on task #${id}...`).start();
+      try {
+        const result = await service.reviewTask(id);
+        spinner.stop();
+        console.log();
+        printReviewResult(id, result);
+      } catch (error) {
+        spinner.fail(chalk.red("Review failed"));
+        console.error(error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+      }
+    } else if (options.all) {
+      const limit = options.limit ? parseInt(options.limit, 10) : void 0;
+      const spinner = ora(`Running AI review on ${limit ?? "all"} pending tasks...`).start();
+      try {
+        spinner.stop();
+        console.log(chalk.green(`Starting AI Review`));
+        console.log(chalk.dim(`Pending tasks: ${stats.pending}`));
+        if (limit) {
+          console.log(chalk.dim(`Limit: ${limit}`));
+        }
+        const result = await service.reviewAllPending(limit);
+        console.log();
+        console.log(chalk.green("Review Complete"));
+        console.log();
+        console.log(chalk.blue("Results:"));
+        console.log(`  Reviewed: ${result.tasksReviewed}`);
+        console.log(`  Passed:   ${chalk.green(String(result.tasksPassed))}`);
+        console.log(`  Failed:   ${chalk.red(String(result.tasksFailed))}`);
+        if (result.tasksErrored > 0) {
+          console.log(`  Errors:   ${chalk.yellow(String(result.tasksErrored))}`);
+        }
+        console.log();
+        console.log(chalk.blue("Token Usage:"));
+        console.log(`  Input:    ${result.totalUsage.inputTokens.toLocaleString()}`);
+        console.log(`  Output:   ${result.totalUsage.outputTokens.toLocaleString()}`);
+        console.log(`  Cost:     $${result.totalUsage.baseCost.toFixed(4)}`);
+      } catch (error) {
+        spinner.fail(chalk.red("Review failed"));
+        console.error(error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+      }
+    } else {
+      const spinner = ora("Running AI review on next pending task...").start();
+      try {
+        const reviewResult = await service.reviewNext();
+        spinner.stop();
+        if (!reviewResult) {
+          console.log(chalk.green("No pending tasks."));
+          return;
+        }
+        console.log();
+        printReviewResult(reviewResult.task.id, reviewResult.result);
+      } catch (error) {
+        spinner.fail(chalk.red("Review failed"));
+        console.error(error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+      }
+    }
+    const finalStats = service.getStats();
+    if (finalStats.pending > 0) {
+      console.log();
+      console.log(chalk.dim(`${finalStats.pending} tasks still pending.`));
+      console.log(chalk.dim("Run `archon review run --all` to review all."));
+    } else if (finalStats.needsFix > 0) {
+      console.log();
+      console.log(chalk.dim(`${finalStats.needsFix} tasks need fixes.`));
+      console.log(chalk.dim("Run `archon review plan` to see the fix plan."));
+    }
+  } finally {
+    service.close();
+  }
+}
+function printReviewResult(taskId, result) {
+  console.log(chalk.green(`Review Result for Task #${taskId}`));
+  console.log();
+  if (result.passesReview) {
+    console.log(chalk.green.bold("  \u2713 PASSED"));
+  } else {
+    console.log(chalk.red.bold("  \u2717 NEEDS FIX"));
+    console.log();
+    console.log(chalk.blue("Issues Found:"));
+    for (const issue of result.issues) {
+      const severityColor = issue.severity === "critical" ? chalk.red.bold : issue.severity === "high" ? chalk.red : issue.severity === "medium" ? chalk.yellow : chalk.blue;
+      console.log(`  ${severityColor(`[${issue.severity.toUpperCase()}]`)} ${issue.type}: ${issue.description}`);
+      if (issue.location) {
+        console.log(chalk.dim(`    at ${issue.location}`));
+      }
+      if (issue.suggestion) {
+        console.log(chalk.dim(`    \u2192 ${issue.suggestion}`));
+      }
+    }
+  }
+  if (result.fixPlan) {
+    console.log();
+    console.log(chalk.blue("Fix Plan:"));
+    console.log(`  ${result.fixPlan}`);
+  }
+  if (result.architectureImpact) {
+    console.log();
+    console.log(chalk.yellow("Architecture Impact:"));
+    console.log(`  ${result.architectureImpact}`);
+  }
+  console.log();
+  console.log(chalk.dim(`Tokens: ${result.usage.totalTokens.toLocaleString()} | Cost: $${result.usage.baseCost.toFixed(4)}`));
+}
+
+export {
+  reviewInit,
+  reviewAnalyze,
+  reviewStatus,
+  reviewNext,
+  reviewShow,
+  reviewUpdate,
+  reviewList,
+  reviewPlan,
+  reviewExport,
+  reviewRun
+};