@wrongstack/plug-lsp 0.269.0 → 0.272.0

package/README.md

@@ -85,7 +85,7 @@ The primary interface for all LSP operations:
 
 ## Registered Tools
 
-The plugin registers 4 tools into WrongStack's tool system. These are kept because
+The plugin registers 5 tools into WrongStack's tool system. These are kept because
 LSP provides genuinely unique data or capability the agent cannot replicate with
 basic tools (read, grep, edit) at comparable cost.
 
@@ -93,6 +93,7 @@ basic tools (read, grep, edit) at comparable cost.
 |---|---|---|
 | `lsp_diagnostics` | `auto` | Get type/lint diagnostics for a file or whole workspace |
 | `lsp_definition` | `auto` | Jump to the definition of a symbol (more precise than grep) |
+| `lsp_completion` | `auto` | Semantic completions for a cursor location, including live editor content when provided |
 | `lsp_rename` | `confirm` | Safe semantic rename across the workspace |
 | `codebase-lsp-search` | `auto` | Fast symbol search via WrongStack's index, with LSP fallback |
 
@@ -236,7 +237,7 @@ packages/plug-lsp/src/
 │   ├── lsp-server.ts   — per-server LSP client (one process per server)
 │   ├── connection.ts    — JSON-RPC 2.0 over stdio transport
 │   └── lifecycle.ts     — state machine for server lifecycle
-├── tools/              — 4 LSP-backed agent tools (diagnostics, definition, rename, codebase-search)
+├── tools/              — 5 LSP-backed agent tools (diagnostics, definition, completion, rename, codebase-search)
 ├── registry.ts         — manages all server instances
 ├── document-tracker.ts — tracks open/edited files across sessions
 ├── auto-discover.ts    — PATH and node_modules discovery

package/dist/index.js

