@mhalder/qdrant-mcp-server 1.3.1 → 1.5.0

package/src/prompts/template.test.ts

@@ -0,0 +1,212 @@
+import { describe, expect, it } from "vitest";
+import { renderTemplate, validateArguments } from "./template.js";
+import type { PromptArgument } from "./types.js";
+
+describe("renderTemplate", () => {
+  it("should render template with provided arguments", () => {
+    const template = "Search {{collection}} for {{query}}";
+    const args = { collection: "papers", query: "machine learning" };
+    const result = renderTemplate(template, args);
+
+    expect(result.text).toBe("Search papers for machine learning");
+  });
+
+  it("should handle multiple occurrences of the same variable", () => {
+    const template = "{{name}} said hello. {{name}} said goodbye.";
+    const args = { name: "Alice" };
+    const result = renderTemplate(template, args);
+
+    expect(result.text).toBe("Alice said hello. Alice said goodbye.");
+  });
+
+  it("should use default values for missing arguments", () => {
+    const template = "Return {{limit}} results";
+    const args = {};
+    const definitions: PromptArgument[] = [
+      { name: "limit", description: "Number of results", required: false, default: "5" },
+    ];
+    const result = renderTemplate(template, args, definitions);
+
+    expect(result.text).toBe("Return 5 results");
+  });
+
+  it("should prefer provided arguments over defaults", () => {
+    const template = "Return {{limit}} results";
+    const args = { limit: "10" };
+    const definitions: PromptArgument[] = [
+      { name: "limit", description: "Number of results", required: false, default: "5" },
+    ];
+    const result = renderTemplate(template, args, definitions);
+
+    expect(result.text).toBe("Return 10 results");
+  });
+
+  it("should keep placeholder if no value and no default", () => {
+    const template = "Search {{collection}} for {{query}}";
+    const args = { collection: "papers" };
+    const result = renderTemplate(template, args);
+
+    expect(result.text).toBe("Search papers for {{query}}");
+  });
+
+  it("should handle templates with no placeholders", () => {
+    const template = "This is a plain text template";
+    const args = { foo: "bar" };
+    const result = renderTemplate(template, args);
+
+    expect(result.text).toBe("This is a plain text template");
+  });
+
+  it("should handle empty template", () => {
+    const template = "";
+    const args = { foo: "bar" };
+    const result = renderTemplate(template, args);
+
+    expect(result.text).toBe("");
+  });
+
+  it("should handle empty args", () => {
+    const template = "Search {{collection}}";
+    const result = renderTemplate(template);
+
+    expect(result.text).toBe("Search {{collection}}");
+  });
+
+  it("should handle complex template with multiple variables and defaults", () => {
+    const template =
+      "Search the '{{collection}}' collection for documents similar to: '{{query}}'. Return the top {{limit}} most relevant results.";
+    const args = { collection: "papers", query: "neural networks" };
+    const definitions: PromptArgument[] = [
+      { name: "collection", description: "Collection name", required: true },
+      { name: "query", description: "Search query", required: true },
+      { name: "limit", description: "Number of results", required: false, default: "5" },
+    ];
+    const result = renderTemplate(template, args, definitions);
+
+    expect(result.text).toBe(
+      "Search the 'papers' collection for documents similar to: 'neural networks'. Return the top 5 most relevant results."
+    );
+  });
+
+  it("should handle special characters in argument values", () => {
+    const template = "Query: {{query}}";
+    const args = { query: "What is $100 + $200?" };
+    const result = renderTemplate(template, args);
+
+    expect(result.text).toBe("Query: What is $100 + $200?");
+  });
+
+  it("should handle numeric-like values as strings", () => {
+    const template = "ID: {{id}}, Count: {{count}}";
+    const args = { id: "123", count: "456" };
+    const result = renderTemplate(template, args);
+
+    expect(result.text).toBe("ID: 123, Count: 456");
+  });
+
+  it("should handle whitespace in variable names", () => {
+    const template = "Value: {{key}}";
+    const args = { key: "  spaced  " };
+    const result = renderTemplate(template, args);
+
+    expect(result.text).toBe("Value:   spaced  ");
+  });
+
+  it("should not match invalid placeholder patterns", () => {
+    const template = "{{ invalid }} {missing} {{also invalid}} {{valid}}";
+    const args = { valid: "yes" };
+    const result = renderTemplate(template, args);
+
+    // Only {{valid}} should be replaced, others don't match \w+ pattern
+    expect(result.text).toBe("{{ invalid }} {missing} {{also invalid}} yes");
+  });
+});
+
+describe("validateArguments", () => {
+  it("should pass validation when all required arguments are provided", () => {
+    const args = { collection: "papers", query: "test" };
+    const definitions: PromptArgument[] = [
+      { name: "collection", description: "Collection name", required: true },
+      { name: "query", description: "Search query", required: true },
+    ];
+
+    expect(() => validateArguments(args, definitions)).not.toThrow();
+  });
+
+  it("should throw error when required argument is missing", () => {
+    const args = { collection: "papers" };
+    const definitions: PromptArgument[] = [
+      { name: "collection", description: "Collection name", required: true },
+      { name: "query", description: "Search query", required: true },
+    ];
+
+    expect(() => validateArguments(args, definitions)).toThrow("Missing required arguments: query");
+  });
+
+  it("should throw error when required argument is empty string", () => {
+    const args = { collection: "papers", query: "" };
+    const definitions: PromptArgument[] = [
+      { name: "collection", description: "Collection name", required: true },
+      { name: "query", description: "Search query", required: true },
+    ];
+
+    expect(() => validateArguments(args, definitions)).toThrow("Missing required arguments: query");
+  });
+
+  it("should throw error listing multiple missing arguments", () => {
+    const args = {};
+    const definitions: PromptArgument[] = [
+      { name: "collection", description: "Collection name", required: true },
+      { name: "query", description: "Search query", required: true },
+      { name: "filter", description: "Filter", required: true },
+    ];
+
+    expect(() => validateArguments(args, definitions)).toThrow(
+      "Missing required arguments: collection, query, filter"
+    );
+  });
+
+  it("should not throw for missing optional arguments", () => {
+    const args = { collection: "papers", query: "test" };
+    const definitions: PromptArgument[] = [
+      { name: "collection", description: "Collection name", required: true },
+      { name: "query", description: "Search query", required: true },
+      { name: "limit", description: "Limit", required: false, default: "5" },
+    ];
+
+    expect(() => validateArguments(args, definitions)).not.toThrow();
+  });
+
+  it("should pass validation with empty definitions", () => {
+    const args = { foo: "bar" };
+    const definitions: PromptArgument[] = [];
+
+    expect(() => validateArguments(args, definitions)).not.toThrow();
+  });
+
+  it("should pass validation with no definitions", () => {
+    const args = { foo: "bar" };
+
+    expect(() => validateArguments(args, [])).not.toThrow();
+  });
+
+  it("should not require arguments that are not defined", () => {
+    const args = { collection: "papers", extra: "data" };
+    const definitions: PromptArgument[] = [
+      { name: "collection", description: "Collection name", required: true },
+    ];
+
+    expect(() => validateArguments(args, definitions)).not.toThrow();
+  });
+
+  it("should handle mixed required and optional arguments", () => {
+    const args = { name: "test" };
+    const definitions: PromptArgument[] = [
+      { name: "name", description: "Name", required: true },
+      { name: "limit", description: "Limit", required: false },
+      { name: "filter", description: "Filter", required: false },
+    ];
+
+    expect(() => validateArguments(args, definitions)).not.toThrow();
+  });
+});

