codereview-aia 0.1.0

package/src/types/review.ts

@@ -0,0 +1,294 @@
+/**
+ * Review type definitions for cr-aia.
+ *
+ * The fork keeps only the options we rely on while trimming unrelated commentary.
+ */
+
+import type { CostInfo } from '../clients/utils/tokenCounter';
+import type { OutputFormat } from './common';
+
+// Re-export CostInfo for convenience
+export type { CostInfo } from '../clients/utils/tokenCounter';
+
+/**
+ * Types of code reviews that can be performed
+ */
+export type ReviewType =
+  | 'quick-fixes'
+  | 'architectural'
+  | 'security'
+  | 'performance'
+  | 'unused-code'
+  | 'focused-unused-code'
+  | 'code-tracing-unused-code'
+  | 'consolidated'
+  | 'best-practices'
+  | 'evaluation'
+  | 'extract-patterns'
+  | 'coding-test'
+  | 'ai-integration'
+  | 'cloud-native'
+  | 'developer-experience'
+  | 'comprehensive';
+
+/**
+ * Options for code reviews
+ */
+export interface ReviewOptions {
+  /** Type of review to perform */
+  type: ReviewType;
+  /** Output format */
+  output?: OutputFormat | 'none';
+  /** Directory to save review output */
+  outputDir?: string;
+  /** Model to use for the review */
+  model?: string;
+  /** Model to use for consolidating multi-pass reviews (defaults to main model) */
+  writerModel?: string;
+  /** Whether to include test files in the review */
+  includeTests?: boolean;
+  /** Whether to include project documentation in the review context */
+  includeProjectDocs?: boolean;
+  /** Whether to include dependency analysis in the review */
+  includeDependencyAnalysis?: boolean;
+  /** Whether to run in interactive mode */
+  interactive?: boolean;
+  /** Whether to test API connections before running the review */
+  testApi?: boolean;
+  /** Whether to estimate token usage and cost without performing the review */
+  estimate?: boolean;
+  /** Whether to use multi-pass review for large codebases */
+  multiPass?: boolean;
+  /** Whether to force single-pass review even if token analysis suggests multiple passes are needed */
+  forceSinglePass?: boolean;
+  /** Context maintenance factor for multi-pass reviews (0-1) */
+  contextMaintenanceFactor?: number;
+  /** Whether to skip confirmation prompts */
+  noConfirm?: boolean;
+  /** Whether to enable debug logging */
+  debug?: boolean;
+  /** Programming language of the code being reviewed */
+  language?: string;
+  /** Framework used in the code being reviewed */
+  framework?: string;
+  /** CI/CD data (TypeScript errors, lint errors) - internal use only */
+  ciData?: any;
+  /** Path to a custom prompt file */
+  promptFile?: string;
+  /** Prompt fragments to inject into the review */
+  promptFragments?: Array<{
+    content: string;
+    position: 'start' | 'middle' | 'end';
+    priority?: number;
+  }>;
+  /** Prompt strategy to use */
+  promptStrategy?: string;
+  /** Whether to use cache for prompts */
+  useCache?: boolean;
+  /** Whether to automatically fix issues */
+  autoFix?: boolean;
+  /** Whether to use ts-prune for unused code detection */
+  useTsPrune?: boolean;
+  /** Whether to use ESLint for code analysis */
+  useEslint?: boolean;
+  /** Whether to trace code execution */
+  traceCode?: boolean;
+  /** UI language for output messages */
+  uiLanguage?: string;
+  /** Target file or directory (used internally) */
+  target?: string;
+  /** Schema instructions for structured output */
+  schemaInstructions?: string;
+  /** Examples for prompts */
+  examples?: any[];
+  /** Whether to prompt for all issues */
+  promptAll?: boolean;
+  /** Whether to skip specific file content */
+  skipFileContent?: boolean;
+  /** Whether this is a consolidation pass */
+  isConsolidation?: boolean;
+  /** Project name */
+  projectName?: string;
+  /** Strategy override */
+  strategy?: string;
+  /** Whether to suppress output */
+  quiet?: boolean;
+  /** Whether to focus on specific aspects */
+  focused?: boolean;
+  /** Whether to use consolidated review */
+  consolidated?: boolean;
+  /** Whether to generate Mermaid architecture diagrams */
+  diagram?: boolean;
+  /** Force maximum tokens per batch (for testing consolidation) */
+  batchTokenLimit?: number;
+
+  // Coding test specific options
+  /** Path to assignment description file */
+  assignmentFile?: string;
+  /** URL to assignment description */
+  assignmentUrl?: string;
+  /** Inline assignment description */
+  assignmentText?: string;
+  /** Path to custom evaluation template */
+  evaluationTemplate?: string;
+  /** URL to evaluation template */
+  templateUrl?: string;
+  /** Path to scoring rubric file */
+  rubricFile?: string;
+  /** Type of assessment */
+  assessmentType?: 'coding-challenge' | 'take-home' | 'live-coding' | 'code-review';
+  /** Difficulty level */
+  difficultyLevel?: 'junior' | 'mid' | 'senior' | 'lead' | 'architect';
+  /** Expected completion time in minutes */
+  timeLimit?: number;
+
+  // Evaluation criteria weights
+  /** Weight for correctness evaluation (0-100) */
+  weightCorrectness?: number;
+  /** Weight for code quality evaluation (0-100) */
+  weightCodeQuality?: number;
+  /** Weight for architecture evaluation (0-100) */
+  weightArchitecture?: number;
+  /** Weight for performance evaluation (0-100) */
+  weightPerformance?: number;
+  /** Weight for testing evaluation (0-100) */
+  weightTesting?: number;
+
+  // Evaluation flags
+  /** Include documentation assessment */
+  evaluateDocumentation?: boolean;
+  /** Include git commit history analysis */
+  evaluateGitHistory?: boolean;
+  /** Focus on edge case handling */
+  evaluateEdgeCases?: boolean;
+  /** Focus on error handling patterns */
+  evaluateErrorHandling?: boolean;
+
+  // Scoring configuration
+  /** Scoring system type */
+  scoringSystem?: 'numeric' | 'letter' | 'pass-fail' | 'custom';
+  /** Maximum possible score */
+  maxScore?: number;
+  /** Minimum passing score */
+  passingThreshold?: number;
+  /** Include detailed score breakdown */
+  scoreBreakdown?: boolean;
+
+  // Feedback options
+  /** Feedback detail level */
+  feedbackLevel?: 'basic' | 'detailed' | 'comprehensive';
+  /** Include code examples in feedback */
+  includeExamples?: boolean;
+  /** Include improvement suggestions */
+  includeSuggestions?: boolean;
+  /** Include learning resources */
+  includeResources?: boolean;
+
+  // Constraints
+  /** Comma-separated list of allowed libraries */
+  allowedLibraries?: string[];
+  /** Comma-separated list of forbidden patterns */
+  forbiddenPatterns?: string[];
+  /** Expected Node.js version */
+  nodeVersion?: string;
+  /** Expected TypeScript version */
+  typescriptVersion?: string;
+  /** Memory constraint in MB */
+  memoryLimit?: number;
+  /** Execution timeout in seconds */
+  executionTimeout?: number;
+
+  /** AI Detection options */
+  /** Enable AI-generated code detection */
+  enableAiDetection?: boolean;
+  /** AI detection confidence threshold (0.0-1.0) */
+  aiDetectionThreshold?: number;
+  /** Comma-separated list of analyzers to use */
+  aiDetectionAnalyzers?: string;
+  /** Include AI detection results in the review report */
+  aiDetectionIncludeInReport?: boolean;
+  /** Automatically fail evaluation if AI-generated code is detected */
+  aiDetectionFailOnDetection?: boolean;
+
+  /** Coding test configuration (internal use) */
+  codingTestConfig?: any;
+
+  /** Metadata about the review (internal use) */
+  metadata?: any;
+}
+
+/**
+ * Information about a file to be reviewed
+ */
+export interface FileInfo {
+  /** Path to the file */
+  path: string;
+  /** Relative path to the file from the project root */
+  relativePath?: string;
+  /** Content of the file */
+  content: string;
+  /** File extension */
+  extension?: string;
+}
+
+/**
+ * Result of a code review
+ */
+export interface ReviewResult {
+  /** Content of the review */
+  content: string;
+  /** Path to the file that was reviewed */
+  filePath: string;
+  /** Type of review that was performed */
+  reviewType: ReviewType;
+  /** Timestamp when the review was generated */
+  timestamp: string;
+  /** Cost information for the review */
+  cost?: CostInfo;
+  /** Cost information for the review (alias for cost) */
+  costInfo?: CostInfo;
+  /** Model used for the review */
+  modelUsed?: string;
+  /** Structured data from the review */
+  structuredData?: any;
+  /** Metadata about the review */
+  metadata?: any;
+  /** Tool version used for the review */
+  toolVersion?: string;
+  /** Command options used for the review */
+  commandOptions?: string;
+  /** Detected language of the code */
+  detectedLanguage?: string;
+  /** Detected framework of the code */
+  detectedFramework?: string;
+  /** Detected framework version */
+  frameworkVersion?: string;
+  /** Detected CSS frameworks */
+  cssFrameworks?: Array<{ name: string; version?: string }>;
+  /** Raw API response (for debugging) */
+  response?: string;
+  /** Output format of the review */
+  outputFormat?: OutputFormat;
+  /** Project name for the review */
+  projectName?: string;
+  /** Total number of passes in multi-pass review */
+  totalPasses?: number;
+  /** Files included in the review */
+  files?: FileInfo[];
+}
+
+/**
+ * Cost information for a single pass in a multi-pass review
+ */
+export interface PassCost {
+  /** Pass number */
+  passNumber: number;
+  /** Input tokens for this pass */
+  inputTokens: number;
+  /** Output tokens for this pass */
+  outputTokens: number;
+  /** Total tokens for this pass */
+  totalTokens: number;
+  /** Estimated cost for this pass */
+  estimatedCost: number;
+}

