@mhalder/qdrant-mcp-server 3.2.0 → 3.3.0

package/src/code/chunker/tree-sitter-chunker.ts

@@ -13,10 +13,13 @@ import Python from "tree-sitter-python";
 import Rust from "tree-sitter-rust";
 import TypeScript from "tree-sitter-typescript";
 
+import logger from "../../logger.js";
 import type { ChunkerConfig, CodeChunk } from "../types.js";
 import type { CodeChunker } from "./base.js";
 import { CharacterChunker } from "./character-chunker.js";
 
+const log = logger.child({ component: "tree-sitter-chunker" });
+
 interface LanguageConfig {
   parser: Parser;
   chunkableTypes: string[];
@@ -65,7 +68,11 @@ export class TreeSitterChunker implements CodeChunker {
     pyParser.setLanguage(Python as any);
     this.languages.set("python", {
       parser: pyParser,
-      chunkableTypes: ["function_definition", "class_definition", "decorated_definition"],
+      chunkableTypes: [
+        "function_definition",
+        "class_definition",
+        "decorated_definition",
+      ],
     });
 
     // Go
@@ -86,7 +93,13 @@ export class TreeSitterChunker implements CodeChunker {
     rustParser.setLanguage(Rust as any);
     this.languages.set("rust", {
       parser: rustParser,
-      chunkableTypes: ["function_item", "impl_item", "trait_item", "struct_item", "enum_item"],
+      chunkableTypes: [
+        "function_item",
+        "impl_item",
+        "trait_item",
+        "struct_item",
+        "enum_item",
+      ],
     });
 
     // Java
@@ -111,7 +124,11 @@ export class TreeSitterChunker implements CodeChunker {
     });
   }
 
-  async chunk(code: string, filePath: string, language: string): Promise<CodeChunk[]> {
+  async chunk(
+    code: string,
+    filePath: string,
+    language: string,
+  ): Promise<CodeChunk[]> {
     const langConfig = this.languages.get(language);
 
     if (!langConfig) {
@@ -124,7 +141,10 @@ export class TreeSitterChunker implements CodeChunker {
       const chunks: CodeChunk[] = [];
 
       // Find all chunkable nodes
-      const nodes = this.findChunkableNodes(tree.rootNode, langConfig.chunkableTypes);
+      const nodes = this.findChunkableNodes(
+        tree.rootNode,
+        langConfig.chunkableTypes,
+      );
 
       for (const [index, node] of nodes.entries()) {
         const content = code.substring(node.startIndex, node.endIndex);
@@ -136,7 +156,11 @@ export class TreeSitterChunker implements CodeChunker {
 
         // If chunk is too large, fall back to character chunking for this node
         if (content.length > this.config.maxChunkSize * 2) {
-          const subChunks = await this.fallbackChunker.chunk(content, filePath, language);
+          const subChunks = await this.fallbackChunker.chunk(
+            content,
+            filePath,
+            language,
+          );
           // Adjust line numbers for sub-chunks
           for (const subChunk of subChunks) {
             chunks.push({
@@ -174,7 +198,10 @@ export class TreeSitterChunker implements CodeChunker {
       return chunks;
     } catch (error) {
       // On parsing error, fallback to character-based chunking
-      console.error(`Tree-sitter parsing failed for ${filePath}:`, error);
+      log.warn(
+        { filePath, err: error },
+        "Tree-sitter parsing failed, falling back to character chunker",
+      );
       return this.fallbackChunker.chunk(code, filePath, language);
     }
   }
@@ -192,7 +219,7 @@ export class TreeSitterChunker implements CodeChunker {
    */
   private findChunkableNodes(
     node: Parser.SyntaxNode,
-    chunkableTypes: string[]
+    chunkableTypes: string[],
   ): Parser.SyntaxNode[] {
     const nodes: Parser.SyntaxNode[] = [];
 
@@ -215,7 +242,10 @@ export class TreeSitterChunker implements CodeChunker {
   /**
    * Extract function/class name from AST node
    */
-  private extractName(node: Parser.SyntaxNode, code: string): string | undefined {
+  private extractName(
+    node: Parser.SyntaxNode,
+    code: string,
+  ): string | undefined {
     // Try to find name node
     const nameNode = node.childForFieldName("name");
     if (nameNode) {
@@ -235,7 +265,9 @@ export class TreeSitterChunker implements CodeChunker {
   /**
    * Map AST node type to chunk type
    */
-  private getChunkType(nodeType: string): "function" | "class" | "interface" | "block" {
+  private getChunkType(
+    nodeType: string,
+  ): "function" | "class" | "interface" | "block" {
     if (nodeType.includes("function") || nodeType.includes("method")) {
       return "function";
     }

package/src/code/indexer.ts

@@ -8,6 +8,7 @@ import { promises as fs } from "node:fs";
 import { extname, join, relative, resolve } from "node:path";
 import { promisify } from "node:util";
 import picomatch from "picomatch";
+import logger from "../logger.js";
 import type { EmbeddingProvider } from "../embeddings/base.js";
 import { BM25SparseVectorGenerator } from "../embeddings/sparse.js";
 import { normalizeRemoteUrl } from "../git/extractor.js";
@@ -34,6 +35,8 @@ const execFileAsync = promisify(execFile);
 const INDEXING_METADATA_ID = "__indexing_metadata__";
 
 export class CodeIndexer {
+  private log = logger.child({ component: "code-indexer" });
+
   constructor(
     private qdrant: QdrantManager,
     private embeddings: EmbeddingProvider,
@@ -83,6 +86,8 @@ export class CodeIndexer {
     const absolutePath = await this.validatePath(path);
     const collectionName = await this.getCollectionName(absolutePath);
 
+    this.log.info({ path: absolutePath, collectionName }, "Indexing started");
+
     try {
       // 1. Scan files
       progressCallback?.({
@@ -105,6 +110,7 @@ export class CodeIndexer {
       const files = await scanner.scanDirectory(absolutePath);
 
       stats.filesScanned = files.length;
+      this.log.info({ filesFound: files.length }, "File scan complete");
 
       if (files.length === 0) {
         stats.status = "completed";
@@ -128,6 +134,7 @@ export class CodeIndexer {
           "Cosine",
           this.config.enableHybridSearch,
         );
+        this.log.debug({ collectionName, vectorSize }, "Collection created");
       }
 
       // Store "indexing in progress" marker immediately after collection is ready
@@ -209,7 +216,7 @@ export class CodeIndexer {
         // Snapshot failure shouldn't fail the entire indexing
         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}`);
       }
 
@@ -223,6 +230,10 @@ export class CodeIndexer {
 
       // 4. 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);
 
@@ -309,6 +320,14 @@ export class CodeIndexer {
       await this.storeIndexingMarker(collectionName, true);
 
       stats.durationMs = Date.now() - startTime;
+      this.log.info(
+        {
+          filesIndexed: stats.filesIndexed,
+          chunksCreated: stats.chunksCreated,
+          durationMs: stats.durationMs,
+        },
+        "Indexing complete",
+      );
       return stats;
     } catch (error) {
       const errorMessage =
@@ -365,7 +384,7 @@ export class CodeIndexer {
       }
     } catch (error) {
       // Non-fatal: log but don't fail the indexing
-      console.error("Failed to store indexing marker:", error);
+      this.log.error({ err: error }, "Failed to store indexing marker");
     }
   }
 
@@ -564,6 +583,8 @@ export class CodeIndexer {
       const absolutePath = await this.validatePath(path);
       const collectionName = await this.getCollectionName(absolutePath);
 
+      this.log.info({ path: absolutePath }, "Reindex started");
+
       // Check if collection exists
       const exists = await this.qdrant.collectionExists(collectionName);
       if (!exists) {
@@ -640,9 +661,9 @@ export class CodeIndexer {
             await this.qdrant.deletePointsByFilter(collectionName, filter);
           } catch (error) {
             // Log but don't fail - file might not have any chunks
-            console.error(
-              `Failed to delete chunks for ${relativePath}:`,
-              error,
+            this.log.error(
+              { relativePath, err: error },
+              "Failed to delete chunks during reindex",
             );
           }
         }
@@ -677,7 +698,10 @@ export class CodeIndexer {
             allChunks.push({ chunk, id });
           }
         } catch (error) {
-          console.error(`Failed to process ${filePath}:`, error);
+          this.log.error(
+            { filePath, err: error },
+            "Failed to process file during reindex",
+          );
         }
       }
 
@@ -746,6 +770,16 @@ export class CodeIndexer {
       await synchronizer.updateSnapshot(currentFiles);
 
       stats.durationMs = Date.now() - startTime;
+      this.log.info(
+        {
+          filesAdded: stats.filesAdded,
+          filesModified: stats.filesModified,
+          filesDeleted: stats.filesDeleted,
+          chunksAdded: stats.chunksAdded,
+          durationMs: stats.durationMs,
+        },
+        "Reindex complete",
+      );
       return stats;
     } catch (error) {
       const errorMessage =
@@ -758,6 +792,7 @@ export class CodeIndexer {
    * Clear all indexed data for a codebase
    */
   async clearIndex(path: string): Promise<void> {
+    this.log.info({ path }, "Clearing index");
     const absolutePath = await this.validatePath(path);
     const collectionName = await this.getCollectionName(absolutePath);
     const exists = await this.qdrant.collectionExists(collectionName);

package/src/embeddings/cohere.test.ts

@@ -12,6 +12,18 @@ vi.mock("cohere-ai", () => ({
   }),
 }));
 
+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("CohereEmbeddings", () => {
   let embeddings: CohereEmbeddings;
 

package/src/embeddings/cohere.ts

@@ -1,5 +1,6 @@
 import { CohereClient } from "cohere-ai";
 import Bottleneck from "bottleneck";
+import logger from "../logger.js";
 import { EmbeddingProvider, EmbeddingResult, RateLimitConfig } from "./base.js";
 
 interface CohereError {
@@ -9,6 +10,7 @@ interface CohereError {
 }
 
 export class CohereEmbeddings implements EmbeddingProvider {
+  private log = logger.child({ component: "embeddings", provider: "cohere" });
   private client: CohereClient;
   private model: string;
   private dimensions: number;
@@ -76,8 +78,13 @@ export class CohereEmbeddings implements EmbeddingProvider {
       if (isRateLimitError && attempt < this.retryAttempts) {
         const delayMs = this.retryDelayMs * Math.pow(2, attempt);
         const waitTimeSeconds = (delayMs / 1000).toFixed(1);
-        console.error(
-          `Rate limit reached. Retrying in ${waitTimeSeconds}s (attempt ${attempt + 1}/${this.retryAttempts})...`,
+        this.log.warn(
+          {
+            waitTimeSeconds,
+            attempt: attempt + 1,
+            maxAttempts: this.retryAttempts,
+          },
+          "Rate limit reached, retrying",
         );
 
         await new Promise((resolve) => setTimeout(resolve, delayMs));
@@ -119,6 +126,7 @@ export class CohereEmbeddings implements EmbeddingProvider {
   }
 
   async embedBatch(texts: string[]): Promise<EmbeddingResult[]> {
+    this.log.debug({ batchSize: texts.length }, "embedBatch");
     return this.limiter.schedule(() =>
       this.retryWithBackoff(async () => {
         const response = await this.client.embed({

package/src/embeddings/factory.test.ts

@@ -1,10 +1,22 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import { EmbeddingProviderFactory, type FactoryConfig } from "./factory.js";
 import { OpenAIEmbeddings } from "./openai.js";
 import { CohereEmbeddings } from "./cohere.js";
 import { VoyageEmbeddings } from "./voyage.js";
 import { OllamaEmbeddings } from "./ollama.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("EmbeddingProviderFactory", () => {
   let originalEnv: NodeJS.ProcessEnv;
 

package/src/embeddings/factory.ts

@@ -1,3 +1,4 @@
+import logger from "../logger.js";
 import { EmbeddingProvider, ProviderConfig } from "./base.js";
 import { OpenAIEmbeddings } from "./openai.js";
 import { CohereEmbeddings } from "./cohere.js";
@@ -15,6 +16,8 @@ export class EmbeddingProviderFactory {
     const { provider, model, dimensions, rateLimitConfig, apiKey, baseUrl } =
       config;
 
+    logger.info({ provider, model }, "Creating embedding provider");
+
     switch (provider) {
       case "openai":
         if (!apiKey) {

package/src/embeddings/ollama.test.ts

@@ -4,6 +4,18 @@ import { OllamaEmbeddings } from "./ollama.js";
 // Mock fetch globally
 global.fetch = vi.fn();
 
+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("OllamaEmbeddings", () => {
   let embeddings: OllamaEmbeddings;
   let mockFetch: any;

package/src/embeddings/ollama.ts

@@ -1,4 +1,5 @@
 import Bottleneck from "bottleneck";
+import logger from "../logger.js";
 import { EmbeddingProvider, EmbeddingResult, RateLimitConfig } from "./base.js";
 
 interface OllamaError {
@@ -11,6 +12,7 @@ interface OllamaEmbedResponse {
 }
 
 export class OllamaEmbeddings implements EmbeddingProvider {
+  private log = logger.child({ component: "embeddings", provider: "ollama" });
   private model: string;
   private dimensions: number;
   private limiter: Bottleneck;
@@ -76,8 +78,13 @@ export class OllamaEmbeddings implements EmbeddingProvider {
       if (isRateLimitError && attempt < this.retryAttempts) {
         const delayMs = this.retryDelayMs * Math.pow(2, attempt);
         const waitTimeSeconds = (delayMs / 1000).toFixed(1);
-        console.error(
-          `Rate limit reached. Retrying in ${waitTimeSeconds}s (attempt ${attempt + 1}/${this.retryAttempts})...`,
+        this.log.warn(
+          {
+            waitTimeSeconds,
+            attempt: attempt + 1,
+            maxAttempts: this.retryAttempts,
+          },
+          "Rate limit reached, retrying",
         );
 
         await new Promise((resolve) => setTimeout(resolve, delayMs));
@@ -169,6 +176,7 @@ export class OllamaEmbeddings implements EmbeddingProvider {
   }
 
   async embedBatch(texts: string[]): Promise<EmbeddingResult[]> {
+    this.log.debug({ batchSize: texts.length }, "embedBatch");
     // Ollama doesn't support batch embeddings natively, so we process in parallel
     // Process in chunks to avoid overwhelming Ollama and prevent memory issues
     const CHUNK_SIZE = 50;

package/src/embeddings/openai.test.ts

@@ -14,6 +14,18 @@ vi.mock("openai", () => ({
   }),
 }));
 
+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("OpenAIEmbeddings", () => {
   let embeddings: OpenAIEmbeddings;
 

package/src/embeddings/openai.ts

@@ -1,5 +1,6 @@
 import OpenAI from "openai";
 import Bottleneck from "bottleneck";
+import logger from "../logger.js";
 import {
   EmbeddingProvider,
   EmbeddingResult,
@@ -18,6 +19,7 @@ interface OpenAIError {
 }
 
 export class OpenAIEmbeddings implements EmbeddingProvider {
+  private log = logger.child({ component: "embeddings", provider: "openai" });
   private client: OpenAI;
   private model: string;
   private dimensions: number;
@@ -95,8 +97,13 @@ export class OpenAIEmbeddings implements EmbeddingProvider {
         }
 
         const waitTimeSeconds = (delayMs / 1000).toFixed(1);
-        console.error(
-          `Rate limit reached. Retrying in ${waitTimeSeconds}s (attempt ${attempt + 1}/${this.retryAttempts})...`,
+        this.log.warn(
+          {
+            waitTimeSeconds,
+            attempt: attempt + 1,
+            maxAttempts: this.retryAttempts,
+          },
+          "Rate limit reached, retrying",
         );
 
         await new Promise((resolve) => setTimeout(resolve, delayMs));
@@ -132,6 +139,7 @@ export class OpenAIEmbeddings implements EmbeddingProvider {
   }
 
   async embedBatch(texts: string[]): Promise<EmbeddingResult[]> {
+    this.log.debug({ batchSize: texts.length }, "embedBatch");
     return this.limiter.schedule(() =>
       this.retryWithBackoff(async () => {
         const response = await this.client.embeddings.create({

package/src/embeddings/voyage.test.ts

@@ -4,6 +4,18 @@ import { VoyageEmbeddings } from "./voyage.js";
 // Mock fetch globally
 global.fetch = vi.fn();
 
+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("VoyageEmbeddings", () => {
   let embeddings: VoyageEmbeddings;
   let mockFetch: any;

package/src/embeddings/voyage.ts

@@ -1,4 +1,5 @@
 import Bottleneck from "bottleneck";
+import logger from "../logger.js";
 import { EmbeddingProvider, EmbeddingResult, RateLimitConfig } from "./base.js";
 
 interface VoyageError {
@@ -15,6 +16,7 @@ interface VoyageEmbedResponse {
 }
 
 export class VoyageEmbeddings implements EmbeddingProvider {
+  private log = logger.child({ component: "embeddings", provider: "voyage" });
   private apiKey: string;
   private model: string;
   private dimensions: number;
@@ -76,8 +78,13 @@ export class VoyageEmbeddings implements EmbeddingProvider {
       if (isRateLimitError && attempt < this.retryAttempts) {
         const delayMs = this.retryDelayMs * Math.pow(2, attempt);
         const waitTimeSeconds = (delayMs / 1000).toFixed(1);
-        console.error(
-          `Rate limit reached. Retrying in ${waitTimeSeconds}s (attempt ${attempt + 1}/${this.retryAttempts})...`,
+        this.log.warn(
+          {
+            waitTimeSeconds,
+            attempt: attempt + 1,
+            maxAttempts: this.retryAttempts,
+          },
+          "Rate limit reached, retrying",
         );
 
         await new Promise((resolve) => setTimeout(resolve, delayMs));
@@ -142,6 +149,7 @@ export class VoyageEmbeddings implements EmbeddingProvider {
   }
 
   async embedBatch(texts: string[]): Promise<EmbeddingResult[]> {
+    this.log.debug({ batchSize: texts.length }, "embedBatch");
     return this.limiter.schedule(() =>
       this.retryWithBackoff(async () => {
         const response = await this.callApi(texts);

package/src/git/indexer.test.ts

@@ -76,6 +76,18 @@ vi.mock("node:fs", () => ({
   },
 }));
 
+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("GitHistoryIndexer", () => {
   let indexer: GitHistoryIndexer;
   let mockQdrant: any;
@@ -622,10 +634,6 @@ describe("GitHistoryIndexer", () => {
     });
 
     it("should handle snapshot save failure gracefully", async () => {
-      const consoleSpy = vi
-        .spyOn(console, "error")
-        .mockImplementation(() => {});
-
       const mockCommits = [
         {
           hash: "abc123",
@@ -653,14 +661,12 @@ describe("GitHistoryIndexer", () => {
 
       expect(stats.status).toBe("completed");
       expect(stats.errors?.some((e) => e.includes("Snapshot"))).toBe(true);
-
-      consoleSpy.mockRestore();
     });
 
     it("should handle storeIndexingMarker errors silently", async () => {
-      const consoleSpy = vi
-        .spyOn(console, "error")
-        .mockImplementation(() => {});
+      const loggerMod = await import("../logger.js");
+      const logError = loggerMod.default.error as ReturnType<typeof vi.fn>;
+      logError.mockClear();
 
       mockExtractorInstance.validateRepository.mockResolvedValue(true);
       mockExtractorInstance.getLatestCommitHash.mockResolvedValue("abc123");
@@ -670,9 +676,7 @@ describe("GitHistoryIndexer", () => {
       const stats = await indexer.indexHistory("/test/repo");
 
       expect(stats.status).toBe("completed");
-      expect(consoleSpy).toHaveBeenCalled();
-
-      consoleSpy.mockRestore();
+      expect(logError).toHaveBeenCalled();
     });
 
     it("should use hybrid search for indexing when enabled", async () => {
@@ -1072,7 +1076,9 @@ describe("GitHistoryIndexer", () => {
       mockChunkerInstance.generateChunkId.mockReturnValue("chunk-1");
 
       // All retries fail
-      mockEmbeddings.embedBatch.mockRejectedValue(new Error("Persistent error"));
+      mockEmbeddings.embedBatch.mockRejectedValue(
+        new Error("Persistent error"),
+      );
 
       mockQdrant.collectionExists.mockResolvedValue(false);
       mockQdrant.getCollectionInfo.mockResolvedValue({ hybridEnabled: false });
@@ -1081,9 +1087,9 @@ describe("GitHistoryIndexer", () => {
 
       expect(stats.status).toBe("partial");
       expect(stats.errors).toBeDefined();
-      expect(
-        stats.errors?.some((e) => e.includes("after 3 attempts")),
-      ).toBe(true);
+      expect(stats.errors?.some((e) => e.includes("after 3 attempts"))).toBe(
+        true,
+      );
     });
   });
 });