@contextrail/code-review-agent 0.1.1 → 0.1.2-alpha.1

package/dist/cli/help.d.ts

@@ -0,0 +1,2 @@
+import type { createLogger } from '../logging/logger.js';
+export declare const printHelp: (log: ReturnType<typeof createLogger>) => void;

package/dist/cli/help.js

@@ -0,0 +1,48 @@
+export const printHelp = (log) => {
+    log.info(`code-review-agent
+
+Usage:
+  code-review-agent review --repo <path> --from <sha> --to <sha> [--output <dir>]
+  code-review-agent review --repo <path> --files <file1,file2> [--output <dir>]
+  code-review-agent review --repo <path> --file <file> [--file <file> ...] [--output <dir>]
+
+Commands:
+  review    Run code review on git diff
+
+Options:
+  --repo <path>              Repository path (default: current directory)
+  --from <sha>               Base commit SHA (required)
+  --to <sha>                  Head commit SHA (required)
+  --files <list>              Comma-separated list of files to review
+  --file <path>               File to review (repeatable)
+  --output <dir>              Output directory (default: ./review)
+  --log-level <lv>            Log level: debug|info|warn|error|silent (overrides DEBUG)
+  --max-steps <n>             Maximum LLM steps per call (default: 10)
+  --max-iterations <n>        Maximum reviewer validation iterations (default: 2)
+  --aggregation-max-steps <n> Maximum steps for aggregation (default: 5)
+  --max-tokens-per-file <n>   Token budget for surrounding context per file (default: 20000)
+  --context-lines <n>         Lines of context around changes (default: 10)
+  --pr-description <text>     PR description to include as context (optional)
+  --domains <list>            Comma-separated review focus domains (optional)
+  -h, --help                  Show this help message
+
+Environment Variables:
+  CONTEXTRAIL_MCP_SERVER_URL  ContextRail MCP server URL (required)
+  CONTEXTRAIL_MCP_JWT_TOKEN   ContextRail MCP authentication token (required)
+  OPENROUTER_API_KEY      OpenRouter API key (required)
+  LLM_MODEL_ORCHESTRATOR  Model for orchestrator (default: anthropic/claude-haiku-4.5)
+  LLM_MODEL_REVIEWER      Model for reviewers (default: anthropic/claude-haiku-4.5)
+  MAX_STEPS               Maximum LLM steps per call (default: 10)
+  MAX_ITERATIONS          Maximum reviewer validation iterations (default: 2)
+  AGGREGATION_MAX_STEPS   Maximum steps for aggregation (default: 5)
+  MAX_TOKENS_PER_FILE     Token budget for surrounding context per file (default: 20000)
+  CONTEXT_LINES           Lines of context around changes (default: 10)
+  REVIEW_DOMAINS          Comma-separated review focus domains (optional)
+
+Examples:
+  code-review-agent review --repo . --from HEAD^ --to HEAD
+  code-review-agent review --repo . --files src/a.ts,src/b.ts
+  code-review-agent review --repo . --file src/a.ts --file src/b.ts
+  code-review-agent review --repo /path/to/repo --from abc123 --to def456 --output ./review-results
+`);
+};

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+export type { CliArgs } from './types.js';
+export { parseArgs, validateArgs } from './parser.js';
+export { printHelp } from './help.js';

package/dist/cli/index.js

@@ -0,0 +1,2 @@
+export { parseArgs, validateArgs } from './parser.js';
+export { printHelp } from './help.js';

package/dist/cli/parser.d.ts

@@ -0,0 +1,3 @@
+import type { CliArgs } from './types.js';
+export declare const parseArgs: (args: string[]) => CliArgs;
+export declare const validateArgs: (args: CliArgs) => void;

package/dist/cli/parser.js

