codereview-aia 0.1.1 → 0.1.3

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/debug/logManager.ts

@@ -0,0 +1,37 @@
+import { mkdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { disableFileLogging, enableFileLogging } from '../../utils/logger';
+
+export interface DebugLogSession {
+  filePath: string;
+  stop: () => void;
+}
+
+function formatTimestamp(date: Date): string {
+  const pad = (value: number) => value.toString().padStart(2, '0');
+  const year = date.getFullYear();
+  const month = pad(date.getMonth() + 1);
+  const day = pad(date.getDate());
+  const hours = pad(date.getHours());
+  const minutes = pad(date.getMinutes());
+  const seconds = pad(date.getSeconds());
+  return `${year}${month}${day}-${hours}${minutes}${seconds}`;
+}
+
+export function startDebugLogSession(workspaceRoot: string): DebugLogSession {
+  const logsDir = resolve(workspaceRoot, 'logs');
+  mkdirSync(logsDir, { recursive: true });
+
+  const timestamp = formatTimestamp(new Date());
+  const fileName = `cr-debug-${timestamp}.log`;
+  const filePath = join(logsDir, fileName);
+
+  enableFileLogging(filePath);
+
+  return {
+    filePath,
+    stop: () => {
+      disableFileLogging();
+    },
+  };
+}

package/src/runtime/fileCollector.ts

@@ -1,9 +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 async function collectFiles(): Promise<string[]> {
+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<FileCollectionResult> {
   try {
     const { stdout: rootOut } = await execa('git', ['rev-parse', '--show-toplevel']);
     const repoRoot = resolvePath(rootOut.trim());
@@ -58,45 +81,73 @@ export async function collectFiles(): Promise<string[]> {
       return absolutePath;
     };
 
-    const gitWorkspaceOptions = { cwd: workspaceRoot } as const;
-    const gitPathSpec = ['--', '.'] as const;
+    const mode: FileCollectionMode = options.mode ?? 'uncommitted';
 
-    const { stdout: statusOut } = await execa('git', ['status', '--porcelain=1', '-z', ...gitPathSpec], gitWorkspaceOptions);
-    const { stdout: diffOut } = await execa('git', ['diff', '--name-only', '-z', ...gitPathSpec], gitWorkspaceOptions);
+    const collectUncommittedFiles = async (): Promise<string[]> => {
+      const gitWorkspaceOptions = { cwd: workspaceRoot } as const;
+      const gitPathSpec = ['--', '.'] as const;
 
-    const statusEntries = statusOut.split('\0').filter(Boolean);
-    const statusFiles: string[] = [];
+      const { stdout: statusOut } = await execa('git', ['status', '--porcelain=1', '-z', ...gitPathSpec], gitWorkspaceOptions);
+      const { stdout: diffOut } = await execa('git', ['diff', '--name-only', '-z', ...gitPathSpec], gitWorkspaceOptions);
 
-    for (let i = 0; i < statusEntries.length; i += 1) {
-      const entry = statusEntries[i];
-      const statusPrefix = entry.slice(0, 3);
-      const pathPart = entry.slice(3).trim();
+      const statusEntries = statusOut.split('\0').filter(Boolean);
+      const statusFiles: string[] = [];
 
-      if (!pathPart) {
-        continue;
-      }
+      for (let i = 0; i < statusEntries.length; i += 1) {
+        const entry = statusEntries[i];
+        const statusPrefix = entry.slice(0, 3);
+        const pathPart = entry.slice(3).trim();
 
-      if (statusPrefix.trim().startsWith('R')) {
-        const renamedTarget = statusEntries[i + 1];
-        if (renamedTarget) {
-          statusFiles.push(renamedTarget);
-          i += 1;
+        if (!pathPart) {
           continue;
         }
+
+        if (statusPrefix.trim().startsWith('R')) {
+          const renamedTarget = statusEntries[i + 1];
+          if (renamedTarget) {
+            statusFiles.push(renamedTarget);
+            i += 1;
+            continue;
+          }
+        }
+
+        statusFiles.push(pathPart);
       }
 
-      statusFiles.push(pathPart);
-    }
+      const diffFiles = diffOut.split('\0').filter(Boolean);
+      const unique = new Set([...statusFiles, ...diffFiles]);
+      return Array.from(unique);
+    };
 
-    const diffFiles = diffOut.split('\0').filter(Boolean);
-    const unique = new Set([...statusFiles, ...diffFiles]);
+    const collectWorkspaceFiles = async (): Promise<string[]> => {
+      const pathSpec = workspaceRelative === '' ? '.' : workspaceRelative;
+      const tracked = await listTrackedFiles(repoRoot, pathSpec || '.');
+      const untracked = await listUntrackedFiles(repoRoot, pathSpec || '.');
+      return Array.from(new Set([...tracked, ...untracked]));
+    };
+
+    const pendingFiles = mode === 'preprod' ? await collectWorkspaceFiles() : await collectUncommittedFiles();
 
-    const resolved = Array.from(unique)
+    const resolved = pendingFiles
       .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.');
@@ -105,6 +156,262 @@ export async function collectFiles(): Promise<string[]> {
   }
 }
 
+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,
+  });
+  return stdout.split('\0').filter(Boolean);
+}
+
+async function listUntrackedFiles(repoRoot: string, pathSpec: string): Promise<string[]> {
+  const { stdout } = await execa('git', ['ls-files', '-z', '--others', '--exclude-standard', '--', pathSpec], {
+    cwd: repoRoot,
+  });
+  return stdout.split('\0').filter(Boolean);
+}
+
 async function excludeIgnored(repoRoot: string, files: string[]): Promise<string[]> {
   if (files.length === 0) {
     return [];

package/src/runtime/preprod/webCheck.ts

@@ -0,0 +1,104 @@
+const DEFAULT_AIA_BASE_URL = 'https://ai.enki.si';
+
+function resolveAiaBaseUrl(): string {
+  const configured = process.env.AIA_BASE_URL || process.env.CR_AIA_AIA_BASE_URL;
+  const base = (configured || DEFAULT_AIA_BASE_URL).trim();
+  return base.replace(/\/$/, '');
+}
+
+function summarizeErrorBody(body: string): string {
+  if (!body.trim()) {
+    return 'No response body';
+  }
+
+  if (/<html/i.test(body)) {
+    const sanitized = body
+      .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+      .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+      .replace(/<[^>]+>/g, ' ')
+      .replace(/\s+/g, ' ')
+      .trim();
+    return sanitized ? `${sanitized.slice(0, 200)}${sanitized.length > 200 ? '…' : ''}` : 'HTML error response';
+  }
+
+  const normalized = body.replace(/\s+/g, ' ').trim();
+  if (!normalized) {
+    return 'Empty error body';
+  }
+  return normalized.length > 200 ? `${normalized.slice(0, 200)}…` : normalized;
+}
+
+class WebCheckRequestError extends Error {
+  status?: number;
+  detail?: string;
+
+  constructor(message: string, options?: { status?: number; detail?: string; cause?: unknown }) {
+    super(message, options?.cause ? { cause: options.cause } : undefined);
+    this.name = 'WebCheckRequestError';
+    this.status = options?.status;
+    this.detail = options?.detail;
+  }
+}
+
+async function extractErrorDetail(response: Response): Promise<string | undefined> {
+  const contentType = response.headers.get('content-type') || '';
+  if (contentType.includes('application/json')) {
+    try {
+      const payload = (await response.json()) as { error?: { message?: string }; message?: string };
+      return payload?.error?.message || payload?.message || JSON.stringify(payload);
+    } catch {
+      return undefined;
+    }
+  }
+
+  try {
+    const textBody = await response.text();
+    return summarizeErrorBody(textBody);
+  } catch {
+    return undefined;
+  }
+}
+
+async function sendWebCheckRequest(endpoint: string, payload: Record<string, unknown>): Promise<void> {
+  let response: Response;
+  try {
+    response = await fetch(endpoint, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(payload),
+    });
+  } catch (networkError) {
+    const message =
+      networkError instanceof Error ? networkError.message : 'Website check request failed due to an unknown error';
+    throw new WebCheckRequestError(`Website check request failed: ${message}`, { cause: networkError });
+  }
+
+  if (!response.ok) {
+    const detail = await extractErrorDetail(response);
+    const suffix = detail ? ` ${detail}` : '';
+    throw new WebCheckRequestError(`Website check failed (${response.status}).${suffix}`, {
+      status: response.status,
+      detail,
+    });
+  }
+}
+
+export async function triggerManualWebCheck(targetUrl: string): Promise<void> {
+  const baseUrl = resolveAiaBaseUrl();
+  const manualEndpoint = `${baseUrl}/api/manual/check`;
+  const legacyEndpoint = `${baseUrl}/api/check-website`;
+  const missingEndpointStatuses = new Set([404, 405, 501]);
+
+  try {
+    await sendWebCheckRequest(manualEndpoint, { url: targetUrl });
+    return;
+  } catch (error) {
+    if (!(error instanceof WebCheckRequestError) || !error.status || !missingEndpointStatuses.has(error.status)) {
+      throw error;
+    }
+  }
+
+  await sendWebCheckRequest(legacyEndpoint, { url: targetUrl, options: {} });
+}