@mrclrchtr/supi-lsp 0.1.0

package/bash-guard.ts

@@ -0,0 +1,58 @@
+const SEMANTIC_PROMPT_PATTERNS = [
+  /\bdefinition\b/i,
+  /\bfind(?: all)? references?\b/i,
+  /\breferences?\b/i,
+  /\busages?\b/i,
+  /\bsymbols?\b/i,
+  /\bhover\b/i,
+  /\brename\b/i,
+  /\bcode actions?\b/i,
+  /\bdiagnostics?\b/i,
+  /\btype errors?\b/i,
+  /\bwarning\b/i,
+];
+
+const TEXT_SEARCH_COMMAND_PATTERNS = [
+  /\brg\b/,
+  /\bripgrep\b/,
+  /\bgrep\b/,
+  /\bgit\s+grep\b/,
+  /\back\b/,
+  /\bag\b/,
+];
+
+/**
+ * Returns a redirect message when the agent is about to run a text-search
+ * command (rg/grep/etc.) for a clearly semantic question (definitions,
+ * references, symbols, diagnostics…) over files that already have active LSP
+ * coverage. In that combination the lsp tool is strictly more accurate, so we
+ * block the bash call and steer the agent to lsp. Returns null otherwise — we
+ * don't interfere with plain-text searches or with searches that fall outside
+ * the active LSP coverage.
+ */
+export function shouldBlockSemanticBashSearch(
+  command: string,
+  prompt: string,
+  relevantPaths: string[],
+  hasRelevantCoverage: boolean,
+): string | null {
+  if (!hasRelevantCoverage) return null;
+  if (!isSemanticPrompt(prompt) || !isTextSearchCommand(command)) return null;
+
+  const visiblePaths = relevantPaths.slice(0, 2).join(", ");
+  const targetText = visiblePaths ? ` in ${visiblePaths}` : " in files with active LSP coverage";
+
+  return [
+    "Use the lsp tool instead of bash text search for semantic queries.",
+    `Active LSP coverage is available${targetText}.`,
+    "Prefer lsp for definitions, references, symbols, hover, rename planning, code actions, and diagnostics.",
+  ].join(" ");
+}
+
+export function isSemanticPrompt(prompt: string): boolean {
+  return SEMANTIC_PROMPT_PATTERNS.some((pattern) => pattern.test(prompt));
+}
+
+export function isTextSearchCommand(command: string): boolean {
+  return TEXT_SEARCH_COMMAND_PATTERNS.some((pattern) => pattern.test(command));
+}

package/capabilities.ts

@@ -0,0 +1,54 @@
+// LSP client capabilities — declares what we support to servers.
+
+import type { ClientCapabilities } from "./types.ts";
+
+export const CLIENT_CAPABILITIES: ClientCapabilities = {
+  textDocument: {
+    synchronization: {
+      didSave: true,
+      dynamicRegistration: false,
+    },
+    hover: {
+      contentFormat: ["markdown", "plaintext"],
+      dynamicRegistration: false,
+    },
+    definition: {
+      dynamicRegistration: false,
+      linkSupport: true,
+    },
+    references: {
+      dynamicRegistration: false,
+    },
+    documentSymbol: {
+      dynamicRegistration: false,
+      hierarchicalDocumentSymbolSupport: true,
+    },
+    rename: {
+      dynamicRegistration: false,
+      prepareSupport: true,
+    },
+    codeAction: {
+      dynamicRegistration: false,
+      codeActionLiteralSupport: {
+        codeActionKind: {
+          valueSet: [
+            "quickfix",
+            "refactor",
+            "refactor.extract",
+            "refactor.inline",
+            "refactor.rewrite",
+            "source",
+            "source.organizeImports",
+            "source.fixAll",
+          ],
+        },
+      },
+    },
+    publishDiagnostics: {
+      relatedInformation: true,
+    },
+  },
+  workspace: {
+    workspaceFolders: false,
+  },
+};

package/client.ts

