@mhalder/qdrant-mcp-server 2.1.2 → 3.0.0

package/src/git/chunker.ts

@@ -0,0 +1,256 @@
+/**
+ * CommitChunker - Create embeddable chunks from git commits
+ */
+
+import { createHash } from "node:crypto";
+import { COMMIT_TYPE_PATTERNS } from "./config.js";
+import type { CommitChunk, CommitType, GitConfig, RawCommit } from "./types.js";
+
+export class CommitChunker {
+  constructor(private config: GitConfig) {}
+
+  /**
+   * Classify commit type based on commit message
+   */
+  classifyCommitType(commit: RawCommit): CommitType {
+    const message = `${commit.subject} ${commit.body}`.toLowerCase();
+
+    // Check each type's patterns
+    for (const { type, patterns } of COMMIT_TYPE_PATTERNS) {
+      for (const pattern of patterns) {
+        if (pattern.test(commit.subject) || pattern.test(message)) {
+          return type;
+        }
+      }
+    }
+
+    return "other";
+  }
+
+  /**
+   * Create embeddable chunks from a commit
+   * Currently produces one chunk per commit, but could be extended
+   * to handle very large commits differently
+   */
+  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,
+      );
+      return [
+        {
+          content: truncatedContent,
+          metadata: this.createMetadata(commit, commitType, repoPath),
+        },
+      ];
+    }
+
+    return [
+      {
+        content,
+        metadata: this.createMetadata(commit, commitType, repoPath),
+      },
+    ];
+  }
+
+  /**
+   * Generate deterministic chunk ID from commit content
+   */
+  generateChunkId(chunk: CommitChunk): string {
+    // Use commit hash + repo path for deterministic ID
+    const data = `${chunk.metadata.commitHash}:${chunk.metadata.repoPath}`;
+    const hash = createHash("sha256").update(data).digest("hex");
+    return `gitcommit_${hash.substring(0, 16)}`;
+  }
+
+  /**
+   * Format the chunk content for embedding
+   */
+  private formatChunkContent(
+    commit: RawCommit,
+    commitType: CommitType,
+    diff?: string,
+  ): string {
+    const lines: string[] = [];
+
+    // Header section
+    lines.push(`Commit: ${commit.shortHash}`);
+    lines.push(`Type: ${commitType}`);
+    lines.push(`Author: ${commit.author}`);
+    lines.push(`Date: ${commit.date.toISOString().split("T")[0]}`);
+    lines.push("");
+
+    // Subject line
+    lines.push(`Subject: ${commit.subject}`);
+    lines.push("");
+
+    // Body (description) if present
+    if (commit.body.trim()) {
+      lines.push("Description:");
+      lines.push(commit.body.trim());
+      lines.push("");
+    }
+
+    // Files changed
+    if (this.config.includeFileList && commit.files.length > 0) {
+      lines.push(`Files changed (${commit.files.length}):`);
+      for (const file of commit.files.slice(0, 20)) {
+        // Limit to 20 files
+        lines.push(`  - ${file}`);
+      }
+      if (commit.files.length > 20) {
+        lines.push(`  ... and ${commit.files.length - 20} more files`);
+      }
+      lines.push("");
+    }
+
+    // Change stats
+    lines.push(`Changes: +${commit.insertions} -${commit.deletions}`);
+
+    // Diff preview if included
+    if (this.config.includeDiff && diff) {
+      lines.push("");
+      lines.push("Diff preview:");
+      lines.push(this.extractDiffPreview(diff));
+    }
+
+    return lines.join("\n");
+  }
+
+  /**
+   * Extract a readable preview from the diff
+   */
+  private extractDiffPreview(diff: string): string {
+    // Remove the commit metadata from the top of git show output
+    const diffStart = diff.indexOf("diff --git");
+    if (diffStart === -1) return "";
+
+    const diffContent = diff.substring(diffStart);
+
+    // Extract just the actual changes (lines starting with + or -)
+    // but not the diff headers
+    const lines = diffContent.split("\n");
+    const changeLines: string[] = [];
+    let currentFile = "";
+
+    for (const line of lines) {
+      if (line.startsWith("diff --git")) {
+        // Extract filename from diff header
+        const match = line.match(/diff --git a\/.+ b\/(.+)/);
+        if (match) {
+          currentFile = match[1];
+        }
+      } else if (line.startsWith("@@")) {
+        // Include hunk header with file context
+        if (currentFile && changeLines.length > 0) {
+          changeLines.push(`--- ${currentFile} ---`);
+        }
+        changeLines.push(line);
+      } else if (
+        (line.startsWith("+") || line.startsWith("-")) &&
+        !line.startsWith("+++") &&
+        !line.startsWith("---")
+      ) {
+        changeLines.push(line);
+      }
+    }
+
+    // Limit the preview size
+    const maxPreviewLines = 50;
+    if (changeLines.length > maxPreviewLines) {
+      return (
+        changeLines.slice(0, maxPreviewLines).join("\n") +
+        `\n... (${changeLines.length - maxPreviewLines} more lines)`
+      );
+    }
+
+    return changeLines.join("\n");
+  }
+
+  /**
+   * Truncate content while preserving essential information
+   */
+  private truncateContent(
+    content: string,
+    commit: RawCommit,
+    commitType: CommitType,
+  ): string {
+    // Keep the header and subject, truncate the rest
+    const essentialLines: string[] = [
+      `Commit: ${commit.shortHash}`,
+      `Type: ${commitType}`,
+      `Author: ${commit.author}`,
+      `Date: ${commit.date.toISOString().split("T")[0]}`,
+      "",
+      `Subject: ${commit.subject}`,
+      "",
+    ];
+
+    // Add truncated body if present
+    if (commit.body.trim()) {
+      const maxBodyLength = 500;
+      const body = commit.body.trim();
+      if (body.length > maxBodyLength) {
+        essentialLines.push("Description:");
+        essentialLines.push(body.substring(0, maxBodyLength) + "...");
+        essentialLines.push("");
+      } else {
+        essentialLines.push("Description:");
+        essentialLines.push(body);
+        essentialLines.push("");
+      }
+    }
+
+    // Add file summary
+    if (commit.files.length > 0) {
+      essentialLines.push(`Files changed (${commit.files.length}):`);
+      for (const file of commit.files.slice(0, 10)) {
+        essentialLines.push(`  - ${file}`);
+      }
+      if (commit.files.length > 10) {
+        essentialLines.push(`  ... and ${commit.files.length - 10} more files`);
+      }
+      essentialLines.push("");
+    }
+
+    essentialLines.push(`Changes: +${commit.insertions} -${commit.deletions}`);
+    essentialLines.push("");
+    essentialLines.push("[content truncated due to size]");
+
+    return essentialLines.join("\n");
+  }
+
+  /**
+   * Create metadata object for a chunk
+   */
+  private createMetadata(
+    commit: RawCommit,
+    commitType: CommitType,
+    repoPath: string,
+  ): CommitChunk["metadata"] {
+    return {
+      commitHash: commit.hash,
+      shortHash: commit.shortHash,
+      author: commit.author,
+      authorEmail: commit.authorEmail,
+      date: commit.date.toISOString(),
+      subject: commit.subject,
+      commitType,
+      files: commit.files,
+      insertions: commit.insertions,
+      deletions: commit.deletions,
+      repoPath,
+    };
+  }
+}

