snow-ai 0.4.15 → 0.4.17

package/dist/mcp/websearch.d.ts

@@ -1,88 +0,0 @@
-import type { SearchResponse, WebPageContent } from './types/websearch.types.js';
-/**
- * Web Search Service using DuckDuckGo Lite with Puppeteer Core
- * Provides web search functionality with real browser support and proxy
- * Uses system-installed Chrome/Edge to reduce package size
- */
-export declare class WebSearchService {
-    private maxResults;
-    private browser;
-    private executablePath;
-    constructor(maxResults?: number);
-    /**
-     * Launch browser with proxy settings from config
-     */
-    private launchBrowser;
-    /**
-     * Close browser instance
-     */
-    closeBrowser(): Promise<void>;
-    /**
-     * Perform a web search using DuckDuckGo
-     * @param query - Search query string
-     * @param maxResults - Maximum number of results to return (default: 10)
-     * @returns Search results with title, URL, and snippet
-     */
-    search(query: string, maxResults?: number): Promise<SearchResponse>;
-    /**
-     * Fetch and extract content from a web page
-     * @param url - URL of the web page to fetch
-     * @param maxLength - Maximum content length (default: 50000 characters)
-     * @param userQuery - Optional user query for content extraction using compact model agent
-     * @param abortSignal - Optional abort signal from main flow
-     * @param onTokenUpdate - Optional callback to update token count during compression
-     * @returns Cleaned page content
-     */
-    fetchPage(url: string, maxLength?: number, userQuery?: string, abortSignal?: AbortSignal, onTokenUpdate?: (tokenCount: number) => void): Promise<WebPageContent>;
-}
-export declare const webSearchService: WebSearchService;
-export declare const mcpTools: ({
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            query: {
-                type: string;
-                description: string;
-            };
-            maxResults: {
-                type: string;
-                description: string;
-                default: number;
-                minimum: number;
-                maximum: number;
-            };
-            url?: undefined;
-            maxLength?: undefined;
-            userQuery?: undefined;
-        };
-        required: string[];
-    };
-} | {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            url: {
-                type: string;
-                description: string;
-            };
-            maxLength: {
-                type: string;
-                description: string;
-                default: number;
-                minimum: number;
-                maximum: number;
-            };
-            userQuery: {
-                type: string;
-                description: string;
-            };
-            query?: undefined;
-            maxResults?: undefined;
-        };
-        required: string[];
-    };
-})[];

package/dist/mcp/websearch.js

