@autodev/codebase 0.0.3 → 0.0.4

package/dist/index.js

@@ -2,13 +2,13 @@ import React, { useState, useEffect, useRef } from 'react';
 import { render, Box, Text, useInput } from 'ink';
 import * as path$3 from 'path';
 import path__default from 'path';
+import * as os from 'os';
+import os__default from 'os';
 import * as fs$2 from 'fs';
 import fs__default, { promises, watch } from 'fs';
 import * as childProcess from 'child_process';
 import { exec } from 'child_process';
 import * as readline from 'readline';
-import * as os from 'os';
-import os__default from 'os';
 import { EventEmitter as EventEmitter$1 } from 'events';
 import require$$0$g, { createHash } from 'crypto';
 import require$$0$7 from 'node:assert';
@@ -35044,46 +35044,6 @@ class QdrantClient {
     }
 }
 
-/*
-The Node.js 'path' module resolves and normalizes paths differently depending on the platform:
-- On Windows, it uses backslashes (\) as the default path separator.
-- On POSIX-compliant systems (Linux, macOS), it uses forward slashes (/) as the default path separator.
-
-While modules like 'upath' can be used to normalize paths to use forward slashes consistently,
-this can create inconsistencies when interfacing with other modules (like vscode.fs) that use
-backslashes on Windows.
-
-Our approach:
-1. We present paths with forward slashes to the AI and user for consistency.
-2. We use the 'arePathsEqual' function for safe path comparisons.
-3. Internally, Node.js gracefully handles both backslashes and forward slashes.
-
-This strategy ensures consistent path presentation while leveraging Node.js's built-in
-path handling capabilities across different platforms.
-
-Note: When interacting with the file system or VS Code APIs, we still use the native path module
-to ensure correct behavior on all platforms. The toPosixPath and arePathsEqual functions are
-primarily used for presentation and comparison purposes, not for actual file system operations.
-
-Observations:
-- Macos isn't so flexible with mixed separators, whereas windows can handle both. ("Node.js does automatically handle path separators on Windows, converting forward slashes to backslashes as needed. However, on macOS and other Unix-like systems, the path separator is always a forward slash (/), and backslashes are treated as regular characters.")
-*/
-function toPosixPath(p) {
-    // Extended-Length Paths in Windows start with "\\?\" to allow longer paths and bypass usual parsing. If detected, we return the path unmodified to maintain functionality, as altering these paths could break their special syntax.
-    const isExtendedLengthPath = p.startsWith("\\\\?\\");
-    if (isExtendedLengthPath) {
-        return p;
-    }
-    return p.replace(/\\/g, "/");
-}
-String.prototype.toPosix = function () {
-    return toPosixPath(this);
-};
-// Node.js 纯实现，不依赖 VSCode
-const getWorkspacePath = (defaultCwdPath = "") => {
-    return defaultCwdPath || process.cwd();
-};
-
 /**
  * Qdrant implementation of the vector store interface
  */
@@ -35255,9 +35215,7 @@ class QdrantVectorStore {
                     hnsw_ef: 128,
                     exact: false,
                 },
-                with_payload: {
-                    include: ["filePath", "codeChunk", "startLine", "endLine", "pathSegments"],
-                },
+                with_payload: true,
             };
             console.log("🔍[QdrantVectorStore] Search request:", JSON.stringify({ ...searchRequest, query: "[query vector]" }));
             const operationResult = await this.client.query(this.collectionName, searchRequest);
