@usewhisper/mcp-server 0.3.0 → 0.4.0

package/dist/server.js

@@ -4,6 +4,9 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
+import { execSync, spawnSync } from "child_process";
+import { readdirSync, readFileSync, statSync } from "fs";
+import { join, relative, extname } from "path";
 
 // ../src/sdk/index.ts
 var WhisperError = class extends Error {
@@ -543,6 +546,23 @@ var WhisperContext = class _WhisperContext {
     });
     return this.request(`/v1/cost/breakdown?${query}`);
   }
+  /**
+   * Semantic search over raw documents without pre-indexing.
+   * Send file contents/summaries directly — the API embeds them in-memory and ranks by similarity.
+   * Perfect for AI agents to semantically explore a codebase on-the-fly.
+   */
+  async semanticSearch(params) {
+    return this.request("/v1/search/semantic", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  async searchFiles(params) {
+    return this.request("/v1/search/files", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
   async getCostSavings(params = {}) {
     const resolvedProject = params.project ? await this.resolveProjectId(params.project) : void 0;
     const query = new URLSearchParams({
@@ -1051,6 +1071,291 @@ server.tool(
     }
   }
 );
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".next", "build", "__pycache__", ".turbo", "coverage", ".cache"]);
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "py", "go", "rs", "java", "cpp", "c", "cs", "rb", "php", "swift", "kt", "sql", "prisma", "graphql", "json", "yaml", "yml", "toml", "env"]);
+function extractSignature(filePath, content) {
+  const lines = content.split("\n");
+  const signature = [`// File: ${filePath}`];
+  const head = lines.slice(0, 60);
+  for (const line of head) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("*")) continue;
+    if (/^(import|from|require|use |pub use )/.test(trimmed)) {
+      signature.push(trimmed.slice(0, 120));
+      continue;
+    }
+    if (/^(export|async function|function|class|interface|type |const |let |def |pub fn |fn |struct |impl |enum )/.test(trimmed)) {
+      signature.push(trimmed.slice(0, 120));
+      continue;
+    }
+    if (trimmed.startsWith("@") || trimmed.startsWith("#[")) {
+      signature.push(trimmed.slice(0, 80));
+    }
+  }
+  for (const line of lines.slice(60)) {
+    const trimmed = line.trim();
+    if (/^(export (default |async )?function|export (default )?class|export const|export type|export interface|async function|function |class |def |pub fn |fn )/.test(trimmed)) {
+      signature.push(trimmed.slice(0, 120));
+    }
+  }
+  return signature.join("\n").slice(0, 2e3);
+}
+server.tool(
+  "semantic_search_codebase",
+  "Semantically search a local codebase without pre-indexing. Unlike grep/ripgrep, this understands meaning \u2014 so 'find authentication logic' finds auth code even if it doesn't literally say 'auth'. Uses vector embeddings via the Whisper API. Perfect for exploring unfamiliar codebases.",
+  {
+    query: z.string().describe("Natural language description of what you're looking for. E.g. 'authentication and session management', 'database connection pooling', 'error handling middleware'"),
+    path: z.string().optional().describe("Absolute path to the codebase root. Defaults to current working directory."),
+    file_types: z.array(z.string()).optional().describe("Limit to specific extensions e.g. ['ts', 'py']. Defaults to all common code files."),
+    top_k: z.number().optional().default(10).describe("Number of most relevant files to return"),
+    threshold: z.number().optional().default(0.2).describe("Minimum similarity score 0-1. Lower = more results but less precise."),
+    max_files: z.number().optional().default(300).describe("Max files to scan. For large codebases, increase this or narrow with file_types.")
+  },
+  async ({ query, path: searchPath, file_types, top_k, threshold, max_files }) => {
+    const rootPath = searchPath || process.cwd();
+    const allowedExts = file_types ? new Set(file_types) : CODE_EXTENSIONS;
+    const files = [];
+    function collect(dir) {
+      if (files.length >= (max_files ?? 300)) return;
+      let entries;
+      try {
+        entries = readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (files.length >= (max_files ?? 300)) break;
+        if (SKIP_DIRS.has(entry.name)) continue;
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          collect(full);
+        } else if (entry.isFile()) {
+          const ext = extname(entry.name).replace(".", "");
+          if (allowedExts.has(ext)) files.push(full);
+        }
+      }
+    }
+    collect(rootPath);
+    if (files.length === 0) {
+      return { content: [{ type: "text", text: `No code files found in ${rootPath}` }] };
+    }
+    const documents = [];
+    for (const filePath of files) {
+      try {
+        const stat = statSync(filePath);
+        if (stat.size > 500 * 1024) continue;
+        const content = readFileSync(filePath, "utf-8");
+        const relPath = relative(rootPath, filePath);
+        const signature = extractSignature(relPath, content);
+        documents.push({ id: relPath, content: signature });
+      } catch {
+      }
+    }
+    if (documents.length === 0) {
+      return { content: [{ type: "text", text: "Could not read any files." }] };
+    }
+    let response;
+    try {
+      response = await whisper.semanticSearch({
+        query,
+        documents,
+        top_k: top_k ?? 10,
+        threshold: threshold ?? 0.2
+      });
+    } catch (error) {
+      return { content: [{ type: "text", text: `Semantic search failed: ${error.message}` }] };
+    }
+    if (!response.results || response.results.length === 0) {
+      return { content: [{ type: "text", text: `No semantically relevant files found for: "${query}"
+
+Searched ${documents.length} files in ${rootPath}.
+
+Try lowering the threshold or rephrasing your query.` }] };
+    }
+    const lines = [
+      `Semantic search: "${query}"`,
+      `Searched ${documents.length} files \u2192 ${response.results.length} relevant (${response.latency_ms}ms)
+`
+    ];
+    for (const result of response.results) {
+      lines.push(`\u{1F4C4} ${result.id}  (score: ${result.score})`);
+      if (result.snippet) {
+        lines.push(`   ${result.snippet}`);
+      }
+      if (result.score > 0.5) {
+        try {
+          const fullPath = join(rootPath, result.id);
+          const content = readFileSync(fullPath, "utf-8");
+          const excerpt = content.split("\n").slice(0, 30).join("\n");
+          lines.push(`
+\`\`\`
+${excerpt}
+\`\`\``);
+        } catch {
+        }
+      }
+      lines.push("");
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  }
+);
+function* walkDir(dir, fileTypes) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (["node_modules", ".git", "dist", ".next", "build", "__pycache__"].includes(entry.name)) continue;
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      yield* walkDir(full, fileTypes);
+    } else if (entry.isFile()) {
+      if (!fileTypes || fileTypes.length === 0) yield full;
+      else if (fileTypes.includes(extname(entry.name).replace(".", ""))) yield full;
+    }
+  }
+}
+server.tool(
+  "search_files",
+  "Search files and content in a local directory without requiring pre-indexing. Uses ripgrep when available, falls back to Node.js. Great for finding files, functions, patterns, or any text across a codebase instantly.",
+  {
+    query: z.string().describe("What to search for \u2014 natural language keyword, function name, pattern, etc."),
+    path: z.string().optional().describe("Absolute path to search in. Defaults to current working directory."),
+    mode: z.enum(["content", "filename", "both"]).optional().default("both").describe("Search file contents, filenames, or both"),
+    file_types: z.array(z.string()).optional().describe("Limit to these file extensions e.g. ['ts', 'js', 'py', 'go']"),
+    max_results: z.number().optional().default(20).describe("Max number of matching files to return"),
+    context_lines: z.number().optional().default(2).describe("Lines of context around each match"),
+    case_sensitive: z.boolean().optional().default(false)
+  },
+  async ({ query, path: searchPath, mode, file_types, max_results, context_lines, case_sensitive }) => {
+    const rootPath = searchPath || process.cwd();
+    const results = [];
+    const rgAvailable = spawnSync("rg", ["--version"], { stdio: "ignore" }).status === 0;
+    if (rgAvailable && (mode === "content" || mode === "both")) {
+      try {
+        const args = [
+          "--json",
+          case_sensitive ? "" : "-i",
+          `-C`,
+          `${context_lines}`,
+          `-m`,
+          `${max_results}`,
+          "--max-filesize",
+          "1M",
+          "--glob",
+          "!node_modules",
+          "--glob",
+          "!.git",
+          "--glob",
+          "!dist",
+          "--glob",
+          "!.next",
+          "--glob",
+          "!build",
+          ...file_types && file_types.length > 0 ? ["--glob", file_types.length === 1 ? `*.${file_types[0]}` : `*.{${file_types.join(",")}}`] : [],
+          query,
+          rootPath
+        ].filter(Boolean);
+        const output = execSync(`rg ${args.join(" ")}`, {
+          maxBuffer: 10 * 1024 * 1024,
+          stdio: ["pipe", "pipe", "ignore"]
+        }).toString().trim();
+        const fileMap = /* @__PURE__ */ new Map();
+        for (const line of output.split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            const entry = JSON.parse(line);
+            if (entry.type === "match") {
+              const filePath = relative(rootPath, entry.data.path.text);
+              if (!fileMap.has(filePath)) fileMap.set(filePath, []);
+              fileMap.get(filePath).push({
+                line: entry.data.line_number,
+                content: entry.data.lines.text.trimEnd(),
+                context_before: [],
+                context_after: []
+              });
+            }
+          } catch {
+          }
+        }
+        for (const [file, matches] of fileMap) {
+          if (results.length >= (max_results ?? 20)) break;
+          results.push({ file, matches });
+        }
+      } catch (err) {
+        if (err.status !== 1) {
+        }
+      }
+    }
+    if (mode === "filename" || mode === "both") {
+      const queryLower = query.toLowerCase();
+      const existingFiles = new Set(results.map((r) => r.file));
+      for (const filePath of walkDir(rootPath, file_types)) {
+        if (results.length >= (max_results ?? 20)) break;
+        const relPath = relative(rootPath, filePath);
+        const check = case_sensitive ? relPath : relPath.toLowerCase();
+        if (check.includes(case_sensitive ? query : queryLower) && !existingFiles.has(relPath)) {
+          results.push({ file: relPath, matches: [] });
+          existingFiles.add(relPath);
+        }
+      }
+    }
+    if (!rgAvailable && (mode === "content" || mode === "both")) {
+      const regex = new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), case_sensitive ? "g" : "gi");
+      for (const filePath of walkDir(rootPath, file_types)) {
+        if (results.length >= (max_results ?? 20)) break;
+        try {
+          const stat = statSync(filePath);
+          if (stat.size > 512 * 1024) continue;
+          const text = readFileSync(filePath, "utf-8");
+          const lines2 = text.split("\n");
+          const matches = [];
+          lines2.forEach((line, i) => {
+            regex.lastIndex = 0;
+            if (regex.test(line)) {
+              matches.push({
+                line: i + 1,
+                content: line.trimEnd(),
+                context_before: lines2.slice(Math.max(0, i - (context_lines ?? 2)), i).map((l) => l.trimEnd()),
+                context_after: lines2.slice(i + 1, i + 1 + (context_lines ?? 2)).map((l) => l.trimEnd())
+              });
+              regex.lastIndex = 0;
+            }
+          });
+          if (matches.length > 0) results.push({ file: relative(rootPath, filePath), matches });
+        } catch {
+        }
+      }
+    }
+    if (results.length === 0) {
+      return { content: [{ type: "text", text: `No results found for "${query}" in ${rootPath}` }] };
+    }
+    const totalMatches = results.reduce((s, r) => s + r.matches.length, 0);
+    const lines = [
+      `Found ${results.length} file(s), ${totalMatches} match(es) for "${query}" in ${rootPath}
+`
+    ];
+    for (const result of results) {
+      lines.push(`\u{1F4C4} ${result.file}`);
+      for (const match of result.matches.slice(0, 5)) {
+        if (match.context_before.length > 0) {
+          lines.push(...match.context_before.map((l) => `  ${l}`));
+        }
+        lines.push(`\u2192 L${match.line}: ${match.content}`);
+        if (match.context_after.length > 0) {
+          lines.push(...match.context_after.map((l) => `  ${l}`));
+        }
+      }
+      if (result.matches.length > 5) {
+        lines.push(`  ... and ${result.matches.length - 5} more matches`);
+      }
+      lines.push("");
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  }
+);
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usewhisper/mcp-server",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "scripts": {
     "build": "tsup ../src/mcp/server.ts --format esm --out-dir dist",
     "prepublishOnly": "npm run build"