codecritique 1.1.1 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codecritique",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "description": "AI-powered code review tool for any programming language",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -54,6 +54,7 @@ program
   .option('--model <model>', 'LLM model to use (e.g., claude-sonnet-4-5)')
   .option('--temperature <number>', 'LLM temperature', parseFloat, 0.2)
   .option('--max-tokens <number>', 'LLM max tokens', parseInt, 8192)
+  .option('--cache-ttl <ttl>', 'Cache TTL for LLM prompts: "5m" (default, no extra cost) or "1h" (extended, extra cost for writes)', '5m')
   .option('--similarity-threshold <number>', 'Threshold for finding similar code examples', parseFloat, 0.6)
   .option('--max-examples <number>', 'Max similar code examples to use', parseInt, 5)
   .option('--concurrency <number>', 'Concurrency for processing multiple files', parseInt, 3)
@@ -329,6 +330,7 @@ async function runCodeReview(options) {
     model: options.model,
     temperature: options.temperature,
     maxTokens: options.maxTokens,
+    cacheTtl: options.cacheTtl,
     similarityThreshold: options.similarityThreshold,
     maxExamples: options.maxExamples,
     concurrency: options.concurrency,
@@ -418,19 +420,18 @@ async function runCodeReview(options) {
         outputFn(reviewResult.results, options);
         console.log(chalk.bold.green(`\nAnalysis complete for ${operationDescription}! (${duration}s)`));
       } else {
-        console.log(chalk.yellow('No results to display. Review result structure:'));
-        console.log(chalk.yellow('reviewResult.results exists?'), reviewResult.results ? 'Yes' : 'No');
-        if (reviewResult.results) {
-          console.log(chalk.yellow('reviewResult.results type:'), typeof reviewResult.results);
-          console.log(chalk.yellow('reviewResult.results is array?'), Array.isArray(reviewResult.results));
-          if (!Array.isArray(reviewResult.results)) {
-            console.log(
-              chalk.yellow('reviewResult.results content:'),
-              JSON.stringify(reviewResult.results, null, 2).substring(0, 500) + '...'
-            );
-          }
+        // No results to display (e.g., all files were excluded/skipped)
+        const message = reviewResult.message || 'All files were excluded from review (e.g., config files, lock files).';
+        console.log(chalk.yellow(message));
+
+        // Still output empty results if outputFile is specified (for CI/CD pipelines)
+        if (options.outputFile) {
+          const outputFn = options.output === 'json' ? outputJson : options.output === 'markdown' ? outputMarkdown : outputText;
+          outputFn([], options);
+          console.log(chalk.yellow(`Empty results written to: ${options.outputFile}`));
         }
-        console.log(chalk.yellow(reviewResult.message || 'Review completed, but no results to display.'));
+
+        console.log(chalk.bold.yellow(`\nReview complete for ${operationDescription} - no reviewable files found (${duration}s)`));
       }
     } else {
       console.error(chalk.red('\nCode review process failed.'));

package/src/llm.js

@@ -5,6 +5,11 @@
  * for code analysis and review. Enhanced to leverage project-specific patterns and
  * feedback from PR reviews for more context-aware recommendations.
  * Currently supports Anthropic's Claude Sonnet 4.
+ *
+ * Prompt Caching:
+ * This module uses Anthropic's prompt caching feature for cost optimization.
+ * Static content in the system message is cached and reused across multiple
+ * requests, reducing input token costs by 75%.
  */
 
 import { Anthropic } from '@anthropic-ai/sdk';
@@ -15,6 +20,7 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 let anthropic = null;
+
 /**
  * Get the Anthropic client
  * @returns {Anthropic} The Anthropic client
@@ -36,80 +42,93 @@ const DEFAULT_MODEL = 'claude-sonnet-4-5';
 const MAX_TOKENS = 4096;
 
 /**
- * Send a prompt to Claude and get a structured JSON response using tool calling
+ * Send a prompt to Claude and get a structured JSON response using tool calling.
+ * Uses prompt caching for system prompts to reduce token costs.
  *
  * @param {string} prompt - The prompt to send to Claude
  * @param {Object} options - Options for the request
+ * @param {string} options.system - System prompt (will be cached for cost optimization)
  * @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)
  * @returns {Promise<Object>} The response from Claude with structured data
  */
 async function sendPromptToClaude(prompt, options = {}) {
-  const { model = DEFAULT_MODEL, maxTokens = MAX_TOKENS, temperature = 0.7, system = '', jsonSchema = null } = options;
+  const { model = DEFAULT_MODEL, maxTokens = MAX_TOKENS, temperature = 0.7, system = '', jsonSchema = null, cacheTtl = '5m' } = options;
 
   try {
     console.log(chalk.cyan('Sending prompt to Claude...'));
 
     const client = getAnthropicClient();
 
-    // Use structured output with tool calling if schema is provided
+    // Build system content with cache_control for cost optimization
+    // The system is passed as an array of blocks with cache_control on the static portion
+    // TTL options: '5m' (default, no extra cost) or '1h' (extended, extra cost for cache writes)
+    const cacheControl = cacheTtl === '1h' ? { type: 'ephemeral', ttl: '1h' } : { type: 'ephemeral' };
+
+    const systemContent = system
+      ? [
+          {
+            type: 'text',
+            text: system,
+            cache_control: cacheControl,
+          },
+        ]
+      : 'You are an expert code reviewer with deep knowledge of software engineering principles, design patterns, and best practices.';
+
+    // Build base request parameters
+    const requestParams = {
+      model,
+      max_tokens: maxTokens,
+      temperature,
+      system: systemContent,
+      messages: [
+        {
+          role: 'user',
+          content: prompt,
+        },
+      ],
+    };
+
+    // Add tool calling if JSON schema is provided
     if (jsonSchema) {
-      const tools = [
+      requestParams.tools = [
         {
           name: 'return_json',
           description: 'Return the final answer strictly as JSON matching the schema.',
           input_schema: jsonSchema,
         },
       ];
+      requestParams.tool_choice = { type: 'tool', name: 'return_json' };
+    }
 
-      const response = await client.messages.create({
-        model,
-        max_tokens: maxTokens,
-        temperature,
-        tools,
-        tool_choice: { type: 'tool', name: 'return_json' },
-        system:
-          system ||
-          'You are an expert code reviewer with deep knowledge of software engineering principles, design patterns, and best practices.',
-        messages: [
-          {
-            role: 'user',
-            content: prompt,
-          },
-        ],
-      });
+    const response = await client.messages.create(requestParams);
+
+    // Log response structure for debugging
+    console.log(chalk.gray(`  Response stop_reason: ${response.stop_reason}`));
+    console.log(chalk.gray(`  Response content blocks: ${response.content?.length || 0}`));
 
-      // Find the tool_use block and extract the structured data
+    // 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');
 
       if (!toolUse) {
+        // Log actual content for debugging
+        console.error(chalk.red('No tool_use block found. Response content:'));
+        response.content?.forEach((block, i) => {
+          console.error(chalk.gray(`  Block ${i}: type=${block.type}, name=${block.name || 'N/A'}`));
+        });
         throw new Error('No structured output received from Claude');
       }
 
       return {
-        content: JSON.stringify(toolUse.input, null, 2), // For backward compatibility
+        content: JSON.stringify(toolUse.input, null, 2),
         model: response.model,
         usage: response.usage,
-        json: toolUse.input, // The parsed JavaScript object
+        json: toolUse.input,
       };
     } else {
-      // Fallback to regular text response
-      const response = await client.messages.create({
-        model,
-        max_tokens: maxTokens,
-        temperature,
-        system:
-          system ||
-          'You are an expert code reviewer with deep knowledge of software engineering principles, design patterns, and best practices.',
-        messages: [
-          {
-            role: 'user',
-            content: prompt,
-          },
-        ],
-      });
-
       return {
-        content: response.content[0].text,
+        content: response.content[0]?.text || '',
         model: response.model,
         usage: response.usage,
       };

package/src/llm.test.js

@@ -75,7 +75,13 @@ describe('sendPromptToClaude', () => {
           model: 'claude-3-opus',
           max_tokens: 8192,
           temperature: 0.5,
-          system: 'Custom system prompt',
+          system: [
+            {
+              type: 'text',
+              text: 'Custom system prompt',
+              cache_control: { type: 'ephemeral' },
+            },
+          ],
         })
       );
     });
@@ -225,7 +231,13 @@ describe('sendPromptToClaude', () => {
 
       expect(mockMessagesCreate).toHaveBeenCalledWith(
         expect.objectContaining({
-          system: customSystem,
+          system: [
+            {
+              type: 'text',
+              text: customSystem,
+              cache_control: { type: 'ephemeral' },
+            },
+          ],
         })
       );
     });

package/src/project-analyzer.js

@@ -11,6 +11,7 @@ import path from 'path';
 import chalk from 'chalk';
 import { getDefaultEmbeddingsSystem } from './embeddings/factory.js';
 import * as llm from './llm.js';
+import { FILE_SELECTION_SYSTEM_PROMPT, PROJECT_SUMMARY_SYSTEM_PROMPT } from './prompt-cache.js';
 import { isDocumentationFile, isTestFile } from './utils/file-validation.js';
 
 // Consolidated file classification configuration
@@ -494,18 +495,7 @@ Project: ${path.basename(projectPath)}
 Files found by embeddings search:
 ${candidatesSummary}
 
-Select files that best reveal the project's architecture:
-- Framework setup & key configurations
-- Custom utilities, hooks, and wrappers
-- API/data layer patterns and GraphQL setup
-- Type definitions & core interfaces
-- Entry points, routing, and main structure
-- State management and data flow patterns
-
-IMPORTANT: Return ONLY a JSON array of file paths, nothing else:
-["path1", "path2", "path3"]
-
-Select files that define HOW this project works, especially custom implementations.`;
+Select files following the criteria in the system instructions.`;
 
     try {
       const fileSelectionSchema = {
@@ -524,6 +514,7 @@ Select files that define HOW this project works, especially custom implementatio
       };
 
       const response = await this.llm.sendPromptToClaude(prompt, {
+        system: FILE_SELECTION_SYSTEM_PROMPT,
         temperature: 0.1,
         maxTokens: 1000,
         jsonSchema: fileSelectionSchema,
@@ -636,11 +627,15 @@ Select files that define HOW this project works, especially custom implementatio
   async generateProjectSummary(keyFiles, projectPath) {
     const fileContents = await this.extractFileContents(keyFiles);
 
-    const prompt = `Analyze this project's architecture and provide a comprehensive summary. Here are the key files:
+    const prompt = `Analyze this project's architecture and provide a comprehensive summary.
+
+## KEY FILES
 
 ${fileContents}
 
-Please analyze this project and provide a JSON response with:
+## OUTPUT FORMAT
+
+Provide a JSON response with this structure:
 
 {
   "projectName": "Project name from package.json or inferred",
@@ -661,7 +656,7 @@ Please analyze this project and provide a JSON response with:
       "name": "Custom feature/hook/utility name",
       "description": "What it does and HOW it modifies standard library behavior",
       "files": ["Files where it's defined"],
-      "properties": ["Key properties/methods it exposes, especially any that extend standard objects"],
+      "properties": ["Key properties/methods it exposes"],
       "usage": "How it should be used",
       "extendsStandard": "Which standard library/framework objects or APIs this modifies"
     }
@@ -697,44 +692,11 @@ Please analyze this project and provide a JSON response with:
   "reviewGuidelines": [
     "Specific guidelines for code review based on this project's patterns",
     "What to look for in PRs",
-    "Common patterns that should be maintained",
-    "Potential issues specific to this architecture"
+    "Common patterns that should be maintained"
   ]
 }
 
-Focus on identifying patterns that would help in code review, especially:
-- Custom utilities or modules that extend standard frameworks and libraries
-- **CRITICAL: Custom properties or methods added to standard library objects** (e.g., custom properties on database query results, API responses, or framework objects)
-- **Extensions to library APIs** - any way this project modifies or enhances standard library behavior
-- Specific ways APIs are called and results are handled (look for non-standard patterns)
-- Data flow and processing patterns
-- Module organization and code structure patterns
-- Type definitions and interfaces that define contracts, especially those that extend standard types
-- Configuration patterns and environment handling
-- **Custom wrappers** around standard libraries that add functionality
-
-**CRITICAL ANALYSIS REQUIRED**: Look specifically for code that:
-1. **Takes standard library return values and adds custom properties** - For example:
-   - Functions that take query results and add success/loading/error properties
-   - Wrappers that enhance API responses with additional metadata
-   - Custom hooks that extend standard framework hooks with extra functionality
-2. **Modifies or extends standard library interfaces** - Look for:
-   - TypeScript interfaces that extend standard types with additional fields
-   - Custom implementations that add methods to standard objects
-   - Wrapper classes that enhance standard library functionality
-3. **Creates custom versions of standard patterns** - Such as:
-   - Custom error handling that adds properties to standard error objects
-   - Middleware that modifies standard request/response patterns
-   - Custom state management that extends standard patterns
-
-**EXAMPLES TO RECOGNIZE**:
-- If you see a function that takes a standard query result and returns an object with added success/error properties, identify this as a custom implementation
-- If you see custom hooks that wrap standard library hooks and add properties, document these
-- If you see type definitions that extend standard interfaces, note what properties they add
-
-**OUTPUT REQUIREMENT**: For each custom implementation found, specifically identify what standard library object or pattern it extends in the "extendsStandard" field.
-
-Be thorough but concise. This summary will be used to provide context during automated code reviews to prevent false positives about "non-standard" properties that are actually valid custom implementations in this project.`;
+Follow the analysis guidelines from the system instructions to identify custom implementations and patterns.`;
 
     try {
       const projectSummarySchema = {
@@ -807,6 +769,7 @@ Be thorough but concise. This summary will be used to provide context during aut
       };
 
       const response = await this.llm.sendPromptToClaude(prompt, {
+        system: PROJECT_SUMMARY_SYSTEM_PROMPT,
         temperature: 0.1,
         maxTokens: 4000,
         jsonSchema: projectSummarySchema,