@mhalder/qdrant-mcp-server 1.4.0 → 1.5.0

package/build/code/sync/synchronizer.js

@@ -0,0 +1,132 @@
+/**
+ * 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 { MerkleTree } from "./merkle.js";
+import { SnapshotManager } from "./snapshot.js";
+export class FileSynchronizer {
+    codebasePath;
+    snapshotManager;
+    previousHashes = new Map();
+    previousTree = null;
+    constructor(codebasePath, collectionName) {
+        this.codebasePath = codebasePath;
+        // 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() {
+        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
+     */
+    async hashFile(filePath) {
+        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) {
+        const fileHashes = new Map();
+        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) {
+        // 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) {
+        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() {
+        await this.snapshotManager.delete();
+        this.previousHashes.clear();
+        this.previousTree = null;
+    }
+    /**
+     * Check if snapshot exists
+     */
+    async hasSnapshot() {
+        return this.snapshotManager.exists();
+    }
+    /**
+     * Validate snapshot integrity
+     */
+    async validateSnapshot() {
+        return this.snapshotManager.validate();
+    }
+    /**
+     * Get snapshot age in milliseconds
+     */
+    async getSnapshotAge() {
+        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) {
+        if (!this.previousTree)
+            return true;
+        const currentHashes = await this.computeFileHashes(currentFiles);
+        const currentTree = new MerkleTree();
+        currentTree.build(currentHashes);
+        return this.previousTree.getRootHash() !== currentTree.getRootHash();
+    }
+}
+//# sourceMappingURL=synchronizer.js.map

package/build/code/sync/synchronizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"synchronizer.js","sourceRoot":"","sources":["../../../src/code/sync/synchronizer.ts"],"names":[],"mappings":"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"}

