codereview-aia 0.1.3 → 0.1.4

package/src/runtime/runAiCodeReview.ts

@@ -1,308 +0,0 @@
-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, 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;
-  outDir: string;
-  format: 'json' | 'md';
-  model?: string;
-  configPath?: string;
-  debug?: boolean;
-  onFileProgress?: (payload: FileProgressPayload) => void;
-  runContext?: RunContext;
-}
-
-export async function runAiCodeReview(
-  targetFiles: string[],
-  contextFiles: string[],
-  opts: AiReviewOptions,
-): Promise<any[]> {
-  if (targetFiles.length === 0) return [];
-
-  const workspaceRoot = process.cwd();
-  let repoRoot: string;
-  try {
-    const { stdout } = await execa('git', ['rev-parse', '--show-toplevel']);
-    repoRoot = stdout.trim();
-  } catch {
-    repoRoot = process.cwd();
-  }
-
-  const absOutDir = resolve(workspaceRoot, opts.outDir);
-
-  if (!existsSync(absOutDir)) {
-    mkdirSync(absOutDir, { recursive: true });
-  }
-
-  const outputFileMeta = new Map<string, { mtimeMs: number; size: number }>();
-  if (existsSync(absOutDir)) {
-    for (const file of readdirSync(absOutDir)) {
-      if (!file.endsWith('.json')) continue;
-      try {
-        const stats = statSync(join(absOutDir, file));
-        outputFileMeta.set(file, { mtimeMs: stats.mtimeMs, size: stats.size });
-      } catch {
-        // ignore stale files
-      }
-    }
-  }
-
-  function getAllFilesInDir(dirPath: string, repo: string): string[] {
-    const entries = readdirSync(dirPath, { withFileTypes: true });
-    const nested: string[] = [];
-    for (const entry of entries) {
-      const fullPath = join(dirPath, entry.name);
-      const relPath = relative(repo, fullPath);
-      if (relPath.includes('.git/') || relPath.includes('node_modules/')) {
-        continue;
-      }
-
-      if (entry.isDirectory()) {
-        const subFiles = getAllFilesInDir(fullPath, repo);
-        nested.push(...subFiles);
-      } else if (entry.isFile()) {
-        nested.push(fullPath);
-      }
-    }
-    return nested;
-  }
-
-  const expandedFiles: string[] = [];
-  for (const file of targetFiles) {
-    const absPath = resolve(file);
-    try {
-      const stats = statSync(absPath);
-      if (stats.isDirectory()) {
-        const dirFiles = getAllFilesInDir(absPath, repoRoot);
-        expandedFiles.push(...dirFiles);
-      } else if (stats.isFile()) {
-        expandedFiles.push(absPath);
-      }
-    } catch {
-      continue;
-    }
-  }
-
-  const uniqueExpandedFiles = Array.from(new Set(expandedFiles));
-  const relativeFilesSet = new Set<string>();
-  for (const absPath of uniqueExpandedFiles) {
-    try {
-      const stats = statSync(absPath);
-      if (!stats.isFile()) continue;
-      const repoRelative = relative(repoRoot, absPath);
-      if (!repoRelative || repoRelative.startsWith('..')) continue;
-
-      const workspaceRelative = relative(workspaceRoot, absPath).replace(/\\/g, '/');
-      if (!workspaceRelative || workspaceRelative.startsWith('..')) continue;
-
-      relativeFilesSet.add(workspaceRelative);
-    } catch {
-      continue;
-    }
-  }
-
-  const outputs: any[] = [];
-
-  const collectOutputs = () => {
-    if (!existsSync(absOutDir)) {
-      return;
-    }
-    const jsonFiles = readdirSync(absOutDir).filter((f) => f.endsWith('.json'));
-    for (const file of jsonFiles) {
-      const filePath = join(absOutDir, file);
-      try {
-        const stats = statSync(filePath);
-        const previous = outputFileMeta.get(file);
-        if (previous && stats.mtimeMs <= previous.mtimeMs && stats.size === previous.size) {
-          continue;
-        }
-        const content = JSON.parse(readFileSync(filePath, 'utf-8'));
-        outputs.push(content);
-        outputFileMeta.set(file, { mtimeMs: stats.mtimeMs, size: stats.size });
-      } catch {
-        continue;
-      }
-    }
-  };
-
-  if (relativeFilesSet.size === 0) {
-    throw new Error('No files to review after filtering');
-  }
-
-  const targets = Array.from(relativeFilesSet);
-  const mappedFormat: OutputFormat = opts.format === 'md' ? 'markdown' : 'json';
-
-  const baseOptions: (ReviewOptions & { config?: string }) = {
-    type: opts.type as ReviewType,
-    output: mappedFormat,
-    outputDir: absOutDir,
-    model: opts.model || RUNTIME_CONFIG.DEFAULT_MODEL,
-    debug: opts.debug ?? false,
-  };
-
-  if (opts.configPath) {
-    baseOptions.config = opts.configPath;
-  }
-
-  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/runtimeConfig.ts

@@ -1,5 +0,0 @@
-export const RUNTIME_CONFIG = {
-  DEFAULT_MODEL: 'openrouter:x-ai/grok-4-fast',
-} as const;
-
-export type RuntimeConfig = typeof RUNTIME_CONFIG;

package/src/runtime/ui/Layout.tsx

@@ -1,57 +0,0 @@
-import React, { createContext, useContext, useEffect, useMemo, useState } from 'react';
-import { getInk } from './inkModules';
-
-interface LayoutValue {
-  columns: number;
-  rows: number;
-  frameWidth: number;
-}
-
-const DEFAULT_COLUMNS = 80;
-const DEFAULT_ROWS = 24;
-
-const LayoutContext = createContext<LayoutValue>({
-  columns: DEFAULT_COLUMNS,
-  rows: DEFAULT_ROWS,
-  frameWidth: DEFAULT_COLUMNS - 4,
-});
-
-export function LayoutProvider({ children }: { children: React.ReactNode }) {
-  const { useStdout } = getInk();
-  const { stdout } = useStdout();
-  const [dimensions, setDimensions] = useState<LayoutValue>(() => ({
-    columns: stdout?.columns ?? DEFAULT_COLUMNS,
-    rows: stdout?.rows ?? DEFAULT_ROWS,
-    frameWidth: Math.max(60, Math.min((stdout?.columns ?? DEFAULT_COLUMNS) - 4, 110)),
-  }));
-
-  useEffect(() => {
-    if (!stdout) {
-      return;
-    }
-
-    const handleResize = () => {
-      const cols = stdout.columns ?? DEFAULT_COLUMNS;
-      const rows = stdout.rows ?? DEFAULT_ROWS;
-      setDimensions({
-        columns: cols,
-        rows,
-        frameWidth: Math.max(60, Math.min(cols - 4, 110)),
-      });
-    };
-
-    stdout.on('resize', handleResize);
-    return () => {
-      stdout.off('resize', handleResize);
-    };
-  }, [stdout]);
-
-  const value = useMemo<LayoutValue>(() => dimensions, [dimensions]);
-
-  return <LayoutContext.Provider value={value}>{children}</LayoutContext.Provider>;
-}
-
-export function useLayout(): LayoutValue {
-  return useContext(LayoutContext);
-}
-

package/src/runtime/ui/RuntimeApp.tsx

@@ -1,262 +0,0 @@
-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 { 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';
-
-interface RuntimeAppProps {
-  debug?: boolean;
-}
-
-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();
-  const { exit } = useApp();
-  const layout = useLayout();
-  const [screen, setScreen] = useState<ScreenState>('auth');
-  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();
-    const token = getSessionToken();
-    if (token) {
-      process.env.CR_AIA_PROXY_SESSION_TOKEN = token;
-    }
-    if (sessionUser) {
-      setUser(sessionUser);
-      setScreen('mode');
-    }
-  }, []);
-
-  useInput(
-    useCallback(
-      (input, key) => {
-        if (key.ctrl && input === 'c') {
-          exit();
-        }
-
-        if (screen === 'results' && key.return) {
-          setScreen('mode');
-        }
-      },
-      [exit, screen],
-    ),
-  );
-
-  const handleAuth = useCallback((nextUser: SessionUser) => {
-    setUser(nextUser);
-    setScreen('mode');
-  }, []);
-
-  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(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: 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',
-          message: 'cr-aia needs a .crignore file in this repo.',
-          hint: `Create ${reviewError.crIgnorePath} (can be empty, gitignore syntax) and rerun.`,
-        });
-      } else {
-        setError({ type: 'generic', message: GENERIC_ERROR_MESSAGE });
-      }
-      setScreen('mode');
-    } finally {
-      finalizeDebugLogging();
-    }
-  }, [combinedDebugFlag, debugEnabled]);
-
-  return (
-    <Box width={layout.frameWidth} flexDirection="column" gap={1}>
-      {screen === 'auth' && <AuthScreen onAuth={handleAuth} />}
-      {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"
-          borderColor={error.type === 'crignore' ? 'yellow' : 'red'}
-          paddingX={1}
-          paddingY={1}
-        >
-          <Text color={error.type === 'crignore' ? 'yellow' : 'red'}>
-            {error.message}
-            {error.hint ? `\n${error.hint}` : ''}
-          </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>
-      </Box>
-    </Box>
-  );
-}
-
-export function RuntimeApp(props: RuntimeAppProps) {
-  return (
-    <LayoutProvider>
-      <AppBody {...props} />
-    </LayoutProvider>
-  );
-}
-
-export function LoadingScreen() {
-  const { Box, Text } = getInk();
-  const Spinner = getInkSpinner();
-  return (
-    <Box flexDirection="column" paddingX={1} paddingY={1}>
-      <Text>
-        <Spinner type="dots" /> Preparing runtime environment...
-      </Text>
-    </Box>
-  );
-}

