codereview-aia 0.1.0

package/src/runtime/fileCollector.ts

@@ -0,0 +1,188 @@
+import { existsSync, statSync } from 'node:fs';
+import { relative as relativePath, resolve as resolvePath, isAbsolute as isAbsolutePath, join as joinPath } from 'node:path';
+import { execa } from 'execa';
+import { MissingCrIgnoreError } from './errors';
+
+export async function collectFiles(): Promise<string[]> {
+  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 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]);
+
+    const resolved = Array.from(unique)
+      .map((file) => normalize(file))
+      .filter((file): file is string => Boolean(file));
+
+    const gitFiltered = await excludeIgnored(repoRoot, resolved);
+    return await excludeCrIgnored(workspaceRoot, crIgnorePath, gitFiltered);
+  } 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;
+  }
+}
+
+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

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

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

package/src/runtime/proxyConfig.ts

@@ -0,0 +1,94 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import yaml from 'js-yaml';
+
+export interface ProxySettings {
+  baseUrl: string;
+  httpReferer?: string;
+  xTitle?: string;
+}
+
+const CR_AIA_CONFIG_CANDIDATES = ['.cr-aia.yml'];
+const DEFAULT_PROXY_BASE_URL = 'https://cr.ai.enki.si';
+
+export function loadProxySettings(repoRoot: string): ProxySettings {
+  const config = loadCrAiaConfig(repoRoot);
+  const scopedConfig = config && typeof config === 'object' ? getScopedConfig(config) : undefined;
+
+  const envBase = sanitize(process.env.PROXY_BASE_URL);
+  const fileBase = getFirstDefined<string>(config, scopedConfig, ['proxy_base_url', 'proxyBaseUrl']);
+
+  const httpReferer =
+    sanitize(process.env.PROXY_HTTP_REFERER) ||
+    getFirstDefined<string>(config, scopedConfig, ['http_referer', 'httpReferer']);
+
+  const xTitle =
+    sanitize(process.env.PROXY_X_TITLE) ||
+    getFirstDefined<string>(config, scopedConfig, ['x_title', 'xTitle']);
+
+  const baseUrl = envBase || fileBase || DEFAULT_PROXY_BASE_URL;
+
+  const settings: ProxySettings = {
+    baseUrl,
+  };
+
+  if (httpReferer) settings.httpReferer = httpReferer;
+  if (xTitle) settings.xTitle = xTitle;
+  return settings;
+}
+
+function sanitize(value: string | undefined): string | undefined {
+  return value && value.trim() ? value.trim() : undefined;
+}
+
+function loadCrAiaConfig(repoRoot: string): any | undefined {
+  for (const candidate of CR_AIA_CONFIG_CANDIDATES) {
+    const filePath = join(repoRoot, candidate);
+    if (!existsSync(filePath)) continue;
+
+    try {
+      const raw = readFileSync(filePath, 'utf-8');
+      if (candidate.endsWith('.json')) {
+        return JSON.parse(raw);
+      }
+      return yaml.load(raw);
+    } catch {
+      return undefined;
+    }
+  }
+  return undefined;
+}
+
+function getScopedConfig(config: Record<string, any>): Record<string, any> | undefined {
+  if (!config) return undefined;
+  if (typeof config.cr_aia === 'object') return config.cr_aia as Record<string, any>;
+  if (typeof config.crAia === 'object') return config.crAia as Record<string, any>;
+  if (typeof config['cr-aia'] === 'object') return config['cr-aia'] as Record<string, any>;
+  return undefined;
+}
+
+function getFirstDefined<T>(
+  rootConfig: Record<string, any> | undefined,
+  scopedConfig: Record<string, any> | undefined,
+  keys: string[],
+): T | undefined {
+  for (const key of keys) {
+    const scopedValue = scopedConfig ? getNested(scopedConfig, key) : undefined;
+    if (scopedValue !== undefined) return scopedValue as T;
+
+    const rootValue = rootConfig ? getNested(rootConfig, key) : undefined;
+    if (rootValue !== undefined) return rootValue as T;
+  }
+  return undefined;
+}
+
+function getNested(obj: Record<string, any>, pathKey: string): any {
+  const segments = pathKey.split('.');
+  let current: any = obj;
+  for (const segment of segments) {
+    if (!current || typeof current !== 'object') return undefined;
+    if (!(segment in current)) return undefined;
+    current = current[segment];
+  }
+  return current;
+}

