@sharc-code/mcp 0.2.0

package/dist/backend-handlers.js

@@ -0,0 +1,1453 @@
+/**
+ * Backend-aware Tool Handlers
+ * These handlers use the SHARC backend for embedding, search, and sync operations.
+ * File scanning and chunking still happen locally.
+ * Snapshot/status data is persisted in the backend database.
+ */
+import * as fs from "fs/promises";
+import * as fsSync from "fs";
+import * as path from "path";
+import * as crypto from "crypto";
+import { ensureAbsolutePath, truncateContent, trackCodebasePath } from "./utils.js";
+// Debug logging to file (since MCP stdout may not be visible in Claude Code)
+const DEBUG_LOG_FILE = path.join(process.env.TEMP || process.env.TMP || '/tmp', 'sharc-mcp-debug.log');
+function debugLog(message) {
+    const timestamp = new Date().toISOString();
+    const line = `[${timestamp}] ${message}\n`;
+    try {
+        fsSync.appendFileSync(DEBUG_LOG_FILE, line);
+    }
+    catch {
+        // Ignore file write errors
+    }
+    console.log(message);
+}
+import { BackendClient, } from "./backend-client.js";
+// Import splitters from @sharc-code/splitter package
+import { AstCodeSplitter, LangChainCodeSplitter } from "@sharc-code/splitter";
+// Import file watcher components
+import { FileWatcherService, IncrementalIndexer, SyntaxGuard } from "./watcher/index.js";
+const CHUNK_TIERS = [
+    {
+        // Tier 1: Code (AST-supported) - semantic units, no overlap needed
+        name: 'code',
+        extensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.pyw', '.java', '.go', '.rs', '.cs', '.cpp', '.hpp', '.cc', '.cxx', '.c', '.h', '.scala'],
+        maxSize: 3500,
+        overlap: 0,
+        useAst: true,
+    },
+    {
+        // Tier 2: Documentation - smaller chunks, overlap helps with prose flow
+        name: 'docs',
+        extensions: ['.md', '.mdx', '.rst', '.txt'],
+        maxSize: 1500,
+        overlap: 150,
+        useAst: false,
+    },
+    {
+        // Tier 3: Config/Data - structured data, moderate overlap
+        name: 'config',
+        extensions: ['.json', '.yaml', '.yml', '.toml', '.xml', '.env.example', '.ini', '.cfg'],
+        maxSize: 1500,
+        overlap: 100,
+        useAst: false,
+    },
+    {
+        // Tier 4: Other code (LangChain fallback) - languages not supported by AST
+        name: 'other',
+        extensions: ['.rb', '.php', '.swift', '.kt', '.kts', '.vue', '.svelte', '.html', '.css', '.scss', '.less', '.sql'],
+        maxSize: 1500,
+        overlap: 100,
+        useAst: false,
+    },
+];
+// Build a lookup map for fast tier resolution
+const EXTENSION_TO_TIER = new Map();
+for (const tier of CHUNK_TIERS) {
+    for (const ext of tier.extensions) {
+        EXTENSION_TO_TIER.set(ext, tier);
+    }
+}
+// Default tier for unknown extensions
+const DEFAULT_TIER = {
+    name: 'unknown',
+    extensions: [],
+    maxSize: 1500,
+    overlap: 100,
+    useAst: false,
+};
+function getTierForExtension(ext) {
+    return EXTENSION_TO_TIER.get(ext.toLowerCase()) || DEFAULT_TIER;
+}
+// Collect all supported extensions from all tiers
+const DEFAULT_FILE_EXTENSIONS = CHUNK_TIERS.flatMap(tier => tier.extensions);
+// Export for use by startup-sync and project-detector
+export { CHUNK_TIERS, DEFAULT_FILE_EXTENSIONS, getTierForExtension };
+// Cache TTL for snapshot data (5 seconds to allow quick status updates during indexing)
+const SNAPSHOT_CACHE_TTL = 5000;
+export class BackendToolHandlers {
+    constructor(config) {
+        // Local cache for snapshot data to reduce API calls
+        this.cachedSnapshot = null;
+        this.cacheTimestamp = 0;
+        // File watcher for incremental indexing
+        this.fileWatcherService = null;
+        this.incrementalIndexers = new Map();
+        // Splitter cache for reuse across chunking operations
+        this.splitterCache = new Map();
+        if (!config.sharcBackendUrl || !config.sharcApiKey) {
+            throw new Error('SHARC_BACKEND_URL and SHARC_API_KEY are required for backend mode');
+        }
+        this.backendClient = new BackendClient(config.sharcBackendUrl, config.sharcApiKey);
+        this.currentWorkspace = process.cwd();
+        this.config = config;
+        this.syntaxGuard = new SyntaxGuard();
+        console.log(`[BackendHandlers] Initialized with backend URL: ${config.sharcBackendUrl}`);
+    }
+    // ==================== Snapshot Cache Methods ====================
+    /**
+     * Load snapshot from backend with caching
+     */
+    async getSnapshot(forceRefresh = false) {
+        const now = Date.now();
+        if (!forceRefresh && this.cachedSnapshot && (now - this.cacheTimestamp) < SNAPSHOT_CACHE_TTL) {
+            return this.cachedSnapshot;
+        }
+        try {
+            this.cachedSnapshot = await this.backendClient.loadSnapshot();
+            this.cacheTimestamp = now;
+            return this.cachedSnapshot;
+        }
+        catch (error) {
+            console.error('[BackendHandlers] Failed to load snapshot from backend:', error);
+            // Return empty snapshot on error
+            return {
+                formatVersion: 'v2',
+                codebases: {},
+                lastUpdated: new Date().toISOString(),
+            };
+        }
+    }
+    /**
+     * Invalidate local cache to force refresh on next access
+     */
+    invalidateCache() {
+        this.cacheTimestamp = 0;
+    }
+    /**
+     * Get list of indexed codebases
+     */
+    async getIndexedCodebases() {
+        const snapshot = await this.getSnapshot();
+        return Object.entries(snapshot.codebases)
+            .filter(([_, info]) => info.status === 'indexed')
+            .map(([path]) => path);
+    }
+    /**
+     * Get list of codebases currently being indexed
+     */
+    async getIndexingCodebases() {
+        const snapshot = await this.getSnapshot();
+        return Object.entries(snapshot.codebases)
+            .filter(([_, info]) => info.status === 'indexing')
+            .map(([path]) => path);
+    }
+    /**
+     * Get codebase status
+     */
+    async getCodebaseStatus(codebasePath) {
+        const snapshot = await this.getSnapshot();
+        const info = snapshot.codebases[codebasePath];
+        if (!info)
+            return 'not_found';
+        return info.status;
+    }
+    /**
+     * Get complete codebase info
+     */
+    async getCodebaseInfo(codebasePath) {
+        const snapshot = await this.getSnapshot();
+        return snapshot.codebases[codebasePath] || null;
+    }
+    /**
+     * Get indexing progress for a codebase
+     */
+    async getIndexingProgress(codebasePath) {
+        const snapshot = await this.getSnapshot();
+        const info = snapshot.codebases[codebasePath];
+        if (info && info.status === 'indexing') {
+            return info.indexingPercentage;
+        }
+        return undefined;
+    }
+    /**
+     * Set codebase to indexing status
+     */
+    async setCodebaseIndexing(codebasePath, progress) {
+        const info = {
+            status: 'indexing',
+            indexingPercentage: progress,
+            lastUpdated: new Date().toISOString(),
+        };
+        await this.backendClient.updateCodebaseInfo(codebasePath, info);
+        this.invalidateCache();
+    }
+    /**
+     * Set codebase to indexed status
+     */
+    async setCodebaseIndexed(codebasePath, stats) {
+        const info = {
+            status: 'indexed',
+            indexedFiles: stats.indexedFiles,
+            totalChunks: stats.totalChunks,
+            indexStatus: stats.status,
+            lastUpdated: new Date().toISOString(),
+        };
+        await this.backendClient.updateCodebaseInfo(codebasePath, info);
+        this.invalidateCache();
+    }
+    /**
+     * Set codebase to failed status
+     */
+    async setCodebaseIndexFailed(codebasePath, errorMessage, lastAttemptedPercentage) {
+        const info = {
+            status: 'indexfailed',
+            errorMessage,
+            lastAttemptedPercentage,
+            lastUpdated: new Date().toISOString(),
+        };
+        await this.backendClient.updateCodebaseInfo(codebasePath, info);
+        this.invalidateCache();
+    }
+    /**
+     * Remove codebase from snapshot completely
+     */
+    async removeCodebaseFromSnapshot(codebasePath) {
+        await this.backendClient.removeCodebaseFromSnapshot(codebasePath);
+        this.invalidateCache();
+    }
+    /**
+     * Generate a collection name from a codebase path
+     * Must match the backend's expectation (URL-safe, unique per path)
+     * Uses SHA-256 for better collision resistance
+     */
+    generateCollectionName(codebasePath) {
+        const hash = crypto.createHash('sha256').update(codebasePath).digest('hex').substring(0, 12);
+        const baseName = path.basename(codebasePath).replace(/[^a-zA-Z0-9]/g, '_').toLowerCase();
+        return `hybrid_code_chunks_${baseName}_${hash}`;
+    }
+    /**
+     * Sync indexed codebases from backend collections
+     * Compares snapshot data with actual vector collections and removes stale entries
+     */
+    async syncIndexedCodebasesFromBackend() {
+        try {
+            console.log(`[SYNC-BACKEND] 🔄 Syncing indexed codebases from backend...`);
+            const response = await this.backendClient.listRepos();
+            console.log(`[SYNC-BACKEND] 📋 Found ${response.count} collections in backend`);
+            // Get snapshot codebases and compare with backend collections
+            const snapshot = await this.getSnapshot(true); // Force refresh
+            const snapshotCodebases = Object.entries(snapshot.codebases)
+                .filter(([_, info]) => info.status === 'indexed')
+                .map(([path]) => path);
+            const backendCollections = new Set(response.repos.map(r => r.name));
+            // Remove snapshot entries whose collections don't exist in backend
+            for (const codebasePath of snapshotCodebases) {
+                const collectionName = this.generateCollectionName(codebasePath);
+                if (!backendCollections.has(collectionName)) {
+                    await this.removeCodebaseFromSnapshot(codebasePath);
+                    console.log(`[SYNC-BACKEND] ➖ Removed stale codebase (collection not in backend): ${codebasePath}`);
+                }
+            }
+            console.log(`[SYNC-BACKEND] ✅ Backend sync completed`);
+        }
+        catch (error) {
+            console.error(`[SYNC-BACKEND] ❌ Error syncing from backend:`, error.message || error);
+        }
+    }
+    // ==================== File Watcher Methods ====================
+    /**
+     * Initialize the file watcher service (lazy initialization)
+     */
+    initializeFileWatcher() {
+        if (!this.fileWatcherService) {
+            // Create the watcher with our change processor
+            this.fileWatcherService = new FileWatcherService((change) => this.processFileChange(change), {
+                debounceMs: parseInt(process.env.SHARC_WATCH_DEBOUNCE_MS || '2000', 10),
+                verbose: process.env.DEBUG === 'true' || process.env.LOG_LEVEL === 'verbose',
+            });
+            console.log('[Watcher] File watcher service initialized');
+        }
+        return this.fileWatcherService;
+    }
+    /**
+     * Process a single file change (used by FileWatcherService)
+     */
+    async processFileChange(change) {
+        // Find the incremental indexer for this file
+        for (const [codebasePath, indexer] of this.incrementalIndexers.entries()) {
+            // Check if this file belongs to this codebase
+            const absoluteCodebase = path.resolve(codebasePath);
+            const absoluteFile = path.resolve(change.absolutePath);
+            if (absoluteFile.startsWith(absoluteCodebase)) {
+                return indexer.processChange(change);
+            }
+        }
+        // No indexer found for this file
+        console.warn(`[Watcher] No indexer found for file: ${change.absolutePath}`);
+        return { success: false, chunksDeleted: 0, chunksIndexed: 0, error: 'No indexer found' };
+    }
+    /**
+     * Create an incremental indexer for a codebase
+     */
+    createIncrementalIndexer(codebasePath, collectionName) {
+        // Create splitter cache for chunking
+        const splitterCache = new Map();
+        const getSplitterForTier = (tier) => {
+            const cacheKey = `${tier.name}-${tier.maxSize}-${tier.overlap}`;
+            if (!splitterCache.has(cacheKey)) {
+                if (tier.useAst) {
+                    splitterCache.set(cacheKey, new AstCodeSplitter(tier.maxSize, tier.overlap));
+                }
+                else {
+                    splitterCache.set(cacheKey, new LangChainCodeSplitter(tier.maxSize, tier.overlap));
+                }
+            }
+            return splitterCache.get(cacheKey);
+        };
+        const indexer = new IncrementalIndexer({
+            codebasePath,
+            collectionName,
+            backendClient: this.backendClient,
+            getLanguageFromExtension: (ext) => this.getLanguageFromExtension(ext),
+            checkSyntax: (content, language) => {
+                return this.syntaxGuard.checkSyntax(content, language);
+            },
+            chunkFile: async (content, language, relativePath) => {
+                const ext = path.extname(relativePath).toLowerCase();
+                const tier = getTierForExtension(ext);
+                const splitter = getSplitterForTier(tier);
+                const chunks = await splitter.split(content, language, relativePath);
+                const indexChunks = [];
+                for (const chunk of chunks) {
+                    if (!chunk.content || chunk.content.trim().length === 0) {
+                        continue;
+                    }
+                    // Add file path context for non-code tiers
+                    let finalContent = chunk.content;
+                    if (!tier.useAst && tier.name !== 'code') {
+                        const pathParts = relativePath.replace(/\\/g, '/').split('/');
+                        const shortPath = pathParts.slice(-2).join('/');
+                        const commentPrefix = language === 'python' ? '#' : '//';
+                        finalContent = `${commentPrefix} File: ${shortPath}\n${chunk.content}`;
+                    }
+                    indexChunks.push({
+                        content: finalContent,
+                        relativePath,
+                        startLine: chunk.metadata.startLine,
+                        endLine: chunk.metadata.endLine,
+                        language,
+                        metadata: { codebasePath },
+                    });
+                }
+                return indexChunks;
+            },
+        });
+        return indexer;
+    }
+    /**
+     * Start watching a codebase for file changes
+     */
+    startWatching(codebasePath, collectionName) {
+        const normalizedPath = path.resolve(codebasePath);
+        // Initialize watcher service if needed
+        const watcher = this.initializeFileWatcher();
+        // Check if already watching
+        if (watcher.isWatching(normalizedPath)) {
+            console.log(`[Watcher] Already watching: ${normalizedPath}`);
+            return;
+        }
+        // Create incremental indexer for this codebase
+        const indexer = this.createIncrementalIndexer(normalizedPath, collectionName);
+        this.incrementalIndexers.set(normalizedPath, indexer);
+        // Start watching
+        watcher.watchCodebase(normalizedPath, collectionName);
+    }
+    /**
+     * Stop watching a codebase
+     */
+    async stopWatching(codebasePath) {
+        const normalizedPath = path.resolve(codebasePath);
+        if (this.fileWatcherService) {
+            await this.fileWatcherService.unwatchCodebase(normalizedPath);
+        }
+        // Clean up indexer
+        this.incrementalIndexers.delete(normalizedPath);
+    }
+    /**
+     * Get list of watched codebases
+     */
+    getWatchedCodebases() {
+        if (!this.fileWatcherService) {
+            return [];
+        }
+        return this.fileWatcherService.getWatchedCodebases();
+    }
+    /**
+     * Check if a codebase is being watched
+     */
+    isWatching(codebasePath) {
+        if (!this.fileWatcherService) {
+            return false;
+        }
+        return this.fileWatcherService.isWatching(codebasePath);
+    }
+    /**
+     * Graceful shutdown of all watchers and cleanup resources
+     */
+    async shutdown() {
+        if (this.fileWatcherService) {
+            await this.fileWatcherService.shutdown();
+            this.fileWatcherService = null;
+        }
+        this.incrementalIndexers.clear();
+        // Clear splitter cache to release any native resources (tree-sitter parsers)
+        this.splitterCache.clear();
+        console.log('[BackendHandlers] Shutdown complete');
+    }
+    // ==================== Splitter Helper ====================
+    /**
+     * Get a splitter for a given tier (cached for reuse)
+     */
+    getSplitterForTier(tier) {
+        const cacheKey = `${tier.name}-${tier.maxSize}-${tier.overlap}`;
+        if (!this.splitterCache.has(cacheKey)) {
+            if (tier.useAst) {
+                this.splitterCache.set(cacheKey, new AstCodeSplitter(tier.maxSize, tier.overlap));
+            }
+            else {
+                this.splitterCache.set(cacheKey, new LangChainCodeSplitter(tier.maxSize, tier.overlap));
+            }
+        }
+        return this.splitterCache.get(cacheKey);
+    }
+    /**
+     * Check if a path exists (async replacement for fs.existsSync)
+     */
+    async pathExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Scan and chunk files from a codebase directory
+     * Uses async file I/O to avoid blocking the event loop
+     */
+    async scanAndChunkFiles(codebasePath, customExtensions = [], ignorePatterns = [], onProgress) {
+        const allChunks = [];
+        // Get all supported extensions
+        const extensions = new Set([...DEFAULT_FILE_EXTENSIONS, ...customExtensions]);
+        console.log(`[CHUNK] Scanning with extensions: ${[...extensions].join(', ')}`);
+        // Find all files recursively using async operations
+        const files = [];
+        const scanDir = async (dir) => {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                const relativePath = path.relative(codebasePath, fullPath);
+                // Skip ignored patterns
+                if (this.shouldIgnore(relativePath, ignorePatterns)) {
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    // Skip hidden directories and common ignore dirs
+                    if (!entry.name.startsWith('.') &&
+                        !['node_modules', 'dist', 'build', '__pycache__', 'venv', '.git'].includes(entry.name)) {
+                        await scanDir(fullPath);
+                    }
+                }
+                else if (entry.isFile()) {
+                    const ext = path.extname(entry.name).toLowerCase();
+                    if (extensions.has(ext)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+        };
+        await scanDir(codebasePath);
+        console.log(`[CHUNK] Found ${files.length} files to process`);
+        // Create splitters for each tier (cached for reuse)
+        const splitterCache = new Map();
+        const getSplitterForTier = (tier) => {
+            const cacheKey = `${tier.name}-${tier.maxSize}-${tier.overlap}`;
+            if (!splitterCache.has(cacheKey)) {
+                if (tier.useAst) {
+                    splitterCache.set(cacheKey, new AstCodeSplitter(tier.maxSize, tier.overlap));
+                }
+                else {
+                    splitterCache.set(cacheKey, new LangChainCodeSplitter(tier.maxSize, tier.overlap));
+                }
+            }
+            return splitterCache.get(cacheKey);
+        };
+        // Track tier statistics
+        const tierStats = {};
+        for (let i = 0; i < files.length; i++) {
+            const filePath = files[i];
+            const relativePath = path.relative(codebasePath, filePath);
+            try {
+                // Check file size before reading
+                const stat = await fs.stat(filePath);
+                if (stat.size > BackendToolHandlers.MAX_FILE_SIZE) {
+                    console.warn(`[CHUNK] Skipping large file (${(stat.size / 1024 / 1024).toFixed(1)}MB): ${relativePath}`);
+                    continue;
+                }
+                const content = await fs.readFile(filePath, 'utf-8');
+                const ext = path.extname(filePath).toLowerCase();
+                const language = this.getLanguageFromExtension(ext);
+                // Get tier-specific settings for this file type
+                const tier = getTierForExtension(ext);
+                const splitter = getSplitterForTier(tier);
+                // Split the file into chunks
+                const chunks = await splitter.split(content, language, relativePath);
+                // Track tier stats
+                if (!tierStats[tier.name]) {
+                    tierStats[tier.name] = { files: 0, chunks: 0 };
+                }
+                tierStats[tier.name].files++;
+                for (const chunk of chunks) {
+                    // Skip empty or whitespace-only chunks
+                    if (!chunk.content || chunk.content.trim().length === 0) {
+                        console.warn(`[CHUNK] Skipping empty chunk from ${relativePath}:${chunk.metadata.startLine}`);
+                        continue;
+                    }
+                    // Add file path context for non-code tiers (docs, config, other)
+                    let finalContent = chunk.content;
+                    if (!tier.useAst && tier.name !== 'code') {
+                        // Shorten path to last 2 segments
+                        const pathParts = relativePath.replace(/\\/g, '/').split('/');
+                        const shortPath = pathParts.slice(-2).join('/');
+                        const commentPrefix = language === 'python' ? '#' : '//';
+                        finalContent = `${commentPrefix} File: ${shortPath}\n${chunk.content}`;
+                    }
+                    allChunks.push({
+                        content: finalContent,
+                        relativePath,
+                        startLine: chunk.metadata.startLine,
+                        endLine: chunk.metadata.endLine,
+                        language,
+                        metadata: {
+                            codebasePath,
+                        },
+                    });
+                    tierStats[tier.name].chunks++;
+                }
+                // Report progress
+                if (onProgress) {
+                    const percentage = ((i + 1) / files.length) * 100;
+                    onProgress({
+                        phase: 'chunking',
+                        percentage,
+                        current: i + 1,
+                        total: files.length,
+                    });
+                }
+            }
+            catch (error) {
+                console.warn(`[CHUNK] Error processing ${relativePath}: ${error.message}`);
+            }
+        }
+        // Log tier statistics
+        console.log(`[CHUNK] Generated ${allChunks.length} chunks from ${files.length} files`);
+        for (const [tierName, stats] of Object.entries(tierStats)) {
+            console.log(`[CHUNK]   ${tierName}: ${stats.files} files → ${stats.chunks} chunks`);
+        }
+        return allChunks;
+    }
+    shouldIgnore(relativePath, ignorePatterns) {
+        const defaultIgnore = [
+            'node_modules', '.git', 'dist', 'build', '__pycache__',
+            'venv', '.env', '.vscode', '.idea', 'coverage',
+        ];
+        const allPatterns = [...defaultIgnore, ...ignorePatterns];
+        for (const pattern of allPatterns) {
+            if (relativePath.includes(pattern)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Generate SHA-256 hashes for all supported files in the codebase
+     */
+    async generateFileHashes(rootDir, ignorePatterns = []) {
+        const hashes = new Map();
+        const supportedExtensions = new Set(DEFAULT_FILE_EXTENSIONS);
+        const scanDir = async (dir) => {
+            let entries;
+            try {
+                entries = await fs.readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                return; // Can't read directory, skip
+            }
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                const relativePath = path.relative(rootDir, fullPath);
+                // Skip hidden files/dirs and ignored patterns
+                if (entry.name.startsWith('.') || this.shouldIgnore(relativePath, ignorePatterns)) {
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    await scanDir(fullPath);
+                }
+                else if (entry.isFile()) {
+                    const ext = path.extname(entry.name).toLowerCase();
+                    if (supportedExtensions.has(ext)) {
+                        try {
+                            const stat = await fs.stat(fullPath);
+                            if (stat.size > BackendToolHandlers.MAX_FILE_SIZE) {
+                                continue; // Skip large files
+                            }
+                            const content = await fs.readFile(fullPath, 'utf-8');
+                            const hash = crypto.createHash('sha256').update(content).digest('hex');
+                            hashes.set(relativePath, hash);
+                        }
+                        catch {
+                            // Can't read file, skip
+                        }
+                    }
+                }
+            }
+        };
+        await scanDir(rootDir);
+        return hashes;
+    }
+    /**
+     * Compare old and new file hashes to detect changes
+     */
+    compareFileHashes(oldHashes, newHashes) {
+        const result = { added: [], modified: [], removed: [] };
+        // If no old hashes, all files are "added" (first index)
+        if (!oldHashes || oldHashes.length === 0) {
+            result.added = Array.from(newHashes.keys());
+            return result;
+        }
+        const oldMap = new Map(oldHashes);
+        // Find added and modified files
+        for (const [filePath, hash] of newHashes) {
+            if (!oldMap.has(filePath)) {
+                result.added.push(filePath);
+            }
+            else if (oldMap.get(filePath) !== hash) {
+                result.modified.push(filePath);
+            }
+            oldMap.delete(filePath);
+        }
+        // Remaining in oldMap are removed files
+        result.removed = Array.from(oldMap.keys());
+        return result;
+    }
+    /**
+     * Apply incremental changes to the index (Merkle diff)
+     * Only indexes added/modified files, deletes removed file vectors
+     */
+    async applyIncrementalChanges(codebasePath, collectionName, changes, 
+    // TODO: Implement ignore pattern filtering for incremental indexing
+    // Currently ignorePatterns is accepted but not applied during incremental updates
+    _ignorePatterns = []) {
+        let chunksIndexed = 0;
+        let chunksDeleted = 0;
+        // Delete vectors for removed files (batch delete)
+        if (changes.removed.length > 0) {
+            try {
+                await this.backendClient.deleteFileVectorsBatch(collectionName, changes.removed);
+                chunksDeleted = changes.removed.length;
+                debugLog(`[MerkleDiff] Deleted vectors for ${changes.removed.length} removed files`);
+            }
+            catch (e) {
+                debugLog(`[MerkleDiff] Could not delete vectors: ${e}`);
+            }
+        }
+        // Process added and modified files
+        const filesToIndex = [...changes.added, ...changes.modified];
+        if (filesToIndex.length === 0) {
+            return { chunksIndexed, chunksDeleted, filesProcessed: 0 };
+        }
+        debugLog(`[MerkleDiff] Processing ${filesToIndex.length} files (${changes.added.length} added, ${changes.modified.length} modified)`);
+        const allChunks = [];
+        const deleteFirst = changes.modified; // Delete old chunks for modified files
+        for (const relativePath of filesToIndex) {
+            const absolutePath = path.join(codebasePath, relativePath);
+            // Path traversal protection - ensure resolved path is within codebase
+            const resolvedPath = path.resolve(absolutePath);
+            const resolvedCodebase = path.resolve(codebasePath);
+            if (!resolvedPath.startsWith(resolvedCodebase + path.sep) && resolvedPath !== resolvedCodebase) {
+                console.warn(`[SECURITY] Path traversal blocked: ${relativePath}`);
+                continue;
+            }
+            try {
+                // Check file size before reading
+                const stat = await fs.stat(absolutePath);
+                if (stat.size > BackendToolHandlers.MAX_FILE_SIZE) {
+                    console.warn(`[CHUNK] Skipping large file (${(stat.size / 1024 / 1024).toFixed(1)}MB): ${relativePath}`);
+                    continue;
+                }
+                const content = await fs.readFile(absolutePath, 'utf-8');
+                const ext = path.extname(relativePath).toLowerCase();
+                const language = this.getLanguageFromExtension(ext);
+                // Chunk the file using tiered strategy
+                const tier = getTierForExtension(ext);
+                const chunks = await this.chunkFileWithTier(content, language, relativePath, codebasePath, tier);
+                allChunks.push(...chunks);
+            }
+            catch {
+                // File might have been deleted, skip
+            }
+        }
+        // Index all chunks in one batch
+        if (allChunks.length > 0) {
+            try {
+                debugLog(`[MerkleDiff] Indexing ${allChunks.length} chunks...`);
+                const response = await this.backendClient.indexChunks({
+                    collection: collectionName,
+                    chunks: allChunks,
+                    createIfNotExists: true,
+                    finalize: false, // Don't rebuild HNSW for incremental updates
+                    deleteFirst,
+                });
+                chunksIndexed = response.indexed;
+                chunksDeleted += response.deleted || 0;
+                debugLog(`[MerkleDiff] Indexed ${chunksIndexed} chunks, deleted ${response.deleted || 0} for modified files`);
+            }
+            catch (error) {
+                debugLog(`[MerkleDiff] Error indexing chunks: ${error.message || error}`);
+                throw error;
+            }
+        }
+        return { chunksIndexed, chunksDeleted, filesProcessed: filesToIndex.length };
+    }
+    /**
+     * Chunk a single file using the tier strategy (helper for incremental indexing)
+     */
+    async chunkFileWithTier(content, language, relativePath, codebasePath, tier) {
+        let splitter = this.splitterCache.get(tier.name);
+        if (!splitter) {
+            if (tier.useAst) {
+                splitter = new AstCodeSplitter(tier.maxSize);
+            }
+            else {
+                splitter = new LangChainCodeSplitter(tier.maxSize, tier.overlap);
+            }
+            this.splitterCache.set(tier.name, splitter);
+        }
+        const rawChunks = await splitter.split(content, language, relativePath);
+        return rawChunks.map(chunk => ({
+            content: chunk.content,
+            relativePath,
+            startLine: chunk.metadata.startLine,
+            endLine: chunk.metadata.endLine,
+            language,
+        }));
+    }
+    getLanguageFromExtension(ext) {
+        const langMap = {
+            // Tier 1: Code (AST-supported)
+            '.ts': 'typescript', '.tsx': 'typescript',
+            '.js': 'javascript', '.jsx': 'javascript', '.mjs': 'javascript', '.cjs': 'javascript',
+            '.py': 'python', '.pyw': 'python',
+            '.rs': 'rust',
+            '.go': 'go',
+            '.java': 'java',
+            '.c': 'c', '.h': 'c',
+            '.cpp': 'cpp', '.hpp': 'cpp', '.cc': 'cpp', '.cxx': 'cpp',
+            '.cs': 'csharp',
+            '.scala': 'scala',
+            // Tier 2: Documentation
+            '.md': 'markdown', '.mdx': 'markdown',
+            '.rst': 'rst', '.txt': 'text',
+            // Tier 3: Config/Data
+            '.json': 'json',
+            '.yaml': 'yaml', '.yml': 'yaml',
+            '.toml': 'toml',
+            '.xml': 'xml',
+            '.ini': 'ini', '.cfg': 'ini',
+            // Tier 4: Other code
+            '.rb': 'ruby',
+            '.php': 'php',
+            '.swift': 'swift',
+            '.kt': 'kotlin', '.kts': 'kotlin',
+            '.vue': 'vue',
+            '.svelte': 'svelte',
+            '.html': 'html',
+            '.css': 'css', '.scss': 'scss', '.less': 'less',
+            '.sql': 'sql',
+        };
+        return langMap[ext] || 'unknown';
+    }
+    async handleIndexCodebase(args) {
+        const { path: codebasePath, force, splitter: _splitter, customExtensions, ignorePatterns } = args;
+        const forceReindex = force || false;
+        const customFileExtensions = customExtensions || [];
+        const customIgnorePatterns = ignorePatterns || [];
+        try {
+            // Sync with backend first
+            await this.syncIndexedCodebasesFromBackend();
+            // Force absolute path resolution
+            const absolutePath = ensureAbsolutePath(codebasePath);
+            // Validate path exists
+            if (!(await this.pathExists(absolutePath))) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Path '${absolutePath}' does not exist. Original input: '${codebasePath}'`
+                        }],
+                    isError: true
+                };
+            }
+            // Check if it's a directory
+            const stat = await fs.stat(absolutePath);
+            if (!stat.isDirectory()) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Path '${absolutePath}' is not a directory`
+                        }],
+                    isError: true
+                };
+            }
+            // Check if already indexing
+            const indexingCodebases = await this.getIndexingCodebases();
+            if (indexingCodebases.includes(absolutePath)) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Codebase '${absolutePath}' is already being indexed in the background. Please wait for completion.`
+                        }],
+                    isError: true
+                };
+            }
+            const collectionName = this.generateCollectionName(absolutePath);
+            const indexedCodebases = await this.getIndexedCodebases();
+            const isAlreadyIndexed = indexedCodebases.includes(absolutePath);
+            // If force reindex, delete existing collection and do full re-index
+            if (forceReindex && isAlreadyIndexed) {
+                try {
+                    const hasCollection = await this.backendClient.hasCollection(collectionName);
+                    if (hasCollection) {
+                        console.log(`[FORCE-REINDEX] 🔄 Deleting existing collection: ${collectionName}`);
+                        await this.backendClient.deleteRepo(collectionName);
+                    }
+                }
+                catch (error) {
+                    console.warn(`[FORCE-REINDEX] Could not delete collection: ${error}`);
+                }
+                await this.removeCodebaseFromSnapshot(absolutePath);
+                // Continue to full index below
+            }
+            // If already indexed (and not forcing), do Merkle diff for incremental sync
+            if (!forceReindex && isAlreadyIndexed) {
+                debugLog(`[Index] Codebase already indexed, checking for changes via Merkle diff...`);
+                const startTime = Date.now();
+                try {
+                    // Load existing Merkle snapshot
+                    const merkleSnapshot = await this.backendClient.loadMerkleSnapshot(absolutePath);
+                    debugLog(`[Index] Merkle snapshot loaded: ${merkleSnapshot ? `${merkleSnapshot.fileHashes?.length || 0} file hashes` : 'null'}`);
+                    // Generate current file hashes
+                    debugLog(`[Index] Scanning files for changes...`);
+                    const currentHashes = await this.generateFileHashes(absolutePath, customIgnorePatterns);
+                    debugLog(`[Index] Found ${currentHashes.size} files`);
+                    // Compare to detect changes
+                    const changes = this.compareFileHashes(merkleSnapshot?.fileHashes || null, currentHashes);
+                    const totalChanges = changes.added.length + changes.modified.length + changes.removed.length;
+                    if (totalChanges === 0) {
+                        const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+                        debugLog(`[Index] No changes detected (${duration}s)`);
+                        // Ensure watcher is running
+                        this.startWatching(absolutePath, collectionName);
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `✅ Index is up to date for '${absolutePath}'.\n\nNo file changes detected since last index. Checked ${currentHashes.size} files in ${duration}s.`
+                                }]
+                        };
+                    }
+                    // Apply incremental changes
+                    debugLog(`[Index] Found ${totalChanges} changes: +${changes.added.length} added, ~${changes.modified.length} modified, -${changes.removed.length} removed`);
+                    const result = await this.applyIncrementalChanges(absolutePath, collectionName, changes, customIgnorePatterns);
+                    // Save updated Merkle snapshot
+                    await this.backendClient.saveMerkleSnapshot(absolutePath, {
+                        fileHashes: Array.from(currentHashes.entries()),
+                        merkleDAG: { nodes: [], rootIds: [] },
+                        fileCount: currentHashes.size,
+                    });
+                    // Start/resume file watcher
+                    this.startWatching(absolutePath, collectionName);
+                    const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+                    debugLog(`[Index] Incremental sync completed in ${duration}s`);
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `✅ Synced '${absolutePath}' in ${duration}s\n\n` +
+                                    `Changes: +${changes.added.length} added, ~${changes.modified.length} modified, -${changes.removed.length} removed\n` +
+                                    `Indexed ${result.chunksIndexed} chunks, deleted ${result.chunksDeleted} old chunks.`
+                            }]
+                    };
+                }
+                catch (error) {
+                    debugLog(`[Index] Merkle diff failed, falling back to full re-index: ${error.message}`);
+                    debugLog(`[Index] Error stack: ${error.stack}`);
+                    // Fall through to full index
+                }
+            }
+            // Full index (new codebase or force=true or Merkle diff failed)
+            console.log(`[Index] Starting full index for: ${absolutePath}`);
+            // Set to indexing status
+            await this.setCodebaseIndexing(absolutePath, 0);
+            // Track the codebase path
+            trackCodebasePath(absolutePath);
+            // Start background indexing (with error logging)
+            this.startBackgroundIndexing(absolutePath, collectionName, customFileExtensions, customIgnorePatterns)
+                .catch(err => debugLog(`[BACKGROUND-INDEX] Unhandled error: ${err.message || err}`));
+            const pathInfo = codebasePath !== absolutePath
+                ? `\nNote: Input path '${codebasePath}' was resolved to absolute path '${absolutePath}'`
+                : '';
+            return {
+                content: [{
+                        type: "text",
+                        text: `Started indexing '${absolutePath}' via SHARC backend.${pathInfo}\n\nIndexing ${isAlreadyIndexed ? '(full re-index)' : '(first time)'} is running in the background. You can search while indexing is in progress, but results may be incomplete until done.`
+                    }]
+            };
+        }
+        catch (error) {
+            console.error('Error in handleIndexCodebase:', error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error starting indexing: ${error.message || error}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    async startBackgroundIndexing(codebasePath, collectionName, customExtensions, ignorePatterns) {
+        try {
+            console.log(`[BACKGROUND-INDEX] Starting background indexing for: ${codebasePath}`);
+            console.log(`[BACKGROUND-INDEX] Collection name: ${collectionName}`);
+            // Scan and chunk files
+            let lastUpdateTime = Date.now();
+            const chunks = await this.scanAndChunkFiles(codebasePath, customExtensions, ignorePatterns, async (progress) => {
+                const chunkProgress = progress.percentage * 0.5; // 0-50% for chunking
+                // Update progress periodically (every 2 seconds)
+                const now = Date.now();
+                if (now - lastUpdateTime >= 2000) {
+                    await this.setCodebaseIndexing(codebasePath, chunkProgress);
+                    lastUpdateTime = now;
+                }
+                console.log(`[BACKGROUND-INDEX] Chunking progress: ${progress.percentage.toFixed(1)}% (${progress.current}/${progress.total})`);
+            });
+            if (chunks.length === 0) {
+                console.warn(`[BACKGROUND-INDEX] No chunks generated for ${codebasePath}`);
+                await this.setCodebaseIndexFailed(codebasePath, 'No indexable files found', 0);
+                return;
+            }
+            // Send ALL chunks in one request if possible (faster, less overhead)
+            // Only batch if we exceed the 10,000 chunk limit per request
+            const MAX_CHUNKS_PER_REQUEST = 10000;
+            const BATCH_SIZE = Math.min(chunks.length, MAX_CHUNKS_PER_REQUEST);
+            let indexedCount = 0;
+            const totalChunks = chunks.length;
+            const totalBatches = Math.ceil(chunks.length / BATCH_SIZE);
+            if (totalBatches === 1) {
+                console.log(`[BACKGROUND-INDEX] Sending ALL ${totalChunks} chunks in single request`);
+            }
+            else {
+                console.log(`[BACKGROUND-INDEX] Sending ${totalChunks} chunks in ${totalBatches} batches of ${BATCH_SIZE}`);
+            }
+            for (let i = 0; i < chunks.length; i += BATCH_SIZE) {
+                const batch = chunks.slice(i, i + BATCH_SIZE);
+                const isLastBatch = (i + BATCH_SIZE >= chunks.length);
+                try {
+                    debugLog(`[BACKGROUND-INDEX] Calling indexChunks for batch (${batch.length} chunks, finalize=${isLastBatch})...`);
+                    await this.backendClient.indexChunks({
+                        collection: collectionName,
+                        chunks: batch,
+                        createIfNotExists: true,
+                        finalize: isLastBatch, // Only enable HNSW on final batch
+                    });
+                    debugLog(`[BACKGROUND-INDEX] indexChunks returned successfully`);
+                    indexedCount += batch.length;
+                    // Update progress (50-100% for embedding/indexing)
+                    const progress = 50 + (indexedCount / totalChunks) * 50;
+                    // Update status less frequently (every 5 seconds instead of 2)
+                    const now = Date.now();
+                    if (now - lastUpdateTime >= 5000 || isLastBatch) {
+                        await this.setCodebaseIndexing(codebasePath, progress);
+                        lastUpdateTime = now;
+                    }
+                    console.log(`[BACKGROUND-INDEX] Indexed ${indexedCount}/${totalChunks} chunks (${progress.toFixed(1)}%)${isLastBatch ? ' [FINAL]' : ''}`);
+                }
+                catch (error) {
+                    console.error(`[BACKGROUND-INDEX] Error indexing batch: ${error.message}`);
+                    throw error;
+                }
+            }
+            // Mark as indexed
+            debugLog(`[BACKGROUND-INDEX] Marking codebase as indexed...`);
+            await this.setCodebaseIndexed(codebasePath, {
+                indexedFiles: -1, // We don't track file count in backend mode
+                totalChunks,
+                status: 'completed',
+            });
+            debugLog(`[BACKGROUND-INDEX] Codebase marked as indexed`);
+            debugLog(`[BACKGROUND-INDEX] ✅ Indexing completed! ${totalChunks} chunks indexed to collection: ${collectionName}`);
+            // Save Merkle snapshot for future incremental syncs
+            try {
+                debugLog(`[BACKGROUND-INDEX] Saving Merkle snapshot...`);
+                const fileHashes = await this.generateFileHashes(codebasePath, ignorePatterns);
+                await this.backendClient.saveMerkleSnapshot(codebasePath, {
+                    fileHashes: Array.from(fileHashes.entries()),
+                    merkleDAG: { nodes: [], rootIds: [] },
+                    fileCount: fileHashes.size,
+                });
+                debugLog(`[BACKGROUND-INDEX] Merkle snapshot saved (${fileHashes.size} files)`);
+            }
+            catch (e) {
+                debugLog(`[BACKGROUND-INDEX] Could not save Merkle snapshot: ${e}`);
+            }
+            // Auto-start file watching for incremental updates
+            this.startWatching(codebasePath, collectionName);
+            debugLog(`[BACKGROUND-INDEX] File watcher started`);
+        }
+        catch (error) {
+            debugLog(`[BACKGROUND-INDEX] Error during indexing for ${codebasePath}: ${error.message || error}`);
+            const lastProgress = await this.getIndexingProgress(codebasePath);
+            await this.setCodebaseIndexFailed(codebasePath, error.message || String(error), lastProgress);
+        }
+    }
+    async handleSearchCode(args) {
+        const { path: codebasePath, query, limit = 10, extensionFilter } = args;
+        try {
+            // Sync with backend first
+            await this.syncIndexedCodebasesFromBackend();
+            // Force absolute path resolution
+            const absolutePath = ensureAbsolutePath(codebasePath);
+            // Validate path exists
+            if (!(await this.pathExists(absolutePath))) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Path '${absolutePath}' does not exist. Original input: '${codebasePath}'`
+                        }],
+                    isError: true
+                };
+            }
+            // Check if it's a directory
+            const stat = await fs.stat(absolutePath);
+            if (!stat.isDirectory()) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Path '${absolutePath}' is not a directory`
+                        }],
+                    isError: true
+                };
+            }
+            trackCodebasePath(absolutePath);
+            // Check if this codebase is indexed or being indexed
+            const indexedCodebases = await this.getIndexedCodebases();
+            const indexingCodebases = await this.getIndexingCodebases();
+            const isIndexed = indexedCodebases.includes(absolutePath);
+            const isIndexing = indexingCodebases.includes(absolutePath);
+            if (!isIndexed && !isIndexing) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Codebase '${absolutePath}' is not indexed.\n\nPlease run index_codebase first:\n  index_codebase(path="${absolutePath}")\n\nThis only needs to be done once per project.`
+                        }],
+                    isError: true
+                };
+            }
+            let indexingStatusMessage = '';
+            if (isIndexing) {
+                indexingStatusMessage = `\n⚠️  **Indexing in Progress**: This codebase is currently being indexed in the background. Search results may be incomplete until indexing completes.`;
+            }
+            const collectionName = this.generateCollectionName(absolutePath);
+            console.log(`[SEARCH] Searching in collection: ${collectionName}`);
+            console.log(`[SEARCH] Query: "${query}"`);
+            // Search via backend
+            const response = await this.backendClient.search({
+                query,
+                collection: collectionName,
+                limit: Math.min(limit, 50),
+                extensionFilter: Array.isArray(extensionFilter) ? extensionFilter : undefined,
+                rerank: true,
+            });
+            if (response.results.length === 0) {
+                let noResultsMessage = `No results found for query: "${query}" in codebase '${absolutePath}'`;
+                if (isIndexing) {
+                    noResultsMessage += `\n\nNote: This codebase is still being indexed. Try searching again after indexing completes.`;
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: noResultsMessage
+                        }]
+                };
+            }
+            // Format results
+            const formattedResults = response.results.map((result, index) => {
+                const location = `${result.relativePath}:${result.startLine}-${result.endLine}`;
+                const context = truncateContent(result.content, 5000);
+                const codebaseInfo = path.basename(absolutePath);
+                return `${index + 1}. Code snippet (${result.language}) [${codebaseInfo}]\n` +
+                    `   Location: ${location}\n` +
+                    `   Score: ${result.score.toFixed(4)}\n` +
+                    `   Context: \n\`\`\`${result.language}\n${context}\n\`\`\`\n`;
+            }).join('\n');
+            let resultMessage = `Found ${response.results.length} results for query: "${query}" in codebase '${absolutePath}'${indexingStatusMessage}\n\n${formattedResults}`;
+            if (isIndexing) {
+                resultMessage += `\n\n💡 **Tip**: This codebase is still being indexed. More results may become available as indexing progresses.`;
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: resultMessage
+                    }]
+            };
+        }
+        catch (error) {
+            console.error('[SEARCH] Error:', error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error searching code: ${error.message || error}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    async handleClearIndex(args) {
+        const { path: codebasePath } = args;
+        const indexedCodebases = await this.getIndexedCodebases();
+        const indexingCodebases = await this.getIndexingCodebases();
+        if (indexedCodebases.length === 0 && indexingCodebases.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "No codebases are currently indexed or being indexed."
+                    }]
+            };
+        }
+        try {
+            // Force absolute path resolution
+            const absolutePath = ensureAbsolutePath(codebasePath);
+            // Validate path exists
+            if (!(await this.pathExists(absolutePath))) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Path '${absolutePath}' does not exist. Original input: '${codebasePath}'`
+                        }],
+                    isError: true
+                };
+            }
+            // Check if it's a directory
+            const stat = await fs.stat(absolutePath);
+            if (!stat.isDirectory()) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Path '${absolutePath}' is not a directory`
+                        }],
+                    isError: true
+                };
+            }
+            // Check if this codebase is indexed or being indexed
+            const isIndexed = indexedCodebases.includes(absolutePath);
+            const isIndexing = indexingCodebases.includes(absolutePath);
+            if (!isIndexed && !isIndexing) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Codebase '${absolutePath}' is not indexed or being indexed.`
+                        }],
+                    isError: true
+                };
+            }
+            const collectionName = this.generateCollectionName(absolutePath);
+            console.log(`[CLEAR] Deleting collection: ${collectionName}`);
+            try {
+                await this.backendClient.deleteRepo(collectionName);
+                console.log(`[CLEAR] Successfully deleted collection: ${collectionName}`);
+            }
+            catch (error) {
+                if (!error.message?.includes('not found')) {
+                    throw error;
+                }
+                console.log(`[CLEAR] Collection already deleted or not found`);
+            }
+            // Remove from snapshot (backend)
+            await this.removeCodebaseFromSnapshot(absolutePath);
+            // Get updated counts
+            const remainingIndexed = await this.getIndexedCodebases();
+            const remainingIndexing = await this.getIndexingCodebases();
+            let resultText = `Successfully cleared codebase '${absolutePath}'`;
+            if (remainingIndexed.length > 0 || remainingIndexing.length > 0) {
+                resultText += `\n${remainingIndexed.length} other indexed codebase(s) and ${remainingIndexing.length} indexing codebase(s) remain`;
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: resultText
+                    }]
+            };
+        }
+        catch (error) {
+            console.error('[CLEAR] Error:', error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error clearing index: ${error.message || error}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    async handleGetIndexingStatus(args) {
+        const { path: codebasePath } = args;
+        try {
+            // Force absolute path resolution
+            const absolutePath = ensureAbsolutePath(codebasePath);
+            // Validate path exists
+            if (!(await this.pathExists(absolutePath))) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Path '${absolutePath}' does not exist. Original input: '${codebasePath}'`
+                        }],
+                    isError: true
+                };
+            }
+            // Check if it's a directory
+            const stat = await fs.stat(absolutePath);
+            if (!stat.isDirectory()) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Path '${absolutePath}' is not a directory`
+                        }],
+                    isError: true
+                };
+            }
+            // Check indexing status from backend snapshot
+            const status = await this.getCodebaseStatus(absolutePath);
+            const info = await this.getCodebaseInfo(absolutePath);
+            let statusMessage = '';
+            switch (status) {
+                case 'indexed':
+                    if (info && 'totalChunks' in info) {
+                        const indexedInfo = info;
+                        statusMessage = `✅ Codebase '${absolutePath}' is fully indexed and ready for search.`;
+                        statusMessage += `\n📊 Statistics: ${indexedInfo.totalChunks} chunks`;
+                        statusMessage += `\n🕐 Last updated: ${new Date(indexedInfo.lastUpdated).toLocaleString()}`;
+                    }
+                    else {
+                        statusMessage = `✅ Codebase '${absolutePath}' is fully indexed and ready for search.`;
+                    }
+                    break;
+                case 'indexing':
+                    if (info && 'indexingPercentage' in info) {
+                        const indexingInfo = info;
+                        const progressPercentage = indexingInfo.indexingPercentage || 0;
+                        statusMessage = `🔄 Codebase '${absolutePath}' is currently being indexed. Progress: ${progressPercentage.toFixed(1)}%`;
+                        if (progressPercentage < 50) {
+                            statusMessage += ' (Scanning and chunking files...)';
+                        }
+                        else {
+                            statusMessage += ' (Generating embeddings via backend...)';
+                        }
+                        statusMessage += `\n🕐 Last updated: ${new Date(indexingInfo.lastUpdated).toLocaleString()}`;
+                    }
+                    else {
+                        statusMessage = `🔄 Codebase '${absolutePath}' is currently being indexed.`;
+                    }
+                    break;
+                case 'indexfailed':
+                    if (info && 'errorMessage' in info) {
+                        const failedInfo = info;
+                        statusMessage = `❌ Codebase '${absolutePath}' indexing failed.`;
+                        statusMessage += `\n🚨 Error: ${failedInfo.errorMessage}`;
+                        if (failedInfo.lastAttemptedPercentage !== undefined) {
+                            statusMessage += `\n📊 Failed at: ${failedInfo.lastAttemptedPercentage.toFixed(1)}% progress`;
+                        }
+                        statusMessage += `\n💡 You can retry indexing by running the index_codebase command again.`;
+                    }
+                    else {
+                        statusMessage = `❌ Codebase '${absolutePath}' indexing failed. You can retry indexing.`;
+                    }
+                    break;
+                default:
+                    statusMessage = `❌ Codebase '${absolutePath}' is not indexed.\n\nPlease run index_codebase first:\n  index_codebase(path="${absolutePath}")\n\nThis only needs to be done once per project.`;
+                    break;
+            }
+            const pathInfo = codebasePath !== absolutePath
+                ? `\nNote: Input path '${codebasePath}' was resolved to absolute path '${absolutePath}'`
+                : '';
+            return {
+                content: [{
+                        type: "text",
+                        text: statusMessage + pathInfo
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error getting indexing status: ${error.message || error}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    async handleStartWatch(args) {
+        const { path: codebasePath } = args;
+        try {
+            // Force absolute path resolution
+            const absolutePath = ensureAbsolutePath(codebasePath);
+            // Validate path exists
+            if (!(await this.pathExists(absolutePath))) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Path '${absolutePath}' does not exist. Original input: '${codebasePath}'`
+                        }],
+                    isError: true
+                };
+            }
+            // Check if it's a directory
+            const stat = await fs.stat(absolutePath);
+            if (!stat.isDirectory()) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Path '${absolutePath}' is not a directory`
+                        }],
+                    isError: true
+                };
+            }
+            // Check if this codebase is indexed
+            const status = await this.getCodebaseStatus(absolutePath);
+            if (status !== 'indexed') {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Codebase '${absolutePath}' is not indexed.\n\nPlease run index_codebase first:\n  index_codebase(path="${absolutePath}")\n\nThis only needs to be done once per project.`
+                        }],
+                    isError: true
+                };
+            }
+            // Check if already watching
+            if (this.isWatching(absolutePath)) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Codebase '${absolutePath}' is already being watched for changes.`
+                        }]
+                };
+            }
+            // Start watching
+            const collectionName = this.generateCollectionName(absolutePath);
+            this.startWatching(absolutePath, collectionName);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Started watching codebase '${absolutePath}' for file changes. Files will be automatically re-indexed when modified.`
+                    }]
+            };
+        }
+        catch (error) {
+            console.error('[START_WATCH] Error:', error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error starting watch: ${error.message || error}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    async handleStopWatch(args) {
+        const { path: codebasePath } = args;
+        try {
+            // Force absolute path resolution
+            const absolutePath = ensureAbsolutePath(codebasePath);
+            // Check if watching
+            if (!this.isWatching(absolutePath)) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Codebase '${absolutePath}' is not being watched.`
+                        }]
+                };
+            }
+            // Stop watching
+            await this.stopWatching(absolutePath);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Stopped watching codebase '${absolutePath}'. Files will no longer be automatically re-indexed.`
+                    }]
+            };
+        }
+        catch (error) {
+            console.error('[STOP_WATCH] Error:', error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error stopping watch: ${error.message || error}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    async handleGetWatchStatus(_args) {
+        try {
+            const watchedCodebases = this.getWatchedCodebases();
+            if (watchedCodebases.length === 0) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: "No codebases are currently being watched for file changes."
+                        }]
+                };
+            }
+            const list = watchedCodebases.map((p, i) => `${i + 1}. ${p}`).join('\n');
+            return {
+                content: [{
+                        type: "text",
+                        text: `Currently watching ${watchedCodebases.length} codebase(s) for file changes:\n\n${list}\n\nFiles in these codebases will be automatically re-indexed when modified.`
+                    }]
+            };
+        }
+        catch (error) {
+            console.error('[GET_WATCH_STATUS] Error:', error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error getting watch status: ${error.message || error}`
+                    }],
+                isError: true
+            };
+        }
+    }
+}
+// ==================== Merkle Diff Helpers ====================
+// Used for incremental indexing - only process changed files
+BackendToolHandlers.MAX_FILE_SIZE = 1000000; // 1MB - skip large/minified files
+//# sourceMappingURL=backend-handlers.js.map