snow-ai 0.3.6 → 0.3.7

package/dist/agents/reviewAgent.d.ts

@@ -0,0 +1,50 @@
+export declare class ReviewAgent {
+    private modelName;
+    private requestMethod;
+    private initialized;
+    /**
+     * Initialize the review agent with current configuration
+     * Uses advanced model (same as main flow)
+     */
+    private initialize;
+    /**
+     * Check if review agent is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Check if current directory or any parent directory is a git repository
+     * @param startDir - Starting directory to check
+     * @returns Path to git root directory, or null if not found
+     */
+    private findGitRoot;
+    /**
+     * Check if git is available and current directory is in a git repository
+     * @returns Object with isGitRepo flag and optional error message
+     */
+    checkGitRepository(): {
+        isGitRepo: boolean;
+        gitRoot?: string;
+        error?: string;
+    };
+    /**
+     * Get git diff for uncommitted changes
+     * @param gitRoot - Git repository root directory
+     * @returns Git diff output
+     */
+    getGitDiff(gitRoot: string): string;
+    /**
+     * Generate code review prompt
+     */
+    private generateReviewPrompt;
+    /**
+     * Call the advanced model with streaming (same routing as main flow)
+     */
+    private callAdvancedModel;
+    /**
+     * Review git changes and return streaming generator
+     * @param abortSignal - Optional abort signal
+     * @returns Async generator for streaming response
+     */
+    reviewChanges(abortSignal?: AbortSignal): AsyncGenerator<any, void, unknown>;
+}
+export declare const reviewAgent: ReviewAgent;

package/dist/agents/reviewAgent.js

