codereview-aia 0.1.3 → 0.1.4

package/src/runtime/debug/logManager.ts

@@ -1,37 +0,0 @@
-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/errors.ts

@@ -1,13 +0,0 @@
-export class MissingCrIgnoreError extends Error {
-  readonly workspaceRoot: string;
-  readonly crIgnorePath: string;
-
-  constructor(workspaceRoot: string, crIgnorePath: string) {
-    super(
-      `cr-aia needs a .crignore file in ${workspaceRoot}. Create one (can be empty, gitignore syntax) and rerun.`,
-    );
-    this.name = 'MissingCrIgnoreError';
-    this.workspaceRoot = workspaceRoot;
-    this.crIgnorePath = crIgnorePath;
-  }
-}

package/src/runtime/fileCollector.ts

@@ -1,495 +0,0 @@
-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<FileCollectionResult> {
-  try {
-    const { stdout: rootOut } = await execa('git', ['rev-parse', '--show-toplevel']);
-    const repoRoot = resolvePath(rootOut.trim());
-    const workspaceRoot = resolvePath(process.cwd());
-    const workspaceRelative = relativePath(repoRoot, workspaceRoot) || '.';
-
-    if (workspaceRelative.startsWith('..')) {
-      throw new Error('Workspace is outside of the current git repository.');
-    }
-
-    const crIgnorePath = joinPath(workspaceRoot, '.crignore');
-    if (!existsSync(crIgnorePath)) {
-      throw new MissingCrIgnoreError(workspaceRoot, crIgnorePath);
-    }
-
-    const isWithinWorkspace = (absolutePath: string): boolean => {
-      if (workspaceRoot === repoRoot) {
-        return true;
-      }
-
-      const rel = relativePath(workspaceRoot, absolutePath);
-      if (rel === '') {
-        return true;
-      }
-
-      return !rel.startsWith('..') && !isAbsolutePath(rel);
-    };
-
-    const normalize = (filePath: string | undefined | null): string | null => {
-      if (!filePath) {
-        return null;
-      }
-
-      if (filePath.startsWith('.git/') || filePath.includes('node_modules')) {
-        return null;
-      }
-
-      const absolutePath = resolvePath(repoRoot, filePath);
-      if (!isWithinWorkspace(absolutePath)) {
-        return null;
-      }
-
-      if (!existsSync(absolutePath)) {
-        return null;
-      }
-
-      const stats = statSync(absolutePath);
-      if (!stats.isFile()) {
-        return null;
-      }
-
-      return absolutePath;
-    };
-
-    const mode: FileCollectionMode = options.mode ?? 'uncommitted';
-
-    const collectUncommittedFiles = async (): Promise<string[]> => {
-      const gitWorkspaceOptions = { cwd: workspaceRoot } as const;
-      const gitPathSpec = ['--', '.'] as const;
-
-      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 statusEntries = statusOut.split('\0').filter(Boolean);
-      const statusFiles: string[] = [];
-
-      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 (!pathPart) {
-          continue;
-        }
-
-        if (statusPrefix.trim().startsWith('R')) {
-          const renamedTarget = statusEntries[i + 1];
-          if (renamedTarget) {
-            statusFiles.push(renamedTarget);
-            i += 1;
-            continue;
-          }
-        }
-
-        statusFiles.push(pathPart);
-      }
-
-      const diffFiles = diffOut.split('\0').filter(Boolean);
-      const unique = new Set([...statusFiles, ...diffFiles]);
-      return Array.from(unique);
-    };
-
-    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 = pendingFiles
-      .map((file) => normalize(file))
-      .filter((file): file is string => Boolean(file));
-
-    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.');
-    }
-    throw error;
-  }
-}
-
-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 [];
-  }
-
-  const relPaths = files.map((file) => {
-    const rel = relativePath(repoRoot, file);
-    return rel.replace(/\\/g, '/');
-  });
-
-  const { stdout, exitCode } = await execa('git', ['check-ignore', '--stdin'], {
-    cwd: repoRoot,
-    input: relPaths.join('\n'),
-    reject: false,
-  });
-
-  if (exitCode !== 0 && exitCode !== 1) {
-    throw new Error(`git check-ignore failed with code ${exitCode}`);
-  }
-
-  if (!stdout) {
-    return files;
-  }
-
-  const ignored = new Set(
-    stdout
-      .split('\n')
-      .map((line) => line.trim())
-      .filter(Boolean),
-  );
-
-  return files.filter((_, index) => !ignored.has(relPaths[index]));
-}
-
-async function excludeCrIgnored(
-  workspaceRoot: string,
-  ignoreFile: string,
-  files: string[],
-): Promise<string[]> {
-  if (files.length === 0) {
-    return [];
-  }
-
-  const entries = files
-    .map((file) => {
-      const rel = relativePath(workspaceRoot, file).replace(/\\/g, '/');
-      return { file, rel };
-    })
-    .filter((entry) => entry.rel && entry.rel !== '.crignore');
-
-  if (entries.length === 0) {
-    return [];
-  }
-
-  const { stdout, exitCode } = await execa(
-    'git',
-    ['-c', `core.excludesFile=${ignoreFile}`, 'check-ignore', '--stdin'],
-    {
-      cwd: workspaceRoot,
-      input: entries.map((entry) => entry.rel).join('\n'),
-      reject: false,
-    },
-  );
-
-  if (exitCode !== 0 && exitCode !== 1) {
-    throw new Error(`git check-ignore (crignore) failed with code ${exitCode}`);
-  }
-
-  if (!stdout) {
-    return entries.map((entry) => entry.file);
-  }
-
-  const ignored = new Set(
-    stdout
-      .split('\n')
-      .map((line) => line.trim())
-      .filter(Boolean),
-  );
-
-  return entries.filter((entry) => !ignored.has(entry.rel)).map((entry) => entry.file);
-}