@@ -1,375 +0,0 @@
-import puppeteer from 'puppeteer-core';
-import { existsSync } from 'node:fs';
-import { getProxyConfig } from '../utils/apiConfig.js';
-// Utility functions
-import { findBrowserExecutable } from './utils/websearch/browser.utils.js';
-import { cleanText } from './utils/websearch/text.utils.js';
-/**
- * Web Search Service using DuckDuckGo Lite with Puppeteer Core
- * Provides web search functionality with real browser support and proxy
- * Uses system-installed Chrome/Edge to reduce package size
- */
-export class WebSearchService {
-    constructor(maxResults = 10) {
-        Object.defineProperty(this, "maxResults", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "browser", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "executablePath", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        this.maxResults = maxResults;
-    }
-    /**
-     * Launch browser with proxy settings from config
-     */
-    async launchBrowser() {
-        if (this.browser && this.browser.connected) {
-            return this.browser;
-        }
-        const proxyConfig = getProxyConfig();
-        // Find browser executable path (cache it)
-        // Priority: 1. User-configured path, 2. Auto-detect
-        if (!this.executablePath) {
-            // First try user-configured browser path
-            if (proxyConfig.browserPath && existsSync(proxyConfig.browserPath)) {
-                this.executablePath = proxyConfig.browserPath;
-            }
-            else {
-                // Fallback to auto-detection
-                this.executablePath = findBrowserExecutable();
-                if (!this.executablePath) {
-                    throw new Error('No system browser found. Please install Chrome or Edge browser, or configure browser path in Proxy settings.');
-                }
-            }
-        }
-        const launchArgs = [
-            '--no-sandbox',
-            '--disable-setuid-sandbox',
-            '--disable-dev-shm-usage',
-            '--disable-accelerated-2d-canvas',
-            '--disable-gpu',
-        ];
-        // Only add proxy if enabled
-        if (proxyConfig.enabled) {
-            launchArgs.unshift(`--proxy-server=http://127.0.0.1:${proxyConfig.port}`);
-        }
-        this.browser = await puppeteer.launch({
-            executablePath: this.executablePath,
-            headless: true,
-            args: launchArgs,
-        });
-        return this.browser;
-    }
-    /**
-     * Close browser instance
-     */
-    async closeBrowser() {
-        if (this.browser) {
-            await this.browser.close();
-            this.browser = null;
-        }
-    }
-    /**
-     * Perform a web search using DuckDuckGo
-     * @param query - Search query string
-     * @param maxResults - Maximum number of results to return (default: 10)
-     * @returns Search results with title, URL, and snippet
-     */
-    async search(query, maxResults) {
-        const limit = maxResults || this.maxResults;
-        let page = null;
-        try {
-            // Launch browser with proxy
-            const browser = await this.launchBrowser();
-            page = await browser.newPage();
-            // Set realistic user agent
-            await page.setUserAgent('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36');
-            // Encode query for URL
-            const encodedQuery = encodeURIComponent(query);
-            const searchUrl = `https://lite.duckduckgo.com/lite?q=${encodedQuery}`;
-            // Navigate to search page with timeout
-            await page.goto(searchUrl, {
-                waitUntil: 'networkidle2',
-                timeout: 30000,
-            });
-            // Extract search results from the page
-            const results = await page.evaluate((maxLimit) => {
-                const searchResults = [];
-                const rows = document.querySelectorAll('table tr');
-                let currentResult = {};
-                let resultCount = 0;
-                for (const row of rows) {
-                    if (resultCount >= maxLimit)
-                        break;
-                    // Check if this row contains a link (title row)
-                    const linkElement = row.querySelector('a.result-link');
-                    if (linkElement) {
-                        // Save previous result if exists
-                        if (currentResult.title && currentResult.url) {
-                            searchResults.push(currentResult);
-                            resultCount++;
-                            if (resultCount >= maxLimit)
-                                break;
-                        }
-                        // Start new result
-                        const title = linkElement.textContent?.trim() || '';
-                        const href = linkElement.getAttribute('href') || '';
-                        // Extract actual URL from DuckDuckGo redirect
-                        let actualUrl = href;
-                        if (href.includes('uddg=')) {
-                            const match = href.match(/uddg=([^&]+)/);
-                            if (match && match[1]) {
-                                actualUrl = decodeURIComponent(match[1]);
-                            }
-                        }
-                        currentResult = {
-                            title: title,
-                            url: actualUrl,
-                            snippet: '',
-                            displayUrl: '',
-                        };
-                        continue;
-                    }
-                    // Check if this row contains snippet
-                    const snippetElement = row.querySelector('td.result-snippet');
-                    if (snippetElement && currentResult.title) {
-                        currentResult.snippet = snippetElement.textContent?.trim() || '';
-                        continue;
-                    }
-                    // Check if this row contains display URL
-                    const displayUrlElement = row.querySelector('span.link-text');
-                    if (displayUrlElement && currentResult.title) {
-                        currentResult.displayUrl =
-                            displayUrlElement.textContent?.trim() || '';
-                    }
-                }
-                // Add last result if exists
-                if (currentResult.title &&
-                    currentResult.url &&
-                    resultCount < maxLimit) {
-                    searchResults.push(currentResult);
-                }
-                return searchResults;
-            }, limit);
-            // Clean text in results
-            const cleanedResults = results.map(result => ({
-                title: cleanText(result.title),
-                url: result.url,
-                snippet: cleanText(result.snippet),
-                displayUrl: cleanText(result.displayUrl),
-            }));
-            // Close the page
-            await page.close();
-            return {
-                query,
-                results: cleanedResults,
-                totalResults: cleanedResults.length,
-            };
-        }
-        catch (error) {
-            // Clean up page on error
-            if (page) {
-                try {
-                    await page.close();
-                }
-                catch {
-                    // Ignore close errors
-                }
-            }
-            throw new Error(`Web search failed: ${error.message}`);
-        }
-    }
-    /**
-     * Fetch and extract content from a web page
-     * @param url - URL of the web page to fetch
-     * @param maxLength - Maximum content length (default: 50000 characters)
-     * @param userQuery - Optional user query for content extraction using compact model agent
-     * @param abortSignal - Optional abort signal from main flow
-     * @param onTokenUpdate - Optional callback to update token count during compression
-     * @returns Cleaned page content
-     */
-    async fetchPage(url, maxLength = 50000, userQuery, abortSignal, onTokenUpdate) {
-        let page = null;
-        try {
-            // Launch browser with proxy
-            const browser = await this.launchBrowser();
-            page = await browser.newPage();
-            // Set realistic user agent
-            await page.setUserAgent('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36');
-            // Navigate to page with timeout
-            await page.goto(url, {
-                waitUntil: 'networkidle2',
-                timeout: 30000,
-            });
-            // Extract content using browser context
-            const pageData = await page.evaluate(() => {
-                // Remove unwanted elements
-                const selectorsToRemove = [
-                    'script',
-                    'style',
-                    'nav',
-                    'header',
-                    'footer',
-                    'iframe',
-                    'noscript',
-                    'svg',
-                    '.advertisement',
-                    '.ad',
-                    '.ads',
-                    '#cookie-banner',
-                    '.cookie-notice',
-                    '.social-share',
-                    '.comments',
-                    '.sidebar',
-                    '[role="banner"]',
-                    '[role="navigation"]',
-                    '[role="complementary"]',
-                ];
-                selectorsToRemove.forEach(selector => {
-                    document.querySelectorAll(selector).forEach(el => el.remove());
-                });
-                // Get title
-                const title = document.title || '';
-                // Try to find main content area
-                let mainContent = null;
-                const mainSelectors = [
-                    'article',
-                    'main',
-                    '[role="main"]',
-                    '.main-content',
-                    '.content',
-                    '#content',
-                    '.article-body',
-                    '.post-content',
-                ];
-                for (const selector of mainSelectors) {
-                    mainContent = document.querySelector(selector);
-                    if (mainContent)
-                        break;
-                }
-                // Fallback to body if no main content found
-                const contentElement = mainContent || document.body;
-                // Extract text content
-                const textContent = contentElement.textContent || '';
-                return {
-                    title,
-                    textContent,
-                };
-            });
-            // Clean and process the text
-            let cleanedContent = pageData.textContent
-                .replace(/\s+/g, ' ') // Replace multiple spaces with single space
-                .replace(/\n\s*\n/g, '\n') // Remove empty lines
-                .trim();
-            // Limit content length
-            if (cleanedContent.length > maxLength) {
-                cleanedContent =
-                    cleanedContent.slice(0, maxLength) + '\n\n[Content truncated...]';
-            }
-            // Create preview (first 500 characters)
-            const contentPreview = cleanedContent.slice(0, 500) +
-                (cleanedContent.length > 500 ? '...' : '');
-            // Close the page
-            await page.close();
-            // Use compact agent to extract key information if userQuery is provided
-            let finalContent = cleanedContent;
-            if (userQuery) {
-                try {
-                    const { compactAgent } = await import('../agents/compactAgent.js');
-                    const isAvailable = await compactAgent.isAvailable();
-                    if (isAvailable) {
-                        // Use compact model to extract relevant information
-                        // No timeout - let it run as long as needed
-                        finalContent = await compactAgent.extractWebPageContent(cleanedContent, userQuery, url, abortSignal, onTokenUpdate);
-                    }
-                }
-                catch (error) {
-                    // If compact agent fails, fallback to original content
-                    // Error is already logged in compactAgent
-                }
-            }
-            return {
-                url,
-                title: cleanText(pageData.title),
-                content: finalContent,
-                textLength: finalContent.length,
-                contentPreview,
-            };
-        }
-        catch (error) {
-            // Clean up page on error
-            if (page) {
-                try {
-                    await page.close();
-                }
-                catch {
-                    // Ignore close errors
-                }
-            }
-            throw new Error(`Failed to fetch page: ${error.message}`);
-        }
-    }
-}
-// Export a default instance
-export const webSearchService = new WebSearchService();
-// MCP Tool definitions
-export const mcpTools = [
-    {
-        name: 'websearch-search',
-        description: 'Search the web using DuckDuckGo. Returns a list of search results with titles, URLs, and snippets. Best for finding current information, documentation, news, or general web content. **IMPORTANT WORKFLOW**: After getting search results, analyze them and choose ONLY ONE most credible and relevant page to fetch. Do NOT fetch multiple pages - reading one high-quality source is sufficient and more efficient.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                query: {
-                    type: 'string',
-                    description: 'Search query string (e.g., "Claude latest model", "TypeScript best practices")',
-                },
-                maxResults: {
-                    type: 'number',
-                    description: 'Maximum number of results to return (default: 10, max: 20)',
-                    default: 10,
-                    minimum: 1,
-                    maximum: 20,
-                },
-            },
-            required: ['query'],
-        },
-    },
-    {
-        name: 'websearch-fetch',
-        description: "Fetch and read the full content of a web page. Automatically cleans HTML and extracts the main text content, removing ads, navigation, and other noise. **USAGE RULE**: Only fetch ONE page per search - choose the most credible and relevant result (prefer official documentation, reputable tech sites, or well-known sources). **OPTIMIZATION**: ALWAYS provide the userQuery parameter with the user's original question. This enables automatic extraction of only relevant information using a compact AI model, which dramatically saves context and improves response quality.",
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: {
-                    type: 'string',
-                    description: 'Full URL of the web page to fetch (e.g., "https://example.com/article")',
-                },
-                maxLength: {
-                    type: 'number',
-                    description: 'Maximum content length in characters (default: 50000, max: 100000)',
-                    default: 50000,
-                    minimum: 1000,
-                    maximum: 100000,
-                },
-                userQuery: {
-                    type: 'string',
-                    description: "REQUIRED: User's original question or query. This is essential for intelligent content extraction - the compact AI model will extract only information relevant to this query, reducing content size by 80-95%. Always provide this parameter.",
-                },
-            },
-            required: ['url'],
-        },
-    },
-];

