codereview-aia 0.1.2 → 0.1.3

package/src/index.ts

@@ -1,10 +1,7 @@
-#!/usr/bin/env node
 import logger from './utils/logger';
 import { ensureProxyEnvironmentInitialized } from './runtime/proxyEnvironment';
 import { handleRuntimeCliEntry } from './runtime/cliEntry';
 
-// Minimal bootstrap that wires the runtime CLI into the proxy-enabled environment.
-
 async function bootstrap(): Promise<void> {
   try {
     ensureProxyEnvironmentInitialized(process.cwd());

package/src/runtime/cliEntry.ts

@@ -164,12 +164,30 @@ async function runDirect(options: DirectOptions): Promise<void> {
       switch (stage) {
         case 'collecting':
           if (info?.filesFound !== undefined) {
-            console.log(pc.green(`✓ Found ${info.filesFound} files`));
+            const uncommitted = info.uncommittedFiles ?? info.filesFound;
+            const context = info.contextFiles ?? 0;
+            const breakdown = context ? ` (${uncommitted} uncommitted + ${context} context)` : '';
+            console.log(pc.green(`✓ Found ${info.filesFound} files${breakdown}`));
           }
           break;
-        case 'reviewing':
-          console.log(pc.blue('Running AI review...'));
+        case 'reviewing': {
+          const context = info?.contextFiles ?? 0;
+          const base = info?.uncommittedFiles ?? info?.filesFound;
+          const suffix =
+            base || context
+              ? ` (scope: ${base ?? '?'} uncommitted${context ? ` + ${context} context` : ''})`
+              : '';
+          const defaultLine = `Running AI review${suffix ? suffix : ''}...`;
+          const detailLine =
+            typeof info?.fileIndex === 'number' &&
+            typeof info.totalFiles === 'number' &&
+            info.totalFiles > 0 &&
+            info.currentFile
+              ? `Running AI review ▸ ${info.fileIndex}/${info.totalFiles} ${info.currentFile}${suffix}`
+              : defaultLine;
+          console.log(pc.blue(detailLine));
           break;
+        }
         case 'merging':
           console.log(pc.blue('Merging reports...'));
           break;

package/src/runtime/fileCollector.ts

@@ -1,15 +1,32 @@
-import { existsSync, statSync } from 'node:fs';
-import { relative as relativePath, resolve as resolvePath, isAbsolute as isAbsolutePath, join as joinPath } from 'node:path';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import {
+  relative as relativePath,
+  resolve as resolvePath,
+  isAbsolute as isAbsolutePath,
+  join as joinPath,
+  dirname as dirnamePath,
+} from 'node:path';
 import { execa } from 'execa';
 import { MissingCrIgnoreError } from './errors';
 
+export interface FileCollectionStats {
+  uncommitted: number;
+  context: number;
+}
+
+export interface FileCollectionResult {
+  targets: string[];
+  context: string[];
+  stats: FileCollectionStats;
+}
+
 export type FileCollectionMode = 'uncommitted' | 'preprod';
 
 export interface CollectFilesOptions {
   mode?: FileCollectionMode;
 }
 
-export async function collectFiles(options: CollectFilesOptions = {}): Promise<string[]> {
+export async function collectFiles(options: CollectFilesOptions = {}): Promise<FileCollectionResult> {
   try {
     const { stdout: rootOut } = await execa('git', ['rev-parse', '--show-toplevel']);
     const repoRoot = resolvePath(rootOut.trim());
@@ -115,8 +132,22 @@ export async function collectFiles(options: CollectFilesOptions = {}): Promise<s
       .map((file) => normalize(file))
       .filter((file): file is string => Boolean(file));
 
-    const gitFiltered = await excludeIgnored(repoRoot, resolved);
-    return await excludeCrIgnored(workspaceRoot, crIgnorePath, gitFiltered);
+    const baseSet = new Set(resolved);
+    const { combinedFiles, extras } = await augmentWithContext(resolved, workspaceRoot);
+    const extraSet = new Set(extras);
+
+    const gitFiltered = await excludeIgnored(repoRoot, combinedFiles);
+    const finalFiles = await excludeCrIgnored(workspaceRoot, crIgnorePath, gitFiltered);
+
+    const targets = finalFiles.filter((file) => baseSet.has(file));
+    const contextFiles = finalFiles.filter((file) => extraSet.has(file) && !baseSet.has(file));
+
+    const stats: FileCollectionStats = {
+      uncommitted: targets.length,
+      context: contextFiles.length,
+    };
+
+    return { targets, context: contextFiles, stats };
   } catch (error: any) {
     if (error.message?.includes('not a git repository')) {
       throw new Error('Not a git repository. Please run this command from a git repository root.');
@@ -125,6 +156,248 @@ export async function collectFiles(options: CollectFilesOptions = {}): Promise<s
   }
 }
 
+const CONTEXT_FILENAMES = [
+  'README.md',
+  'readme.md',
+  'README',
+  'README.mdx',
+  'CHANGELOG.md',
+  'changelog.md',
+  'HISTORY.md',
+  'history.md',
+  'package.json',
+  '.env.example',
+  '.env.sample',
+  '.env.template',
+  '.env.local.example',
+  '.env.production.example',
+];
+
+const DEPENDENCY_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mts', '.cts'];
+const MAX_CONTEXT_FILE_BYTES = 200 * 1024; // 200KB guardrail
+
+async function augmentWithContext(
+  files: string[],
+  workspaceRoot: string,
+): Promise<{ combinedFiles: string[]; extras: string[] }> {
+  if (files.length === 0) {
+    return { combinedFiles: files, extras: [] };
+  }
+
+  const baseSet = new Set(files);
+  const contextFiles = collectContextFiles(files, workspaceRoot);
+  const dependencyFiles = collectDependencyFiles(files, workspaceRoot);
+  const localMarkdownFiles = collectLocalMarkdownFiles(files);
+  const globalNamedFiles = await collectGlobalNamedContext(workspaceRoot);
+
+  const extras = Array.from(
+    new Set(
+      [...contextFiles, ...dependencyFiles, ...localMarkdownFiles, ...globalNamedFiles].filter(
+        (file) => !baseSet.has(file),
+      ),
+    ),
+  );
+
+  const combinedFiles = Array.from(new Set([...files, ...extras]));
+  return { combinedFiles, extras };
+}
+
+function collectContextFiles(files: string[], workspaceRoot: string): string[] {
+  const extras = new Set<string>();
+  const candidateDirs = new Set<string>();
+  files.forEach((file) => candidateDirs.add(dirnamePath(file)));
+  candidateDirs.add(workspaceRoot);
+
+  for (const dir of candidateDirs) {
+    for (const filename of CONTEXT_FILENAMES) {
+      const candidate = joinPath(dir, filename);
+      if (!candidate.startsWith(workspaceRoot)) {
+        continue;
+      }
+      try {
+        const stats = statSync(candidate);
+        if (stats.isFile() && stats.size <= MAX_CONTEXT_FILE_BYTES && isTextFile(candidate)) {
+          extras.add(candidate);
+        }
+      } catch {
+        // ignored
+      }
+    }
+  }
+
+  return Array.from(extras);
+}
+
+function collectDependencyFiles(files: string[], workspaceRoot: string): string[] {
+  const extras = new Set<string>();
+
+  for (const file of files) {
+    if (!isDependencyCandidate(file)) {
+      continue;
+    }
+
+    let content: string;
+    try {
+      content = readFileSync(file, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    const specifiers = extractImportSpecifiers(content);
+    if (specifiers.length === 0) {
+      continue;
+    }
+
+    const baseDir = dirnamePath(file);
+    for (const specifier of specifiers) {
+      const resolved = resolveImportSpecifier(specifier, baseDir, workspaceRoot);
+      if (resolved) {
+        extras.add(resolved);
+      }
+    }
+  }
+
+  return Array.from(extras);
+}
+
+function isDependencyCandidate(filePath: string): boolean {
+  const lower = filePath.toLowerCase();
+  return DEPENDENCY_EXTENSIONS.some((ext) => lower.endsWith(ext));
+}
+
+function extractImportSpecifiers(content: string): string[] {
+  const specifiers = new Set<string>();
+  const patterns = [
+    /import\s+[^;]*?from\s+['"]([^'"\n]+)['"]/g,
+    /import\s+['"]([^'"\n]+)['"]/g,
+    /export\s+[^;]*?from\s+['"]([^'"\n]+)['"]/g,
+    /require\(\s*['"]([^'"\n]+)['"]\s*\)/g,
+    /import\(\s*['"]([^'"\n]+)['"]\s*\)/g,
+  ];
+
+  for (const pattern of patterns) {
+    let match: RegExpExecArray | null;
+    while ((match = pattern.exec(content)) !== null) {
+      const spec = match[1];
+      if (spec && spec.startsWith('.')) {
+        specifiers.add(spec);
+      }
+    }
+  }
+
+  return Array.from(specifiers);
+}
+
+function resolveImportSpecifier(
+  specifier: string,
+  baseDir: string,
+  workspaceRoot: string,
+): string | null {
+  const cleaned = specifier.replace(/[#?].*$/, '');
+  const resolvedBase = resolvePath(baseDir, cleaned);
+  const candidates = new Set<string>([resolvedBase]);
+
+  const hasExtension = DEPENDENCY_EXTENSIONS.some((ext) => resolvedBase.endsWith(ext));
+  if (!hasExtension) {
+    for (const ext of DEPENDENCY_EXTENSIONS) {
+      candidates.add(`${resolvedBase}${ext}`);
+      candidates.add(joinPath(resolvedBase, `index${ext}`));
+    }
+  }
+
+  for (const candidate of candidates) {
+    if (!candidate.startsWith(workspaceRoot)) {
+      continue;
+    }
+    try {
+      const stats = statSync(candidate);
+      if (stats.isFile()) {
+        return candidate;
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return null;
+}
+
+function collectLocalMarkdownFiles(files: string[]): string[] {
+  const extras = new Set<string>();
+  const dirs = new Set<string>();
+  files.forEach((file) => dirs.add(dirnamePath(file)));
+
+  for (const dir of dirs) {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isFile()) {
+        continue;
+      }
+
+      const lower = entry.name.toLowerCase();
+      if (!lower.endsWith('.md') && !lower.endsWith('.mdx')) {
+        continue;
+      }
+
+      const fullPath = joinPath(dir, entry.name);
+      try {
+        const stats = statSync(fullPath);
+        if (stats.isFile() && stats.size <= MAX_CONTEXT_FILE_BYTES && isTextFile(fullPath)) {
+          extras.add(fullPath);
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  return Array.from(extras);
+}
+
+async function collectGlobalNamedContext(workspaceRoot: string): Promise<string[]> {
+  try {
+    const pathspecs = CONTEXT_FILENAMES.map((name) => `:(glob)**/${name}`);
+    const { stdout } = await execa('git', ['ls-files', '-z', '--', ...pathspecs], {
+      cwd: workspaceRoot,
+      reject: false,
+    });
+    if (!stdout) {
+      return [];
+    }
+
+    return stdout
+      .split('\0')
+      .filter(Boolean)
+      .map((rel) => resolvePath(workspaceRoot, rel))
+      .filter((abs) => {
+        try {
+          const stats = statSync(abs);
+          return stats.isFile() && stats.size <= MAX_CONTEXT_FILE_BYTES && isTextFile(abs);
+        } catch {
+          return false;
+        }
+      });
+  } catch {
+    return [];
+  }
+}
+
+function isTextFile(filePath: string): boolean {
+  try {
+    const buffer = readFileSync(filePath);
+    const sample = buffer.subarray(0, 4096);
+    return !sample.includes(0);
+  } catch {
+    return false;
+  }
+}
+
 async function listTrackedFiles(repoRoot: string, pathSpec: string): Promise<string[]> {
   const { stdout } = await execa('git', ['ls-files', '-z', '--', pathSpec], {
     cwd: repoRoot,

package/src/runtime/reviewPipeline.ts

@@ -15,13 +15,22 @@ 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?: { filesFound?: number }) => void;
+  onStage?: (stage: ReviewStage, info?: StageUpdate) => void;
 }
 
 export interface ReviewTotals {
@@ -37,6 +46,8 @@ export interface ReviewResult {
   duration: number;
   repo: string;
   filesReviewed: number;
+  fileBreakdown?: { uncommitted: number; context: number };
+  reportSummary?: string;
   reportPath?: string;
 }
 
@@ -45,14 +56,18 @@ export async function executeReview(options: ReviewOptions): Promise<ReviewResul
 
   onStage?.('collecting');
   logger.info('Collecting files for review', { mode, workspace: process.cwd() });
-  const files = await collectFiles({ mode });
-  const fileCount = files.length;
+  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 });
+  onStage?.('collecting', {
+    filesFound: fileCount,
+    uncommittedFiles: stats.uncommitted,
+    contextFiles: stats.context,
+  });
   logger.info('File collection complete', { fileCount });
 
   const workspaceRoot = process.cwd();
@@ -70,9 +85,15 @@ export async function executeReview(options: ReviewOptions): Promise<ReviewResul
 
   const start = Date.now();
 
+  const repoName = basename(workspaceRoot) || 'workspace';
   try {
-    onStage?.('reviewing', { filesFound: fileCount });
-    const reports = await runAiCodeReview(files, {
+    onStage?.('reviewing', {
+      filesFound: fileCount,
+      totalFiles: fileCount,
+      uncommittedFiles: stats.uncommitted,
+      contextFiles: stats.context,
+    });
+    const reports = await runAiCodeReview(targets, context, {
       provider: 'openrouter',
       type: 'comprehensive',
       outDir: rawOutDir,
@@ -80,6 +101,22 @@ export async function executeReview(options: ReviewOptions): Promise<ReviewResul
       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');
@@ -88,7 +125,7 @@ export async function executeReview(options: ReviewOptions): Promise<ReviewResul
       (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 repo = repoName;
     const duration = Math.round((Date.now() - start) / 1000);
     const reportTimestamp = new Date();
 
@@ -125,6 +162,8 @@ export async function executeReview(options: ReviewOptions): Promise<ReviewResul
       duration,
       repo,
       filesReviewed: fileCount,
+      fileBreakdown: { uncommitted: stats.uncommitted, context: stats.context },
+      reportSummary: summary,
       reportPath,
     };
   } finally {

package/src/runtime/runAiCodeReview.ts

@@ -1,11 +1,35 @@
 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 } from '../types/review';
+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;
@@ -14,10 +38,16 @@ export interface AiReviewOptions {
   model?: string;
   configPath?: string;
   debug?: boolean;
+  onFileProgress?: (payload: FileProgressPayload) => void;
+  runContext?: RunContext;
 }
 
-export async function runAiCodeReview(files: string[], opts: AiReviewOptions): Promise<any[]> {
-  if (files.length === 0) return [];
+export async function runAiCodeReview(
+  targetFiles: string[],
+  contextFiles: string[],
+  opts: AiReviewOptions,
+): Promise<any[]> {
+  if (targetFiles.length === 0) return [];
 
   const workspaceRoot = process.cwd();
   let repoRoot: string;
@@ -68,7 +98,7 @@ export async function runAiCodeReview(files: string[], opts: AiReviewOptions): P
   }
 
   const expandedFiles: string[] = [];
-  for (const file of files) {
+  for (const file of targetFiles) {
     const absPath = resolve(file);
     try {
       const stats = statSync(absPath);
@@ -144,10 +174,135 @@ export async function runAiCodeReview(files: string[], opts: AiReviewOptions): P
     baseOptions.config = opts.configPath;
   }
 
-  for (const target of targets) {
-    await orchestrateReview(target, baseOptions);
+  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);
+}