package/src/runtime/proxyEnvironment.ts

@@ -0,0 +1,71 @@
+import type { ProxySettings } from './proxyConfig';
+import { loadProxySettings } from './proxyConfig';
+import { getSessionToken } from './auth/session';
+
+let cachedSettings: ProxySettings | null = null;
+
+function proxySuppliesApiKey(settings: ProxySettings): boolean {
+  const override = process.env.CR_AIA_PROXY_SUPPLIES_API_KEY;
+  if (override && override.trim()) {
+    return override.trim().toLowerCase() !== 'false';
+  }
+  return settings.baseUrl.toLowerCase().includes('cr.ai.enki.si');
+}
+
+function ensureApiKeyPlaceholder(settings: ProxySettings): void {
+  if (!proxySuppliesApiKey(settings)) {
+    return;
+  }
+
+  const placeholder = process.env.CR_AIA_PROXY_API_KEY_PLACEHOLDER || 'provided-by-proxy';
+
+  if (!process.env.AI_CODE_REVIEW_OPENROUTER_API_KEY) {
+    process.env.AI_CODE_REVIEW_OPENROUTER_API_KEY = placeholder;
+  }
+
+  if (!process.env.OPENROUTER_API_KEY) {
+    process.env.OPENROUTER_API_KEY = placeholder;
+  }
+}
+
+function applyProxySettings(settings: ProxySettings): void {
+  process.env.CR_AIA_PROXY_BASE_URL = settings.baseUrl;
+
+  if (settings.httpReferer) {
+    process.env.CR_AIA_PROXY_HTTP_REFERER = settings.httpReferer;
+  } else {
+    delete process.env.CR_AIA_PROXY_HTTP_REFERER;
+  }
+
+  if (settings.xTitle) {
+    process.env.CR_AIA_PROXY_X_TITLE = settings.xTitle;
+  } else {
+    delete process.env.CR_AIA_PROXY_X_TITLE;
+  }
+
+  ensureApiKeyPlaceholder(settings);
+  ensureSessionToken();
+}
+
+function ensureSessionToken(): void {
+  if (process.env.CR_AIA_PROXY_SESSION_TOKEN && process.env.CR_AIA_PROXY_SESSION_TOKEN.trim()) {
+    return;
+  }
+
+  const token = getSessionToken();
+  if (token) {
+    process.env.CR_AIA_PROXY_SESSION_TOKEN = token;
+  }
+}
+
+export function ensureProxyEnvironmentInitialized(repoRoot: string): ProxySettings {
+  if (!cachedSettings) {
+    cachedSettings = loadProxySettings(repoRoot);
+    applyProxySettings(cachedSettings);
+  }
+  return cachedSettings;
+}
+
+export function getActiveProxySettings(): ProxySettings | null {
+  return cachedSettings;
+}

package/src/runtime/reportMerge.ts