package/dist/test/logger-test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/logger-test.js

@@ -1,7 +0,0 @@
-import { logger } from '../utils/logger.js';
-// Test the logger
-logger.info('Logger service initialized successfully');
-logger.error('Test error message', { errorCode: 500 });
-logger.warn('Test warning message');
-logger.debug('Debug information', { timestamp: Date.now() });
-console.log('Logger test completed. Check ./snow/log directory for log files.');

package/dist/types/index.d.ts

@@ -1,15 +0,0 @@
-export interface SnowConfig {
-    model?: string;
-    apiKey?: string;
-    maxTokens?: number;
-}
-export interface Command {
-    name: string;
-    description: string;
-    handler: (args: string[]) => Promise<void>;
-}
-export interface AppState {
-    isLoading: boolean;
-    currentCommand?: string;
-    history: string[];
-}

package/dist/types/index.js

@@ -1 +0,0 @@
-export {};

package/dist/ui/components/AgentPickerPanel.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import type { SubAgent } from '../../utils/subAgentConfig.js';
-interface Props {
-    agents: SubAgent[];
-    selectedIndex: number;
-    visible: boolean;
-    maxHeight?: number;
-}
-declare const AgentPickerPanel: React.MemoExoticComponent<({ agents, selectedIndex, visible, maxHeight }: Props) => React.JSX.Element | null>;
-export default AgentPickerPanel;

