snow-ai 0.4.15 → 0.4.17

package/dist/agents/promptOptimizeAgent.d.ts

@@ -1,54 +0,0 @@
-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

@@ -1,268 +0,0 @@
-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();

package/dist/agents/reviewAgent.d.ts

@@ -1,50 +0,0 @@
-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

@@ -1,265 +0,0 @@
-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,
-                    disableThinking: true, // Agents 不使用 Extended Thinking
-                }, 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/agents/summaryAgent.d.ts

@@ -1,57 +0,0 @@
-/**
- * Summary Agent Service
- *
- * Generates concise summaries for conversations after the first user-assistant exchange.
- * This service operates in the background without blocking the main conversation flow.
- *
- * Features:
- * - Uses basicModel for efficient, low-cost summarization
- * - Follows the same API routing as main flow (chat, responses, gemini, anthropic)
- * - Generates title (max 50 chars) and summary (max 150 chars)
- * - Only runs once after the first complete conversation exchange
- * - Silent execution with error handling to prevent main flow disruption
- */
-export declare class SummaryAgent {
-    private modelName;
-    private requestMethod;
-    private initialized;
-    /**
-     * Initialize the summary agent with current configuration
-     * @returns true if initialized successfully, false otherwise
-     */
-    private initialize;
-    /**
-     * Check if summary 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;
-    /**
-     * Generate title and summary for a conversation
-     *
-     * @param userMessage - User's first message content
-     * @param assistantMessage - Assistant's first response content
-     * @param abortSignal - Optional abort signal to cancel generation
-     * @returns Object containing title and summary, or null if generation fails
-     */
-    generateSummary(userMessage: string, assistantMessage: string, abortSignal?: AbortSignal): Promise<{
-        title: string;
-        summary: string;
-    } | null>;
-    /**
-     * Generate fallback summary when AI generation fails
-     * Simply truncates the user message for title and summary
-     */
-    private generateFallbackSummary;
-    /**
-     * Truncate string to specified length, adding ellipsis if truncated
-     */
-    private truncateString;
-}
-export declare const summaryAgent: SummaryAgent;