@mhalder/qdrant-mcp-server 3.3.3 → 3.3.4

package/src/embeddings/openai.test.ts

@@ -30,9 +30,7 @@ describe("OpenAIEmbeddings", () => {
   let embeddings: OpenAIEmbeddings;
 
   beforeEach(() => {
-    mockOpenAI.embeddings.create
-      .mockReset()
-      .mockResolvedValue({ data: [{ embedding: [] }] });
+    mockOpenAI.embeddings.create.mockReset().mockResolvedValue({ data: [{ embedding: [] }] });
     vi.mocked(OpenAI).mockClear();
     embeddings = new OpenAIEmbeddings("test-api-key");
   });
@@ -44,28 +42,18 @@ describe("OpenAIEmbeddings", () => {
     });
 
     it("should use custom model", () => {
-      const customEmbeddings = new OpenAIEmbeddings(
-        "test-api-key",
-        "text-embedding-3-large",
-      );
+      const customEmbeddings = new OpenAIEmbeddings("test-api-key", "text-embedding-3-large");
       expect(customEmbeddings.getModel()).toBe("text-embedding-3-large");
       expect(customEmbeddings.getDimensions()).toBe(3072);
     });
 
     it("should use custom dimensions", () => {
-      const customEmbeddings = new OpenAIEmbeddings(
-        "test-api-key",
-        "text-embedding-3-small",
-        512,
-      );
+      const customEmbeddings = new OpenAIEmbeddings("test-api-key", "text-embedding-3-small", 512);
       expect(customEmbeddings.getDimensions()).toBe(512);
     });
 
     it("should use default dimensions for text-embedding-ada-002", () => {
-      const adaEmbeddings = new OpenAIEmbeddings(
-        "test-api-key",
-        "text-embedding-ada-002",
-      );
+      const adaEmbeddings = new OpenAIEmbeddings("test-api-key", "text-embedding-ada-002");
       expect(adaEmbeddings.getDimensions()).toBe(1536);
     });
   });
