@wrongstack/plug-lsp 0.7.4 → 0.7.6

package/dist/index.js

@@ -5,6 +5,7 @@ import { TOKENS, buildChildEnv, atomicWrite } from '@wrongstack/core';
 import { pathToFileURL, fileURLToPath } from 'url';
 import { EventEmitter } from 'events';
 import * as fs3 from 'fs';
+import { IndexStore, buildIndexableText, buildBm25Index, tokenise, internalKindToLspKind, lspKindToInternalKind } from '@wrongstack/tools/codebase-index/index';
 
 // src/presets.ts
 var PRESETS = {
@@ -1426,6 +1427,298 @@ function formatActions(actions) {
   return actions.map((a, i) => `[${i}] ${a.kind ?? "action"} ${a.title}`).join("\n");
 }
 
+// src/constants.ts
+var LSP_CONSTANTS = Object.freeze({
+  /** Default timeout for LSP tool operations (5 seconds). */
+  TOOL_TIMEOUT_MS: 5e3
+});
+
+// src/formatters/symbols.ts
+function formatDocumentSymbols(path8, symbols, cwd) {
+  if (!symbols || symbols.length === 0) return "No symbols found.";
+  const lines = [`${displayPath(path8, cwd)}:`];
+  for (const sym of symbols) appendSymbol(lines, sym, 1, cwd);
+  return lines.join("\n");
+}
+function formatWorkspaceSymbols(symbols, query, cwd, limit = 100) {
+  if (!symbols || symbols.length === 0) return `No symbols matching "${query}".`;
+  const lines = [`${symbols.length} symbols matching "${query}":`];
+  for (const sym of symbols.slice(0, limit)) {
+    lines.push(
+      `  ${kindName(sym.kind)} ${sym.name} ${displayPath(uriToPath(sym.location.uri), cwd)}:${sym.location.range.start.line + 1}`
+    );
+  }
+  if (symbols.length > limit) lines.push(`  ... truncated ${symbols.length - limit} more`);
+  return lines.join("\n");
+}
+function appendSymbol(lines, sym, depth, cwd) {
+  const indent = "  ".repeat(depth);
+  if ("selectionRange" in sym) {
+    lines.push(
+      `${indent}${kindName(sym.kind)} ${sym.name} (L${sym.selectionRange.start.line + 1})`
+    );
+    for (const child of sym.children ?? []) appendSymbol(lines, child, depth + 1, cwd);
+  } else {
+    lines.push(
+      `${indent}${kindName(sym.kind)} ${sym.name} ${displayPath(uriToPath(sym.location.uri), cwd)}:${sym.location.range.start.line + 1}`
+    );
+  }
+}
+function kindName(kind) {
+  return [
+    "file",
+    "module",
+    "namespace",
+    "package",
+    "class",
+    "method",
+    "property",
+    "field",
+    "constructor",
+    "enum",
+    "interface",
+    "function",
+    "variable",
+    "constant",
+    "string",
+    "number",
+    "boolean",
+    "array",
+    "object",
+    "key",
+    "null",
+    "enumMember",
+    "struct",
+    "event",
+    "operator",
+    "typeParameter"
+  ][kind - 1] ?? "symbol";
+}
+function formatCodebaseLspResults(output, cwd) {
+  const { results, totalIndex, totalLsp, query, usedIndex, usedLsp } = output;
+  if (results.length === 0) {
+    const sources = [];
+    if (usedIndex) sources.push(`index(${totalIndex})`);
+    if (usedLsp) sources.push(`lsp(${totalLsp})`);
+    return `No symbols matching "${query}". Searched: ${sources.join(", ") || "none"}.`;
+  }
+  const lines = [];
+  lines.push(`${results.length} results for "${query}" (index:${totalIndex} lsp:${totalLsp}):`);
+  for (const r of results) {
+    const sourceTag = r.source === "index" ? "[index]" : `[lsp:${r.server ?? "?"}]`;
+    const scoreTag = r.score !== void 0 ? ` score=${r.score.toFixed(2)}` : "";
+    const location = `${displayPath(r.file, cwd)}:${r.line}`;
+    if (r.snippet) {
+      lines.push(`  ${sourceTag} ${r.kind} ${r.name} ${location}${scoreTag}`);
+      lines.push(`      ${r.snippet}`);
+    } else {
+      lines.push(`  ${sourceTag} ${r.kind} ${r.name} ${location}${scoreTag}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/tools/codebase-lsp-search.ts
+function createCodebaseLspSearchTool(deps) {
+  return {
+    name: "codebase-lsp-search",
+    description: "Search code symbols using a fast SQLite+BM25 index, falling back to live LSP workspaceSymbol queries when needed.",
+    usageHint: "Pass `query` to search. Use `limit` (default 20) to cap results. Set `preferLsp=true` to skip the index and query LSP servers directly for live precision.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query string" },
+        limit: {
+          type: "integer",
+          description: "Maximum number of results to return (default 20, max 100)",
+          minimum: 1,
+          maximum: 100
+        },
+        preferLsp: {
+          type: "boolean",
+          description: "If true, skip the index and query LSP servers directly. Useful for live precision when the index may be stale."
+        }
+      },
+      required: ["query"]
+    },
+    permission: "auto",
+    mutating: false,
+    timeoutMs: LSP_CONSTANTS.TOOL_TIMEOUT_MS * 2,
+    // Allow extra time for LSP round-robins
+    async execute(input, ctx, opts) {
+      try {
+        const limit = Math.min(input.limit ?? 20, 100);
+        const query = input.query ?? "";
+        let indexResults = [];
+        let totalIndex = 0;
+        let usedIndex = false;
+        let usedLsp = false;
+        let lspResults = [];
+        let totalLsp = 0;
+        if (!input.preferLsp) {
+          const indexOutcome = await searchIndex(ctx.projectRoot, query, limit);
+          indexResults = indexOutcome.results;
+          totalIndex = indexOutcome.total;
+          usedIndex = true;
+        }
+        const needsLsp = input.preferLsp || indexResults.length === 0;
+        if (needsLsp) {
+          const lspOutcome = await searchLsp(deps, query, limit, opts.signal);
+          lspResults = lspOutcome.results;
+          totalLsp = lspOutcome.total;
+          usedLsp = true;
+        }
+        const output = mergeResults(indexResults, lspResults, limit);
+        const fullOutput = {
+          results: output,
+          totalIndex,
+          totalLsp,
+          query,
+          usedIndex,
+          usedLsp
+        };
+        return formatCodebaseLspResults(fullOutput, ctx.cwd);
+      } catch (err) {
+        return stringifyToolError(err);
+      }
+    }
+  };
+}
+async function searchIndex(projectRoot, query, limit) {
+  const store = new IndexStore(projectRoot);
+  try {
+    const candidates = store.search(query);
+    if (candidates.length === 0) {
+      return { results: [], total: 0 };
+    }
+    const indexable = candidates.map((c) => ({
+      id: c.id,
+      text: buildIndexableText(c.name, c.signature, c.docComment)
+    }));
+    const bm25 = buildBm25Index(indexable);
+    const scored = bm25.score(query, (id) => candidates.some((c) => c.id === id));
+    scored.sort((a, b) => b.score - a.score);
+    const top = scored.slice(0, limit);
+    const qTokens = tokenise(query);
+    const results = top.map(({ id, score }) => {
+      const c = candidates.find((c2) => c2.id === id);
+      const lspKind = internalKindToLspKind(c.kind) ?? 0;
+      const snippet = bm25.extractSnippet(id, qTokens);
+      return {
+        name: c.name,
+        kind: c.kind,
+        lspKind,
+        file: c.file,
+        line: c.line,
+        source: "index",
+        score,
+        snippet
+      };
+    });
+    return { results, total: candidates.length };
+  } finally {
+    store.close();
+  }
+}
+async function searchLsp(deps, query, limit, signal) {
+  const merged = [];
+  const servers = deps.registry.list();
+  const promises = [];
+  for (const server of servers) {
+    if (server.state !== "ready") continue;
+    if (server.capabilities && !supportsWorkspaceSymbol(server.capabilities)) continue;
+    promises.push(
+      (async () => {
+        try {
+          const result = await server.workspaceSymbol(
+            { query },
+            LSP_CONSTANTS.TOOL_TIMEOUT_MS,
+            signal
+          );
+          if (result) {
+            for (const sym of result) {
+              merged.push(sym);
+            }
+          }
+        } catch {
+        }
+      })()
+    );
+  }
+  await Promise.all(promises);
+  const deduplicated = deduplicateByKey(
+    merged.map((sym) => ({
+      name: sym.name,
+      kind: lspKindToInternalKind(sym.kind) ?? "symbol",
+      lspKind: sym.kind,
+      file: sym.location.uri.startsWith("file://") ? sym.location.uri.slice(7) : sym.location.uri,
+      line: sym.location.range.start.line + 1,
+      // convert to 1-based
+      source: "lsp",
+      server: serverNameFromConfig(deps, sym)
+    }))
+  );
+  return {
+    results: deduplicated.slice(0, limit),
+    total: deduplicated.length
+  };
+}
+function serverNameFromConfig(deps, sym) {
+  const file = sym.location.uri;
+  const ext = file.includes(".") ? file.split(".").pop().toLowerCase() : "";
+  const langMap = {
+    ts: ["typescript", "tsserver"],
+    tsx: ["typescript", "tsserver"],
+    js: ["javascript", "typescript"],
+    jsx: ["javascript", "typescript"],
+    py: ["python", "pyright"],
+    go: ["go", "gopls"],
+    rs: ["rust", "rust-analyzer"]
+  };
+  const langs = langMap[ext] ?? [ext];
+  const servers = deps.registry.list();
+  for (const lang of langs) {
+    for (const server of servers) {
+      if (server.state === "ready" && server.config.languages.some((l) => l.toLowerCase() === lang.toLowerCase())) {
+        return server.name;
+      }
+    }
+  }
+  return servers.find((s) => s.state === "ready")?.name ?? "unknown";
+}
+function mergeResults(indexResults, lspResults, limit) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const r of indexResults) {
+    const key = `${r.file}:${r.line}:${r.name}`;
+    seen.set(key, r);
+  }
+  for (const r of lspResults) {
+    const key = `${r.file}:${r.line}:${r.name}`;
+    if (!seen.has(key)) {
+      seen.set(key, r);
+    }
+  }
+  const merged = Array.from(seen.values());
+  merged.sort((a, b) => {
+    if (a.source === "index" && b.source !== "index") return -1;
+    if (a.source !== "index" && b.source === "index") return 1;
+    if (a.source === "index" && b.source === "index") {
+      return (b.score ?? 0) - (a.score ?? 0);
+    }
+    return 0;
+  });
+  return merged.slice(0, limit);
+}
+function deduplicateByKey(items) {
+  const seen = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    const key = `${item.file}:${item.line}:${item.name}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
 // src/formatters/location.ts
 function formatLocations(locations, cwd, limit = 100) {
   if (!locations || locations.length === 0) return "No locations found.";
@@ -1438,12 +1731,6 @@ function formatLocations(locations, cwd, limit = 100) {
   return lines.join("\n");
 }
 
-// src/constants.ts
-var LSP_CONSTANTS = Object.freeze({
-  /** Default timeout for LSP tool operations (5 seconds). */
-  TOOL_TIMEOUT_MS: 5e3
-});
-
 // src/tools/definition.ts
 function createDefinitionTool(deps) {
   return {
@@ -1697,68 +1984,6 @@ Applied: ${applied.edits} edits across ${applied.files.length} files.`;
   };
 }
 
-// src/formatters/symbols.ts
-function formatDocumentSymbols(path8, symbols, cwd) {
-  if (!symbols || symbols.length === 0) return "No symbols found.";
-  const lines = [`${displayPath(path8, cwd)}:`];
-  for (const sym of symbols) appendSymbol(lines, sym, 1, cwd);
-  return lines.join("\n");
-}
-function formatWorkspaceSymbols(symbols, query, cwd, limit = 100) {
-  if (!symbols || symbols.length === 0) return `No symbols matching "${query}".`;
-  const lines = [`${symbols.length} symbols matching "${query}":`];
-  for (const sym of symbols.slice(0, limit)) {
-    lines.push(
-      `  ${kindName(sym.kind)} ${sym.name} ${displayPath(uriToPath(sym.location.uri), cwd)}:${sym.location.range.start.line + 1}`
-    );
-  }
-  if (symbols.length > limit) lines.push(`  ... truncated ${symbols.length - limit} more`);
-  return lines.join("\n");
-}
-function appendSymbol(lines, sym, depth, cwd) {
-  const indent = "  ".repeat(depth);
-  if ("selectionRange" in sym) {
-    lines.push(
-      `${indent}${kindName(sym.kind)} ${sym.name} (L${sym.selectionRange.start.line + 1})`
-    );
-    for (const child of sym.children ?? []) appendSymbol(lines, child, depth + 1, cwd);
-  } else {
-    lines.push(
-      `${indent}${kindName(sym.kind)} ${sym.name} ${displayPath(uriToPath(sym.location.uri), cwd)}:${sym.location.range.start.line + 1}`
-    );
-  }
-}
-function kindName(kind) {
-  return [
-    "file",
-    "module",
-    "namespace",
-    "package",
-    "class",
-    "method",
-    "property",
-    "field",
-    "constructor",
-    "enum",
-    "interface",
-    "function",
-    "variable",
-    "constant",
-    "string",
-    "number",
-    "boolean",
-    "array",
-    "object",
-    "key",
-    "null",
-    "enumMember",
-    "struct",
-    "event",
-    "operator",
-    "typeParameter"
-  ][kind - 1] ?? "symbol";
-}
-
 // src/tools/symbols.ts
 function createSymbolsTool(deps) {
   return {
@@ -1818,6 +2043,7 @@ function makeLSPTools(deps) {
     createReferencesTool(deps),
     createHoverTool(deps),
     createSymbolsTool(deps),
+    createCodebaseLspSearchTool(deps),
     createRenameTool(deps),
     createCodeActionsTool(deps)
   ];