package/build/code/types.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Type definitions for code vectorization module
+ */
+export interface CodeConfig {
+    chunkSize: number;
+    chunkOverlap: number;
+    enableASTChunking: boolean;
+    supportedExtensions: string[];
+    ignorePatterns: string[];
+    customExtensions?: string[];
+    customIgnorePatterns?: string[];
+    batchSize: number;
+    maxChunksPerFile?: number;
+    maxTotalChunks?: number;
+    defaultSearchLimit: number;
+    enableHybridSearch: boolean;
+}
+export interface ScannerConfig {
+    supportedExtensions: string[];
+    ignorePatterns: string[];
+    customIgnorePatterns?: string[];
+}
+export interface ChunkerConfig {
+    chunkSize: number;
+    chunkOverlap: number;
+    maxChunkSize: number;
+}
+export interface IndexOptions {
+    forceReindex?: boolean;
+    extensions?: string[];
+    ignorePatterns?: string[];
+}
+export interface IndexStats {
+    filesScanned: number;
+    filesIndexed: number;
+    chunksCreated: number;
+    durationMs: number;
+    status: "completed" | "partial" | "failed";
+    errors?: string[];
+}
+export interface ChangeStats {
+    filesAdded: number;
+    filesModified: number;
+    filesDeleted: number;
+    chunksAdded: number;
+    chunksDeleted: number;
+    durationMs: number;
+}
+export interface CodeSearchResult {
+    content: string;
+    filePath: string;
+    startLine: number;
+    endLine: number;
+    language: string;
+    score: number;
+    fileExtension: string;
+}
+export interface SearchOptions {
+    limit?: number;
+    useHybrid?: boolean;
+    fileTypes?: string[];
+    pathPattern?: string;
+    scoreThreshold?: number;
+}
+export interface IndexStatus {
+    isIndexed: boolean;
+    collectionName?: string;
+    filesCount?: number;
+    chunksCount?: number;
+    lastUpdated?: Date;
+    languages?: string[];
+}
+export type ProgressCallback = (progress: ProgressUpdate) => void;
+export interface ProgressUpdate {
+    phase: "scanning" | "chunking" | "embedding" | "storing";
+    current: number;
+    total: number;
+    percentage: number;
+    message: string;
+}
+export interface CodeChunk {
+    content: string;
+    startLine: number;
+    endLine: number;
+    metadata: {
+        filePath: string;
+        language: string;
+        chunkIndex: number;
+        chunkType?: "function" | "class" | "interface" | "block";
+        name?: string;
+    };
+}
+export interface FileChanges {
+    added: string[];
+    modified: string[];
+    deleted: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/build/code/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/code/types.ts"],"names":[],"mappings":"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"}

package/build/code/types.js

@@ -0,0 +1,5 @@
+/**
+ * Type definitions for code vectorization module
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/build/code/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/code/types.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/build/index.js

@@ -9,6 +9,8 @@ import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema
 import Bottleneck from "bottleneck";
 import express from "express";
 import { z } from "zod";
+import { DEFAULT_BATCH_SIZE, DEFAULT_CHUNK_OVERLAP, DEFAULT_CHUNK_SIZE, DEFAULT_CODE_EXTENSIONS, DEFAULT_IGNORE_PATTERNS, DEFAULT_SEARCH_LIMIT, } from "./code/config.js";
+import { CodeIndexer } from "./code/indexer.js";
 import { EmbeddingProviderFactory } from "./embeddings/factory.js";
 import { BM25SparseVectorGenerator } from "./embeddings/sparse.js";
 import { getPrompt, listPrompts, loadPromptsConfig } from "./prompts/index.js";
@@ -116,6 +118,18 @@ async function checkOllamaAvailability() {
 // Initialize clients
 const qdrant = new QdrantManager(QDRANT_URL);
 const embeddings = EmbeddingProviderFactory.createFromEnv();
+// Initialize code indexer
+const codeConfig = {
+    chunkSize: parseInt(process.env.CODE_CHUNK_SIZE || String(DEFAULT_CHUNK_SIZE), 10),
+    chunkOverlap: parseInt(process.env.CODE_CHUNK_OVERLAP || String(DEFAULT_CHUNK_OVERLAP), 10),
+    enableASTChunking: process.env.CODE_ENABLE_AST !== "false",
+    supportedExtensions: DEFAULT_CODE_EXTENSIONS,
+    ignorePatterns: DEFAULT_IGNORE_PATTERNS,
+    batchSize: parseInt(process.env.CODE_BATCH_SIZE || String(DEFAULT_BATCH_SIZE), 10),
+    defaultSearchLimit: parseInt(process.env.CODE_SEARCH_LIMIT || String(DEFAULT_SEARCH_LIMIT), 10),
+    enableHybridSearch: process.env.CODE_ENABLE_HYBRID === "true",
+};
+const codeIndexer = new CodeIndexer(qdrant, embeddings, codeConfig);
 // Load prompts configuration if file exists
 let promptsConfig = null;
 if (existsSync(PROMPTS_CONFIG_FILE)) {
@@ -322,6 +336,107 @@ function registerHandlers(server) {
                         required: ["collection", "query"],
                     },
                 },
+                {
+                    name: "index_codebase",
+                    description: "Index a codebase for semantic code search. Automatically discovers files, chunks code intelligently using AST-aware parsing, and stores in vector database. Respects .gitignore and other ignore files.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            path: {
+                                type: "string",
+                                description: "Absolute or relative path to codebase root directory",
+                            },
+                            forceReindex: {
+                                type: "boolean",
+                                description: "Force full re-index even if already indexed (default: false)",
+                            },
+                            extensions: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Custom file extensions to index (e.g., ['.proto', '.graphql'])",
+                            },
+                            ignorePatterns: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Additional patterns to ignore (e.g., ['**/test/**', '**/*.test.ts'])",
+                            },
+                        },
+                        required: ["path"],
+                    },
+                },
+                {
+                    name: "search_code",
+                    description: "Search indexed codebase using natural language queries. Returns semantically relevant code chunks with file paths and line numbers.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            path: {
+                                type: "string",
+                                description: "Path to codebase (must be indexed first)",
+                            },
+                            query: {
+                                type: "string",
+                                description: "Natural language search query (e.g., 'authentication logic')",
+                            },
+                            limit: {
+                                type: "number",
+                                description: "Maximum number of results (default: 5, max: 100)",
+                            },
+                            fileTypes: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Filter by file extensions (e.g., ['.ts', '.py'])",
+                            },
+                            pathPattern: {
+                                type: "string",
+                                description: "Filter by path glob pattern (e.g., 'src/services/**')",
+                            },
+                        },
+                        required: ["path", "query"],
+                    },
+                },
+                {
+                    name: "reindex_changes",
+                    description: "Incrementally re-index only changed files. Detects added, modified, and deleted files since last index. Requires previous indexing with index_codebase.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            path: {
+                                type: "string",
+                                description: "Path to codebase",
+                            },
+                        },
+                        required: ["path"],
+                    },
+                },
+                {
+                    name: "get_index_status",
+                    description: "Get indexing status and statistics for a codebase.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            path: {
+                                type: "string",
+                                description: "Path to codebase",
+                            },
+                        },
+                        required: ["path"],
+                    },
+                },
+                {
+                    name: "clear_index",
+                    description: "Delete all indexed data for a codebase. This is irreversible and will remove the entire collection.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            path: {
+                                type: "string",
+                                description: "Path to codebase",
+                            },
+                        },
+                        required: ["path"],
+                    },
+                },
             ],
         };
     });