@@ -110,11 +98,7 @@ describe("OpenAIEmbeddings", () => {
     });
 
     it("should use custom model configuration", async () => {
-      const customEmbeddings = new OpenAIEmbeddings(
-        "test-api-key",
-        "text-embedding-3-large",
-        3072,
-      );
+      const customEmbeddings = new OpenAIEmbeddings("test-api-key", "text-embedding-3-large", 3072);
       const mockEmbedding = Array(3072).fill(0.1);
       mockOpenAI.embeddings.create.mockResolvedValue({
         data: [{ embedding: mockEmbedding }],
@@ -138,11 +122,7 @@ describe("OpenAIEmbeddings", () => {
 
   describe("embedBatch", () => {
     it("should generate embeddings for multiple texts", async () => {
-      const mockEmbeddings = [
-        Array(1536).fill(0.1),
-        Array(1536).fill(0.2),
-        Array(1536).fill(0.3),
-      ];
+      const mockEmbeddings = [Array(1536).fill(0.1), Array(1536).fill(0.2), Array(1536).fill(0.3)];
       mockOpenAI.embeddings.create.mockResolvedValue({
         data: [
           { embedding: mockEmbeddings[0] },
@@ -207,13 +187,9 @@ describe("OpenAIEmbeddings", () => {
     });
 
     it("should propagate errors in batch", async () => {
-      mockOpenAI.embeddings.create.mockRejectedValue(
-        new Error("Batch API Error"),
-      );
+      mockOpenAI.embeddings.create.mockRejectedValue(new Error("Batch API Error"));
 
-      await expect(embeddings.embedBatch(["text1", "text2"])).rejects.toThrow(
-        "Batch API Error",
-      );
+      await expect(embeddings.embedBatch(["text1", "text2"])).rejects.toThrow("Batch API Error");
     });
   });
 
@@ -223,11 +199,7 @@ describe("OpenAIEmbeddings", () => {
     });
 
     it("should return custom dimensions", () => {
-      const customEmbeddings = new OpenAIEmbeddings(
-        "test-api-key",
-        "text-embedding-3-small",
-        512,
-      );
+      const customEmbeddings = new OpenAIEmbeddings("test-api-key", "text-embedding-3-small", 512);
       expect(customEmbeddings.getDimensions()).toBe(512);
     });
   });
@@ -238,10 +210,7 @@ describe("OpenAIEmbeddings", () => {
     });
 
     it("should return custom model", () => {
-      const customEmbeddings = new OpenAIEmbeddings(
-        "test-api-key",
-        "text-embedding-3-large",
-      );
+      const customEmbeddings = new OpenAIEmbeddings("test-api-key", "text-embedding-3-large");
       expect(customEmbeddings.getModel()).toBe("text-embedding-3-large");
     });
   });
@@ -290,7 +259,7 @@ describe("OpenAIEmbeddings", () => {
         {
           retryAttempts: 2,
           retryDelayMs: 100, // 100ms for faster tests
-        },
+        }
       );
 
       const mockEmbedding = Array(1536).fill(0.5);
@@ -323,7 +292,7 @@ describe("OpenAIEmbeddings", () => {
         {
           retryAttempts: 3,
           retryDelayMs: 100, // 100ms for faster tests
-        },
+        }
       );
 
       const mockEmbedding = Array(1536).fill(0.5);
@@ -353,7 +322,7 @@ describe("OpenAIEmbeddings", () => {
         {
           retryAttempts: 2,
           retryDelayMs: 100,
-        },
+        }
       );
 
       const rateLimitError = {
@@ -364,7 +333,7 @@ describe("OpenAIEmbeddings", () => {
       mockOpenAI.embeddings.create.mockRejectedValue(rateLimitError);
 
       await expect(rateLimitEmbeddings.embed("test text")).rejects.toThrow(
-        "OpenAI API rate limit exceeded after 2 retry attempts",
+        "OpenAI API rate limit exceeded after 2 retry attempts"
       );
 
       // Should try initial + 2 retries = 3 total attempts
@@ -377,10 +346,7 @@ describe("OpenAIEmbeddings", () => {
       mockOpenAI.embeddings.create
         .mockRejectedValueOnce({ status: 429, message: "Rate limit exceeded" })
         .mockResolvedValue({
-          data: [
-            { embedding: mockEmbeddings[0] },
-            { embedding: mockEmbeddings[1] },
-          ],
+          data: [{ embedding: mockEmbeddings[0] }, { embedding: mockEmbeddings[1] }],
         });
 
       const results = await embeddings.embedBatch(["text1", "text2"]);
@@ -393,9 +359,7 @@ describe("OpenAIEmbeddings", () => {
       const apiError = new Error("Invalid API key");
       mockOpenAI.embeddings.create.mockRejectedValue(apiError);
 
-      await expect(embeddings.embed("test text")).rejects.toThrow(
-        "Invalid API key",
-      );
+      await expect(embeddings.embed("test text")).rejects.toThrow("Invalid API key");
       expect(mockOpenAI.embeddings.create).toHaveBeenCalledTimes(1);
     });
 
@@ -408,7 +372,7 @@ describe("OpenAIEmbeddings", () => {
           maxRequestsPerMinute: 1000,
           retryAttempts: 5,
           retryDelayMs: 2000,
-        },
+        }
       );
 
       expect(customEmbeddings).toBeDefined();

package/src/embeddings/openai.ts

@@ -1,12 +1,7 @@
-import OpenAI from "openai";
 import Bottleneck from "bottleneck";
+import OpenAI from "openai";
 import logger from "../logger.js";
-import {
-  EmbeddingProvider,
-  EmbeddingResult,
-  RateLimitConfig,
-  ProviderConfig,
-} from "./base.js";
+import type { EmbeddingProvider, EmbeddingResult, RateLimitConfig } from "./base.js";
 
 interface OpenAIError {
   status?: number;
@@ -31,7 +26,7 @@ export class OpenAIEmbeddings implements EmbeddingProvider {
     apiKey: string,
     model: string = "text-embedding-3-small",
     dimensions?: number,
-    rateLimitConfig?: RateLimitConfig,
+    rateLimitConfig?: RateLimitConfig
   ) {
     this.client = new OpenAI({ apiKey });
     this.model = model;
@@ -64,10 +59,7 @@ export class OpenAIEmbeddings implements EmbeddingProvider {
     });
   }
 
-  private async retryWithBackoff<T>(
-    fn: () => Promise<T>,
-    attempt: number = 0,
-  ): Promise<T> {
+  private async retryWithBackoff<T>(fn: () => Promise<T>, attempt: number = 0): Promise<T> {
     try {
       return await fn();
     } catch (error: unknown) {
@@ -80,20 +72,17 @@ export class OpenAIEmbeddings implements EmbeddingProvider {
       if (isRateLimitError && attempt < this.retryAttempts) {
         // Check for Retry-After header (different HTTP clients may nest differently)
         const retryAfter =
-          apiError?.response?.headers?.["retry-after"] ||
-          apiError?.headers?.["retry-after"];
+          apiError?.response?.headers?.["retry-after"] || apiError?.headers?.["retry-after"];
         let delayMs: number;
 
         if (retryAfter) {
           // Use Retry-After header if available (in seconds)
           const parsed = parseInt(retryAfter, 10);
           delayMs =
-            !isNaN(parsed) && parsed > 0
-              ? parsed * 1000
-              : this.retryDelayMs * Math.pow(2, attempt);
+            !Number.isNaN(parsed) && parsed > 0 ? parsed * 1000 : this.retryDelayMs * 2 ** attempt;
         } else {
           // Exponential backoff: 1s, 2s, 4s, 8s...
-          delayMs = this.retryDelayMs * Math.pow(2, attempt);
+          delayMs = this.retryDelayMs * 2 ** attempt;
         }
 
         const waitTimeSeconds = (delayMs / 1000).toFixed(1);
@@ -103,7 +92,7 @@ export class OpenAIEmbeddings implements EmbeddingProvider {
             attempt: attempt + 1,
             maxAttempts: this.retryAttempts,
           },
-          "Rate limit reached, retrying",
+          "Rate limit reached, retrying"
         );
 
         await new Promise((resolve) => setTimeout(resolve, delayMs));
@@ -113,7 +102,7 @@ export class OpenAIEmbeddings implements EmbeddingProvider {
       // If not a rate limit error or max retries exceeded, throw
       if (isRateLimitError) {
         throw new Error(
-          `OpenAI API rate limit exceeded after ${this.retryAttempts} retry attempts. Please try again later or reduce request frequency.`,
+          `OpenAI API rate limit exceeded after ${this.retryAttempts} retry attempts. Please try again later or reduce request frequency.`
         );
       }
 
@@ -134,7 +123,7 @@ export class OpenAIEmbeddings implements EmbeddingProvider {
           embedding: response.data[0].embedding,
           dimensions: this.dimensions,
         };
-      }),
+      })
     );
   }
 
@@ -152,7 +141,7 @@ export class OpenAIEmbeddings implements EmbeddingProvider {
           embedding: item.embedding,
           dimensions: this.dimensions,
         }));
-      }),
+      })
     );
   }
 

package/src/embeddings/sparse.test.ts

@@ -124,8 +124,18 @@ describe("BM25SparseVectorGenerator", () => {
   it("should map different tokens to different indices (within hash collision tolerance)", () => {
     const generator = new BM25SparseVectorGenerator();
     // Use a set of clearly distinct tokens
-    const tokens = ["apple", "banana", "cherry", "dragon", "elephant",
-      "flamingo", "giraffe", "helicopter", "igloo", "jungle"];
+    const tokens = [
+      "apple",
+      "banana",
+      "cherry",
+      "dragon",
+      "elephant",
+      "flamingo",
+      "giraffe",
+      "helicopter",
+      "igloo",
+      "jungle",
+    ];
 
     const indices = new Set<number>();
     for (const token of tokens) {

package/src/embeddings/voyage.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { VoyageEmbeddings } from "./voyage.js";
 
 // Mock fetch globally
@@ -34,20 +34,13 @@ describe("VoyageEmbeddings", () => {
     });
 
     it("should use custom model", () => {
-      const customEmbeddings = new VoyageEmbeddings(
-        "test-api-key",
-        "voyage-large-2",
-      );
+      const customEmbeddings = new VoyageEmbeddings("test-api-key", "voyage-large-2");
       expect(customEmbeddings.getModel()).toBe("voyage-large-2");
       expect(customEmbeddings.getDimensions()).toBe(1536);
     });
 
     it("should use custom dimensions", () => {
-      const customEmbeddings = new VoyageEmbeddings(
-        "test-api-key",
-        "voyage-2",
-        512,
-      );
+      const customEmbeddings = new VoyageEmbeddings("test-api-key", "voyage-2", 512);
       expect(customEmbeddings.getDimensions()).toBe(512);
     });
 
@@ -62,16 +55,13 @@ describe("VoyageEmbeddings", () => {
         "voyage-2",
         undefined,
         undefined,
-        "https://custom.voyage.com",
+        "https://custom.voyage.com"
       );
       expect(customEmbeddings).toBeDefined();
     });
 
     it("should default to 1024 for unknown models", () => {
-      const unknownEmbeddings = new VoyageEmbeddings(
-        "test-api-key",
-        "custom-model",
-      );
+      const unknownEmbeddings = new VoyageEmbeddings("test-api-key", "custom-model");
       expect(unknownEmbeddings.getDimensions()).toBe(1024);
     });
 
@@ -82,7 +72,7 @@ describe("VoyageEmbeddings", () => {
         undefined,
         undefined,
         undefined,
-        "query",
+        "query"
       );
       expect(queryEmbeddings).toBeInstanceOf(VoyageEmbeddings);
     });
@@ -108,20 +98,17 @@ describe("VoyageEmbeddings", () => {
         embedding: mockEmbedding,
         dimensions: 1024,
       });
-      expect(mockFetch).toHaveBeenCalledWith(
-        "https://api.voyageai.com/v1/embeddings",
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: "Bearer test-api-key",
-          },
-          body: JSON.stringify({
-            input: ["test text"],
-            model: "voyage-2",
-          }),
+      expect(mockFetch).toHaveBeenCalledWith("https://api.voyageai.com/v1/embeddings", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer test-api-key",
         },
-      );
+        body: JSON.stringify({
+          input: ["test text"],
+          model: "voyage-2",
+        }),
+      });
     });
 
     it("should include input_type when specified", async () => {
@@ -131,7 +118,7 @@ describe("VoyageEmbeddings", () => {
         undefined,
         undefined,
         undefined,
-        "query",
+        "query"
       );
 
       const mockEmbedding = Array(1024).fill(0.5);
@@ -173,7 +160,7 @@ describe("VoyageEmbeddings", () => {
         "voyage-2",
         undefined,
         undefined,
-        "https://custom.voyage.com/v1",
+        "https://custom.voyage.com/v1"
       );
 
       const mockEmbedding = Array(1024).fill(0.1);
@@ -190,7 +177,7 @@ describe("VoyageEmbeddings", () => {
 
       expect(mockFetch).toHaveBeenCalledWith(
         "https://custom.voyage.com/v1/embeddings",
-        expect.any(Object),
+        expect.any(Object)
       );
     });
 
@@ -205,7 +192,7 @@ describe("VoyageEmbeddings", () => {
       });
 
       await expect(embeddings.embed("test")).rejects.toThrow(
-        "No embedding returned from Voyage AI API",
+        "No embedding returned from Voyage AI API"
       );
     });
 
@@ -228,11 +215,7 @@ describe("VoyageEmbeddings", () => {
 
   describe("embedBatch", () => {
     it("should generate embeddings for multiple texts", async () => {
-      const mockEmbeddings = [
-        Array(1024).fill(0.1),
-        Array(1024).fill(0.2),
-        Array(1024).fill(0.3),
-      ];
+      const mockEmbeddings = [Array(1024).fill(0.1), Array(1024).fill(0.2), Array(1024).fill(0.3)];
       mockFetch.mockResolvedValue({
         ok: true,
         json: async () => ({
@@ -320,16 +303,14 @@ describe("VoyageEmbeddings", () => {
       });
 
       await expect(embeddings.embedBatch(["text1"])).rejects.toThrow(
-        "No embeddings returned from Voyage AI API",
+        "No embeddings returned from Voyage AI API"
       );
     });
 
     it("should propagate errors in batch", async () => {
       mockFetch.mockRejectedValue(new Error("Batch API Error"));
 
-      await expect(embeddings.embedBatch(["text1", "text2"])).rejects.toThrow(
-        "Batch API Error",
-      );
+      await expect(embeddings.embedBatch(["text1", "text2"])).rejects.toThrow("Batch API Error");
     });
   });
 
@@ -339,11 +320,7 @@ describe("VoyageEmbeddings", () => {
     });
 
     it("should return custom dimensions", () => {
-      const customEmbeddings = new VoyageEmbeddings(
-        "test-api-key",
-        "voyage-2",
-        512,
-      );
+      const customEmbeddings = new VoyageEmbeddings("test-api-key", "voyage-2", 512);
       expect(customEmbeddings.getDimensions()).toBe(512);
     });
   });
@@ -354,10 +331,7 @@ describe("VoyageEmbeddings", () => {
     });
 
     it("should return custom model", () => {
-      const customEmbeddings = new VoyageEmbeddings(
-        "test-api-key",
-        "voyage-large-2",
-      );
+      const customEmbeddings = new VoyageEmbeddings("test-api-key", "voyage-large-2");
       expect(customEmbeddings.getModel()).toBe("voyage-large-2");
     });
   });
@@ -415,15 +389,10 @@ describe("VoyageEmbeddings", () => {
     });
 
     it("should use exponential backoff", async () => {
-      const rateLimitEmbeddings = new VoyageEmbeddings(
-        "test-api-key",
-        "voyage-2",
-        undefined,
-        {
-          retryAttempts: 3,
-          retryDelayMs: 100,
-        },
-      );
+      const rateLimitEmbeddings = new VoyageEmbeddings("test-api-key", "voyage-2", undefined, {
+        retryAttempts: 3,
+        retryDelayMs: 100,
+      });
 
       const mockEmbedding = Array(1024).fill(0.5);
 
@@ -456,15 +425,10 @@ describe("VoyageEmbeddings", () => {
     });
 
     it("should throw error after max retries exceeded", async () => {
-      const rateLimitEmbeddings = new VoyageEmbeddings(
-        "test-api-key",
-        "voyage-2",
-        undefined,
-        {
-          retryAttempts: 2,
-          retryDelayMs: 100,
-        },
-      );
+      const rateLimitEmbeddings = new VoyageEmbeddings("test-api-key", "voyage-2", undefined, {
+        retryAttempts: 2,
+        retryDelayMs: 100,
+      });
 
       mockFetch.mockResolvedValue({
         ok: false,
@@ -473,7 +437,7 @@ describe("VoyageEmbeddings", () => {
       });
 
       await expect(rateLimitEmbeddings.embed("test text")).rejects.toThrow(
-        "Voyage AI API rate limit exceeded after 2 retry attempts",
+        "Voyage AI API rate limit exceeded after 2 retry attempts"
       );
 
       expect(mockFetch).toHaveBeenCalledTimes(3);
@@ -515,16 +479,11 @@ describe("VoyageEmbeddings", () => {
     });
 
     it("should accept custom rate limit configuration", () => {
-      const customEmbeddings = new VoyageEmbeddings(
-        "test-api-key",
-        "voyage-2",
-        undefined,
-        {
-          maxRequestsPerMinute: 500,
-          retryAttempts: 5,
-          retryDelayMs: 2000,
-        },
-      );
+      const customEmbeddings = new VoyageEmbeddings("test-api-key", "voyage-2", undefined, {
+        maxRequestsPerMinute: 500,
+        retryAttempts: 5,
+        retryDelayMs: 2000,
+      });
 
       expect(customEmbeddings).toBeDefined();
     });

package/src/embeddings/voyage.ts

@@ -1,6 +1,6 @@
 import Bottleneck from "bottleneck";
 import logger from "../logger.js";
-import { EmbeddingProvider, EmbeddingResult, RateLimitConfig } from "./base.js";
+import type { EmbeddingProvider, EmbeddingResult, RateLimitConfig } from "./base.js";
 
 interface VoyageError {
   status?: number;
@@ -32,7 +32,7 @@ export class VoyageEmbeddings implements EmbeddingProvider {
     dimensions?: number,
     rateLimitConfig?: RateLimitConfig,
     baseUrl: string = "https://api.voyageai.com/v1",
-    inputType?: "query" | "document",
+    inputType?: "query" | "document"
   ) {
     this.apiKey = apiKey;
     this.model = model;
@@ -63,20 +63,16 @@ export class VoyageEmbeddings implements EmbeddingProvider {
     });
   }
 
-  private async retryWithBackoff<T>(
-    fn: () => Promise<T>,
-    attempt: number = 0,
-  ): Promise<T> {
+  private async retryWithBackoff<T>(fn: () => Promise<T>, attempt: number = 0): Promise<T> {
     try {
       return await fn();
     } catch (error: unknown) {
       const apiError = error as VoyageError;
       const isRateLimitError =
-        apiError?.status === 429 ||
-        apiError?.message?.toLowerCase().includes("rate limit");
+        apiError?.status === 429 || apiError?.message?.toLowerCase().includes("rate limit");
 
       if (isRateLimitError && attempt < this.retryAttempts) {
-        const delayMs = this.retryDelayMs * Math.pow(2, attempt);
+        const delayMs = this.retryDelayMs * 2 ** attempt;
         const waitTimeSeconds = (delayMs / 1000).toFixed(1);
         this.log.warn(
           {
@@ -84,7 +80,7 @@ export class VoyageEmbeddings implements EmbeddingProvider {
             attempt: attempt + 1,
             maxAttempts: this.retryAttempts,
           },
-          "Rate limit reached, retrying",
+          "Rate limit reached, retrying"
         );
 
         await new Promise((resolve) => setTimeout(resolve, delayMs));
@@ -93,7 +89,7 @@ export class VoyageEmbeddings implements EmbeddingProvider {
 
       if (isRateLimitError) {
         throw new Error(
-          `Voyage AI API rate limit exceeded after ${this.retryAttempts} retry attempts. Please try again later or reduce request frequency.`,
+          `Voyage AI API rate limit exceeded after ${this.retryAttempts} retry attempts. Please try again later or reduce request frequency.`
         );
       }
 
@@ -144,7 +140,7 @@ export class VoyageEmbeddings implements EmbeddingProvider {
           embedding: response.data[0].embedding,
           dimensions: this.dimensions,
         };
-      }),
+      })
     );
   }
 
@@ -162,7 +158,7 @@ export class VoyageEmbeddings implements EmbeddingProvider {
           embedding: item.embedding,
           dimensions: this.dimensions,
         }));
-      }),
+      })
     );
   }
 

package/src/git/chunker.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach } from "vitest";
+import { beforeEach, describe, expect, it } from "vitest";
 import { CommitChunker } from "./chunker.js";
 import { DEFAULT_GIT_CONFIG } from "./config.js";
 import type { GitConfig, RawCommit } from "./types.js";

package/src/git/chunker.ts

@@ -32,22 +32,14 @@ export class CommitChunker {
    * Currently produces one chunk per commit, but could be extended
    * to handle very large commits differently
    */
-  createChunks(
-    commit: RawCommit,
-    repoPath: string,
-    diff?: string,
-  ): CommitChunk[] {
+  createChunks(commit: RawCommit, repoPath: string, diff?: string): CommitChunk[] {
     const commitType = this.classifyCommitType(commit);
     const content = this.formatChunkContent(commit, commitType, diff);
 
     // Check if content exceeds max chunk size
     if (content.length > this.config.maxChunkSize) {
       // Truncate content but keep essential metadata visible
-      const truncatedContent = this.truncateContent(
-        content,
-        commit,
-        commitType,
-      );
+      const truncatedContent = this.truncateContent(content, commit, commitType);
       return [
         {
           content: truncatedContent,
@@ -77,11 +69,7 @@ export class CommitChunker {
   /**
    * Format the chunk content for embedding
    */
-  private formatChunkContent(
-    commit: RawCommit,
-    commitType: CommitType,
-    diff?: string,
-  ): string {
+  private formatChunkContent(commit: RawCommit, commitType: CommitType, diff?: string): string {
     const lines: string[] = [];
 
     // Header section
@@ -181,11 +169,7 @@ export class CommitChunker {
   /**
    * Truncate content while preserving essential information
    */
-  private truncateContent(
-    content: string,
-    commit: RawCommit,
-    commitType: CommitType,
-  ): string {
+  private truncateContent(_content: string, commit: RawCommit, commitType: CommitType): string {
     // Keep the header and subject, truncate the rest
     const essentialLines: string[] = [
       `Commit: ${commit.shortHash}`,
@@ -203,7 +187,7 @@ export class CommitChunker {
       const body = commit.body.trim();
       if (body.length > maxBodyLength) {
         essentialLines.push("Description:");
-        essentialLines.push(body.substring(0, maxBodyLength) + "...");
+        essentialLines.push(`${body.substring(0, maxBodyLength)}...`);
         essentialLines.push("");
       } else {
         essentialLines.push("Description:");
@@ -237,7 +221,7 @@ export class CommitChunker {
   private createMetadata(
     commit: RawCommit,
     commitType: CommitType,
-    repoPath: string,
+    repoPath: string
   ): CommitChunk["metadata"] {
     return {
       commitHash: commit.hash,