@mhalder/qdrant-mcp-server 3.2.0 → 3.3.0

package/src/git/indexer.ts

@@ -5,6 +5,7 @@
 import { createHash } from "node:crypto";
 import { promises as fs } from "node:fs";
 import { resolve } from "node:path";
+import logger from "../logger.js";
 import type { EmbeddingProvider } from "../embeddings/base.js";
 import { BM25SparseVectorGenerator } from "../embeddings/sparse.js";
 import type { QdrantManager } from "../qdrant/client.js";
@@ -25,6 +26,8 @@ import type {
 } from "./types.js";
 
 export class GitHistoryIndexer {
+  private log = logger.child({ component: "git-indexer" });
+
   constructor(
     private qdrant: QdrantManager,
     private embeddings: EmbeddingProvider,
@@ -66,6 +69,11 @@ export class GitHistoryIndexer {
     const absolutePath = await this.validatePath(path);
     const collectionName = await this.getCollectionName(absolutePath);
 
+    this.log.info(
+      { path: absolutePath, collectionName },
+      "Git indexing started",
+    );
+
     try {
       // 1. Validate repository
       const extractor = new GitExtractor(absolutePath, this.config);
@@ -119,6 +127,7 @@ export class GitHistoryIndexer {
       });
 
       stats.commitsScanned = commits.length;
+      this.log.info({ commitsExtracted: commits.length }, "Commits extracted");
 
       if (commits.length === 0) {
         await this.storeIndexingMarker(collectionName, true);
@@ -175,6 +184,10 @@ export class GitHistoryIndexer {
 
       // 5. Generate embeddings and store in batches
       const batchSize = this.config.batchSize;
+      this.log.debug(
+        { totalChunks: allChunks.length, batchSize },
+        "Starting embedding generation",
+      );
       for (let i = 0; i < allChunks.length; i += batchSize) {
         const batch = allChunks.slice(i, i + batchSize);
 
@@ -232,7 +245,9 @@ export class GitHistoryIndexer {
               const sparseGenerator = new BM25SparseVectorGenerator();
               const hybridPoints = points.map((point, idx) => ({
                 ...point,
-                sparseVector: sparseGenerator.generate(batch[idx].chunk.content),
+                sparseVector: sparseGenerator.generate(
+                  batch[idx].chunk.content,
+                ),
               }));
               await this.qdrant.addPointsWithSparse(
                 collectionName,
@@ -245,7 +260,8 @@ export class GitHistoryIndexer {
             success = true;
             break;
           } catch (error) {
-            lastError = error instanceof Error ? error : new Error(String(error));
+            lastError =
+              error instanceof Error ? error : new Error(String(error));
             if (attempt < this.config.batchRetryAttempts) {
               // Exponential backoff: 1s, 2s, 4s...
               const delay = Math.pow(2, attempt - 1) * 1000;
@@ -270,7 +286,7 @@ export class GitHistoryIndexer {
       } catch (error) {
         const errorMessage =
           error instanceof Error ? error.message : String(error);
-        console.error("Failed to save snapshot:", errorMessage);
+        this.log.error({ err: error }, "Failed to save snapshot");
         stats.errors?.push(`Snapshot save failed: ${errorMessage}`);
       }
 
@@ -278,6 +294,14 @@ export class GitHistoryIndexer {
       await this.storeIndexingMarker(collectionName, true);
 
       stats.durationMs = Date.now() - startTime;
+      this.log.info(
+        {
+          commitsIndexed: stats.commitsIndexed,
+          chunksCreated: stats.chunksCreated,
+          durationMs: stats.durationMs,
+        },
+        "Git indexing complete",
+      );
       return stats;
     } catch (error) {
       const errorMessage =
@@ -509,6 +533,7 @@ export class GitHistoryIndexer {
     });
 
     stats.newCommits = newCommits.length;
+    this.log.info({ newCommits: newCommits.length }, "New commits found");
 
     if (newCommits.length === 0) {
       stats.durationMs = Date.now() - startTime;
@@ -612,6 +637,7 @@ export class GitHistoryIndexer {
    * Clear all indexed data for a repository
    */
   async clearIndex(path: string): Promise<void> {
+    this.log.info({ path }, "Clearing git index");
     const absolutePath = await this.validatePath(path);
     const collectionName = await this.getCollectionName(absolutePath);
     const exists = await this.qdrant.collectionExists(collectionName);
@@ -670,7 +696,7 @@ export class GitHistoryIndexer {
         ]);
       }
     } catch (error) {
-      console.error("Failed to store indexing marker:", error);
+      this.log.error({ err: error }, "Failed to store indexing marker");
     }
   }
 

package/src/index.test.ts

@@ -1,190 +1,212 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-vi.mock('./qdrant/client.js');
-vi.mock('./embeddings/openai.js');
-
-describe('MCP Server Tool Schemas', () => {
-  describe('CreateCollectionSchema', () => {
-    it('should validate correct collection creation input', async () => {
-      const { z } = await import('zod');
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("./qdrant/client.js");
+vi.mock("./embeddings/openai.js");
+vi.mock("./logger.js", () => ({
+  default: {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+    fatal: vi.fn(),
+    trace: vi.fn(),
+    child: vi.fn().mockReturnThis(),
+  },
+}));
+
+describe("MCP Server Tool Schemas", () => {
+  describe("CreateCollectionSchema", () => {
+    it("should validate correct collection creation input", async () => {
+      const { z } = await import("zod");
 
       const CreateCollectionSchema = z.object({
         name: z.string(),
-        distance: z.enum(['Cosine', 'Euclid', 'Dot']).optional(),
+        distance: z.enum(["Cosine", "Euclid", "Dot"]).optional(),
       });
 
-      const validInput = { name: 'test-collection' };
+      const validInput = { name: "test-collection" };
       expect(() => CreateCollectionSchema.parse(validInput)).not.toThrow();
 
-      const validInputWithDistance = { name: 'test-collection', distance: 'Cosine' as const };
-      expect(() => CreateCollectionSchema.parse(validInputWithDistance)).not.toThrow();
+      const validInputWithDistance = {
+        name: "test-collection",
+        distance: "Cosine" as const,
+      };
+      expect(() =>
+        CreateCollectionSchema.parse(validInputWithDistance),
+      ).not.toThrow();
     });
 
-    it('should reject invalid distance metric', async () => {
-      const { z } = await import('zod');
+    it("should reject invalid distance metric", async () => {
+      const { z } = await import("zod");
 
       const CreateCollectionSchema = z.object({
         name: z.string(),
-        distance: z.enum(['Cosine', 'Euclid', 'Dot']).optional(),
+        distance: z.enum(["Cosine", "Euclid", "Dot"]).optional(),
       });
 
-      const invalidInput = { name: 'test', distance: 'Invalid' };
+      const invalidInput = { name: "test", distance: "Invalid" };
       expect(() => CreateCollectionSchema.parse(invalidInput)).toThrow();
     });
 
-    it('should require name field', async () => {
-      const { z } = await import('zod');
+    it("should require name field", async () => {
+      const { z } = await import("zod");
 
       const CreateCollectionSchema = z.object({
         name: z.string(),
-        distance: z.enum(['Cosine', 'Euclid', 'Dot']).optional(),
+        distance: z.enum(["Cosine", "Euclid", "Dot"]).optional(),
       });
 
-      const invalidInput = { distance: 'Cosine' };
+      const invalidInput = { distance: "Cosine" };
       expect(() => CreateCollectionSchema.parse(invalidInput)).toThrow();
     });
   });
 
-  describe('AddDocumentsSchema', () => {
-    it('should validate correct document addition input', async () => {
-      const { z } = await import('zod');
+  describe("AddDocumentsSchema", () => {
+    it("should validate correct document addition input", async () => {
+      const { z } = await import("zod");
 
       const AddDocumentsSchema = z.object({
         collection: z.string(),
-        documents: z.array(z.object({
-          id: z.union([z.string(), z.number()]),
-          text: z.string(),
-          metadata: z.record(z.any()).optional(),
-        })),
+        documents: z.array(
+          z.object({
+            id: z.union([z.string(), z.number()]),
+            text: z.string(),
+            metadata: z.record(z.string(), z.any()).optional(),
+          }),
+        ),
       });
 
       const validInput = {
-        collection: 'test-collection',
+        collection: "test-collection",
         documents: [
-          { id: 1, text: 'test document' },
-          { id: 'doc-2', text: 'another document', metadata: { type: 'test' } },
+          { id: 1, text: "test document" },
+          { id: "doc-2", text: "another document", metadata: { type: "test" } },
         ],
       };
 
       expect(() => AddDocumentsSchema.parse(validInput)).not.toThrow();
     });
 
-    it('should accept both string and number IDs', async () => {
-      const { z } = await import('zod');
+    it("should accept both string and number IDs", async () => {
+      const { z } = await import("zod");
 
       const AddDocumentsSchema = z.object({
         collection: z.string(),
-        documents: z.array(z.object({
-          id: z.union([z.string(), z.number()]),
-          text: z.string(),
-          metadata: z.record(z.any()).optional(),
-        })),
+        documents: z.array(
+          z.object({
+            id: z.union([z.string(), z.number()]),
+            text: z.string(),
+            metadata: z.record(z.string(), z.any()).optional(),
+          }),
+        ),
       });
 
       const stringIdInput = {
-        collection: 'test',
-        documents: [{ id: 'string-id', text: 'test' }],
+        collection: "test",
+        documents: [{ id: "string-id", text: "test" }],
       };
       expect(() => AddDocumentsSchema.parse(stringIdInput)).not.toThrow();
 
       const numberIdInput = {
-        collection: 'test',
-        documents: [{ id: 123, text: 'test' }],
+        collection: "test",
+        documents: [{ id: 123, text: "test" }],
       };
       expect(() => AddDocumentsSchema.parse(numberIdInput)).not.toThrow();
     });
 
-    it('should require text field in documents', async () => {
-      const { z } = await import('zod');
+    it("should require text field in documents", async () => {
+      const { z } = await import("zod");
 
       const AddDocumentsSchema = z.object({
         collection: z.string(),
-        documents: z.array(z.object({
-          id: z.union([z.string(), z.number()]),
-          text: z.string(),
-          metadata: z.record(z.any()).optional(),
-        })),
+        documents: z.array(
+          z.object({
+            id: z.union([z.string(), z.number()]),
+            text: z.string(),
+            metadata: z.record(z.string(), z.any()).optional(),
+          }),
+        ),
       });
 
       const invalidInput = {
-        collection: 'test',
+        collection: "test",
         documents: [{ id: 1, metadata: {} }],
       };
       expect(() => AddDocumentsSchema.parse(invalidInput)).toThrow();
     });
   });
 
-  describe('SemanticSearchSchema', () => {
-    it('should validate correct search input', async () => {
-      const { z } = await import('zod');
+  describe("SemanticSearchSchema", () => {
+    it("should validate correct search input", async () => {
+      const { z } = await import("zod");
 
       const SemanticSearchSchema = z.object({
         collection: z.string(),
         query: z.string(),
         limit: z.number().optional(),
-        filter: z.record(z.any()).optional(),
+        filter: z.record(z.string(), z.any()).optional(),
       });
 
       const validInput = {
-        collection: 'test-collection',
-        query: 'search query',
+        collection: "test-collection",
+        query: "search query",
         limit: 10,
-        filter: { category: 'test' },
+        filter: { category: "test" },
       };
 
       expect(() => SemanticSearchSchema.parse(validInput)).not.toThrow();
     });
 
-    it('should work with minimal input', async () => {
-      const { z } = await import('zod');
+    it("should work with minimal input", async () => {
+      const { z } = await import("zod");
 
       const SemanticSearchSchema = z.object({
         collection: z.string(),
         query: z.string(),
         limit: z.number().optional(),
-        filter: z.record(z.any()).optional(),
+        filter: z.record(z.string(), z.any()).optional(),
       });
 
       const minimalInput = {
-        collection: 'test',
-        query: 'search',
+        collection: "test",
+        query: "search",
       };
 
       expect(() => SemanticSearchSchema.parse(minimalInput)).not.toThrow();
     });
 
-    it('should require collection and query', async () => {
-      const { z } = await import('zod');
+    it("should require collection and query", async () => {
+      const { z } = await import("zod");
 
       const SemanticSearchSchema = z.object({
         collection: z.string(),
         query: z.string(),
         limit: z.number().optional(),
-        filter: z.record(z.any()).optional(),
+        filter: z.record(z.string(), z.any()).optional(),
       });
 
-      const missingQuery = { collection: 'test', limit: 5 };
+      const missingQuery = { collection: "test", limit: 5 };
       expect(() => SemanticSearchSchema.parse(missingQuery)).toThrow();
 
-      const missingCollection = { query: 'test', limit: 5 };
+      const missingCollection = { query: "test", limit: 5 };
       expect(() => SemanticSearchSchema.parse(missingCollection)).toThrow();
     });
   });
 
-  describe('DeleteCollectionSchema', () => {
-    it('should validate correct delete input', async () => {
-      const { z } = await import('zod');
+  describe("DeleteCollectionSchema", () => {
+    it("should validate correct delete input", async () => {
+      const { z } = await import("zod");
 
       const DeleteCollectionSchema = z.object({
         name: z.string(),
       });
 
-      const validInput = { name: 'test-collection' };
+      const validInput = { name: "test-collection" };
       expect(() => DeleteCollectionSchema.parse(validInput)).not.toThrow();
     });
 
-    it('should require name field', async () => {
-      const { z } = await import('zod');
+    it("should require name field", async () => {
+      const { z } = await import("zod");
 
       const DeleteCollectionSchema = z.object({
         name: z.string(),
@@ -194,22 +216,22 @@ describe('MCP Server Tool Schemas', () => {
     });
   });
 
-  describe('GetCollectionInfoSchema', () => {
-    it('should validate correct input', async () => {
-      const { z } = await import('zod');
+  describe("GetCollectionInfoSchema", () => {
+    it("should validate correct input", async () => {
+      const { z } = await import("zod");
 
       const GetCollectionInfoSchema = z.object({
         name: z.string(),
       });
 
-      const validInput = { name: 'test-collection' };
+      const validInput = { name: "test-collection" };
       expect(() => GetCollectionInfoSchema.parse(validInput)).not.toThrow();
     });
   });
 
-  describe('DeleteDocumentsSchema', () => {
-    it('should validate correct delete documents input', async () => {
-      const { z } = await import('zod');
+  describe("DeleteDocumentsSchema", () => {
+    it("should validate correct delete documents input", async () => {
+      const { z } = await import("zod");
 
       const DeleteDocumentsSchema = z.object({
         collection: z.string(),
@@ -217,40 +239,40 @@ describe('MCP Server Tool Schemas', () => {
       });
 
       const validInput = {
-        collection: 'test-collection',
-        ids: [1, 'doc-2', 3],
+        collection: "test-collection",
+        ids: [1, "doc-2", 3],
       };
 
       expect(() => DeleteDocumentsSchema.parse(validInput)).not.toThrow();
     });
 
-    it('should accept string and number IDs', async () => {
-      const { z } = await import('zod');
+    it("should accept string and number IDs", async () => {
+      const { z } = await import("zod");
 
       const DeleteDocumentsSchema = z.object({
         collection: z.string(),
         ids: z.array(z.union([z.string(), z.number()])),
       });
 
-      const stringIds = { collection: 'test', ids: ['a', 'b', 'c'] };
+      const stringIds = { collection: "test", ids: ["a", "b", "c"] };
       expect(() => DeleteDocumentsSchema.parse(stringIds)).not.toThrow();
 
-      const numberIds = { collection: 'test', ids: [1, 2, 3] };
+      const numberIds = { collection: "test", ids: [1, 2, 3] };
       expect(() => DeleteDocumentsSchema.parse(numberIds)).not.toThrow();
 
-      const mixedIds = { collection: 'test', ids: [1, 'b', 3] };
+      const mixedIds = { collection: "test", ids: [1, "b", 3] };
       expect(() => DeleteDocumentsSchema.parse(mixedIds)).not.toThrow();
     });
 
-    it('should require both collection and ids', async () => {
-      const { z } = await import('zod');
+    it("should require both collection and ids", async () => {
+      const { z } = await import("zod");
 
       const DeleteDocumentsSchema = z.object({
         collection: z.string(),
         ids: z.array(z.union([z.string(), z.number()])),
       });
 
-      const missingIds = { collection: 'test' };
+      const missingIds = { collection: "test" };
       expect(() => DeleteDocumentsSchema.parse(missingIds)).toThrow();
 
       const missingCollection = { ids: [1, 2, 3] };
@@ -259,25 +281,25 @@ describe('MCP Server Tool Schemas', () => {
   });
 });
 
-describe('MCP Server Resource URIs', () => {
-  it('should match collections URI pattern', () => {
-    const collectionsUri = 'qdrant://collections';
+describe("MCP Server Resource URIs", () => {
+  it("should match collections URI pattern", () => {
+    const collectionsUri = "qdrant://collections";
     expect(collectionsUri).toMatch(/^qdrant:\/\/collections$/);
   });
 
-  it('should match collection detail URI pattern', () => {
-    const collectionUri = 'qdrant://collection/my-collection';
+  it("should match collection detail URI pattern", () => {
+    const collectionUri = "qdrant://collection/my-collection";
     const match = collectionUri.match(/^qdrant:\/\/collection\/(.+)$/);
 
     expect(match).not.toBeNull();
-    expect(match![1]).toBe('my-collection');
+    expect(match![1]).toBe("my-collection");
   });
 
-  it('should extract collection name from URI', () => {
+  it("should extract collection name from URI", () => {
     const testCases = [
-      { uri: 'qdrant://collection/test', expected: 'test' },
-      { uri: 'qdrant://collection/my-docs', expected: 'my-docs' },
-      { uri: 'qdrant://collection/collection-123', expected: 'collection-123' },
+      { uri: "qdrant://collection/test", expected: "test" },
+      { uri: "qdrant://collection/my-docs", expected: "my-docs" },
+      { uri: "qdrant://collection/collection-123", expected: "collection-123" },
     ];
 
     testCases.forEach(({ uri, expected }) => {
@@ -286,12 +308,12 @@ describe('MCP Server Resource URIs', () => {
     });
   });
 
-  it('should not match invalid URIs', () => {
+  it("should not match invalid URIs", () => {
     const invalidUris = [
-      'qdrant://invalid',
-      'http://collections',
-      'qdrant://collection/',
-      'qdrant:collections',
+      "qdrant://invalid",
+      "http://collections",
+      "qdrant://collection/",
+      "qdrant:collections",
     ];
 
     invalidUris.forEach((uri) => {