codereview-aia 0.1.1 → 0.1.3

package/src/runtime/ui/screens/ModeSelection.tsx

@@ -1,23 +1,154 @@
-import React from 'react';
-import { getInk, getInkSelectInput } from '../inkModules';
+import React, { useCallback, useState } from 'react';
+import { getInk, getInkSelectInput, getInkTextInput } from '../inkModules';
 import { useLayout } from '../Layout';
+import type { ReviewMode } from '../../reviewPipeline';
 
 interface ModeSelectionProps {
-  onSelect: (mode: string) => void;
+  onSelect: (mode: ReviewMode, extras?: { targetUrl?: string }) => void;
+  debugEnabled: boolean;
+  onToggleDebug: () => void;
 }
 
-const OPTIONS = [
+interface ModeOption {
+  label: string;
+  value: ReviewMode;
+  description: string;
+  requiresUrl?: boolean;
+}
+
+const OPTIONS: ModeOption[] = [
   {
     label: 'Review uncommitted changes',
     value: 'uncommitted',
     description: 'Scan staged and unstaged changes only',
   },
+  {
+    label: 'Pre-production review',
+    value: 'preprod',
+    description: 'Scan the entire workspace and trigger website checks',
+    requiresUrl: true,
+  },
 ];
 
-export function ModeSelection({ onSelect }: ModeSelectionProps) {
-  const { Box, Text } = getInk();
+export function ModeSelection({ onSelect, debugEnabled, onToggleDebug }: ModeSelectionProps) {
+  const { Box, Text, useInput } = getInk();
   const SelectInput = getInkSelectInput();
+  const TextInput = getInkTextInput();
   const { frameWidth } = useLayout();
+  const [phase, setPhase] = useState<'list' | 'preprodUrl'>('list');
+  const [pendingMode, setPendingMode] = useState<ReviewMode>('preprod');
+  const [highlighted, setHighlighted] = useState<ReviewMode>('uncommitted');
+  const [urlValue, setUrlValue] = useState('');
+  const [urlError, setUrlError] = useState<string | null>(null);
+
+  const resetUrlState = useCallback(() => {
+    setUrlValue('');
+    setUrlError(null);
+  }, []);
+
+  const handleModeSelect = useCallback(
+    (mode: ReviewMode) => {
+      const option = OPTIONS.find((opt) => opt.value === mode);
+      if (!option) {
+        return;
+      }
+
+      if (option.requiresUrl) {
+        setPendingMode(option.value);
+        resetUrlState();
+        setPhase('preprodUrl');
+        return;
+      }
+
+      onSelect(option.value);
+    },
+    [onSelect, resetUrlState],
+  );
+
+  const submitUrl = useCallback(() => {
+    if (phase !== 'preprodUrl') {
+      return;
+    }
+
+    const trimmed = urlValue.trim();
+    if (!trimmed) {
+      setUrlError('URL is required');
+      return;
+    }
+
+    try {
+      const parsed = new URL(trimmed);
+      if (!['http:', 'https:'].includes(parsed.protocol)) {
+        throw new Error('invalid');
+      }
+      setUrlError(null);
+      onSelect(pendingMode, { targetUrl: parsed.toString() });
+    } catch {
+      setUrlError('Enter a valid URL starting with http:// or https://');
+    }
+  }, [onSelect, pendingMode, phase, urlValue]);
+
+  useInput((input, key) => {
+    const normalizedInput = input.toLowerCase();
+    if (normalizedInput === 'd' && !key.ctrl && !key.meta) {
+      onToggleDebug();
+      return;
+    }
+
+    if (phase !== 'preprodUrl') {
+      return;
+    }
+
+    if (key.escape) {
+      setPhase('list');
+      resetUrlState();
+      return;
+    }
+
+    if (key.return) {
+      submitUrl();
+    }
+  });
+
+  if (phase === 'preprodUrl') {
+    return (
+      <Box
+        width={frameWidth}
+        flexDirection="column"
+        borderStyle="round"
+        borderColor="cyan"
+        paddingX={2}
+        paddingY={1}
+        gap={1}
+      >
+        <Text color="cyan" bold>
+          Pre-production review
+        </Text>
+        <Text dimColor>Enter the full website URL. We will trigger ai.enki.si and scan every file here.</Text>
+        <Box flexDirection="column">
+          <Text dimColor>Target URL</Text>
+          <TextInput
+            value={urlValue}
+            onChange={(value) => {
+              setUrlValue(value);
+              if (urlError) {
+                setUrlError(null);
+              }
+            }}
+            placeholder="https://example.com"
+            focus
+          />
+        </Box>
+        {urlError && (
+          <Text color="red">{urlError}</Text>
+        )}
+        <Box justifyContent="space-between">
+          <Text dimColor>Press Enter to start · Esc to go back</Text>
+          <Text dimColor>Debug: {debugEnabled ? 'On' : 'Off'} (press D)</Text>
+        </Box>
+      </Box>
+    );
+  }
 
   return (
     <Box
@@ -29,23 +160,25 @@ export function ModeSelection({ onSelect }: ModeSelectionProps) {
       paddingY={1}
       gap={1}
     >
-      <Text color="green" bold>
-        Choose review mode
-      </Text>
+      <Box justifyContent="space-between" alignItems="center">
+        <Text color="green" bold>
+          Choose review mode
+        </Text>
+        <Text dimColor>Debug: {debugEnabled ? 'On' : 'Off'} (press D)</Text>
+      </Box>
       <Text dimColor>Use arrow keys, press Enter to start.</Text>
       <SelectInput
         items={OPTIONS.map((option) => ({
           label: option.label,
           value: option.value,
         }))}
-        onSelect={(item) => onSelect(String(item.value))}
+        onHighlight={(item) => setHighlighted(item.value as ReviewMode)}
+        onSelect={(item) => handleModeSelect(item.value as ReviewMode)}
       />
       <Box flexDirection="column" marginTop={1}>
-        {OPTIONS.map((option) => (
-          <Text key={option.value} dimColor>
-            · {option.description}
-          </Text>
-        ))}
+        <Text dimColor>
+          · {OPTIONS.find((option) => option.value === highlighted)?.description}
+        </Text>
       </Box>
     </Box>
   );

package/src/runtime/ui/screens/ProgressScreen.tsx

@@ -6,9 +6,18 @@ import { getInk, getInkSpinner } from '../inkModules';
 interface ProgressScreenProps {
   stage: ReviewStage;
   filesFound?: number;
+  currentFile?: string;
+  currentIndex?: number;
+  totalFiles?: number;
+  uncommittedFiles?: number;
+  contextFiles?: number;
 }
 
 const STAGE_TEXT: Record<ReviewStage, { title: string; detail: string }> = {
+  preparing: {
+    title: 'Preparing run',
+    detail: 'Triggering website checks and configuring the reviewer',
+  },
   collecting: {
     title: 'Collecting files',
     detail: 'Inspecting your working tree',
@@ -23,14 +32,45 @@ const STAGE_TEXT: Record<ReviewStage, { title: string; detail: string }> = {
   },
 };
 
-export function ProgressScreen({ stage, filesFound }: ProgressScreenProps) {
+export function ProgressScreen({
+  stage,
+  filesFound,
+  currentFile,
+  currentIndex,
+  totalFiles,
+  uncommittedFiles,
+  contextFiles,
+}: ProgressScreenProps) {
   const { Box, Text } = getInk();
   const Spinner = getInkSpinner();
   const { frameWidth } = useLayout();
 
   const meta = useMemo(() => STAGE_TEXT[stage], [stage]);
+  const base = typeof uncommittedFiles === 'number' ? uncommittedFiles : undefined;
+  const context = typeof contextFiles === 'number' ? contextFiles : undefined;
+  const totalBreakdown =
+    base !== undefined || context !== undefined
+      ? `Queued: ${base ?? '?'} uncommitted${context ? ` + ${context} context` : ''}`
+      : '';
   const fileStatus =
-    typeof filesFound === 'number' && filesFound >= 0 ? `${filesFound} files queued` : 'Preparing file list…';
+    stage === 'collecting' && typeof filesFound === 'number' && filesFound >= 0
+      ? `${filesFound} files queued`
+      : stage === 'collecting'
+        ? 'Preparing file list…'
+        : '';
+
+  const showReviewingProgress =
+    stage === 'reviewing' &&
+    typeof currentIndex === 'number' &&
+    typeof totalFiles === 'number' &&
+    totalFiles > 0 &&
+    Boolean(currentFile);
+
+  const truncatedPath = useMemo(() => {
+    if (!currentFile) return '';
+    const availableWidth = Math.max(10, frameWidth - 10);
+    return truncateMiddle(currentFile, availableWidth);
+  }, [currentFile, frameWidth]);
 
   return (
     <Box
@@ -48,8 +88,23 @@ export function ProgressScreen({ stage, filesFound }: ProgressScreenProps) {
         </Text>
       </Box>
       <Text dimColor>{meta.detail}</Text>
-      <Text dimColor>{fileStatus}</Text>
+      {fileStatus && <Text dimColor>{fileStatus}</Text>}
+      {totalBreakdown && <Text dimColor>{totalBreakdown}</Text>}
+      {showReviewingProgress && (
+        <Text dimColor>{`Reviewing (${currentIndex}/${totalFiles}): ${truncatedPath}`}</Text>
+      )}
     </Box>
   );
 }
 
+function truncateMiddle(value: string, maxLength: number): string {
+  if (value.length <= maxLength) {
+    return value;
+  }
+
+  const ellipsis = '…';
+  const keep = Math.max(1, Math.floor((maxLength - ellipsis.length) / 2));
+  const start = value.slice(0, keep);
+  const end = value.slice(value.length - keep);
+  return `${start}${ellipsis}${end}`;
+}

package/src/runtime/ui/screens/ResultsScreen.tsx

@@ -5,9 +5,10 @@ import { getInk } from '../inkModules';
 
 interface ResultsScreenProps {
   result: ReviewResult;
+  debugLogPath?: string | null;
 }
 
-export function ResultsScreen({ result }: ResultsScreenProps) {
+export function ResultsScreen({ result, debugLogPath }: ResultsScreenProps) {
   const { Box, Text } = getInk();
   const { frameWidth } = useLayout();
 
@@ -21,6 +22,14 @@ export function ResultsScreen({ result }: ResultsScreenProps) {
     ];
   }, [result.totals]);
 
+  const scopeLine = useMemo(() => {
+    const breakdown = result.fileBreakdown;
+    if (!breakdown) return null;
+    return `Scope: ${breakdown.uncommitted} uncommitted + ${breakdown.context} context files`;
+  }, [result.fileBreakdown]);
+
+  const summaryText = result.reportSummary?.trim() || 'Summary unavailable. Open the saved report for details.';
+
   return (
     <Box
       width={frameWidth}
@@ -35,15 +44,26 @@ export function ResultsScreen({ result }: ResultsScreenProps) {
         Review complete for {result.repo}
       </Text>
       <Text dimColor>Duration: {result.duration}s — Files reviewed: {result.filesReviewed}</Text>
+      {scopeLine && <Text dimColor>{scopeLine}</Text>}
+
+      <Box flexDirection="column" borderStyle="round" borderColor="cyan" paddingX={1} paddingY={0}>
+        <Text color="cyan" bold>
+          LLM summary
+        </Text>
+        <Text>{summaryText}</Text>
+      </Box>
 
       <Box flexDirection="column" marginTop={1}>
-        {severityRows.map((row) => (
-          <Box key={row.label}>
-            <Text>
-              {row.label}: {row.value}
-            </Text>
-          </Box>
-        ))}
+        <Text bold>Severity totals</Text>
+        <Box flexDirection="row" flexWrap="wrap">
+          {severityRows.map((row) => (
+            <Box key={row.label} width={24}>
+              <Text>
+                {row.label}: {row.value}
+              </Text>
+            </Box>
+          ))}
+        </Box>
       </Box>
 
       {result.findings.length === 0 ? (
@@ -52,8 +72,9 @@ export function ResultsScreen({ result }: ResultsScreenProps) {
         <Box flexDirection="column" marginTop={1}>
           <Text bold>Sample findings</Text>
           {result.findings.slice(0, 5).map((finding, index) => (
-            <Text key={`${finding.filePath}-${index}`} dimColor>
-              · {finding.filePath ?? finding.file ?? 'unknown'} {finding.priority ? `(${finding.priority})` : ''}
+            <Text key={`${finding.filePath ?? finding.file ?? 'unknown'}-${index}`} dimColor>
+              · {finding.filePath ?? finding.file ?? 'unknown'}{' '}
+              {finding.priority ? `(${finding.priority})` : ''}
             </Text>
           ))}
           {result.findings.length > 5 && (
@@ -68,6 +89,12 @@ export function ResultsScreen({ result }: ResultsScreenProps) {
         </Box>
       )}
 
+      {debugLogPath && (
+        <Box marginTop={1}>
+          <Text dimColor>Debug logs saved to: {debugLogPath}</Text>
+        </Box>
+      )}
+
       <Box marginTop={1}>
         <Text dimColor>Press Enter to return to mode selection.</Text>
       </Box>

package/src/types/review.ts

@@ -97,6 +97,10 @@ export interface ReviewOptions {
   uiLanguage?: string;
   /** Target file or directory (used internally) */
   target?: string;
+  /** Explicit list of files to review (bypasses discovery) */
+  targetFileList?: string[];
+  /** Runtime context information for prompt enrichment */
+  runContext?: RunContext;
   /** Schema instructions for structured output */
   schemaInstructions?: string;
   /** Examples for prompts */
@@ -277,6 +281,20 @@ export interface ReviewResult {
   files?: FileInfo[];
 }
 
+export interface RunContext {
+  repoName: string;
+  reviewMode?: string;
+  totalFiles?: number;
+  groupIndex?: number;
+  groupCount?: number;
+  groupLabel?: string;
+  groupFiles?: string[];
+  docFiles?: string[];
+  uncommittedFiles?: number;
+  contextFiles?: number;
+  contextDocs?: Array<{ path: string; snippet: string }>;
+}
+
 /**
  * Cost information for a single pass in a multi-pass review
  */

package/src/utils/logger.ts

@@ -25,6 +25,9 @@ const LOG_LEVEL_MAP: Record<string, LogLevel> = {
   none: LogLevel.NONE,
 };
 
+import { createWriteStream, mkdirSync, type WriteStream } from 'node:fs';
+import { dirname } from 'node:path';
+
 // ANSI color codes for terminal output
 const COLORS = {
   reset: '\x1b[0m',
@@ -39,6 +42,8 @@ const COLORS = {
 
 // Track if we're initializing to avoid circular dependencies
 const isInitializing = false;
+let logFileStream: WriteStream | null = null;
+let suppressConsoleOutput = false;
 
 // Get the current log level from environment variables
 function getCurrentLogLevel(): LogLevel {
@@ -131,19 +136,54 @@ export function getLogLevel(): LogLevel {
   return currentLogLevel;
 }
 
-/**
- * Format a log message with timestamp and level
- * @param level The log level
- * @param message The message to log
- * @returns The formatted message
- */
-function formatLogMessage(level: string, message: string): string {
-  const timestamp = new Date().toISOString();
+function formatConsoleMessage(level: string, message: string, timestamp: string): string {
   const levelUpper = level.toUpperCase().padEnd(5);
-
   return `${COLORS.time}[${timestamp}]${COLORS.reset} ${COLORS[level as keyof typeof COLORS]}${levelUpper}${COLORS.reset} ${message}`;
 }
 
+function formatFileMessage(level: string, message: string, timestamp: string, args: any[]): string {
+  const levelUpper = level.toUpperCase().padEnd(5);
+  const extras = args.length ? ` ${args.map((arg) => serializeLogArg(arg)).join(' ')}` : '';
+  return `[${timestamp}] ${levelUpper} ${message}${extras}`;
+}
+
+function serializeLogArg(arg: unknown): string {
+  if (typeof arg === 'string') {
+    return arg;
+  }
+  if (arg instanceof Error) {
+    return arg.stack || arg.message;
+  }
+  try {
+    return JSON.stringify(arg);
+  } catch {
+    return String(arg);
+  }
+}
+
+export function enableFileLogging(filePath: string, options?: { suppressConsole?: boolean }): void {
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+    if (logFileStream) {
+      logFileStream.end();
+    }
+    logFileStream = createWriteStream(filePath, { flags: 'a' });
+    suppressConsoleOutput = options?.suppressConsole ?? true;
+  } catch (error) {
+    console.error('Failed to enable file logging:', error);
+    logFileStream = null;
+    suppressConsoleOutput = false;
+  }
+}
+
+export function disableFileLogging(): void {
+  if (logFileStream) {
+    logFileStream.end();
+    logFileStream = null;
+  }
+  suppressConsoleOutput = false;
+}
+
 /**
  * Log a message if the current log level allows it
  * @param level The log level
@@ -151,9 +191,16 @@ function formatLogMessage(level: string, message: string): string {
  * @param args Additional arguments to log
  */
 function log(level: LogLevel, levelName: string, message: string, ...args: any[]): void {
-  // Only log if the current log level is less than or equal to the specified level
-  if (level >= currentLogLevel) {
-    const formattedMessage = formatLogMessage(levelName, message);
+  const timestamp = new Date().toISOString();
+
+  if (logFileStream) {
+    logFileStream.write(`${formatFileMessage(levelName, message, timestamp, args)}\n`);
+  }
+
+  const shouldLogToConsole = !suppressConsoleOutput && level >= currentLogLevel;
+
+  if (shouldLogToConsole) {
+    const formattedMessage = formatConsoleMessage(levelName, message, timestamp);
 
     switch (level) {
       case LogLevel.DEBUG:
@@ -168,9 +215,10 @@ function log(level: LogLevel, levelName: string, message: string, ...args: any[]
       case LogLevel.ERROR:
         console.error(formattedMessage, ...args);
         break;
+      default:
+        break;
     }
-  } else if (level === LogLevel.DEBUG && process.argv.includes('--trace-logger')) {
-    // Only show debug suppression messages when explicitly requested
+  } else if (!suppressConsoleOutput && level === LogLevel.DEBUG && process.argv.includes('--trace-logger')) {
     console.error(
       `Suppressing DEBUG log because currentLogLevel=${currentLogLevel}, message was: ${message}`,
     );
@@ -237,4 +285,6 @@ export default {
   getLogLevel,
   createLogger,
   LogLevel,
+  enableFileLogging,
+  disableFileLogging,
 };