codereview-aia 0.1.2 → 0.1.4

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,222 +0,0 @@
-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 type FileCollectionMode = 'uncommitted' | 'preprod';
-
-export interface CollectFilesOptions {
-  mode?: FileCollectionMode;
-}
-
-export async function collectFiles(options: CollectFilesOptions = {}): 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 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 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 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;
-}

package/src/runtime/preprod/webCheck.ts

@@ -1,104 +0,0 @@
-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: {} });
-}

package/src/runtime/proxyConfig.ts

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

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