semantic-code-mcp 2.0.0

package/features/get-status.js

@@ -0,0 +1,210 @@
+/**
+ * Get Status Feature
+ * 
+ * MCP tool to return comprehensive status information about the server.
+ * Useful for agents to understand current state and configuration.
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const packageJson = require('../package.json');
+
+/**
+ * Get tool definition for MCP registration
+ */
+export function getToolDefinition(config) {
+  return {
+    name: "f_get_status",
+    description: "Get comprehensive status information about the Smart Coding MCP server. Returns version, workspace path, model configuration, indexing status, and cache information. Useful for understanding the current state of the semantic search system.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  };
+}
+
+/**
+ * Status Reporter class
+ */
+export class StatusReporter {
+  constructor(config, cache, indexer, embedder) {
+    this.config = config;
+    this.cache = cache;
+    this.indexer = indexer;
+    this.embedder = embedder;
+    this.startTime = Date.now();
+  }
+
+  /**
+   * Get comprehensive status
+   */
+  async getStatus() {
+    const vectorStoreProvider = (this.config.vectorStoreProvider || 'sqlite').toLowerCase();
+    let totalChunks = 0;
+    let totalFiles = 0;
+
+    if (typeof this.cache?.getStats === 'function') {
+      try {
+        const stats = await this.cache.getStats();
+        totalChunks = Number(stats?.totalChunks || 0);
+        totalFiles = Number(stats?.totalFiles || 0);
+      } catch (err) {
+        // Fallback to legacy vectorStore contract if cache-specific stats fail.
+      }
+    }
+
+    if (totalChunks === 0 && totalFiles === 0) {
+      const vectorStore = this.cache?.getVectorStore?.() || [];
+      totalChunks = vectorStore.length;
+      totalFiles = new Set(vectorStore.map((v) => v.file)).size;
+    }
+    
+    // Get cache size (check for SQLite database)
+    let cacheSizeBytes = 0;
+    let cacheType = 'none';
+    if (vectorStoreProvider === 'milvus') {
+      cacheType = 'milvus';
+    } else {
+      try {
+        // Check for SQLite cache first
+        const sqlitePath = path.join(this.config.cacheDirectory, 'embeddings.db');
+        const stats = await fs.stat(sqlitePath);
+        cacheSizeBytes = stats.size;
+        cacheType = 'sqlite';
+      } catch {
+        // Try old JSON cache as fallback
+        try {
+          const jsonPath = path.join(this.config.cacheDirectory, 'embeddings.json');
+          const stats = await fs.stat(jsonPath);
+          cacheSizeBytes = stats.size;
+          cacheType = 'json';
+        } catch {
+          // No cache file exists
+          cacheType = 'none';
+        }
+      }
+    }
+
+    // Determine index status and progressive indexing info
+    let indexStatus = 'empty';
+    let progressiveIndexing = null;
+    
+    if (this.indexer?.isIndexing) {
+      indexStatus = 'indexing';
+      // Include progressive indexing status
+      if (this.indexer.indexingStatus) {
+        progressiveIndexing = {
+          inProgress: this.indexer.indexingStatus.inProgress,
+          totalFiles: this.indexer.indexingStatus.totalFiles,
+          processedFiles: this.indexer.indexingStatus.processedFiles,
+          percentage: this.indexer.indexingStatus.percentage
+        };
+      }
+    } else if (totalChunks > 0) {
+      indexStatus = 'ready';
+    }
+
+    const provider = (this.config.embeddingProvider || "local").toLowerCase();
+    const isApiProvider = ["gemini", "openai", "openai-compatible", "vertex"].includes(provider);
+    const defaultApiModel =
+      provider === "vertex"
+        ? "gemini-embedding-001"
+        : (provider === "openai" || provider === "openai-compatible")
+          ? "text-embedding-3-small"
+          : (this.config.geminiModel || "gemini-embedding-001");
+    const configuredApiModel =
+      typeof this.config.embeddingModel === "string" && this.config.embeddingModel.trim().length > 0
+        ? this.config.embeddingModel.trim()
+        : "";
+
+    return {
+      version: packageJson.version,
+      uptime: Math.floor((Date.now() - this.startTime) / 1000),
+      
+      workspace: {
+        path: this.config.searchDirectory,
+        cacheDirectory: this.config.cacheDirectory
+      },
+
+      model: {
+        provider: this.config.embeddingProvider,
+        name: this.embedder?.modelName || (
+          isApiProvider
+            ? (
+                configuredApiModel && !configuredApiModel.includes("nomic")
+                  ? configuredApiModel
+                  : defaultApiModel
+              )
+            : this.config.embeddingModel
+        ),
+        dimension: this.embedder?.dimension || (
+          isApiProvider
+            ? this.config.geminiDimensions
+            : this.config.embeddingDimension
+        ),
+        device: this.embedder?.device || this.config.device
+      },
+
+      index: {
+        status: indexStatus,
+        filesIndexed: totalFiles,
+        chunksCount: totalChunks,
+        chunkingMode: this.config.chunkingMode,
+        ...(progressiveIndexing && { progressiveIndexing })
+      },
+
+      cache: {
+        enabled: this.config.enableCache,
+        type: cacheType,
+        path: cacheType === 'milvus' ? this.config.milvusAddress : this.config.cacheDirectory,
+        sizeBytes: cacheSizeBytes,
+        sizeFormatted: formatBytes(cacheSizeBytes)
+      },
+
+      config: {
+        maxResults: this.config.maxResults,
+        chunkSize: this.config.chunkSize,
+        semanticWeight: this.config.semanticWeight,
+        exactMatchBoost: this.config.exactMatchBoost,
+        workerThreads: this.config.workerThreads,
+        embeddingProvider: this.config.embeddingProvider,
+        vectorStoreProvider
+      },
+      
+      resourceThrottling: {
+        maxCpuPercent: this.config.maxCpuPercent,
+        batchDelay: this.config.batchDelay,
+        maxWorkers: this.config.maxWorkers
+      }
+    };
+  }
+}
+
+/**
+ * Format bytes to human readable
+ */
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+/**
+ * Handle MCP tool call
+ */
+export async function handleToolCall(request, instance) {
+  const status = await instance.getStatus();
+
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify(status, null, 2)
+    }]
+  };
+}

