@mhalder/qdrant-mcp-server 1.3.1 → 1.4.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;
+}