codereview-aia 0.1.0

package/src/runtime/reporting/reportDataCollector.ts

@@ -0,0 +1,234 @@
+import type { StructuredDataReport, StructuredIssue } from '../reportMerge';
+import type { ReviewTotals } from '../reviewPipeline';
+
+export type IssueSeverity = 'critical' | 'high' | 'medium' | 'low';
+
+export interface NormalizedIssue {
+  filePath: string;
+  severity: IssueSeverity;
+  title?: string;
+  description?: string;
+  impact?: string;
+  suggestedFix?: string;
+  lineLabel?: string;
+  lineStart?: number;
+  lineEnd?: number;
+}
+
+export interface FileIssueGroup {
+  filePath: string;
+  issues: NormalizedIssue[];
+}
+
+export interface TokenStats {
+  totalTokens: number;
+  inputTokens: number;
+  outputTokens: number;
+}
+
+export interface CollectedReportData {
+  totals: ReviewTotals;
+  groupedIssues: FileIssueGroup[];
+  tokenStats?: TokenStats;
+  estimatedCostUSD?: number;
+  issueCount: number;
+}
+
+const SEVERITY_ORDER: Record<IssueSeverity, number> = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3,
+};
+
+function normalizeSeverity(priority?: string): IssueSeverity {
+  const normalized = priority?.toLowerCase().trim();
+  if (normalized === 'critical') return 'critical';
+  if (normalized === 'high') return 'high';
+  if (normalized === 'low') return 'low';
+  return 'medium';
+}
+
+function parseLineLabel(lineNumbers?: string): {
+  label?: string;
+  start?: number;
+  end?: number;
+} {
+  if (!lineNumbers) {
+    return {};
+  }
+
+  const trimmed = lineNumbers.trim();
+  if (!trimmed) {
+    return {};
+  }
+
+  const match = trimmed.match(/^(\d+)(?:\s*-\s*(\d+))?$/);
+  if (!match) {
+    return { label: trimmed };
+  }
+
+  const start = Number.parseInt(match[1], 10);
+  const end = match[2] ? Number.parseInt(match[2], 10) : start;
+  const label = start === end ? `${start}` : `${start}-${end}`;
+
+  return { label, start, end };
+}
+
+function toNumber(value: unknown): number | undefined {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === 'string') {
+    const parsed = Number.parseFloat(value);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return undefined;
+}
+
+function extractIssues(reports: StructuredDataReport[]): NormalizedIssue[] {
+  const issues: NormalizedIssue[] = [];
+
+  for (const report of reports) {
+    let structuredIssues: StructuredIssue[] | undefined = report.structuredData?.issues;
+
+    if (!structuredIssues && typeof report.structuredData === 'string') {
+      try {
+        const parsed = JSON.parse(report.structuredData);
+        structuredIssues = parsed?.issues;
+      } catch {
+        structuredIssues = undefined;
+      }
+    }
+
+    if (!Array.isArray(structuredIssues)) {
+      continue;
+    }
+
+    for (const issue of structuredIssues) {
+      const filePath = issue.filePath?.trim() || 'Unspecified file';
+      const severity = normalizeSeverity(issue.priority);
+      const { label, start, end } = parseLineLabel(issue.lineNumbers);
+
+      issues.push({
+        filePath,
+        severity,
+        title: issue.title,
+        description: issue.description,
+        impact: issue.impact,
+        suggestedFix: issue.suggestedFix,
+        lineLabel: label,
+        lineStart: start,
+        lineEnd: end,
+      });
+    }
+  }
+
+  return issues;
+}
+
+function groupIssuesByFile(issues: NormalizedIssue[]): FileIssueGroup[] {
+  const groups = new Map<string, NormalizedIssue[]>();
+
+  for (const issue of issues) {
+    if (!groups.has(issue.filePath)) {
+      groups.set(issue.filePath, []);
+    }
+    groups.get(issue.filePath)!.push(issue);
+  }
+
+  const sortedGroups = Array.from(groups.entries())
+    .map(([filePath, fileIssues]) => {
+      fileIssues.sort((a, b) => {
+        const severityDiff = SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity];
+        if (severityDiff !== 0) {
+          return severityDiff;
+        }
+        if (a.lineStart && b.lineStart) {
+          return a.lineStart - b.lineStart;
+        }
+        return (a.title || '').localeCompare(b.title || '');
+      });
+
+      return { filePath, issues: fileIssues };
+    })
+    .sort((a, b) => a.filePath.localeCompare(b.filePath));
+
+  return sortedGroups;
+}
+
+function aggregateCostInfo(reports: StructuredDataReport[]): {
+  tokenStats?: TokenStats;
+  estimatedCostUSD?: number;
+} {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let estimatedCost = 0;
+  let hasCostInfo = false;
+
+  for (const report of reports) {
+    const costInfo = (report.costInfo || (report as any).costInfo) as Record<string, unknown> | undefined;
+    if (!costInfo) continue;
+
+    const input = toNumber(costInfo.inputTokens);
+    const output = toNumber(costInfo.outputTokens);
+    const total = toNumber(costInfo.totalTokens);
+    const estimate = toNumber(costInfo.estimatedCost ?? costInfo.cost);
+
+    if (input) {
+      inputTokens += input;
+      hasCostInfo = true;
+    }
+    if (output) {
+      outputTokens += output;
+      hasCostInfo = true;
+    }
+    if (estimate) {
+      estimatedCost += estimate;
+      hasCostInfo = true;
+    }
+
+    if (!input && !output && total && !Number.isNaN(total)) {
+      // If total tokens is provided without split, distribute evenly.
+      inputTokens += total / 2;
+      outputTokens += total / 2;
+      hasCostInfo = true;
+    }
+  }
+
+  if (!hasCostInfo) {
+    return {};
+  }
+
+  return {
+    tokenStats: {
+      inputTokens: Math.round(inputTokens),
+      outputTokens: Math.round(outputTokens),
+      totalTokens: Math.round(inputTokens + outputTokens),
+    },
+    estimatedCostUSD: estimatedCost || undefined,
+  };
+}
+
+export function collectReportData(reports: StructuredDataReport[]): CollectedReportData {
+  const issues = extractIssues(reports);
+  const groupedIssues = groupIssuesByFile(issues);
+
+  // Derive severity totals if missing (default zero).
+  const totals: ReviewTotals = { critical: 0, high: 0, medium: 0, low: 0 };
+  for (const issue of issues) {
+    totals[issue.severity] += 1;
+  }
+
+  const { tokenStats, estimatedCostUSD } = aggregateCostInfo(reports);
+
+  return {
+    totals,
+    groupedIssues,
+    tokenStats,
+    estimatedCostUSD,
+    issueCount: issues.length,
+  };
+}