package/src/git/config.ts

@@ -0,0 +1,173 @@
+/**
+ * Default configuration and constants for git history indexing
+ */
+
+import type { CommitType, GitConfig } from "./types.js";
+
+/**
+ * Default configuration for git history indexing
+ */
+export const DEFAULT_GIT_CONFIG: GitConfig = {
+  maxCommits: 5000,
+  includeFileList: true,
+  includeDiff: true,
+  maxDiffSize: 5000, // 5KB max diff per commit
+  gitTimeout: 300000, // 5 minutes timeout for git commands
+  maxChunkSize: 3000,
+  batchSize: 100,
+  batchRetryAttempts: 3, // Retry failed batches up to 3 times
+  defaultSearchLimit: 10,
+  enableHybridSearch: true,
+};
+
+/**
+ * Patterns for classifying commit types based on conventional commits
+ * Order matters - first match wins
+ */
+export const COMMIT_TYPE_PATTERNS: Array<{
+  type: CommitType;
+  patterns: RegExp[];
+}> = [
+  {
+    type: "feat",
+    patterns: [
+      /^feat(\(.+\))?[!:]/, // feat: or feat(scope):
+      /^feature(\(.+\))?[!:]/,
+      /\badd(ed|s|ing)?\b.*\b(feature|functionality|support)/i,
+      /\bimplement(ed|s|ing)?\b/i,
+      /\bnew\b.*\b(feature|functionality)/i,
+    ],
+  },
+  {
+    type: "fix",
+    patterns: [
+      /^fix(\(.+\))?[!:]/,
+      /^bugfix(\(.+\))?[!:]/,
+      /^hotfix(\(.+\))?[!:]/,
+      /\bfix(ed|es|ing)?\b.*\b(bug|issue|problem|error)/i,
+      /\bresolve[ds]?\b.*\b(issue|bug|problem)/i,
+      /\bcorrect(ed|s|ing)?\b/i,
+    ],
+  },
+  {
+    type: "refactor",
+    patterns: [
+      /^refactor(\(.+\))?[!:]/,
+      /\brefactor(ed|s|ing)?\b/i,
+      /\brestructur(ed|es|ing)?\b/i,
+      /\breorganiz(ed|es|ing)?\b/i,
+      /\bclean(ed|s|ing)?\s*up\b/i,
+    ],
+  },
+  {
+    type: "docs",
+    patterns: [
+      /^docs?(\(.+\))?[!:]/,
+      /\bdocument(ed|s|ing|ation)?\b/i,
+      /\breadme\b/i,
+      /\bchangelog\b/i,
+      /\bcomments?\b/i,
+      /\bjsdoc\b/i,
+      /\btypedoc\b/i,
+    ],
+  },
+  {
+    type: "test",
+    patterns: [
+      /^test(\(.+\))?[!:]/,
+      /^tests?(\(.+\))?[!:]/,
+      /\btest(ed|s|ing)?\b/i,
+      /\bspec(s)?\b/i,
+      /\bcoverage\b/i,
+      /\bunit\s*test/i,
+      /\bintegration\s*test/i,
+      /\be2e\b/i,
+    ],
+  },
+  {
+    type: "chore",
+    patterns: [
+      /^chore(\(.+\))?[!:]/,
+      /\bchore\b/i,
+      /\bmaintenance\b/i,
+      /\bdependenc(y|ies)\b/i,
+      /\bbump(ed|s|ing)?\b.*\bversion/i,
+      /\bupgrade[ds]?\b/i,
+      /\bupdate[ds]?\b.*\b(dep|package|lock)/i,
+    ],
+  },
+  {
+    type: "style",
+    patterns: [
+      /^style(\(.+\))?[!:]/,
+      /\bformat(ted|s|ting)?\b/i,
+      /\blint(ed|s|ing)?\b/i,
+      /\bprettier\b/i,
+      /\beslint\b/i,
+      /\bwhitespace\b/i,
+      /\bindentation\b/i,
+    ],
+  },
+  {
+    type: "perf",
+    patterns: [
+      /^perf(\(.+\))?[!:]/,
+      /^performance(\(.+\))?[!:]/,
+      /\bperformance\b/i,
+      /\boptimiz(ed|es|ing|ation)?\b/i,
+      /\bspeed\s*up\b/i,
+      /\bfaster\b/i,
+      /\bcach(e|ed|ing)\b/i,
+    ],
+  },
+  {
+    type: "build",
+    patterns: [
+      /^build(\(.+\))?[!:]/,
+      /\bbuild\b/i,
+      /\bwebpack\b/i,
+      /\brollup\b/i,
+      /\bvite\b/i,
+      /\bbundl(e|ed|er|ing)\b/i,
+      /\bcompil(e|ed|er|ing|ation)\b/i,
+    ],
+  },
+  {
+    type: "ci",
+    patterns: [
+      /^ci(\(.+\))?[!:]/,
+      /\bci\b/i,
+      /\bgithub\s*actions?\b/i,
+      /\bworkflow\b/i,
+      /\bpipeline\b/i,
+      /\btravis\b/i,
+      /\bcircle\s*ci\b/i,
+      /\bjenkins\b/i,
+    ],
+  },
+  {
+    type: "revert",
+    patterns: [/^revert(\(.+\))?[!:]/, /\brevert(ed|s|ing)?\b/i],
+  },
+];
+
+/**
+ * Git log format string for extracting structured commit data
+ * Format: hash|shortHash|author|authorEmail|date|subject|body
+ */
+export const GIT_LOG_FORMAT = "%H|%h|%an|%ae|%aI|%s|%b";
+
+/**
+ * Delimiter used in git log output to separate commits
+ */
+export const GIT_LOG_COMMIT_DELIMITER = "---COMMIT_DELIMITER---";
+
+/**
+ * Max buffer size for git operations (50MB)
+ */
+export const GIT_MAX_BUFFER = 50 * 1024 * 1024;
+
+/**
+ * Reserved ID for storing indexing metadata in the collection
+ */
+export const GIT_INDEXING_METADATA_ID = "__git_indexing_metadata__";

