@mhalder/qdrant-mcp-server 2.1.1 → 2.2.0

package/tests/code/indexer.test.ts

@@ -19,8 +19,8 @@ class MockQdrantManager implements Partial<QdrantManager> {
   async createCollection(
     name: string,
     _vectorSize: number,
-    _distance: string,
-    _enableHybrid?: boolean
+    _distance: "Cosine" | "Euclid" | "Dot" = "Cosine",
+    _enableHybrid?: boolean,
   ): Promise<void> {
     this.collections.set(name, {
       vectorSize: _vectorSize,
@@ -36,10 +36,16 @@ class MockQdrantManager implements Partial<QdrantManager> {
 
   async addPoints(collectionName: string, points: any[]): Promise<void> {
     const existing = this.points.get(collectionName) || [];
-    this.points.set(collectionName, [...existing, ...points]);
+    // Upsert: remove existing points with same ID, then add new ones
+    const newIds = new Set(points.map((p) => p.id));
+    const filtered = existing.filter((p) => !newIds.has(p.id));
+    this.points.set(collectionName, [...filtered, ...points]);
   }
 
-  async addPointsWithSparse(collectionName: string, points: any[]): Promise<void> {
+  async addPointsWithSparse(
+    collectionName: string,
+    points: any[],
+  ): Promise<void> {
     await this.addPoints(collectionName, points);
   }
 
@@ -47,7 +53,7 @@ class MockQdrantManager implements Partial<QdrantManager> {
     collectionName: string,
     _vector: number[],
     limit: number,
-    _filter?: any
+    _filter?: any,
   ): Promise<any[]> {
     const points = this.points.get(collectionName) || [];
     return points.slice(0, limit).map((p, idx) => ({
@@ -62,7 +68,7 @@ class MockQdrantManager implements Partial<QdrantManager> {
     _vector: number[],
     _sparseVector: any,
     limit: number,
-    _filter?: any
+    _filter?: any,
   ): Promise<any[]> {
     return this.search(collectionName, _vector, limit, _filter);
   }
@@ -76,6 +82,35 @@ class MockQdrantManager implements Partial<QdrantManager> {
       vectorSize: collection?.vectorSize || 384,
     };
   }
+
+  async getPoint(
+    collectionName: string,
+    id: string | number,
+  ): Promise<{ id: string | number; payload?: Record<string, any> } | null> {
+    const points = this.points.get(collectionName) || [];
+    const point = points.find((p) => p.id === id);
+    if (!point) {
+      return null;
+    }
+    return {
+      id: point.id,
+      payload: point.payload,
+    };
+  }
+
+  async deletePointsByFilter(
+    collectionName: string,
+    filter: Record<string, any>,
+  ): Promise<void> {
+    const points = this.points.get(collectionName) || [];
+    const pathToDelete = filter?.must?.[0]?.match?.value;
+    if (pathToDelete) {
+      const filtered = points.filter(
+        (p) => p.payload?.relativePath !== pathToDelete,
+      );
+      this.points.set(collectionName, filtered);
+    }
+  }
 }
 
 class MockEmbeddingProvider implements EmbeddingProvider {
@@ -83,12 +118,23 @@ class MockEmbeddingProvider implements EmbeddingProvider {
     return 384;
   }
 
-  async embed(_text: string): Promise<{ embedding: number[] }> {
-    return { embedding: new Array(384).fill(0.1) };
+  getModel(): string {
+    return "mock-model";
   }
 
-  async embedBatch(texts: string[]): Promise<Array<{ embedding: number[] }>> {
-    return texts.map(() => ({ embedding: new Array(384).fill(0.1) }));
+  async embed(
+    _text: string,
+  ): Promise<{ embedding: number[]; dimensions: number }> {
+    return { embedding: new Array(384).fill(0.1), dimensions: 384 };
+  }
+
+  async embedBatch(
+    texts: string[],
+  ): Promise<Array<{ embedding: number[]; dimensions: number }>> {
+    return texts.map(() => ({
+      embedding: new Array(384).fill(0.1),
+      dimensions: 384,
+    }));
   }
 }
 
@@ -104,7 +150,7 @@ describe("CodeIndexer", () => {
     // Create temporary test directory
     tempDir = join(
       tmpdir(),
-      `qdrant-mcp-test-${Date.now()}-${Math.random().toString(36).substring(7)}`
+      `qdrant-mcp-test-${Date.now()}-${Math.random().toString(36).substring(7)}`,
     );
     codebaseDir = join(tempDir, "codebase");
     await fs.mkdir(codebaseDir, { recursive: true });
@@ -139,7 +185,7 @@ describe("CodeIndexer", () => {
       await createTestFile(
         codebaseDir,
         "hello.ts",
-        'export function hello(name: string): string {\n  console.log("Greeting user");\n  return `Hello, ${name}!`;\n}'
+        'export function hello(name: string): string {\n  console.log("Greeting user");\n  return `Hello, ${name}!`;\n}',
       );
 
       const stats = await indexer.indexCodebase(codebaseDir);
@@ -173,7 +219,7 @@ describe("CodeIndexer", () => {
       await createTestFile(
         codebaseDir,
         "test.ts",
-        "export const configuration = {\n  apiKey: process.env.API_KEY,\n  timeout: 5000\n};"
+        "export const configuration = {\n  apiKey: process.env.API_KEY,\n  timeout: 5000\n};",
       );
 
       const createCollectionSpy = vi.spyOn(qdrant, "createCollection");
@@ -184,7 +230,7 @@ describe("CodeIndexer", () => {
         expect.stringContaining("code_"),
         384,
         "Cosine",
-        false
+        false,
       );
     });
 
@@ -192,7 +238,7 @@ describe("CodeIndexer", () => {
       await createTestFile(
         codebaseDir,
         "test.ts",
-        "export function calculateTotal(items: number[]): number {\n  return items.reduce((sum, item) => sum + item, 0);\n}"
+        "export function calculateTotal(items: number[]): number {\n  return items.reduce((sum, item) => sum + item, 0);\n}",
       );
 
       await indexer.indexCodebase(codebaseDir);
@@ -207,7 +253,7 @@ describe("CodeIndexer", () => {
       await createTestFile(
         codebaseDir,
         "test.ts",
-        "export interface User {\n  id: string;\n  name: string;\n  email: string;\n}"
+        "export interface User {\n  id: string;\n  name: string;\n  email: string;\n}",
       );
 
       const progressCallback = vi.fn();
@@ -215,8 +261,16 @@ describe("CodeIndexer", () => {
       await indexer.indexCodebase(codebaseDir, undefined, progressCallback);
 
       expect(progressCallback).toHaveBeenCalled();
-      expect(progressCallback.mock.calls.some((call) => call[0].phase === "scanning")).toBe(true);
-      expect(progressCallback.mock.calls.some((call) => call[0].phase === "chunking")).toBe(true);
+      expect(
+        progressCallback.mock.calls.some(
+          (call) => call[0].phase === "scanning",
+        ),
+      ).toBe(true);
+      expect(
+        progressCallback.mock.calls.some(
+          (call) => call[0].phase === "chunking",
+        ),
+      ).toBe(true);
     });
 
     it("should respect custom extensions", async () => {
@@ -234,7 +288,7 @@ describe("CodeIndexer", () => {
       await createTestFile(
         codebaseDir,
         "secrets.ts",
-        'const apiKey = "sk_test_FAKE_KEY_FOR_TESTING_ONLY_NOT_REAL";'
+        'const apiKey = "sk_test_FAKE_KEY_FOR_TESTING_ONLY_NOT_REAL";',
       );
 
       const stats = await indexer.indexCodebase(codebaseDir);
@@ -245,12 +299,16 @@ describe("CodeIndexer", () => {
 
     it("should enable hybrid search when configured", async () => {
       const hybridConfig = { ...config, enableHybridSearch: true };
-      const hybridIndexer = new CodeIndexer(qdrant as any, embeddings, hybridConfig);
+      const hybridIndexer = new CodeIndexer(
+        qdrant as any,
+        embeddings,
+        hybridConfig,
+      );
 
       await createTestFile(
         codebaseDir,
         "test.ts",
-        "export class DataService {\n  async fetchData(): Promise<any[]> {\n    return [];\n  }\n}"
+        "export class DataService {\n  async fetchData(): Promise<any[]> {\n    return [];\n  }\n}",
       );
 
       const createCollectionSpy = vi.spyOn(qdrant, "createCollection");
@@ -261,7 +319,7 @@ describe("CodeIndexer", () => {
         expect.stringContaining("code_"),
         384,
         "Cosine",
-        true
+        true,
       );
     });
 
@@ -270,16 +328,20 @@ describe("CodeIndexer", () => {
 
       // Mock fs.readFile to throw error for this specific file
       const originalReadFile = fs.readFile;
-      vi.spyOn(fs, "readFile").mockImplementation(async (path: any, ...args: any[]) => {
-        if (path.includes("test.ts")) {
-          throw new Error("Permission denied");
-        }
-        return originalReadFile(path, ...args);
-      });
+      vi.spyOn(fs, "readFile").mockImplementation(
+        async (path: any, ...args: any[]) => {
+          if (path.includes("test.ts")) {
+            throw new Error("Permission denied");
+          }
+          return originalReadFile(path, ...args);
+        },
+      );
 
       const stats = await indexer.indexCodebase(codebaseDir);
 
-      expect(stats.errors?.some((e) => e.includes("Permission denied"))).toBe(true);
+      expect(stats.errors?.some((e) => e.includes("Permission denied"))).toBe(
+        true,
+      );
 
       vi.restoreAllMocks();
     });
@@ -290,7 +352,7 @@ describe("CodeIndexer", () => {
         await createTestFile(
           codebaseDir,
           `file${i}.ts`,
-          `export function test${i}() {\n  console.log('Test function ${i}');\n  return ${i};\n}`
+          `export function test${i}() {\n  console.log('Test function ${i}');\n  return ${i};\n}`,
         );
       }
 
@@ -307,7 +369,7 @@ describe("CodeIndexer", () => {
       await createTestFile(
         codebaseDir,
         "test.ts",
-        "export function hello(name: string): string {\n  const greeting = `Hello, ${name}!`;\n  return greeting;\n}"
+        "export function hello(name: string): string {\n  const greeting = `Hello, ${name}!`;\n  return greeting;\n}",
       );
       await indexer.indexCodebase(codebaseDir);
     });
@@ -323,11 +385,15 @@ describe("CodeIndexer", () => {
       const nonIndexedDir = join(tempDir, "non-indexed");
       await fs.mkdir(nonIndexedDir, { recursive: true });
 
-      await expect(indexer.searchCode(nonIndexedDir, "test")).rejects.toThrow("not indexed");
+      await expect(indexer.searchCode(nonIndexedDir, "test")).rejects.toThrow(
+        "not indexed",
+      );
     });
 
     it("should respect limit option", async () => {
-      const results = await indexer.searchCode(codebaseDir, "test", { limit: 2 });
+      const results = await indexer.searchCode(codebaseDir, "test", {
+        limit: 2,
+      });
 
       expect(results.length).toBeLessThanOrEqual(2);
     });
@@ -356,7 +422,11 @@ describe("CodeIndexer", () => {
 
     it("should use hybrid search when enabled", async () => {
       const hybridConfig = { ...config, enableHybridSearch: true };
-      const hybridIndexer = new CodeIndexer(qdrant as any, embeddings, hybridConfig);
+      const hybridIndexer = new CodeIndexer(
+        qdrant as any,
+        embeddings,
+        hybridConfig,
+      );
 
       await createTestFile(
         codebaseDir,
@@ -373,7 +443,7 @@ function performValidation(): boolean {
 }
 function checkStatus(): boolean {
   return true;
-}`
+}`,
       );
       // Force reindex to recreate collection with hybrid search enabled
       await hybridIndexer.indexCodebase(codebaseDir, { forceReindex: true });
@@ -400,31 +470,287 @@ function checkStatus(): boolean {
   });
 
   describe("getIndexStatus", () => {
-    it("should return not indexed for new codebase", async () => {
-      const status = await indexer.getIndexStatus(codebaseDir);
+    describe("not_indexed status", () => {
+      it("should return not_indexed for new codebase with no collection", async () => {
+        const status = await indexer.getIndexStatus(codebaseDir);
+
+        expect(status.isIndexed).toBe(false);
+        expect(status.status).toBe("not_indexed");
+        expect(status.collectionName).toBeUndefined();
+        expect(status.chunksCount).toBeUndefined();
+      });
 
-      expect(status.isIndexed).toBe(false);
+      it("should return not_indexed when collection exists but has no chunks and no completion marker", async () => {
+        // Create an empty directory with no supported files
+        const emptyDir = join(tempDir, "empty-codebase");
+        await fs.mkdir(emptyDir, { recursive: true });
+        // Create a non-supported file
+        await fs.writeFile(join(emptyDir, "readme.md"), "# README");
+
+        const stats = await indexer.indexCodebase(emptyDir);
+
+        // No files to index means no collection is created
+        expect(stats.filesScanned).toBe(0);
+
+        const status = await indexer.getIndexStatus(emptyDir);
+        expect(status.status).toBe("not_indexed");
+        expect(status.isIndexed).toBe(false);
+      });
     });
 
-    it("should return indexed status after indexing", async () => {
-      await createTestFile(
-        codebaseDir,
-        "test.ts",
-        "export const APP_CONFIG = {\n  port: 3000,\n  host: 'localhost',\n  debug: true,\n  apiUrl: 'https://api.example.com',\n  timeout: 5000\n};\nconsole.log('Config loaded');"
-      );
-      await indexer.indexCodebase(codebaseDir);
+    describe("indexed status", () => {
+      it("should return indexed status after successful indexing", async () => {
+        await createTestFile(
+          codebaseDir,
+          "test.ts",
+          "export const APP_CONFIG = {\n  port: 3000,\n  host: 'localhost',\n  debug: true,\n  apiUrl: 'https://api.example.com',\n  timeout: 5000\n};\nconsole.log('Config loaded');",
+        );
+        await indexer.indexCodebase(codebaseDir);
 
-      const status = await indexer.getIndexStatus(codebaseDir);
+        const status = await indexer.getIndexStatus(codebaseDir);
+
+        expect(status.isIndexed).toBe(true);
+        expect(status.status).toBe("indexed");
+        expect(status.collectionName).toBeDefined();
+        expect(status.chunksCount).toBeGreaterThan(0);
+      });
+
+      it("should include lastUpdated timestamp after indexing", async () => {
+        await createTestFile(
+          codebaseDir,
+          "test.ts",
+          "export const value = 1;\nconsole.log('Testing timestamp');\nfunction test() { return value; }",
+        );
+
+        const beforeIndexing = new Date();
+        await indexer.indexCodebase(codebaseDir);
+        const afterIndexing = new Date();
+
+        const status = await indexer.getIndexStatus(codebaseDir);
+
+        expect(status.status).toBe("indexed");
+        expect(status.lastUpdated).toBeDefined();
+        expect(status.lastUpdated).toBeInstanceOf(Date);
+        expect(status.lastUpdated!.getTime()).toBeGreaterThanOrEqual(
+          beforeIndexing.getTime(),
+        );
+        expect(status.lastUpdated!.getTime()).toBeLessThanOrEqual(
+          afterIndexing.getTime(),
+        );
+      });
+
+      it("should return correct chunks count excluding metadata point", async () => {
+        await createTestFile(
+          codebaseDir,
+          "test.ts",
+          "export const a = 1;\nexport const b = 2;\nconsole.log('File with content');\nfunction helper() { return a + b; }",
+        );
+        await indexer.indexCodebase(codebaseDir);
+
+        const status = await indexer.getIndexStatus(codebaseDir);
+
+        // Chunks count should not include the metadata point
+        expect(status.chunksCount).toBeGreaterThanOrEqual(0);
+        // The actual count depends on chunking, but it should be consistent
+        expect(typeof status.chunksCount).toBe("number");
+      });
+    });
+
+    describe("completion marker", () => {
+      it("should store completion marker when indexing completes", async () => {
+        await createTestFile(
+          codebaseDir,
+          "test.ts",
+          "export const data = { key: 'value' };\nconsole.log('Completion marker test');\nfunction process() { return data; }",
+        );
+        await indexer.indexCodebase(codebaseDir);
+
+        // Verify status is indexed (which means completion marker exists)
+        const status = await indexer.getIndexStatus(codebaseDir);
+        expect(status.status).toBe("indexed");
+        expect(status.isIndexed).toBe(true);
+      });
+
+      it("should store completion marker even when no chunks are created", async () => {
+        // Create a file that might produce no chunks (very small)
+        await createTestFile(codebaseDir, "tiny.ts", "const x = 1;");
+
+        await indexer.indexCodebase(codebaseDir);
+
+        const status = await indexer.getIndexStatus(codebaseDir);
+
+        // Even with minimal content, should be marked as indexed
+        expect(status.status).toBe("indexed");
+        expect(status.isIndexed).toBe(true);
+      });
+
+      it("should update completion marker on force reindex", async () => {
+        await createTestFile(
+          codebaseDir,
+          "test.ts",
+          "export const v1 = 'first';\nconsole.log('First indexing');\nfunction init() { return v1; }",
+        );
+
+        await indexer.indexCodebase(codebaseDir);
+        const status1 = await indexer.getIndexStatus(codebaseDir);
+
+        // Wait a tiny bit to ensure timestamp difference
+        await new Promise((resolve) => setTimeout(resolve, 10));
+
+        // Force reindex
+        await indexer.indexCodebase(codebaseDir, { forceReindex: true });
+        const status2 = await indexer.getIndexStatus(codebaseDir);
+
+        expect(status2.status).toBe("indexed");
+        // Both should have lastUpdated
+        expect(status1.lastUpdated).toBeDefined();
+        expect(status2.lastUpdated).toBeDefined();
+      });
+    });
+
+    describe("backwards compatibility", () => {
+      it("should always return isIndexed boolean for backwards compatibility", async () => {
+        // Not indexed
+        let status = await indexer.getIndexStatus(codebaseDir);
+        expect(typeof status.isIndexed).toBe("boolean");
+        expect(status.isIndexed).toBe(false);
+
+        // Indexed
+        await createTestFile(
+          codebaseDir,
+          "test.ts",
+          "export const test = true;\nconsole.log('Backwards compat test');\nfunction run() { return test; }",
+        );
+        await indexer.indexCodebase(codebaseDir);
+
+        status = await indexer.getIndexStatus(codebaseDir);
+        expect(typeof status.isIndexed).toBe("boolean");
+        expect(status.isIndexed).toBe(true);
+      });
+
+      it("should have isIndexed=true only when status=indexed", async () => {
+        await createTestFile(
+          codebaseDir,
+          "test.ts",
+          "export const consistency = 1;\nconsole.log('Consistency check');\nfunction check() { return consistency; }",
+        );
+        await indexer.indexCodebase(codebaseDir);
+
+        const status = await indexer.getIndexStatus(codebaseDir);
+
+        // isIndexed should match status
+        if (status.status === "indexed") {
+          expect(status.isIndexed).toBe(true);
+        } else {
+          expect(status.isIndexed).toBe(false);
+        }
+      });
+    });
+
+    describe("indexing in-progress status", () => {
+      it("should return indexing status during active indexing", async () => {
+        // Create multiple files to ensure indexing takes some time
+        for (let i = 0; i < 5; i++) {
+          await createTestFile(
+            codebaseDir,
+            `file${i}.ts`,
+            `export const value${i} = ${i};\nconsole.log('Processing file ${i}');\nfunction process${i}(x: number) {\n  const result = x * ${i};\n  console.log('Result:', result);\n  return result;\n}`,
+          );
+        }
+
+        let statusDuringIndexing: any = null;
+
+        // Use progress callback to check status mid-indexing
+        const indexingPromise = indexer.indexCodebase(
+          codebaseDir,
+          undefined,
+          async (progress) => {
+            // Check status during the embedding phase (when we know indexing is in progress)
+            if (
+              progress.phase === "embedding" &&
+              statusDuringIndexing === null
+            ) {
+              statusDuringIndexing = await indexer.getIndexStatus(codebaseDir);
+            }
+          },
+        );
+
+        await indexingPromise;
+
+        // Verify we captured the in-progress status
+        if (statusDuringIndexing) {
+          expect(statusDuringIndexing.status).toBe("indexing");
+          expect(statusDuringIndexing.isIndexed).toBe(false);
+          expect(statusDuringIndexing.collectionName).toBeDefined();
+        }
+
+        // After indexing completes, status should be "indexed"
+        const statusAfter = await indexer.getIndexStatus(codebaseDir);
+        expect(statusAfter.status).toBe("indexed");
+        expect(statusAfter.isIndexed).toBe(true);
+      });
+
+      it("should track chunksCount during indexing", async () => {
+        for (let i = 0; i < 3; i++) {
+          await createTestFile(
+            codebaseDir,
+            `module${i}.ts`,
+            `export class Module${i} {\n  constructor() {\n    console.log('Module ${i} initialized');\n  }\n  process(data: string): string {\n    return data.toUpperCase();\n  }\n}`,
+          );
+        }
+
+        let chunksCountDuringIndexing: number | undefined;
 
-      expect(status.isIndexed).toBe(true);
-      expect(status.collectionName).toBeDefined();
-      expect(status.chunksCount).toBeGreaterThan(0);
+        await indexer.indexCodebase(
+          codebaseDir,
+          undefined,
+          async (progress) => {
+            if (
+              progress.phase === "storing" &&
+              chunksCountDuringIndexing === undefined
+            ) {
+              const status = await indexer.getIndexStatus(codebaseDir);
+              chunksCountDuringIndexing = status.chunksCount;
+            }
+          },
+        );
+
+        // chunksCount during indexing should be a number (could be 0 or more depending on progress)
+        if (chunksCountDuringIndexing !== undefined) {
+          expect(typeof chunksCountDuringIndexing).toBe("number");
+          expect(chunksCountDuringIndexing).toBeGreaterThanOrEqual(0);
+        }
+      });
+    });
+
+    describe("legacy collection handling", () => {
+      it("should treat collection with chunks but no completion marker as indexed", async () => {
+        // Simulate a legacy collection by directly adding points without completion marker
+        // First, index normally
+        await createTestFile(
+          codebaseDir,
+          "legacy.ts",
+          "export const legacy = true;\nconsole.log('Legacy test');\nfunction legacyFn() { return legacy; }",
+        );
+        await indexer.indexCodebase(codebaseDir);
+
+        // Get initial status to get collection name
+        const initialStatus = await indexer.getIndexStatus(codebaseDir);
+        expect(initialStatus.status).toBe("indexed");
+
+        // The mock should have stored the completion marker
+        // In a real scenario, legacy collections wouldn't have this marker
+        // but they would have chunks, and the code handles this gracefully
+        expect(initialStatus.chunksCount).toBeGreaterThanOrEqual(0);
+      });
     });
   });
 
   describe("reindexChanges", () => {
     it("should throw error if not previously indexed", async () => {
-      await expect(indexer.reindexChanges(codebaseDir)).rejects.toThrow("not indexed");
+      await expect(indexer.reindexChanges(codebaseDir)).rejects.toThrow(
+        "not indexed",
+      );
     });
 
     it("should detect and index new files", async () => {
@@ -436,7 +762,7 @@ console.log('Initial file created');
 function helper(param: string): boolean {
   console.log('Processing:', param);
   return true;
-}`
+}`,
       );
       await indexer.indexCodebase(codebaseDir);
 
@@ -463,7 +789,7 @@ function helper(param: string): boolean {
           "  console.log('Valid input');",
           "  return input.length > 5;",
           "}",
-        ].join("\n")
+        ].join("\n"),
       );
 
       const stats = await indexer.reindexChanges(codebaseDir);
@@ -476,14 +802,14 @@ function helper(param: string): boolean {
       await createTestFile(
         codebaseDir,
         "test.ts",
-        "export const originalValue = 1;\nconsole.log('Original');"
+        "export const originalValue = 1;\nconsole.log('Original');",
       );
       await indexer.indexCodebase(codebaseDir);
 
       await createTestFile(
         codebaseDir,
         "test.ts",
-        "export const updatedValue = 2;\nconsole.log('Updated');"
+        "export const updatedValue = 2;\nconsole.log('Updated');",
       );
 
       const stats = await indexer.reindexChanges(codebaseDir);
@@ -495,7 +821,7 @@ function helper(param: string): boolean {
       await createTestFile(
         codebaseDir,
         "test.ts",
-        "export const toBeDeleted = 1;\nconsole.log('Will be deleted');"
+        "export const toBeDeleted = 1;\nconsole.log('Will be deleted');",
       );
       await indexer.indexCodebase(codebaseDir);
 
@@ -510,7 +836,7 @@ function helper(param: string): boolean {
       await createTestFile(
         codebaseDir,
         "test.ts",
-        "export const unchangedValue = 1;\nconsole.log('No changes');"
+        "export const unchangedValue = 1;\nconsole.log('No changes');",
       );
       await indexer.indexCodebase(codebaseDir);
 
@@ -525,14 +851,14 @@ function helper(param: string): boolean {
       await createTestFile(
         codebaseDir,
         "test.ts",
-        "export const existingValue = 1;\nconsole.log('Existing');"
+        "export const existingValue = 1;\nconsole.log('Existing');",
       );
       await indexer.indexCodebase(codebaseDir);
 
       await createTestFile(
         codebaseDir,
         "new.ts",
-        "export const newValue = 2;\nconsole.log('New file');"
+        "export const newValue = 2;\nconsole.log('New file');",
       );
 
       const progressCallback = vi.fn();
@@ -540,6 +866,113 @@ function helper(param: string): boolean {
 
       expect(progressCallback).toHaveBeenCalled();
     });
+
+    it("should delete old chunks when file is modified", async () => {
+      await createTestFile(
+        codebaseDir,
+        "test.ts",
+        "export const originalValue = 1;\nconsole.log('Original version');",
+      );
+      await indexer.indexCodebase(codebaseDir);
+
+      const deletePointsByFilterSpy = vi.spyOn(qdrant, "deletePointsByFilter");
+
+      await createTestFile(
+        codebaseDir,
+        "test.ts",
+        "export const modifiedValue = 2;\nconsole.log('Modified version');",
+      );
+
+      await indexer.reindexChanges(codebaseDir);
+
+      expect(deletePointsByFilterSpy).toHaveBeenCalledWith(
+        expect.stringContaining("code_"),
+        {
+          must: [{ key: "relativePath", match: { value: "test.ts" } }],
+        },
+      );
+    });
+
+    it("should delete all chunks when file is deleted", async () => {
+      await createTestFile(
+        codebaseDir,
+        "test.ts",
+        "export const toDelete = 1;\nconsole.log('Will be deleted');",
+      );
+      await indexer.indexCodebase(codebaseDir);
+
+      const deletePointsByFilterSpy = vi.spyOn(qdrant, "deletePointsByFilter");
+
+      await fs.unlink(join(codebaseDir, "test.ts"));
+
+      await indexer.reindexChanges(codebaseDir);
+
+      expect(deletePointsByFilterSpy).toHaveBeenCalledWith(
+        expect.stringContaining("code_"),
+        {
+          must: [{ key: "relativePath", match: { value: "test.ts" } }],
+        },
+      );
+    });
+
+    it("should not affect chunks from unchanged files", async () => {
+      await createTestFile(
+        codebaseDir,
+        "unchanged.ts",
+        "export const unchanged = 1;\nconsole.log('Unchanged');",
+      );
+      await createTestFile(
+        codebaseDir,
+        "changed.ts",
+        "export const original = 2;\nconsole.log('Original');",
+      );
+      await indexer.indexCodebase(codebaseDir);
+
+      const deletePointsByFilterSpy = vi.spyOn(qdrant, "deletePointsByFilter");
+
+      await createTestFile(
+        codebaseDir,
+        "changed.ts",
+        "export const modified = 3;\nconsole.log('Modified');",
+      );
+
+      await indexer.reindexChanges(codebaseDir);
+
+      // Should only delete chunks for changed.ts, not unchanged.ts
+      expect(deletePointsByFilterSpy).toHaveBeenCalledTimes(1);
+      expect(deletePointsByFilterSpy).toHaveBeenCalledWith(
+        expect.stringContaining("code_"),
+        {
+          must: [{ key: "relativePath", match: { value: "changed.ts" } }],
+        },
+      );
+    });
+
+    it("should handle deletion errors gracefully", async () => {
+      await createTestFile(
+        codebaseDir,
+        "test.ts",
+        "export const original = 1;\nconsole.log('Original');",
+      );
+      await indexer.indexCodebase(codebaseDir);
+
+      // Mock deletePointsByFilter to throw an error
+      const deletePointsByFilterSpy = vi
+        .spyOn(qdrant, "deletePointsByFilter")
+        .mockRejectedValueOnce(new Error("Deletion failed"));
+
+      await createTestFile(
+        codebaseDir,
+        "test.ts",
+        "export const modified = 2;\nconsole.log('Modified');",
+      );
+
+      // Should not throw, should continue with reindexing
+      const stats = await indexer.reindexChanges(codebaseDir);
+
+      expect(deletePointsByFilterSpy).toHaveBeenCalled();
+      expect(stats.filesModified).toBe(1);
+    });
   });
 
   describe("path validation", () => {
@@ -568,7 +1001,7 @@ function helper(param: string): boolean {
       await createTestFile(
         codebaseDir,
         "test.ts",
-        "export const configValue = 1;\nconsole.log('Config loaded');"
+        "export const configValue = 1;\nconsole.log('Config loaded');",
       );
       await indexer.indexCodebase(codebaseDir);
 
@@ -586,7 +1019,7 @@ function helper(param: string): boolean {
       await createTestFile(
         codebaseDir,
         "test.ts",
-        "export const reindexValue = 1;\nconsole.log('Reindexing');"
+        "export const reindexValue = 1;\nconsole.log('Reindexing');",
       );
       await indexer.indexCodebase(codebaseDir);
 
@@ -599,7 +1032,9 @@ function helper(param: string): boolean {
 
   describe("edge cases", () => {
     it("should handle nested directory structures", async () => {
-      await fs.mkdir(join(codebaseDir, "src", "components"), { recursive: true });
+      await fs.mkdir(join(codebaseDir, "src", "components"), {
+        recursive: true,
+      });
       await createTestFile(
         codebaseDir,
         "src/components/Button.ts",
@@ -609,7 +1044,7 @@ function helper(param: string): boolean {
     console.log('Button clicked');
   };
   return '<button>Click me</button>';
-}`
+}`,
       );
 
       const stats = await indexer.indexCodebase(codebaseDir);
@@ -618,7 +1053,11 @@ function helper(param: string): boolean {
     });
 
     it("should handle files with unicode content", async () => {
-      await createTestFile(codebaseDir, "test.ts", "const greeting = '你好世界';");
+      await createTestFile(
+        codebaseDir,
+        "test.ts",
+        "const greeting = '你好世界';",
+      );
 
       const stats = await indexer.indexCodebase(codebaseDir);
 
@@ -671,12 +1110,19 @@ function helper(param: string): boolean {
         ...config,
         maxChunksPerFile: 2,
       };
-      const limitedIndexer = new CodeIndexer(qdrant as any, embeddings, limitedConfig);
+      const limitedIndexer = new CodeIndexer(
+        qdrant as any,
+        embeddings,
+        limitedConfig,
+      );
 
       // Create a large file that would generate many chunks
       const largeContent = Array(50)
         .fill(null)
-        .map((_, i) => `function test${i}() { console.log('test ${i}'); return ${i}; }`)
+        .map(
+          (_, i) =>
+            `function test${i}() { console.log('test ${i}'); return ${i}; }`,
+        )
         .join("\n\n");
 
       await createTestFile(codebaseDir, "large.ts", largeContent);
@@ -693,14 +1139,18 @@ function helper(param: string): boolean {
         ...config,
         maxTotalChunks: 3,
       };
-      const limitedIndexer = new CodeIndexer(qdrant as any, embeddings, limitedConfig);
+      const limitedIndexer = new CodeIndexer(
+        qdrant as any,
+        embeddings,
+        limitedConfig,
+      );
 
       // Create multiple files
       for (let i = 0; i < 10; i++) {
         await createTestFile(
           codebaseDir,
           `file${i}.ts`,
-          `export function func${i}() { console.log('function ${i}'); return ${i}; }`
+          `export function func${i}() { console.log('function ${i}'); return ${i}; }`,
         );
       }
 
@@ -716,7 +1166,11 @@ function helper(param: string): boolean {
         ...config,
         maxTotalChunks: 1,
       };
-      const limitedIndexer = new CodeIndexer(qdrant as any, embeddings, limitedConfig);
+      const limitedIndexer = new CodeIndexer(
+        qdrant as any,
+        embeddings,
+        limitedConfig,
+      );
 
       // Create a file with multiple chunks
       const content = `
@@ -751,7 +1205,7 @@ function third() {
       await createTestFile(
         codebaseDir,
         "file1.ts",
-        "export const initial = 1;\nconsole.log('Initial');"
+        "export const initial = 1;\nconsole.log('Initial');",
       );
       await indexer.indexCodebase(codebaseDir);
 
@@ -765,7 +1219,7 @@ console.log('Added file');
 export function process() {
   console.log('Processing');
   return true;
-}`
+}`,
       );
 
       const progressUpdates: string[] = [];
@@ -793,7 +1247,11 @@ export function process() {
       // @ts-expect-error - Mocking for test
       fs.readFile = async (path: any, encoding: any) => {
         callCount++;
-        if (callCount === 1 && typeof path === "string" && path.endsWith("test.ts")) {
+        if (
+          callCount === 1 &&
+          typeof path === "string" &&
+          path.endsWith("test.ts")
+        ) {
           // Throw a non-Error object
           throw "String error";
         }
@@ -805,10 +1263,11 @@ export function process() {
 
         // Should handle the error gracefully
         expect(stats.status).toBe("completed");
-        expect(stats.errors?.some((e) => e.includes("String error"))).toBe(true);
+        expect(stats.errors?.some((e) => e.includes("String error"))).toBe(
+          true,
+        );
       } finally {
         // Restore original function
-        // @ts-expect-error
         fs.readFile = originalReadFile;
       }
     });
@@ -819,7 +1278,7 @@ export function process() {
 async function createTestFile(
   baseDir: string,
   relativePath: string,
-  content: string
+  content: string,
 ): Promise<void> {
   const fullPath = join(baseDir, relativePath);
   const dir = join(fullPath, "..");