package/dist/ui/components/AgentPickerPanel.js

@@ -1,74 +0,0 @@
-import React, { memo, useMemo } from 'react';
-import { Box, Text } from 'ink';
-import { Alert } from '@inkjs/ui';
-import { useTheme } from '../contexts/ThemeContext.js';
-const AgentPickerPanel = memo(({ agents, selectedIndex, visible, maxHeight }) => {
-    const { theme } = useTheme();
-    // Fixed maximum display items to prevent rendering issues
-    const MAX_DISPLAY_ITEMS = 5;
-    const effectiveMaxItems = maxHeight
-        ? Math.min(maxHeight, MAX_DISPLAY_ITEMS)
-        : MAX_DISPLAY_ITEMS;
-    // Limit displayed agents
-    const displayedAgents = useMemo(() => {
-        if (agents.length <= effectiveMaxItems) {
-            return agents;
-        }
-        // Show agents around the selected index
-        const halfWindow = Math.floor(effectiveMaxItems / 2);
-        let startIndex = Math.max(0, selectedIndex - halfWindow);
-        let endIndex = Math.min(agents.length, startIndex + effectiveMaxItems);
-        // Adjust if we're near the end
-        if (endIndex - startIndex < effectiveMaxItems) {
-            startIndex = Math.max(0, endIndex - effectiveMaxItems);
-        }
-        return agents.slice(startIndex, endIndex);
-    }, [agents, selectedIndex, effectiveMaxItems]);
-    // Calculate actual selected index in the displayed subset
-    const displayedSelectedIndex = useMemo(() => {
-        return displayedAgents.findIndex(agent => {
-            const originalIndex = agents.indexOf(agent);
-            return originalIndex === selectedIndex;
-        });
-    }, [displayedAgents, agents, selectedIndex]);
-    // Don't show panel if not visible
-    if (!visible) {
-        return null;
-    }
-    // Show message if no agents configured
-    if (agents.length === 0) {
-        return (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Box, { width: "100%" },
-                React.createElement(Box, { flexDirection: "column", width: "100%" },
-                    React.createElement(Box, null,
-                        React.createElement(Text, { color: theme.colors.warning, bold: true }, "Sub-Agent Selection")),
-                    React.createElement(Box, { marginTop: 1 },
-                        React.createElement(Alert, { variant: "warning" }, "No sub-agents configured. Please configure sub-agents first."))))));
-    }
-    return (React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Box, { width: "100%" },
-            React.createElement(Box, { flexDirection: "column", width: "100%" },
-                React.createElement(Box, null,
-                    React.createElement(Text, { color: theme.colors.warning, bold: true },
-                        "Select Sub-Agent",
-                        ' ',
-                        agents.length > effectiveMaxItems &&
-                            `(${selectedIndex + 1}/${agents.length})`),
-                    React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true }, "(Press ESC to close)")),
-                displayedAgents.map((agent, index) => (React.createElement(Box, { key: agent.id, flexDirection: "column", width: "100%" },
-                    React.createElement(Text, { color: index === displayedSelectedIndex ? theme.colors.success : theme.colors.menuSecondary, bold: true },
-                        index === displayedSelectedIndex ? '❯ ' : '  ',
-                        "#",
-                        agent.name),
-                    React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(Text, { color: index === displayedSelectedIndex ? theme.colors.success : theme.colors.menuSecondary, dimColor: true },
-                            "\u2514\u2500 ",
-                            agent.description || 'No description'))))),
-                agents.length > effectiveMaxItems && (React.createElement(Box, { marginTop: 1 },
-                    React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true },
-                        "\u2191\u2193 to scroll \u00B7 ",
-                        agents.length - effectiveMaxItems,
-                        " more hidden")))))));
-});
-AgentPickerPanel.displayName = 'AgentPickerPanel';
-export default AgentPickerPanel;

