archondev 0.1.0 → 1.2.0

package/dist/chunk-VKM3HAHW.js

@@ -0,0 +1,832 @@
+import {
+  AnthropicClient,
+  getDefaultModel
+} from "./chunk-A7QU6JC6.js";
+
+// src/core/code-review/database.ts
+import Database from "better-sqlite3";
+import { join, dirname } from "path";
+import { mkdirSync, existsSync } from "fs";
+var REVIEW_DB_PATH = "docs/code-review/review-tasks.db";
+var CREATE_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS review_tasks (
+  id INTEGER PRIMARY KEY,
+  
+  -- Task Definition
+  category TEXT NOT NULL,
+  subcategory TEXT,
+  feature_name TEXT NOT NULL,
+  user_story TEXT,
+  acceptance_criteria TEXT,
+  technical_requirements TEXT,
+  expected_behavior TEXT,
+  edge_cases TEXT,
+  integration_points TEXT,
+  verification_steps TEXT,
+  files_to_check TEXT,
+  dependencies TEXT,
+  data_contracts TEXT,
+  
+  -- Architecture Context
+  architecture_context TEXT,
+  
+  -- Review Tracking
+  status TEXT DEFAULT 'pending',
+  reviewed_by TEXT,
+  reviewed_at TEXT,
+  
+  -- Findings
+  passes_review INTEGER,
+  issues_found TEXT,
+  fix_priority TEXT,
+  fix_plan TEXT,
+  architecture_impact TEXT,
+  related_bugs TEXT,
+  
+  -- Metadata
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_review_tasks_status ON review_tasks(status);
+CREATE INDEX IF NOT EXISTS idx_review_tasks_category ON review_tasks(category);
+CREATE INDEX IF NOT EXISTS idx_review_tasks_priority ON review_tasks(fix_priority);
+`;
+var ReviewDatabase = class {
+  db = null;
+  projectPath;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  getDbPath() {
+    return join(this.projectPath, REVIEW_DB_PATH);
+  }
+  isInitialized() {
+    return existsSync(this.getDbPath());
+  }
+  open() {
+    if (this.db) return;
+    const dbPath = this.getDbPath();
+    const dbDir = dirname(dbPath);
+    if (!existsSync(dbDir)) {
+      mkdirSync(dbDir, { recursive: true });
+    }
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.exec(CREATE_TABLE_SQL);
+  }
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  ensureOpen() {
+    if (!this.db) {
+      throw new Error("Database not open. Call open() first.");
+    }
+    return this.db;
+  }
+  rowToTask(row) {
+    return {
+      id: row["id"],
+      category: row["category"],
+      subcategory: row["subcategory"],
+      featureName: row["feature_name"],
+      userStory: row["user_story"],
+      acceptanceCriteria: row["acceptance_criteria"] ? JSON.parse(row["acceptance_criteria"]) : null,
+      technicalRequirements: row["technical_requirements"],
+      expectedBehavior: row["expected_behavior"],
+      edgeCases: row["edge_cases"],
+      integrationPoints: row["integration_points"] ? JSON.parse(row["integration_points"]) : null,
+      verificationSteps: row["verification_steps"],
+      filesToCheck: row["files_to_check"] ? JSON.parse(row["files_to_check"]) : null,
+      dependencies: row["dependencies"] ? JSON.parse(row["dependencies"]) : null,
+      dataContracts: row["data_contracts"] ? JSON.parse(row["data_contracts"]) : null,
+      architectureContext: row["architecture_context"],
+      status: row["status"],
+      reviewedBy: row["reviewed_by"],
+      reviewedAt: row["reviewed_at"],
+      passesReview: row["passes_review"] === null ? null : row["passes_review"] === 1,
+      issuesFound: row["issues_found"] ? JSON.parse(row["issues_found"]) : null,
+      fixPriority: row["fix_priority"],
+      fixPlan: row["fix_plan"],
+      architectureImpact: row["architecture_impact"],
+      relatedBugs: row["related_bugs"],
+      createdAt: row["created_at"],
+      updatedAt: row["updated_at"]
+    };
+  }
+  insertTask(task) {
+    const db = this.ensureOpen();
+    const stmt = db.prepare(`
+      INSERT INTO review_tasks (
+        category, subcategory, feature_name, user_story, acceptance_criteria,
+        technical_requirements, expected_behavior, edge_cases, integration_points,
+        verification_steps, files_to_check, dependencies, data_contracts,
+        architecture_context
+      ) VALUES (
+        ?, ?, ?, ?, ?,
+        ?, ?, ?, ?,
+        ?, ?, ?, ?,
+        ?
+      )
+    `);
+    const result = stmt.run(
+      task.category,
+      task.subcategory ?? null,
+      task.featureName,
+      task.userStory ?? null,
+      task.acceptanceCriteria ? JSON.stringify(task.acceptanceCriteria) : null,
+      task.technicalRequirements ?? null,
+      task.expectedBehavior ?? null,
+      task.edgeCases ?? null,
+      task.integrationPoints ? JSON.stringify(task.integrationPoints) : null,
+      task.verificationSteps ?? null,
+      task.filesToCheck ? JSON.stringify(task.filesToCheck) : null,
+      task.dependencies ? JSON.stringify(task.dependencies) : null,
+      task.dataContracts ? JSON.stringify(task.dataContracts) : null,
+      task.architectureContext ?? null
+    );
+    return Number(result.lastInsertRowid);
+  }
+  updateTask(id, update) {
+    const db = this.ensureOpen();
+    const fields = [];
+    const values = [];
+    if (update.status !== void 0) {
+      fields.push("status = ?");
+      values.push(update.status);
+    }
+    if (update.reviewedBy !== void 0) {
+      fields.push("reviewed_by = ?");
+      values.push(update.reviewedBy);
+    }
+    if (update.reviewedAt !== void 0) {
+      fields.push("reviewed_at = ?");
+      values.push(update.reviewedAt);
+    }
+    if (update.passesReview !== void 0) {
+      fields.push("passes_review = ?");
+      values.push(update.passesReview ? 1 : 0);
+    }
+    if (update.issuesFound !== void 0) {
+      fields.push("issues_found = ?");
+      values.push(JSON.stringify(update.issuesFound));
+    }
+    if (update.fixPriority !== void 0) {
+      fields.push("fix_priority = ?");
+      values.push(update.fixPriority);
+    }
+    if (update.fixPlan !== void 0) {
+      fields.push("fix_plan = ?");
+      values.push(update.fixPlan);
+    }
+    if (update.architectureImpact !== void 0) {
+      fields.push("architecture_impact = ?");
+      values.push(update.architectureImpact);
+    }
+    if (update.relatedBugs !== void 0) {
+      fields.push("related_bugs = ?");
+      values.push(update.relatedBugs);
+    }
+    if (fields.length === 0) {
+      return false;
+    }
+    fields.push("updated_at = datetime('now')");
+    values.push(id);
+    const stmt = db.prepare(`UPDATE review_tasks SET ${fields.join(", ")} WHERE id = ?`);
+    const result = stmt.run(...values);
+    return result.changes > 0;
+  }
+  getTask(id) {
+    const db = this.ensureOpen();
+    const row = db.prepare("SELECT * FROM review_tasks WHERE id = ?").get(id);
+    return row ? this.rowToTask(row) : null;
+  }
+  getAllTasks() {
+    const db = this.ensureOpen();
+    const rows = db.prepare("SELECT * FROM review_tasks ORDER BY id").all();
+    return rows.map((row) => this.rowToTask(row));
+  }
+  getTasksByStatus(status) {
+    const db = this.ensureOpen();
+    const rows = db.prepare("SELECT * FROM review_tasks WHERE status = ? ORDER BY id").all(status);
+    return rows.map((row) => this.rowToTask(row));
+  }
+  getNextPendingTask() {
+    const db = this.ensureOpen();
+    const row = db.prepare("SELECT * FROM review_tasks WHERE status = ? ORDER BY id LIMIT 1").get("pending");
+    return row ? this.rowToTask(row) : null;
+  }
+  getTasksNeedingFix() {
+    const db = this.ensureOpen();
+    const rows = db.prepare(`
+      SELECT * FROM review_tasks 
+      WHERE status = 'needs_fix' 
+      ORDER BY 
+        CASE fix_priority 
+          WHEN 'critical' THEN 1 
+          WHEN 'high' THEN 2 
+          WHEN 'medium' THEN 3 
+          WHEN 'low' THEN 4 
+          ELSE 5 
+        END,
+        id
+    `).all();
+    return rows.map((row) => this.rowToTask(row));
+  }
+  getStats() {
+    const db = this.ensureOpen();
+    const total = db.prepare("SELECT COUNT(*) as count FROM review_tasks").get().count;
+    const pending = db.prepare("SELECT COUNT(*) as count FROM review_tasks WHERE status = 'pending'").get().count;
+    const inReview = db.prepare("SELECT COUNT(*) as count FROM review_tasks WHERE status = 'in_review'").get().count;
+    const completed = db.prepare("SELECT COUNT(*) as count FROM review_tasks WHERE status = 'completed'").get().count;
+    const needsFix = db.prepare("SELECT COUNT(*) as count FROM review_tasks WHERE status = 'needs_fix'").get().count;
+    const passing = db.prepare("SELECT COUNT(*) as count FROM review_tasks WHERE passes_review = 1").get().count;
+    const failing = db.prepare("SELECT COUNT(*) as count FROM review_tasks WHERE passes_review = 0").get().count;
+    return { total, pending, inReview, completed, needsFix, passing, failing };
+  }
+  clearAllTasks() {
+    const db = this.ensureOpen();
+    db.prepare("DELETE FROM review_tasks").run();
+  }
+  deleteTask(id) {
+    const db = this.ensureOpen();
+    const result = db.prepare("DELETE FROM review_tasks WHERE id = ?").run(id);
+    return result.changes > 0;
+  }
+};
+
+// src/core/code-review/analyzer.ts
+import { readdir, readFile } from "fs/promises";
+import { join as join2, extname, basename, relative } from "path";
+import { existsSync as existsSync2 } from "fs";
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "coverage",
+  "__pycache__",
+  ".pytest_cache",
+  "venv",
+  ".venv",
+  "target",
+  ".idea",
+  ".vscode"
+]);
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".rb",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".swift",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".cs",
+  ".php",
+  ".vue",
+  ".svelte"
+]);
+var CONFIG_FILES = /* @__PURE__ */ new Set([
+  "package.json",
+  "tsconfig.json",
+  "vite.config.ts",
+  "vitest.config.ts",
+  "webpack.config.js",
+  "rollup.config.js",
+  "babel.config.js",
+  "Cargo.toml",
+  "go.mod",
+  "requirements.txt",
+  "Gemfile",
+  "pom.xml",
+  "build.gradle",
+  "Makefile",
+  "CMakeLists.txt",
+  ".eslintrc",
+  ".prettierrc",
+  "jest.config.js"
+]);
+function getFileType(filepath) {
+  const name = basename(filepath);
+  const ext = extname(filepath);
+  if (name.includes(".test.") || name.includes(".spec.") || filepath.includes("__tests__")) {
+    return "test";
+  }
+  if (CONFIG_FILES.has(name) || name.startsWith(".") || ext === ".json" || ext === ".yaml" || ext === ".yml") {
+    return "config";
+  }
+  if (ext === ".md" || ext === ".txt" || ext === ".rst" || filepath.includes("/docs/")) {
+    return "docs";
+  }
+  if (SOURCE_EXTENSIONS.has(ext)) {
+    return "source";
+  }
+  return "other";
+}
+function getLanguage(filepath) {
+  const ext = extname(filepath);
+  const langMap = {
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".py": "python",
+    ".rb": "ruby",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".swift": "swift",
+    ".c": "c",
+    ".cpp": "cpp",
+    ".cs": "csharp",
+    ".php": "php",
+    ".vue": "vue",
+    ".svelte": "svelte"
+  };
+  return langMap[ext];
+}
+async function countLines(filepath) {
+  try {
+    const content = await readFile(filepath, "utf-8");
+    return content.split("\n").length;
+  } catch {
+    return 0;
+  }
+}
+async function scanDirectory(dir, baseDir, files, depth = 0) {
+  if (depth > 10) return;
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join2(dir, entry.name);
+      const relativePath = relative(baseDir, fullPath);
+      if (entry.isDirectory()) {
+        if (!IGNORE_DIRS.has(entry.name)) {
+          await scanDirectory(fullPath, baseDir, files, depth + 1);
+        }
+      } else if (entry.isFile()) {
+        const fileType = getFileType(relativePath);
+        if (fileType !== "other" || SOURCE_EXTENSIONS.has(extname(entry.name))) {
+          const language = getLanguage(relativePath);
+          const lines = fileType === "source" ? await countLines(fullPath) : void 0;
+          files.push({
+            path: relativePath,
+            type: fileType,
+            language,
+            lines
+          });
+        }
+      }
+    }
+  } catch {
+  }
+}
+function inferFeatures(files, projectPath) {
+  const features = [];
+  const featureMap = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    if (file.type !== "source") continue;
+    const parts = file.path.split("/");
+    if (parts.length < 2) continue;
+    const category = parts[0] ?? "root";
+    const feature = parts[1] ?? "main";
+    const key = `${category}/${feature}`;
+    if (!featureMap.has(key)) {
+      featureMap.set(key, /* @__PURE__ */ new Set());
+    }
+    featureMap.get(key)?.add(file.path);
+  }
+  for (const [key, filePaths] of featureMap) {
+    const [category, feature] = key.split("/");
+    if (!category || !feature) continue;
+    features.push({
+      name: feature,
+      category,
+      files: Array.from(filePaths)
+    });
+  }
+  features.sort((a, b) => {
+    if (a.category !== b.category) return a.category.localeCompare(b.category);
+    return a.name.localeCompare(b.name);
+  });
+  return features;
+}
+async function analyzeProject(projectPath) {
+  const name = basename(projectPath);
+  const files = [];
+  await scanDirectory(projectPath, projectPath, files);
+  const hasArchitecture = existsSync2(join2(projectPath, "ARCHITECTURE.md"));
+  const hasDataDictionary = existsSync2(join2(projectPath, "DATA-DICTIONARY.md"));
+  const hasDependencies = existsSync2(join2(projectPath, "DEPENDENCIES.md"));
+  const hasReviewDb = existsSync2(join2(projectPath, "docs/code-review/review-tasks.db"));
+  const features = inferFeatures(files, projectPath);
+  return {
+    name,
+    path: projectPath,
+    hasArchitecture,
+    hasDataDictionary,
+    hasDependencies,
+    hasReviewDb,
+    features,
+    files
+  };
+}
+function featuresToTasks(features, architectureContext) {
+  return features.map((feature) => ({
+    category: feature.category,
+    featureName: feature.name,
+    filesToCheck: feature.files,
+    expectedBehavior: feature.description,
+    architectureContext
+  }));
+}
+async function readArchitectureContext(projectPath) {
+  const archPath = join2(projectPath, "ARCHITECTURE.md");
+  if (!existsSync2(archPath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(archPath, "utf-8");
+    return content.slice(0, 2e3);
+  } catch {
+    return null;
+  }
+}
+
+// src/agents/reviewer.ts
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+var SYSTEM_PROMPT = `You are a meticulous Code Reviewer, responsible for analyzing code quality, correctness, and adherence to specifications.
+
+Your role:
+- Review code files against provided specifications and acceptance criteria
+- Identify bugs, security issues, performance problems, and architectural violations
+- Document issues with specific file locations and actionable suggestions
+- Be thorough but fair - only flag genuine issues
+- Do NOT suggest modifications - only document findings
+
+Output your review in the following JSON format:
+{
+  "passes_review": boolean,
+  "issues": [
+    {
+      "type": "bug" | "security" | "performance" | "style" | "architecture" | "documentation",
+      "severity": "critical" | "high" | "medium" | "low",
+      "description": "Clear description of the issue",
+      "location": "path/to/file.ts:L42" (optional),
+      "suggestion": "How to fix it" (optional)
+    }
+  ],
+  "fix_priority": "critical" | "high" | "medium" | "low" | "none",
+  "fix_plan": "Overall approach to fix the issues" (or null if passes),
+  "architecture_impact": "What else might be affected" (or null if none)
+}
+
+Guidelines:
+- passes_review is true ONLY if there are no issues of severity high or critical
+- fix_priority should reflect the highest severity issue found
+- Be specific about locations (file:line when possible)
+- Focus on correctness, not style preferences
+- Consider edge cases and error handling
+- Check for security vulnerabilities (injection, auth, data exposure)
+- Verify the code actually implements what's specified`;
+var ReviewerAgent = class {
+  client;
+  config;
+  constructor(config, apiKey) {
+    this.config = {
+      provider: "anthropic",
+      model: config?.model ?? getDefaultModel("reviewer"),
+      maxTokens: config?.maxTokens ?? 4096,
+      temperature: config?.temperature ?? 0.3
+    };
+    this.client = new AnthropicClient(this.config, apiKey);
+  }
+  /**
+   * Review a task by analyzing its associated files
+   */
+  async reviewTask(task, context) {
+    const fileContents = await this.loadFilesForReview(task, context);
+    if (fileContents.length === 0) {
+      return {
+        passesReview: false,
+        issues: [{
+          type: "documentation",
+          severity: "medium",
+          description: "No files found to review for this task"
+        }],
+        fixPriority: "medium",
+        fixPlan: "Ensure filesToCheck is populated with valid file paths",
+        architectureImpact: null,
+        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, baseCost: 0, markedUpCost: 0 }
+      };
+    }
+    const userMessage = this.buildPrompt(task, fileContents, context);
+    const response = await this.client.chat(SYSTEM_PROMPT, userMessage, {
+      temperature: 0.3,
+      maxTokens: 4096
+    });
+    return this.parseReviewResponse(response.content, response.usage);
+  }
+  /**
+   * Load file contents for review
+   */
+  async loadFilesForReview(task, context) {
+    const files = [];
+    const filesToCheck = task.filesToCheck ?? [];
+    const maxFiles = context.maxFilesToRead ?? 10;
+    for (const relativePath of filesToCheck.slice(0, maxFiles)) {
+      const fullPath = join3(context.projectPath, relativePath);
+      if (!existsSync3(fullPath)) {
+        continue;
+      }
+      try {
+        const content = await readFile2(fullPath, "utf-8");
+        const truncated = content.length > 1e4 ? content.slice(0, 1e4) + "\n\n... [truncated, file too large]" : content;
+        files.push({ path: relativePath, content: truncated });
+      } catch {
+      }
+    }
+    return files;
+  }
+  /**
+   * Build the review prompt
+   */
+  buildPrompt(task, files, context) {
+    const parts = [];
+    parts.push("# Review Task");
+    parts.push(`**Feature:** ${task.featureName}`);
+    parts.push(`**Category:** ${task.category}${task.subcategory ? ` / ${task.subcategory}` : ""}`);
+    parts.push("");
+    if (task.userStory) {
+      parts.push("**User Story:**");
+      parts.push(task.userStory);
+      parts.push("");
+    }
+    if (task.acceptanceCriteria && task.acceptanceCriteria.length > 0) {
+      parts.push("**Acceptance Criteria:**");
+      task.acceptanceCriteria.forEach((ac, i) => parts.push(`${i + 1}. ${ac}`));
+      parts.push("");
+    }
+    if (task.technicalRequirements) {
+      parts.push("**Technical Requirements:**");
+      parts.push(task.technicalRequirements);
+      parts.push("");
+    }
+    if (task.expectedBehavior) {
+      parts.push("**Expected Behavior:**");
+      parts.push(task.expectedBehavior);
+      parts.push("");
+    }
+    if (task.edgeCases) {
+      parts.push("**Edge Cases to Consider:**");
+      parts.push(task.edgeCases);
+      parts.push("");
+    }
+    if (task.verificationSteps) {
+      parts.push("**Verification Steps:**");
+      parts.push(task.verificationSteps);
+      parts.push("");
+    }
+    if (context.architectureContent) {
+      parts.push("# Architecture Context");
+      parts.push(context.architectureContent);
+      parts.push("");
+    } else if (task.architectureContext) {
+      parts.push("# Architecture Context");
+      parts.push(task.architectureContext);
+      parts.push("");
+    }
+    parts.push("# Files to Review");
+    parts.push("");
+    for (const file of files) {
+      parts.push(`## ${file.path}`);
+      parts.push("```");
+      parts.push(file.content);
+      parts.push("```");
+      parts.push("");
+    }
+    parts.push("# Instructions");
+    parts.push("");
+    parts.push("Review these files against the specifications above.");
+    parts.push("Identify any issues, bugs, security vulnerabilities, or deviations from requirements.");
+    parts.push("Output your review as valid JSON.");
+    return parts.join("\n");
+  }
+  /**
+   * Parse the review response from AI
+   */
+  parseReviewResponse(content, usage) {
+    const jsonMatch = content.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      throw new Error("Failed to parse review: no JSON found in response");
+    }
+    try {
+      const parsed = JSON.parse(jsonMatch[0]);
+      const issues = (parsed.issues ?? []).filter((i) => i.description).map((i) => ({
+        type: this.normalizeIssueType(i.type),
+        severity: this.normalizeSeverity(i.severity),
+        description: i.description ?? "",
+        location: i.location,
+        suggestion: i.suggestion
+      }));
+      const hasCriticalOrHigh = issues.some((i) => i.severity === "critical" || i.severity === "high");
+      return {
+        passesReview: hasCriticalOrHigh ? false : parsed.passes_review ?? true,
+        issues,
+        fixPriority: this.normalizeFixPriority(parsed.fix_priority),
+        fixPlan: parsed.fix_plan ?? null,
+        architectureImpact: parsed.architecture_impact ?? null,
+        usage
+      };
+    } catch (error) {
+      throw new Error(`Failed to parse review JSON: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  normalizeIssueType(value) {
+    const normalized = value?.toLowerCase();
+    if (normalized === "bug" || normalized === "security" || normalized === "performance" || normalized === "style" || normalized === "architecture" || normalized === "documentation") {
+      return normalized;
+    }
+    return "bug";
+  }
+  normalizeSeverity(value) {
+    const normalized = value?.toLowerCase();
+    if (normalized === "critical" || normalized === "high" || normalized === "medium" || normalized === "low") {
+      return normalized;
+    }
+    return "medium";
+  }
+  normalizeFixPriority(value) {
+    const normalized = value?.toLowerCase();
+    if (normalized === "critical" || normalized === "high" || normalized === "medium" || normalized === "low" || normalized === "none") {
+      return normalized;
+    }
+    return "medium";
+  }
+};
+
+// src/core/code-review/service.ts
+var ReviewService = class {
+  db;
+  agent;
+  config;
+  architectureContent = null;
+  constructor(config) {
+    this.config = config;
+    this.db = new ReviewDatabase(config.projectPath);
+    this.agent = new ReviewerAgent(void 0, config.apiKey);
+  }
+  /**
+   * Initialize the service (load architecture context)
+   */
+  async initialize() {
+    this.db.open();
+    this.architectureContent = await readArchitectureContext(this.config.projectPath);
+  }
+  /**
+   * Close the database connection
+   */
+  close() {
+    this.db.close();
+  }
+  /**
+   * Get current review statistics
+   */
+  getStats() {
+    return this.db.getStats();
+  }
+  /**
+   * Review a single task by ID
+   */
+  async reviewTask(taskId) {
+    const task = this.db.getTask(taskId);
+    if (!task) {
+      throw new Error(`Task ${taskId} not found`);
+    }
+    return this.executeReview(task);
+  }
+  /**
+   * Review the next pending task
+   */
+  async reviewNext() {
+    const task = this.db.getNextPendingTask();
+    if (!task) {
+      return null;
+    }
+    const result = await this.executeReview(task);
+    return { task, result };
+  }
+  /**
+   * Review all pending tasks
+   */
+  async reviewAllPending(maxTasks) {
+    const stats = {
+      tasksReviewed: 0,
+      tasksPassed: 0,
+      tasksFailed: 0,
+      tasksErrored: 0,
+      totalUsage: {
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        baseCost: 0,
+        markedUpCost: 0
+      }
+    };
+    const limit = maxTasks ?? Infinity;
+    while (stats.tasksReviewed < limit) {
+      const task = this.db.getNextPendingTask();
+      if (!task) {
+        break;
+      }
+      try {
+        const result = await this.executeReview(task);
+        stats.tasksReviewed++;
+        if (result.passesReview) {
+          stats.tasksPassed++;
+        } else {
+          stats.tasksFailed++;
+        }
+        stats.totalUsage.inputTokens += result.usage.inputTokens;
+        stats.totalUsage.outputTokens += result.usage.outputTokens;
+        stats.totalUsage.totalTokens += result.usage.totalTokens;
+        stats.totalUsage.baseCost += result.usage.baseCost;
+        stats.totalUsage.markedUpCost += result.usage.markedUpCost;
+      } catch (error) {
+        stats.tasksErrored++;
+        this.db.updateTask(task.id, {
+          status: "pending",
+          reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          reviewedBy: "ai-reviewer-error"
+        });
+        if (this.config.onError) {
+          this.config.onError(task, error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    }
+    return stats;
+  }
+  /**
+   * Execute a review on a single task
+   */
+  async executeReview(task) {
+    this.db.updateTask(task.id, {
+      status: "in_review",
+      reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      reviewedBy: "ai-reviewer"
+    });
+    if (this.config.onTaskStart) {
+      this.config.onTaskStart(task);
+    }
+    const context = {
+      projectPath: this.config.projectPath,
+      architectureContent: this.architectureContent ?? void 0,
+      maxFilesToRead: this.config.maxFilesPerTask ?? 10
+    };
+    const result = await this.agent.reviewTask(task, context);
+    const update = {
+      status: result.passesReview ? "completed" : "needs_fix",
+      passesReview: result.passesReview,
+      issuesFound: result.issues,
+      fixPriority: result.fixPriority,
+      fixPlan: result.fixPlan ?? void 0,
+      architectureImpact: result.architectureImpact ?? void 0,
+      reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      reviewedBy: "ai-reviewer"
+    };
+    this.db.updateTask(task.id, update);
+    if (this.config.onTaskComplete) {
+      const updatedTask = this.db.getTask(task.id);
+      if (updatedTask) {
+        this.config.onTaskComplete(updatedTask, result);
+      }
+    }
+    return result;
+  }
+};
+
+export {
+  ReviewDatabase,
+  analyzeProject,
+  featuresToTasks,
+  readArchitectureContext,
+  ReviewService
+};