package/features/hybrid-search.js

@@ -0,0 +1,189 @@
+import path from "path";
+import { cosineSimilarity } from "../lib/utils.js";
+
+export class HybridSearch {
+  constructor(embedder, cache, config, indexer = null) {
+    this.embedder = embedder;
+    this.cache = cache;
+    this.config = config;
+    this.indexer = indexer; // Reference to indexer for status checking
+  }
+
+  async search(query, maxResults) {
+    const hasAnnSearch = typeof this.cache?.searchByVector === "function";
+
+    // Show warning if indexing is still in progress but we have some results
+    let indexingWarning = null;
+    if (this.indexer?.indexingStatus?.inProgress) {
+      indexingWarning = `⚠️ Indexing in progress (${this.indexer.indexingStatus.percentage}% complete). Results shown are from partially indexed codebase.\n\n`;
+    }
+
+    // Generate query embedding
+    const queryEmbed = await this.embedder(query, { pooling: "mean", normalize: true });
+    const queryVector = Array.from(queryEmbed.data);
+
+    if (hasAnnSearch) {
+      const annTopK = Math.max(maxResults * 5, 20);
+      const candidates = await this.cache.searchByVector(queryVector, annTopK);
+
+      const scoredChunks = candidates.map((chunk) => {
+        // Base semantic score from provider (Milvus or fallback cache) plus lexical boost.
+        let score = Number(chunk.score || 0) * this.config.semanticWeight;
+
+        const lowerQuery = query.toLowerCase();
+        const lowerContent = String(chunk.content || "").toLowerCase();
+
+        if (lowerContent.includes(lowerQuery)) {
+          score += this.config.exactMatchBoost;
+        } else {
+          const queryWords = lowerQuery.split(/\s+/).filter(Boolean);
+          const matchedWords = queryWords.filter(
+            (word) => word.length > 2 && lowerContent.includes(word)
+          ).length;
+          const lexicalBoost = queryWords.length > 0 ? (matchedWords / queryWords.length) * 0.3 : 0;
+          score += lexicalBoost;
+        }
+
+        return { ...chunk, score };
+      });
+
+      const results = scoredChunks
+        .sort((a, b) => b.score - a.score)
+        .slice(0, maxResults);
+
+      if (results.length === 0) {
+        const stats = typeof this.cache?.getStats === "function"
+          ? await this.cache.getStats().catch(() => null)
+          : null;
+        const totalChunks = Number(stats?.totalChunks || 0);
+
+        if (totalChunks === 0) {
+          if (this.indexer?.indexingStatus?.inProgress) {
+            return {
+              results: [],
+              message: `Indexing in progress (${this.indexer.indexingStatus.percentage}% complete). Search available but results may be incomplete. Please wait for indexing to finish for full coverage.`
+            };
+          }
+          return {
+            results: [],
+            message: "No code has been indexed yet. Please wait for initial indexing to complete."
+          };
+        }
+      }
+
+      return { results, message: null, indexingWarning };
+    }
+
+    // Legacy fallback: in-memory vector scoring.
+    const vectorStore = this.cache.getVectorStore();
+
+    if (vectorStore.length === 0) {
+      if (this.indexer?.indexingStatus?.inProgress) {
+        return {
+          results: [],
+          message: `Indexing in progress (${this.indexer.indexingStatus.percentage}% complete). Search available but results may be incomplete. Please wait for indexing to finish for full coverage.`
+        };
+      }
+      return {
+        results: [],
+        message: "No code has been indexed yet. Please wait for initial indexing to complete."
+      };
+    }
+
+    const scoredChunks = vectorStore.map((chunk) => {
+      let score = cosineSimilarity(queryVector, chunk.vector) * this.config.semanticWeight;
+
+      const lowerQuery = query.toLowerCase();
+      const lowerContent = chunk.content.toLowerCase();
+
+      if (lowerContent.includes(lowerQuery)) {
+        score += this.config.exactMatchBoost;
+      } else {
+        const queryWords = lowerQuery.split(/\s+/);
+        const matchedWords = queryWords.filter((word) =>
+          word.length > 2 && lowerContent.includes(word)
+        ).length;
+        score += (matchedWords / queryWords.length) * 0.3;
+      }
+
+      return { ...chunk, score };
+    });
+
+    const results = scoredChunks
+      .sort((a, b) => b.score - a.score)
+      .slice(0, maxResults);
+
+    return { results, message: null, indexingWarning };
+  }
+
+  formatResults(results) {
+    if (results.length === 0) {
+      return "No matching code found for your query.";
+    }
+
+    return results.map((r, idx) => {
+      const relPath = path.relative(this.config.searchDirectory, r.file);
+      return `## Result ${idx + 1} (Relevance: ${(r.score * 100).toFixed(1)}%)\n` +
+             `**File:** \`${relPath}\`\n` +
+             `**Lines:** ${r.startLine}-${r.endLine}\n\n` +
+             "```" + path.extname(r.file).slice(1) + "\n" +
+             r.content + "\n" +
+             "```\n";
+    }).join("\n");
+  }
+}
+
+// MCP Tool definition for this feature
+export function getToolDefinition(config) {
+  return {
+    name: "a_semantic_search",
+    description: "Performs intelligent hybrid code search combining semantic understanding with exact text matching. Ideal for finding code by meaning (e.g., 'authentication logic', 'database queries') even with typos or variations. Returns the most relevant code snippets with file locations and line numbers.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { 
+          type: "string", 
+          description: "Search query - can be natural language (e.g., 'where do we handle user login') or specific terms" 
+        },
+        maxResults: {
+          type: "number",
+          description: "Maximum number of results to return (default: from config)",
+          default: config.maxResults
+        }
+      },
+      required: ["query"]
+    },
+    annotations: {
+      title: "Semantic Code Search",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    }
+  };
+}
+
+// Tool handler
+export async function handleToolCall(request, hybridSearch) {
+  const query = request.params.arguments.query;
+  const maxResults = request.params.arguments.maxResults || hybridSearch.config.maxResults;
+  
+  const { results, message, indexingWarning } = await hybridSearch.search(query, maxResults);
+  
+  if (message) {
+    return {
+      content: [{ type: "text", text: message }]
+    };
+  }
+
+  let formattedText = hybridSearch.formatResults(results);
+  
+  // Prepend indexing warning if present
+  if (indexingWarning) {
+    formattedText = indexingWarning + formattedText;
+  }
+  
+  return {
+    content: [{ type: "text", text: formattedText }]
+  };
+}