snow-ai 0.3.36 → 0.4.0

package/dist/agents/codebaseIndexAgent.js

@@ -619,6 +619,7 @@ Object.defineProperty(CodebaseIndexAgent, "CODE_EXTENSIONS", {
         '.kt',
         '.scala',
         '.m',
+        '.md',
         '.mm',
         '.sh',
         '.bash',

package/dist/agents/codebaseReviewAgent.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Codebase Review Agent Service
+ *
+ * Reviews codebase search results to filter out irrelevant items.
+ * Uses basicModel for efficient, low-cost relevance checking.
+ * Can also suggest better search keywords if results are not relevant.
+ */
+export declare class CodebaseReviewAgent {
+    private modelName;
+    private requestMethod;
+    private initialized;
+    private readonly MAX_RETRIES;
+    /**
+     * Initialize the review agent with current configuration
+     */
+    private initialize;
+    /**
+     * Check if review agent is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Call the model with streaming API and assemble complete response
+     */
+    private callModel;
+    /**
+     * Try to parse JSON response with retry logic
+     */
+    private tryParseJSON;
+    /**
+     * Review search results with retry mechanism
+     */
+    private reviewWithRetry;
+    /**
+     * Sleep utility for retry backoff
+     */
+    private sleep;
+    /**
+     * Review search results and filter out irrelevant ones
+     * With retry mechanism and graceful degradation
+     *
+     * @param query - Original search query
+     * @param results - Search results to review
+     * @param abortSignal - Optional abort signal
+     * @returns Object with filtered results and optional suggestions
+     */
+    reviewResults(query: string, results: Array<{
+        rank: number;
+        filePath: string;
+        startLine: number;
+        endLine: number;
+        content: string;
+        similarityScore: string;
+        location: string;
+    }>, abortSignal?: AbortSignal): Promise<{
+        filteredResults: typeof results;
+        removedCount: number;
+        suggestions?: string[];
+        reviewFailed?: boolean;
+    }>;
+}
+export declare const codebaseReviewAgent: CodebaseReviewAgent;

package/dist/agents/codebaseReviewAgent.js

@@ -0,0 +1,301 @@
+import { getOpenAiConfig } 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';
+/**
+ * Codebase Review Agent Service
+ *
+ * Reviews codebase search results to filter out irrelevant items.
+ * Uses basicModel for efficient, low-cost relevance checking.
+ * Can also suggest better search keywords if results are not relevant.
+ */
+export class CodebaseReviewAgent {
+    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
+        });
+        Object.defineProperty(this, "MAX_RETRIES", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 3
+        });
+    }
+    /**
+     * Initialize the review agent with current configuration
+     */
+    async initialize() {
+        try {
+            const config = getOpenAiConfig();
+            if (!config.basicModel) {
+                logger.warn('Codebase review agent: Basic model not configured, using advanced model as fallback');
+                if (!config.advancedModel) {
+                    logger.warn('Codebase review agent: No model configured');
+                    return false;
+                }
+                this.modelName = config.advancedModel;
+            }
+            else {
+                this.modelName = config.basicModel;
+            }
+            this.requestMethod = config.requestMethod;
+            this.initialized = true;
+            return true;
+        }
+        catch (error) {
+            logger.warn('Codebase review agent: Failed to initialize:', error);
+            return false;
+        }
+    }
+    /**
+     * Check if review agent is available
+     */
+    async isAvailable() {
+        if (!this.initialized) {
+            return await this.initialize();
+        }
+        return true;
+    }
+    /**
+     * Call the model with streaming API and assemble complete response
+     */
+    async callModel(messages, abortSignal) {
+        let streamGenerator;
+        switch (this.requestMethod) {
+            case 'anthropic':
+                streamGenerator = createStreamingAnthropicCompletion({
+                    model: this.modelName,
+                    messages,
+                    includeBuiltinSystemPrompt: false,
+                    disableThinking: true,
+                }, abortSignal);
+                break;
+            case 'gemini':
+                streamGenerator = createStreamingGeminiCompletion({
+                    model: this.modelName,
+                    messages,
+                    includeBuiltinSystemPrompt: false,
+                }, abortSignal);
+                break;
+            case 'responses':
+                streamGenerator = createStreamingResponse({
+                    model: this.modelName,
+                    messages,
+                    stream: true,
+                    includeBuiltinSystemPrompt: false,
+                }, abortSignal);
+                break;
+            case 'chat':
+            default:
+                streamGenerator = createStreamingChatCompletion({
+                    model: this.modelName,
+                    messages,
+                    stream: true,
+                    includeBuiltinSystemPrompt: false,
+                }, abortSignal);
+                break;
+        }
+        let completeContent = '';
+        try {
+            for await (const chunk of streamGenerator) {
+                if (abortSignal?.aborted) {
+                    throw new Error('Request aborted');
+                }
+                if (this.requestMethod === 'chat') {
+                    if (chunk.choices && chunk.choices[0]?.delta?.content) {
+                        completeContent += chunk.choices[0].delta.content;
+                    }
+                }
+                else {
+                    if (chunk.type === 'content' && chunk.content) {
+                        completeContent += chunk.content;
+                    }
+                }
+            }
+        }
+        catch (streamError) {
+            logger.error('Codebase review agent: Streaming error:', streamError);
+            throw streamError;
+        }
+        return completeContent;
+    }
+    /**
+     * Try to parse JSON response with retry logic
+     */
+    tryParseJSON(response) {
+        try {
+            // Extract JSON from markdown code blocks if present
+            let jsonStr = response.trim();
+            const jsonMatch = jsonStr.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+            if (jsonMatch) {
+                jsonStr = jsonMatch[1].trim();
+            }
+            const parsed = JSON.parse(jsonStr);
+            // Validate structure
+            if (!Array.isArray(parsed.relevantIndices)) {
+                logger.warn('Codebase review agent: Invalid JSON structure - missing relevantIndices array');
+                return null;
+            }
+            return parsed;
+        }
+        catch (error) {
+            logger.warn('Codebase review agent: JSON parse error:', error);
+            return null;
+        }
+    }
+    /**
+     * Review search results with retry mechanism
+     */
+    async reviewWithRetry(query, results, abortSignal) {
+        const reviewPrompt = `You are a code search result reviewer. Your task is to analyze search results and determine which ones are truly relevant to the user's query.
+
+Search Query: "${query}"
+
+Search Results (${results.length} items):
+${results
+            .map((r, idx) => `\n[Result ${idx + 1}]
+File: ${r.filePath}
+Lines: ${r.startLine}-${r.endLine}
+Similarity Score: ${r.similarityScore}%
+Code:
+\`\`\`
+${r.content}
+\`\`\``)
+            .join('\n---')}
+
+Your Tasks:
+1. Identify which results are RELEVANT to the search query
+2. Mark irrelevant results for removal
+3. If most results are irrelevant, suggest better search keywords
+
+Output in JSON format:
+{
+  "relevantIndices": [1, 3, 5],
+  "removedIndices": [2, 4],
+  "suggestions": ["keyword1", "keyword2"]
+}
+
+Guidelines:
+- Be strict but fair: code doesn't need to match exactly, but should be semantically related
+- Consider file paths, code content, and context
+- If a result is marginally relevant, keep it
+- Only suggest new keywords if >50% of results are irrelevant
+- Return ONLY valid JSON, no other text or explanation`;
+        const messages = [
+            {
+                role: 'user',
+                content: reviewPrompt,
+            },
+        ];
+        // Retry loop
+        for (let attempt = 1; attempt <= this.MAX_RETRIES; attempt++) {
+            try {
+                logger.info(`Codebase review agent: Attempt ${attempt}/${this.MAX_RETRIES}`);
+                const response = await this.callModel(messages, abortSignal);
+                if (!response || response.trim().length === 0) {
+                    logger.warn(`Codebase review agent: Empty response on attempt ${attempt}`);
+                    if (attempt < this.MAX_RETRIES) {
+                        await this.sleep(500 * attempt); // Exponential backoff
+                        continue;
+                    }
+                    return null;
+                }
+                // Try to parse JSON
+                const parsed = this.tryParseJSON(response);
+                if (parsed) {
+                    logger.info(`Codebase review agent: Successfully parsed on attempt ${attempt}`);
+                    return { parsed, attempt };
+                }
+                // If parse failed and we have retries left
+                if (attempt < this.MAX_RETRIES) {
+                    logger.warn(`Codebase review agent: Parse failed on attempt ${attempt}, retrying...`);
+                    await this.sleep(500 * attempt); // Exponential backoff
+                    continue;
+                }
+                return null;
+            }
+            catch (error) {
+                logger.error(`Codebase review agent: Error on attempt ${attempt}:`, error);
+                if (attempt < this.MAX_RETRIES) {
+                    await this.sleep(500 * attempt); // Exponential backoff
+                    continue;
+                }
+                return null;
+            }
+        }
+        return null;
+    }
+    /**
+     * Sleep utility for retry backoff
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Review search results and filter out irrelevant ones
+     * With retry mechanism and graceful degradation
+     *
+     * @param query - Original search query
+     * @param results - Search results to review
+     * @param abortSignal - Optional abort signal
+     * @returns Object with filtered results and optional suggestions
+     */
+    async reviewResults(query, results, abortSignal) {
+        const available = await this.isAvailable();
+        if (!available) {
+            logger.warn('Codebase review agent: Not available, returning original results');
+            return {
+                filteredResults: results,
+                removedCount: 0,
+                reviewFailed: true,
+            };
+        }
+        // Attempt review with retry
+        const reviewResult = await this.reviewWithRetry(query, results, abortSignal);
+        // If all retries failed, gracefully degrade
+        if (!reviewResult) {
+            logger.warn('Codebase review agent: All retry attempts failed, returning original results');
+            return {
+                filteredResults: results,
+                removedCount: 0,
+                reviewFailed: true,
+            };
+        }
+        // Success - filter results
+        const { parsed, attempt } = reviewResult;
+        const filteredResults = results.filter((_, idx) => parsed.relevantIndices.includes(idx + 1));
+        const removedCount = results.length - filteredResults.length;
+        logger.info('Codebase review agent: Review completed', {
+            originalCount: results.length,
+            filteredCount: filteredResults.length,
+            removedCount,
+            attempts: attempt,
+            hasSuggestions: !!parsed.suggestions?.length,
+        });
+        return {
+            filteredResults,
+            removedCount,
+            suggestions: parsed.suggestions || undefined,
+            reviewFailed: false,
+        };
+    }
+}
+// Export singleton instance
+export const codebaseReviewAgent = new CodebaseReviewAgent();

package/dist/agents/promptOptimizeAgent.d.ts

@@ -0,0 +1,54 @@
+import { type ChatMessage } from '../api/chat.js';
+/**
+ * Prompt Optimization Agent Service
+ *
+ * Optimizes user prompts for better AI understanding and response quality.
+ * This service operates using the basic model for efficient, low-cost optimization.
+ *
+ * Features:
+ * - Uses basicModel for efficient prompt optimization
+ * - Follows the same API routing as main flow (chat, responses, gemini, anthropic)
+ * - Filters context to only include user->assistant pairs without tool calls
+ * - Returns optimized prompt that preserves user intent while improving clarity
+ * - Silent execution with error handling to prevent main flow disruption
+ */
+export declare class PromptOptimizeAgent {
+    private modelName;
+    private requestMethod;
+    private initialized;
+    /**
+     * Initialize the prompt optimization agent with current configuration
+     * @returns true if initialized successfully, false otherwise
+     */
+    private initialize;
+    /**
+     * Check if prompt optimization agent is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Call the model with streaming API and assemble complete response
+     * Uses the same routing logic as main flow for consistency
+     *
+     * @param messages - Chat messages
+     * @param abortSignal - Optional abort signal to cancel the request
+     */
+    private callModel;
+    /**
+     * Filter conversation history to only include user->assistant pairs without tool calls
+     * This creates a lightweight context for prompt optimization
+     *
+     * @param messages - Full conversation history
+     * @returns Filtered messages containing only user->assistant exchanges
+     */
+    private filterContextMessages;
+    /**
+     * Optimize user prompt for better AI understanding
+     *
+     * @param userPrompt - Original user prompt
+     * @param conversationHistory - Full conversation history for context
+     * @param abortSignal - Optional abort signal to cancel optimization
+     * @returns Optimized prompt, or original prompt if optimization fails
+     */
+    optimizePrompt(userPrompt: string, conversationHistory: ChatMessage[], abortSignal?: AbortSignal): Promise<string>;
+}
+export declare const promptOptimizeAgent: PromptOptimizeAgent;

package/dist/agents/promptOptimizeAgent.js

@@ -0,0 +1,268 @@
+import { getOpenAiConfig } 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';
+/**
+ * Prompt Optimization Agent Service
+ *
+ * Optimizes user prompts for better AI understanding and response quality.
+ * This service operates using the basic model for efficient, low-cost optimization.
+ *
+ * Features:
+ * - Uses basicModel for efficient prompt optimization
+ * - Follows the same API routing as main flow (chat, responses, gemini, anthropic)
+ * - Filters context to only include user->assistant pairs without tool calls
+ * - Returns optimized prompt that preserves user intent while improving clarity
+ * - Silent execution with error handling to prevent main flow disruption
+ */
+export class PromptOptimizeAgent {
+    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 prompt optimization agent with current configuration
+     * @returns true if initialized successfully, false otherwise
+     */
+    async initialize() {
+        try {
+            const config = getOpenAiConfig();
+            // Check if basic model is configured
+            if (!config.basicModel) {
+                logger.warn('Prompt optimize agent: Basic model not configured');
+                return false;
+            }
+            this.modelName = config.basicModel;
+            this.requestMethod = config.requestMethod;
+            this.initialized = true;
+            return true;
+        }
+        catch (error) {
+            logger.warn('Prompt optimize agent: Failed to initialize:', error);
+            return false;
+        }
+    }
+    /**
+     * Check if prompt optimization agent is available
+     */
+    async isAvailable() {
+        if (!this.initialized) {
+            return await this.initialize();
+        }
+        return true;
+    }
+    /**
+     * Call the model with streaming API and assemble complete response
+     * Uses the same routing logic as main flow for consistency
+     *
+     * @param messages - Chat messages
+     * @param abortSignal - Optional abort signal to cancel the request
+     */
+    async callModel(messages, abortSignal) {
+        let streamGenerator;
+        // Route to appropriate streaming API based on request method
+        switch (this.requestMethod) {
+            case 'anthropic':
+                streamGenerator = createStreamingAnthropicCompletion({
+                    model: this.modelName,
+                    messages,
+                    max_tokens: 1000, // Limited tokens for prompt optimization
+                    includeBuiltinSystemPrompt: false,
+                    disableThinking: true, // Agents don't use Extended Thinking
+                }, abortSignal);
+                break;
+            case 'gemini':
+                streamGenerator = createStreamingGeminiCompletion({
+                    model: this.modelName,
+                    messages,
+                    includeBuiltinSystemPrompt: false,
+                }, abortSignal);
+                break;
+            case 'responses':
+                streamGenerator = createStreamingResponse({
+                    model: this.modelName,
+                    messages,
+                    stream: true,
+                    includeBuiltinSystemPrompt: false,
+                }, abortSignal);
+                break;
+            case 'chat':
+            default:
+                streamGenerator = createStreamingChatCompletion({
+                    model: this.modelName,
+                    messages,
+                    stream: true,
+                    includeBuiltinSystemPrompt: false,
+                }, abortSignal);
+                break;
+        }
+        // Assemble complete content from streaming response
+        let completeContent = '';
+        try {
+            for await (const chunk of streamGenerator) {
+                // Check abort signal
+                if (abortSignal?.aborted) {
+                    throw new Error('Request aborted');
+                }
+                // Handle different chunk formats based on request method
+                if (this.requestMethod === 'chat') {
+                    // Chat API uses standard OpenAI format
+                    if (chunk.choices && chunk.choices[0]?.delta?.content) {
+                        completeContent += chunk.choices[0].delta.content;
+                    }
+                }
+                else {
+                    // Responses, Gemini, and Anthropic APIs use unified format
+                    if (chunk.type === 'content' && chunk.content) {
+                        completeContent += chunk.content;
+                    }
+                }
+            }
+        }
+        catch (streamError) {
+            logger.error('Prompt optimize agent: Streaming error:', streamError);
+            throw streamError;
+        }
+        return completeContent;
+    }
+    /**
+     * Filter conversation history to only include user->assistant pairs without tool calls
+     * This creates a lightweight context for prompt optimization
+     *
+     * @param messages - Full conversation history
+     * @returns Filtered messages containing only user->assistant exchanges
+     */
+    filterContextMessages(messages) {
+        const filtered = [];
+        for (const msg of messages) {
+            // Only include user and assistant messages
+            if (msg.role === 'user' || msg.role === 'assistant') {
+                // For assistant messages, skip if they contain tool calls
+                if (msg.role === 'assistant') {
+                    // Check if message has tool_calls (OpenAI format) or tool_use content (Anthropic format)
+                    const hasToolCalls = !!msg.tool_calls;
+                    const hasToolUseContent = Array.isArray(msg.content) &&
+                        msg.content.some((c) => c.type === 'tool_use' || c.type === 'tool_call');
+                    if (hasToolCalls || hasToolUseContent) {
+                        continue; // Skip assistant messages with tool calls
+                    }
+                }
+                // Add message to filtered list
+                filtered.push(msg);
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Optimize user prompt for better AI understanding
+     *
+     * @param userPrompt - Original user prompt
+     * @param conversationHistory - Full conversation history for context
+     * @param abortSignal - Optional abort signal to cancel optimization
+     * @returns Optimized prompt, or original prompt if optimization fails
+     */
+    async optimizePrompt(userPrompt, conversationHistory, abortSignal) {
+        const available = await this.isAvailable();
+        if (!available) {
+            return userPrompt;
+        }
+        try {
+            // Check word count - if prompt > 100 words, skip optimization
+            // User likely provided detailed/important original text that should be preserved as-is
+            const wordCount = userPrompt.trim().split(/\s+/).length;
+            if (wordCount > 100) {
+                return userPrompt;
+            }
+            // Filter conversation history to lightweight context (only user<->assistant, no tool calls)
+            const contextMessages = this.filterContextMessages(conversationHistory);
+            // Build context summary if there's conversation history
+            let contextSummary = '';
+            if (contextMessages.length > 0) {
+                // Take last 8 messages to keep context focused, but use full content (no truncation)
+                const recentContext = contextMessages.slice(-8);
+                contextSummary =
+                    '\n\nRecent conversation context:\n' +
+                        recentContext
+                            .map((msg) => {
+                            const content = typeof msg.content === 'string'
+                                ? msg.content
+                                : JSON.stringify(msg.content);
+                            // Use full message content (no truncation)
+                            return `${msg.role}: ${content}`;
+                        })
+                            .join('\n');
+            }
+            const optimizationPrompt = `You are a prompt optimization assistant. Your task is to improve user prompts for better AI understanding while maintaining HIGH FIDELITY to the original content.
+
+User's original prompt:
+${userPrompt}${contextSummary}
+
+Your optimization goals (in priority order):
+1. **HIGH FIDELITY REQUIREMENT**: Preserve ALL important information, details, and requirements from the user's original prompt - DO NOT lose or omit any critical content
+2. Preserve the EXACT SAME LANGUAGE as the user (if Chinese, stay Chinese; if English, stay English)
+3. Keep the core intent and meaning unchanged
+4. Make the prompt clearer and more specific ONLY if vague - if already clear, keep it as-is
+5. Add relevant context if the user is asking follow-up questions
+6. Break down complex requests into clear requirements without losing details
+7. Keep the tone natural and conversational
+8. DO NOT add unnecessary formality or change the user's communication style
+9. If the prompt is already clear and specific, return it as-is
+
+CRITICAL RULES:
+- NEVER remove important details, specific requirements, file paths, code snippets, or technical specifications
+- NEVER simplify the prompt if it means losing user-provided information
+- When in doubt, prefer preserving the original over optimizing
+- The goal is CLARITY, not BREVITY - keep all important content
+
+IMPORTANT: Output ONLY the optimized prompt text. No explanations, no meta-commentary, no JSON format. Just the optimized prompt itself.`;
+            const messages = [
+                {
+                    role: 'user',
+                    content: optimizationPrompt,
+                },
+            ];
+            const optimizedPrompt = await this.callModel(messages, abortSignal);
+            if (!optimizedPrompt || optimizedPrompt.trim().length === 0) {
+                logger.warn('Prompt optimize agent: Empty response, using original prompt');
+                return userPrompt;
+            }
+            // Clean up the response (remove any markdown formatting if present)
+            let cleanedPrompt = optimizedPrompt.trim();
+            // Remove markdown code blocks if present
+            const codeBlockMatch = cleanedPrompt.match(/```[\s\S]*?\n([\s\S]*?)```/);
+            if (codeBlockMatch) {
+                cleanedPrompt = codeBlockMatch[1].trim();
+            }
+            // If optimized prompt is suspiciously short or looks like it failed, use original
+            if (cleanedPrompt.length < userPrompt.length * 0.3) {
+                logger.warn('Prompt optimize agent: Optimized prompt too short, using original');
+                return userPrompt;
+            }
+            return cleanedPrompt;
+        }
+        catch (error) {
+            logger.error('Prompt optimize agent: Failed to optimize prompt', error);
+            return userPrompt;
+        }
+    }
+}
+// Export singleton instance
+export const promptOptimizeAgent = new PromptOptimizeAgent();