@mhalder/qdrant-mcp-server 1.4.0 → 1.5.0

package/src/code/metadata.ts

@@ -0,0 +1,153 @@
+/**
+ * MetadataExtractor - Extracts metadata from code chunks
+ */
+
+import { createHash } from "node:crypto";
+import { extname } from "node:path";
+import { LANGUAGE_MAP } from "./config.js";
+import type { CodeChunk } from "./types.js";
+
+export class MetadataExtractor {
+  /**
+   * Extract programming language from file path
+   */
+  extractLanguage(filePath: string): string {
+    const ext = extname(filePath);
+    return LANGUAGE_MAP[ext] || "unknown";
+  }
+
+  /**
+   * Generate deterministic chunk ID based on content and location
+   * Format: chunk_{sha256(path:start:end:content)[:16]}
+   */
+  generateChunkId(chunk: CodeChunk): string {
+    const { metadata, startLine, endLine, content } = chunk;
+    const combined = `${metadata.filePath}:${startLine}:${endLine}:${content}`;
+    const hash = createHash("sha256").update(combined).digest("hex");
+    return `chunk_${hash.substring(0, 16)}`;
+  }
+
+  /**
+   * Calculate simple code complexity score (optional)
+   * Based on: cyclomatic complexity indicators
+   */
+  calculateComplexity(code: string): number {
+    if (!code || code.trim().length === 0) {
+      return 0;
+    }
+
+    let complexity = 0;
+
+    // Count control flow statements
+    const controlFlowPatterns = [
+      /\bif\b/g,
+      /\belse\b/g,
+      /\bfor\b/g,
+      /\bwhile\b/g,
+      /\bswitch\b/g,
+      /\bcase\b/g,
+      /\bcatch\b/g,
+      /&&/g,
+      /\|\|/g,
+      /\?[^?]/g, // Ternary operator
+    ];
+
+    for (const pattern of controlFlowPatterns) {
+      const matches = code.match(pattern);
+      if (matches) {
+        complexity += matches.length;
+      }
+    }
+
+    // If code contains function/method/class, add base complexity of 1
+    if (complexity > 0 || /\b(function|class|def|fn)\b/.test(code)) {
+      complexity = Math.max(1, complexity);
+    }
+
+    return complexity;
+  }
+
+  /**
+   * Detect potential secrets in code (basic pattern matching)
+   */
+  containsSecrets(code: string): boolean {
+    const secretPatterns = [
+      /(?:api[-_]?key|apikey)\s*=\s*['"][^'"]{20,}['"]/i,
+      /(?:secret|SECRET)\s*=\s*['"][^'"]{20,}['"]/i,
+      /(?:password|PASSWORD)\s*=\s*['"][^'"]{8,}['"]/i,
+      /(?:token|TOKEN)\s*=\s*['"][^'"]{20,}['"]/i,
+      /-----BEGIN\s+(RSA\s+)?PRIVATE\s+KEY-----/,
+      /sk_live_[a-zA-Z0-9]{24,}/, // Stripe secret key
+      /ghp_[a-zA-Z0-9]{36,}/, // GitHub personal access token
+      /AIza[0-9A-Za-z\\-_]{35}/, // Google API key
+      /AKIA[0-9A-Z]{16}/, // AWS access key
+    ];
+
+    for (const pattern of secretPatterns) {
+      if (pattern.test(code)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Extract imports/exports from code (basic regex-based)
+   */
+  extractImportsExports(
+    code: string,
+    language: string
+  ): {
+    imports: string[];
+    exports: string[];
+  } {
+    const imports: string[] = [];
+    const exports: string[] = [];
+
+    if (language === "typescript" || language === "javascript") {
+      // Extract imports
+      const importMatches = code.matchAll(/import\s+.*?\s+from\s+['"]([^'"]+)['"]/g);
+      for (const match of importMatches) {
+        imports.push(match[1]);
+      }
+
+      // Extract require statements
+      const requireMatches = code.matchAll(/require\s*\(\s*['"]([^'"]+)['"]\s*\)/g);
+      for (const match of requireMatches) {
+        imports.push(match[1]);
+      }
+
+      // Extract exports - regular declarations
+      const exportMatches = code.matchAll(/export\s+(?:class|function|const|let|var)\s+(\w+)/g);
+      for (const match of exportMatches) {
+        exports.push(match[1]);
+      }
+
+      // Extract export default
+      if (/export\s+default\b/.test(code)) {
+        exports.push("default");
+      }
+
+      // Extract named exports from other modules: export { name } from 'module'
+      const reExportMatches = code.matchAll(/export\s+\{\s*(\w+)\s*\}/g);
+      for (const match of reExportMatches) {
+        exports.push(match[1]);
+      }
+    } else if (language === "python") {
+      // Extract imports
+      const importMatches = code.matchAll(/(?:from\s+(\S+)\s+)?import\s+([^;\n]+)/g);
+      for (const match of importMatches) {
+        imports.push(match[1] || match[2]);
+      }
+
+      // Extract functions/classes (rough)
+      const defMatches = code.matchAll(/^(?:def|class)\s+(\w+)/gm);
+      for (const match of defMatches) {
+        exports.push(match[1]);
+      }
+    }
+
+    return { imports, exports };
+  }
+}

package/src/code/scanner.ts

@@ -0,0 +1,124 @@
+/**
+ * FileScanner - Discovers code files in a directory while respecting ignore patterns
+ */
+
+import { promises as fs } from "node:fs";
+import { extname, join, relative, resolve } from "node:path";
+import ignore, { type Ignore } from "ignore";
+import type { ScannerConfig } from "./types.js";
+
+export class FileScanner {
+  private ig: Ignore = ignore();
+  private supportedExts: Set<string>;
+
+  constructor(private config: ScannerConfig) {
+    this.supportedExts = new Set(config.supportedExtensions);
+  }
+
+  /**
+   * Load ignore patterns from .gitignore, .dockerignore, .npmignore, and .contextignore
+   */
+  async loadIgnorePatterns(rootPath: string): Promise<void> {
+    const ignoreFiles = [".gitignore", ".dockerignore", ".npmignore", ".contextignore"];
+
+    for (const ignoreFile of ignoreFiles) {
+      const ignorePath = join(rootPath, ignoreFile);
+      if (await this.fileExists(ignorePath)) {
+        try {
+          const content = await fs.readFile(ignorePath, "utf-8");
+          this.ig.add(content);
+        } catch (_error) {
+          // Silently skip if file can't be read
+        }
+      }
+    }
+
+    // Add default patterns from config
+    if (this.config.ignorePatterns && this.config.ignorePatterns.length > 0) {
+      this.ig.add(this.config.ignorePatterns);
+    }
+
+    // Add custom patterns
+    if (this.config.customIgnorePatterns && this.config.customIgnorePatterns.length > 0) {
+      this.ig.add(this.config.customIgnorePatterns);
+    }
+  }
+
+  /**
+   * Scan directory recursively and return all code files
+   */
+  async scanDirectory(rootPath: string): Promise<string[]> {
+    const absoluteRoot = resolve(rootPath);
+    const files: string[] = [];
+
+    await this.walkDirectory(absoluteRoot, absoluteRoot, files);
+
+    return files;
+  }
+
+  /**
+   * Check if a file should be ignored based on patterns
+   */
+  shouldIgnore(filePath: string, rootPath: string): boolean {
+    const relativePath = relative(rootPath, filePath);
+    return this.ig.ignores(relativePath);
+  }
+
+  /**
+   * Get list of supported file extensions
+   */
+  getSupportedExtensions(): string[] {
+    return Array.from(this.supportedExts);
+  }
+
+  /**
+   * Recursively walk directory tree
+   */
+  private async walkDirectory(
+    currentPath: string,
+    rootPath: string,
+    files: string[]
+  ): Promise<void> {
+    try {
+      const entries = await fs.readdir(currentPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = join(currentPath, entry.name);
+        const relativePath = relative(rootPath, fullPath);
+
+        // Skip ignored paths
+        if (this.ig.ignores(relativePath)) {
+          continue;
+        }
+
+        // Handle symbolic links safely to avoid infinite loops
+        if (entry.isSymbolicLink()) {
+          continue;
+        }
+
+        if (entry.isDirectory()) {
+          await this.walkDirectory(fullPath, rootPath, files);
+        } else if (entry.isFile()) {
+          const ext = extname(entry.name);
+          if (this.supportedExts.has(ext)) {
+            files.push(fullPath);
+          }
+        }
+      }
+    } catch (_error) {
+      // Skip directories that can't be read (permission errors, etc.)
+    }
+  }
+
+  /**
+   * Check if a file exists
+   */
+  private async fileExists(path: string): Promise<boolean> {
+    try {
+      await fs.access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/code/sync/merkle.ts

@@ -0,0 +1,136 @@
+/**
+ * MerkleTree - Efficient change detection using Merkle trees
+ * Enables incremental updates by comparing file hashes
+ */
+
+import { createHash } from "node:crypto";
+
+export class MerkleNode {
+  constructor(
+    public hash: string,
+    public left?: MerkleNode,
+    public right?: MerkleNode
+  ) {}
+}
+
+export class MerkleTree {
+  root: MerkleNode | undefined = undefined;
+
+  /**
+   * Build Merkle tree from file hashes
+   * @param fileHashes Map of file path to content hash
+   */
+  build(fileHashes: Map<string, string>): void {
+    if (fileHashes.size === 0) {
+      this.root = undefined;
+      return;
+    }
+
+    // Sort files for deterministic tree structure
+    const leaves = Array.from(fileHashes.entries())
+      .sort(([pathA], [pathB]) => pathA.localeCompare(pathB))
+      .map(([path, hash]) => {
+        const combined = `${path}:${hash}`;
+        const leafHash = createHash("sha256").update(combined).digest("hex");
+        return new MerkleNode(leafHash);
+      });
+
+    this.root = this.buildRecursive(leaves);
+  }
+
+  /**
+   * Recursively build tree from leaf nodes
+   */
+  private buildRecursive(nodes: MerkleNode[]): MerkleNode {
+    if (nodes.length === 1) {
+      return nodes[0];
+    }
+
+    const parents: MerkleNode[] = [];
+    for (let i = 0; i < nodes.length; i += 2) {
+      const left = nodes[i];
+      const right = nodes[i + 1] || left; // Duplicate if odd number
+
+      const combined = left.hash + right.hash;
+      const parentHash = createHash("sha256").update(combined).digest("hex");
+
+      parents.push(new MerkleNode(parentHash, left, right));
+    }
+
+    return this.buildRecursive(parents);
+  }
+
+  /**
+   * Compare two trees and return file differences
+   */
+  static compare(
+    oldHashes: Map<string, string>,
+    newHashes: Map<string, string>
+  ): { added: string[]; modified: string[]; deleted: string[] } {
+    const added: string[] = [];
+    const modified: string[] = [];
+    const deleted: string[] = [];
+
+    // Find added and modified files
+    for (const [path, hash] of newHashes) {
+      if (!oldHashes.has(path)) {
+        added.push(path);
+      } else if (oldHashes.get(path) !== hash) {
+        modified.push(path);
+      }
+    }
+
+    // Find deleted files
+    for (const [path] of oldHashes) {
+      if (!newHashes.has(path)) {
+        deleted.push(path);
+      }
+    }
+
+    return { added, modified, deleted };
+  }
+
+  /**
+   * Get root hash (quick comparison)
+   */
+  getRootHash(): string | undefined {
+    return this.root?.hash;
+  }
+
+  /**
+   * Serialize tree for storage
+   */
+  serialize(): string {
+    return JSON.stringify({
+      root: this.serializeNode(this.root),
+    });
+  }
+
+  private serializeNode(node: MerkleNode | undefined): any | null {
+    if (!node) return null;
+    return {
+      hash: node.hash,
+      left: this.serializeNode(node.left),
+      right: this.serializeNode(node.right),
+    };
+  }
+
+  /**
+   * Deserialize tree from storage
+   */
+  static deserialize(data: string): MerkleTree {
+    const tree = new MerkleTree();
+    const obj = JSON.parse(data);
+    tree.root = tree.deserializeNode(obj.root);
+    return tree;
+  }
+
+  private deserializeNode(obj: any): MerkleNode | undefined {
+    if (!obj) return undefined;
+    return new MerkleNode(
+      obj.hash,
+      this.deserializeNode(obj.left),
+      this.deserializeNode(obj.right)
+    );
+  }
+}

package/src/code/sync/snapshot.ts

@@ -0,0 +1,110 @@
+/**
+ * Snapshot - Persistence layer for Merkle tree snapshots
+ * Stores file hashes and tree structure for incremental updates
+ */
+
+import { promises as fs } from "node:fs";
+import { dirname } from "node:path";
+import { MerkleTree } from "./merkle.js";
+
+export interface Snapshot {
+  codebasePath: string;
+  timestamp: number;
+  fileHashes: Record<string, string>;
+  merkleTree: string; // Serialized tree
+}
+
+export class SnapshotManager {
+  constructor(private snapshotPath: string) {}
+
+  /**
+   * Save snapshot to disk
+   */
+  async save(
+    codebasePath: string,
+    fileHashes: Map<string, string>,
+    tree: MerkleTree
+  ): Promise<void> {
+    const snapshot: Snapshot = {
+      codebasePath,
+      timestamp: Date.now(),
+      fileHashes: Object.fromEntries(fileHashes),
+      merkleTree: tree.serialize(),
+    };
+
+    // Ensure directory exists
+    await fs.mkdir(dirname(this.snapshotPath), { recursive: true });
+
+    // Write snapshot atomically (write to temp file, then rename)
+    // Use unique temp file name to avoid race conditions
+    const tempPath = `${this.snapshotPath}.tmp.${Date.now()}.${Math.random().toString(36).substring(2, 9)}`;
+    await fs.writeFile(tempPath, JSON.stringify(snapshot, null, 2), "utf-8");
+    await fs.rename(tempPath, this.snapshotPath);
+  }
+
+  /**
+   * Load snapshot from disk
+   */
+  async load(): Promise<{
+    codebasePath: string;
+    fileHashes: Map<string, string>;
+    merkleTree: MerkleTree;
+    timestamp: number;
+  } | null> {
+    try {
+      const data = await fs.readFile(this.snapshotPath, "utf-8");
+      const snapshot: Snapshot = JSON.parse(data);
+
+      const fileHashes = new Map(Object.entries(snapshot.fileHashes));
+      const tree = MerkleTree.deserialize(snapshot.merkleTree);
+
+      return {
+        codebasePath: snapshot.codebasePath,
+        fileHashes,
+        merkleTree: tree,
+        timestamp: snapshot.timestamp,
+      };
+    } catch (_error) {
+      // Snapshot doesn't exist or is corrupted
+      return null;
+    }
+  }
+
+  /**
+   * Check if snapshot exists
+   */
+  async exists(): Promise<boolean> {
+    try {
+      await fs.access(this.snapshotPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Delete snapshot
+   */
+  async delete(): Promise<void> {
+    try {
+      await fs.unlink(this.snapshotPath);
+    } catch {
+      // Ignore if doesn't exist
+    }
+  }
+
+  /**
+   * Validate snapshot (check for corruption)
+   */
+  async validate(): Promise<boolean> {
+    try {
+      const snapshot = await this.load();
+      if (!snapshot) return false;
+
+      // Basic validation: check if tree can be deserialized
+      return snapshot.merkleTree.getRootHash() !== undefined || snapshot.fileHashes.size === 0;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/code/sync/synchronizer.ts

@@ -0,0 +1,154 @@
+/**
+ * FileSynchronizer - Manages incremental updates using Merkle trees
+ * Detects file changes and updates snapshots
+ */
+
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join, relative } from "node:path";
+import type { FileChanges } from "../types.js";
+import { MerkleTree } from "./merkle.js";
+import { SnapshotManager } from "./snapshot.js";
+
+export class FileSynchronizer {
+  private snapshotManager: SnapshotManager;
+  private previousHashes: Map<string, string> = new Map();
+  private previousTree: MerkleTree | null = null;
+
+  constructor(
+    private codebasePath: string,
+    collectionName: string
+  ) {
+    // Store snapshots in ~/.qdrant-mcp/snapshots/
+    const snapshotDir = join(homedir(), ".qdrant-mcp", "snapshots");
+    const snapshotPath = join(snapshotDir, `${collectionName}.json`);
+    this.snapshotManager = new SnapshotManager(snapshotPath);
+  }
+
+  /**
+   * Initialize synchronizer by loading previous snapshot
+   */
+  async initialize(): Promise<boolean> {
+    const snapshot = await this.snapshotManager.load();
+
+    if (snapshot) {
+      this.previousHashes = snapshot.fileHashes;
+      this.previousTree = snapshot.merkleTree;
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Compute hash for a file's content
+   */
+  private async hashFile(filePath: string): Promise<string> {
+    try {
+      // Resolve path relative to codebase if not absolute
+      const absolutePath = filePath.startsWith(this.codebasePath)
+        ? filePath
+        : join(this.codebasePath, filePath);
+      const content = await fs.readFile(absolutePath, "utf-8");
+      return createHash("sha256").update(content).digest("hex");
+    } catch (_error) {
+      // If file can't be read, return empty hash
+      return "";
+    }
+  }
+
+  /**
+   * Compute hashes for all files
+   */
+  async computeFileHashes(filePaths: string[]): Promise<Map<string, string>> {
+    const fileHashes = new Map<string, string>();
+
+    for (const filePath of filePaths) {
+      const hash = await this.hashFile(filePath);
+      if (hash) {
+        // Normalize to relative path
+        const relativePath = filePath.startsWith(this.codebasePath)
+          ? relative(this.codebasePath, filePath)
+          : filePath;
+        fileHashes.set(relativePath, hash);
+      }
+    }
+
+    return fileHashes;
+  }
+
+  /**
+   * Detect changes since last snapshot
+   */
+  async detectChanges(currentFiles: string[]): Promise<FileChanges> {
+    // Compute current hashes
+    const currentHashes = await this.computeFileHashes(currentFiles);
+
+    // Compare with previous snapshot
+    const changes = MerkleTree.compare(this.previousHashes, currentHashes);
+
+    return changes;
+  }
+
+  /**
+   * Update snapshot with current state
+   */
+  async updateSnapshot(files: string[]): Promise<void> {
+    const fileHashes = await this.computeFileHashes(files);
+    const tree = new MerkleTree();
+    tree.build(fileHashes);
+
+    await this.snapshotManager.save(this.codebasePath, fileHashes, tree);
+
+    // Update internal state
+    this.previousHashes = fileHashes;
+    this.previousTree = tree;
+  }
+
+  /**
+   * Delete snapshot
+   */
+  async deleteSnapshot(): Promise<void> {
+    await this.snapshotManager.delete();
+    this.previousHashes.clear();
+    this.previousTree = null;
+  }
+
+  /**
+   * Check if snapshot exists
+   */
+  async hasSnapshot(): Promise<boolean> {
+    return this.snapshotManager.exists();
+  }
+
+  /**
+   * Validate snapshot integrity
+   */
+  async validateSnapshot(): Promise<boolean> {
+    return this.snapshotManager.validate();
+  }
+
+  /**
+   * Get snapshot age in milliseconds
+   */
+  async getSnapshotAge(): Promise<number | null> {
+    const snapshot = await this.snapshotManager.load();
+    if (!snapshot) return null;
+
+    return Date.now() - snapshot.timestamp;
+  }
+
+  /**
+   * Quick check if re-indexing is needed (compare root hashes)
+   */
+  async needsReindex(currentFiles: string[]): Promise<boolean> {
+    if (!this.previousTree) return true;
+
+    const currentHashes = await this.computeFileHashes(currentFiles);
+    const currentTree = new MerkleTree();
+    currentTree.build(currentHashes);
+
+    return this.previousTree.getRootHash() !== currentTree.getRootHash();
+  }
+}