codereview-aia 0.1.2 → 0.1.4

package/src/runtime/reviewPipeline.ts

@@ -1,161 +0,0 @@
-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, type FileCollectionMode } from './fileCollector';
-import { loadManifest } from './manifest';
-import { runAiCodeReview } from './runAiCodeReview';
-import { ensureProxyEnvironmentInitialized } from './proxyEnvironment';
-import { mergeReports } from './reportMerge';
-import { collectReportData } from './reporting/reportDataCollector';
-import { buildMarkdownReport, injectSummary } from './reporting/markdownReportBuilder';
-import { generateReportSummary } from './reporting/summaryGenerator';
-import logger from '../utils/logger';
-
-export type ReviewStage = 'preparing' | 'collecting' | 'reviewing' | 'merging';
-export type ReviewMode = FileCollectionMode;
-
-export interface ReviewOptions {
-  model: string;
-  outDir: string;
-  debug?: boolean;
-  mode?: ReviewMode;
-  preprodTargetUrl?: string;
-  onStage?: (stage: ReviewStage, info?: { filesFound?: number }) => void;
-}
-
-export interface ReviewTotals {
-  critical: number;
-  high: number;
-  medium: number;
-  low: number;
-}
-
-export interface ReviewResult {
-  totals: ReviewTotals;
-  findings: any[];
-  duration: number;
-  repo: string;
-  filesReviewed: number;
-  reportPath?: string;
-}
-
-export async function executeReview(options: ReviewOptions): Promise<ReviewResult> {
-  const { model, outDir, debug = false, onStage, mode = 'uncommitted' } = options;
-
-  onStage?.('collecting');
-  logger.info('Collecting files for review', { mode, workspace: process.cwd() });
-  const files = await collectFiles({ mode });
-  const fileCount = files.length;
-
-  if (fileCount === 0) {
-    throw new Error('No files to review');
-  }
-
-  onStage?.('collecting', { filesFound: fileCount });
-  logger.info('File collection complete', { fileCount });
-
-  const workspaceRoot = process.cwd();
-  const repoRoot = await resolveRepoRoot();
-  const manifest = loadManifest(workspaceRoot);
-  const tempDir = mkdtempSync(join(tmpdir(), 'cr-aia-'));
-  const rawOutDir = mkdtempSync(join(tmpdir(), 'cr-aia-raw-'));
-  const manifestPath = join(tempDir, 'ai-code-review.json');
-  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-
-  ensureProxyEnvironmentInitialized(repoRoot);
-
-  const finalOutDir = resolveOutputDirectory(workspaceRoot, outDir);
-  mkdirSync(finalOutDir, { recursive: true });
-
-  const start = Date.now();
-
-  try {
-    onStage?.('reviewing', { filesFound: fileCount });
-    const reports = await runAiCodeReview(files, {
-      provider: 'openrouter',
-      type: 'comprehensive',
-      outDir: rawOutDir,
-      format: 'json',
-      model,
-      configPath: manifestPath,
-      debug,
-    });
-
-    onStage?.('merging');
-    const merged = mergeReports(reports || []);
-    const totals =
-      (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 duration = Math.round((Date.now() - start) / 1000);
-    const reportTimestamp = new Date();
-
-    const collected = collectReportData(reports || []);
-    const severityTotals = totals || collected.totals;
-
-    const markdownDraft = buildMarkdownReport({
-      repoName: repo,
-      generatedAt: reportTimestamp,
-      durationSeconds: duration,
-      filesReviewed: fileCount,
-      totals: severityTotals,
-      tokenStats: collected.tokenStats,
-      estimatedCostUSD: collected.estimatedCostUSD,
-      issueGroups: collected.groupedIssues,
-    });
-
-    const summary = await generateReportSummary(markdownDraft, {
-      model,
-      totals: severityTotals,
-      durationSeconds: duration,
-      estimatedCostUSD: collected.estimatedCostUSD,
-      issueCount: collected.issueCount,
-    });
-
-    const finalMarkdown = injectSummary(markdownDraft, summary);
-    const reportFileName = formatReportFileName(repo, reportTimestamp);
-    const reportPath = join(finalOutDir, reportFileName);
-    writeFileSync(reportPath, finalMarkdown, 'utf-8');
-
-    return {
-      totals: severityTotals,
-      findings,
-      duration,
-      repo,
-      filesReviewed: fileCount,
-      reportPath,
-    };
-  } finally {
-    rmSync(tempDir, { recursive: true, force: true });
-    rmSync(rawOutDir, { recursive: true, force: true });
-  }
-}
-
-async function resolveRepoRoot(): Promise<string> {
-  try {
-    const { stdout } = await execa('git', ['rev-parse', '--show-toplevel']);
-    return stdout.trim();
-  } catch {
-    return process.cwd();
-  }
-}
-
-function resolveOutputDirectory(root: string, outputDir: string): string {
-  if (isAbsolute(outputDir)) {
-    return outputDir;
-  }
-  return resolve(root, outputDir);
-}
-
-function formatReportFileName(repo: string, date: Date): string {
-  const sanitizedRepo = repo.replace(/[^a-zA-Z0-9_-]+/g, '-').replace(/-+/g, '-');
-  const pad = (value: number) => value.toString().padStart(2, '0');
-  const day = pad(date.getDate());
-  const month = pad(date.getMonth() + 1);
-  const year = date.getFullYear();
-  const hours = pad(date.getHours());
-  const minutes = pad(date.getMinutes());
-  return `cr-${sanitizedRepo}-${day}-${month}-${year}-${hours}-${minutes}.md`;
-}

package/src/runtime/runAiCodeReview.ts

@@ -1,153 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync } from 'node:fs';
-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 { orchestrateReview } from '../core/reviewOrchestrator';
-import { RUNTIME_CONFIG } from './runtimeConfig';
-
-export interface AiReviewOptions {
-  provider: 'openrouter';
-  type: string;
-  outDir: string;
-  format: 'json' | 'md';
-  model?: string;
-  configPath?: string;
-  debug?: boolean;
-}
-
-export async function runAiCodeReview(files: string[], opts: AiReviewOptions): Promise<any[]> {
-  if (files.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 files) {
-    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;
-  }
-
-  for (const target of targets) {
-    await orchestrateReview(target, baseOptions);
-    collectOutputs();
-  }
-
-  return outputs;
-}

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,233 +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 } 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;
-}
-
-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 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({ stage: 'collecting' });
-      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({ stage, filesFound: info?.filesFound }),
-      });
-
-      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} />}
-      {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;
-}
-