@@ -0,0 +1,264 @@
+import { getOpenAiConfig, getCustomSystemPrompt } from '../utils/apiConfig.js';
+import { logger } from '../utils/logger.js';
+import { createStreamingChatCompletion } from '../api/chat.js';
+import { createStreamingResponse } from '../api/responses.js';
+import { createStreamingGeminiCompletion } from '../api/gemini.js';
+import { createStreamingAnthropicCompletion } from '../api/anthropic.js';
+import { execSync } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+export class ReviewAgent {
+    constructor() {
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "requestMethod", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'chat'
+        });
+        Object.defineProperty(this, "initialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    /**
+     * Initialize the review agent with current configuration
+     * Uses advanced model (same as main flow)
+     */
+    async initialize() {
+        try {
+            const config = getOpenAiConfig();
+            if (!config.advancedModel) {
+                return false;
+            }
+            this.modelName = config.advancedModel;
+            this.requestMethod = config.requestMethod;
+            this.initialized = true;
+            return true;
+        }
+        catch (error) {
+            logger.warn('Failed to initialize review agent:', error);
+            return false;
+        }
+    }
+    /**
+     * Check if review agent is available
+     */
+    async isAvailable() {
+        if (!this.initialized) {
+            return await this.initialize();
+        }
+        return true;
+    }
+    /**
+     * Check if current directory or any parent directory is a git repository
+     * @param startDir - Starting directory to check
+     * @returns Path to git root directory, or null if not found
+     */
+    findGitRoot(startDir) {
+        let currentDir = path.resolve(startDir);
+        const root = path.parse(currentDir).root;
+        while (currentDir !== root) {
+            const gitDir = path.join(currentDir, '.git');
+            if (fs.existsSync(gitDir)) {
+                return currentDir;
+            }
+            currentDir = path.dirname(currentDir);
+        }
+        return null;
+    }
+    /**
+     * Check if git is available and current directory is in a git repository
+     * @returns Object with isGitRepo flag and optional error message
+     */
+    checkGitRepository() {
+        try {
+            // Check if git command is available
+            try {
+                execSync('git --version', { stdio: 'ignore' });
+            }
+            catch {
+                return {
+                    isGitRepo: false,
+                    error: 'Git is not installed or not available in PATH',
+                };
+            }
+            // Find git root directory (check current and parent directories)
+            const gitRoot = this.findGitRoot(process.cwd());
+            if (!gitRoot) {
+                return {
+                    isGitRepo: false,
+                    error: 'Current directory is not in a git repository. Please run this command from within a git repository.',
+                };
+            }
+            return { isGitRepo: true, gitRoot };
+        }
+        catch (error) {
+            return {
+                isGitRepo: false,
+                error: error instanceof Error
+                    ? error.message
+                    : 'Failed to check git repository',
+            };
+        }
+    }
+    /**
+     * Get git diff for uncommitted changes
+     * @param gitRoot - Git repository root directory
+     * @returns Git diff output
+     */
+    getGitDiff(gitRoot) {
+        try {
+            // Get staged changes
+            const stagedDiff = execSync('git diff --cached', {
+                cwd: gitRoot,
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+            });
+            // Get unstaged changes
+            const unstagedDiff = execSync('git diff', {
+                cwd: gitRoot,
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024,
+            });
+            // Combine both diffs
+            let combinedDiff = '';
+            if (stagedDiff) {
+                combinedDiff += '# Staged Changes\n\n' + stagedDiff + '\n\n';
+            }
+            if (unstagedDiff) {
+                combinedDiff += '# Unstaged Changes\n\n' + unstagedDiff;
+            }
+            if (!combinedDiff) {
+                return 'No changes detected in the repository.';
+            }
+            return combinedDiff;
+        }
+        catch (error) {
+            logger.error('Failed to get git diff:', error);
+            throw new Error('Failed to get git changes: ' +
+                (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }
+    /**
+     * Generate code review prompt
+     */
+    generateReviewPrompt(gitDiff) {
+        return `You are a senior code reviewer. Please review the following git changes and provide feedback.
+
+**Your task:**
+1. Identify potential bugs, security issues, or logic errors
+2. Suggest performance optimizations
+3. Point out code quality issues (readability, maintainability)
+4. Check for best practices violations
+5. Highlight any breaking changes or compatibility issues
+
+**Important:**
+- DO NOT modify the code yourself
+- Focus on finding issues and suggesting improvements
+- Ask the user if they want to fix any issues you find
+- Be constructive and specific in your feedback
+- Prioritize critical issues over minor style preferences
+
+**Git Changes:**
+
+\`\`\`diff
+${gitDiff}
+\`\`\`
+
+Please provide your review in a clear, structured format.`;
+    }
+    /**
+     * Call the advanced model with streaming (same routing as main flow)
+     */
+    async *callAdvancedModel(messages, abortSignal) {
+        const config = getOpenAiConfig();
+        if (!config.advancedModel) {
+            throw new Error('Advanced model not configured');
+        }
+        // Get custom system prompt if configured
+        const customSystemPrompt = getCustomSystemPrompt();
+        // If custom system prompt exists, prepend it to messages
+        let processedMessages = messages;
+        if (customSystemPrompt) {
+            processedMessages = [
+                {
+                    role: 'system',
+                    content: customSystemPrompt,
+                },
+                ...messages,
+            ];
+        }
+        // Route to appropriate streaming API based on request method
+        switch (this.requestMethod) {
+            case 'anthropic':
+                yield* createStreamingAnthropicCompletion({
+                    model: this.modelName,
+                    messages: processedMessages,
+                    max_tokens: 4096,
+                }, abortSignal);
+                break;
+            case 'gemini':
+                yield* createStreamingGeminiCompletion({
+                    model: this.modelName,
+                    messages: processedMessages,
+                }, abortSignal);
+                break;
+            case 'responses':
+                yield* createStreamingResponse({
+                    model: this.modelName,
+                    messages: processedMessages,
+                    stream: true,
+                }, abortSignal);
+                break;
+            case 'chat':
+            default:
+                yield* createStreamingChatCompletion({
+                    model: this.modelName,
+                    messages: processedMessages,
+                    stream: true,
+                }, abortSignal);
+                break;
+        }
+    }
+    /**
+     * Review git changes and return streaming generator
+     * @param abortSignal - Optional abort signal
+     * @returns Async generator for streaming response
+     */
+    async *reviewChanges(abortSignal) {
+        const available = await this.isAvailable();
+        if (!available) {
+            throw new Error('Review agent is not available');
+        }
+        // Check git repository
+        const gitCheck = this.checkGitRepository();
+        if (!gitCheck.isGitRepo) {
+            throw new Error(gitCheck.error || 'Not a git repository');
+        }
+        // Get git diff
+        const gitDiff = this.getGitDiff(gitCheck.gitRoot);
+        if (gitDiff === 'No changes detected in the repository.') {
+            throw new Error('No changes detected. Please make some changes before running code review.');
+        }
+        // Generate review prompt
+        const reviewPrompt = this.generateReviewPrompt(gitDiff);
+        const messages = [
+            {
+                role: 'user',
+                content: reviewPrompt,
+            },
+        ];
+        // Stream the response
+        yield* this.callAdvancedModel(messages, abortSignal);
+    }
+}
+// Export singleton instance
+export const reviewAgent = new ReviewAgent();

package/dist/api/anthropic.js

@@ -1,7 +1,10 @@
 import { createHash, randomUUID } from 'crypto';
-import { getOpenAiConfig, getCustomSystemPrompt, getCustomHeaders } from '../utils/apiConfig.js';
-import { SYSTEM_PROMPT } from './systemPrompt.js';
-import { withRetryGenerator } from '../utils/retryUtils.js';
+import { getOpenAiConfig, getCustomSystemPrompt, getCustomHeaders, } from '../utils/apiConfig.js';
+import { getSystemPrompt } from './systemPrompt.js';
+import { withRetryGenerator, parseJsonWithFix } from '../utils/retryUtils.js';
+import { logger } from '../utils/logger.js';
+import { addProxyToFetchOptions } from '../utils/proxyUtils.js';
+import { saveUsageToFile } from '../utils/usageLogger.js';
 let anthropicConfig = null;
 function getAnthropicConfig() {
     if (!anthropicConfig) {
@@ -16,7 +19,7 @@ function getAnthropicConfig() {
                 ? config.baseUrl
                 : 'https://api.anthropic.com/v1',
             customHeaders,
-            anthropicBeta: config.anthropicBeta
+            anthropicBeta: config.anthropicBeta,
         };
     }
     return anthropicConfig;
@@ -51,7 +54,7 @@ function convertToolsToAnthropic(tools) {
             return {
                 name: tool.function.name,
                 description: tool.function.description || '',
-                input_schema: tool.function.parameters
+                input_schema: tool.function.parameters,
             };
         }
         throw new Error('Invalid tool format');
@@ -78,11 +81,13 @@ function convertToAnthropicMessages(messages) {
         if (msg.role === 'tool' && msg.tool_call_id) {
             anthropicMessages.push({
                 role: 'user',
-                content: [{
+                content: [
+                    {
                         type: 'tool_result',
                         tool_use_id: msg.tool_call_id,
-                        content: msg.content
-                    }]
+                        content: msg.content,
+                    },
+                ],
             });
             continue;
         }
@@ -91,7 +96,7 @@ function convertToAnthropicMessages(messages) {
             if (msg.content) {
                 content.push({
                     type: 'text',
-                    text: msg.content
+                    text: msg.content,
                 });
             }
             for (const image of msg.images) {
@@ -102,23 +107,25 @@ function convertToAnthropicMessages(messages) {
                         source: {
                             type: 'base64',
                             media_type: base64Match[1] || image.mimeType,
-                            data: base64Match[2] || ''
-                        }
+                            data: base64Match[2] || '',
+                        },
                     });
                 }
             }
             anthropicMessages.push({
                 role: 'user',
-                content
+                content,
             });
             continue;
         }
-        if (msg.role === 'assistant' && msg.tool_calls && msg.tool_calls.length > 0) {
+        if (msg.role === 'assistant' &&
+            msg.tool_calls &&
+            msg.tool_calls.length > 0) {
             const content = [];
             if (msg.content) {
                 content.push({
                     type: 'text',
-                    text: msg.content
+                    text: msg.content,
                 });
             }
             for (const toolCall of msg.tool_calls) {
@@ -126,19 +133,19 @@ function convertToAnthropicMessages(messages) {
                     type: 'tool_use',
                     id: toolCall.id,
                     name: toolCall.function.name,
-                    input: JSON.parse(toolCall.function.arguments)
+                    input: JSON.parse(toolCall.function.arguments),
                 });
             }
             anthropicMessages.push({
                 role: 'assistant',
-                content
+                content,
             });
             continue;
         }
         if (msg.role === 'user' || msg.role === 'assistant') {
             anthropicMessages.push({
                 role: msg.role,
-                content: msg.content
+                content: msg.content,
             });
         }
     }
@@ -146,15 +153,17 @@ function convertToAnthropicMessages(messages) {
         systemContent = customSystemPrompt;
         anthropicMessages.unshift({
             role: 'user',
-            content: [{
+            content: [
+                {
                     type: 'text',
-                    text: SYSTEM_PROMPT,
-                    cache_control: { type: 'ephemeral' }
-                }]
+                    text: getSystemPrompt(),
+                    cache_control: { type: 'ephemeral' },
+                },
+            ],
         });
     }
     else if (!systemContent) {
-        systemContent = SYSTEM_PROMPT;
+        systemContent = getSystemPrompt();
     }
     let lastUserMessageIndex = -1;
     for (let i = anthropicMessages.length - 1; i >= 0; i--) {
@@ -170,11 +179,13 @@ function convertToAnthropicMessages(messages) {
         const lastMessage = anthropicMessages[lastUserMessageIndex];
         if (lastMessage && lastMessage.role === 'user') {
             if (typeof lastMessage.content === 'string') {
-                lastMessage.content = [{
+                lastMessage.content = [
+                    {
                         type: 'text',
                         text: lastMessage.content,
-                        cache_control: { type: 'ephemeral' }
-                    }];
+                        cache_control: { type: 'ephemeral' },
+                    },
+                ];
             }
             else if (Array.isArray(lastMessage.content)) {
                 const lastContentIndex = lastMessage.content.length - 1;
@@ -185,11 +196,15 @@ function convertToAnthropicMessages(messages) {
             }
         }
     }
-    const system = systemContent ? [{
-            type: 'text',
-            text: systemContent,
-            cache_control: { type: 'ephemeral' }
-        }] : undefined;
+    const system = systemContent
+        ? [
+            {
+                type: 'text',
+                text: systemContent,
+                cache_control: { type: 'ephemeral' },
+            },
+        ]
+        : undefined;
     return { system, messages: anthropicMessages };
 }
 /**
@@ -209,20 +224,24 @@ async function* parseSSEStream(reader) {
             const trimmed = line.trim();
             if (!trimmed || trimmed.startsWith(':'))
                 continue;
-            if (trimmed === 'data: [DONE]') {
+            if (trimmed === 'data: [DONE]' || trimmed === 'data:[DONE]') {
                 return;
             }
-            if (trimmed.startsWith('event: ')) {
+            // Handle both "event: " and "event:" formats
+            if (trimmed.startsWith('event:')) {
                 // Event type, will be followed by data
                 continue;
             }
-            if (trimmed.startsWith('data: ')) {
-                const data = trimmed.slice(6);
+            // Handle both "data: " and "data:" formats
+            if (trimmed.startsWith('data:')) {
+                const data = trimmed.startsWith('data: ')
+                    ? trimmed.slice(6)
+                    : trimmed.slice(5);
                 try {
                     yield JSON.parse(data);
                 }
                 catch (e) {
-                    console.error('Failed to parse SSE data:', data);
+                    logger.error('Failed to parse SSE data:', data);
                 }
             }
         }
@@ -245,17 +264,17 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
             messages,
             tools: convertToolsToAnthropic(options.tools),
             metadata: {
-                user_id: userId
+                user_id: userId,
             },
-            stream: true
+            stream: true,
         };
         // Prepare headers
         const headers = {
             'Content-Type': 'application/json',
             'x-api-key': config.apiKey,
-            'authorization': `Bearer ${config.apiKey}`,
+            'Authorization': `Bearer ${config.apiKey}`,
             'anthropic-version': '2023-06-01',
-            ...config.customHeaders
+            ...config.customHeaders,
         };
         // Add beta parameter if configured
         // if (config.anthropicBeta) {
@@ -264,12 +283,13 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
         const url = config.anthropicBeta
             ? `${config.baseUrl}/messages?beta=true`
             : `${config.baseUrl}/messages`;
-        const response = await fetch(url, {
+        const fetchOptions = addProxyToFetchOptions(url, {
             method: 'POST',
             headers,
             body: JSON.stringify(requestBody),
-            signal: abortSignal
+            signal: abortSignal,
         });
+        const response = await fetch(url, fetchOptions);
         if (!response.ok) {
             const errorText = await response.text();
             throw new Error(`Anthropic API error: ${response.status} ${response.statusText} - ${errorText}`);
@@ -298,12 +318,12 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
                         type: 'function',
                         function: {
                             name: block.name,
-                            arguments: ''
-                        }
+                            arguments: '',
+                        },
                     });
                     yield {
                         type: 'tool_call_delta',
-                        delta: block.name
+                        delta: block.name,
                     };
                 }
             }
@@ -314,7 +334,7 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
                     contentBuffer += text;
                     yield {
                         type: 'content',
-                        content: text
+                        content: text,
                     };
                 }
                 if (delta.type === 'input_json_delta') {
@@ -331,7 +351,7 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
                                 toolCall.function.arguments += cleanedDelta;
                                 yield {
                                     type: 'tool_call_delta',
-                                    delta: cleanedDelta
+                                    delta: cleanedDelta,
                                 };
                             }
                         }
@@ -351,9 +371,12 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
                     usageData = {
                         prompt_tokens: event.message.usage.input_tokens || 0,
                         completion_tokens: event.message.usage.output_tokens || 0,
-                        total_tokens: (event.message.usage.input_tokens || 0) + (event.message.usage.output_tokens || 0),
-                        cache_creation_input_tokens: event.message.usage.cache_creation_input_tokens,
-                        cache_read_input_tokens: event.message.usage.cache_read_input_tokens
+                        total_tokens: (event.message.usage.input_tokens || 0) +
+                            (event.message.usage.output_tokens || 0),
+                        cache_creation_input_tokens: event.message.usage
+                            .cache_creation_input_tokens,
+                        cache_read_input_tokens: event.message.usage
+                            .cache_read_input_tokens,
                     };
                 }
             }
@@ -363,11 +386,12 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
                         usageData = {
                             prompt_tokens: 0,
                             completion_tokens: 0,
-                            total_tokens: 0
+                            total_tokens: 0,
                         };
                     }
                     usageData.completion_tokens = event.usage.output_tokens || 0;
-                    usageData.total_tokens = usageData.prompt_tokens + usageData.completion_tokens;
+                    usageData.total_tokens =
+                        usageData.prompt_tokens + usageData.completion_tokens;
                     if (event.usage.cache_creation_input_tokens !== undefined) {
                         usageData.cache_creation_input_tokens = event.usage.cache_creation_input_tokens;
                     }
@@ -386,42 +410,51 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
                 if (!args) {
                     args = '{}';
                 }
-                // Try to parse the JSON
-                try {
-                    JSON.parse(args);
-                    toolCall.function.arguments = args;
+                // Try to parse the JSON using the unified parseJsonWithFix utility
+                if (completedToolBlocks.has(toolCall.id)) {
+                    // Tool block was completed, parse with fix and logging
+                    const parseResult = parseJsonWithFix(args, {
+                        toolName: toolCall.function.name,
+                        fallbackValue: {},
+                        logWarning: true,
+                        logError: true,
+                    });
+                    // Use the parsed data or fallback value
+                    toolCall.function.arguments = JSON.stringify(parseResult.data);
                 }
-                catch (e) {
-                    // Only throw error if this tool block was marked as completed
-                    // This prevents errors from incomplete streaming
-                    if (completedToolBlocks.has(toolCall.id)) {
-                        const errorMsg = e instanceof Error ? e.message : 'Unknown error';
-                        throw new Error(`Invalid tool call JSON for ${toolCall.function.name}: ${args} (${errorMsg})`);
-                    }
-                    else {
-                        // Tool block wasn't completed, likely interrupted stream
-                        // Use partial data or empty object
-                        console.warn(`Warning: Tool call ${toolCall.function.name} (${toolCall.id}) was incomplete. Using partial data.`);
-                        toolCall.function.arguments = '{}';
+                else {
+                    // Tool block wasn't completed, likely interrupted stream
+                    // Try to parse without logging errors (incomplete data is expected)
+                    const parseResult = parseJsonWithFix(args, {
+                        toolName: toolCall.function.name,
+                        fallbackValue: {},
+                        logWarning: false,
+                        logError: false,
+                    });
+                    if (!parseResult.success) {
+                        logger.warn(`Warning: Tool call ${toolCall.function.name} (${toolCall.id}) was incomplete. Using fallback data.`);
                     }
+                    toolCall.function.arguments = JSON.stringify(parseResult.data);
                 }
             }
             yield {
                 type: 'tool_calls',
-                tool_calls: toolCalls
+                tool_calls: toolCalls,
             };
         }
         if (usageData) {
+            // Save usage to file system at API layer
+            saveUsageToFile(options.model, usageData);
             yield {
                 type: 'usage',
-                usage: usageData
+                usage: usageData,
             };
         }
         yield {
-            type: 'done'
+            type: 'done',
         };
     }, {
         abortSignal,
-        onRetry
+        onRetry,
     });
 }