@@ -0,0 +1,102 @@
+import type { ReviewTotals } from './reviewPipeline';
+
+export interface StructuredIssue {
+  priority?: string;
+  filePath?: string;
+  lineNumbers?: string;
+  type?: string;
+  description?: string;
+  suggestedFix?: string;
+  title?: string;
+  impact?: string;
+  [key: string]: unknown;
+}
+
+export interface StructuredDataReport {
+  structuredData?: {
+    issues?: StructuredIssue[];
+  };
+  totals?: Record<string, number>;
+  metadata?: Record<string, unknown>;
+  costInfo?: Record<string, unknown>;
+  modelUsed?: string;
+}
+
+interface MergeResult {
+  findings: Record<string, unknown>[];
+  totals: ReviewTotals;
+  metadata?: Record<string, unknown>;
+  costInfo?: Record<string, unknown>;
+  modelUsed?: string;
+}
+
+export function mergeReports(reports: StructuredDataReport[]): MergeResult {
+  if (reports.length === 0) {
+    return { findings: [], totals: { critical: 0, high: 0, medium: 0, low: 0 } };
+  }
+
+  if (reports.length === 1) {
+    return normalizeReport(reports[0]);
+  }
+
+  const allFindings: Record<string, unknown>[] = [];
+  const totals: ReviewTotals = { critical: 0, high: 0, medium: 0, low: 0 };
+
+  for (const report of reports) {
+    const normalized = normalizeReport(report);
+    if (normalized.findings) {
+      allFindings.push(...(normalized.findings as Record<string, unknown>[]));
+    }
+    if (normalized.totals) {
+      totals.critical += normalized.totals.critical || 0;
+      totals.high += normalized.totals.high || 0;
+      totals.medium += normalized.totals.medium || 0;
+      totals.low += normalized.totals.low || 0;
+    }
+  }
+
+  return {
+    findings: allFindings,
+    totals,
+    metadata: {
+      mergedFrom: reports.length,
+      timestamp: new Date().toISOString(),
+    },
+  };
+}
+
+function normalizeReport(report: StructuredDataReport): MergeResult {
+  const findings: Record<string, unknown>[] = [];
+  const totals: ReviewTotals = { critical: 0, high: 0, medium: 0, low: 0 };
+
+  if (report.structuredData?.issues) {
+    for (const issue of report.structuredData.issues) {
+      const priority = issue.priority?.toLowerCase() || 'medium';
+      const finding = {
+        file: issue.filePath,
+        line: parseInt(issue.lineNumbers?.split('-')[0] || '0', 10),
+        rule: issue.type || 'general',
+        severity: priority,
+        msg: issue.description,
+        fix_hint: issue.suggestedFix,
+        title: issue.title,
+        impact: issue.impact,
+        raw: issue,
+      };
+      findings.push(finding);
+
+      if (priority === 'critical') totals.critical += 1;
+      else if (priority === 'high') totals.high += 1;
+      else if (priority === 'medium') totals.medium += 1;
+      else totals.low += 1;
+    }
+  }
+
+  return {
+    findings,
+    totals,
+    metadata: report.metadata,
+    costInfo: report.costInfo,
+    modelUsed: report.modelUsed,
+  };
+}

package/src/runtime/reporting/markdownReportBuilder.ts

