codereview-aia 0.1.1 → 0.1.3

package/src/runtime/reviewPipeline.ts

@@ -2,7 +2,7 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { basename, isAbsolute, join, resolve } from 'node:path';
 import { tmpdir } from 'node:os';
 import { execa } from 'execa';
-import { collectFiles } from './fileCollector';
+import { collectFiles, type FileCollectionMode } from './fileCollector';
 import { loadManifest } from './manifest';
 import { runAiCodeReview } from './runAiCodeReview';
 import { ensureProxyEnvironmentInitialized } from './proxyEnvironment';
@@ -10,14 +10,27 @@ import { mergeReports } from './reportMerge';
 import { collectReportData } from './reporting/reportDataCollector';
 import { buildMarkdownReport, injectSummary } from './reporting/markdownReportBuilder';
 import { generateReportSummary } from './reporting/summaryGenerator';
-
-export type ReviewStage = 'collecting' | 'reviewing' | 'merging';
+import logger from '../utils/logger';
+
+export type ReviewStage = 'preparing' | 'collecting' | 'reviewing' | 'merging';
+export type ReviewMode = FileCollectionMode;
+
+export interface StageUpdate {
+  filesFound?: number;
+  currentFile?: string;
+  fileIndex?: number;
+  totalFiles?: number;
+  uncommittedFiles?: number;
+  contextFiles?: number;
+}
 
 export interface ReviewOptions {
   model: string;
   outDir: string;
   debug?: boolean;
-  onStage?: (stage: ReviewStage, info?: { filesFound?: number }) => void;
+  mode?: ReviewMode;
+  preprodTargetUrl?: string;
+  onStage?: (stage: ReviewStage, info?: StageUpdate) => void;
 }
 
 export interface ReviewTotals {
@@ -33,21 +46,29 @@ export interface ReviewResult {
   duration: number;
   repo: string;
   filesReviewed: number;
+  fileBreakdown?: { uncommitted: number; context: number };
+  reportSummary?: string;
   reportPath?: string;
 }
 
 export async function executeReview(options: ReviewOptions): Promise<ReviewResult> {
-  const { model, outDir, debug = false, onStage } = options;
+  const { model, outDir, debug = false, onStage, mode = 'uncommitted' } = options;
 
   onStage?.('collecting');
-  const files = await collectFiles();
-  const fileCount = files.length;
+  logger.info('Collecting files for review', { mode, workspace: process.cwd() });
+  const { targets, context, stats } = await collectFiles({ mode });
+  const fileCount = targets.length;
 
   if (fileCount === 0) {
     throw new Error('No files to review');
   }
 
-  onStage?.('collecting', { filesFound: fileCount });
+  onStage?.('collecting', {
+    filesFound: fileCount,
+    uncommittedFiles: stats.uncommitted,
+    contextFiles: stats.context,
+  });
+  logger.info('File collection complete', { fileCount });
 
   const workspaceRoot = process.cwd();
   const repoRoot = await resolveRepoRoot();
@@ -64,9 +85,15 @@ export async function executeReview(options: ReviewOptions): Promise<ReviewResul
 
   const start = Date.now();
 
+  const repoName = basename(workspaceRoot) || 'workspace';
   try {
-    onStage?.('reviewing', { filesFound: fileCount });
-    const reports = await runAiCodeReview(files, {
+    onStage?.('reviewing', {
+      filesFound: fileCount,
+      totalFiles: fileCount,
+      uncommittedFiles: stats.uncommitted,
+      contextFiles: stats.context,
+    });
+    const reports = await runAiCodeReview(targets, context, {
       provider: 'openrouter',
       type: 'comprehensive',
       outDir: rawOutDir,
@@ -74,6 +101,22 @@ export async function executeReview(options: ReviewOptions): Promise<ReviewResul
       model,
       configPath: manifestPath,
       debug,
+      runContext: {
+        repoName,
+        reviewMode: mode,
+        totalFiles: fileCount,
+        uncommittedFiles: stats.uncommitted,
+        contextFiles: stats.context,
+      },
+      onFileProgress: ({ file, index, total }) =>
+        onStage?.('reviewing', {
+          filesFound: fileCount,
+          currentFile: file,
+          fileIndex: index,
+          totalFiles: total,
+          uncommittedFiles: stats.uncommitted,
+          contextFiles: stats.context,
+        }),
     });
 
     onStage?.('merging');
@@ -82,7 +125,7 @@ export async function executeReview(options: ReviewOptions): Promise<ReviewResul
       (merged?.totals as ReviewTotals) || ({ critical: 0, high: 0, medium: 0, low: 0 } as ReviewTotals);
     const findings = (merged?.findings as any[]) || [];
 
-    const repo = basename(workspaceRoot) || 'workspace';
+    const repo = repoName;
     const duration = Math.round((Date.now() - start) / 1000);
     const reportTimestamp = new Date();
 
@@ -119,6 +162,8 @@ export async function executeReview(options: ReviewOptions): Promise<ReviewResul
       duration,
       repo,
       filesReviewed: fileCount,
+      fileBreakdown: { uncommitted: stats.uncommitted, context: stats.context },
+      reportSummary: summary,
       reportPath,
     };
   } finally {

package/src/runtime/runAiCodeReview.ts

@@ -1,11 +1,35 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
 import { join, relative, resolve } from 'node:path';
 import { execa } from 'execa';
 import type { OutputFormat } from '../types/common';
-import type { ReviewOptions, ReviewType } from '../types/review';
+import type { ReviewOptions, ReviewType, RunContext } from '../types/review';
 import { orchestrateReview } from '../core/reviewOrchestrator';
 import { RUNTIME_CONFIG } from './runtimeConfig';
 
+interface FileProgressPayload {
+  file: string;
+  index: number;
+  total: number;
+}
+
+interface ReviewGroup {
+  label: string;
+  files: string[];
+  absoluteFiles: string[];
+  targetPath: string;
+}
+
+const MAX_FILES_PER_GROUP = 5;
+const MAX_CONTEXT_DOCS_PER_GROUP = 5;
+const MAX_CONTEXT_DOC_CHARS = 2000;
+
+interface ContextDocEntry {
+  path: string;
+  relativePath: string;
+  snippet: string;
+}
+
 export interface AiReviewOptions {
   provider: 'openrouter';
   type: string;
@@ -14,10 +38,16 @@ export interface AiReviewOptions {
   model?: string;
   configPath?: string;
   debug?: boolean;
+  onFileProgress?: (payload: FileProgressPayload) => void;
+  runContext?: RunContext;
 }
 
-export async function runAiCodeReview(files: string[], opts: AiReviewOptions): Promise<any[]> {
-  if (files.length === 0) return [];
+export async function runAiCodeReview(
+  targetFiles: string[],
+  contextFiles: string[],
+  opts: AiReviewOptions,
+): Promise<any[]> {
+  if (targetFiles.length === 0) return [];
 
   const workspaceRoot = process.cwd();
   let repoRoot: string;
@@ -68,7 +98,7 @@ export async function runAiCodeReview(files: string[], opts: AiReviewOptions): P
   }
 
   const expandedFiles: string[] = [];
-  for (const file of files) {
+  for (const file of targetFiles) {
     const absPath = resolve(file);
     try {
       const stats = statSync(absPath);
@@ -144,10 +174,135 @@ export async function runAiCodeReview(files: string[], opts: AiReviewOptions): P
     baseOptions.config = opts.configPath;
   }
 
-  for (const target of targets) {
-    await orchestrateReview(target, baseOptions);
+  const groups = createReviewGroups(targets, workspaceRoot);
+  const contextDocEntries = prepareContextDocs(contextFiles, workspaceRoot);
+  const totalFiles = targets.length;
+  let processedCount = 0;
+
+  const groupCount = groups.length;
+  for (let groupIdx = 0; groupIdx < groups.length; groupIdx += 1) {
+    const group = groups[groupIdx];
+    const progressIndex = Math.min(processedCount + 1, totalFiles);
+    const displayName = formatGroupDisplay(group.files);
+    opts.onFileProgress?.({ file: displayName, index: progressIndex, total: totalFiles });
+
+    const selectedContextDocs = selectContextDocs(group.files, contextDocEntries);
+    const inheritedContext = opts.runContext;
+    const runContext = inheritedContext
+      ? {
+          ...inheritedContext,
+          groupIndex: groupIdx + 1,
+          groupCount,
+          groupLabel: group.label,
+          groupFiles: group.files,
+          docFiles: selectedContextDocs.map((doc) => doc.relativePath),
+          contextDocs: selectedContextDocs.map((doc) => ({
+            path: doc.relativePath,
+            snippet: doc.snippet,
+          })),
+        }
+      : undefined;
+
+    await orchestrateReview(group.targetPath, {
+      ...baseOptions,
+      targetFileList: group.absoluteFiles,
+      runContext,
+    });
+    processedCount += group.files.length;
     collectOutputs();
   }
 
   return outputs;
 }
+
+function createReviewGroups(targets: string[], workspaceRoot: string): ReviewGroup[] {
+  const directoryMap = new Map<string, string[]>();
+  for (const target of targets) {
+    const dir = path.posix.dirname(target) || '.';
+    if (!directoryMap.has(dir)) {
+      directoryMap.set(dir, []);
+    }
+    directoryMap.get(dir)!.push(target);
+  }
+
+  const groups: ReviewGroup[] = [];
+  for (const [dir, files] of directoryMap) {
+    for (let i = 0; i < files.length; i += MAX_FILES_PER_GROUP) {
+      const chunk = files.slice(i, i + MAX_FILES_PER_GROUP);
+      const absoluteFiles = chunk.map((file) => resolve(workspaceRoot, file));
+      const targetPath = dir === '.' ? chunk[0] ?? '.' : dir;
+      groups.push({
+        label: dir,
+        files: chunk,
+        absoluteFiles,
+        targetPath,
+      });
+    }
+  }
+
+  return groups;
+}
+
+function formatGroupDisplay(files: string[]): string {
+  if (files.length === 0) {
+    return 'pending files';
+  }
+
+  if (files.length === 1) {
+    return files[0];
+  }
+
+  return `${files[0]} (+${files.length - 1} more)`;
+}
+
+function prepareContextDocs(contextFiles: string[], workspaceRoot: string): ContextDocEntry[] {
+  const docs: ContextDocEntry[] = [];
+  const seen = new Set<string>();
+
+  for (const file of contextFiles) {
+    const absPath = resolve(file);
+    if (seen.has(absPath)) continue;
+    seen.add(absPath);
+
+    try {
+      const stats = statSync(absPath);
+      if (!stats.isFile()) continue;
+      const buffer = readFileSync(absPath);
+      if (buffer.length === 0 || buffer.includes(0)) continue;
+      const snippet = buffer.toString('utf-8').slice(0, MAX_CONTEXT_DOC_CHARS);
+      const relativePath = relative(workspaceRoot, absPath).replace(/\\/g, '/');
+      if (!relativePath || relativePath.startsWith('..')) continue;
+      docs.push({ path: absPath, relativePath, snippet });
+    } catch {
+      continue;
+    }
+  }
+
+  return docs;
+}
+
+function selectContextDocs(
+  groupFiles: string[],
+  docs: ContextDocEntry[],
+  limit = MAX_CONTEXT_DOCS_PER_GROUP,
+): ContextDocEntry[] {
+  if (docs.length === 0 || limit <= 0) {
+    return [];
+  }
+
+  const groupDirs = new Set(groupFiles.map((file) => path.posix.dirname(file)));
+  const prioritized: ContextDocEntry[] = [];
+  const remaining: ContextDocEntry[] = [];
+
+  for (const doc of docs) {
+    const docDir = path.posix.dirname(doc.relativePath);
+    if (groupDirs.has(docDir)) {
+      prioritized.push(doc);
+    } else {
+      remaining.push(doc);
+    }
+  }
+
+  const ordered = [...prioritized, ...remaining];
+  return ordered.slice(0, limit);
+}

package/src/runtime/ui/RuntimeApp.tsx

@@ -1,16 +1,19 @@
-import React, { useCallback, useEffect, useState } from 'react';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
 import { LayoutProvider, useLayout } from './Layout';
 import { AuthScreen } from './screens/AuthScreen';
 import { ModeSelection } from './screens/ModeSelection';
 import { ProgressScreen } from './screens/ProgressScreen';
 import { ResultsScreen } from './screens/ResultsScreen';
 import { getInk, getInkSpinner } from './inkModules';
-import type { ReviewResult, ReviewStage } from '../reviewPipeline';
+import type { ReviewMode, ReviewResult, ReviewStage, StageUpdate } from '../reviewPipeline';
 import { executeReview } from '../reviewPipeline';
 import { loadSession, getSessionToken } from '../auth/session';
 import type { SessionUser } from '../auth/types';
 import { RUNTIME_CONFIG } from '../runtimeConfig';
 import { MissingCrIgnoreError } from '../errors';
+import { triggerManualWebCheck } from '../preprod/webCheck';
+import { startDebugLogSession, type DebugLogSession } from '../debug/logManager';
+import logger from '../../utils/logger';
 
 type ScreenState = 'auth' | 'mode' | 'progress' | 'results';
 
@@ -21,9 +24,31 @@ interface RuntimeAppProps {
 interface ProgressState {
   stage: ReviewStage;
   filesFound?: number;
+  currentFile?: string;
+  currentIndex?: number;
+  totalFiles?: number;
+  uncommittedFiles?: number;
+  contextFiles?: number;
 }
 
 const defaultProgress: ProgressState = { stage: 'collecting' };
+const GENERIC_ERROR_MESSAGE =
+  'Something went wrong. Press D to enable debug mode and rerun to capture logs.';
+const PREPROD_ERROR_MESSAGE =
+  'Could not start the website check. Double-check the URL or try again later.';
+
+function transformStageUpdate(stage: ReviewStage, info?: StageUpdate): ProgressState {
+  return {
+    stage,
+    filesFound: info?.filesFound,
+    currentFile: info?.currentFile,
+    currentIndex:
+      typeof info?.fileIndex === 'number' && info.fileIndex > 0 ? info.fileIndex : undefined,
+    totalFiles: info?.totalFiles,
+    uncommittedFiles: info?.uncommittedFiles,
+    contextFiles: info?.contextFiles,
+  };
+}
 
 function AppBody({ debug = false }: RuntimeAppProps) {
   const { Box, Text, useApp, useInput } = getInk();
@@ -33,8 +58,11 @@ function AppBody({ debug = false }: RuntimeAppProps) {
   const [user, setUser] = useState<SessionUser | null>(null);
   const [progress, setProgress] = useState<ProgressState>(defaultProgress);
   const [results, setResults] = useState<ReviewResult | null>(null);
+  const [debugEnabled, setDebugEnabled] = useState(false);
+  const [lastDebugLogPath, setLastDebugLogPath] = useState<string | null>(null);
   type ErrorInfo = { type: 'generic' | 'crignore'; message: string; hint?: string };
   const [error, setError] = useState<ErrorInfo | null>(null);
+  const combinedDebugFlag = useMemo(() => debug || debugEnabled, [debug, debugEnabled]);
 
   useEffect(() => {
     const sessionUser = loadSession();
@@ -68,23 +96,86 @@ function AppBody({ debug = false }: RuntimeAppProps) {
     setScreen('mode');
   }, []);
 
-  const handleRunReview = useCallback(async (_mode: string) => {
+  const handleToggleDebug = useCallback(() => {
+    setDebugEnabled((prev) => {
+      if (prev) {
+        setLastDebugLogPath(null);
+      }
+      return !prev;
+    });
+  }, []);
+
+  const handleRunReview = useCallback(async (mode: ReviewMode, extras?: { targetUrl?: string }) => {
+    const trimmedUrl = extras?.targetUrl?.trim();
+
+    if (mode === 'preprod' && !trimmedUrl) {
+      setError({ type: 'generic', message: 'Pre-production mode requires a website URL.' });
+      return;
+    }
+
     setScreen('progress');
     setResults(null);
     setError(null);
-    setProgress(defaultProgress);
+    setProgress(mode === 'preprod' ? { stage: 'preparing' } : { ...defaultProgress });
+    setLastDebugLogPath(null);
+
+    let debugSession: DebugLogSession | null = null;
+    const finalizeDebugLogging = () => {
+      if (debugSession) {
+        debugSession.stop();
+        setLastDebugLogPath(debugSession.filePath);
+      } else {
+        setLastDebugLogPath(null);
+      }
+    };
+
+    if (debugEnabled) {
+      try {
+        debugSession = startDebugLogSession(process.cwd());
+      } catch (logInitError) {
+        const message =
+          logInitError instanceof Error
+            ? logInitError.message
+            : 'Unable to initialize debug logging.';
+        setError({ type: 'generic', message: `Debug logging disabled: ${message}` });
+      }
+    }
+
+    if (mode === 'preprod' && trimmedUrl) {
+      try {
+        logger.info('Triggering manual website check', { url: trimmedUrl });
+        await triggerManualWebCheck(trimmedUrl);
+      } catch (webError) {
+        logger.error('Pre-production web check failed', webError);
+        setError({ type: 'generic', message: PREPROD_ERROR_MESSAGE });
+        setScreen('mode');
+        finalizeDebugLogging();
+        return;
+      }
+    }
 
     try {
+      logger.info('Starting code review run', { mode, workspace: process.cwd(), preprodTarget: trimmedUrl });
+      setProgress({ ...defaultProgress });
       const reviewResult = await executeReview({
         model: process.env.AI_CODE_REVIEW_MODEL || RUNTIME_CONFIG.DEFAULT_MODEL,
         outDir: './reports',
-        debug,
-        onStage: (stage, info) => setProgress({ stage, filesFound: info?.filesFound }),
+        debug: combinedDebugFlag,
+        mode,
+        preprodTargetUrl: trimmedUrl,
+        onStage: (stage, info) =>
+          setProgress(transformStageUpdate(stage, info)),
       });
 
+      logger.info('Code review run complete', {
+        mode,
+        durationSeconds: reviewResult.duration,
+        filesReviewed: reviewResult.filesReviewed,
+      });
       setResults(reviewResult);
       setScreen('results');
     } catch (reviewError) {
+      logger.error('Code review run failed', reviewError);
       if (reviewError instanceof MissingCrIgnoreError) {
         setError({
           type: 'crignore',
@@ -92,22 +183,38 @@ function AppBody({ debug = false }: RuntimeAppProps) {
           hint: `Create ${reviewError.crIgnorePath} (can be empty, gitignore syntax) and rerun.`,
         });
       } else {
-        const message =
-          reviewError instanceof Error
-            ? reviewError.message
-            : 'Failed to run review. Check proxy/auth configuration.';
-        setError({ type: 'generic', message });
+        setError({ type: 'generic', message: GENERIC_ERROR_MESSAGE });
       }
       setScreen('mode');
+    } finally {
+      finalizeDebugLogging();
     }
-  }, [debug]);
+  }, [combinedDebugFlag, debugEnabled]);
 
   return (
     <Box width={layout.frameWidth} flexDirection="column" gap={1}>
       {screen === 'auth' && <AuthScreen onAuth={handleAuth} />}
-      {screen === 'mode' && user && <ModeSelection onSelect={(mode) => handleRunReview(mode)} />}
-      {screen === 'progress' && <ProgressScreen stage={progress.stage} filesFound={progress.filesFound} />}
-      {screen === 'results' && results && <ResultsScreen result={results} />}
+      {screen === 'mode' && user && (
+        <ModeSelection
+          onSelect={(mode, payload) => handleRunReview(mode, payload)}
+          debugEnabled={debugEnabled}
+          onToggleDebug={handleToggleDebug}
+        />
+      )}
+      {screen === 'progress' && (
+        <ProgressScreen
+          stage={progress.stage}
+          filesFound={progress.filesFound}
+          currentFile={progress.currentFile}
+          currentIndex={progress.currentIndex}
+          totalFiles={progress.totalFiles}
+          uncommittedFiles={progress.uncommittedFiles}
+          contextFiles={progress.contextFiles}
+        />
+      )}
+      {screen === 'results' && results && (
+        <ResultsScreen result={results} debugLogPath={lastDebugLogPath} />
+      )}
       {error && (
         <Box
           borderStyle="round"
@@ -121,6 +228,11 @@ function AppBody({ debug = false }: RuntimeAppProps) {
           </Text>
         </Box>
       )}
+      {lastDebugLogPath && screen !== 'results' && (
+        <Box>
+          <Text dimColor>Debug logs saved to: {lastDebugLogPath}</Text>
+        </Box>
+      )}
       <Box justifyContent="space-between">
         <Text dimColor>{user ? `Logged in as ${user.username}` : 'Authenticate to start reviewing'}</Text>
         <Text dimColor>Ctrl+C to exit</Text>