snow-ai 0.3.31 → 0.3.32

package/dist/api/embedding.js

@@ -0,0 +1,74 @@
+import { loadCodebaseConfig } from '../utils/codebaseConfig.js';
+import { addProxyToFetchOptions } from '../utils/proxyUtils.js';
+/**
+ * Create embeddings for text array (single API call)
+ * @param options Embedding options
+ * @returns Embedding response with vectors
+ */
+export async function createEmbeddings(options) {
+    const config = loadCodebaseConfig();
+    // Use config defaults if not provided
+    const model = options.model || config.embedding.modelName;
+    const baseUrl = options.baseUrl || config.embedding.baseUrl;
+    const apiKey = options.apiKey || config.embedding.apiKey;
+    const dimensions = options.dimensions ?? config.embedding.dimensions;
+    const { input, task } = options;
+    if (!model) {
+        throw new Error('Embedding model name is required');
+    }
+    if (!baseUrl) {
+        throw new Error('Embedding base URL is required');
+    }
+    if (!apiKey) {
+        throw new Error('Embedding API key is required');
+    }
+    if (!input || input.length === 0) {
+        throw new Error('Input texts are required');
+    }
+    // Build request body
+    const requestBody = {
+        model,
+        input,
+    };
+    if (task) {
+        requestBody.task = task;
+    }
+    if (dimensions) {
+        requestBody.dimensions = dimensions;
+    }
+    // Use baseUrl directly, append /embeddings if needed
+    const url = baseUrl.endsWith('/embeddings')
+        ? baseUrl
+        : `${baseUrl.replace(/\/$/, '')}/embeddings`;
+    const fetchOptions = addProxyToFetchOptions(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify(requestBody),
+    });
+    const response = await fetch(url, fetchOptions);
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Embedding API error (${response.status}): ${errorText}`);
+    }
+    const data = await response.json();
+    return data;
+}
+/**
+ * Create embedding for single text
+ * @param text Single text to embed
+ * @param options Optional embedding options
+ * @returns Embedding vector
+ */
+export async function createEmbedding(text, options) {
+    const response = await createEmbeddings({
+        input: [text],
+        ...options,
+    });
+    if (response.data.length === 0) {
+        throw new Error('No embedding returned from API');
+    }
+    return response.data[0].embedding;
+}

package/dist/api/systemPrompt.d.ts

@@ -1,4 +1,8 @@
 /**
  * System prompt configuration for Snow AI CLI
  */
-export declare function getSystemPrompt(): string;
+export declare function getSystemPrompt(tools?: Array<{
+    function: {
+        name: string;
+    };
+}>): string;

package/dist/api/systemPrompt.js

@@ -90,15 +90,7 @@ const SYSTEM_PROMPT_TEMPLATE = `You are Snow AI CLI, an intelligent command-line
 - "Add validation to form" → Read form component + related validation utils → Add code → Done
 - "Refactor error handling" → Read error handler + callers → Refactor → Done
 
-**Your workflow:**
-1. Read the primary file(s) mentioned
-2. Check dependencies/imports that directly impact the change
-3. Read related files ONLY if they're critical to understanding the task
-4. Write/modify code with proper context
-5. Verify with build
-6. ❌ NO excessive exploration beyond what's needed
-7. ❌ NO reading entire modules "for reference"
-8. ❌ NO over-planning multi-step workflows for simple tasks
+PLACEHOLDER_FOR_WORKFLOW_SECTION
 
 **Golden Rule: Read what you need to write correct code, nothing more.**
 
@@ -154,11 +146,8 @@ const SYSTEM_PROMPT_TEMPLATE = `You are Snow AI CLI, an intelligent command-line
 - \`filesystem-edit\` - Modify existing files
 - \`filesystem-create\` - Create new files
 
-**Code Search (ACE):**
-- \`ace-search-symbols\` - Find functions/classes/variables
-- \`ace-find-definition\` - Go to definition
-- \`ace-find-references\` - Find all usages
-- \`ace-text-search\` - Fast text/regex search
+**Code Search:**
+PLACEHOLDER_FOR_CODE_SEARCH_SECTION
 
 **IDE Diagnostics:**
 - \`ide-get_diagnostics\` - Get real-time diagnostics (errors, warnings, hints) from connected IDE
@@ -314,11 +303,92 @@ Guidance and recommendations:
 - This file may not exist. If you can't find it, please ignore it.
 
 Remember: **ACTION > ANALYSIS**. Write code first, investigate only when blocked.`;