@@ -0,0 +1,397 @@
+// LSP Client — wraps a server process + JsonRpcClient.
+// Handles initialize handshake, document sync, shutdown, and crash recovery.
+
+import { type ChildProcess, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { CLIENT_CAPABILITIES } from "./capabilities.ts";
+import { JsonRpcClient } from "./transport.ts";
+import type {
+  CodeAction,
+  CodeActionContext,
+  Diagnostic,
+  DocumentSymbol,
+  Hover,
+  InitializeResult,
+  Location,
+  LocationLink,
+  Position,
+  PublishDiagnosticsParams,
+  Range,
+  ServerCapabilities,
+  ServerConfig,
+  SymbolInformation,
+  TextDocumentIdentifier,
+  TextDocumentItem,
+  VersionedTextDocumentIdentifier,
+  WorkspaceEdit,
+} from "./types.ts";
+import { detectLanguageId, fileToUri, uriToFile } from "./utils.ts";
+
+const SHUTDOWN_TIMEOUT_MS = 5_000;
+const DIAGNOSTIC_WAIT_MS = 3_000;
+
+// ── Types ─────────────────────────────────────────────────────────────
+
+export type ClientStatus = "initializing" | "running" | "error" | "shutdown";
+
+export interface DiagnosticEntry {
+  uri: string;
+  diagnostics: Diagnostic[];
+}
+
+// ── LspClient ─────────────────────────────────────────────────────────
+
+export class LspClient {
+  readonly name: string;
+  readonly root: string;
+
+  private process: ChildProcess | null = null;
+  private rpc: JsonRpcClient | null = null;
+  private _status: ClientStatus = "initializing";
+  private capabilities: ServerCapabilities | null = null;
+
+  /** Open documents: uri → { version, languageId } */
+  private openDocs = new Map<string, { version: number; languageId: string }>();
+  /** Per-file diagnostics from the server */
+  private diagnosticStore = new Map<string, Diagnostic[]>();
+  /** Listeners waiting for diagnostics on a specific uri */
+  private diagnosticWaiters = new Map<string, Array<() => void>>();
+
+  constructor(
+    name: string,
+    private readonly config: ServerConfig,
+    root: string,
+  ) {
+    this.name = name;
+    this.root = root;
+  }
+
+  get status(): ClientStatus {
+    return this._status;
+  }
+
+  get openFiles(): string[] {
+    return Array.from(this.openDocs.keys()).map(uriToFile);
+  }
+
+  // ── Lifecycle ───────────────────────────────────────────────────────
+
+  /** Spawn the server process and perform the initialize handshake. */
+  async start(): Promise<void> {
+    const cmd = this.config.command;
+    const args = this.config.args ?? [];
+
+    try {
+      this.process = spawn(cmd, args, {
+        cwd: this.root,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env },
+      });
+    } catch (err) {
+      this._status = "error";
+      throw new Error(`Failed to spawn ${cmd}: ${err}`, { cause: err });
+    }
+
+    if (!this.process.stdin || !this.process.stdout) {
+      this._status = "error";
+      this.process.kill();
+      throw new Error(`${cmd}: missing stdin/stdout`);
+    }
+
+    this.rpc = new JsonRpcClient(this.process.stdout, this.process.stdin);
+
+    // Handle notifications
+    this.rpc.onNotification((method, params) => {
+      if (method === "textDocument/publishDiagnostics") {
+        this.handlePublishDiagnostics(params as PublishDiagnosticsParams);
+      }
+    });
+
+    // Handle crashes
+    this.process.on("exit", (_code) => {
+      if (this._status !== "shutdown") {
+        this._status = "error";
+      }
+      this.rpc?.dispose();
+    });
+
+    this.process.on("error", (_err) => {
+      if (this._status !== "shutdown") {
+        this._status = "error";
+      }
+    });
+
+    // Suppress stderr to avoid noise in the agent
+    this.process.stderr?.on("data", () => {});
+
+    // Initialize handshake
+    try {
+      const result = (await this.rpc.sendRequest("initialize", {
+        processId: process.pid,
+        rootUri: fileToUri(this.root),
+        capabilities: CLIENT_CAPABILITIES,
+        initializationOptions: this.config.initializationOptions,
+      })) as InitializeResult;
+
+      this.capabilities = result.capabilities;
+      this.rpc.sendNotification("initialized", {});
+      this._status = "running";
+    } catch (err) {
+      this._status = "error";
+      this.process.kill();
+      throw new Error(`${this.name}: initialize failed: ${err}`, { cause: err });
+    }
+  }
+
+  /** Graceful shutdown: send shutdown → exit, kill after timeout. */
+  async shutdown(): Promise<void> {
+    if (this._status === "shutdown") return;
+    this._status = "shutdown";
+
+    if (!this.rpc || !this.process) return;
+
+    try {
+      // Send shutdown request with a timeout
+      await Promise.race([
+        this.rpc.sendRequest("shutdown"),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error("shutdown timeout")), SHUTDOWN_TIMEOUT_MS),
+        ),
+      ]);
+      this.rpc.sendNotification("exit");
+    } catch {
+      // Timeout or error — force kill
+    }
+
+    this.rpc.dispose();
+
+    // Wait briefly for clean exit, then force kill
+    if (this.process.exitCode === null) {
+      await new Promise<void>((resolve) => {
+        const timer = setTimeout(() => {
+          this.process?.kill("SIGTERM");
+          resolve();
+        }, 1_000);
+        this.process?.on("exit", () => {
+          clearTimeout(timer);
+          resolve();
+        });
+      });
+    }
+
+    this.openDocs.clear();
+    this.diagnosticStore.clear();
+  }
+
+  // ── Document Synchronization ────────────────────────────────────────
+
+  /** Open a document (or re-sync if already open). */
+  didOpen(filePath: string, content: string): void {
+    if (!this.rpc || this._status !== "running") return;
+
+    const uri = fileToUri(filePath);
+    const languageId = detectLanguageId(filePath);
+
+    if (this.openDocs.has(uri)) {
+      // Already open — send didChange instead
+      this.didChange(filePath, content);
+      return;
+    }
+
+    this.openDocs.set(uri, { version: 1, languageId });
+    this.rpc.sendNotification("textDocument/didOpen", {
+      textDocument: {
+        uri,
+        languageId,
+        version: 1,
+        text: content,
+      } satisfies TextDocumentItem,
+    });
+  }
+
+  /** Notify the server of a content change (full document sync). */
+  didChange(filePath: string, content: string): void {
+    if (!this.rpc || this._status !== "running") return;
+
+    const uri = fileToUri(filePath);
+    const doc = this.openDocs.get(uri);
+
+    if (!doc) {
+      // Not yet open — do a didOpen
+      this.didOpen(filePath, content);
+      return;
+    }
+
+    doc.version++;
+    this.rpc.sendNotification("textDocument/didChange", {
+      textDocument: { uri, version: doc.version } satisfies VersionedTextDocumentIdentifier,
+      contentChanges: [{ text: content }],
+    });
+  }
+
+  /** Close a document and clear any cached state for it. */
+  didClose(filePath: string): void {
+    const uri = fileToUri(filePath);
+    const wasOpen = this.openDocs.has(uri);
+
+    this.clearFileState(uri);
+
+    if (!wasOpen || !this.rpc || this._status !== "running") return;
+
+    this.rpc.sendNotification("textDocument/didClose", {
+      textDocument: { uri } satisfies TextDocumentIdentifier,
+    });
+  }
+
+  /** Prune missing files from open documents and cached diagnostics. */
+  pruneMissingFiles(): string[] {
+    const uris = new Set([...this.openDocs.keys(), ...this.diagnosticStore.keys()]);
+    const removedFiles: string[] = [];
+
+    for (const uri of uris) {
+      const filePath = uriToFile(uri);
+      if (existsSync(filePath)) continue;
+
+      const wasOpen = this.openDocs.has(uri);
+      this.clearFileState(uri);
+      removedFiles.push(filePath);
+
+      if (wasOpen && this.rpc && this._status === "running") {
+        this.rpc.sendNotification("textDocument/didClose", {
+          textDocument: { uri } satisfies TextDocumentIdentifier,
+        });
+      }
+    }
+
+    return removedFiles;
+  }
+
+  // ── Diagnostics ─────────────────────────────────────────────────────
+
+  /** Get stored diagnostics for a file. */
+  getDiagnostics(filePath: string): Diagnostic[] {
+    return this.diagnosticStore.get(fileToUri(filePath)) ?? [];
+  }
+
+  /** Get all stored diagnostics across all files. */
+  getAllDiagnostics(): DiagnosticEntry[] {
+    const result: DiagnosticEntry[] = [];
+    for (const [uri, diagnostics] of this.diagnosticStore) {
+      if (diagnostics.length > 0) {
+        result.push({ uri, diagnostics });
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Sync a file and wait for diagnostics (up to timeout).
+   * Returns diagnostics for the file.
+   */
+  async syncAndWaitForDiagnostics(filePath: string, content: string): Promise<Diagnostic[]> {
+    const uri = fileToUri(filePath);
+
+    // Sync the content
+    this.didChange(filePath, content);
+
+    // Wait for publishDiagnostics or timeout
+    await new Promise<void>((resolve) => {
+      const timer = setTimeout(resolve, DIAGNOSTIC_WAIT_MS);
+      const waiters = this.diagnosticWaiters.get(uri) ?? [];
+      waiters.push(() => {
+        clearTimeout(timer);
+        resolve();
+      });
+      this.diagnosticWaiters.set(uri, waiters);
+    });
+
+    return this.getDiagnostics(filePath);
+  }
+
+  // ── LSP Requests ───────────────────────────────────────────────────
+
+  async hover(filePath: string, position: Position): Promise<Hover | null> {
+    return this.request("textDocument/hover", {
+      textDocument: { uri: fileToUri(filePath) },
+      position,
+    });
+  }
+
+  async definition(
+    filePath: string,
+    position: Position,
+  ): Promise<Location | Location[] | LocationLink[] | null> {
+    return this.request("textDocument/definition", {
+      textDocument: { uri: fileToUri(filePath) },
+      position,
+    });
+  }
+
+  async references(filePath: string, position: Position): Promise<Location[] | null> {
+    return this.request("textDocument/references", {
+      textDocument: { uri: fileToUri(filePath) },
+      position,
+      context: { includeDeclaration: true },
+    });
+  }
+
+  async documentSymbols(filePath: string): Promise<DocumentSymbol[] | SymbolInformation[] | null> {
+    return this.request("textDocument/documentSymbol", {
+      textDocument: { uri: fileToUri(filePath) },
+    });
+  }
+
+  async rename(
+    filePath: string,
+    position: Position,
+    newName: string,
+  ): Promise<WorkspaceEdit | null> {
+    return this.request("textDocument/rename", {
+      textDocument: { uri: fileToUri(filePath) },
+      position,
+      newName,
+    });
+  }
+
+  async codeActions(
+    filePath: string,
+    range: Range,
+    context: CodeActionContext,
+  ): Promise<CodeAction[] | null> {
+    return this.request("textDocument/codeAction", {
+      textDocument: { uri: fileToUri(filePath) },
+      range,
+      context,
+    });
+  }
+
+  // ── Private ─────────────────────────────────────────────────────────
+
+  private async request<T>(method: string, params: unknown): Promise<T | null> {
+    if (!this.rpc || this._status !== "running") return null;
+    try {
+      return (await this.rpc.sendRequest(method, params)) as T;
+    } catch {
+      return null;
+    }
+  }
+
+  private handlePublishDiagnostics(params: PublishDiagnosticsParams): void {
+    this.diagnosticStore.set(params.uri, params.diagnostics);
+    this.releaseDiagnosticWaiters(params.uri);
+  }
+
+  private clearFileState(uri: string): void {
+    this.openDocs.delete(uri);
+    this.diagnosticStore.delete(uri);
+    this.releaseDiagnosticWaiters(uri);
+  }
+
+  private releaseDiagnosticWaiters(uri: string): void {
+    const waiters = this.diagnosticWaiters.get(uri);
+    if (!waiters) return;
+
+    this.diagnosticWaiters.delete(uri);
+    for (const waiter of waiters) waiter();
+  }
+}

package/config.ts

@@ -0,0 +1,99 @@
+// LSP server configuration — load defaults, merge with project overrides.
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { LspConfig, ServerConfig } from "./types.ts";
+
+// Load defaults at module level — resolve relative to this file.
+// pi loads extensions via jiti, which always provides __dirname.
+const DEFAULTS: LspConfig = JSON.parse(
+  fs.readFileSync(path.join(__dirname, "defaults.json"), "utf-8"),
+) as LspConfig;
+
+// ── Public API ────────────────────────────────────────────────────────
+
+/**
+ * Load LSP config: built-in defaults merged with optional `.pi-lsp.json`
+ * from the project root. Project config takes precedence.
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: straightforward merge logic
+export function loadConfig(cwd: string): LspConfig {
+  const defaults = DEFAULTS;
+  const projectOverrides = loadProjectConfig(cwd);
+
+  // Start from defaults, merge project overrides if present
+  const merged: Record<string, ServerConfig> = { ...defaults.servers };
+
+  if (projectOverrides) {
+    for (const [name, override] of Object.entries(projectOverrides.servers)) {
+      if (override.enabled === false) {
+        delete merged[name];
+        continue;
+      }
+      if (merged[name]) {
+        merged[name] = { ...merged[name], ...override };
+      } else {
+        // New server from project config — must have all required fields
+        if (override.command && override.fileTypes && override.rootMarkers) {
+          merged[name] = override as ServerConfig;
+        }
+      }
+    }
+  }
+
+  // Apply PI_LSP_SERVERS filter (always, even without project config)
+  const allowList = getServerAllowList();
+  if (allowList) {
+    for (const name of Object.keys(merged)) {
+      if (!allowList.has(name)) {
+        delete merged[name];
+      }
+    }
+  }
+
+  return { servers: merged };
+}
+
+/**
+ * Find which server config handles a given file extension.
+ * Returns [serverName, config] or null.
+ */
+export function getServerForFile(
+  config: LspConfig,
+  filePath: string,
+): [string, ServerConfig] | null {
+  const ext = path.extname(filePath).slice(1).toLowerCase();
+  if (!ext) return null;
+
+  for (const [name, server] of Object.entries(config.servers)) {
+    if (server.fileTypes.includes(ext)) {
+      return [name, server];
+    }
+  }
+  return null;
+}
+
+// ── Private ───────────────────────────────────────────────────────────
+
+function loadProjectConfig(cwd: string): LspConfig | null {
+  const jsonPath = path.join(cwd, ".pi-lsp.json");
+
+  if (fs.existsSync(jsonPath)) {
+    try {
+      const content = fs.readFileSync(jsonPath, "utf-8");
+      return JSON.parse(content) as LspConfig;
+    } catch {}
+  }
+
+  return null;
+}
+
+function getServerAllowList(): Set<string> | null {
+  const env = process.env.PI_LSP_SERVERS;
+  if (!env) return null;
+  const names = env
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+  return names.length > 0 ? new Set(names) : null;
+}

package/defaults.json

@@ -0,0 +1,40 @@
+{
+  "servers": {
+    "typescript-language-server": {
+      "command": "typescript-language-server",
+      "args": ["--stdio"],
+      "fileTypes": ["ts", "tsx", "js", "jsx", "mts", "cts", "mjs", "cjs"],
+      "rootMarkers": ["tsconfig.json", "jsconfig.json", "package.json"]
+    },
+    "pyright": {
+      "command": "pyright-langserver",
+      "args": ["--stdio"],
+      "fileTypes": ["py", "pyi"],
+      "rootMarkers": [
+        "pyproject.toml",
+        "setup.py",
+        "setup.cfg",
+        "requirements.txt",
+        "pyrightconfig.json"
+      ]
+    },
+    "rust-analyzer": {
+      "command": "rust-analyzer",
+      "args": [],
+      "fileTypes": ["rs"],
+      "rootMarkers": ["Cargo.toml"]
+    },
+    "gopls": {
+      "command": "gopls",
+      "args": ["serve"],
+      "fileTypes": ["go", "mod"],
+      "rootMarkers": ["go.mod", "go.sum"]
+    },
+    "clangd": {
+      "command": "clangd",
+      "args": ["--background-index"],
+      "fileTypes": ["c", "h", "cpp", "hpp", "cc", "cxx", "hxx", "c++", "h++"],
+      "rootMarkers": ["compile_commands.json", "CMakeLists.txt", ".clangd", "Makefile"]
+    }
+  }
+}