package/src/git/extractor.integration.test.ts

@@ -0,0 +1,221 @@
+/**
+ * Integration tests for GitExtractor
+ * These tests run against real git repositories (not mocked)
+ */
+
+import { describe, it, expect, beforeAll } from "vitest";
+import { GitExtractor } from "./extractor.js";
+import { DEFAULT_GIT_CONFIG } from "./config.js";
+import type { GitConfig } from "./types.js";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+describe("GitExtractor Integration Tests", () => {
+  let extractor: GitExtractor;
+  const config: GitConfig = { ...DEFAULT_GIT_CONFIG, maxCommits: 100 };
+
+  // Use the current repository for integration tests
+  const repoPath = process.cwd();
+
+  beforeAll(async () => {
+    extractor = new GitExtractor(repoPath, config);
+
+    // Verify we're in a git repository
+    const isRepo = await extractor.validateRepository();
+    if (!isRepo) {
+      throw new Error("Integration tests must be run from a git repository");
+    }
+  });
+
+  describe("validateRepository", () => {
+    it("should detect valid git repository", async () => {
+      const result = await extractor.validateRepository();
+      expect(result).toBe(true);
+    });
+
+    it("should return false for non-existent path", async () => {
+      const badExtractor = new GitExtractor("/nonexistent/path", config);
+      const result = await badExtractor.validateRepository();
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("getCommits - data integrity", () => {
+    it("should extract commits without data corruption", async () => {
+      const commits = await extractor.getCommits({ maxCommits: 50 });
+
+      expect(commits.length).toBeGreaterThan(0);
+      expect(commits.length).toBeLessThanOrEqual(50);
+
+      for (const commit of commits) {
+        // Verify hash format (40 hex characters)
+        expect(commit.hash).toMatch(/^[a-f0-9]{40}$/);
+
+        // Verify short hash format (7+ hex characters)
+        expect(commit.shortHash).toMatch(/^[a-f0-9]{7,}$/);
+
+        // Verify author is not empty
+        expect(commit.author.length).toBeGreaterThan(0);
+
+        // Verify author email format
+        expect(commit.authorEmail).toMatch(/.+@.+/);
+
+        // Verify date is valid
+        expect(commit.date).toBeInstanceOf(Date);
+        expect(commit.date.getTime()).not.toBeNaN();
+
+        // Verify subject is not empty
+        expect(commit.subject.length).toBeGreaterThan(0);
+
+        // CRITICAL: Verify fields don't contain numstat patterns
+        // This catches the parsing bug where numstat bleeds into format fields
+        const numstatPattern = /^\d+\s+\d+\s+\S+/;
+        expect(commit.hash).not.toMatch(numstatPattern);
+        expect(commit.author).not.toMatch(numstatPattern);
+        expect(commit.subject).not.toMatch(numstatPattern);
+
+        // Verify insertions/deletions are non-negative integers
+        expect(commit.insertions).toBeGreaterThanOrEqual(0);
+        expect(commit.deletions).toBeGreaterThanOrEqual(0);
+        expect(Number.isInteger(commit.insertions)).toBe(true);
+        expect(Number.isInteger(commit.deletions)).toBe(true);
+
+        // Verify files array
+        expect(Array.isArray(commit.files)).toBe(true);
+        for (const file of commit.files) {
+          expect(typeof file).toBe("string");
+          expect(file.length).toBeGreaterThan(0);
+        }
+      }
+    });
+
+    it("should return correct commit count matching git rev-list", async () => {
+      // Get expected count from git directly
+      const { stdout } = await execFileAsync(
+        "git",
+        ["rev-list", "--count", "-n", "50", "HEAD"],
+        { cwd: repoPath },
+      );
+      const expectedCount = Math.min(parseInt(stdout.trim(), 10), 50);
+
+      // Get commits via extractor
+      const commits = await extractor.getCommits({ maxCommits: 50 });
+
+      // Should match exactly
+      expect(commits.length).toBe(expectedCount);
+    });
+
+    it("should extract files correctly with stats", async () => {
+      // Find a commit with files using git log
+      const { stdout: logOutput } = await execFileAsync(
+        "git",
+        ["log", "--oneline", "--shortstat", "-n", "10", "HEAD"],
+        { cwd: repoPath },
+      );
+
+      // If there are commits with files changed, verify our extractor gets them
+      if (logOutput.includes("file")) {
+        const commits = await extractor.getCommits({ maxCommits: 10 });
+        const commitsWithFiles = commits.filter((c) => c.files.length > 0);
+
+        // At least some commits should have files
+        expect(commitsWithFiles.length).toBeGreaterThan(0);
+
+        // Verify files and stats are consistent
+        for (const commit of commitsWithFiles) {
+          // If there are files, there should typically be insertions or deletions
+          // (unless all files are renames with no changes)
+          expect(commit.files.length).toBeGreaterThan(0);
+        }
+      }
+    });
+  });
+
+  describe("getCommits - range filtering", () => {
+    it("should support sinceCommit range filtering", async () => {
+      // Get all commits first
+      const allCommits = await extractor.getCommits({ maxCommits: 20 });
+
+      if (allCommits.length >= 5) {
+        // Use the 5th commit as the "since" point
+        const sinceHash = allCommits[4].hash;
+
+        // Get commits since that point
+        const recentCommits = await extractor.getCommits({
+          sinceCommit: sinceHash,
+          maxCommits: 20,
+        });
+
+        // Should have fewer commits (the 4 before the since point)
+        expect(recentCommits.length).toBeLessThan(allCommits.length);
+        expect(recentCommits.length).toBe(4);
+
+        // Verify the commits are the expected ones
+        for (let i = 0; i < recentCommits.length; i++) {
+          expect(recentCommits[i].hash).toBe(allCommits[i].hash);
+        }
+      }
+    });
+  });
+
+  describe("getCommitDiff", () => {
+    it("should return diff for a valid commit", async () => {
+      const commits = await extractor.getCommits({ maxCommits: 1 });
+
+      if (commits.length > 0) {
+        const diff = await extractor.getCommitDiff(commits[0].hash);
+
+        // Diff should contain commit information
+        expect(diff).toContain("commit");
+        expect(diff).toContain(commits[0].hash);
+      }
+    });
+
+    it("should return empty string for invalid commit", async () => {
+      const diff = await extractor.getCommitDiff("0000000000000000000000000000000000000000");
+      expect(diff).toBe("");
+    });
+  });
+
+  describe("getLatestCommitHash", () => {
+    it("should return the HEAD commit hash", async () => {
+      const hash = await extractor.getLatestCommitHash();
+
+      // Verify format
+      expect(hash).toMatch(/^[a-f0-9]{40}$/);
+
+      // Verify it matches git rev-parse HEAD
+      const { stdout } = await execFileAsync("git", ["rev-parse", "HEAD"], {
+        cwd: repoPath,
+      });
+      expect(hash).toBe(stdout.trim());
+    });
+  });
+
+  describe("getCommitCount", () => {
+    it("should return total commit count", async () => {
+      const count = await extractor.getCommitCount();
+
+      // Verify against git rev-list
+      const { stdout } = await execFileAsync(
+        "git",
+        ["rev-list", "--count", "HEAD"],
+        { cwd: repoPath },
+      );
+      expect(count).toBe(parseInt(stdout.trim(), 10));
+    });
+
+    it("should return count since specific commit", async () => {
+      const commits = await extractor.getCommits({ maxCommits: 10 });
+
+      if (commits.length >= 5) {
+        const sinceHash = commits[4].hash;
+        const count = await extractor.getCommitCount(sinceHash);
+
+        expect(count).toBe(4); // 4 commits between sinceHash and HEAD
+      }
+    });
+  });
+});