@@ -35285,16 +35243,11 @@ class QdrantVectorStore {
             return;
         }
         try {
-            const workspaceRoot = getWorkspacePath();
-            const normalizedPaths = filePaths.map((filePath) => {
-                const absolutePath = path$3.resolve(workspaceRoot, filePath);
-                return path$3.normalize(absolutePath);
-            });
             const filter = {
-                should: normalizedPaths.map((normalizedPath) => ({
+                should: filePaths.map((filePath) => ({
                     key: "filePath",
                     match: {
-                        value: normalizedPath,
+                        value: filePath,
                     },
                 })),
             };
@@ -35348,6 +35301,34 @@ class QdrantVectorStore {
         const collectionInfo = await this.getCollectionInfo();
         return collectionInfo !== null;
     }
+    async getAllFilePaths() {
+        try {
+            const allFilePaths = new Set();
+            let nextPageOffset = undefined;
+            do {
+                const response = await this.client.scroll(this.collectionName, {
+                    limit: 250,
+                    with_payload: ["filePath"],
+                    with_vector: false,
+                    offset: nextPageOffset,
+                });
+                for (const point of response.points) {
+                    if (point.payload?.['filePath'] && typeof point.payload['filePath'] === 'string') {
+                        allFilePaths.add(point.payload['filePath']);
+                    }
+                }
+                nextPageOffset = response.next_page_offset;
+            } while (nextPageOffset);
+            return Array.from(allFilePaths);
+        }
+        catch (error) {
+            // console.error("[QdrantVectorStore] Failed to get all file paths:", error)
+            // In case of an error (e.g., collection not found), return an empty array
+            // This prevents the reconciliation process from accidentally deleting everything
+            // if Qdrant is temporarily unavailable.
+            return [];
+        }
+    }
 }
 
 var treeSitter = {exports: {}};
@@ -41445,8 +41426,28 @@ class CodeParser {
             }
         }
         const results = [];
-        // Process captures if not empty
-        const queue = captures.map((capture) => capture.node);
+        // Process captures if not empty - build a map to track node identifiers
+        const nodeIdentifierMap = new Map();
+        // Extract identifiers from captures
+        for (const capture of captures) {
+            if (capture.name === 'name' || capture.name === 'property.name.definition') {
+                // Find the corresponding definition node for this name
+                const definitionCapture = captures.find(c => c.name.includes('definition') &&
+                    c.node.startPosition.row <= capture.node.startPosition.row &&
+                    c.node.endPosition.row >= capture.node.endPosition.row);
+                if (definitionCapture) {
+                    // For JSON properties, remove quotes from the identifier
+                    let identifier = capture.node.text;
+                    if (capture.name === 'property.name.definition' && identifier.startsWith('"') && identifier.endsWith('"')) {
+                        identifier = identifier.slice(1, -1);
+                    }
+                    nodeIdentifierMap.set(definitionCapture.node, identifier);
+                }
+            }
+        }
+        const queue = captures
+            .filter((capture) => capture.name.includes('definition'))
+            .map((capture) => capture.node);
         while (queue.length > 0) {
             const currentNode = queue.shift();
             // const lineSpan = currentNode.endPosition.row - currentNode.startPosition.row + 1 // Removed as per lint error
@@ -41467,7 +41468,8 @@ class CodeParser {
                 }
                 else {
                     // Node meets min chars and is within max chars, create a block
-                    const identifier = currentNode.childForFieldName("name")?.text ||
+                    const identifier = nodeIdentifierMap.get(currentNode) ||
+                        currentNode.childForFieldName("name")?.text ||
                         currentNode.children?.find((c) => c.type === "identifier")?.text ||
                         null;
                     const type = currentNode.type;
@@ -41479,6 +41481,9 @@ class CodeParser {
                         .digest("hex");
                     if (!seenSegmentHashes.has(segmentHash)) {
                         seenSegmentHashes.add(segmentHash);
+                        // Build parent chain and hierarchy display
+                        const parentChain = this.buildParentChain(currentNode, nodeIdentifierMap);
+                        const hierarchyDisplay = this.buildHierarchyDisplay(parentChain, identifier, type);
                         results.push({
                             file_path: filePath,
                             identifier,
@@ -41488,13 +41493,16 @@ class CodeParser {
                             content,
                             segmentHash,
                             fileHash,
+                            chunkSource: 'tree-sitter',
+                            parentChain,
+                            hierarchyDisplay,
                         });
                     }
                 }
             }
             // Nodes smaller than MIN_BLOCK_CHARS are ignored
         }
-        return results;
+        return this.deduplicateBlocks(results);
     }
     /**
      * Common helper function to chunk text by lines, avoiding tiny remainders.
@@ -41524,6 +41532,9 @@ class CodeParser {
                         content: chunkContent,
                         segmentHash,
                         fileHash,
+                        chunkSource: 'fallback',
+                        parentChain: [], // No parent chain for fallback chunks
+                        hierarchyDisplay: null,
                     });
                 }
             }
@@ -41546,6 +41557,9 @@ class CodeParser {
                     content: segment,
                     segmentHash,
                     fileHash,
+                    chunkSource: 'line-segment',
+                    parentChain: [], // No parent chain for line segments
+                    hierarchyDisplay: null,
                 });
             }
         };
@@ -41628,6 +41642,154 @@ class CodeParser {
         return this._chunkTextByLines(lines, filePath, fileHash, node.type, // Use the node's type
         seenSegmentHashes, baseStartLine);
     }
+    /**
+     * Removes blocks that are contained within other blocks to avoid duplication
+     */
+    deduplicateBlocks(blocks) {
+        const sourceOrder = ['tree-sitter', 'fallback', 'line-segment'];
+        blocks.sort((a, b) => sourceOrder.indexOf(a.chunkSource) - sourceOrder.indexOf(b.chunkSource));
+        const result = [];
+        for (const block of blocks) {
+            const isDuplicate = result.some(existing => this.isBlockContained(block, existing));
+            if (!isDuplicate) {
+                result.push(block);
+            }
+        }
+        return result;
+    }
+    /**
+     * Builds the parent chain for a given tree-sitter node
+     */
+    buildParentChain(node, nodeIdentifierMap) {
+        const parentChain = [];
+        // Container node types that we want to track in the hierarchy
+        const containerTypes = new Set([
+            'class_declaration', 'class_definition',
+            'interface_declaration', 'interface_definition',
+            'namespace_declaration', 'namespace_definition',
+            'module_declaration', 'module_definition',
+            'function_declaration', 'function_definition', 'method_definition',
+            'object_expression', 'object_pattern',
+            'object', 'pair', // JSON objects and properties
+            'program', 'source_file'
+        ]);
+        let currentNode = node.parent;
+        while (currentNode) {
+            // Skip non-container nodes
+            if (!containerTypes.has(currentNode.type)) {
+                currentNode = currentNode.parent;
+                continue;
+            }
+            // Skip program/source_file as they're too generic
+            if (currentNode.type === 'program' || currentNode.type === 'source_file') {
+                currentNode = currentNode.parent;
+                continue;
+            }
+            // Try to get identifier from various sources
+            let identifier = nodeIdentifierMap.get(currentNode) || null;
+            if (!identifier) {
+                // Try to extract identifier from the node structure
+                identifier = this.extractNodeIdentifier(currentNode);
+            }
+            // Only add to chain if we found a meaningful identifier
+            if (identifier) {
+                parentChain.unshift({
+                    identifier: identifier,
+                    type: this.normalizeNodeType(currentNode.type)
+                });
+            }
+            currentNode = currentNode.parent;
+        }
+        return parentChain;
+    }
+    /**
+     * Extracts identifier from a tree-sitter node using various strategies
+     */
+    extractNodeIdentifier(node) {
+        // Try field-based extraction first
+        const nameField = node.childForFieldName("name");
+        if (nameField) {
+            let name = nameField.text;
+            // Remove quotes from JSON properties
+            if (name.startsWith('"') && name.endsWith('"')) {
+                name = name.slice(1, -1);
+            }
+            return name;
+        }
+        // Try to find identifier child nodes
+        const identifierChild = node.children?.find(child => child.type === "identifier" ||
+            child.type === "type_identifier" ||
+            child.type === "property_identifier");
+        if (identifierChild) {
+            let name = identifierChild.text;
+            // Remove quotes from JSON properties
+            if (name.startsWith('"') && name.endsWith('"')) {
+                name = name.slice(1, -1);
+            }
+            return name;
+        }
+        // For JSON pairs, try to get the key
+        if (node.type === 'pair' && node.children && node.children.length > 0) {
+            const key = node.children[0];
+            if (key) {
+                let name = key.text;
+                // Remove quotes from JSON keys
+                if (name.startsWith('"') && name.endsWith('"')) {
+                    name = name.slice(1, -1);
+                }
+                return name;
+            }
+        }
+        return null;
+    }
+    /**
+     * Normalizes node types to more readable format
+     */
+    normalizeNodeType(nodeType) {
+        const typeMap = {
+            'class_declaration': 'class',
+            'class_definition': 'class',
+            'interface_declaration': 'interface',
+            'interface_definition': 'interface',
+            'namespace_declaration': 'namespace',
+            'namespace_definition': 'namespace',
+            'module_declaration': 'module',
+            'module_definition': 'module',
+            'function_declaration': 'function',
+            'function_definition': 'function',
+            'method_definition': 'method',
+            'object_expression': 'object',
+            'object_pattern': 'object',
+            'object': 'object',
+            'pair': 'property'
+        };
+        return typeMap[nodeType] || nodeType;
+    }
+    /**
+     * Builds hierarchy display string from parent chain
+     */
+    buildHierarchyDisplay(parentChain, currentIdentifier, currentType) {
+        const parts = [];
+        // Add parent parts
+        for (const parent of parentChain) {
+            parts.push(`${parent.type} ${parent.identifier}`);
+        }
+        // Add current node if it has an identifier
+        if (currentIdentifier) {
+            const normalizedCurrentType = this.normalizeNodeType(currentType);
+            parts.push(`${normalizedCurrentType} ${currentIdentifier}`);
+        }
+        return parts.length > 0 ? parts.join(' > ') : null;
+    }
+    /**
+     * Checks if block1 is contained within block2
+     */
+    isBlockContained(block1, block2) {
+        return block1.file_path === block2.file_path &&
+            block1.start_line >= block2.start_line &&
+            block1.end_line <= block2.end_line &&
+            block2.content.includes(block1.content);
+    }
 }
 // Export a singleton instance for convenience
 const codeParser = new CodeParser();
@@ -41653,6 +41815,7 @@ const DIRS_TO_IGNORE = [
     "pkg",
     "Pods",
     ".*",
+    ".autodev-cache"
 ];
 /**
  * List files in a directory, with optional recursive traversal
@@ -41676,6 +41839,7 @@ async function listFiles(dirPath, recursive, limit, deps) {
     }
     // Get files using ripgrep
     const files = await listFilesWithRipgrep(rgPath, dirPath, recursive, limit, deps.pathUtils);
+    // console.log(`[listFiles] Found ${files.length} files in ${dirPath} (recursive: ${recursive})`)
     // Get directories with proper filtering
     const gitignorePatterns = await parseGitignoreFile(dirPath, recursive, deps.pathUtils);
     const directories = await listFilteredDirectories(dirPath, recursive, gitignorePatterns, deps.pathUtils);
@@ -41979,22 +42143,23 @@ async function execRipgrep(rgPath, args, limit) {
  */
 class BatchProcessor {
     async processBatch(items, options) {
-        if (items.length === 0) {
-            return { processed: 0, failed: 0, errors: [] };
-        }
-        const result = { processed: 0, failed: 0, errors: [] };
+        // console.log(`[BatchProcessor] Starting batch processing for ${items.length} items`)
+        const result = { processed: 0, failed: 0, errors: [], processedFiles: [] };
         // Report initial progress
         options.onProgress?.(0, items.length);
         try {
-            // Phase 1: Handle deletions if needed
+            // Phase 1: Handle deletions if needed (even if items is empty)
             if (options.getFilesToDelete) {
                 const filesToDelete = options.getFilesToDelete(items);
+                console.log(`[BatchProcessor] Files to delete: ${filesToDelete.length}`, filesToDelete);
                 if (filesToDelete.length > 0) {
                     await this.handleDeletions(filesToDelete, options, result);
                 }
             }
-            // Phase 2: Process items in batches
-            await this.processItemsInBatches(items, options, result);
+            // Phase 2: Process items in batches (only if there are items to process)
+            if (items.length > 0) {
+                await this.processItemsInBatches(items, options, result);
+            }
             return result;
         }
         catch (error) {
@@ -42007,15 +42172,30 @@ class BatchProcessor {
     async handleDeletions(filesToDelete, options, result) {
         try {
             await options.vectorStore.deletePointsByMultipleFilePaths(filesToDelete);
-            // Clear cache for deleted files
+            // Clear cache for deleted files and record successful deletions
             for (const filePath of filesToDelete) {
-                options.cacheManager.deleteHash(filePath);
+                // Convert relative path to absolute path for cache deletion if converter is provided
+                const cacheFilePath = options.relativeCachePathToAbsolute ?
+                    options.relativeCachePathToAbsolute(filePath) : filePath;
+                options.cacheManager.deleteHash(cacheFilePath);
+                result.processedFiles.push({
+                    path: filePath,
+                    status: "success"
+                });
             }
         }
         catch (error) {
             const err = error;
             result.errors.push(err);
             options.onError?.(err);
+            // Record failed deletions
+            for (const filePath of filesToDelete) {
+                result.processedFiles.push({
+                    path: filePath,
+                    status: "error",
+                    error: err
+                });
+            }
             throw err;
         }
     }
@@ -42049,6 +42229,11 @@ class BatchProcessor {
                         options.cacheManager.updateHash(filePath, fileHash);
                     }
                     result.processed++;
+                    result.processedFiles.push({
+                        path: filePath,
+                        status: "success",
+                        newHash: fileHash
+                    });
                     options.onProgress?.(result.processed, result.processed + result.failed, filePath);
                 }
                 success = true;
@@ -42069,9 +42254,14 @@ class BatchProcessor {
             const batchError = new Error(errorMessage);
             result.errors.push(batchError);
             options.onError?.(batchError);
-            // Still report progress for failed items
+            // Record failed items and still report progress
             for (const item of batchItems) {
                 const filePath = options.itemToFilePath(item);
+                result.processedFiles.push({
+                    path: filePath,
+                    status: "error",
+                    error: lastError
+                });
                 options.onProgress?.(result.processed, result.processed + result.failed, filePath);
             }
         }
@@ -42819,6 +43009,11 @@ class DirectoryScanner {
                         codeChunk: block.content,
                         startLine: block.start_line,
                         endLine: block.end_line,
+                        chunkSource: block.chunkSource,
+                        type: block.type,
+                        identifier: block.identifier,
+                        parentChain: block.parentChain,
+                        hierarchyDisplay: block.hierarchyDisplay,
                     },
                 };
             },
@@ -42847,21 +43042,34 @@ class DirectoryScanner {
             onError?.(new Error(errorMessage));
         }
     }
-}
-
-/**
- * Helper function to check if a path exists.
- *
- * @param path - The path to check.
- * @returns A promise that resolves to true if the path exists, false otherwise.
- */
-async function fileExistsAtPath(filePath) {
-    try {
-        await promises.access(filePath);
-        return true;
-    }
-    catch {
-        return false;
+    async getAllFilePaths(directory) {
+        const directoryPath = directory;
+        this.debug(`[Scanner] Getting all file paths for: ${directoryPath}`);
+        // Get all files recursively (handles .gitignore automatically)
+        const [allPaths, _] = await listFiles(directoryPath, true, MAX_LIST_FILES_LIMIT, { pathUtils: this.deps.pathUtils, ripgrepPath: 'rg' });
+        this.debug(`[Scanner] Found ${allPaths.length} paths from listFiles:`);
+        // Filter out directories (marked with trailing '/')
+        const filePaths = allPaths.filter((p) => !p.endsWith("/"));
+        this.debug(`[Scanner] After filtering directories: ${filePaths.length} files:`);
+        // Filter paths using workspace ignore rules
+        const allowedPaths = [];
+        for (const filePath of filePaths) {
+            const shouldIgnore = await this.deps.workspace.shouldIgnore(filePath);
+            if (!shouldIgnore) {
+                allowedPaths.push(filePath);
+            }
+        }
+        this.debug(`[Scanner] After workspace ignore rules: ${allowedPaths.length} files:`);
+        // Filter by supported extensions and ignore patterns
+        const supportedPaths = allowedPaths.filter((filePath) => {
+            const ext = this.deps.pathUtils.extname(filePath).toLowerCase();
+            const relativeFilePath = this.deps.workspace.getRelativePath(filePath);
+            const extSupported = scannerExtensions.includes(ext);
+            const ignoreInstanceIgnores = this.deps.ignoreInstance.ignores(relativeFilePath);
+            return extSupported && !ignoreInstanceIgnores;
+        });
+        this.debug(`[Scanner] After extension and ignore filtering: ${supportedPaths.length} files:`);
+        return supportedPaths;
     }
 }
 
@@ -43511,9 +43719,11 @@ const LOCK_TEXT_SYMBOL = "\u{1F512}";
  * Uses the 'ignore' library to support standard .gitignore syntax in .rooignore files.
  */
 class RooIgnoreController {
-    constructor(cwd, fileWatcher) {
+    constructor(fileSystem, workspace, pathUtils, fileWatcher) {
         this.cleanupFunctions = [];
-        this.cwd = cwd;
+        this.fileSystem = fileSystem;
+        this.workspace = workspace;
+        this.pathUtils = pathUtils;
         this.ignoreInstance = ignore$1();
         this.rooIgnoreContent = undefined;
         this.fileWatcher = fileWatcher;
@@ -43536,7 +43746,11 @@ class RooIgnoreController {
         if (!this.fileWatcher) {
             return;
         }
-        const rooignorePath = path$3.join(this.cwd, ".rooignore");
+        const rootPath = this.workspace.getRootPath();
+        if (!rootPath) {
+            return;
+        }
+        const rooignorePath = this.pathUtils.join(rootPath, ".rooignore");
         // Watch for changes to the .rooignore file
         const cleanup = this.fileWatcher.watchFile(rooignorePath, (event) => {
             // Reload .rooignore on any file system event
@@ -43551,14 +43765,21 @@ class RooIgnoreController {
         try {
             // Reset ignore instance to prevent duplicate patterns
             this.ignoreInstance = ignore$1();
-            const ignorePath = path$3.join(this.cwd, ".rooignore");
-            if (await fileExistsAtPath(ignorePath)) {
-                const content = await promises.readFile(ignorePath, "utf8");
+            const rootPath = this.workspace.getRootPath();
+            if (!rootPath) {
+                this.rooIgnoreContent = undefined;
+                return;
+            }
+            const ignorePath = this.pathUtils.join(rootPath, ".rooignore");
+            try {
+                const buffer = await this.fileSystem.readFile(ignorePath);
+                const content = new TextDecoder().decode(buffer);
                 this.rooIgnoreContent = content;
                 this.ignoreInstance.add(content);
                 this.ignoreInstance.add(".rooignore");
             }
-            else {
+            catch (fileError) {
+                // File doesn't exist or can't be read
                 this.rooIgnoreContent = undefined;
             }
         }
@@ -43569,7 +43790,7 @@ class RooIgnoreController {
     }
     /**
      * Check if a file should be accessible to the LLM
-     * @param filePath - Path to check (relative to cwd)
+     * @param filePath - Path to check (can be absolute or relative)
      * @returns true if file is accessible, false if ignored
      */
     validateAccess(filePath) {
@@ -43578,15 +43799,14 @@ class RooIgnoreController {
             return true;
         }
         try {
-            // Normalize path to be relative to cwd and use forward slashes
-            const absolutePath = path$3.resolve(this.cwd, filePath);
-            const relativePath = path$3.relative(this.cwd, absolutePath).toPosix();
-            // Ignore expects paths to be path.relative()'d
+            // Get relative path using workspace abstraction
+            const relativePath = this.workspace.getRelativePath(filePath);
+            // Ignore expects paths to be relative and use forward slashes
             return !this.ignoreInstance.ignores(relativePath);
         }
         catch (error) {
             // console.error(`Error validating access for ${filePath}:`, error)
-            // Ignore is designed to work with relative file paths, so will throw error for paths outside cwd. We are allowing access to all files outside cwd.
+            // Ignore is designed to work with relative file paths, so will throw error for paths outside workspace. We are allowing access to all files outside workspace.
             return true;
         }
     }
@@ -43680,37 +43900,6 @@ class RooIgnoreController {
     }
 }
 
-/**
- * Generates a normalized absolute path from a given file path and workspace root.
- * Handles path resolution and normalization to ensure consistent absolute paths.
- *
- * @param filePath - The file path to normalize (can be relative or absolute)
- * @param workspaceRoot - The root directory of the workspace
- * @returns The normalized absolute path
- */
-function generateNormalizedAbsolutePath(filePath) {
-    const workspaceRoot = getWorkspacePath();
-    // Resolve the path to make it absolute if it's relative
-    const resolvedPath = path$3.resolve(workspaceRoot, filePath);
-    // Normalize to handle any . or .. segments and duplicate slashes
-    return path$3.normalize(resolvedPath);
-}
-/**
- * Generates a relative file path from a normalized absolute path and workspace root.
- * Ensures consistent relative path generation across different platforms.
- *
- * @param normalizedAbsolutePath - The normalized absolute path to convert
- * @param workspaceRoot - The root directory of the workspace
- * @returns The relative path from workspaceRoot to the file
- */
-function generateRelativeFilePath(normalizedAbsolutePath) {
-    const workspaceRoot = getWorkspacePath();
-    // Generate the relative path
-    const relativePath = path$3.relative(workspaceRoot, normalizedAbsolutePath);
-    // Normalize to ensure consistent path separators
-    return path$3.normalize(relativePath);
-}
-
 /**
  * Implementation of the file watcher interface
  */
@@ -43724,7 +43913,7 @@ class FileWatcher {
      * @param vectorStore Optional vector store
      * @param cacheManager Cache manager
      */
-    constructor(workspacePath, fileSystem, eventBus, cacheManager, embedder, vectorStore, ignoreInstance, ignoreController) {
+    constructor(workspacePath, fileSystem, eventBus, workspace, pathUtils, cacheManager, embedder, vectorStore, ignoreInstance, ignoreController) {
         this.workspacePath = workspacePath;
         this.cacheManager = cacheManager;
         this.embedder = embedder;
@@ -43734,7 +43923,9 @@ class FileWatcher {
         this.FILE_PROCESSING_CONCURRENCY_LIMIT = 10;
         this.eventBus = eventBus;
         this.fileSystem = fileSystem;
-        this.ignoreController = ignoreController || new RooIgnoreController(workspacePath);
+        this.workspace = workspace;
+        this.pathUtils = pathUtils;
+        this.ignoreController = ignoreController || new RooIgnoreController(fileSystem, workspace, pathUtils);
         this.batchProcessor = new BatchProcessor();
         if (ignoreInstance) {
             this.ignoreInstance = ignoreInstance;
@@ -43752,6 +43943,7 @@ class FileWatcher {
         this.fileWatcher = fs$2.watch(this.workspacePath, { recursive: true }, (eventType, filename) => {
             if (!filename)
                 return;
+            // console.log(`[FileWatcher] Detected ${eventType} on file: ${filename}`)
             const fullPath = path$3.join(this.workspacePath, filename);
             // Check if file extension is supported
             const ext = path$3.extname(fullPath);
@@ -43759,19 +43951,21 @@ class FileWatcher {
                 return;
             // Handle different event types
             if (eventType === 'rename') {
-                // Check if file exists to determine if it's create or delete
-                fs$2.access(fullPath, fs$2.constants.F_OK, (err) => {
-                    if (err) {
-                        // File doesn't exist, it was deleted
-                        this.handleFileDeleted(fullPath);
-                    }
-                    else {
-                        // File exists, it was created
-                        this.handleFileCreated(fullPath);
-                    }
-                });
+                // Use synchronous check for more reliable file existence detection
+                try {
+                    fs$2.accessSync(fullPath, fs$2.constants.F_OK);
+                    // File exists, it was created or moved here
+                    // console.log(`[FileWatcher] File exists, treating as create: ${fullPath}`)
+                    this.handleFileCreated(fullPath);
+                }
+                catch (err) {
+                    // File doesn't exist, it was deleted or moved away
+                    // console.log(`[FileWatcher] File doesn't exist, treating as delete: ${fullPath}`)
+                    this.handleFileDeleted(fullPath);
+                }
             }
             else if (eventType === 'change') {
+                // console.log(`[FileWatcher] File changed: ${fullPath}`)
                 this.handleFileChanged(fullPath);
             }
         });
@@ -43838,6 +44032,7 @@ class FileWatcher {
      * @param events Array of events to process
      */
     async processBatch(events) {
+        console.log(`[FileWatcher] Processing batch of ${events.length} events`, JSON.stringify(events));
         const batchResults = [];
         const totalFilesInBatch = events.length;
         // Initial progress update
@@ -43874,82 +44069,126 @@ class FileWatcher {
                 }
             }
         }
-        // Use BatchProcessor for the actual processing
-        if (this.embedder && this.vectorStore) {
+        // Parse files into code blocks and separate deletions
+        const blocksToUpsert = [];
+        const filesToDelete = [];
+        const fileInfoMap = new Map();
+        for (const event of eventsWithContent) {
+            if (event.type === "delete") {
+                filesToDelete.push(event.filePath);
+            }
+            else if (event.content && event.newHash) {
+                // Parse the file to get code blocks like DirectoryScanner does
+                try {
+                    const blocks = await codeParser.parseFile(event.filePath, {
+                        content: event.content,
+                        fileHash: event.newHash
+                    });
+                    // Add all blocks from this file to the batch
+                    blocks.forEach(block => {
+                        if (block.content.trim()) {
+                            blocksToUpsert.push(block);
+                        }
+                    });
+                    // Store file info for later use
+                    fileInfoMap.set(event.filePath, {
+                        fileHash: event.newHash,
+                        isNew: event.type === "create"
+                    });
+                }
+                catch (error) {
+                    console.error(`[FileWatcher] Failed to parse file ${event.filePath}:`, error);
+                    batchResults.push({
+                        path: event.filePath,
+                        status: "error",
+                        error: error
+                    });
+                }
+            }
+        }
+        // Deletions will be handled by BatchProcessor
+        // Use BatchProcessor for both deletions and upserting blocks (like DirectoryScanner)
+        if (this.embedder && this.vectorStore && (blocksToUpsert.length > 0 || filesToDelete.length > 0)) {
+            console.log(`[FileWatcher] Processing batch of ${blocksToUpsert.length} Upserts and ${filesToDelete.length} deletions`);
             const options = {
                 embedder: this.embedder,
                 vectorStore: this.vectorStore,
                 cacheManager: this.cacheManager,
-                itemToText: (item) => item.content || "",
-                itemToFilePath: (item) => item.filePath,
-                getFileHash: (item) => item.newHash || "",
-                itemToPoint: (item, embedding) => {
-                    if (!item.content) {
-                        throw new Error(`No content available for ${item.filePath}`);
-                    }
-                    // Parse the file to get code blocks
-                    codeParser.parseFile(item.filePath, {
-                        content: item.content,
-                        fileHash: item.newHash || ""
-                    });
-                    // For simplicity, create a single point per file
-                    // In a real implementation, you might want to create multiple points for multiple blocks
-                    const normalizedAbsolutePath = generateNormalizedAbsolutePath(item.filePath);
-                    const stableName = `${normalizedAbsolutePath}:0`;
+                itemToText: (block) => block.content,
+                itemToFilePath: (block) => block.file_path,
+                getFileHash: (block) => {
+                    // Find the corresponding file info for this block
+                    const fileInfo = fileInfoMap.get(block.file_path);
+                    return fileInfo?.fileHash || "";
+                },
+                itemToPoint: (block, embedding) => {
+                    // Use the same logic as DirectoryScanner
+                    const normalizedAbsolutePath = this.pathUtils.normalize(this.pathUtils.resolve(block.file_path));
+                    const stableName = `${normalizedAbsolutePath}:${block.start_line}`;
                     const pointId = v5(stableName, QDRANT_CODE_BLOCK_NAMESPACE);
                     return {
                         id: pointId,
                         vector: embedding,
                         payload: {
-                            filePath: generateRelativeFilePath(normalizedAbsolutePath),
-                            codeChunk: item.content,
-                            startLine: 1,
-                            endLine: item.content.split('\n').length,
+                            filePath: this.workspace.getRelativePath(normalizedAbsolutePath),
+                            codeChunk: block.content,
+                            startLine: block.start_line,
+                            endLine: block.end_line,
+                            chunkSource: block.chunkSource,
+                            type: block.type,
+                            identifier: block.identifier,
+                            parentChain: block.parentChain,
+                            hierarchyDisplay: block.hierarchyDisplay,
                         },
                     };
                 },
-                getFilesToDelete: (items) => {
-                    const filesToDelete = [];
-                    for (const item of items) {
-                        if (item.type === "delete") {
-                            filesToDelete.push(item.filePath);
-                        }
-                        else if (item.type === "change") {
-                            // For change events, we need to delete old points first
-                            filesToDelete.push(item.filePath);
-                        }
-                    }
-                    return filesToDelete;
+                getFilesToDelete: (blocks) => {
+                    // Get files that need to be deleted (modified files, not new ones) + explicit deletions
+                    const uniqueFilePaths = Array.from(new Set(blocks
+                        .map(block => block.file_path)
+                        .filter(filePath => {
+                        const fileInfo = fileInfoMap.get(filePath);
+                        return fileInfo && !fileInfo.isNew; // Only modified files (not new)
+                    })));
+                    // Convert all paths to relative paths for vector store deletion
+                    const relativeDeletePaths = filesToDelete.map(path => this.workspace.getRelativePath(path));
+                    const relativeUpdatePaths = uniqueFilePaths.map(path => this.workspace.getRelativePath(path));
+                    return [...relativeDeletePaths, ...relativeUpdatePaths];
                 },
-                onProgress: (processed, total, currentFile) => {
+                // Path converter for cache deletion (relative -> absolute)
+                relativeCachePathToAbsolute: (relativePath) => {
+                    return this.pathUtils.resolve(this.workspacePath, relativePath);
+                },
+                onProgress: (processed, total) => {
                     this.eventBus.emit('batch-progress', {
                         processedInBatch: processed,
                         totalInBatch: total,
-                        currentFile,
                     });
                 },
                 onError: (error) => {
                     console.error("[FileWatcher] Batch processing error:", error);
                 }
             };
-            const result = await this.batchProcessor.processBatch(eventsWithContent.filter(e => e.type !== "delete" && e.content), options);
-            // Convert BatchProcessor results to FileProcessingResult format
-            for (const event of eventsWithContent) {
-                if (event.type === "delete" || !event.content) {
-                    // Handle delete events and files that couldn't be read
-                    batchResults.push({
-                        path: event.filePath,
-                        status: "success"
-                    });
+            const result = await this.batchProcessor.processBatch(blocksToUpsert, options);
+            // Add BatchProcessor results to our batch results
+            batchResults.push(...result.processedFiles);
+        }
+        else if (this.vectorStore && filesToDelete.length > 0) {
+            console.log(`[FileWatcher] Processing batch of ${filesToDelete.length} deletions without embedder`);
+            // Handle deletions even without embedder - convert to relative paths
+            const relativeDeletePaths = filesToDelete.map(path => this.workspace.getRelativePath(path));
+            try {
+                await this.vectorStore.deletePointsByMultipleFilePaths(relativeDeletePaths);
+                for (const filePath of filesToDelete) {
+                    this.cacheManager.deleteHash(filePath);
+                    batchResults.push({ path: filePath, status: "success" });
                 }
             }
-            // Add any errors from batch processing
-            for (const error of result.errors) {
-                batchResults.push({
-                    path: "unknown",
-                    status: "error",
-                    error
-                });
+            catch (error) {
+                console.error("[FileWatcher] Error deleting points for files:", filesToDelete, error);
+                for (const filePath of filesToDelete) {
+                    batchResults.push({ path: filePath, status: "error", error: error });
+                }
             }
         }
         // Finalize
@@ -43978,7 +44217,7 @@ class FileWatcher {
     async processFile(filePath) {
         try {
             // Check if file should be ignored
-            const relativeFilePath = generateRelativeFilePath(filePath);
+            const relativeFilePath = this.workspace.getRelativePath(filePath);
             if (!this.ignoreController.validateAccess(filePath) ||
                 (this.ignoreInstance && this.ignoreInstance.ignores(relativeFilePath))) {
                 return {
@@ -44017,14 +44256,14 @@ class FileWatcher {
                 const texts = blocks.map((block) => block.content);
                 const { embeddings } = await this.embedder.createEmbeddings(texts);
                 pointsToUpsert = blocks.map((block, index) => {
-                    const normalizedAbsolutePath = generateNormalizedAbsolutePath(block.file_path);
+                    const normalizedAbsolutePath = this.pathUtils.normalize(this.pathUtils.resolve(block.file_path));
                     const stableName = `${normalizedAbsolutePath}:${block.start_line}`;
                     const pointId = v5(stableName, QDRANT_CODE_BLOCK_NAMESPACE);
                     return {
                         id: pointId,
                         vector: embeddings[index],
                         payload: {
-                            filePath: generateRelativeFilePath(normalizedAbsolutePath),
+                            filePath: this.workspace.getRelativePath(normalizedAbsolutePath),
                             codeChunk: block.content,
                             startLine: block.start_line,
                             endLine: block.end_line,
@@ -44169,8 +44408,8 @@ class CodeIndexServiceFactory {
     /**
      * Creates a file watcher instance with its required dependencies.
      */
-    createFileWatcher(fileSystem, eventBus, embedder, vectorStore, cacheManager, ignoreInstance) {
-        return new FileWatcher(this.workspacePath, fileSystem, eventBus, cacheManager, embedder, vectorStore, ignoreInstance);
+    createFileWatcher(fileSystem, eventBus, workspace, pathUtils, embedder, vectorStore, cacheManager, ignoreInstance) {
+        return new FileWatcher(this.workspacePath, fileSystem, eventBus, workspace, pathUtils, cacheManager, embedder, vectorStore, ignoreInstance);
     }
     /**
      * Creates all required service dependencies if the service is properly configured.
@@ -44184,7 +44423,7 @@ class CodeIndexServiceFactory {
         const vectorStore = this.createVectorStore();
         const parser = codeParser;
         const scanner = this.createDirectoryScanner(embedder, vectorStore, parser, ignoreInstance, fileSystem, workspace, pathUtils);
-        const fileWatcher = this.createFileWatcher(fileSystem, eventBus, embedder, vectorStore, cacheManager, ignoreInstance);
+        const fileWatcher = this.createFileWatcher(fileSystem, eventBus, workspace, pathUtils, embedder, vectorStore, cacheManager, ignoreInstance);
         return {
             embedder,
             vectorStore,
@@ -44856,6 +45095,12 @@ class CacheManager {
             await this._performSave();
         }, 1500);
     }
+    /**
+     * Gets the cache file path
+     */
+    get getCachePath() {
+        return this.cachePath;
+    }
     /**
      * Initializes the cache manager by loading the cache file
      */
@@ -44918,6 +45163,16 @@ class CacheManager {
         delete this.fileHashes[filePath];
         this._debouncedSaveCache();
     }
+    /**
+     * Deletes multiple hashes by file path
+     * @param filePaths Array of file paths to delete
+     */
+    deleteHashes(filePaths) {
+        for (const filePath of filePaths) {
+            delete this.fileHashes[filePath];
+        }
+        this._debouncedSaveCache();
+    }
     /**
      * Gets a copy of all file hashes
      * @returns A copy of the file hashes record
@@ -45009,6 +45264,7 @@ class CodeIndexManager {
             this._cacheManager = new CacheManager(this.dependencies.fileSystem, this.dependencies.storage, this.workspacePath);
             await this._cacheManager.initialize();
         }
+        // console.log(`[CodeIndexManager] Cache initialized at ${this._cacheManager.getCachePath}`)
         // 4. Determine if Core Services Need Recreation
         const needsServiceRecreation = !this._serviceFactory || requiresRestart;
         if (needsServiceRecreation) {
@@ -45027,6 +45283,8 @@ class CodeIndexManager {
             this._orchestrator = new CodeIndexOrchestrator(this._configManager, this._stateManager, this.workspacePath, this._cacheManager, vectorStore, scanner, fileWatcher, this.dependencies.logger);
             // (Re)Initialize search service
             this._searchService = new CodeIndexSearchService(this._configManager, this._stateManager, embedder, vectorStore);
+            // Add the new reconciliation step
+            await this.reconcileIndex(vectorStore, scanner);
         }
         // 5. Handle Indexing Start/Restart
         // The enhanced vectorStore.initialize() in startIndexing() now handles dimension changes automatically
@@ -45092,6 +45350,32 @@ class CodeIndexManager {
     getCurrentStatus() {
         return this._stateManager.getCurrentStatus();
     }
+    async reconcileIndex(vectorStore, scanner) {
+        const logger = this.dependencies.logger;
+        logger?.info("Reconciling index with filesystem...");
+        // 1. Get all file paths from the vector store (these are relative paths)
+        const indexedRelativePaths = await vectorStore.getAllFilePaths();
+        if (indexedRelativePaths.length === 0) {
+            logger?.info("No files found in vector store. Skipping reconciliation.");
+            return;
+        }
+        // 2. Get all file paths from the local filesystem (these are absolute paths)
+        const localAbsolutePaths = await scanner.getAllFilePaths(this.workspacePath);
+        const localRelativePathSet = new Set(localAbsolutePaths.map((p) => this.dependencies.workspace.getRelativePath(p)));
+        // 3. Determine which files are stale
+        const staleRelativePaths = indexedRelativePaths.filter((p) => !localRelativePathSet.has(p));
+        if (staleRelativePaths.length > 0) {
+            logger?.info(`Found ${staleRelativePaths.length} stale files to remove.`);
+            // 4. Delete stale entries from vector store (using relative paths)
+            await vectorStore.deletePointsByMultipleFilePaths(staleRelativePaths);
+            // 5. Delete stale entries from cache (using absolute paths)
+            const staleAbsolutePaths = staleRelativePaths.map((p) => this.dependencies.pathUtils.resolve(this.workspacePath, p));
+            this._cacheManager.deleteHashes(staleAbsolutePaths);
+        }
+        else {
+            logger?.info("Index is already up-to-date.");
+        }
+    }
     async searchIndex(query, filter) {
         if (!this.isFeatureEnabled) {
             return [];
@@ -45121,6 +45405,77 @@ class CodeIndexManager {
 // --- Singleton Implementation ---
 CodeIndexManager.instances = new Map(); // Map workspace path to instance
 
+/*
+The Node.js 'path' module resolves and normalizes paths differently depending on the platform:
+- On Windows, it uses backslashes (\) as the default path separator.
+- On POSIX-compliant systems (Linux, macOS), it uses forward slashes (/) as the default path separator.
+
+While modules like 'upath' can be used to normalize paths to use forward slashes consistently,
+this can create inconsistencies when interfacing with other modules (like vscode.fs) that use
+backslashes on Windows.
+
+Our approach:
+1. We present paths with forward slashes to the AI and user for consistency.
+2. We use the 'arePathsEqual' function for safe path comparisons.
+3. Internally, Node.js gracefully handles both backslashes and forward slashes.
+
+This strategy ensures consistent path presentation while leveraging Node.js's built-in
+path handling capabilities across different platforms.
+
+Note: When interacting with the file system or VS Code APIs, we still use the native path module
+to ensure correct behavior on all platforms. The toPosixPath and arePathsEqual functions are
+primarily used for presentation and comparison purposes, not for actual file system operations.
+
+Observations:
+- Macos isn't so flexible with mixed separators, whereas windows can handle both. ("Node.js does automatically handle path separators on Windows, converting forward slashes to backslashes as needed. However, on macOS and other Unix-like systems, the path separator is always a forward slash (/), and backslashes are treated as regular characters.")
+*/
+function toPosixPath(p) {
+    // Extended-Length Paths in Windows start with "\\?\" to allow longer paths and bypass usual parsing. If detected, we return the path unmodified to maintain functionality, as altering these paths could break their special syntax.
+    const isExtendedLengthPath = p.startsWith("\\\\?\\");
+    if (isExtendedLengthPath) {
+        return p;
+    }
+    return p.replace(/\\/g, "/");
+}
+String.prototype.toPosix = function () {
+    return toPosixPath(this);
+};
+// Node.js 纯实现，不依赖 VSCode
+const getWorkspacePath = (defaultCwdPath = "") => {
+    return defaultCwdPath || process.cwd();
+};
+
+/**
+ * Generates a normalized absolute path from a given file path and workspace root.
+ * Handles path resolution and normalization to ensure consistent absolute paths.
+ *
+ * @param filePath - The file path to normalize (can be relative or absolute)
+ * @param workspaceRoot - The root directory of the workspace
+ * @returns The normalized absolute path
+ */
+function generateNormalizedAbsolutePath(filePath) {
+    const workspaceRoot = getWorkspacePath();
+    // Resolve the path to make it absolute if it's relative
+    const resolvedPath = path$3.resolve(workspaceRoot, filePath);
+    // Normalize to handle any . or .. segments and duplicate slashes
+    return path$3.normalize(resolvedPath);
+}
+/**
+ * Generates a relative file path from a normalized absolute path and workspace root.
+ * Ensures consistent relative path generation across different platforms.
+ *
+ * @param normalizedAbsolutePath - The normalized absolute path to convert
+ * @param workspaceRoot - The root directory of the workspace
+ * @returns The relative path from workspaceRoot to the file
+ */
+function generateRelativeFilePath(normalizedAbsolutePath) {
+    const workspaceRoot = getWorkspacePath();
+    // Generate the relative path
+    const relativePath = path$3.relative(workspaceRoot, normalizedAbsolutePath);
+    // Normalize to ensure consistent path separators
+    return path$3.normalize(relativePath);
+}
+
 /**
  * Node.js File System Adapter
  * Implements IFileSystem using Node.js fs/promises API
@@ -139551,14 +139906,14 @@ class CodebaseHTTPMCPServer {
         // Register search_codebase tool
         this.mcpServer.tool('search_codebase', 'Search the codebase using semantic vector search to find relevant code snippets, functions, and documentation.', {
             query: stringType().describe('The search query to find relevant code'),
-            limit: numberType().optional().default(20).describe('Maximum number of results to return (default: 20)'),
+            limit: numberType().optional().default(20).describe('Maximum number of results to return (default: 10)'),
             filters: objectType({
                 pathFilters: arrayType(stringType()).optional().describe('Filter by path strings - directories, extensions, file names, Case sensitive (e.g., ["src/", ".ts", "components"])'),
                 minScore: numberType().optional().describe('Minimum similarity score threshold (0-1)，default 0.4')
             }).optional().describe('Optional filters for file types, paths, etc.')
-        }, async ({ query, limit = 20, filters }) => {
+        }, async ({ query, limit = 10, filters }) => {
             if (limit === 0) {
-                limit = 20; // Default limit if not provided
+                limit = 10; // Default limit if not provided
             }
             if (!query || !query.trim() || typeof query !== 'string') {
                 throw new Error('Query parameter is required and must be a string');
@@ -139676,10 +140031,12 @@ class CodebaseHTTPMCPServer {
                     const startLine = result.payload?.startLine;
                     const endLine = result.payload?.endLine;
                     const lineInfo = (startLine !== undefined && endLine !== undefined)
-                        ? ` (L${startLine}-${endLine})`
+                        ? `(L${startLine}-${endLine})`
                         : '';
-                    const score = result.score?.toFixed(3) || '0.000';
-                    return `${lineInfo}
+                    const hierarchyInfo = result.payload?.hierarchyDisplay ? `< ${result.payload?.hierarchyDisplay} > `
+                        : '';
+                    const score = result.score?.toFixed(3) || '1.000';
+                    return `${hierarchyInfo}${lineInfo}
 ${codeChunk}`;
                 }).join('\n' + '─'.repeat(5) + '\n');
                 const snippetInfo = deduplicatedResults.length > 1 ? ` | ${deduplicatedResults.length} snippets` : '';
@@ -139838,7 +140195,7 @@ Note: Configuration changes will apply to subsequent searches.
         <h1>🔍 Codebase MCP Server</h1>
         <p>Status: <strong style="color: green;">Running</strong></p>
         <p>Workspace: <code>${this.codeIndexManager.workspacePathValue}</code></p>
-        
+
         <h2>Endpoints</h2>
         <ul>
             <li><code>GET /sse</code> - SSE connection endpoint</li>