@arvorco/relentless 0.3.1 → 0.4.3

package/src/review/tasks/typecheck.ts

@@ -0,0 +1,323 @@
+/**
+ * Typecheck Micro-Task
+ *
+ * Runs `bun run typecheck` in the project's working directory,
+ * parses TypeScript errors, and generates fix tasks.
+ *
+ * Features:
+ * - Parses TypeScript compiler errors with file, line, column, code, message
+ * - Groups errors by file for efficient fixing
+ * - Generates fix tasks with priority "high"
+ * - Strips ANSI color codes from output
+ * - Tracks warnings separately (doesn't generate fix tasks)
+ * - Provides summary for 100+ errors
+ * - Reports tsconfig.json configuration errors
+ *
+ * @module src/review/tasks/typecheck
+ */
+
+import type { ReviewTaskResult, FixTask } from "../types";
+
+/**
+ * A parsed TypeScript error
+ */
+export interface TypecheckError {
+  /** File path relative to project root */
+  file: string;
+  /** Line number (1-based) */
+  line: number;
+  /** Column number (1-based, optional) */
+  column?: number;
+  /** TypeScript error code (e.g., "TS2339") */
+  code: string;
+  /** Error message text */
+  message: string;
+}
+
+/**
+ * Extended result type for typecheck micro-task
+ */
+export interface TypecheckResult extends ReviewTaskResult {
+  /** The command that was executed */
+  command: string;
+  /** Warning count (not included in fix tasks) */
+  warningCount?: number;
+  /** Summary for paginated results (when 100+ errors) */
+  summary?: string;
+}
+
+/**
+ * Options for running typecheck
+ */
+export interface TypecheckOptions {
+  /** Working directory for the command */
+  cwd?: string;
+}
+
+/**
+ * Strip ANSI color codes from a string
+ *
+ * @param str - Input string potentially containing ANSI codes
+ * @returns Clean string without ANSI codes
+ */
+export function stripAnsiCodes(str: string): string {
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+/**
+ * Parse TypeScript compiler output into structured errors
+ *
+ * Handles multiple output formats:
+ * - Standard tsc format: `file(line,col): error TSxxxx: message`
+ * - Colon-separated format: `file:line:col - error TSxxxx: message`
+ * - Bun typecheck format (arrow style)
+ *
+ * @param output - Raw compiler output (stdout)
+ * @returns Array of parsed errors (excludes warnings)
+ */
+export function parseTypecheckOutput(output: string): TypecheckError[] {
+  const cleanOutput = stripAnsiCodes(output);
+  const errors: TypecheckError[] = [];
+
+  // Split into lines and process each
+  const lines = cleanOutput.split("\n");
+
+  for (const line of lines) {
+    // Skip warning lines
+    if (line.includes("warning TS") || line.includes("warning:")) {
+      continue;
+    }
+
+    // Pattern 1: Standard tsc format - file(line,col): error TSxxxx: message
+    const stdMatch = line.match(
+      /^(.+?)\((\d+),(\d+)\):\s*error\s+(TS\d+):\s*(.+)$/
+    );
+    if (stdMatch) {
+      errors.push({
+        file: stdMatch[1],
+        line: parseInt(stdMatch[2], 10),
+        column: parseInt(stdMatch[3], 10),
+        code: stdMatch[4],
+        message: stdMatch[5],
+      });
+      continue;
+    }
+
+    // Pattern 1b: Without column - file(line): error TSxxxx: message
+    const noColMatch = line.match(
+      /^(.+?)\((\d+)\):\s*error\s+(TS\d+):\s*(.+)$/
+    );
+    if (noColMatch) {
+      errors.push({
+        file: noColMatch[1],
+        line: parseInt(noColMatch[2], 10),
+        code: noColMatch[3],
+        message: noColMatch[4],
+      });
+      continue;
+    }
+
+    // Pattern 2: Colon-separated format - file:line:col - error TSxxxx: message
+    const colonMatch = line.match(
+      /^(.+?):(\d+):(\d+)\s+-\s*error\s+(TS\d+):\s*(.+)$/
+    );
+    if (colonMatch) {
+      errors.push({
+        file: colonMatch[1],
+        line: parseInt(colonMatch[2], 10),
+        column: parseInt(colonMatch[3], 10),
+        code: colonMatch[4],
+        message: colonMatch[5],
+      });
+      continue;
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * Parse warnings from TypeScript compiler output
+ *
+ * @param output - Raw compiler output
+ * @returns Number of warnings found
+ */
+function parseWarningCount(output: string): number {
+  const cleanOutput = stripAnsiCodes(output);
+  const lines = cleanOutput.split("\n");
+  let count = 0;
+
+  for (const line of lines) {
+    if (line.includes("warning TS") || line.includes("warning:")) {
+      count++;
+    }
+  }
+
+  return count;
+}
+
+/**
+ * Group errors by file path
+ *
+ * @param errors - Array of parsed errors
+ * @returns Record mapping file paths to their errors
+ */
+export function groupErrorsByFile(
+  errors: TypecheckError[]
+): Record<string, TypecheckError[]> {
+  const grouped: Record<string, TypecheckError[]> = {};
+
+  for (const error of errors) {
+    if (!grouped[error.file]) {
+      grouped[error.file] = [];
+    }
+    grouped[error.file].push(error);
+  }
+
+  return grouped;
+}
+
+/**
+ * Create a fix task from a TypeScript error
+ *
+ * @param error - The parsed TypeScript error
+ * @returns A fix task for the review system
+ */
+function createFixTask(error: TypecheckError): FixTask {
+  const lineInfo = error.column
+    ? `at line ${error.line}, column ${error.column}`
+    : `at line ${error.line}`;
+
+  return {
+    type: "typecheck_fix",
+    file: error.file,
+    line: error.line,
+    column: error.column,
+    description: `Fix TypeScript error ${error.code} in ${error.file} ${lineInfo}: ${error.message}`,
+    priority: "high",
+    code: error.code,
+  };
+}
+
+/**
+ * Run the typecheck micro-task
+ *
+ * Executes `bun run typecheck` in the specified working directory,
+ * parses the output, and generates fix tasks for any errors found.
+ *
+ * @param options - Options including working directory
+ * @returns TypecheckResult with success status, errors, and fix tasks
+ *
+ * @example
+ * ```typescript
+ * const result = await runTypecheck({ cwd: "/path/to/project" });
+ * if (!result.success) {
+ *   console.log(`${result.errorCount} errors found`);
+ *   result.fixTasks.forEach(task => console.log(task.description));
+ * }
+ * ```
+ */
+export async function runTypecheck(
+  options: TypecheckOptions = {}
+): Promise<TypecheckResult> {
+  const cwd = options.cwd || process.cwd();
+  const command = "bun run typecheck";
+  const startTime = Date.now();
+
+  try {
+    // Spawn the typecheck process
+    const proc = Bun.spawn(["bun", "run", "typecheck"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Wait for completion
+    const exitCode = await proc.exited;
+    const stdout = await proc.stdout.text();
+    const stderr = await proc.stderr.text();
+    const duration = Date.now() - startTime;
+
+    // Check for tsconfig.json errors
+    if (
+      stderr.includes("tsconfig.json") ||
+      stderr.includes("Could not find") ||
+      stderr.includes("Cannot find")
+    ) {
+      return {
+        taskType: "typecheck",
+        success: false,
+        errorCount: 1,
+        warningCount: 0,
+        fixTasks: [],
+        duration,
+        command,
+        error: `Configuration error: ${stderr.includes("tsconfig") ? "tsconfig.json not found or invalid" : stderr}`,
+      };
+    }
+
+    // Parse errors from output (check both stdout and stderr)
+    const combinedOutput = stdout + "\n" + stderr;
+    const errors = parseTypecheckOutput(combinedOutput);
+    const warningCount = parseWarningCount(combinedOutput);
+
+    // Generate fix tasks for each error
+    const fixTasks = errors.map(createFixTask);
+
+    // Create summary for large error counts
+    let summary: string | undefined;
+    if (errors.length >= 100) {
+      const grouped = groupErrorsByFile(errors);
+      const fileCount = Object.keys(grouped).length;
+      summary = `Found ${errors.length} TypeScript errors across ${fileCount} files. Top files with errors: ${Object.entries(grouped)
+        .sort((a, b) => b[1].length - a[1].length)
+        .slice(0, 5)
+        .map(([file, errs]) => `${file} (${errs.length})`)
+        .join(", ")}`;
+    }
+
+    // Check for general command failure (stderr has content but no parsed errors)
+    if (exitCode !== 0 && errors.length === 0 && stderr.trim()) {
+      return {
+        taskType: "typecheck",
+        success: false,
+        errorCount: 1,
+        warningCount: 0,
+        fixTasks: [],
+        duration,
+        command,
+        error: stderr.trim(),
+      };
+    }
+
+    // Success if no errors (warnings are OK)
+    const success = errors.length === 0 && exitCode === 0;
+
+    return {
+      taskType: "typecheck",
+      success,
+      errorCount: errors.length,
+      warningCount,
+      fixTasks,
+      duration,
+      command,
+      summary,
+    };
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    const errorMessage =
+      error instanceof Error ? error.message : String(error);
+
+    return {
+      taskType: "typecheck",
+      success: false,
+      errorCount: 1,
+      warningCount: 0,
+      fixTasks: [],
+      duration,
+      command,
+      error: `Command execution failed: ${errorMessage}`,
+    };
+  }
+}

package/src/review/types.ts

@@ -0,0 +1,139 @@
+/**
+ * Shared types and interfaces for the Review module
+ *
+ * This module defines the core types used by the review runner
+ * and all micro-task implementations.
+ *
+ * @module src/review/types
+ */
+
+import { z } from "zod";
+
+/**
+ * Priority levels for fix tasks
+ * - critical: Security vulnerabilities, data corruption risks
+ * - high: TypeScript errors, failing tests
+ * - medium: Lint warnings, code quality issues
+ * - low: Documentation, style suggestions
+ */
+export const FixTaskPrioritySchema = z.enum(["critical", "high", "medium", "low"]);
+export type FixTaskPriority = z.infer<typeof FixTaskPrioritySchema>;
+
+/**
+ * Fix task types corresponding to review micro-tasks
+ */
+export const FixTaskTypeSchema = z.enum([
+  "typecheck_fix",
+  "lint_fix",
+  "test_fix",
+  "security_fix",
+  "quality_fix",
+  "docs_fix",
+]);
+export type FixTaskType = z.infer<typeof FixTaskTypeSchema>;
+
+/**
+ * A fix task queued from a review micro-task
+ *
+ * Fix tasks are generated when micro-tasks find issues
+ * and are queued to progress.txt for subsequent processing.
+ */
+export const FixTaskSchema = z.object({
+  /** Type of fix task, corresponds to the micro-task that generated it */
+  type: FixTaskTypeSchema,
+  /** File path relative to project root */
+  file: z.string(),
+  /** Line number where the issue was found (optional) */
+  line: z.number().int().positive().optional(),
+  /** Column number (optional) */
+  column: z.number().int().positive().optional(),
+  /** Human-readable description of the issue and fix needed */
+  description: z.string(),
+  /** Priority level for ordering fix tasks */
+  priority: FixTaskPrioritySchema,
+  /** Specific rule or error code (optional, e.g., ESLint rule) */
+  rule: z.string().optional(),
+  /** Error code (optional, e.g., TS2339) */
+  code: z.string().optional(),
+});
+export type FixTask = z.infer<typeof FixTaskSchema>;
+
+/**
+ * Result from running a single micro-task
+ */
+export const ReviewTaskResultSchema = z.object({
+  /** Type of micro-task that was run */
+  taskType: z.enum(["typecheck", "lint", "test", "security", "quality", "docs"]),
+  /** Whether the task passed (no blocking issues) */
+  success: z.boolean(),
+  /** Number of errors/issues found */
+  errorCount: z.number().int().min(0),
+  /** Warning count (non-blocking) */
+  warningCount: z.number().int().min(0).optional(),
+  /** Fix tasks generated for issues found */
+  fixTasks: z.array(FixTaskSchema),
+  /** Duration in milliseconds */
+  duration: z.number().min(0),
+  /** Error message if task threw an exception */
+  error: z.string().optional(),
+  /** Number of retry attempts used */
+  retryAttempts: z.number().int().min(0).optional(),
+});
+export type ReviewTaskResult = z.infer<typeof ReviewTaskResultSchema>;
+
+/**
+ * Summary of the complete review phase
+ */
+export const ReviewSummarySchema = z.object({
+  /** Total number of micro-tasks run */
+  tasksRun: z.number().int().min(0),
+  /** Number of tasks that passed */
+  tasksPassed: z.number().int().min(0),
+  /** Number of tasks that failed */
+  tasksFailed: z.number().int().min(0),
+  /** Total fix tasks generated across all micro-tasks */
+  fixTasksGenerated: z.number().int().min(0),
+  /** Total duration of review phase in milliseconds */
+  totalDuration: z.number().min(0),
+  /** Estimated cost before running (based on mode and task count) */
+  estimatedCost: z.number().min(0),
+  /** Actual cost after running (based on model usage) */
+  actualCost: z.number().min(0),
+  /** Individual results for each micro-task */
+  results: z.array(ReviewTaskResultSchema),
+  /** Whether review was stopped early due to stopOnFailure */
+  stoppedEarly: z.boolean().optional(),
+});
+export type ReviewSummary = z.infer<typeof ReviewSummarySchema>;
+
+/**
+ * Options for controlling review execution
+ */
+export const ReviewOptionsSchema = z.object({
+  /** Stop on first failure instead of continuing */
+  stopOnFailure: z.boolean().default(false),
+  /** Mode override (defaults to config.defaultMode) */
+  mode: z.enum(["free", "cheap", "good", "genius"]).default("good"),
+  /** Micro-tasks to skip */
+  skipTasks: z.array(z.enum(["typecheck", "lint", "test", "security", "quality", "docs"])).optional(),
+  /** Custom handlers for testing (overrides default implementations) */
+  handlers: z.record(z.string(), z.any()).optional(),
+  /** Custom logger function */
+  logger: z.function().args(z.string()).returns(z.unknown()).optional(),
+  /** Callback when model is selected for review */
+  onModelSelected: z.function().args(z.string()).returns(z.unknown()).optional(),
+});
+export type ReviewOptions = z.infer<typeof ReviewOptionsSchema>;
+
+/**
+ * Handler function for a micro-task
+ *
+ * Each micro-task (typecheck, lint, test, etc.) implements this interface.
+ * The handler runs in a fresh process/context with no shared state.
+ */
+export type MicroTaskHandler = () => Promise<ReviewTaskResult>;
+
+/**
+ * Registry of micro-task handlers
+ */
+export type MicroTaskHandlerRegistry = Record<string, MicroTaskHandler>;