package/src/prompts/template.ts

@@ -0,0 +1,69 @@
+/**
+ * Simple template rendering engine for prompts
+ */
+
+import type { PromptArgument, RenderedPrompt } from "./types.js";
+
+/**
+ * Render a template string by replacing {{variable}} placeholders with actual values
+ * @param template Template string with {{variable}} placeholders
+ * @param args Record of argument values
+ * @param definitions Argument definitions with defaults
+ * @returns Rendered template
+ */
+export function renderTemplate(
+  template: string,
+  args: Record<string, string> = {},
+  definitions: PromptArgument[] = []
+): RenderedPrompt {
+  let rendered = template;
+
+  // Create a map of defaults
+  const defaults = new Map<string, string>();
+  for (const def of definitions) {
+    if (def.default !== undefined) {
+      defaults.set(def.name, def.default);
+    }
+  }
+
+  // Replace all {{variable}} placeholders
+  rendered = rendered.replace(/\{\{(\w+)\}\}/g, (match, varName) => {
+    // Check if value is provided in args
+    if (args[varName] !== undefined) {
+      return args[varName];
+    }
+
+    // Check if there's a default value
+    if (defaults.has(varName)) {
+      return defaults.get(varName)!;
+    }
+
+    // If no value and no default, keep the placeholder
+    return match;
+  });
+
+  return { text: rendered };
+}
+
+/**
+ * Validate that all required arguments are provided
+ * @param args Provided arguments
+ * @param definitions Argument definitions
+ * @throws Error if required arguments are missing
+ */
+export function validateArguments(
+  args: Record<string, string>,
+  definitions: PromptArgument[]
+): void {
+  const missing: string[] = [];
+
+  for (const def of definitions) {
+    if (def.required && (args[def.name] === undefined || args[def.name] === "")) {
+      missing.push(def.name);
+    }
+  }
+
+  if (missing.length > 0) {
+    throw new Error(`Missing required arguments: ${missing.join(", ")}`);
+  }
+}

package/src/prompts/types.ts

@@ -0,0 +1,37 @@
+/**
+ * Configuration types for MCP prompts
+ */
+
+/**
+ * Argument definition for a prompt
+ */
+export interface PromptArgument {
+  name: string;
+  description: string;
+  required: boolean;
+  default?: string;
+}
+
+/**
+ * Individual prompt definition
+ */
+export interface PromptDefinition {
+  name: string;
+  description: string;
+  arguments: PromptArgument[];
+  template: string;
+}
+
+/**
+ * Root configuration structure
+ */
+export interface PromptsConfig {
+  prompts: PromptDefinition[];
+}
+
+/**
+ * Parsed template with resolved arguments
+ */
+export interface RenderedPrompt {
+  text: string;
+}

