@mhalder/qdrant-mcp-server 1.4.0 → 1.6.0

package/tests/code/chunker/tree-sitter-chunker.test.ts

@@ -0,0 +1,275 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { TreeSitterChunker } from "../../../src/code/chunker/tree-sitter-chunker.js";
+import type { ChunkerConfig } from "../../../src/code/types.js";
+
+describe("TreeSitterChunker", () => {
+  let chunker: TreeSitterChunker;
+  let config: ChunkerConfig;
+
+  beforeEach(() => {
+    config = {
+      chunkSize: 500,
+      chunkOverlap: 50,
+      maxChunkSize: 1000,
+    };
+    chunker = new TreeSitterChunker(config);
+  });
+
+  describe("chunk - TypeScript", () => {
+    it("should chunk TypeScript functions", async () => {
+      const code = `
+function add(a: number, b: number): number {
+  return a + b;
+}
+
+function multiply(a: number, b: number): number {
+  return a * b;
+}
+      `;
+
+      const chunks = await chunker.chunk(code, "test.ts", "typescript");
+      expect(chunks.length).toBeGreaterThanOrEqual(2);
+      expect(chunks.some((c) => c.metadata.name === "add")).toBe(true);
+      expect(chunks.some((c) => c.metadata.name === "multiply")).toBe(true);
+    });
+
+    it("should chunk TypeScript classes", async () => {
+      const code = `
+class Calculator {
+  add(a: number, b: number): number {
+    return a + b;
+  }
+
+  subtract(a: number, b: number): number {
+    return a - b;
+  }
+}
+      `;
+
+      const chunks = await chunker.chunk(code, "test.ts", "typescript");
+      expect(chunks.length).toBeGreaterThan(0);
+      expect(chunks.some((c) => c.metadata.chunkType === "class")).toBe(true);
+    });
+
+    it("should chunk TypeScript interfaces", async () => {
+      const code = `
+interface User {
+  id: string;
+  name: string;
+  email: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+interface Product {
+  id: string;
+  name: string;
+  description: string;
+  price: number;
+  quantity: number;
+  category: string;
+}
+
+interface Order {
+  id: string;
+  userId: string;
+  productId: string;
+  quantity: number;
+  totalPrice: number;
+  status: string;
+}
+      `;
+
+      const chunks = await chunker.chunk(code, "test.ts", "typescript");
+      expect(chunks.length).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe("chunk - Python", () => {
+    it("should chunk Python functions", async () => {
+      const code = `
+def calculate_sum(numbers):
+    """Calculate the sum of a list of numbers."""
+    total = 0
+    for num in numbers:
+        total += num
+    return total
+
+def calculate_product(numbers):
+    """Calculate the product of a list of numbers."""
+    result = 1
+    for num in numbers:
+        result *= num
+    return result
+
+def calculate_average(numbers):
+    """Calculate the average of a list of numbers."""
+    if not numbers:
+        return 0
+    return calculate_sum(numbers) / len(numbers)
+      `;
+
+      const chunks = await chunker.chunk(code, "test.py", "python");
+      expect(chunks.length).toBeGreaterThanOrEqual(1);
+      if (chunks.length > 0) {
+        expect(
+          chunks.some(
+            (c) => c.metadata.name === "calculate_sum" || c.metadata.name === "calculate_product"
+          )
+        ).toBe(true);
+      }
+    });
+
+    it("should chunk Python classes", async () => {
+      const code = `
+class Calculator:
+    def add(self, a, b):
+        return a + b
+
+    def multiply(self, a, b):
+        return a * b
+      `;
+
+      const chunks = await chunker.chunk(code, "test.py", "python");
+      expect(chunks.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("chunk - JavaScript", () => {
+    it("should chunk JavaScript functions", async () => {
+      const code = `
+function greet(name) {
+  return 'Hello, ' + name;
+}
+
+function farewell(name) {
+  return 'Goodbye, ' + name;
+}
+      `;
+
+      const chunks = await chunker.chunk(code, "test.js", "javascript");
+      expect(chunks.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+
+  describe("fallback behavior", () => {
+    it("should fallback to character chunker for unsupported language", async () => {
+      const code =
+        "Some random text that is long enough to not be filtered out by the minimum chunk size requirement.\n" +
+        "This is another line with enough content to make a valid chunk.\n" +
+        "And here is a third line to ensure we have sufficient text content.";
+      const chunks = await chunker.chunk(code, "test.txt", "unknown");
+
+      expect(chunks.length).toBeGreaterThan(0);
+    });
+
+    it("should fallback for very large chunks", async () => {
+      const largeFunction = `
+function veryLargeFunction() {
+  ${Array(100).fill('console.log("line");').join("\n  ")}
+}
+      `;
+
+      const chunks = await chunker.chunk(largeFunction, "test.js", "javascript");
+      expect(chunks.length).toBeGreaterThan(0);
+    });
+
+    it("should fallback on parsing errors", async () => {
+      const invalidCode = "function broken( { invalid syntax";
+      const chunks = await chunker.chunk(invalidCode, "test.js", "javascript");
+
+      // Should handle gracefully and fallback
+      expect(Array.isArray(chunks)).toBe(true);
+    });
+  });
+
+  describe("metadata extraction", () => {
+    it("should extract function names", async () => {
+      const code = `
+function myFunction() {
+  console.log('Processing data');
+  return 42;
+}
+      `;
+
+      const chunks = await chunker.chunk(code, "test.ts", "typescript");
+      expect(chunks[0].metadata.name).toBe("myFunction");
+      expect(chunks[0].metadata.chunkType).toBe("function");
+    });
+
+    it("should include file path and language", async () => {
+      const code = "function test() {\n  console.log('Test function');\n  return true;\n}";
+      const chunks = await chunker.chunk(code, "/path/to/file.ts", "typescript");
+
+      expect(chunks[0].metadata.filePath).toBe("/path/to/file.ts");
+      expect(chunks[0].metadata.language).toBe("typescript");
+    });
+
+    it("should set correct line numbers", async () => {
+      const code = `
+line1
+function test() {
+  console.log('Testing line numbers');
+  return 1;
+}
+      `;
+
+      const chunks = await chunker.chunk(code, "test.ts", "typescript");
+      expect(chunks[0].startLine).toBeGreaterThan(0);
+      expect(chunks[0].endLine).toBeGreaterThan(chunks[0].startLine);
+    });
+  });
+
+  describe("supportsLanguage", () => {
+    it("should support TypeScript", () => {
+      expect(chunker.supportsLanguage("typescript")).toBe(true);
+    });
+
+    it("should support Python", () => {
+      expect(chunker.supportsLanguage("python")).toBe(true);
+    });
+
+    it("should not support unknown languages", () => {
+      expect(chunker.supportsLanguage("unknown")).toBe(false);
+    });
+  });
+
+  describe("getStrategyName", () => {
+    it("should return tree-sitter", () => {
+      expect(chunker.getStrategyName()).toBe("tree-sitter");
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle empty code", async () => {
+      const chunks = await chunker.chunk("", "test.ts", "typescript");
+      expect(chunks).toHaveLength(0);
+    });
+
+    it("should skip very small chunks", async () => {
+      const code = "const x = 1;";
+      const chunks = await chunker.chunk(code, "test.ts", "typescript");
+      // Very small chunks should be skipped
+      expect(chunks.length).toBeGreaterThanOrEqual(0);
+    });
+
+    it("should handle nested structures", async () => {
+      const code = `
+class Outer {
+  method1() {
+    function inner() {
+      return 1;
+    }
+  }
+
+  method2() {
+    return 2;
+  }
+}
+      `;
+
+      const chunks = await chunker.chunk(code, "test.ts", "typescript");
+      expect(chunks.length).toBeGreaterThan(0);
+    });
+  });
+});

package/tests/code/fixtures/sample-py/calculator.py

@@ -0,0 +1,32 @@
+"""Simple calculator module for testing."""
+
+
+class Calculator:
+    """A basic calculator class."""
+
+    def add(self, a: float, b: float) -> float:
+        """Add two numbers."""
+        return a + b
+
+    def subtract(self, a: float, b: float) -> float:
+        """Subtract b from a."""
+        return a - b
+
+    def multiply(self, a: float, b: float) -> float:
+        """Multiply two numbers."""
+        return a * b
+
+    def divide(self, a: float, b: float) -> float:
+        """Divide a by b."""
+        if b == 0:
+            raise ValueError("Cannot divide by zero")
+        return a / b
+
+
+def factorial(n: int) -> int:
+    """Calculate factorial of n."""
+    if n < 0:
+        raise ValueError("Factorial not defined for negative numbers")
+    if n == 0 or n == 1:
+        return 1
+    return n * factorial(n - 1)

package/tests/code/fixtures/sample-ts/async-operations.ts

@@ -0,0 +1,120 @@
+/**
+ * Demonstrates various async/await patterns
+ */
+
+export class AsyncOperations {
+  /**
+   * Parallel async operations
+   */
+  async fetchMultiple(urls: string[]): Promise<any[]> {
+    const promises = urls.map((url) => this.fetchData(url));
+    return await Promise.all(promises);
+  }
+
+  /**
+   * Sequential async operations
+   */
+  async fetchSequential(urls: string[]): Promise<any[]> {
+    const results = [];
+    for (const url of urls) {
+      const data = await this.fetchData(url);
+      results.push(data);
+    }
+    return results;
+  }
+
+  /**
+   * Async operation with timeout
+   */
+  async fetchWithTimeout(url: string, timeout: number): Promise<any> {
+    return Promise.race([
+      this.fetchData(url),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), timeout)),
+    ]);
+  }
+
+  /**
+   * Async generator function
+   */
+  async *streamData(count: number): AsyncGenerator<number> {
+    for (let i = 0; i < count; i++) {
+      await this.delay(100);
+      yield i;
+    }
+  }
+
+  /**
+   * Process items with concurrency limit
+   */
+  async processWithConcurrency<T, R>(
+    items: T[],
+    processor: (item: T) => Promise<R>,
+    concurrency: number
+  ): Promise<R[]> {
+    const results: R[] = [];
+    const executing: Promise<void>[] = [];
+
+    for (const item of items) {
+      const promise = processor(item).then((result) => {
+        results.push(result);
+      });
+
+      executing.push(promise);
+
+      if (executing.length >= concurrency) {
+        await Promise.race(executing);
+        const index = executing.indexOf(promise);
+        if (index !== -1) {
+          executing.splice(index, 1);
+        }
+      }
+    }
+
+    await Promise.all(executing);
+    return results;
+  }
+
+  /**
+   * Retry with exponential backoff
+   */
+  async retryWithBackoff<T>(fn: () => Promise<T>, maxRetries: number = 3): Promise<T> {
+    let lastError: Error;
+
+    for (let i = 0; i <= maxRetries; i++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error as Error;
+        if (i < maxRetries) {
+          await this.delay(2 ** i * 1000);
+        }
+      }
+    }
+
+    throw lastError!;
+  }
+
+  private async fetchData(url: string): Promise<any> {
+    await this.delay(100);
+    return { url, data: "mock data" };
+  }
+
+  private delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+export async function parallelMap<T, R>(items: T[], mapper: (item: T) => Promise<R>): Promise<R[]> {
+  return Promise.all(items.map(mapper));
+}
+
+export async function sequentialMap<T, R>(
+  items: T[],
+  mapper: (item: T) => Promise<R>
+): Promise<R[]> {
+  const results: R[] = [];
+  for (const item of items) {
+    results.push(await mapper(item));
+  }
+  return results;
+}

package/tests/code/fixtures/sample-ts/auth.ts

@@ -0,0 +1,31 @@
+export interface User {
+  id: string;
+  email: string;
+  name: string;
+}
+
+export class AuthService {
+  private users: Map<string, User> = new Map();
+
+  async authenticate(email: string, _password: string): Promise<User | null> {
+    const user = Array.from(this.users.values()).find((u) => u.email === email);
+    if (!user) {
+      return null;
+    }
+    return user;
+  }
+
+  async register(email: string, name: string, _password: string): Promise<User> {
+    const user: User = {
+      id: Math.random().toString(36),
+      email,
+      name,
+    };
+    this.users.set(user.id, user);
+    return user;
+  }
+
+  async getUser(id: string): Promise<User | null> {
+    return this.users.get(id) || null;
+  }
+}

package/tests/code/fixtures/sample-ts/config.ts

@@ -0,0 +1,52 @@
+/**
+ * Configuration constants and settings
+ */
+
+export const API_VERSION = "v1";
+export const API_BASE_URL = "https://api.example.com";
+export const TIMEOUT = 5000;
+export const MAX_RETRIES = 3;
+
+export enum Environment {
+  Development = "development",
+  Staging = "staging",
+  Production = "production",
+}
+
+export const CONFIG = {
+  api: {
+    baseUrl: API_BASE_URL,
+    version: API_VERSION,
+    timeout: TIMEOUT,
+  },
+  features: {
+    analytics: true,
+    darkMode: true,
+    notifications: false,
+  },
+  limits: {
+    maxUploadSize: 10 * 1024 * 1024, // 10MB
+    maxRequests: 100,
+    rateWindow: 60000, // 1 minute
+  },
+} as const;
+
+export type AppConfig = typeof CONFIG;
+
+export class ConfigManager {
+  private config: Partial<AppConfig> = {};
+
+  get<K extends keyof AppConfig>(key: K): AppConfig[K] {
+    return (this.config[key] || CONFIG[key]) as AppConfig[K];
+  }
+
+  set<K extends keyof AppConfig>(key: K, value: AppConfig[K]): void {
+    this.config[key] = value;
+  }
+
+  reset(): void {
+    this.config = {};
+  }
+}
+
+export { Environment as Env };

package/tests/code/fixtures/sample-ts/database.ts

@@ -0,0 +1,50 @@
+export interface Database<T> {
+  get(id: string): Promise<T | null>;
+  set(id: string, value: T): Promise<void>;
+  delete(id: string): Promise<boolean>;
+  list(): Promise<T[]>;
+}
+
+export class InMemoryDatabase<T extends { id: string }> implements Database<T> {
+  private store: Map<string, T> = new Map();
+
+  async get(id: string): Promise<T | null> {
+    return this.store.get(id) || null;
+  }
+
+  async set(id: string, value: T): Promise<void> {
+    this.store.set(id, value);
+  }
+
+  async delete(id: string): Promise<boolean> {
+    return this.store.delete(id);
+  }
+
+  async list(): Promise<T[]> {
+    return Array.from(this.store.values());
+  }
+
+  async clear(): Promise<void> {
+    this.store.clear();
+  }
+
+  get size(): number {
+    return this.store.size;
+  }
+}
+
+export type ConnectionConfig = {
+  host: string;
+  port: number;
+  username?: string;
+  password?: string;
+  database: string;
+  ssl?: boolean;
+};
+
+export async function connect(config: ConnectionConfig): Promise<Database<any>> {
+  console.log(`Connecting to ${config.host}:${config.port}`);
+  return new InMemoryDatabase();
+}
+
+export default InMemoryDatabase;

package/tests/code/fixtures/sample-ts/index.ts

@@ -0,0 +1,39 @@
+/**
+ * Main entry point - demonstrates various export patterns
+ */
+
+// Export everything from a module
+export * from "./auth.js";
+// Named exports from other modules
+export { AuthService, User } from "./auth.js";
+// Re-export with alias
+export { CONFIG, ConfigManager, Environment, Environment as Env } from "./config.js";
+// Default export
+export { ConnectionConfig, connect, Database, default, InMemoryDatabase } from "./database.js";
+export { capitalize, debounce, isValidEmail, retry, slugify } from "./utils.js";
+export { ValidationResult, Validator } from "./validator.js";
+
+// Local exports
+export const VERSION = "1.0.0";
+export const APP_NAME = "Sample TypeScript App";
+
+export function initializeApp(): void {
+  console.log(`Initializing ${APP_NAME} v${VERSION}`);
+}
+
+// Named export class
+export class Application {
+  private initialized = false;
+
+  async start(): Promise<void> {
+    if (this.initialized) {
+      throw new Error("Application already initialized");
+    }
+    initializeApp();
+    this.initialized = true;
+  }
+
+  isRunning(): boolean {
+    return this.initialized;
+  }
+}