package/src/runtime/manifest.ts

@@ -1,64 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import yaml from 'js-yaml';
-
-const DEFAULT_MANIFEST: Record<string, unknown> = {
-  rules: {
-    universal: {
-      secret_leaks: 'high',
-      todos_left: 'medium',
-      dead_code: 'medium',
-      license_headers: 'low',
-    },
-    ts: {
-      no_any: 'high',
-      prefer_readonly: 'medium',
-      exhaustiveness_in_switch: 'high',
-    },
-    py: {
-      type_hints_required: 'medium',
-      no_bare_except: 'high',
-    },
-    go: {
-      errcheck_required: 'high',
-      context_passthrough: 'medium',
-    },
-  },
-  policies: {
-    fail_on: 'critical',
-  },
-  outputs: {
-    report: 'json',
-  },
-};
-
-export function loadManifest(repoRoot: string): Record<string, unknown> {
-  const defaultManifest = clone(DEFAULT_MANIFEST);
-
-  const overridePaths = [join(repoRoot, 'cr-manifest.yml'), join(repoRoot, '.cr-aia.yml')];
-
-  for (const overridePath of overridePaths) {
-    if (existsSync(overridePath)) {
-      const override = yaml.load(readFileSync(overridePath, 'utf-8')) as Record<string, unknown>;
-      return deepMerge(defaultManifest, override);
-    }
-  }
-
-  return defaultManifest;
-}
-
-function deepMerge(defaultObj: Record<string, any>, overrideObj: Record<string, any>): Record<string, any> {
-  const result: Record<string, any> = { ...defaultObj };
-  for (const key of Object.keys(overrideObj)) {
-    if (typeof overrideObj[key] === 'object' && overrideObj[key] !== null && !Array.isArray(overrideObj[key])) {
-      result[key] = deepMerge((result[key] as Record<string, any>) || {}, overrideObj[key] as Record<string, any>);
-    } else {
-      result[key] = overrideObj[key];
-    }
-  }
-  return result;
-}
-
-function clone<T>(value: T): T {
-  return JSON.parse(JSON.stringify(value));
-}

package/src/runtime/openrouterProxy.ts

@@ -1,45 +0,0 @@
-const DEFAULT_PROXY_BASE_URL = 'https://cr.ai.enki.si';
-
-export function getProxyBaseUrl(): string {
-  return process.env.CR_AIA_PROXY_BASE_URL || DEFAULT_PROXY_BASE_URL;
-}
-
-export function resolveOpenRouterProxyUrl(): string {
-  const base = getProxyBaseUrl().replace(/\/$/, '');
-  if (base.endsWith('/openrouter-proxy')) {
-    return base;
-  }
-  if (base.endsWith('/proxy')) {
-    return `${base.replace(/\/proxy$/, '')}/openrouter-proxy`;
-  }
-  return `${base}/openrouter-proxy`;
-}
-
-export function buildOpenRouterProxyHeaders(): Record<string, string> {
-  const headers: Record<string, string> = {
-    'Content-Type': 'application/json',
-  };
-
-  const sessionToken = process.env.CR_AIA_PROXY_SESSION_TOKEN;
-  if (!sessionToken) {
-    throw new Error(
-      'Missing session token. Run `node dist/index.js`, sign in, or set CR_AIA_PROXY_SESSION_TOKEN before running reviews.',
-    );
-  }
-
-  headers.Authorization = `Bearer ${sessionToken}`;
-  headers['x-session-token'] = sessionToken;
-
-  return headers;
-}
-
-export function withProxyMetadata(payload: Record<string, unknown>): Record<string, unknown> {
-  const enriched = { ...payload };
-  if (process.env.CR_AIA_PROXY_HTTP_REFERER && enriched['http_referer'] === undefined) {
-    enriched['http_referer'] = process.env.CR_AIA_PROXY_HTTP_REFERER;
-  }
-  if (enriched['x_title'] === undefined) {
-    enriched['x_title'] = process.env.CR_AIA_PROXY_X_TITLE || 'cr-aia';
-  }
-  return enriched;
-}