+/**
+ * Check if codebase-search tool is available
+ */
+function hasCodebaseSearchTool(tools) {
+    if (!tools)
+        return false;
+    return tools.some(tool => tool.function.name === 'codebase-search');
+}
+/**
+ * Generate workflow section based on available tools
+ */
+function getWorkflowSection(hasCodebase) {
+    if (hasCodebase) {
+        return `**Your workflow:**
+1. **Understand the task** - For conceptual questions, try \\\`codebase-search\\\` FIRST (semantic search)
+2. Read the primary file(s) mentioned (or files found by codebase search)
+3. Check dependencies/imports that directly impact the change
+4. For precise symbol lookup, use \\\`ace-search-symbols\\\`, \\\`ace-find-definition\\\`, or \\\`ace-find-references\\\`
+5. Read related files ONLY if they're critical to understanding the task
+6. Write/modify code with proper context
+7. Verify with build
+8. ❌ NO excessive exploration beyond what's needed
+9. ❌ NO reading entire modules "for reference"
+10. ❌ NO over-planning multi-step workflows for simple tasks`;
+    }
+    else {
+        return `**Your workflow:**
+1. Read the primary file(s) mentioned
+2. Use \\\`ace-search-symbols\\\`, \\\`ace-find-definition\\\`, or \\\`ace-find-references\\\` to find related code
+3. Check dependencies/imports that directly impact the change
+4. Read related files ONLY if they're critical to understanding the task
+5. Write/modify code with proper context
+6. Verify with build
+7. ❌ NO excessive exploration beyond what's needed
+8. ❌ NO reading entire modules "for reference"
+9. ❌ NO over-planning multi-step workflows for simple tasks`;
+    }
+}
+/**
+ * Generate code search section based on available tools
+ */
+function getCodeSearchSection(hasCodebase) {
+    if (hasCodebase) {
+        // When codebase tool is available, prioritize it
+        return `**Code Search:**
+
+🎯 **Priority Order (use in this sequence):**
+
+1. **Codebase Semantic Search** (⚡ HIGHEST PRIORITY):
+   - \\\`codebase-search\\\` - Semantic search using embeddings
+     - 🔍 Find code by MEANING, not just keywords
+     - 🎯 Best for: "how is authentication handled", "error handling patterns"
+     - 📊 Returns: Full code content + similarity scores + file locations
+     - 💡 **IMPORTANT**: Always try this FIRST for conceptual queries!
+     - 🚀 **When to use**: Understanding concepts, finding similar code, pattern discovery
+     - ❌ **When to skip**: Exact symbol names, file-specific searches (use ACE instead)
+
+2. **ACE Code Search** (Fallback for precise lookups):
+   - \\\`ace-search-symbols\\\` - Find functions/classes/variables by exact name
+   - \\\`ace-find-definition\\\` - Go to definition of a symbol
+   - \\\`ace-find-references\\\` - Find all usages of a symbol
+   - \\\`ace-text-search\\\` - Fast text/regex search across files
+   - 💡 **When to use**: Exact symbol lookup, reference finding, regex patterns`;
+    }
+    else {
+        // When codebase tool is NOT available, only show ACE
+        return `**Code Search (ACE):**
+- \\\`ace-search-symbols\\\` - Find functions/classes/variables by exact name
+- \\\`ace-find-definition\\\` - Go to definition of a symbol
+- \\\`ace-find-references\\\` - Find all usages of a symbol
+- \\\`ace-text-search\\\` - Fast text/regex search across files`;
+    }
+}
 // Export SYSTEM_PROMPT as a getter function for real-time ROLE.md updates