package/dist/ui/components/ChatInput.d.ts

@@ -1,46 +0,0 @@
-import React from 'react';
-/**
- * Calculate context usage percentage
- * This is the same logic used in ChatInput to display usage
- */
-export declare function calculateContextPercentage(contextUsage: {
-    inputTokens: number;
-    maxContextTokens: number;
-    cacheCreationTokens?: number;
-    cacheReadTokens?: number;
-    cachedTokens?: number;
-}): number;
-type Props = {
-    onSubmit: (message: string, images?: Array<{
-        data: string;
-        mimeType: string;
-    }>) => void;
-    onCommand?: (commandName: string, result: any) => void;
-    placeholder?: string;
-    disabled?: boolean;
-    isProcessing?: boolean;
-    chatHistory?: Array<{
-        role: string;
-        content: string;
-    }>;
-    onHistorySelect?: (selectedIndex: number, message: string) => void;
-    yoloMode?: boolean;
-    contextUsage?: {
-        inputTokens: number;
-        maxContextTokens: number;
-        cacheCreationTokens?: number;
-        cacheReadTokens?: number;
-        cachedTokens?: number;
-    };
-    initialContent?: {
-        text: string;
-        images?: Array<{
-            type: 'image';
-            data: string;
-            mimeType: string;
-        }>;
-    } | null;
-    onContextPercentageChange?: (percentage: number) => void;
-};
-export default function ChatInput({ onSubmit, onCommand, placeholder, disabled, isProcessing, chatHistory, onHistorySelect, yoloMode, contextUsage, initialContent, onContextPercentageChange, }: Props): React.JSX.Element;
-export {};