@@ -0,0 +1,138 @@
+import type { FileIssueGroup, TokenStats } from './reportDataCollector';
+import type { ReviewTotals } from '../reviewPipeline';
+
+export const SUMMARY_PLACEHOLDER = '<!--REPORT_SUMMARY_PLACEHOLDER-->';
+
+export interface MarkdownReportContext {
+  repoName: string;
+  generatedAt: Date;
+  durationSeconds: number;
+  filesReviewed: number;
+  totals: ReviewTotals;
+  tokenStats?: TokenStats;
+  estimatedCostUSD?: number;
+  issueGroups: FileIssueGroup[];
+}
+
+function pad(num: number): string {
+  return num.toString().padStart(2, '0');
+}
+
+function formatEuropeanTimestamp(date: Date): string {
+  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 `${day}.${month}.${year} ${hours}.${minutes}`;
+}
+
+function formatDuration(seconds: number): string {
+  const hrs = Math.floor(seconds / 3600);
+  const mins = Math.floor((seconds % 3600) / 60);
+  const secs = seconds % 60;
+  return `${pad(hrs)}:${pad(mins)}:${pad(secs)}`;
+}
+
+function formatCost(amount?: number): string | undefined {
+  if (typeof amount !== 'number' || Number.isNaN(amount)) {
+    return undefined;
+  }
+  return `$${amount.toFixed(amount < 1 ? 4 : 2)} USD`;
+}
+
+function buildStatsSection(ctx: MarkdownReportContext): string {
+  const stats: string[] = ['### Stats'];
+
+  const cost = formatCost(ctx.estimatedCostUSD);
+  if (cost) {
+    stats.push(`- Spend: ${cost}`);
+  }
+
+  stats.push(`- Duration: ${formatDuration(ctx.durationSeconds)}`);
+  stats.push(`- Files reviewed: ${ctx.filesReviewed}`);
+
+  if (ctx.tokenStats) {
+    stats.push(
+      `- Total tokens: ${ctx.tokenStats.totalTokens.toLocaleString()} (input: ${ctx.tokenStats.inputTokens.toLocaleString()} / output: ${ctx.tokenStats.outputTokens.toLocaleString()})`,
+    );
+  }
+
+  stats.push(
+    `- Issues: Critical ${ctx.totals.critical} · High ${ctx.totals.high} · Medium ${ctx.totals.medium} · Low ${ctx.totals.low}`,
+  );
+
+  return stats.join('\n');
+}
+
+function formatIssueTitle(issue: FileIssueGroup['issues'][number]): string {
+  const capitalized = issue.severity.charAt(0).toUpperCase() + issue.severity.slice(1);
+  const linePart = issue.lineLabel ? ` (lines ${issue.lineLabel})` : '';
+  const title = issue.title || 'Issue';
+  return `##### [${capitalized}] ${title}${linePart}`;
+}
+
+function buildIssueBlock(group: FileIssueGroup): string {
+  const lines: string[] = [`#### ${group.filePath}`];
+
+  for (const issue of group.issues) {
+    lines.push(formatIssueTitle(issue));
+
+    if (issue.description) {
+      lines.push(`- **Problem:** ${issue.description.trim()}`);
+    }
+    if (issue.impact) {
+      lines.push(`- **Impact:** ${issue.impact.trim()}`);
+    }
+    if (issue.suggestedFix) {
+      lines.push(`- **Recommendation:** ${issue.suggestedFix.trim()}`);
+    }
+
+    lines.push('');
+  }
+
+  return lines.join('\n').trimEnd();
+}
+
+function buildIssuesSection(groups: FileIssueGroup[]): string {
+  if (groups.length === 0) {
+    return '### Issues\n_No actionable issues reported in this review._';
+  }
+
+  const blocks = groups.map((group) => buildIssueBlock(group));
+  return `### Issues\n\n${blocks.join('\n\n---\n\n')}`;
+}
+
+export function buildMarkdownReport(ctx: MarkdownReportContext): string {
+  const parts: string[] = [];
+  const timestamp = formatEuropeanTimestamp(ctx.generatedAt);
+
+  parts.push(`# Code Review Report — ${timestamp}`);
+  parts.push(`**Repository:** ${ctx.repoName}`);
+  parts.push('\n---\n');
+
+  parts.push(buildStatsSection(ctx));
+  parts.push('\n\n---\n');
+
+  parts.push('### Summary');
+  parts.push(SUMMARY_PLACEHOLDER);
+  parts.push('\n---\n');
+
+  parts.push(buildIssuesSection(ctx.issueGroups));
+  parts.push('\n\n---\n');
+  parts.push('_Generated by cr-aia_');
+
+  return parts.join('\n\n');
+}
+
+export function injectSummary(markdown: string, summary: string): string {
+  if (!markdown.includes(SUMMARY_PLACEHOLDER)) {
+    return markdown;
+  }
+
+  const formattedSummary = summary.trim() ? summary.trim() : '_Summary unavailable._';
+  return markdown.replace(
+    SUMMARY_PLACEHOLDER,
+    `>${formattedSummary.replace(/\n+/g, ' ')}`,
+  );
+}