@@ -0,0 +1,144 @@
+const ALLOWED_LOG_LEVELS = new Set(['debug', 'info', 'warn', 'error', 'silent']);
+const isPositiveInteger = (value) => Number.isInteger(value) && value > 0;
+const isNonNegativeInteger = (value) => Number.isInteger(value) && value >= 0;
+export const parseArgs = (args) => {
+    const parsed = {};
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        if (!arg) {
+            i += 1;
+            continue;
+        }
+        if (arg === '-h' || arg === '--help') {
+            parsed.help = true;
+            i += 1;
+        }
+        else if (arg === '--repo' && i + 1 < args.length) {
+            parsed.repo = args[i + 1];
+            i += 2;
+        }
+        else if (arg === '--from' && i + 1 < args.length) {
+            parsed.from = args[i + 1];
+            i += 2;
+        }
+        else if (arg === '--to' && i + 1 < args.length) {
+            parsed.to = args[i + 1];
+            i += 2;
+        }
+        else if (arg === '--output' && i + 1 < args.length) {
+            parsed.output = args[i + 1];
+            i += 2;
+        }
+        else if (arg === '--files' && i + 1 < args.length) {
+            const raw = args[i + 1] ?? '';
+            const files = raw
+                .split(',')
+                .map((file) => file.trim())
+                .filter(Boolean);
+            if (!parsed.files) {
+                parsed.files = [];
+            }
+            parsed.files.push(...files);
+            i += 2;
+        }
+        else if (arg === '--file' && i + 1 < args.length) {
+            const file = args[i + 1];
+            if (file) {
+                if (!parsed.files) {
+                    parsed.files = [];
+                }
+                parsed.files.push(file);
+            }
+            i += 2;
+        }
+        else if (arg === '--log-level' && i + 1 < args.length) {
+            parsed.logLevel = args[i + 1];
+            i += 2;
+        }
+        else if (arg === '--pr-description' && i + 1 < args.length) {
+            parsed.prDescription = args[i + 1];
+            i += 2;
+        }
+        else if (arg === '--domains' && i + 1 < args.length) {
+            const raw = args[i + 1] ?? '';
+            const domains = raw
+                .split(',')
+                .map((domain) => domain.trim())
+                .filter(Boolean);
+            if (!parsed.domains) {
+                parsed.domains = [];
+            }
+            parsed.domains.push(...domains);
+            i += 2;
+        }
+        else if (arg === '--max-steps' && i + 1 < args.length) {
+            const value = parseInt(args[i + 1] ?? '10', 10);
+            parsed.maxSteps = value;
+            i += 2;
+        }
+        else if (arg === '--max-iterations' && i + 1 < args.length) {
+            const value = parseInt(args[i + 1] ?? '2', 10);
+            parsed.maxIterations = value;
+            i += 2;
+        }
+        else if (arg === '--aggregation-max-steps' && i + 1 < args.length) {
+            const value = parseInt(args[i + 1] ?? '5', 10);
+            parsed.aggregationMaxSteps = value;
+            i += 2;
+        }
+        else if (arg === '--max-tokens-per-file' && i + 1 < args.length) {
+            const value = parseInt(args[i + 1] ?? '20000', 10);
+            parsed.maxTokensPerFile = value;
+            i += 2;
+        }
+        else if (arg === '--context-lines' && i + 1 < args.length) {
+            const value = parseInt(args[i + 1] ?? '10', 10);
+            parsed.contextLines = value;
+            i += 2;
+        }
+        else if (!parsed.command && !arg.startsWith('-')) {
+            parsed.command = arg;
+            i += 1;
+        }
+        else {
+            i += 1;
+        }
+    }
+    return parsed;
+};
+export const validateArgs = (args) => {
+    if (args.help) {
+        return;
+    }
+    if (args.command !== 'review') {
+        throw new Error(`Unknown command: ${args.command ?? 'none'}. Use 'review' or see --help.`);
+    }
+    if (args.logLevel !== undefined && !ALLOWED_LOG_LEVELS.has(args.logLevel)) {
+        throw new Error(`Invalid log level: ${args.logLevel}. Must be one of: ${Array.from(ALLOWED_LOG_LEVELS).join(', ')}`);
+    }
+    const hasFileList = Array.isArray(args.files) && args.files.length > 0;
+    if (!hasFileList) {
+        if (!args.from) {
+            throw new Error('Missing required argument: --from');
+        }
+        if (!args.to) {
+            throw new Error('Missing required argument: --to');
+        }
+    }
+    if (args.maxSteps !== undefined && !isPositiveInteger(args.maxSteps)) {
+        throw new Error(`Invalid max-steps: ${args.maxSteps}. Must be a positive integer.`);
+    }
+    if (args.maxIterations !== undefined && !isPositiveInteger(args.maxIterations)) {
+        throw new Error(`Invalid max-iterations: ${args.maxIterations}. Must be a positive integer.`);
+    }
+    if (args.aggregationMaxSteps !== undefined && !isPositiveInteger(args.aggregationMaxSteps)) {
+        throw new Error(`Invalid aggregation-max-steps: ${args.aggregationMaxSteps}. Must be a positive integer.`);
+    }
+    if (args.maxTokensPerFile !== undefined && !isPositiveInteger(args.maxTokensPerFile)) {
+        throw new Error(`Invalid max-tokens-per-file: ${args.maxTokensPerFile}. Must be a positive integer.`);
+    }
+    if (args.contextLines !== undefined && !isNonNegativeInteger(args.contextLines)) {
+        throw new Error(`Invalid context-lines: ${args.contextLines}. Must be a non-negative integer.`);
+    }
+};

