codereview-aia 0.1.3 → 0.1.4

package/src/runtime/reporting/reportDataCollector.ts

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

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

@@ -1,200 +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 StageUpdate {
-  filesFound?: number;
-  currentFile?: string;
-  fileIndex?: number;
-  totalFiles?: number;
-  uncommittedFiles?: number;
-  contextFiles?: number;
-}
-
-export interface ReviewOptions {
-  model: string;
-  outDir: string;
-  debug?: boolean;
-  mode?: ReviewMode;
-  preprodTargetUrl?: string;
-  onStage?: (stage: ReviewStage, info?: StageUpdate) => 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;
-  fileBreakdown?: { uncommitted: number; context: number };
-  reportSummary?: string;
-  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 { targets, context, stats } = await collectFiles({ mode });
-  const fileCount = targets.length;
-
-  if (fileCount === 0) {
-    throw new Error('No files to review');
-  }
-
-  onStage?.('collecting', {
-    filesFound: fileCount,
-    uncommittedFiles: stats.uncommitted,
-    contextFiles: stats.context,
-  });
-  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();
-
-  const repoName = basename(workspaceRoot) || 'workspace';
-  try {
-    onStage?.('reviewing', {
-      filesFound: fileCount,
-      totalFiles: fileCount,
-      uncommittedFiles: stats.uncommitted,
-      contextFiles: stats.context,
-    });
-    const reports = await runAiCodeReview(targets, context, {
-      provider: 'openrouter',
-      type: 'comprehensive',
-      outDir: rawOutDir,
-      format: 'json',
-      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');
-    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 = repoName;
-    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,
-      fileBreakdown: { uncommitted: stats.uncommitted, context: stats.context },
-      reportSummary: summary,
-      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`;
-}