codecritique 2.1.3 → 2.2.1

package/README.md

@@ -418,9 +418,12 @@ jobs:
 | `model`             | LLM model to use (e.g., `claude-sonnet-4-6`)                                                             | No       | Auto-selected        |
 | `max-tokens`        | Maximum tokens for LLM response                                                                          | No       | Auto-calculated      |
 | `cache-ttl`         | Cache TTL for LLM prompts: "5m" (default, no extra cost) or "1h" (extended, extra cost for cache writes) | No       | `5m`                 |
+| `batch`             | Use Anthropic Message Batches for lower-cost, asynchronous reviews                                       | No       | `false`              |
 | `concurrency`       | Concurrency for processing multiple files                                                                | No       | `3`                  |
 | `custom-docs`       | Custom documents (format: `"title:path,title:path"`)                                                     | No       | `''`                 |
 
+Batch mode trades latency for Anthropic's Message Batches API discount. Processing may take up to 24 hours, and batch requests are not eligible for Zero Data Retention. GitHub-hosted jobs can run for at most six hours; the action polls in-process and cannot resume a batch after the job ends. If holistic analysis falls back to per-file reviews, each concurrency wave can incur a separate batch wait and further increase runtime.
+
 > **Note**: The action uses sensible defaults for all review parameters. It always:
 >
 > - Uses JSON output format for parsing results

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codecritique",
-  "version": "2.1.3",
+  "version": "2.2.1",
   "description": "AI-powered code review tool for any programming language",
   "type": "module",
   "main": "src/index.js",
@@ -53,7 +53,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "0.71.0",
     "@huggingface/transformers": "3.8.0",
-    "@lancedb/lancedb": "0.30.0",
+    "@lancedb/lancedb": "0.33.0",
     "@octokit/rest": "22.0.1",
     "apache-arrow": "18.1.0",
     "chalk": "5.6.2",

package/src/index.js

@@ -67,6 +67,7 @@ program
   .option('--temperature <number>', 'LLM temperature', parseFloat, 0.2)
   .option('--max-tokens <number>', 'LLM max tokens', parseIntegerOption, 8192)
   .option('--cache-ttl <ttl>', 'Cache TTL for LLM prompts: "5m" (default, no extra cost) or "1h" (extended, extra cost for writes)', '5m')
+  .option('--batch', 'Use the asynchronous Anthropic Message Batches API for lower-cost reviews')
   .option('--similarity-threshold <number>', 'Threshold for finding similar code examples', parseFloat, 0.6)
   .option('--max-examples <number>', 'Max similar code examples to use', parseIntegerOption, 5)
   .option('--concurrency <number>', 'Concurrency for processing multiple files', parseIntegerOption, 3)