@@ -593,7 +593,17 @@ var DocumentTracker = class {
     const absPath = this.resolve(filePath);
     const languageId = languageIdFor(absPath);
     if (!languageId) return;
-    const text = knownText ?? await fs2.readFile(absPath, "utf8");
+    let text;
+    if (knownText !== void 0) {
+      text = knownText;
+    } else {
+      try {
+        text = await fs2.readFile(absPath, "utf8");
+      } catch (err) {
+        this.log.debug(`LSP tracker could not read file ${absPath}`, err);
+        return;
+      }
+    }
     let doc = this.docs.get(absPath);
     if (!doc) {
       doc = {
@@ -606,6 +616,14 @@ var DocumentTracker = class {
       };
       this.docs.set(absPath, doc);
       this.events?.emit("lsp.document.opened", { path: absPath, language: languageId });
+    } else if (knownText !== void 0 && knownText !== doc.text) {
+      doc.version++;
+      doc.text = knownText;
+      for (const server of this.registry().list()) {
+        if (server.state !== "ready" || !server.config.languages.includes(languageId)) continue;
+        if (!doc.serverNames.has(server.name)) continue;
+        server.notifyDidChange({ uri: doc.uri, version: doc.version }, knownText);
+      }
     }
     for (const server of this.registry().list()) {
       if (server.state !== "ready" || !server.config.languages.includes(languageId)) continue;
@@ -1012,6 +1030,9 @@ var LSPServer = class {
   async hover(params, timeoutMs, signal) {
     return await this.request("textDocument/hover", params, timeoutMs, signal);
   }
+  async completion(params, timeoutMs, signal) {
+    return await this.request("textDocument/completion", params, timeoutMs, signal);
+  }
   async documentSymbol(params, timeoutMs, signal) {
     return await this.request("textDocument/documentSymbol", params, timeoutMs, signal);
   }
@@ -1898,6 +1919,9 @@ function formatCodebaseLspResults(output, cwd) {
 }
 
 // src/server/capabilities.ts
+function supportsCompletion(cap) {
+  return !!cap.completionProvider;
+}
 function supportsDefinition(cap) {
   return !!cap.definitionProvider;
 }
@@ -2116,18 +2140,6 @@ function deduplicateByKey(items) {
   });
 }
 
-// src/formatters/location.ts
-function formatLocations(locations, cwd, limit = 100) {
-  if (!locations || locations.length === 0) return "No locations found.";
-  const lines = locations.slice(0, limit).map((loc) => {
-    const uri = "uri" in loc ? loc.uri : loc.targetUri;
-    const range = "range" in loc ? loc.range : loc.targetSelectionRange;
-    return `${displayPath(uriToPath(uri), cwd)}:${range.start.line + 1}:${range.start.character + 1}`;
-  });
-  if (locations.length > limit) lines.push(`... truncated ${locations.length - limit} more`);
-  return lines.join("\n");
-}
-
 // src/position.ts
 function humanToLSP(content, pos) {
   const lines = splitLines(content);
@@ -2153,6 +2165,143 @@ function clamp(n, min, max) {
   return Math.max(min, Math.min(max, n));
 }
 
+// src/tools/completion.ts
+function createCompletionTool(deps) {
+  return {
+    name: "lsp_completion",
+    description: "Get semantic code completions from a configured language server.",
+    usageHint: 'Use for context-aware completion at a cursor location. Lines and columns are 1-based; pass trigger_character for member access like ".".',
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        line: { type: "integer" },
+        character: { type: "integer" },
+        content: { type: "string", maxLength: 5e5 },
+        limit: { type: "integer", minimum: 1, maximum: 100 },
+        trigger_character: { type: "string" },
+        format: { type: "string", enum: ["text", "json"] }
+      },
+      required: ["path", "line", "character"]
+    },
+    permission: "auto",
+    mutating: false,
+    timeoutMs: LSP_CONSTANTS.TOOL_TIMEOUT_MS,
+    maxOutputBytes: 32768,
+    async execute(input, ctx, opts) {
+      try {
+        const file = resolveInputPath(input.path, ctx);
+        const server = await requireServer(deps.registry, file, opts.signal);
+        if (server.capabilities && !supportsCompletion(server.capabilities)) {
+          throw new LSPError(
+            "LSP_CAPABILITY_MISSING" /* CapabilityMissing */,
+            `Server "${server.name}" does not support completion`
+          );
+        }
+        const content = typeof input.content === "string" ? input.content : await readDocumentContent(file, deps.tracker);
+        await deps.tracker.open(file, content);
+        const position = humanToLSP(content, { line: input.line, character: input.character });
+        const result = await server.completion(
+          {
+            textDocument: { uri: pathToUri(file) },
+            position,
+            context: input.trigger_character ? { triggerKind: 2, triggerCharacter: input.trigger_character } : { triggerKind: 1 }
+          },
+          LSP_CONSTANTS.TOOL_TIMEOUT_MS,
+          opts.signal
+        );
+        const items = collectCompletionItems(result, Math.min(input.limit ?? 25, 100));
+        if (input.format === "json") {
+          return JSON.stringify({
+            items: items.map((item) => ({
+              label: item.label,
+              insertText: item.insertText ?? item.label,
+              kind: item.kind ? completionKindName(item.kind) : void 0,
+              detail: compact(item.detail),
+              documentation: compact(documentationText(item.documentation))
+            }))
+          });
+        }
+        return formatCompletionItems(items, result);
+      } catch (err) {
+        return stringifyToolError(err);
+      }
+    }
+  };
+}
+function collectCompletionItems(result, limit) {
+  const items = Array.isArray(result) ? result : result?.items ?? [];
+  return items.slice(0, limit);
+}
+function formatCompletionItems(visibleItems, result) {
+  const items = Array.isArray(result) ? result : result?.items ?? [];
+  if (items.length === 0) return "No completions found.";
+  const lines = visibleItems.map((item, index) => {
+    const label = item.label || item.insertText || "(unnamed)";
+    const kind = item.kind ? completionKindName(item.kind) : "Completion";
+    const detail = compact(item.detail);
+    const docs = compact(documentationText(item.documentation));
+    const suffix = [detail, docs].filter(Boolean).join(" \u2014 ");
+    return `${index + 1}. ${label} [${kind}]${suffix ? ` \u2014 ${suffix}` : ""}`;
+  });
+  if (items.length > visibleItems.length) {
+    lines.push(`... truncated ${items.length - visibleItems.length} more`);
+  }
+  return lines.join("\n");
+}
+function documentationText(value) {
+  if (!value) return void 0;
+  if (typeof value === "string") return value;
+  return value.value;
+}
+function compact(value) {
+  const cleaned = value?.replace(/\s*\r?\n\s*/g, " ").trim();
+  if (!cleaned) return void 0;
+  return cleaned.length <= 160 ? cleaned : `${cleaned.slice(0, 157)}...`;
+}
+function completionKindName(kind) {
+  const names = {
+    1: "Text",
+    2: "Method",
+    3: "Function",
+    4: "Constructor",
+    5: "Field",
+    6: "Variable",
+    7: "Class",
+    8: "Interface",
+    9: "Module",
+    10: "Property",
+    11: "Unit",
+    12: "Value",
+    13: "Enum",
+    14: "Keyword",
+    15: "Snippet",
+    16: "Color",
+    17: "File",
+    18: "Reference",
+    19: "Folder",
+    20: "EnumMember",
+    21: "Constant",
+    22: "Struct",
+    23: "Event",
+    24: "Operator",
+    25: "TypeParameter"
+  };
+  return names[kind] ?? `Kind ${kind}`;
+}
+
+// src/formatters/location.ts
+function formatLocations(locations, cwd, limit = 100) {
+  if (!locations || locations.length === 0) return "No locations found.";
+  const lines = locations.slice(0, limit).map((loc) => {
+    const uri = "uri" in loc ? loc.uri : loc.targetUri;
+    const range = "range" in loc ? loc.range : loc.targetSelectionRange;
+    return `${displayPath(uriToPath(uri), cwd)}:${range.start.line + 1}:${range.start.character + 1}`;
+  });
+  if (locations.length > limit) lines.push(`... truncated ${locations.length - limit} more`);
+  return lines.join("\n");
+}
+
 // src/tools/definition.ts
 function createDefinitionTool(deps) {
   return {
@@ -2372,6 +2521,7 @@ function makeLSPTools(deps) {
   return [
     createDiagnosticsTool(deps),
     createDefinitionTool(deps),
+    createCompletionTool(deps),
     createCodebaseLspSearchTool(deps),
     createRenameTool(deps)
   ];
@@ -2414,7 +2564,7 @@ var plugin = {
         void tracker.forceCloseAll().finally(() => registry.shutdown());
       }),
       api.events.on("tool.executed", (event) => {
-        void tracker.handleToolExecuted(event);
+        void tracker.handleToolExecuted(event).catch((err) => api.log.debug("LSP tracker failed to handle tool event", err));
       })
     ];
     teardownState = {