package/tests/code/chunker/character-chunker.test.ts

@@ -0,0 +1,141 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { CharacterChunker } from "../../../src/code/chunker/character-chunker.js";
+import type { ChunkerConfig } from "../../../src/code/types.js";
+
+describe("CharacterChunker", () => {
+  let chunker: CharacterChunker;
+  let config: ChunkerConfig;
+
+  beforeEach(() => {
+    config = {
+      chunkSize: 100,
+      chunkOverlap: 20,
+      maxChunkSize: 200,
+    };
+    chunker = new CharacterChunker(config);
+  });
+
+  describe("chunk", () => {
+    it("should chunk small code into single chunk", async () => {
+      const code =
+        "function hello() {\n  console.log('Starting hello function');\n  return 'world';\n}";
+      const chunks = await chunker.chunk(code, "test.ts", "typescript");
+
+      expect(chunks).toHaveLength(1);
+      expect(chunks[0].content).toContain("hello");
+      expect(chunks[0].startLine).toBe(1);
+      expect(chunks[0].metadata.language).toBe("typescript");
+    });
+
+    it("should chunk large code into multiple chunks", async () => {
+      const code = Array(20)
+        .fill("function testFunction() { console.log('This is a test function'); return true; }\n")
+        .join("");
+      const chunks = await chunker.chunk(code, "test.js", "javascript");
+
+      expect(chunks.length).toBeGreaterThan(1);
+      chunks.forEach((chunk) => {
+        expect(chunk.content.length).toBeLessThanOrEqual(config.maxChunkSize);
+      });
+    });
+
+    it("should preserve line numbers", async () => {
+      const code =
+        "This is line 1 with enough content to not be filtered\n" +
+        "This is line 2 with enough content to not be filtered\n" +
+        "This is line 3 with enough content to not be filtered";
+      const chunks = await chunker.chunk(code, "test.txt", "text");
+
+      expect(chunks.length).toBeGreaterThan(0);
+      expect(chunks[0].startLine).toBe(1);
+      expect(chunks[0].endLine).toBeGreaterThan(chunks[0].startLine);
+    });
+
+    it("should apply overlap between chunks", async () => {
+      const code = Array(20).fill("const x = 1;\n").join("");
+      const chunks = await chunker.chunk(code, "test.js", "javascript");
+
+      if (chunks.length > 1) {
+        // Check that there's overlap in content
+        expect(chunks.length).toBeGreaterThan(1);
+      }
+    });
+
+    it("should find good break points", async () => {
+      const code = `function foo() {
+  return 1;
+}
+
+function bar() {
+  return 2;
+}
+
+function baz() {
+  return 3;
+}`;
+
+      const chunks = await chunker.chunk(code, "test.js", "javascript");
+      // Should try to break at function boundaries
+      chunks.forEach((chunk) => {
+        expect(chunk.content.length).toBeGreaterThan(0);
+      });
+    });
+
+    it("should handle empty code", async () => {
+      const code = "";
+      const chunks = await chunker.chunk(code, "test.ts", "typescript");
+      expect(chunks).toHaveLength(0);
+    });
+
+    it("should handle code with only whitespace", async () => {
+      const code = "   \n\n\n   ";
+      const chunks = await chunker.chunk(code, "test.ts", "typescript");
+      expect(chunks).toHaveLength(0);
+    });
+
+    it("should skip very small chunks", async () => {
+      const code = "x";
+      const chunks = await chunker.chunk(code, "test.ts", "typescript");
+      expect(chunks).toHaveLength(0);
+    });
+  });
+
+  describe("supportsLanguage", () => {
+    it("should support all languages", () => {
+      expect(chunker.supportsLanguage("typescript")).toBe(true);
+      expect(chunker.supportsLanguage("python")).toBe(true);
+      expect(chunker.supportsLanguage("unknown")).toBe(true);
+    });
+  });
+
+  describe("getStrategyName", () => {
+    it("should return correct strategy name", () => {
+      expect(chunker.getStrategyName()).toBe("character-based");
+    });
+  });
+
+  describe("metadata", () => {
+    it("should include correct chunk metadata", async () => {
+      const code = "function test() {\n  console.log('test function');\n  return 1;\n}";
+      const chunks = await chunker.chunk(code, "/path/to/file.ts", "typescript");
+
+      expect(chunks.length).toBeGreaterThan(0);
+      expect(chunks[0].metadata).toEqual({
+        filePath: "/path/to/file.ts",
+        language: "typescript",
+        chunkIndex: 0,
+        chunkType: "block",
+      });
+    });
+
+    it("should increment chunk index", async () => {
+      const code = Array(20).fill("function test() {}\n").join("");
+      const chunks = await chunker.chunk(code, "test.ts", "typescript");
+
+      if (chunks.length > 1) {
+        expect(chunks[0].metadata.chunkIndex).toBe(0);
+        expect(chunks[1].metadata.chunkIndex).toBe(1);
+      }
+    });
+  });
+});