@mhalder/qdrant-mcp-server 2.2.0 → 3.1.0

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
+      }
+    });
+  });
+});

package/src/git/extractor.test.ts

@@ -0,0 +1,403 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { GitExtractor, normalizeRemoteUrl } from "./extractor.js";
+import { DEFAULT_GIT_CONFIG, GIT_LOG_COMMIT_DELIMITER } from "./config.js";
+import type { GitConfig } from "./types.js";
+
+// Mock child_process with promisify-compatible execFile
+vi.mock("node:child_process", () => ({
+  execFile: vi.fn(),
+}));
+
+vi.mock("node:util", () => ({
+  promisify: (fn: any) => fn,
+}));
+
+import { execFile } from "node:child_process";
+
+const mockExecFile = vi.mocked(execFile);
+
+describe("GitExtractor", () => {
+  let extractor: GitExtractor;
+  const config: GitConfig = { ...DEFAULT_GIT_CONFIG };
+
+  beforeEach(() => {
+    mockExecFile.mockReset();
+    extractor = new GitExtractor("/test/repo", config);
+  });
+
+  describe("validateRepository", () => {
+    it("should return true for valid git repository", async () => {
+      mockExecFile.mockResolvedValue({ stdout: ".git", stderr: "" } as any);
+
+      const result = await extractor.validateRepository();
+
+      expect(result).toBe(true);
+      expect(mockExecFile).toHaveBeenCalledWith(
+        "git",
+        ["rev-parse", "--git-dir"],
+        expect.objectContaining({ cwd: "/test/repo" }),
+      );
+    });
+
+    it("should return false for non-git directory", async () => {
+      mockExecFile.mockRejectedValue(new Error("fatal: not a git repository"));
+
+      const result = await extractor.validateRepository();
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("getLatestCommitHash", () => {
+    it("should return latest commit hash", async () => {
+      mockExecFile.mockResolvedValue({
+        stdout: "abc123def456789\n",
+        stderr: "",
+      } as any);
+
+      const result = await extractor.getLatestCommitHash();
+
+      expect(result).toBe("abc123def456789");
+      expect(mockExecFile).toHaveBeenCalledWith(
+        "git",
+        ["rev-parse", "HEAD"],
+        expect.objectContaining({ cwd: "/test/repo" }),
+      );
+    });
+  });
+
+  describe("getCommitCount", () => {
+    it("should return total commit count", async () => {
+      mockExecFile.mockResolvedValue({ stdout: "42\n", stderr: "" } as any);
+
+      const result = await extractor.getCommitCount();
+
+      expect(result).toBe(42);
+      expect(mockExecFile).toHaveBeenCalledWith(
+        "git",
+        ["rev-list", "--count", "HEAD"],
+        expect.objectContaining({ cwd: "/test/repo" }),
+      );
+    });
+
+    it("should return commit count since specific commit", async () => {
+      mockExecFile.mockResolvedValue({ stdout: "10\n", stderr: "" } as any);
+
+      const result = await extractor.getCommitCount("abc123");
+
+      expect(result).toBe(10);
+      expect(mockExecFile).toHaveBeenCalledWith(
+        "git",
+        ["rev-list", "--count", "abc123..HEAD"],
+        expect.objectContaining({ cwd: "/test/repo" }),
+      );
+    });
+  });
+
+  describe("getCommits", () => {
+    it("should parse commits from git log output", async () => {
+      const gitLogOutput = [
+        GIT_LOG_COMMIT_DELIMITER,
+        "abc123def|abc123d|John Doe|john@example.com|2024-01-15T10:30:00Z|feat: add new feature|This is the body",
+        "",
+        "10\t5\tsrc/feature.ts",
+        "3\t1\tsrc/utils.ts",
+        GIT_LOG_COMMIT_DELIMITER,
+        "xyz789ghi|xyz789g|Jane Smith|jane@example.com|2024-01-14T09:00:00Z|fix: resolve bug|Bug fix description",
+        "",
+        "2\t8\tsrc/bug.ts",
+      ].join("\n");
+
+      mockExecFile.mockResolvedValue({
+        stdout: gitLogOutput,
+        stderr: "",
+      } as any);
+
+      const result = await extractor.getCommits();
+
+      expect(result).toHaveLength(2);
+
+      // First commit
+      expect(result[0].hash).toBe("abc123def");
+      expect(result[0].shortHash).toBe("abc123d");
+      expect(result[0].author).toBe("John Doe");
+      expect(result[0].authorEmail).toBe("john@example.com");
+      expect(result[0].subject).toBe("feat: add new feature");
+      expect(result[0].body).toBe("This is the body");
+      expect(result[0].files).toEqual(["src/feature.ts", "src/utils.ts"]);
+      expect(result[0].insertions).toBe(13);
+      expect(result[0].deletions).toBe(6);
+
+      // Second commit
+      expect(result[1].hash).toBe("xyz789ghi");
+      expect(result[1].subject).toBe("fix: resolve bug");
+      expect(result[1].files).toEqual(["src/bug.ts"]);
+      expect(result[1].insertions).toBe(2);
+      expect(result[1].deletions).toBe(8);
+    });
+
+    it("should handle commits with no files", async () => {
+      const gitLogOutput = [
+        GIT_LOG_COMMIT_DELIMITER,
+        "abc123|abc12|Author|author@example.com|2024-01-15T10:00:00Z|chore: empty commit|",
+      ].join("\n");
+
+      mockExecFile.mockResolvedValue({
+        stdout: gitLogOutput,
+        stderr: "",
+      } as any);
+
+      const result = await extractor.getCommits();
+
+      expect(result).toHaveLength(1);
+      expect(result[0].files).toEqual([]);
+      expect(result[0].insertions).toBe(0);
+      expect(result[0].deletions).toBe(0);
+    });
+
+    it("should handle binary files in numstat", async () => {
+      const gitLogOutput = [
+        GIT_LOG_COMMIT_DELIMITER,
+        "abc123|abc12|Author|author@example.com|2024-01-15T10:00:00Z|feat: add image|",
+        "",
+        "-\t-\tassets/image.png",
+        "5\t2\tsrc/component.ts",
+      ].join("\n");
+
+      mockExecFile.mockResolvedValue({
+        stdout: gitLogOutput,
+        stderr: "",
+      } as any);
+
+      const result = await extractor.getCommits();
+
+      expect(result[0].files).toEqual(["assets/image.png", "src/component.ts"]);
+      expect(result[0].insertions).toBe(5); // Binary files don't count
+      expect(result[0].deletions).toBe(2);
+    });
+
+    it("should handle renamed files", async () => {
+      const gitLogOutput = [
+        GIT_LOG_COMMIT_DELIMITER,
+        "abc123|abc12|Author|author@example.com|2024-01-15T10:00:00Z|refactor: rename file|",
+        "",
+        "0\t0\tsrc/{old.ts => new.ts}",
+      ].join("\n");
+
+      mockExecFile.mockResolvedValue({
+        stdout: gitLogOutput,
+        stderr: "",
+      } as any);
+
+      const result = await extractor.getCommits();
+
+      expect(result[0].files).toEqual(["src/new.ts"]);
+    });
+
+    it("should respect maxCommits option", async () => {
+      mockExecFile.mockResolvedValue({ stdout: "", stderr: "" } as any);
+
+      await extractor.getCommits({ maxCommits: 100 });
+
+      expect(mockExecFile).toHaveBeenCalledWith(
+        "git",
+        expect.arrayContaining(["-n100"]),
+        expect.any(Object),
+      );
+    });
+
+    it("should add sinceCommit range when specified", async () => {
+      mockExecFile.mockResolvedValue({ stdout: "", stderr: "" } as any);
+
+      await extractor.getCommits({ sinceCommit: "abc123" });
+
+      expect(mockExecFile).toHaveBeenCalledWith(
+        "git",
+        expect.arrayContaining(["abc123..HEAD"]),
+        expect.any(Object),
+      );
+    });
+
+    it("should add sinceDate filter when specified", async () => {
+      mockExecFile.mockResolvedValue({ stdout: "", stderr: "" } as any);
+
+      await extractor.getCommits({ sinceDate: "2024-01-01" });
+
+      expect(mockExecFile).toHaveBeenCalledWith(
+        "git",
+        expect.arrayContaining(["--since=2024-01-01"]),
+        expect.any(Object),
+      );
+    });
+
+    it("should handle commits with pipes in body", async () => {
+      const gitLogOutput = [
+        GIT_LOG_COMMIT_DELIMITER,
+        "abc123|abc12|Author|author@example.com|2024-01-15T10:00:00Z|feat: add feature|Body with | pipes | characters",
+      ].join("\n");
+
+      mockExecFile.mockResolvedValue({
+        stdout: gitLogOutput,
+        stderr: "",
+      } as any);
+
+      const result = await extractor.getCommits();
+
+      expect(result[0].body).toBe("Body with | pipes | characters");
+    });
+
+    it("should handle simple rename format", async () => {
+      const gitLogOutput = [
+        GIT_LOG_COMMIT_DELIMITER,
+        "abc123|abc12|Author|author@example.com|2024-01-15T10:00:00Z|refactor: move|",
+        "",
+        "0\t0\told-name.ts => new-name.ts",
+      ].join("\n");
+
+      mockExecFile.mockResolvedValue({
+        stdout: gitLogOutput,
+        stderr: "",
+      } as any);
+
+      const result = await extractor.getCommits();
+
+      expect(result[0].files).toEqual(["new-name.ts"]);
+    });
+  });
+
+  describe("getCommitDiff", () => {
+    it("should return diff for a commit", async () => {
+      const diffOutput = `commit abc123
+Author: John Doe <john@example.com>
+
+    feat: add feature
+
+diff --git a/file.ts b/file.ts
+--- a/file.ts
++++ b/file.ts
+@@ -1,3 +1,5 @@
++const newLine = true;
+ const existingLine = true;`;
+
+      mockExecFile.mockResolvedValue({ stdout: diffOutput, stderr: "" } as any);
+
+      const result = await extractor.getCommitDiff("abc123");
+
+      expect(result).toBe(diffOutput);
+      expect(mockExecFile).toHaveBeenCalledWith(
+        "git",
+        ["show", "--no-color", "-p", "abc123"],
+        expect.objectContaining({ cwd: "/test/repo" }),
+      );
+    });
+
+    it("should truncate large diffs", async () => {
+      const largeDiff = "x".repeat(10000);
+      const customConfig = { ...config, maxDiffSize: 100 };
+      const customExtractor = new GitExtractor("/test/repo", customConfig);
+
+      mockExecFile.mockResolvedValue({ stdout: largeDiff, stderr: "" } as any);
+
+      const result = await customExtractor.getCommitDiff("abc123");
+
+      expect(result.length).toBeLessThan(largeDiff.length);
+      expect(result).toContain("[diff truncated: showing 100 of 10000 bytes]");
+    });
+
+    it("should return empty string on error", async () => {
+      mockExecFile.mockRejectedValue(new Error("Commit not found"));
+
+      const result = await extractor.getCommitDiff("nonexistent");
+
+      expect(result).toBe("");
+    });
+  });
+
+  describe("getRemoteUrl", () => {
+    it("should return remote origin URL", async () => {
+      mockExecFile.mockResolvedValue({
+        stdout: "git@github.com:user/repo.git\n",
+        stderr: "",
+      } as any);
+
+      const result = await extractor.getRemoteUrl();
+
+      expect(result).toBe("git@github.com:user/repo.git");
+      expect(mockExecFile).toHaveBeenCalledWith(
+        "git",
+        ["remote", "get-url", "origin"],
+        expect.objectContaining({ cwd: "/test/repo" }),
+      );
+    });
+
+    it("should return empty string when no remote configured", async () => {
+      mockExecFile.mockRejectedValue(
+        new Error("fatal: No such remote 'origin'"),
+      );
+
+      const result = await extractor.getRemoteUrl();
+
+      expect(result).toBe("");
+    });
+
+    it("should return HTTPS URL", async () => {
+      mockExecFile.mockResolvedValue({
+        stdout: "https://github.com/user/repo.git\n",
+        stderr: "",
+      } as any);
+
+      const result = await extractor.getRemoteUrl();
+
+      expect(result).toBe("https://github.com/user/repo.git");
+    });
+  });
+});
+
+describe("normalizeRemoteUrl", () => {
+  it("should normalize SSH URL", () => {
+    expect(normalizeRemoteUrl("git@github.com:user/repo.git")).toBe(
+      "user/repo",
+    );
+  });
+
+  it("should normalize HTTPS URL", () => {
+    expect(normalizeRemoteUrl("https://github.com/user/repo.git")).toBe(
+      "user/repo",
+    );
+  });
+
+  it("should handle URL without .git suffix", () => {
+    expect(normalizeRemoteUrl("git@github.com:user/repo")).toBe("user/repo");
+    expect(normalizeRemoteUrl("https://github.com/user/repo")).toBe(
+      "user/repo",
+    );
+  });
+
+  it("should return empty string for empty input", () => {
+    expect(normalizeRemoteUrl("")).toBe("");
+  });
+
+  it("should handle GitLab SSH URL", () => {
+    expect(normalizeRemoteUrl("git@gitlab.com:group/project.git")).toBe(
+      "group/project",
+    );
+  });
+
+  it("should handle Bitbucket SSH URL", () => {
+    expect(normalizeRemoteUrl("git@bitbucket.org:team/repo.git")).toBe(
+      "team/repo",
+    );
+  });
+
+  it("should handle HTTP URL (not HTTPS)", () => {
+    expect(normalizeRemoteUrl("http://github.com/user/repo.git")).toBe(
+      "user/repo",
+    );
+  });
+
+  it("should handle nested paths", () => {
+    expect(
+      normalizeRemoteUrl("https://github.com/org/group/subgroup/repo.git"),
+    ).toBe("org/group/subgroup/repo");
+  });
+});