package/src/runtime/reporting/summaryGenerator.ts

@@ -0,0 +1,86 @@
+import { buildOpenRouterProxyHeaders, resolveOpenRouterProxyUrl, withProxyMetadata } from '../openrouterProxy';
+import type { ReviewTotals } from '../reviewPipeline';
+import logger from '../../utils/logger';
+
+interface SummaryGeneratorOptions {
+  model?: string;
+  totals: ReviewTotals;
+  durationSeconds: number;
+  estimatedCostUSD?: number;
+  issueCount: number;
+}
+
+function buildFallbackSummary(options: SummaryGeneratorOptions): string {
+  const parts: string[] = [];
+  const { totals, durationSeconds, estimatedCostUSD, issueCount } = options;
+  const totalIssues = issueCount || totals.critical + totals.high + totals.medium + totals.low;
+  parts.push(
+    `Review completed in ${Math.round(durationSeconds)}s with ${totalIssues} tracked issues ` +
+      `(critical ${totals.critical}, high ${totals.high}, medium ${totals.medium}, low ${totals.low}).`,
+  );
+
+  if (typeof estimatedCostUSD === 'number') {
+    parts.push(`Approximate spend: $${estimatedCostUSD.toFixed(estimatedCostUSD < 1 ? 4 : 2)} USD.`);
+  }
+
+  return parts.join(' ');
+}
+
+export async function generateReportSummary(
+  markdownDraft: string,
+  options: SummaryGeneratorOptions,
+): Promise<string> {
+  const summaryModel = process.env.CR_AIA_SUMMARY_MODEL || options.model;
+  if (!summaryModel) {
+    return buildFallbackSummary(options);
+  }
+
+  const [, modelName] = summaryModel.includes(':')
+    ? summaryModel.split(':')
+    : ['openrouter', summaryModel];
+
+  const systemPrompt = `You are an engineering lead summarizing a comprehensive code review report.
+Provide 2-3 sentences capturing:
+- Overall health of the reviewed codebase
+- Highest-risk themes or repeating issues
+- Notable spend/time observations if they appear.
+Keep it factual and concise.`;
+
+  const payload = withProxyMetadata({
+    model: modelName,
+    temperature: 0.2,
+    max_tokens: 200,
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: markdownDraft },
+    ],
+  });
+
+  try {
+    const response = await fetch(resolveOpenRouterProxyUrl(), {
+      method: 'POST',
+      headers: buildOpenRouterProxyHeaders(),
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      const errorData = await response.text();
+      logger.warn(`AI summary generation failed (${response.status}): ${errorData}`);
+      return buildFallbackSummary(options);
+    }
+
+    const data = await response.json();
+    const content = data?.choices?.[0]?.message?.content?.trim();
+    if (content) {
+      return content;
+    }
+
+    logger.warn('AI summary response missing content, falling back to deterministic summary.');
+    return buildFallbackSummary(options);
+  } catch (error) {
+    logger.warn(
+      `Unable to generate AI summary: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    return buildFallbackSummary(options);
+  }
+}

package/src/runtime/reviewPipeline.ts

@@ -0,0 +1,155 @@
+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 { 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';
+
+export type ReviewStage = 'collecting' | 'reviewing' | 'merging';
+
+export interface ReviewOptions {
+  model: string;
+  outDir: string;
+  debug?: boolean;
+  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 } = options;
+
+  onStage?.('collecting');
+  const files = await collectFiles();
+  const fileCount = files.length;
+
+  if (fileCount === 0) {
+    throw new Error('No files to review');
+  }
+
+  onStage?.('collecting', { filesFound: 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

@@ -0,0 +1,153 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,57 @@
+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);
+}
+