@mhalder/qdrant-mcp-server 2.1.2 → 3.0.0

package/src/git/sync/synchronizer.test.ts

@@ -0,0 +1,250 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { GitSynchronizer } from "./synchronizer.js";
+
+// Mock fs module
+vi.mock("node:fs", () => ({
+  promises: {
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    rename: vi.fn(),
+    unlink: vi.fn(),
+    access: vi.fn(),
+    mkdir: vi.fn(),
+  },
+}));
+
+// Mock os module
+vi.mock("node:os", () => ({
+  homedir: vi.fn(() => "/home/test"),
+}));
+
+import { promises as fs } from "node:fs";
+
+describe("GitSynchronizer", () => {
+  let synchronizer: GitSynchronizer;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    synchronizer = new GitSynchronizer("/test/repo", "git_abc12345");
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("initialize", () => {
+    it("should return true when snapshot exists and matches repo", async () => {
+      const snapshot = {
+        repoPath: "/test/repo",
+        lastCommitHash: "abc123",
+        lastIndexedAt: Date.now(),
+        commitsIndexed: 100,
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(snapshot));
+
+      const result = await synchronizer.initialize();
+
+      expect(result).toBe(true);
+      expect(synchronizer.getLastCommitHash()).toBe("abc123");
+      expect(synchronizer.getCommitsIndexed()).toBe(100);
+    });
+
+    it("should return false when snapshot does not exist", async () => {
+      vi.mocked(fs.readFile).mockRejectedValue(
+        new Error("ENOENT: no such file"),
+      );
+
+      const result = await synchronizer.initialize();
+
+      expect(result).toBe(false);
+      expect(synchronizer.getLastCommitHash()).toBeNull();
+    });
+
+    it("should return false when snapshot is for different repo", async () => {
+      const snapshot = {
+        repoPath: "/different/repo",
+        lastCommitHash: "abc123",
+        lastIndexedAt: Date.now(),
+        commitsIndexed: 100,
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(snapshot));
+
+      const result = await synchronizer.initialize();
+
+      expect(result).toBe(false);
+      expect(synchronizer.getLastCommitHash()).toBeNull();
+    });
+
+    it("should return false when snapshot is invalid JSON", async () => {
+      vi.mocked(fs.readFile).mockResolvedValue("not valid json");
+
+      const result = await synchronizer.initialize();
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("getLastCommitHash", () => {
+    it("should return null when no snapshot loaded", () => {
+      expect(synchronizer.getLastCommitHash()).toBeNull();
+    });
+
+    it("should return hash after loading snapshot", async () => {
+      const snapshot = {
+        repoPath: "/test/repo",
+        lastCommitHash: "xyz789",
+        lastIndexedAt: Date.now(),
+        commitsIndexed: 50,
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(snapshot));
+      await synchronizer.initialize();
+
+      expect(synchronizer.getLastCommitHash()).toBe("xyz789");
+    });
+  });
+
+  describe("getLastIndexedAt", () => {
+    it("should return null when no snapshot loaded", () => {
+      expect(synchronizer.getLastIndexedAt()).toBeNull();
+    });
+
+    it("should return date after loading snapshot", async () => {
+      const timestamp = Date.now();
+      const snapshot = {
+        repoPath: "/test/repo",
+        lastCommitHash: "abc123",
+        lastIndexedAt: timestamp,
+        commitsIndexed: 50,
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(snapshot));
+      await synchronizer.initialize();
+
+      const date = synchronizer.getLastIndexedAt();
+      expect(date).toBeInstanceOf(Date);
+      expect(date?.getTime()).toBe(timestamp);
+    });
+  });
+
+  describe("getCommitsIndexed", () => {
+    it("should return 0 when no snapshot loaded", () => {
+      expect(synchronizer.getCommitsIndexed()).toBe(0);
+    });
+
+    it("should return count after loading snapshot", async () => {
+      const snapshot = {
+        repoPath: "/test/repo",
+        lastCommitHash: "abc123",
+        lastIndexedAt: Date.now(),
+        commitsIndexed: 150,
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(snapshot));
+      await synchronizer.initialize();
+
+      expect(synchronizer.getCommitsIndexed()).toBe(150);
+    });
+  });
+
+  describe("updateSnapshot", () => {
+    it("should write snapshot to file", async () => {
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+      vi.mocked(fs.rename).mockResolvedValue(undefined);
+
+      await synchronizer.updateSnapshot("def456", 200);
+
+      expect(fs.mkdir).toHaveBeenCalledWith(
+        expect.stringContaining("git-snapshots"),
+        { recursive: true },
+      );
+      // Check the file was written with correct data (JSON may be formatted)
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining(".tmp"),
+        expect.stringMatching(/lastCommitHash.*def456/s),
+      );
+      expect(fs.rename).toHaveBeenCalled();
+
+      // Verify internal state was updated
+      expect(synchronizer.getLastCommitHash()).toBe("def456");
+      expect(synchronizer.getCommitsIndexed()).toBe(200);
+    });
+
+    it("should use atomic write with rename", async () => {
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+      vi.mocked(fs.rename).mockResolvedValue(undefined);
+
+      await synchronizer.updateSnapshot("abc123", 100);
+
+      // Verify write to temp file first, then rename
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const renameCall = vi.mocked(fs.rename).mock.calls[0];
+
+      expect(writeCall[0]).toContain(".tmp");
+      expect(renameCall[0]).toContain(".tmp");
+      expect(renameCall[1]).not.toContain(".tmp");
+    });
+  });
+
+  describe("deleteSnapshot", () => {
+    it("should delete snapshot file", async () => {
+      vi.mocked(fs.unlink).mockResolvedValue(undefined);
+
+      await synchronizer.deleteSnapshot();
+
+      expect(fs.unlink).toHaveBeenCalled();
+      expect(synchronizer.getLastCommitHash()).toBeNull();
+    });
+
+    it("should not throw when file does not exist", async () => {
+      vi.mocked(fs.unlink).mockRejectedValue(new Error("ENOENT"));
+
+      await expect(synchronizer.deleteSnapshot()).resolves.not.toThrow();
+    });
+  });
+
+  describe("exists", () => {
+    it("should return true when snapshot file exists", async () => {
+      vi.mocked(fs.access).mockResolvedValue(undefined);
+
+      const result = await synchronizer.exists();
+
+      expect(result).toBe(true);
+    });
+
+    it("should return false when snapshot file does not exist", async () => {
+      vi.mocked(fs.access).mockRejectedValue(new Error("ENOENT"));
+
+      const result = await synchronizer.exists();
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("getSnapshotAge", () => {
+    it("should return null when no snapshot loaded", () => {
+      expect(synchronizer.getSnapshotAge()).toBeNull();
+    });
+
+    it("should return age in milliseconds", async () => {
+      const timestamp = Date.now() - 10000; // 10 seconds ago
+      const snapshot = {
+        repoPath: "/test/repo",
+        lastCommitHash: "abc123",
+        lastIndexedAt: timestamp,
+        commitsIndexed: 50,
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(snapshot));
+      await synchronizer.initialize();
+
+      const age = synchronizer.getSnapshotAge();
+      expect(age).toBeGreaterThanOrEqual(10000);
+      expect(age).toBeLessThan(11000);
+    });
+  });
+});

package/src/git/sync/synchronizer.ts

@@ -0,0 +1,122 @@
+/**
+ * GitSynchronizer - Track last indexed commit for incremental updates
+ */
+
+import { promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import type { GitSnapshot } from "../types.js";
+
+export class GitSynchronizer {
+  private snapshotPath: string;
+  private snapshot: GitSnapshot | null = null;
+
+  constructor(
+    private repoPath: string,
+    collectionName: string,
+  ) {
+    // Store snapshots in ~/.qdrant-mcp/git-snapshots/
+    const snapshotDir = join(homedir(), ".qdrant-mcp", "git-snapshots");
+    this.snapshotPath = join(snapshotDir, `${collectionName}.json`);
+  }
+
+  /**
+   * Initialize synchronizer by loading existing snapshot
+   * @returns true if snapshot exists and was loaded
+   */
+  async initialize(): Promise<boolean> {
+    try {
+      const content = await fs.readFile(this.snapshotPath, "utf-8");
+      this.snapshot = JSON.parse(content) as GitSnapshot;
+
+      // Validate snapshot is for the same repo
+      if (this.snapshot.repoPath !== this.repoPath) {
+        this.snapshot = null;
+        return false;
+      }
+
+      return true;
+    } catch {
+      this.snapshot = null;
+      return false;
+    }
+  }
+
+  /**
+   * Get the last indexed commit hash
+   */
+  getLastCommitHash(): string | null {
+    return this.snapshot?.lastCommitHash ?? null;
+  }
+
+  /**
+   * Get the timestamp of last indexing
+   */
+  getLastIndexedAt(): Date | null {
+    if (!this.snapshot) return null;
+    return new Date(this.snapshot.lastIndexedAt);
+  }
+
+  /**
+   * Get the number of commits indexed
+   */
+  getCommitsIndexed(): number {
+    return this.snapshot?.commitsIndexed ?? 0;
+  }
+
+  /**
+   * Update snapshot with new indexing state
+   */
+  async updateSnapshot(
+    lastCommitHash: string,
+    commitsIndexed: number,
+  ): Promise<void> {
+    this.snapshot = {
+      repoPath: this.repoPath,
+      lastCommitHash,
+      lastIndexedAt: Date.now(),
+      commitsIndexed,
+    };
+
+    // Ensure directory exists
+    const dir = dirname(this.snapshotPath);
+    await fs.mkdir(dir, { recursive: true });
+
+    // Write snapshot atomically using temp file
+    const tempPath = `${this.snapshotPath}.tmp`;
+    await fs.writeFile(tempPath, JSON.stringify(this.snapshot, null, 2));
+    await fs.rename(tempPath, this.snapshotPath);
+  }
+
+  /**
+   * Delete the snapshot file
+   */
+  async deleteSnapshot(): Promise<void> {
+    try {
+      await fs.unlink(this.snapshotPath);
+      this.snapshot = null;
+    } catch {
+      // Ignore if file doesn't exist
+    }
+  }
+
+  /**
+   * Check if snapshot exists
+   */
+  async exists(): Promise<boolean> {
+    try {
+      await fs.access(this.snapshotPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get snapshot age in milliseconds
+   */
+  getSnapshotAge(): number | null {
+    if (!this.snapshot) return null;
+    return Date.now() - this.snapshot.lastIndexedAt;
+  }
+}

package/src/git/types.ts

@@ -0,0 +1,192 @@
+/**
+ * Type definitions for git history indexing module
+ */
+
+/**
+ * Commit type classification based on conventional commits
+ */
+export type CommitType =
+  | "feat"
+  | "fix"
+  | "refactor"
+  | "docs"
+  | "test"
+  | "chore"
+  | "style"
+  | "perf"
+  | "build"
+  | "ci"
+  | "revert"
+  | "other";
+
+/**
+ * Configuration for git history indexing
+ */
+export interface GitConfig {
+  // Commit extraction
+  maxCommits: number; // Max commits to index per run
+  includeFileList: boolean; // Include changed file list in chunks
+  includeDiff: boolean; // Include truncated diff in chunks
+  maxDiffSize: number; // Max bytes of diff per commit
+  gitTimeout: number; // Timeout for git commands in milliseconds
+
+  // Chunking
+  maxChunkSize: number; // Max characters per chunk
+
+  // Indexing
+  batchSize: number; // Embeddings per batch
+  batchRetryAttempts: number; // Number of retry attempts for failed batches
+
+  // Search
+  defaultSearchLimit: number; // Default search results
+  enableHybridSearch: boolean; // Enable hybrid search
+}
+
+/**
+ * Raw commit data parsed from git log
+ */
+export interface RawCommit {
+  hash: string; // Full commit hash
+  shortHash: string; // Short hash (7 chars)
+  author: string; // Author name
+  authorEmail: string; // Author email
+  date: Date; // Commit date
+  subject: string; // First line of commit message
+  body: string; // Full commit message body
+  files: string[]; // Changed files
+  insertions: number; // Lines added
+  deletions: number; // Lines deleted
+}
+
+/**
+ * Embeddable chunk created from a commit
+ */
+export interface CommitChunk {
+  content: string; // Text content for embedding
+  metadata: {
+    commitHash: string;
+    shortHash: string;
+    author: string;
+    authorEmail: string;
+    date: string; // ISO date string
+    subject: string;
+    commitType: CommitType;
+    files: string[];
+    insertions: number;
+    deletions: number;
+    repoPath: string;
+  };
+}
+
+/**
+ * Options for indexing git history
+ */
+export interface GitIndexOptions {
+  forceReindex?: boolean; // Delete existing and re-index
+  sinceDate?: string; // ISO date string - only index commits after this date
+  maxCommits?: number; // Override config maxCommits
+}
+
+/**
+ * Statistics from indexing operation
+ */
+export interface GitIndexStats {
+  commitsScanned: number;
+  commitsIndexed: number;
+  chunksCreated: number;
+  durationMs: number;
+  status: "completed" | "partial" | "failed";
+  errors?: string[];
+}
+
+/**
+ * Statistics from incremental update operation
+ */
+export interface GitChangeStats {
+  newCommits: number;
+  chunksAdded: number;
+  durationMs: number;
+}
+
+/**
+ * Search result from git history
+ */
+export interface GitSearchResult {
+  content: string;
+  commitHash: string;
+  shortHash: string;
+  author: string;
+  date: string;
+  subject: string;
+  commitType: CommitType;
+  files: string[];
+  score: number;
+}
+
+/**
+ * Search options for git history
+ */
+export interface GitSearchOptions {
+  limit?: number;
+  useHybrid?: boolean;
+  commitTypes?: CommitType[]; // Filter by commit type
+  authors?: string[]; // Filter by author name/email
+  dateFrom?: string; // ISO date string - only commits after
+  dateTo?: string; // ISO date string - only commits before
+  scoreThreshold?: number;
+}
+
+/**
+ * Indexing status for a repository
+ */
+export type GitIndexingStatus = "not_indexed" | "indexing" | "indexed";
+
+/**
+ * Status information for a git history index
+ */
+export interface GitIndexStatus {
+  /** @deprecated Use `status` instead. True only when status is 'indexed'. */
+  isIndexed: boolean;
+  /** Current indexing status: 'not_indexed', 'indexing', or 'indexed' */
+  status: GitIndexingStatus;
+  collectionName?: string;
+  commitsCount?: number;
+  chunksCount?: number;
+  lastCommitHash?: string;
+  lastIndexedAt?: Date;
+}
+
+/**
+ * Progress callback for indexing operations
+ */
+export type GitProgressCallback = (progress: GitProgressUpdate) => void;
+
+/**
+ * Progress update during indexing
+ */
+export interface GitProgressUpdate {
+  phase: "extracting" | "chunking" | "embedding" | "storing";
+  current: number;
+  total: number;
+  percentage: number;
+  message: string;
+}
+
+/**
+ * Snapshot for tracking last indexed commit
+ */
+export interface GitSnapshot {
+  repoPath: string;
+  lastCommitHash: string;
+  lastIndexedAt: number; // Unix timestamp
+  commitsIndexed: number;
+}
+
+/**
+ * Options for extracting commits from git
+ */
+export interface GitExtractOptions {
+  sinceCommit?: string; // Only commits after this hash
+  sinceDate?: string; // Only commits after this date (ISO string)
+  maxCommits?: number; // Limit number of commits
+}

package/src/index.ts

@@ -18,6 +18,8 @@ import {
 } from "./code/config.js";
 import { CodeIndexer } from "./code/indexer.js";
 import type { CodeConfig } from "./code/types.js";
+import { DEFAULT_GIT_CONFIG, GitHistoryIndexer } from "./git/index.js";
+import type { GitConfig } from "./git/types.js";
 import { EmbeddingProviderFactory } from "./embeddings/factory.js";
 import { loadPromptsConfig, type PromptsConfig } from "./prompts/index.js";
 import { registerAllPrompts } from "./prompts/register.js";
@@ -183,6 +185,45 @@ const codeConfig: CodeConfig = {
 
 const codeIndexer = new CodeIndexer(qdrant, embeddings, codeConfig);
 
+// Initialize git history indexer
+const gitConfig: GitConfig = {
+  maxCommits: parseInt(
+    process.env.GIT_MAX_COMMITS || String(DEFAULT_GIT_CONFIG.maxCommits),
+    10,
+  ),
+  includeFileList: process.env.GIT_INCLUDE_FILES !== "false",
+  includeDiff: process.env.GIT_INCLUDE_DIFF !== "false",
+  maxDiffSize: parseInt(
+    process.env.GIT_MAX_DIFF_SIZE || String(DEFAULT_GIT_CONFIG.maxDiffSize),
+    10,
+  ),
+  gitTimeout: parseInt(
+    process.env.GIT_TIMEOUT || String(DEFAULT_GIT_CONFIG.gitTimeout),
+    10,
+  ),
+  maxChunkSize: parseInt(
+    process.env.GIT_MAX_CHUNK_SIZE || String(DEFAULT_GIT_CONFIG.maxChunkSize),
+    10,
+  ),
+  batchSize: parseInt(
+    process.env.GIT_BATCH_SIZE || String(DEFAULT_GIT_CONFIG.batchSize),
+    10,
+  ),
+  batchRetryAttempts: parseInt(
+    process.env.GIT_BATCH_RETRY_ATTEMPTS ||
+      String(DEFAULT_GIT_CONFIG.batchRetryAttempts),
+    10,
+  ),
+  defaultSearchLimit: parseInt(
+    process.env.GIT_SEARCH_LIMIT ||
+      String(DEFAULT_GIT_CONFIG.defaultSearchLimit),
+    10,
+  ),
+  enableHybridSearch: process.env.GIT_ENABLE_HYBRID !== "false",
+};
+
+const gitHistoryIndexer = new GitHistoryIndexer(qdrant, embeddings, gitConfig);
+
 // Load prompts configuration if file exists
 let promptsConfig: PromptsConfig | null = null;
 if (existsSync(PROMPTS_CONFIG_FILE)) {
@@ -213,6 +254,7 @@ function createAndConfigureServer(): McpServer {
       qdrant,
       embeddings,
       codeIndexer,
+      gitHistoryIndexer,
     });
 
     // Register all resources

package/src/qdrant/client.test.ts

@@ -634,6 +634,35 @@ describe("QdrantManager", () => {
     });
   });
 
+  describe("deletePointsByFilter", () => {
+    it("should delete points matching filter", async () => {
+      const filter = {
+        must: [{ key: "relativePath", match: { value: "src/test.ts" } }],
+      };
+      await manager.deletePointsByFilter("test-collection", filter);
+
+      expect(mockClient.delete).toHaveBeenCalledWith("test-collection", {
+        wait: true,
+        filter: filter,
+      });
+    });
+
+    it("should delete points with complex filter", async () => {
+      const filter = {
+        must: [
+          { key: "relativePath", match: { value: "src/utils.ts" } },
+          { key: "language", match: { value: "typescript" } },
+        ],
+      };
+      await manager.deletePointsByFilter("test-collection", filter);
+
+      expect(mockClient.delete).toHaveBeenCalledWith("test-collection", {
+        wait: true,
+        filter: filter,
+      });
+    });
+  });
+
   describe("hybridSearch", () => {
     beforeEach(() => {
       mockClient.query = vi.fn();

package/src/qdrant/client.ts

@@ -240,6 +240,20 @@ export class QdrantManager {
     });
   }
 
+  /**
+   * Deletes points matching a filter condition.
+   * Useful for deleting all chunks associated with a specific file path.
+   */
+  async deletePointsByFilter(
+    collectionName: string,
+    filter: Record<string, any>,
+  ): Promise<void> {
+    await this.client.delete(collectionName, {
+      wait: true,
+      filter: filter,
+    });
+  }
+
   /**
    * Performs hybrid search combining semantic vector search with sparse vector (keyword) search
    * using Reciprocal Rank Fusion (RRF) to combine results