package/src/runtime/ui/inkModules.ts

@@ -1,73 +0,0 @@
-type InkModule = typeof import('ink');
-type SpinnerModule = typeof import('ink-spinner');
-type TextInputModule = typeof import('ink-text-input');
-type SelectInputModule = typeof import('ink-select-input');
-
-const dynamicImporter = new Function('specifier', 'return import(specifier);') as (
-  specifier: string,
-) => Promise<unknown>;
-
-let inkModule: InkModule | null = null;
-let spinnerModule: SpinnerModule['default'] | null = null;
-let textInputModule: TextInputModule['default'] | null = null;
-let selectInputModule: SelectInputModule['default'] | null = null;
-
-async function loadInk(): Promise<void> {
-  if (!inkModule) {
-    inkModule = (await dynamicImporter('ink')) as InkModule;
-  }
-}
-
-async function loadSpinner(): Promise<void> {
-  if (!spinnerModule) {
-    const mod = (await dynamicImporter('ink-spinner')) as SpinnerModule;
-    spinnerModule = mod.default;
-  }
-}
-
-async function loadTextInput(): Promise<void> {
-  if (!textInputModule) {
-    const mod = (await dynamicImporter('ink-text-input')) as TextInputModule;
-    textInputModule = mod.default;
-  }
-}
-
-async function loadSelectInput(): Promise<void> {
-  if (!selectInputModule) {
-    const mod = (await dynamicImporter('ink-select-input')) as SelectInputModule;
-    selectInputModule = mod.default;
-  }
-}
-
-export async function preloadInkModules(): Promise<void> {
-  await Promise.all([loadInk(), loadSpinner(), loadTextInput(), loadSelectInput()]);
-}
-
-export function getInk(): InkModule {
-  if (!inkModule) {
-    throw new Error('Ink module not loaded. Call preloadInkModules() before rendering UI.');
-  }
-  return inkModule;
-}
-
-export function getInkSpinner(): SpinnerModule['default'] {
-  if (!spinnerModule) {
-    throw new Error('Ink spinner module not loaded. Call preloadInkModules() before rendering UI.');
-  }
-  return spinnerModule;
-}
-
-export function getInkTextInput(): TextInputModule['default'] {
-  if (!textInputModule) {
-    throw new Error('Ink TextInput module not loaded. Call preloadInkModules() before rendering UI.');
-  }
-  return textInputModule;
-}
-
-export function getInkSelectInput(): SelectInputModule['default'] {
-  if (!selectInputModule) {
-    throw new Error('Ink SelectInput module not loaded. Call preloadInkModules() before rendering UI.');
-  }
-  return selectInputModule;
-}
-