-export function getSystemPrompt() {
+export function getSystemPrompt(tools) {
     const basePrompt = getSystemPromptWithRole();
     const systemEnv = getSystemEnvironmentInfo();
-    return `${basePrompt}
+    const hasCodebase = hasCodebaseSearchTool(tools);
+    // Generate dynamic sections
+    const workflowSection = getWorkflowSection(hasCodebase);
+    const codeSearchSection = getCodeSearchSection(hasCodebase);
+    // Replace placeholders with actual content
+    let finalPrompt = basePrompt
+        .replace('PLACEHOLDER_FOR_WORKFLOW_SECTION', workflowSection)
+        .replace('PLACEHOLDER_FOR_CODE_SEARCH_SECTION', codeSearchSection);
+    return `${finalPrompt}
 
 ## 💻 System Environment
 

package/dist/hooks/useConversation.js

@@ -37,7 +37,7 @@ export async function handleConversationWithTools(options) {
     const mcpTools = await collectAllMCPTools();
     // Build conversation history with TODO context as pinned user message
     let conversationMessages = [
-        { role: 'system', content: getSystemPrompt() },
+        { role: 'system', content: getSystemPrompt(mcpTools) },
     ];
     // If there are TODOs, add pinned context message at the front
     if (existingTodoList && existingTodoList.todos.length > 0) {

package/dist/mcp/aceCodeSearch.d.ts

@@ -86,19 +86,6 @@ export declare class ACECodeSearchService {
      * Search with language-specific context (cross-reference search)
      */
     semanticSearch(query: string, searchType?: 'definition' | 'usage' | 'implementation' | 'all', language?: string, maxResults?: number): Promise<SemanticSearchResult>;
-    /**
-     * Clear the symbol index cache and force full re-index on next search
-     */
-    clearCache(): void;
-    /**
-     * Get index statistics
-     */
-    getIndexStats(): {
-        totalFiles: number;
-        totalSymbols: number;
-        languageBreakdown: Record<string, number>;
-        cacheAge: number;
-    };
 }
 export declare const aceCodeSearchService: ACECodeSearchService;
 export declare const mcpTools: ({
@@ -282,24 +269,4 @@ export declare const mcpTools: ({
         };
         required: string[];
     };
-} | {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            query?: undefined;
-            symbolType?: undefined;
-            language?: undefined;
-            maxResults?: undefined;
-            symbolName?: undefined;
-            contextFile?: undefined;
-            searchType?: undefined;
-            filePath?: undefined;
-            pattern?: undefined;
-            fileGlob?: undefined;
-            isRegex?: undefined;
-        };
-        required?: undefined;
-    };
 })[];

package/dist/mcp/aceCodeSearch.js

@@ -875,36 +875,6 @@ export class ACECodeSearchService {
             searchTime,
         };
     }
-    /**
-     * Clear the symbol index cache and force full re-index on next search
-     */
-    clearCache() {
-        this.indexCache.clear();
-        this.fileModTimes.clear();
-        this.allIndexedFiles.clear();
-        this.fileContentCache.clear();
-        this.lastIndexTime = 0;
-    }
-    /**
-     * Get index statistics
-     */
-    getIndexStats() {
-        let totalSymbols = 0;
-        const languageBreakdown = {};
-        for (const symbols of this.indexCache.values()) {
-            totalSymbols += symbols.length;
-            for (const symbol of symbols) {
-                languageBreakdown[symbol.language] =
-                    (languageBreakdown[symbol.language] || 0) + 1;
-            }
-        }
-        return {
-            totalFiles: this.indexCache.size,
-            totalSymbols,
-            languageBreakdown,
-            cacheAge: Date.now() - this.lastIndexTime,
-        };
-    }
 }
 // Export a default instance
 export const aceCodeSearchService = new ACECodeSearchService();
@@ -1075,20 +1045,4 @@ export const mcpTools = [
             required: ['pattern'],
         },
     },
-    {
-        name: 'ace-index_stats',
-        description: 'ACE Code Search: Get statistics about the code index. Shows number of indexed files, symbols, language breakdown, and cache status. Useful for understanding search coverage.',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'ace-clear_cache',
-        description: 'ACE Code Search: Clear the symbol index cache and force a full re-index on next search. Use when codebase has changed significantly or search results seem stale.',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
 ];

package/dist/mcp/codebaseSearch.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Codebase Search Service
+ * Provides semantic search capabilities for the codebase using embeddings
+ */
+declare class CodebaseSearchService {
+    /**
+     * Check if codebase index is available and has data
+     */
+    private isCodebaseIndexAvailable;
+    /**
+     * Calculate cosine similarity between two vectors
+     */
+    private cosineSimilarity;
+    /**
+     * Search codebase using semantic similarity
+     */
+    search(query: string, topN?: number): Promise<any>;
+}
+export declare const codebaseSearchService: CodebaseSearchService;
+/**
+ * MCP Tools Definition
+ */
+export declare const mcpTools: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            topN: {
+                type: string;
+                description: string;
+                default: number;
+                minimum: number;
+                maximum: number;
+            };
+        };
+        required: string[];
+    };
+}[];
+export {};