package/src/types/reviewContext.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Module augmentation that exposes the runtime ReviewContext class to TypeScript.
+ */
+
+declare module '../analysis/context' {
+  export enum CodeElementType {
+    Function = 'function',
+    Class = 'class',
+    Interface = 'interface',
+    Variable = 'variable',
+    Import = 'import',
+    ExportedItem = 'exported',
+    Component = 'component',
+    EntryPoint = 'entryPoint',
+  }
+
+  export interface CodeElement {
+    type: CodeElementType;
+    name: string;
+    file: string;
+    signature?: string;
+    importance: number;
+  }
+
+  export interface ReviewFinding {
+    type: string;
+    description: string;
+    file?: string;
+    severity: number;
+    passNumber: number;
+  }
+
+  export interface FileSummary {
+    path: string;
+    type: string;
+    description: string;
+    keyElements: string[];
+    passNumber: number;
+  }
+
+  export class ReviewContext {
+    constructor(
+      projectName: string,
+      reviewType: string,
+      files: import('../types/review').FileInfo[],
+    );
+
+    startPass(): number;
+    getCurrentPass(): number;
+    addCodeElement(element: CodeElement): void;
+    getCodeElements(): CodeElement[];
+    getCodeElementsByType(type: CodeElementType): CodeElement[];
+    getCodeElementsInFile(filePath: string): CodeElement[];
+    addFinding(finding: ReviewFinding): void;
+    getFindings(): ReviewFinding[];
+    addFileSummary(summary: FileSummary): void;
+    getFileSummary(filePath: string): FileSummary | undefined;
+    getAllFileSummaries(): FileSummary[];
+    addGeneralNote(note: string): void;
+    getGeneralNotes(): string[];
+    generateNextPassContext(files: string[], maxContextLength?: number): string;
+    toJSON(): Record<string, unknown>;
+    static fromJSON(json: Record<string, unknown>): ReviewContext;
+  }
+}