@@ -521,6 +636,141 @@ function registerHandlers(server) {
                         ],
                     };
                 }
+                case "index_codebase": {
+                    const IndexCodebaseSchema = z.object({
+                        path: z.string(),
+                        forceReindex: z.boolean().optional(),
+                        extensions: z.array(z.string()).optional(),
+                        ignorePatterns: z.array(z.string()).optional(),
+                    });
+                    const { path, forceReindex, extensions, ignorePatterns } = IndexCodebaseSchema.parse(args);
+                    const stats = await codeIndexer.indexCodebase(path, { forceReindex, extensions, ignorePatterns }, (progress) => {
+                        // Progress callback - could send progress updates via SSE in future
+                        console.error(`[${progress.phase}] ${progress.percentage}% - ${progress.message}`);
+                    });
+                    let statusMessage = `Indexed ${stats.filesIndexed}/${stats.filesScanned} files (${stats.chunksCreated} chunks) in ${(stats.durationMs / 1000).toFixed(1)}s`;
+                    if (stats.status === "partial") {
+                        statusMessage += `\n\nWarnings:\n${stats.errors?.join("\n")}`;
+                    }
+                    else if (stats.status === "failed") {
+                        statusMessage = `Indexing failed:\n${stats.errors?.join("\n")}`;
+                    }
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: statusMessage,
+                            },
+                        ],
+                        isError: stats.status === "failed",
+                    };
+                }
+                case "search_code": {
+                    const SearchCodeSchema = z.object({
+                        path: z.string(),
+                        query: z.string(),
+                        limit: z.number().optional(),
+                        fileTypes: z.array(z.string()).optional(),
+                        pathPattern: z.string().optional(),
+                    });
+                    const { path, query, limit, fileTypes, pathPattern } = SearchCodeSchema.parse(args);
+                    const results = await codeIndexer.searchCode(path, query, {
+                        limit,
+                        fileTypes,
+                        pathPattern,
+                    });
+                    if (results.length === 0) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `No results found for query: "${query}"`,
+                                },
+                            ],
+                        };
+                    }
+                    // Format results with file references
+                    const formattedResults = results
+                        .map((r, idx) => `\n--- Result ${idx + 1} (score: ${r.score.toFixed(3)}) ---\n` +
+                        `File: ${r.filePath}:${r.startLine}-${r.endLine}\n` +
+                        `Language: ${r.language}\n\n` +
+                        `${r.content}\n`)
+                        .join("\n");
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Found ${results.length} result(s):\n${formattedResults}`,
+                            },
+                        ],
+                    };
+                }
+                case "get_index_status": {
+                    const GetIndexStatusSchema = z.object({
+                        path: z.string(),
+                    });
+                    const { path } = GetIndexStatusSchema.parse(args);
+                    const status = await codeIndexer.getIndexStatus(path);
+                    if (!status.isIndexed) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Codebase at "${path}" is not indexed. Use index_codebase to index it first.`,
+                                },
+                            ],
+                        };
+                    }
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify(status, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case "reindex_changes": {
+                    const ReindexChangesSchema = z.object({
+                        path: z.string(),
+                    });
+                    const { path } = ReindexChangesSchema.parse(args);
+                    const stats = await codeIndexer.reindexChanges(path, (progress) => {
+                        console.error(`[${progress.phase}] ${progress.percentage}% - ${progress.message}`);
+                    });
+                    let message = `Incremental re-index complete:\n`;
+                    message += `- Files added: ${stats.filesAdded}\n`;
+                    message += `- Files modified: ${stats.filesModified}\n`;
+                    message += `- Files deleted: ${stats.filesDeleted}\n`;
+                    message += `- Chunks added: ${stats.chunksAdded}\n`;
+                    message += `- Duration: ${(stats.durationMs / 1000).toFixed(1)}s`;
+                    if (stats.filesAdded === 0 && stats.filesModified === 0 && stats.filesDeleted === 0) {
+                        message = `No changes detected. Codebase is up to date.`;
+                    }
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: message,
+                            },
+                        ],
+                    };
+                }
+                case "clear_index": {
+                    const ClearIndexSchema = z.object({
+                        path: z.string(),
+                    });
+                    const { path } = ClearIndexSchema.parse(args);
+                    await codeIndexer.clearIndex(path);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Index cleared for codebase at "${path}".`,
+                            },
+                        ],
+                    };
+                }
                 default:
                     return {
                         content: [