@@ -350,6 +351,7 @@ async function runCodeReview(options) {
     temperature: options.temperature,
     maxTokens: options.maxTokens,
     cacheTtl: options.cacheTtl,
+    batch: options.batch,
     similarityThreshold: options.similarityThreshold,
     maxExamples: options.maxExamples,
     concurrency: options.concurrency,
@@ -1093,11 +1095,12 @@ async function emitEmptyReviewOutputIfNeeded(options, aggregateResult = {}) {
 }
 
 async function emitErrorReviewOutputIfNeeded(options, error, aggregateResult = {}) {
-  if (!shouldEmitReviewOutput(options)) {
+  if (!shouldEmitReviewOutput(options) && !aggregateResult.results?.length) {
     return false;
   }
 
-  await outputReviewResults([createReviewErrorResult(error)], options, {
+  const reviewResults = aggregateResult.results?.length ? aggregateResult.results : [{ filePath: 'review', success: false, error }];
+  await outputReviewResults(reviewResults, options, {
     ...aggregateResult,
     success: false,
     error,
@@ -1105,14 +1108,6 @@ async function emitErrorReviewOutputIfNeeded(options, error, aggregateResult = {
   return true;
 }
 
-function createReviewErrorResult(error) {
-  return {
-    filePath: 'review',
-    success: false,
-    error,
-  };
-}
-
 /**
  * Output results in JSON format
  *
@@ -1140,6 +1135,8 @@ async function outputJson(reviewResults, options, aggregateResult = {}) {
       }, 0),
       skippedFiles: reviewResults.filter((r) => r.skipped).length,
       errorFiles: reviewResults.filter((r) => !r.success).length,
+      incomplete: aggregateResult.success === false,
+      error: aggregateResult.success === false ? aggregateResult.error : undefined,
     },
     details: reviewResults.map((r) => {
       if (!r.success) {
@@ -1152,6 +1149,8 @@ async function outputJson(reviewResults, options, aggregateResult = {}) {
       return {
         filePath: r.filePath,
         success: true,
+        partial: r.partial || undefined,
+        error: r.partial ? r.error : undefined,
         language: r.language,
         review: r.results, // Contains summary and actionable issues (with optional codeSuggestion)
         // Optionally include similar examples if needed
@@ -1208,6 +1207,9 @@ async function outputMarkdown(reviewResults, options, aggregateResult = {}) {
   if (errorFiles > 0) {
     lines.push(`- **Errors:** ${errorFiles}`);
   }
+  if (aggregateResult.success === false) {
+    lines.push(`- **Review Incomplete:** ${aggregateResult.error || 'Some review work failed.'}`);
+  }
 
   appendPRLevelFindingsMarkdown(lines, prLevelFindings);
 
@@ -1219,6 +1221,9 @@ async function outputMarkdown(reviewResults, options, aggregateResult = {}) {
       lines.push(`**Error:** ${fileResult.error}`, '');
       return;
     }
+    if (fileResult.partial) {
+      lines.push(`**Partial review:** ${fileResult.error || 'Some review segments failed.'}`, '');
+    }
     if (fileResult.skipped) {
       lines.push('*Skipped (based on exclusion patterns or file type).*', '');
       return;
@@ -1296,6 +1301,9 @@ function outputText(reviewResults, cliOptions, aggregateResult = {}) {
   if (errorFiles > 0) {
     console.log(`Errors: ${chalk.red(errorFiles)}`);
   }
+  if (aggregateResult.success === false) {
+    console.warn(chalk.yellow(`Review Incomplete: ${aggregateResult.error || 'Some review work failed.'}`));
+  }
   console.log(chalk.bold.blue('================================================'));
 
   outputPRLevelFindingsText(prLevelFindings);
@@ -1307,6 +1315,9 @@ function outputText(reviewResults, cliOptions, aggregateResult = {}) {
       console.log(chalk.bold.red('================================================'));
       return;
     }
+    if (fileResult.partial) {
+      console.warn(chalk.yellow(`\nPartial review for ${fileResult.filePath}: ${fileResult.error || 'Some review segments failed.'}`));
+    }
     if (fileResult.skipped) {
       verboseLog(cliOptions, chalk.yellow(`\nSkipped: ${fileResult.filePath}`));
       return;

package/src/index.test.js

@@ -1,3 +1,7 @@
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { program } from 'commander';
 import { expect, it, onTestFinished, vi } from 'vitest';
 
 const { originalArgv, originalListeners, reviewFile } = vi.hoisted(() => {
@@ -7,7 +11,19 @@ const { originalArgv, originalListeners, reviewFile } = vi.hoisted(() => {
   return {
     originalArgv,
     originalListeners,
-    reviewFile: vi.fn().mockResolvedValue({ success: true, results: [] }),
+    reviewFile: vi.fn().mockResolvedValue({
+      success: false,
+      error: 'Review incomplete',
+      results: [
+        {
+          filePath: 'src/index.js',
+          success: true,
+          partial: true,
+          error: 'Batch expired',
+          results: { issues: [{ severity: 'high', description: 'Visible partial finding', lineNumbers: [1] }] },
+        },
+      ],
+    }),
   };
 });
 
@@ -20,8 +36,9 @@ vi.mock('./rag-review.js', () => ({
 
 import './index.js';
 
-it('parses integer options independently of Commander defaults', async () => {
-  onTestFinished(() => {
+it('parses integer options and renders incomplete results in every output format', async () => {
+  const directory = await mkdtemp(join(tmpdir(), 'codecritique-output-'));
+  onTestFinished(async () => {
     process.argv = originalArgv;
     for (const [event, listeners] of Object.entries(originalListeners)) {
       process
@@ -29,7 +46,41 @@ it('parses integer options independently of Commander defaults', async () => {
         .filter((listener) => !listeners.includes(listener))
         .forEach((listener) => process.removeListener(event, listener));
     }
+    await rm(directory, { recursive: true, force: true });
   });
   await vi.waitFor(() => expect(reviewFile).toHaveBeenCalled());
   expect(reviewFile.mock.calls[0][1].maxExamples).toBe(12);
+  await vi.waitFor(() => expect(console.log).toHaveBeenCalledWith('    Visible partial finding'));
+  expect(console.warn.mock.calls.some(([message]) => String(message).includes('Partial review for src/index.js'))).toBe(true);
+  expect(console.warn.mock.calls.some(([message]) => String(message).includes('Review incomplete'))).toBe(true);
+
+  const jsonPath = join(directory, 'review.json');
+  await program.parseAsync(['node', 'index.js', 'analyze', '--file', 'src/index.js', '--output', 'json', '--output-file', jsonPath]);
+  const jsonOutput = JSON.parse(await readFile(jsonPath, 'utf8'));
+  expect(jsonOutput.summary).toEqual(expect.objectContaining({ errorFiles: 0, incomplete: true, error: 'Review incomplete' }));
+  expect(jsonOutput.details).toEqual([
+    expect.objectContaining({
+      success: true,
+      partial: true,
+      error: 'Batch expired',
+      review: expect.objectContaining({ issues: [expect.objectContaining({ description: 'Visible partial finding' })] }),
+    }),
+  ]);
+
+  const markdownPath = join(directory, 'review.md');
+  await program.parseAsync([
+    'node',
+    'index.js',
+    'analyze',
+    '--file',
+    'src/index.js',
+    '--output',
+    'markdown',
+    '--output-file',
+    markdownPath,
+  ]);
+  const markdownOutput = await readFile(markdownPath, 'utf8');
+  expect(markdownOutput).toContain('**Review Incomplete:** Review incomplete');
+  expect(markdownOutput).toContain('**Partial review:** Batch expired');
+  expect(markdownOutput).toContain('Visible partial finding');
 });

package/src/llm.js

@@ -12,6 +12,7 @@
  * requests, reducing input token costs by 75%.
  */
 
+import { setTimeout as delay } from 'node:timers/promises';
 import { Anthropic } from '@anthropic-ai/sdk';
 import chalk from 'chalk';
 import dotenv from 'dotenv';
@@ -46,6 +47,9 @@ const DEFAULT_MODEL = 'claude-sonnet-4-6';
 // Maximum tokens for response
 const MAX_TOKENS = 4096;
 
+const DEFAULT_BATCH_POLL_INTERVAL_MS = 10000;
+const MAX_BATCH_POLL_FAILURES = 3;
+
 const MAX_CACHE_CONTROL_BLOCKS = 4;
 
 function normalizeSystemBlock(block, cacheControl) {
@@ -84,6 +88,47 @@ function buildSystemContent(system, cachedSystemBlocks, cacheControl) {
   return systemBlocks;
 }
 
+async function createBatchedMessage(client, requestParams, options) {
+  const customId = 'codecritique-review';
+  let batch = await client.messages.batches.create({
+    requests: [{ custom_id: customId, params: requestParams }],
+  });
+
+  verboseLog(options, chalk.cyan(`Submitted Claude message batch ${batch.id}; waiting for completion...`));
+  let consecutivePollFailures = 0;
+
+  while (batch.processing_status !== 'ended') {
+    await delay(DEFAULT_BATCH_POLL_INTERVAL_MS);
+    try {
+      batch = await client.messages.batches.retrieve(batch.id);
+      consecutivePollFailures = 0;
+    }
+    catch (error) {
+      consecutivePollFailures++;
+      if (consecutivePollFailures >= MAX_BATCH_POLL_FAILURES) {
+        throw new Error(`Unable to poll Claude message batch ${batch.id} after ${MAX_BATCH_POLL_FAILURES} attempts: ${error.message}`);
+      }
+      console.warn(chalk.yellow(`Unable to poll Claude message batch ${batch.id}; retrying: ${error.message}`));
+    }
+  }
+
+  const results = await client.messages.batches.results(batch.id);
+  for await (const response of results) {
+    if (response.custom_id !== customId) {
+      continue;
+    }
+
+    if (response.result.type === 'succeeded') {
+      return response.result.message;
+    }
+
+    const detail = response.result.type === 'errored' ? `: ${response.result.error.error.message}` : '';
+    throw new Error(`Claude batch request ${response.result.type}${detail}`);
+  }
+
+  throw new Error('Claude batch response did not contain the review request');
+}
+
 /**
  * Send a prompt to Claude and get a structured JSON response using tool calling.
  * Uses prompt caching for system prompts to reduce token costs.
@@ -94,6 +139,7 @@ function buildSystemContent(system, cachedSystemBlocks, cacheControl) {
  * @param {Array<string|Object>} options.cachedSystemBlocks - Additional stable system blocks to cache when possible
  * @param {Object} options.jsonSchema - JSON schema for structured output
  * @param {string} options.cacheTtl - Cache TTL: '5m' (default, no extra cost) or '1h' (extended, extra cost for writes)
+ * @param {boolean} [options.batch=false] - Use the asynchronous Message Batches API
  * @returns {Promise<Object>} The response from Claude with structured data
  */
 async function sendPromptToClaude(prompt, options = {}) {
@@ -145,7 +191,9 @@ async function sendPromptToClaude(prompt, options = {}) {
       requestParams.tool_choice = { type: 'tool', name: 'return_json' };
     }
 
-    const response = await client.messages.create(requestParams);
+    const response = options.batch
+      ? await createBatchedMessage(client, requestParams, options)
+      : await client.messages.create(requestParams);
 
     // Log response structure for debugging
     verboseLog(options, chalk.gray(`  Response stop_reason: ${response.stop_reason}`));

package/src/llm.test.js

@@ -2,15 +2,31 @@ import { sendPromptToClaude } from './llm.js';
 
 // Create hoisted mock for the Anthropic SDK
 const mockMessagesCreate = vi.hoisted(() => vi.fn());
+const mockBatchesCreate = vi.hoisted(() => vi.fn());
+const mockBatchesRetrieve = vi.hoisted(() => vi.fn());
+const mockBatchesResults = vi.hoisted(() => vi.fn());
+
+vi.mock('node:timers/promises', () => ({ setTimeout: vi.fn() }));
 
 vi.mock('@anthropic-ai/sdk', () => ({
   Anthropic: class MockAnthropic {
     messages = {
       create: mockMessagesCreate,
+      batches: {
+        create: mockBatchesCreate,
+        retrieve: mockBatchesRetrieve,
+        results: mockBatchesResults,
+      },
     };
   },
 }));
 
+function batchResults(...responses) {
+  return (async function* iterateResults() {
+    yield* responses;
+  })();
+}
+
 describe('sendPromptToClaude', () => {
   beforeEach(() => {
     mockConsoleSelective('log', 'error');
@@ -85,6 +101,72 @@ describe('sendPromptToClaude', () => {
         })
       );
     });
+
+    it('should retry polling and unwrap a successful batch request', async () => {
+      const message = {
+        content: [{ type: 'text', text: 'Batched response' }],
+        model: 'claude-sonnet-4-6',
+        usage: { input_tokens: 100, output_tokens: 50 },
+      };
+      mockBatchesCreate.mockResolvedValue({ id: 'msgbatch_123', processing_status: 'in_progress' });
+      mockBatchesRetrieve
+        .mockRejectedValueOnce(new Error('Temporary network error'))
+        .mockRejectedValueOnce(new Error('Temporary network error'))
+        .mockResolvedValueOnce({ id: 'msgbatch_123', processing_status: 'in_progress' })
+        .mockRejectedValueOnce(new Error('Temporary network error'))
+        .mockRejectedValueOnce(new Error('Temporary network error'))
+        .mockResolvedValueOnce({ id: 'msgbatch_123', processing_status: 'ended' });
+      mockBatchesResults.mockResolvedValue(batchResults({ custom_id: 'codecritique-review', result: { type: 'succeeded', message } }));
+
+      const result = await sendPromptToClaude('Review this code', { batch: true });
+
+      expect(result.content).toBe('Batched response');
+      expect(mockMessagesCreate).not.toHaveBeenCalled();
+      expect(mockBatchesCreate).toHaveBeenCalledWith({
+        requests: [
+          {
+            custom_id: 'codecritique-review',
+            params: expect.objectContaining({
+              model: 'claude-sonnet-4-6',
+              messages: [{ role: 'user', content: 'Review this code' }],
+            }),
+          },
+        ],
+      });
+      expect(mockBatchesRetrieve).toHaveBeenCalledTimes(6);
+      expect(mockBatchesRetrieve).toHaveBeenCalledWith('msgbatch_123');
+      expect(mockBatchesResults).toHaveBeenCalledWith('msgbatch_123');
+    });
+
+    it('should stop polling after repeated retrieval failures', async () => {
+      mockBatchesCreate.mockResolvedValue({ id: 'msgbatch_123', processing_status: 'in_progress' });
+      mockBatchesRetrieve.mockRejectedValue(new Error('Unauthorized'));
+
+      await expect(sendPromptToClaude('Review this code', { batch: true })).rejects.toThrow(
+        'Unable to poll Claude message batch msgbatch_123 after 3 attempts: Unauthorized'
+      );
+      expect(mockBatchesRetrieve).toHaveBeenCalledTimes(3);
+    });
+
+    it.each([
+      [{ type: 'errored', error: { error: { message: 'Request overloaded' } } }, 'Claude batch request errored: Request overloaded'],
+      [{ type: 'canceled' }, 'Claude batch request canceled'],
+      [{ type: 'expired' }, 'Claude batch request expired'],
+    ])('should report an unsuccessful batch result', async (batchResult, expectedMessage) => {
+      mockBatchesCreate.mockResolvedValue({ id: 'msgbatch_123', processing_status: 'ended' });
+      mockBatchesResults.mockResolvedValue(batchResults({ custom_id: 'codecritique-review', result: batchResult }));
+
+      await expect(sendPromptToClaude('Review this code', { batch: true })).rejects.toThrow(expectedMessage);
+    });
+
+    it('should reject a batch response without the review result', async () => {
+      mockBatchesCreate.mockResolvedValue({ id: 'msgbatch_123', processing_status: 'ended' });
+      mockBatchesResults.mockResolvedValue(batchResults());
+
+      await expect(sendPromptToClaude('Review this code', { batch: true })).rejects.toThrow(
+        'Claude batch response did not contain the review request'
+      );
+    });
   });
 
   describe('structured JSON response with tool calling', () => {

package/src/rag-analyzer.js

@@ -782,6 +782,7 @@ async function callLLMForAnalysis(context, options = {}) {
       isJsonMode: true, // Standardize on using JSON mode if available
       verbose: options.verbose || false, // Pass verbose flag for cache statistics
       cacheTtl: options.cacheTtl || '5m', // Pass cache TTL option (default: 5m, no extra cost)
+      batch: options.batch || false,
     });
 
     verboseLog(options, chalk.blue('Received LLM response, attempting to parse...'));

package/src/rag-analyzer.test.js

@@ -196,6 +196,14 @@ describe('rag-analyzer', () => {
       expect(result.error).toContain('LLM unavailable');
     });
 
+    it('should forward batch transport options to the LLM', async () => {
+      setupSuccessfulLLMResponse();
+
+      await runAnalysis('/test/file.js', { batch: true });
+
+      expect(llm.sendPromptToClaude).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ batch: true }));
+    });
+
     it('should initialize embeddings system', async () => {
       setupSuccessfulLLMResponse();
       await runAnalysis('/test/file.js');

package/src/rag-review.js

@@ -399,6 +399,9 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
 
       // Create a synthetic "file" path for holistic analysis
       const holisticResult = await runAnalysis('PR_HOLISTIC_REVIEW', holisticOptions);
+      if (!holisticResult?.success) {
+        throw new Error(holisticResult?.error || 'Holistic PR analysis failed');
+      }
 
       // Convert holistic result to individual file results format for compatibility
       const results = prFiles.map((file) => {
@@ -525,8 +528,10 @@ async function reviewPullRequestWithCrossFileContext(filesToReview, options = {}
       }
 
       // Return fallback results
+      const failedReviewCount = results.filter((result) => !result?.success).length;
       return {
-        success: true,
+        success: failedReviewCount === 0,
+        error: failedReviewCount > 0 ? `${failedReviewCount} file review(s) failed after holistic review fallback` : undefined,
         results: results,
         prContext: prContext,
         sharedContextStats: {

package/src/rag-review.test.js

@@ -436,6 +436,36 @@ describe('rag-review', () => {
       expect(result.success).toBe(true);
     });
 
+    it('should retain successful fallback results when another file fails', async () => {
+      shouldProcessFile.mockReturnValue(true);
+      getFileContentFromGit.mockReturnValue('const x = 1;');
+      getChangedLinesInfo.mockReturnValue({
+        hasChanges: true,
+        addedLines: [1],
+        removedLines: [],
+        fullDiff: '+ code',
+      });
+      shouldChunkPR.mockReturnValue({ shouldChunk: false, estimatedTokens: 1000 });
+      runAnalysis
+        .mockResolvedValueOnce({ success: false, error: 'Claude batch request expired' })
+        .mockResolvedValueOnce({
+          success: true,
+          filePath: '/src/a.js',
+          results: { issues: [{ description: 'Known issue' }] },
+        })
+        .mockResolvedValueOnce({ success: false, filePath: '/src/b.js', error: 'Claude batch request expired' });
+
+      const result = await reviewPullRequest(['/src/a.js', '/src/b.js'], { batch: true });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('1 file review(s) failed after holistic review fallback');
+      expect(result.results).toEqual([
+        expect.objectContaining({ success: true, filePath: '/src/a.js' }),
+        expect.objectContaining({ success: false, filePath: '/src/b.js', error: 'Claude batch request expired' }),
+      ]);
+      expect(runAnalysis).toHaveBeenLastCalledWith('/src/b.js', expect.objectContaining({ batch: true, isPRReview: true, diffOnly: true }));
+    });
+
     it('should handle multiple files with different statuses', async () => {
       runAnalysis
         .mockResolvedValueOnce({