package/src/types/reviewSchema.ts

@@ -0,0 +1,181 @@
+/**
+ * Structured code review schema definitions used by cr-aia prompts and validators.
+ *
+ * We keep the TypeScript interfaces with matching Zod schemas so the runtime,
+ * validator, and prompt generator all stay in sync.
+ */
+
+import { z } from 'zod';
+
+/**
+ * Priority level for code review issues
+ */
+export enum IssuePriority {
+  HIGH = 'HIGH',
+  MEDIUM = 'MEDIUM',
+  LOW = 'LOW',
+}
+
+// Zod schema for issue priority
+export const issuePrioritySchema = z.nativeEnum(IssuePriority);
+
+/**
+ * Location of an issue in the code
+ */
+export interface IssueLocation {
+  startLine: number;
+  endLine: number;
+}
+
+// Zod schema for issue location
+export const issueLocationSchema = z.object({
+  startLine: z.number(),
+  endLine: z.number(),
+});
+
+/**
+ * A single issue identified in the code review
+ */
+export interface ReviewIssue {
+  id: string;
+  priority: IssuePriority;
+  description: string;
+  location: IssueLocation;
+  currentCode: string;
+  suggestedCode: string;
+  explanation: string;
+}
+
+// Zod schema for review issue
+export const reviewIssueSchema = z.object({
+  id: z.string(),
+  priority: issuePrioritySchema,
+  description: z.string(),
+  location: issueLocationSchema,
+  currentCode: z.string(),
+  suggestedCode: z.string(),
+  explanation: z.string(),
+});
+
+/**
+ * Review results for a single file
+ */
+export interface FileReview {
+  filePath: string;
+  issues: ReviewIssue[];
+}
+
+// Zod schema for file review
+export const fileReviewSchema = z.object({
+  filePath: z.string(),
+  issues: z.array(reviewIssueSchema),
+});
+
+/**
+ * Summary statistics for the code review
+ */
+export interface ReviewSummary {
+  highPriorityIssues: number;
+  mediumPriorityIssues: number;
+  lowPriorityIssues: number;
+  totalIssues: number;
+}
+
+// Zod schema for review summary
+export const reviewSummarySchema = z.object({
+  highPriorityIssues: z.number(),
+  mediumPriorityIssues: z.number(),
+  lowPriorityIssues: z.number(),
+  totalIssues: z.number(),
+});
+
+/**
+ * Complete code review results
+ */
+export interface CodeReview {
+  version: string;
+  timestamp: string;
+  files: FileReview[];
+  summary: ReviewSummary;
+}
+
+// Zod schema for code review
+export const codeReviewSchema = z.object({
+  version: z.string(),
+  timestamp: z.string(),
+  files: z.array(fileReviewSchema),
+  summary: reviewSummarySchema,
+});
+
+/**
+ * Root object for the code review schema
+ */
+export interface ReviewSchema {
+  review: CodeReview;
+}
+
+// Zod schema for review schema
+export const reviewSchema = z.object({
+  review: codeReviewSchema,
+});
+
+/**
+ * Get the schema as a string for inclusion in prompts
+ */
+export function getSchemaAsString(): string {
+  return `
+{
+  "review": {
+    "version": "1.0",
+    "timestamp": "2024-04-06T12:00:00Z",
+    "files": [
+      {
+        "filePath": "path/to/file.ts",
+        "issues": [
+          {
+            "id": "ISSUE-1",
+            "priority": "HIGH",
+            "description": "Description of the issue",
+            "location": {
+              "startLine": 10,
+              "endLine": 15
+            },
+            "currentCode": "function example() {\\n  // Problematic code here\\n}",
+            "suggestedCode": "function example() {\\n  // Improved code here\\n}",
+            "explanation": "Detailed explanation of why this change is recommended"
+          }
+        ]
+      }
+    ],
+    "summary": {
+      "highPriorityIssues": 1,
+      "mediumPriorityIssues": 2,
+      "lowPriorityIssues": 3,
+      "totalIssues": 6
+    }
+  }
+}
+`;
+}
+
+/**
+ * Get schema instructions for inclusion in prompts
+ */
+export function getSchemaInstructions(): string {
+  return `
+IMPORTANT: In interactive mode, you MUST format your response as a valid JSON object following this exact schema:
+
+${getSchemaAsString()}
+
+Guidelines for filling the schema:
+1. Each issue must have a unique ID (e.g., "ISSUE-1", "ISSUE-2")
+2. Priority must be one of: "HIGH", "MEDIUM", "LOW"
+3. Location should include the start and end line numbers of the affected code
+4. Current code should be the exact code snippet that needs to be changed
+5. Suggested code should be the improved version of the code
+6. Explanation should provide a detailed rationale for the suggested change
+7. The summary should accurately count the number of issues by priority
+
+Your response must be valid JSON that can be parsed programmatically. Do not include any text outside of the JSON structure.
+`;
+}

