codecritique 2.2.5 → 2.3.0

package/README.md

@@ -415,7 +415,7 @@ jobs:
 | `anthropic-api-key` | Anthropic API key for Claude models                                                                      | **Yes**  | -                    |
 | `skip-label`        | Label name to skip AI review                                                                             | No       | `ai-review-disabled` |
 | `verbose`           | Show verbose output                                                                                      | No       | `false`              |
-| `model`             | LLM model to use (e.g., `claude-sonnet-4-6`)                                                             | No       | Auto-selected        |
+| `model`             | LLM model to use (e.g., `claude-sonnet-5`)                                                               | 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`              |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codecritique",
-  "version": "2.2.5",
+  "version": "2.3.0",
   "description": "AI-powered code review tool for any programming language",
   "type": "module",
   "main": "src/index.js",
@@ -51,7 +51,7 @@
   "license": "MIT",
   "author": "cosmocoder",
   "dependencies": {
-    "@anthropic-ai/sdk": "0.123.0",
+    "@anthropic-ai/sdk": "0.125.0",
     "@huggingface/transformers": "3.8.0",
     "@lancedb/lancedb": "0.38.0",
     "@octokit/rest": "22.0.1",

package/src/index.js

@@ -63,7 +63,7 @@ program
   .option('--output-file <file>', 'Save output to file (useful with --output json)')
   .option('--no-color', 'Disable colored output')
   .option('--verbose', 'Show verbose output')
-  .option('--model <model>', 'LLM model to use (e.g., claude-sonnet-4-6)')
+  .option('--model <model>', 'LLM model to use (e.g., claude-sonnet-5)')
   .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')

package/src/llm.js

@@ -42,7 +42,11 @@ function getAnthropicClient() {
 }
 
 // Default model
-const DEFAULT_MODEL = 'claude-sonnet-4-6';
+const DEFAULT_MODEL = 'claude-sonnet-5';
+
+// Models after the 4.6 generation reject `temperature` with a 400. Only send it
+// for the older families; unknown models fall back to the API default.
+const SAMPLING_MODEL_PATTERN = /^claude-(?:3|(?:opus|sonnet|haiku)-4-[0-6])/;
 
 // Maximum tokens for response
 const MAX_TOKENS = 4096;
@@ -138,6 +142,8 @@ async function createBatchedMessage(client, requestParams, options) {
  * @param {string} options.system - System prompt (will be cached for cost optimization)
  * @param {Array<string|Object>} options.cachedSystemBlocks - Additional stable system blocks to cache when possible
  * @param {Object} options.jsonSchema - JSON schema for structured output
+ * @param {boolean} [options.strict=false] - Enforce the schema on the tool input. Every object in the
+ *   schema must set `additionalProperties: false`, and `additionalProperties` accepts no other value.
  * @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
@@ -150,6 +156,7 @@ async function sendPromptToClaude(prompt, options = {}) {
     system = '',
     cachedSystemBlocks = [],
     jsonSchema = null,
+    strict = false,
     cacheTtl = '5m',
   } = options;
 
@@ -169,7 +176,7 @@ async function sendPromptToClaude(prompt, options = {}) {
     const requestParams = {
       model,
       max_tokens: maxTokens,
-      temperature,
+      ...(SAMPLING_MODEL_PATTERN.test(model) ? { temperature } : {}),
       system: systemContent,
       messages: [
         {
@@ -186,6 +193,9 @@ async function sendPromptToClaude(prompt, options = {}) {
           name: 'return_json',
           description: 'Return the final answer strictly as JSON matching the schema.',
           input_schema: jsonSchema,
+          // Omitted rather than sent as false so the tool block stays byte-identical
+          // for callers that do not use it, which keeps their cached prefix valid.
+          ...(strict ? { strict: true } : {}),
         },
       ];
       requestParams.tool_choice = { type: 'tool', name: 'return_json' };
@@ -199,6 +209,22 @@ async function sendPromptToClaude(prompt, options = {}) {
     verboseLog(options, chalk.gray(`  Response stop_reason: ${response.stop_reason}`));
     verboseLog(options, chalk.gray(`  Response content blocks: ${response.content?.length || 0}`));
 
+    // A refusal arrives as HTTP 200 with no tool_use and no text, so it must be caught
+    // here or it surfaces as a missing-output error that hides the real cause.
+    if (response.stop_reason === 'refusal') {
+      const { category, explanation } = response.stop_details || {};
+      const reason = explanation || 'no explanation provided';
+      throw new Error(`Claude declined the request${category ? ` (${category})` : ''}: ${reason}`);
+    }
+
+    // Truncation also arrives as HTTP 200. Without this the tool path reports missing
+    // output and the text path returns a severed answer that reads as a complete one.
+    if (response.stop_reason === 'max_tokens' || response.stop_reason === 'model_context_window_exceeded') {
+      const remedy =
+        response.stop_reason === 'max_tokens' ? 'Increase the configured output limit or continue the response.' : 'Reduce the input size.';
+      throw new Error(`Claude's response was truncated (${response.stop_reason}). ${remedy}`);
+    }
+
     // Process response based on whether we used tool calling
     if (jsonSchema) {
       const toolUse = response.content.find((block) => block.type === 'tool_use' && block.name === 'return_json');
@@ -221,7 +247,7 @@ async function sendPromptToClaude(prompt, options = {}) {
     }
     else {
       return {
-        content: response.content[0]?.text || '',
+        content: response.content?.find((block) => block.type === 'text')?.text || '',
         model: response.model,
         usage: response.usage,
       };

package/src/llm.test.js

@@ -65,13 +65,122 @@ describe('sendPromptToClaude', () => {
 
       expect(mockMessagesCreate).toHaveBeenCalledWith(
         expect.objectContaining({
-          model: 'claude-sonnet-4-6',
+          model: 'claude-sonnet-5',
           max_tokens: 4096,
-          temperature: 0.7,
         })
       );
     });
 
+    it('should surface the refusal explanation instead of a missing-output error', async () => {
+      mockMessagesCreate.mockResolvedValue({
+        stop_reason: 'refusal',
+        stop_details: { type: 'refusal', category: 'cyber', explanation: 'Declined: offensive tooling.' },
+        content: [],
+        model: 'claude-sonnet-5',
+        usage: {},
+      });
+
+      await expect(sendPromptToClaude('Test prompt', { jsonSchema: { type: 'object' } })).rejects.toThrow(
+        'Claude declined the request (cyber): Declined: offensive tooling.'
+      );
+    });
+
+    it.each([
+      ['max_tokens', 'Increase the configured output limit or continue the response.'],
+      ['model_context_window_exceeded', 'Reduce the input size.'],
+    ])('should report a truncated response for stop_reason %s', async (stopReason, remedy) => {
+      mockMessagesCreate.mockResolvedValue({
+        stop_reason: stopReason,
+        content: [],
+        model: 'claude-sonnet-5',
+        usage: {},
+      });
+
+      await expect(sendPromptToClaude('Test prompt', { jsonSchema: { type: 'object' } })).rejects.toThrow(
+        `Claude's response was truncated (${stopReason}). ${remedy}`
+      );
+    });
+
+    it('should report truncation rather than returning a severed plain-text answer', async () => {
+      mockMessagesCreate.mockResolvedValue({
+        stop_reason: 'max_tokens',
+        content: [{ type: 'text', text: 'partial answer cut off mid-' }],
+        model: 'claude-sonnet-5',
+        usage: {},
+      });
+
+      await expect(sendPromptToClaude('Test prompt')).rejects.toThrow('was truncated (max_tokens)');
+    });
+
+    it('should read the text block even when a thinking block precedes it', async () => {
+      mockMessagesCreate.mockResolvedValue({
+        stop_reason: 'end_turn',
+        content: [
+          { type: 'thinking', thinking: '' },
+          { type: 'text', text: 'The real answer' },
+        ],
+        model: 'claude-sonnet-5',
+        usage: {},
+      });
+
+      const result = await sendPromptToClaude('Test prompt');
+
+      expect(result.content).toBe('The real answer');
+    });
+
+    it('should omit temperature for models that reject sampling parameters', async () => {
+      mockMessagesCreate.mockResolvedValue({
+        content: [{ type: 'text', text: 'Response' }],
+        model: 'claude-sonnet-5',
+        usage: {},
+      });
+
+      await sendPromptToClaude('Test prompt', { temperature: 0.5 });
+
+      expect(mockMessagesCreate.mock.calls[0][0]).not.toHaveProperty('temperature');
+    });
+
+    it('should set strict on the return_json tool when requested', async () => {
+      mockMessagesCreate.mockResolvedValue({
+        content: [{ type: 'tool_use', name: 'return_json', input: { ok: true } }],
+        model: 'claude-sonnet-5',
+        usage: {},
+      });
+
+      await sendPromptToClaude('Test prompt', {
+        jsonSchema: { type: 'object', properties: {}, required: [], additionalProperties: false },
+        strict: true,
+      });
+
+      expect(mockMessagesCreate.mock.calls[0][0].tools[0]).toHaveProperty('strict', true);
+    });
+
+    it('should omit strict from the return_json tool by default', async () => {
+      mockMessagesCreate.mockResolvedValue({
+        content: [{ type: 'tool_use', name: 'return_json', input: { ok: true } }],
+        model: 'claude-sonnet-5',
+        usage: {},
+      });
+
+      await sendPromptToClaude('Test prompt', {
+        jsonSchema: { type: 'object', properties: {}, required: [], additionalProperties: false },
+      });
+
+      expect(mockMessagesCreate.mock.calls[0][0].tools[0]).not.toHaveProperty('strict');
+    });
+
+    it('should keep temperature for models that still accept it', async () => {
+      mockMessagesCreate.mockResolvedValue({
+        content: [{ type: 'text', text: 'Response' }],
+        model: 'claude-haiku-4-5',
+        usage: {},
+      });
+
+      await sendPromptToClaude('Test prompt', { model: 'claude-haiku-4-5', temperature: 0.1 });
+
+      expect(mockMessagesCreate).toHaveBeenCalledWith(expect.objectContaining({ temperature: 0.1 }));
+    });
+
     it('should use custom options', async () => {
       mockMessagesCreate.mockResolvedValue({
         content: [{ type: 'text', text: 'Response' }],
@@ -105,7 +214,7 @@ 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',
+        model: 'claude-sonnet-5',
         usage: { input_tokens: 100, output_tokens: 50 },
       };
       mockBatchesCreate.mockResolvedValue({ id: 'msgbatch_123', processing_status: 'in_progress' });
@@ -127,7 +236,7 @@ describe('sendPromptToClaude', () => {
           {
             custom_id: 'codecritique-review',
             params: expect.objectContaining({
-              model: 'claude-sonnet-4-6',
+              model: 'claude-sonnet-5',
               messages: [{ role: 'user', content: 'Review this code' }],
             }),
           },

package/src/project-analyzer.js

@@ -592,6 +592,7 @@ Select files following the criteria in the system instructions.`;
         temperature: 0.1,
         maxTokens: 1000,
         jsonSchema: fileSelectionSchema,
+        strict: true,
       });
 
       verboseLog({}, chalk.gray('   📄 LLM Response preview:'), response.content.substring(0, 200));

package/src/project-analyzer.test.js

@@ -556,7 +556,10 @@ describe('ProjectAnalyzer', () => {
 
       const result = await analyzer.selectFinalKeyFiles(candidates, mockProjectPath);
 
-      expect(llm.sendPromptToClaude).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ model: 'claude-haiku-4-5' }));
+      expect(llm.sendPromptToClaude).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({ model: 'claude-haiku-4-5', strict: true })
+      );
       expect(result.length).toBe(1);
       expect(result[0].relativePath).toBe('package.json');
     });
@@ -673,6 +676,9 @@ describe('ProjectAnalyzer', () => {
       const result = await analyzer.generateProjectSummary(mockKeyFiles, mockProjectPath);
 
       expect(llm.sendPromptToClaude).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ model: 'claude-haiku-4-5' }));
+      // projectSummarySchema sets additionalProperties: false on its top level only, and
+      // the documented strict subset requires it on every object.
+      expect(llm.sendPromptToClaude.mock.calls[0][1]).not.toHaveProperty('strict');
       expect(result.projectName).toBe('test-project');
       expect(result.analysisDate).toBeDefined();
       expect(result.projectPath).toBe(mockProjectPath);

package/src/prompt-cache.js

@@ -248,9 +248,9 @@ You must respond with EXACTLY this JSON structure, with no additional text:
     {
       "type": "bug | improvement | convention | architecture",
       "severity": "critical | high | medium",
-      "description": "Detailed description of an issue that spans multiple files...",
+      "message": "Detailed description of an issue that spans multiple files...",
       "suggestion": "Actionable suggestion to resolve the cross-file issue.",
-      "filesInvolved": ["path/to/file1.js", "path/to/file2.ts"]
+      "files": ["path/to/file1.js", "path/to/file2.ts"]
     }
   ],
   "fileSpecificIssues": {
@@ -272,9 +272,10 @@ You must respond with EXACTLY this JSON structure, with no additional text:
   },
   "recommendations": [
     {
-      "type": "refactoring | testing | documentation",
-      "description": "A high-level recommendation for improving the codebase...",
-      "filesInvolved": ["path/to/relevant/file.js"]
+      "category": "refactoring | testing | documentation",
+      "suggestion": "A high-level recommendation for improving the codebase...",
+      "priority": "high | medium | low",
+      "impact": "Expected benefit of applying this recommendation."
     }
   ]
 }`;

package/src/prompt-cache.test.js

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest';
+import { PR_REVIEW_JSON_SCHEMA } from './prompt-cache.js';
+import { collectPRLevelFindings } from './utils/review-results.js';
+
+/**
+ * The prompt tells the model which field names to emit. `review-results.js` reads
+ * those names back. A divergence drops data silently, so these tests pin the
+ * prompt to the names the consumers actually read.
+ */
+describe('PR_REVIEW_JSON_SCHEMA', () => {
+  it('should name the cross-file issue fields that normalizePRLevelIssue reads', () => {
+    expect(PR_REVIEW_JSON_SCHEMA).toContain('"message"');
+    expect(PR_REVIEW_JSON_SCHEMA).toContain('"files"');
+  });
+
+  it('should name the recommendation fields that normalizeRecommendation reads', () => {
+    // "suggestion" appears in three blocks, so bound the slice at both ends: a slice
+    // that ran to the end of the schema would pass on any later block instead.
+    const start = PR_REVIEW_JSON_SCHEMA.indexOf('"recommendations"');
+    const recommendations = PR_REVIEW_JSON_SCHEMA.slice(start, PR_REVIEW_JSON_SCHEMA.indexOf(']', start) + 1);
+
+    expect(recommendations).toContain('"category"');
+    expect(recommendations).toContain('"suggestion"');
+    expect(recommendations).toContain('"impact"');
+  });
+
+  it('should not name filesInvolved, which no consumer reads', () => {
+    expect(PR_REVIEW_JSON_SCHEMA).not.toContain('filesInvolved');
+  });
+});
+
+describe('collectPRLevelFindings with prompt-shaped input', () => {
+  const holisticAnalysis = {
+    results: {
+      summary: 'PR summary',
+      crossFileIssues: [
+        {
+          type: 'architecture',
+          severity: 'high',
+          message: 'Duplicated retry logic',
+          suggestion: 'Extract a shared helper',
+          files: ['a.js', 'b.js'],
+        },
+      ],
+      recommendations: [{ category: 'testing', suggestion: 'Cover the retry path', impact: 'Fewer regressions' }],
+    },
+  };
+
+  it('should keep the file list from a cross-file issue', () => {
+    const findings = collectPRLevelFindings([], { holisticAnalysis });
+
+    expect(findings.issues[0].files).toEqual(['a.js', 'b.js']);
+    expect(findings.issues[0].description).toBe('Duplicated retry logic');
+  });
+
+  it('should render a recommendation as text rather than raw JSON', () => {
+    const findings = collectPRLevelFindings([], { holisticAnalysis });
+
+    expect(findings.recommendations[0]).toBe('testing: Cover the retry path: Fewer regressions');
+  });
+});

package/src/rag-analyzer.js

@@ -764,7 +764,6 @@ function prepareContextForLLM(filePath, content, language, finalCodeExamples, fi
 async function callLLMForAnalysis(context, options = {}) {
   try {
     let prompt;
-    const model = options.model || 'claude-sonnet-4-6';
     const maxTokens = options.maxTokens || 8192; // Default to a safe limit
 
     if (options.isHolisticPRReview) {
@@ -778,7 +777,7 @@ async function callLLMForAnalysis(context, options = {}) {
     const llmResponse = await sendPromptToLLM(prompt, {
       temperature: 0,
       maxTokens: maxTokens,
-      model: model,
+      model: options.model,
       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)

package/src/rag-analyzer.test.js

@@ -242,6 +242,12 @@ describe('rag-analyzer', () => {
       expect(result.success).toBe(true);
     });
 
+    it('should forward an explicit model option to the LLM', async () => {
+      await runAnalysis('/test/file.js', { model: 'claude-3-opus' });
+
+      expect(llm.sendPromptToClaude).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ model: 'claude-3-opus' }));
+    });
+
     it('should handle diff-only mode', async () => {
       const result = await runAnalysis('/test/file.js', {
         diffOnly: true,