@mhalder/qdrant-mcp-server 2.1.1 → 2.1.2

package/tests/code/integration.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,
@@ -37,10 +37,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);
   }
 
@@ -48,7 +54,7 @@ class MockQdrantManager implements Partial<QdrantManager> {
     collectionName: string,
     _vector: number[],
     limit: number,
-    filter?: any
+    filter?: any,
   ): Promise<any[]> {
     const points = this.points.get(collectionName) || [];
     let filtered = points;
@@ -57,7 +63,9 @@ class MockQdrantManager implements Partial<QdrantManager> {
     if (filter?.must) {
       for (const condition of filter.must) {
         if (condition.key === "fileExtension") {
-          filtered = filtered.filter((p) => condition.match.any.includes(p.payload.fileExtension));
+          filtered = filtered.filter((p) =>
+            condition.match.any.includes(p.payload.fileExtension),
+          );
         }
       }
     }
@@ -74,7 +82,7 @@ class MockQdrantManager implements Partial<QdrantManager> {
     vector: number[],
     _sparseVector: any,
     limit: number,
-    filter?: any
+    filter?: any,
   ): Promise<any[]> {
     // Hybrid search returns similar results with slight boost
     const results = await this.search(collectionName, vector, limit, filter);
@@ -90,6 +98,21 @@ 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,
+    };
+  }
 }
 
 class MockEmbeddingProvider implements EmbeddingProvider {
@@ -97,14 +120,24 @@ class MockEmbeddingProvider implements EmbeddingProvider {
     return 384;
   }
 
-  async embed(text: string): Promise<{ embedding: number[] }> {
+  getModel(): string {
+    return "mock-model";
+  }
+
+  async embed(
+    text: string,
+  ): Promise<{ embedding: number[]; dimensions: number }> {
     // Simple hash-based mock embedding
-    const hash = text.split("").reduce((acc, char) => acc + char.charCodeAt(0), 0);
+    const hash = text
+      .split("")
+      .reduce((acc, char) => acc + char.charCodeAt(0), 0);
     const base = (hash % 100) / 100;
-    return { embedding: new Array(384).fill(base) };
+    return { embedding: new Array(384).fill(base), dimensions: 384 };
   }
 
-  async embedBatch(texts: string[]): Promise<Array<{ embedding: number[] }>> {
+  async embedBatch(
+    texts: string[],
+  ): Promise<Array<{ embedding: number[]; dimensions: number }>> {
     return Promise.all(texts.map((text) => this.embed(text)));
   }
 }
@@ -120,7 +153,7 @@ describe("CodeIndexer Integration Tests", () => {
   beforeEach(async () => {
     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 });
@@ -161,7 +194,7 @@ export class AuthService {
     return { token: 'jwt-token' };
   }
 }
-      `
+      `,
       );
 
       await createTestFile(
@@ -173,7 +206,7 @@ export class RegistrationService {
     return { id: '123', email: user.email };
   }
 }
-      `
+      `,
       );
 
       await createTestFile(
@@ -183,7 +216,7 @@ export class RegistrationService {
 export function validateEmail(email: string): boolean {
   return /^[^@]+@[^@]+\\.[^@]+$/.test(email);
 }
-      `
+      `,
       );
 
       // Index the codebase
@@ -195,7 +228,10 @@ export function validateEmail(email: string): boolean {
       expect(indexStats.status).toBe("completed");
 
       // Search for authentication-related code
-      const authResults = await indexer.searchCode(codebaseDir, "authentication login");
+      const authResults = await indexer.searchCode(
+        codebaseDir,
+        "authentication login",
+      );
 
       expect(authResults.length).toBeGreaterThan(0);
       expect(authResults[0].language).toBe("typescript");
@@ -215,7 +251,7 @@ export function validateEmail(email: string): boolean {
 import express from 'express';
 const app = express();
 app.listen(3000);
-      `
+      `,
       );
 
       await createTestFile(
@@ -224,7 +260,7 @@ app.listen(3000);
         `
 const API_URL = 'http://localhost:3000';
 fetch(API_URL).then(res => res.json());
-      `
+      `,
       );
 
       await createTestFile(
@@ -233,7 +269,7 @@ fetch(API_URL).then(res => res.json());
         `
 def process_data(data):
     return [x * 2 for x in data]
-      `
+      `,
       );
 
       const stats = await indexer.indexCodebase(codebaseDir);
@@ -259,7 +295,7 @@ console.log('First file loaded successfully');
 function init(): string {
   console.log('Initializing system');
   return 'ready';
-}`
+}`,
       );
       await createTestFile(
         codebaseDir,
@@ -269,7 +305,7 @@ console.log('Second file loaded successfully');
 function start(): string {
   console.log('Starting application');
   return 'started';
-}`
+}`,
       );
 
       const initialStats = await indexer.indexCodebase(codebaseDir);
@@ -291,7 +327,7 @@ export function process(): string {
   return status;
 }
 
-export const thirdValue = 3;`
+export const thirdValue = 3;`,
       );
 
       // Incremental update
@@ -310,7 +346,7 @@ export const thirdValue = 3;`
       await createTestFile(
         codebaseDir,
         "config.ts",
-        "export const DEBUG_MODE = false;\nconsole.log('Debug mode off');"
+        "export const DEBUG_MODE = false;\nconsole.log('Debug mode off');",
       );
 
       await indexer.indexCodebase(codebaseDir);
@@ -319,7 +355,7 @@ export const thirdValue = 3;`
       await createTestFile(
         codebaseDir,
         "config.ts",
-        "export const DEBUG_MODE = true;\nconsole.log('Debug mode on');"
+        "export const DEBUG_MODE = true;\nconsole.log('Debug mode on');",
       );
 
       const updateStats = await indexer.reindexChanges(codebaseDir);
@@ -332,12 +368,12 @@ export const thirdValue = 3;`
       await createTestFile(
         codebaseDir,
         "temp.ts",
-        "export const tempValue = true;\nconsole.log('Temporary file created');\nfunction cleanup() { return null; }"
+        "export const tempValue = true;\nconsole.log('Temporary file created');\nfunction cleanup() { return null; }",
       );
       await createTestFile(
         codebaseDir,
         "keep.ts",
-        "export const keepValue = true;\nconsole.log('Permanent file stays');\nfunction maintain() { return true; }"
+        "export const keepValue = true;\nconsole.log('Permanent file stays');\nfunction maintain() { return true; }",
       );
 
       await indexer.indexCodebase(codebaseDir);
@@ -356,17 +392,17 @@ export const thirdValue = 3;`
       await createTestFile(
         codebaseDir,
         "file1.ts",
-        "export const alpha = 1;\nconsole.log('Alpha file');"
+        "export const alpha = 1;\nconsole.log('Alpha file');",
       );
       await createTestFile(
         codebaseDir,
         "file2.ts",
-        "export const beta = 2;\nconsole.log('Beta file');"
+        "export const beta = 2;\nconsole.log('Beta file');",
       );
       await createTestFile(
         codebaseDir,
         "file3.ts",
-        "export const gamma = 3;\nconsole.log('Gamma file');"
+        "export const gamma = 3;\nconsole.log('Gamma file');",
       );
 
       await indexer.indexCodebase(codebaseDir);
@@ -375,12 +411,12 @@ export const thirdValue = 3;`
       await createTestFile(
         codebaseDir,
         "file1.ts",
-        "export const alpha = 100;\nconsole.log('Alpha modified');"
+        "export const alpha = 100;\nconsole.log('Alpha modified');",
       ); // Modified
       await createTestFile(
         codebaseDir,
         "file4.ts",
-        "export const delta = 4;\nconsole.log('Delta file added');"
+        "export const delta = 4;\nconsole.log('Delta file added');",
       ); // Added
       await fs.unlink(join(codebaseDir, "file3.ts")); // Deleted
 
@@ -394,9 +430,21 @@ export const thirdValue = 3;`
 
   describe("Search filtering and options", () => {
     beforeEach(async () => {
-      await createTestFile(codebaseDir, "users.ts", "export class UserService {}");
-      await createTestFile(codebaseDir, "auth.ts", "export class AuthService {}");
-      await createTestFile(codebaseDir, "utils.js", "export function helper() {}");
+      await createTestFile(
+        codebaseDir,
+        "users.ts",
+        "export class UserService {}",
+      );
+      await createTestFile(
+        codebaseDir,
+        "auth.ts",
+        "export class AuthService {}",
+      );
+      await createTestFile(
+        codebaseDir,
+        "utils.js",
+        "export function helper() {}",
+      );
       await createTestFile(codebaseDir, "data.py", "class DataProcessor: pass");
 
       await indexer.indexCodebase(codebaseDir);
@@ -431,7 +479,11 @@ export const thirdValue = 3;`
     });
 
     it("should support path pattern filtering", async () => {
-      await createTestFile(codebaseDir, "src/api/endpoints.ts", "export const API = {}");
+      await createTestFile(
+        codebaseDir,
+        "src/api/endpoints.ts",
+        "export const API = {}",
+      );
       await indexer.indexCodebase(codebaseDir, { forceReindex: true });
 
       const results = await indexer.searchCode(codebaseDir, "export", {
@@ -445,24 +497,35 @@ export const thirdValue = 3;`
   describe("Hybrid search workflow", () => {
     it("should enable and use hybrid search", 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,
         "search.ts",
-        "function performSearch(query: string) { return results; }"
+        "function performSearch(query: string) { return results; }",
       );
 
       await hybridIndexer.indexCodebase(codebaseDir);
 
-      const results = await hybridIndexer.searchCode(codebaseDir, "search query");
+      const results = await hybridIndexer.searchCode(
+        codebaseDir,
+        "search query",
+      );
 
       expect(results.length).toBeGreaterThan(0);
     });
 
     it("should fallback to standard search if hybrid not available", async () => {
       const hybridConfig = { ...config, enableHybridSearch: true };
-      const hybridIndexer = new CodeIndexer(qdrant as any, embeddings, hybridConfig);
+      const hybridIndexer = new CodeIndexer(
+        qdrant as any,
+        embeddings,
+        hybridConfig,
+      );
 
       // Index without hybrid
       await createTestFile(
@@ -473,7 +536,7 @@ console.log('Test value configured successfully');
 function validate(): boolean {
   console.log('Validating test value');
   return testValue === true;
-}`
+}`,
       );
       await indexer.indexCodebase(codebaseDir);
 
@@ -491,7 +554,7 @@ function validate(): boolean {
         await createTestFile(
           codebaseDir,
           `module${i}.ts`,
-          `export function func${i}() { return ${i}; }`
+          `export function func${i}() { return ${i}; }`,
         );
       }
 
@@ -521,12 +584,12 @@ function validate(): boolean {
       await createTestFile(
         codebaseDir,
         "valid.ts",
-        "export const validValue = true;\nconsole.log('Valid file');"
+        "export const validValue = true;\nconsole.log('Valid file');",
       );
       await createTestFile(
         codebaseDir,
         "secrets.ts",
-        'export const apiKey = "sk_test_FAKE_KEY_FOR_TESTING_NOT_REAL_KEY";\nconsole.log("Secrets file");'
+        'export const apiKey = "sk_test_FAKE_KEY_FOR_TESTING_NOT_REAL_KEY";\nconsole.log("Secrets file");',
       );
 
       const stats = await indexer.indexCodebase(codebaseDir);
@@ -541,14 +604,16 @@ function validate(): boolean {
       await createTestFile(
         codebaseDir,
         "test.ts",
-        "export const testData = true;\nconsole.log('Test data loaded');"
+        "export const testData = true;\nconsole.log('Test data loaded');",
       );
 
       const stats1 = await indexer.indexCodebase(codebaseDir);
       expect(stats1.status).toBe("completed");
 
       // Force re-index
-      const stats2 = await indexer.indexCodebase(codebaseDir, { forceReindex: true });
+      const stats2 = await indexer.indexCodebase(codebaseDir, {
+        forceReindex: true,
+      });
       expect(stats2.status).toBe("completed");
     });
   });
@@ -561,11 +626,13 @@ function validate(): boolean {
 
       let status = await indexer.getIndexStatus(codebaseDir);
       expect(status.isIndexed).toBe(true);
+      expect(status.status).toBe("indexed");
 
       await indexer.clearIndex(codebaseDir);
 
       status = await indexer.getIndexStatus(codebaseDir);
       expect(status.isIndexed).toBe(false);
+      expect(status.status).toBe("not_indexed");
 
       // Re-index
       const stats = await indexer.indexCodebase(codebaseDir);
@@ -573,6 +640,120 @@ function validate(): boolean {
 
       status = await indexer.getIndexStatus(codebaseDir);
       expect(status.isIndexed).toBe(true);
+      expect(status.status).toBe("indexed");
+    });
+  });
+
+  describe("Index status states", () => {
+    it("should transition through all status states during indexing lifecycle", async () => {
+      // Initial state: not_indexed
+      let status = await indexer.getIndexStatus(codebaseDir);
+      expect(status.status).toBe("not_indexed");
+      expect(status.isIndexed).toBe(false);
+
+      // Create files and index
+      for (let i = 0; i < 3; i++) {
+        await createTestFile(
+          codebaseDir,
+          `component${i}.ts`,
+          `export class Component${i} {\n  private value = ${i};\n  render() {\n    console.log('Rendering component ${i}');\n    return this.value;\n  }\n}`,
+        );
+      }
+
+      // Track status during indexing
+      let sawIndexingStatus = false;
+      await indexer.indexCodebase(codebaseDir, undefined, async (progress) => {
+        if (progress.phase === "embedding" && !sawIndexingStatus) {
+          const midStatus = await indexer.getIndexStatus(codebaseDir);
+          if (midStatus.status === "indexing") {
+            sawIndexingStatus = true;
+          }
+        }
+      });
+
+      // Final state: indexed
+      status = await indexer.getIndexStatus(codebaseDir);
+      expect(status.status).toBe("indexed");
+      expect(status.isIndexed).toBe(true);
+      expect(status.collectionName).toBeDefined();
+      expect(status.chunksCount).toBeGreaterThanOrEqual(0);
+    });
+
+    it("should include lastUpdated timestamp in indexed status", async () => {
+      await createTestFile(
+        codebaseDir,
+        "timestamped.ts",
+        "export const timestamp = Date.now();\nconsole.log('Timestamp test');\nfunction getTime() { return timestamp; }",
+      );
+
+      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 correctly count chunks excluding metadata point", async () => {
+      // Create several files to generate multiple chunks
+      for (let i = 0; i < 5; i++) {
+        await createTestFile(
+          codebaseDir,
+          `service${i}.ts`,
+          `export class Service${i} {\n  async process(input: string): Promise<string> {\n    console.log('Processing in service ${i}:', input);\n    const result = input.toUpperCase();\n    return result;\n  }\n  async validate(data: any): Promise<boolean> {\n    console.log('Validating in service ${i}');\n    return data !== null;\n  }\n}`,
+        );
+      }
+
+      const stats = await indexer.indexCodebase(codebaseDir);
+      const status = await indexer.getIndexStatus(codebaseDir);
+
+      // The chunks count in status should match what was indexed
+      // Note: The actual count depends on chunking algorithm, but should be consistent
+      expect(status.chunksCount).toBeDefined();
+      expect(typeof status.chunksCount).toBe("number");
+      // chunksCount should be close to chunksCreated (accounting for metadata point)
+      expect(status.chunksCount).toBeGreaterThanOrEqual(0);
+    });
+
+    it("should maintain indexed status after force reindex", async () => {
+      await createTestFile(
+        codebaseDir,
+        "reindexable.ts",
+        "export const version = 1;\nconsole.log('Version:', version);\nfunction getVersion() { return version; }",
+      );
+
+      // Initial index
+      await indexer.indexCodebase(codebaseDir);
+      let status = await indexer.getIndexStatus(codebaseDir);
+      expect(status.status).toBe("indexed");
+      const firstTimestamp = status.lastUpdated;
+
+      // Wait to ensure different timestamp
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      // Force reindex
+      await indexer.indexCodebase(codebaseDir, { forceReindex: true });
+      status = await indexer.getIndexStatus(codebaseDir);
+
+      expect(status.status).toBe("indexed");
+      expect(status.isIndexed).toBe(true);
+      expect(status.lastUpdated).toBeDefined();
+
+      // Timestamp should be updated
+      if (firstTimestamp && status.lastUpdated) {
+        expect(status.lastUpdated.getTime()).toBeGreaterThanOrEqual(
+          firstTimestamp.getTime(),
+        );
+      }
     });
   });
 
@@ -582,7 +763,7 @@ function validate(): boolean {
         await createTestFile(
           codebaseDir,
           `file${i}.ts`,
-          `export const value${i} = ${i};\nconsole.log('File ${i} loaded successfully');\nfunction process${i}() { return value${i} * 2; }`
+          `export const value${i} = ${i};\nconsole.log('File ${i} loaded successfully');\nfunction process${i}() { return value${i} * 2; }`,
         );
       }
 
@@ -603,14 +784,14 @@ function validate(): boolean {
       await createTestFile(
         codebaseDir,
         "file1.ts",
-        "export const initial = 1;\nconsole.log('Initial file');"
+        "export const initial = 1;\nconsole.log('Initial file');",
       );
       await indexer.indexCodebase(codebaseDir);
 
       await createTestFile(
         codebaseDir,
         "file2.ts",
-        "export const additional = 2;\nconsole.log('Additional file');"
+        "export const additional = 2;\nconsole.log('Additional file');",
       );
 
       const progressUpdates: string[] = [];
@@ -627,13 +808,17 @@ function validate(): boolean {
   describe("Hybrid search with incremental updates", () => {
     it("should use hybrid search during reindexChanges", async () => {
       const hybridConfig = { ...config, enableHybridSearch: true };
-      const hybridIndexer = new CodeIndexer(qdrant as any, embeddings, hybridConfig);
+      const hybridIndexer = new CodeIndexer(
+        qdrant as any,
+        embeddings,
+        hybridConfig,
+      );
 
       // Initial indexing with hybrid search
       await createTestFile(
         codebaseDir,
         "initial.ts",
-        "export const initial = 1;\nconsole.log('Initial file');"
+        "export const initial = 1;\nconsole.log('Initial file');",
       );
       await hybridIndexer.indexCodebase(codebaseDir);
 
@@ -657,7 +842,7 @@ export class DataProcessor {
   process(input: string): string {
     return input.trim();
   }
-}`
+}`,
       );
 
       // Reindex with hybrid search - this should cover lines 540-545
@@ -674,7 +859,7 @@ export class DataProcessor {
       await createTestFile(
         codebaseDir,
         "file1.ts",
-        "export const value = 1;\nconsole.log('File 1');"
+        "export const value = 1;\nconsole.log('File 1');",
       );
       await indexer.indexCodebase(codebaseDir);
 
@@ -682,7 +867,7 @@ export class DataProcessor {
       await createTestFile(
         codebaseDir,
         "file2.ts",
-        "export const value2 = 2;\nconsole.log('File 2');"
+        "export const value2 = 2;\nconsole.log('File 2');",
       );
 
       // This should not throw even if there are processing errors
@@ -699,7 +884,7 @@ export class DataProcessor {
 async function createTestFile(
   baseDir: string,
   relativePath: string,
-  content: string
+  content: string,
 ): Promise<void> {
   const fullPath = join(baseDir, relativePath);
   const dir = join(fullPath, "..");