package/src/types/structuredReview.ts

@@ -0,0 +1,167 @@
+/**
+ * Type definitions for the structured review output that cr-aia emits.
+ */
+
+/**
+ * Priority levels for code review issues
+ */
+export type IssuePriority = 'high' | 'medium' | 'low';
+
+/**
+ * Types of code review issues
+ */
+export type IssueType =
+  | 'bug'
+  | 'security'
+  | 'performance'
+  | 'maintainability'
+  | 'readability'
+  | 'architecture'
+  | 'best-practice'
+  | 'documentation'
+  | 'testing'
+  | 'other';
+
+/**
+ * A single code review issue
+ */
+export interface ReviewIssue {
+  /**
+   * Title of the issue
+   */
+  title: string;
+
+  /**
+   * Priority level of the issue
+   */
+  priority: IssuePriority;
+
+  /**
+   * Type of issue
+   */
+  type: IssueType;
+
+  /**
+   * File path where the issue was found
+   */
+  filePath: string;
+
+  /**
+   * Line number(s) where the issue was found
+   * Can be a single line number or a range (e.g., "10-15")
+   */
+  lineNumbers?: string;
+
+  /**
+   * Description of the issue
+   */
+  description: string;
+
+  /**
+   * Code snippet showing the issue
+   */
+  codeSnippet?: string;
+
+  /**
+   * Suggested fix for the issue
+   */
+  suggestedFix?: string;
+
+  /**
+   * Impact of the issue
+   */
+  impact?: string;
+}
+
+/**
+ * Grade level types for overall code quality
+ */
+export type GradeLevel =
+  | 'A+'
+  | 'A'
+  | 'A-'
+  | 'B+'
+  | 'B'
+  | 'B-'
+  | 'C+'
+  | 'C'
+  | 'C-'
+  | 'D+'
+  | 'D'
+  | 'D-'
+  | 'F';
+
+/**
+ * Code quality assessment categories
+ */
+export interface GradeCategories {
+  /**
+   * Code functionality grade
+   */
+  functionality?: GradeLevel;
+
+  /**
+   * Code quality grade
+   */
+  codeQuality?: GradeLevel;
+
+  /**
+   * Documentation grade
+   */
+  documentation?: GradeLevel;
+
+  /**
+   * Testing grade
+   */
+  testing?: GradeLevel;
+
+  /**
+   * Maintainability grade
+   */
+  maintainability?: GradeLevel;
+
+  /**
+   * Security grade
+   */
+  security?: GradeLevel;
+
+  /**
+   * Performance grade
+   */
+  performance?: GradeLevel;
+}
+
+/**
+ * Structured code review output
+ */
+export interface StructuredReview {
+  /**
+   * Overall grade for the codebase
+   */
+  grade?: GradeLevel;
+
+  /**
+   * Detailed grade breakdown by category
+   */
+  gradeCategories?: GradeCategories;
+
+  /**
+   * Summary of the code review
+   */
+  summary: string;
+
+  /**
+   * List of issues found in the code review
+   */
+  issues: ReviewIssue[];
+
+  /**
+   * General recommendations that don't fit into specific issues
+   */
+  recommendations?: string[];
+
+  /**
+   * Positive aspects of the code
+   */
+  positiveAspects?: string[];
+}