package/dist/mcp/codebaseSearch.js

@@ -0,0 +1,146 @@
+import { CodebaseDatabase } from '../utils/codebaseDatabase.js';
+import { createEmbedding } from '../api/embedding.js';
+import { logger } from '../utils/logger.js';
+import path from 'node:path';
+import fs from 'node:fs';
+/**
+ * Codebase Search Service
+ * Provides semantic search capabilities for the codebase using embeddings
+ */
+class CodebaseSearchService {
+    /**
+     * Check if codebase index is available and has data
+     */
+    isCodebaseIndexAvailable() {
+        try {
+            const projectRoot = process.cwd();
+            const dbPath = path.join(projectRoot, '.snow', 'codebase', 'embeddings.db');
+            // Check if database file exists
+            if (!fs.existsSync(dbPath)) {
+                return {
+                    available: false,
+                    reason: 'Codebase index not found. Please run codebase indexing first.',
+                };
+            }
+            // Initialize database and check for data
+            const db = new CodebaseDatabase(projectRoot);
+            db.initialize();
+            const totalChunks = db.getTotalChunks();
+            db.close();
+            if (totalChunks === 0) {
+                return {
+                    available: false,
+                    reason: 'Codebase index is empty. Please run indexing to build the index.',
+                };
+            }
+            return { available: true };
+        }
+        catch (error) {
+            logger.error('Error checking codebase index availability:', error);
+            return {
+                available: false,
+                reason: `Error checking codebase index: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            };
+        }
+    }
+    /**
+     * Calculate cosine similarity between two vectors
+     */
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length) {
+            throw new Error('Vectors must have same length');
+        }
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+    }
+    /**
+     * Search codebase using semantic similarity
+     */
+    async search(query, topN = 10) {
+        // Check if codebase index is available
+        const { available, reason } = this.isCodebaseIndexAvailable();
+        if (!available) {
+            return {
+                error: reason,
+                results: [],
+                totalResults: 0,
+            };
+        }
+        try {
+            const projectRoot = process.cwd();
+            const db = new CodebaseDatabase(projectRoot);
+            db.initialize();
+            const totalChunks = db.getTotalChunks();
+            // Generate embedding for query
+            logger.info(`Generating embedding for query: "${query}"`);
+            const queryEmbedding = await createEmbedding(query);
+            // Search similar chunks
+            logger.info(`Searching top ${topN} similar chunks from ${totalChunks} total chunks`);
+            const results = db.searchSimilar(queryEmbedding, topN);
+            // Format results with similarity scores and full content (no truncation)
+            const formattedResults = results.map((chunk, index) => {
+                const score = this.cosineSimilarity(queryEmbedding, chunk.embedding);
+                const scorePercent = (score * 100).toFixed(2);
+                return {
+                    rank: index + 1,
+                    filePath: chunk.filePath,
+                    startLine: chunk.startLine,
+                    endLine: chunk.endLine,
+                    content: chunk.content, // Full content, no truncation
+                    similarityScore: scorePercent,
+                    location: `${chunk.filePath}:${chunk.startLine}-${chunk.endLine}`,
+                };
+            });
+            db.close();
+            return {
+                query,
+                totalChunks,
+                resultsCount: formattedResults.length,
+                results: formattedResults,
+            };
+        }
+        catch (error) {
+            logger.error('Codebase search failed:', error);
+            throw error;
+        }
+    }
+}
+// Export singleton instance
+export const codebaseSearchService = new CodebaseSearchService();
+/**
+ * MCP Tools Definition
+ */
+export const mcpTools = [
+    {
+        name: 'codebase-search',
+        description: '🔍 Semantic search across the codebase using embeddings. ' +
+            'Finds code snippets similar to your query based on meaning, not just keywords. ' +
+            'Returns full code content with similarity scores and file locations. ' +
+            'NOTE: Only available when codebase indexing is enabled and the index has been built. ' +
+            'If the index is not available, the tool will return an error message with instructions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Search query describing the code you want to find (e.g., "database query", "error handling", "authentication logic")',
+                },
+                topN: {
+                    type: 'number',
+                    description: 'Maximum number of results to return (default: 10, max: 50)',
+                    default: 10,
+                    minimum: 1,
+                    maximum: 50,
+                },
+            },
+            required: ['query'],
+        },
+    },
+];