snow-ai 0.3.31 → 0.3.33

package/dist/utils/codebaseDatabase.js

@@ -0,0 +1,333 @@
+import Database from 'better-sqlite3';
+import path from 'node:path';
+import fs from 'node:fs';
+import { logger } from './logger.js';
+/**
+ * Codebase SQLite database manager
+ * Handles embedding storage with vector support
+ */
+export class CodebaseDatabase {
+    constructor(projectRoot) {
+        Object.defineProperty(this, "db", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "dbPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "initialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        // Store database in .snow/codebase directory
+        const snowDir = path.join(projectRoot, '.snow', 'codebase');
+        if (!fs.existsSync(snowDir)) {
+            fs.mkdirSync(snowDir, { recursive: true });
+        }
+        this.dbPath = path.join(snowDir, 'embeddings.db');
+    }
+    /**
+     * Initialize database and create tables
+     */
+    initialize() {
+        if (this.initialized)
+            return;
+        try {
+            // Open database with better-sqlite3
+            this.db = new Database(this.dbPath);
+            // Enable WAL mode for better concurrency
+            this.db.pragma('journal_mode = WAL');
+            // Create tables
+            this.createTables();
+            this.initialized = true;
+            logger.info('Codebase database initialized', { path: this.dbPath });
+        }
+        catch (error) {
+            logger.error('Failed to initialize codebase database', error);
+            throw error;
+        }
+    }
+    /**
+     * Create database tables
+     */
+    createTables() {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        // Code chunks table with embeddings
+        this.db.exec(`
+			CREATE TABLE IF NOT EXISTS code_chunks (
+				id INTEGER PRIMARY KEY AUTOINCREMENT,
+				file_path TEXT NOT NULL,
+				content TEXT NOT NULL,
+				start_line INTEGER NOT NULL,
+				end_line INTEGER NOT NULL,
+				embedding BLOB NOT NULL,
+				file_hash TEXT NOT NULL,
+				created_at INTEGER NOT NULL,
+				updated_at INTEGER NOT NULL
+			);
+			
+			CREATE INDEX IF NOT EXISTS idx_file_path ON code_chunks(file_path);
+			CREATE INDEX IF NOT EXISTS idx_file_hash ON code_chunks(file_hash);
+		`);
+        // Indexing progress table
+        this.db.exec(`
+			CREATE TABLE IF NOT EXISTS index_progress (
+				id INTEGER PRIMARY KEY CHECK (id = 1),
+				total_files INTEGER NOT NULL DEFAULT 0,
+				processed_files INTEGER NOT NULL DEFAULT 0,
+				total_chunks INTEGER NOT NULL DEFAULT 0,
+				status TEXT NOT NULL DEFAULT 'idle',
+				last_error TEXT,
+				last_processed_file TEXT,
+				started_at INTEGER,
+				completed_at INTEGER,
+				updated_at INTEGER NOT NULL,
+				watcher_enabled INTEGER NOT NULL DEFAULT 0
+			);
+			
+			-- Initialize progress record if not exists
+			INSERT OR IGNORE INTO index_progress (id, updated_at) VALUES (1, ${Date.now()});
+		`);
+    }
+    /**
+     * Insert or update code chunks (batch operation)
+     */
+    insertChunks(chunks) {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        const insert = this.db.prepare(`
+			INSERT INTO code_chunks (
+				file_path, content, start_line, end_line, 
+				embedding, file_hash, created_at, updated_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+		`);
+        const transaction = this.db.transaction((chunks) => {
+            for (const chunk of chunks) {
+                // Convert embedding array to Buffer for storage
+                const embeddingBuffer = Buffer.from(new Float32Array(chunk.embedding).buffer);
+                insert.run(chunk.filePath, chunk.content, chunk.startLine, chunk.endLine, embeddingBuffer, chunk.fileHash, chunk.createdAt, chunk.updatedAt);
+            }
+        });
+        transaction(chunks);
+    }
+    /**
+     * Delete chunks by file path
+     */
+    deleteChunksByFile(filePath) {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        const stmt = this.db.prepare('DELETE FROM code_chunks WHERE file_path = ?');
+        stmt.run(filePath);
+    }
+    /**
+     * Get chunks by file path
+     */
+    getChunksByFile(filePath) {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        const stmt = this.db.prepare('SELECT * FROM code_chunks WHERE file_path = ?');
+        const rows = stmt.all(filePath);
+        return rows.map(row => this.rowToChunk(row));
+    }
+    /**
+     * Check if file has been indexed by hash
+     */
+    hasFileHash(fileHash) {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        const stmt = this.db.prepare('SELECT COUNT(*) as count FROM code_chunks WHERE file_hash = ?');
+        const result = stmt.get(fileHash);
+        return result.count > 0;
+    }
+    /**
+     * Get total chunks count
+     */
+    getTotalChunks() {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        const stmt = this.db.prepare('SELECT COUNT(*) as count FROM code_chunks');
+        const result = stmt.get();
+        return result.count;
+    }
+    /**
+     * Search similar code chunks by embedding
+     * Uses cosine similarity
+     */
+    searchSimilar(queryEmbedding, limit = 10) {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        // Get all chunks (in production, use approximate nearest neighbor)
+        const stmt = this.db.prepare('SELECT * FROM code_chunks');
+        const rows = stmt.all();
+        // Calculate cosine similarity for each chunk
+        const results = rows.map(row => {
+            const chunk = this.rowToChunk(row);
+            const similarity = this.cosineSimilarity(queryEmbedding, chunk.embedding);
+            return { chunk, similarity };
+        });
+        // Sort by similarity and return top N
+        results.sort((a, b) => b.similarity - a.similarity);
+        return results.slice(0, limit).map(r => r.chunk);
+    }
+    /**
+     * Update indexing progress
+     */
+    updateProgress(progress) {
+        if (!this.db || !this.initialized) {
+            // Silently ignore if database is not initialized
+            return;
+        }
+        const fields = [];
+        const values = [];
+        if (progress.totalFiles !== undefined) {
+            fields.push('total_files = ?');
+            values.push(progress.totalFiles);
+        }
+        if (progress.processedFiles !== undefined) {
+            fields.push('processed_files = ?');
+            values.push(progress.processedFiles);
+        }
+        if (progress.totalChunks !== undefined) {
+            fields.push('total_chunks = ?');
+            values.push(progress.totalChunks);
+        }
+        if (progress.status !== undefined) {
+            fields.push('status = ?');
+            values.push(progress.status);
+        }
+        if (progress.lastError !== undefined) {
+            fields.push('last_error = ?');
+            values.push(progress.lastError);
+        }
+        if (progress.lastProcessedFile !== undefined) {
+            fields.push('last_processed_file = ?');
+            values.push(progress.lastProcessedFile);
+        }
+        if (progress.startedAt !== undefined) {
+            fields.push('started_at = ?');
+            values.push(progress.startedAt);
+        }
+        if (progress.completedAt !== undefined) {
+            fields.push('completed_at = ?');
+            values.push(progress.completedAt);
+        }
+        fields.push('updated_at = ?');
+        values.push(Date.now());
+        const sql = `UPDATE index_progress SET ${fields.join(', ')} WHERE id = 1`;
+        this.db.prepare(sql).run(...values);
+    }
+    /**
+     * Get current indexing progress
+     */
+    getProgress() {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        const stmt = this.db.prepare('SELECT * FROM index_progress WHERE id = 1');
+        const row = stmt.get();
+        return {
+            totalFiles: row.total_files,
+            processedFiles: row.processed_files,
+            totalChunks: row.total_chunks,
+            status: row.status,
+            lastError: row.last_error,
+            lastProcessedFile: row.last_processed_file,
+            startedAt: row.started_at,
+            completedAt: row.completed_at,
+        };
+    }
+    /**
+     * Set watcher enabled status
+     */
+    setWatcherEnabled(enabled) {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        this.db
+            .prepare('UPDATE index_progress SET watcher_enabled = ? WHERE id = 1')
+            .run(enabled ? 1 : 0);
+    }
+    /**
+     * Get watcher enabled status
+     */
+    isWatcherEnabled() {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        const stmt = this.db.prepare('SELECT watcher_enabled FROM index_progress WHERE id = 1');
+        const result = stmt.get();
+        return result.watcher_enabled === 1;
+    }
+    /**
+     * Clear all chunks and reset progress
+     */
+    clear() {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        this.db.exec('DELETE FROM code_chunks');
+        this.db.exec(`
+			UPDATE index_progress 
+			SET total_files = 0, 
+				processed_files = 0, 
+				total_chunks = 0, 
+				status = 'idle',
+				last_error = NULL,
+				last_processed_file = NULL,
+				started_at = NULL,
+				completed_at = NULL,
+				updated_at = ${Date.now()}
+			WHERE id = 1
+		`);
+    }
+    /**
+     * Close database connection
+     */
+    close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+            this.initialized = false;
+        }
+    }
+    /**
+     * Convert database row to CodeChunk
+     */
+    rowToChunk(row) {
+        // Convert Buffer back to number array
+        const embeddingBuffer = row.embedding;
+        const embedding = Array.from(new Float32Array(embeddingBuffer.buffer, embeddingBuffer.byteOffset, embeddingBuffer.byteLength / 4));
+        return {
+            id: row.id,
+            filePath: row.file_path,
+            content: row.content,
+            startLine: row.start_line,
+            endLine: row.end_line,
+            embedding,
+            fileHash: row.file_hash,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
+    /**
+     * 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));
+    }
+}

package/dist/utils/commands/home.js

@@ -5,7 +5,20 @@ import { resetOpenAIClient as resetChatClient } from '../../api/chat.js';
 import { resetOpenAIClient as resetResponseClient } from '../../api/responses.js';
 // Home command handler - returns to welcome screen
 registerCommand('home', {
-    execute: () => {
+    execute: async () => {
+        // Stop codebase indexing if running (to avoid database errors)
+        if (global.__stopCodebaseIndexing) {
+            try {
+                // Show stopping message
+                console.log('\n⏸  Pausing codebase indexing...');
+                await global.__stopCodebaseIndexing();
+                console.log('✓ Indexing paused, progress saved\n');
+            }
+            catch (error) {
+                // Ignore errors during stop
+                console.error('Failed to stop codebase indexing:', error);
+            }
+        }
         // Clear all API configuration caches
         resetAnthropicClient();
         resetGeminiClient();

package/dist/utils/mcpToolsManager.js

@@ -8,6 +8,7 @@ import { mcpTools as terminalTools } from '../mcp/bash.js';
 import { mcpTools as aceCodeSearchTools } from '../mcp/aceCodeSearch.js';
 import { mcpTools as websearchTools } from '../mcp/websearch.js';
 import { mcpTools as ideDiagnosticsTools } from '../mcp/ideDiagnostics.js';
+import { mcpTools as codebaseSearchTools } from '../mcp/codebaseSearch.js';
 import { TodoService } from '../mcp/todo.js';
 import { mcpTools as notebookTools, executeNotebookTool, } from '../mcp/notebook.js';
 import { getMCPTools as getSubAgentTools, subAgentService, } from '../mcp/subagent.js';
@@ -32,13 +33,17 @@ export function getTodoService() {
 /**
  * Generate a hash of the current MCP configuration and sub-agents
  */
-function generateConfigHash() {
+async function generateConfigHash() {
     try {
         const mcpConfig = getMCPConfig();
         const subAgents = getSubAgentTools(); // Include sub-agents in hash
+        // 🔥 CRITICAL: Include codebase enabled status in hash
+        const { loadCodebaseConfig } = await import('./codebaseConfig.js');
+        const codebaseConfig = loadCodebaseConfig();
         return JSON.stringify({
             mcpServers: mcpConfig.mcpServers,
             subAgents: subAgents.map(t => t.name), // Only track agent names for hash
+            codebaseEnabled: codebaseConfig.enabled, // 🔥 Must include to invalidate cache on enable/disable
         });
     }
     catch {
@@ -48,19 +53,20 @@ function generateConfigHash() {
 /**
  * Check if the cache is valid and not expired
  */
-function isCacheValid() {
+async function isCacheValid() {
     if (!toolsCache)
         return false;
     const now = Date.now();
     const isExpired = now - toolsCache.lastUpdate > CACHE_DURATION;
-    const configChanged = toolsCache.configHash !== generateConfigHash();
+    const configHash = await generateConfigHash();
+    const configChanged = toolsCache.configHash !== configHash;
     return !isExpired && !configChanged;
 }
 /**
  * Get cached tools or build cache if needed
  */
 async function getCachedTools() {
-    if (isCacheValid()) {
+    if (await isCacheValid()) {
         return toolsCache.tools;
     }
     await refreshToolsCache();
@@ -248,6 +254,54 @@ async function refreshToolsCache() {
             });
         }
     }
+    // Add built-in Codebase Search tools (conditionally loaded if enabled and index is available)
+    try {
+        // First check if codebase feature is enabled in config
+        const { loadCodebaseConfig } = await import('./codebaseConfig.js');
+        const codebaseConfig = loadCodebaseConfig();
+        // Only proceed if feature is enabled
+        if (codebaseConfig.enabled) {
+            const projectRoot = process.cwd();
+            const dbPath = path.join(projectRoot, '.snow', 'codebase', 'embeddings.db');
+            const fs = await import('node:fs');
+            // Only add if database file exists
+            if (fs.existsSync(dbPath)) {
+                // Check if database has data by importing CodebaseDatabase
+                const { CodebaseDatabase } = await import('./codebaseDatabase.js');
+                const db = new CodebaseDatabase(projectRoot);
+                db.initialize();
+                const totalChunks = db.getTotalChunks();
+                db.close();
+                if (totalChunks > 0) {
+                    const codebaseSearchServiceTools = codebaseSearchTools.map(tool => ({
+                        name: tool.name.replace('codebase-', ''),
+                        description: tool.description,
+                        inputSchema: tool.inputSchema,
+                    }));
+                    servicesInfo.push({
+                        serviceName: 'codebase',
+                        tools: codebaseSearchServiceTools,
+                        isBuiltIn: true,
+                        connected: true,
+                    });
+                    for (const tool of codebaseSearchTools) {
+                        allTools.push({
+                            type: 'function',
+                            function: {
+                                name: tool.name,
+                                description: tool.description,
+                                parameters: tool.inputSchema,
+                            },
+                        });
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        // Silently ignore if codebase search tools are not available
+        logger.debug('Codebase search tools not available:', error);
+    }
     // Add user-configured MCP server tools (probe for availability but don't maintain connections)
     try {
         const mcpConfig = getMCPConfig();
@@ -290,7 +344,7 @@ async function refreshToolsCache() {
         tools: allTools,
         servicesInfo,
         lastUpdate: Date.now(),
-        configHash: generateConfigHash(),
+        configHash: await generateConfigHash(),
     };
 }
 /**
@@ -316,6 +370,7 @@ export async function reconnectMCPService(serviceName) {
         serviceName === 'todo' ||
         serviceName === 'ace' ||
         serviceName === 'websearch' ||
+        serviceName === 'codebase' ||
         serviceName === 'subagent') {
         return;
     }
@@ -390,7 +445,8 @@ export async function getMCPServicesInfo() {
     if (!isCacheValid()) {
         await refreshToolsCache();
     }
-    return toolsCache.servicesInfo;
+    // Ensure toolsCache is not null before accessing
+    return toolsCache?.servicesInfo || [];
 }
 /**
  * Quick probe of MCP service tools without maintaining connections
@@ -603,6 +659,10 @@ export async function executeMCPTool(toolName, args, abortSignal, onTokenUpdate)
         serviceName = 'ide';
         actualToolName = toolName.substring('ide-'.length);
     }
+    else if (toolName.startsWith('codebase-')) {
+        serviceName = 'codebase';
+        actualToolName = toolName.substring('codebase-'.length);
+    }
     else if (toolName.startsWith('subagent-')) {
         serviceName = 'subagent';
         actualToolName = toolName.substring('subagent-'.length);
@@ -690,11 +750,6 @@ export async function executeMCPTool(toolName, args, abortSignal, onTokenUpdate)
                 return await aceCodeSearchService.getFileOutline(args.filePath);
             case 'text_search':
                 return await aceCodeSearchService.textSearch(args.pattern, args.fileGlob, args.isRegex, args.maxResults);
-            case 'index_stats':
-                return aceCodeSearchService.getIndexStats();
-            case 'clear_cache':
-                aceCodeSearchService.clearCache();
-                return { message: 'ACE Code Search cache cleared successfully' };
             default:
                 throw new Error(`Unknown ACE tool: ${actualToolName}`);
         }
@@ -734,6 +789,16 @@ export async function executeMCPTool(toolName, args, abortSignal, onTokenUpdate)
                 throw new Error(`Unknown IDE tool: ${actualToolName}`);
         }
     }
+    else if (serviceName === 'codebase') {
+        // Handle built-in Codebase Search tools (no connection needed)
+        const { codebaseSearchService } = await import('../mcp/codebaseSearch.js');
+        switch (actualToolName) {
+            case 'search':
+                return await codebaseSearchService.search(args.query, args.topN);
+            default:
+                throw new Error(`Unknown codebase tool: ${actualToolName}`);
+        }
+    }
     else if (serviceName === 'subagent') {
         // Handle sub-agent tools
         // actualToolName is the agent ID

package/dist/utils/toolDisplayConfig.js

@@ -13,6 +13,8 @@ const TWO_STEP_TOOLS = new Set([
     'filesystem-create',
     // 终端执行工具 - 执行时间不确定，需要显示进度
     'terminal-execute',
+    // 代码库搜索工具 - 需要生成 embedding 和搜索，耗时较长
+    'codebase-search',
     // 子代理工具 - 执行复杂任务，需要显示进度
     // 所有以 'subagent-' 开头的工具都需要两步显示
 ]);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.3.31",
+	"version": "0.3.33",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {
@@ -41,12 +41,15 @@
 	"dependencies": {
 		"@inkjs/ui": "^2.0.0",
 		"@modelcontextprotocol/sdk": "^1.17.3",
+		"@types/better-sqlite3": "^7.6.13",
+		"better-sqlite3": "^12.4.1",
 		"cli-highlight": "^2.1.11",
 		"cli-markdown": "^3.5.1",
 		"diff": "^8.0.2",
 		"fzf": "^0.5.2",
 		"http-proxy-agent": "^7.0.2",
 		"https-proxy-agent": "^7.0.6",
+		"ignore": "^7.0.5",
 		"ink": "^5.2.1",
 		"ink-gradient": "^3.0.0",
 		"ink-select-input": "^6.2.0",