package/dist/cli/types.d.ts

@@ -0,0 +1,17 @@
+export interface CliArgs {
+    command?: string;
+    repo?: string;
+    from?: string;
+    to?: string;
+    output?: string;
+    logLevel?: string;
+    files?: string[];
+    help?: boolean;
+    maxSteps?: number;
+    maxIterations?: number;
+    aggregationMaxSteps?: number;
+    maxTokensPerFile?: number;
+    contextLines?: number;
+    prDescription?: string;
+    domains?: string[];
+}

package/dist/cli/types.js

@@ -0,0 +1 @@
+export {};

package/dist/config/index.d.ts

@@ -1,4 +1,5 @@
 import { type LogLevel } from '../logging/logger.js';
+import type { CliArgs } from '../cli/types.js';
 export type ReviewAgentConfig = {
     mcpServerUrl?: string;
     mcpAuthToken?: string;
@@ -31,4 +32,5 @@ export type ValidatedReviewAgentConfig = {
     reviewDomains?: string[];
 };
 export declare const loadConfig: () => ReviewAgentConfig;
+export declare const applyCliArgs: (config: ReviewAgentConfig, args: CliArgs) => void;
 export declare const validateConfig: (config: ReviewAgentConfig) => ValidatedReviewAgentConfig;

package/dist/config/index.js

@@ -63,6 +63,22 @@ export const loadConfig = () => {
     }
     return config;
 };
+export const applyCliArgs = (config, args) => {
+    if (args.maxSteps !== undefined)
+        config.maxSteps = args.maxSteps;
+    if (args.maxIterations !== undefined)
+        config.maxIterations = args.maxIterations;
+    if (args.aggregationMaxSteps !== undefined)
+        config.aggregationMaxSteps = args.aggregationMaxSteps;
+    if (args.maxTokensPerFile !== undefined)
+        config.maxTokensPerFile = args.maxTokensPerFile;
+    if (args.contextLines !== undefined)
+        config.contextLines = args.contextLines;
+    if (args.prDescription !== undefined)
+        config.prDescription = args.prDescription;
+    if (args.domains && args.domains.length > 0)
+        config.reviewDomains = args.domains;
+};
 export const validateConfig = (config) => {
     const mcpServerUrl = config.mcpServerUrl;
     const mcpAuthToken = config.mcpAuthToken;

package/dist/errors/error-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const toError: (error: unknown) => Error;
+export declare const serializeError: (error: Error) => Record<string, unknown>;

package/dist/errors/error-utils.js

@@ -0,0 +1,37 @@
+export const toError = (error) => {
+    if (error instanceof Error) {
+        return error;
+    }
+    if (typeof error === 'string') {
+        return new Error(error);
+    }
+    if (error && typeof error === 'object') {
+        const kind = Object.prototype.toString.call(error);
+        try {
+            return new Error(`Non-Error thrown (${kind}): ${JSON.stringify(error)}`);
+        }
+        catch {
+            return new Error(`Non-Error thrown (${kind})`);
+        }
+    }
+    return new Error(`Non-Error thrown: ${String(error)}`);
+};
+const serializeCause = (cause) => {
+    if (cause instanceof Error) {
+        return {
+            name: cause.name,
+            message: cause.message,
+            stack: cause.stack,
+        };
+    }
+    if (cause === undefined || cause === null) {
+        return cause;
+    }
+    return String(cause);
+};
+export const serializeError = (error) => ({
+    name: error.name,
+    message: error.message,
+    stack: error.stack,
+    ...('cause' in error ? { cause: serializeCause(error.cause) } : {}),
+});