@ilya-lesikov/pi-pi 0.1.0

package/3p/pi-lsp/extensions/lsp/index.ts

@@ -0,0 +1,231 @@
+/**
+ * Pi LSP Extension
+ *
+ * Language-agnostic code intelligence via LSP.
+ * Auto-detects servers by file extension, configurable via:
+ *   - ~/.pi/agent/extensions/lsp/config.json  (global defaults)
+ *   - .pi/lsp.json                            (project overrides)
+ *
+ * Any LSP server can be added via config.
+ */
+
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+
+import { LspClient } from './client';
+import { loadConfig, scaffoldGlobalConfig, serversForExtension, type LoadedConfig } from './config';
+import { registerLspTool, type ServerManagerService } from './tools';
+import type { ResolvedServerConfig } from './types';
+
+export default function lspExtension(pi: ExtensionAPI) {
+  const subagentSessionKey = Symbol.for('pi-pi:subagent-session');
+  const lspApiKey = Symbol.for('pi-lsp:api');
+  let rootPath = '';
+  let config: LoadedConfig | null = null;
+  const clients = new Map<string, LspClient>();
+
+  // ── Client management ───────────────────────────────────────────────
+
+  function getOrCreateClient(serverConfig: ResolvedServerConfig): LspClient {
+    const existing = clients.get(serverConfig.name);
+    if (existing) return existing;
+
+    const client = new LspClient(serverConfig, rootPath);
+    clients.set(serverConfig.name, client);
+    return client;
+  }
+
+  async function shutdownAll(): Promise<void> {
+    const shutdowns = [...clients.values()].map((c) => c.shutdown().catch(() => {}));
+    await Promise.all(shutdowns);
+    clients.clear();
+  }
+
+  function refreshStatus(
+    ui: { setStatus: (key: string, value: string) => void },
+    cfg: LoadedConfig | null,
+  ) {
+    if (!cfg) {
+      ui.setStatus('lsp', 'LSP: no servers detected');
+      return;
+    }
+
+    if (cfg.globalDisabled) {
+      ui.setStatus('lsp', 'LSP: disabled');
+      return;
+    }
+
+    if (cfg.servers.length === 0) {
+      ui.setStatus('lsp', 'LSP: no servers detected');
+      return;
+    }
+
+    const running = cfg.servers.filter((server) => clients.get(server.name)?.isInitialized);
+    if (running.length > 0) {
+      ui.setStatus('lsp', `LSP: ${running.map((s) => s.name).join(', ')} (running)`);
+      return;
+    }
+
+    ui.setStatus('lsp', `LSP: ${cfg.servers.map((s) => s.name).join(', ')}`);
+  }
+
+  // ── Server manager (passed to tool) ───────────────────────────────────
+
+  const serverManager: ServerManagerService = {
+    clientsForFile(filePath: string): LspClient[] {
+      if (!config) return [];
+      const matching = serversForExtension(config.servers, filePath);
+      return matching.map((s) => getOrCreateClient(s));
+    },
+
+    clientForFileWithCapability(filePath: string, capability: string): LspClient | null {
+      if (!config) return null;
+      const matching = serversForExtension(config.servers, filePath);
+      for (const serverConfig of matching) {
+        const client = getOrCreateClient(serverConfig);
+        // If not yet initialized, return it (capability check happens after init)
+        if (!client.isInitialized) return client;
+        if (client.hasCapability(capability)) return client;
+      }
+      return null;
+    },
+
+    anyClient(): LspClient | null {
+      // Return first initialized client, or first available
+      for (const client of clients.values()) {
+        if (client.isInitialized) return client;
+      }
+      // Try to create one from config
+      if (config && config.servers.length > 0) {
+        return getOrCreateClient(config.servers[0]);
+      }
+      return null;
+    },
+
+    getRootPath: () => rootPath,
+  };
+
+  // ── Register tool ─────────────────────────────────────────────────────
+
+  registerLspTool(pi, serverManager);
+
+  // ── Session lifecycle ─────────────────────────────────────────────────
+
+  pi.on('session_start', async (_event, ctx) => {
+    if ((globalThis as any)[subagentSessionKey]) {
+      return;
+    }
+    rootPath = ctx.cwd;
+
+    const scaffolded = await scaffoldGlobalConfig(rootPath);
+    if (scaffolded) {
+      ctx.ui.notify(
+        'LSP: created starter config at ~/.pi/agent/extensions/lsp/config.json — edit it to add your servers.',
+        'info',
+      );
+    }
+
+    config = await loadConfig(rootPath);
+    refreshStatus(ctx.ui, config);
+  });
+
+  pi.on('session_shutdown', async () => {
+    if ((globalThis as any)[subagentSessionKey]) {
+      return;
+    }
+    await shutdownAll();
+    config = null;
+  });
+
+  pi.on('tool_execution_end', async (event, ctx) => {
+    if ((globalThis as any)[subagentSessionKey]) {
+      return;
+    }
+    if (event.toolName !== 'lsp') return;
+    refreshStatus(ctx.ui, config);
+  });
+
+  // ── Commands ──────────────────────────────────────────────────────────
+
+  pi.registerCommand('lsp', {
+    description: 'Show LSP server status',
+    handler: async (_args, ctx) => {
+      rootPath = ctx.cwd;
+      const cfg = await loadConfig(ctx.cwd);
+      config = cfg;
+      refreshStatus(ctx.ui, cfg);
+      const lines: string[] = ['LSP Status:'];
+
+      if (cfg.globalDisabled) {
+        lines.push('  All servers disabled via config.');
+      } else if (cfg.servers.length === 0) {
+        lines.push('  No servers configured.');
+        lines.push('  Add servers to ~/.pi/agent/extensions/lsp/config.json or .pi/lsp.json');
+      } else {
+        for (const server of cfg.servers) {
+          const client = clients.get(server.name);
+          const status = client?.isInitialized ? 'running' : 'available (lazy start)';
+          const exts = server.extensions.join(', ');
+          lines.push(`  ${server.name}: ${status} — handles ${exts}`);
+        }
+      }
+
+      if (cfg.errors.length > 0) {
+        lines.push('', 'Config errors:');
+        for (const err of cfg.errors) lines.push(`  - ${err}`);
+      }
+
+      ctx.ui.notify(lines.join('\n'), 'info');
+    },
+  });
+
+  pi.registerCommand('lsp-restart', {
+    description: 'Restart all LSP servers',
+    handler: async (_args, ctx) => {
+      await shutdownAll();
+      config = null;
+      rootPath = ctx.cwd;
+      config = await loadConfig(ctx.cwd);
+      refreshStatus(ctx.ui, config);
+      ctx.ui.notify('LSP servers stopped. Will reinitialize on next tool use.', 'info');
+    },
+  });
+
+  (globalThis as any)[lspApiKey] = {
+    status: async (ctx: any) => {
+      rootPath = ctx.cwd;
+      const cfg = await loadConfig(ctx.cwd);
+      config = cfg;
+      refreshStatus(ctx.ui, cfg);
+      const lines: string[] = ['LSP Status:'];
+
+      if (cfg.globalDisabled) {
+        lines.push('  All servers disabled via config.');
+      } else if (cfg.servers.length === 0) {
+        lines.push('  No servers configured.');
+        lines.push('  Add servers to ~/.pi/agent/extensions/lsp/config.json or .pi/lsp.json');
+      } else {
+        for (const server of cfg.servers) {
+          const client = clients.get(server.name);
+          const status = client?.isInitialized ? 'running' : 'available (lazy start)';
+          const exts = server.extensions.join(', ');
+          lines.push(`  ${server.name}: ${status} — handles ${exts}`);
+        }
+      }
+
+      if (cfg.errors.length > 0) {
+        lines.push('', 'Config errors:');
+        for (const err of cfg.errors) lines.push(`  - ${err}`);
+      }
+
+      ctx.ui.notify(lines.join('\n'), 'info');
+    },
+    restart: async (ctx: any) => {
+      await shutdownAll();
+      config = null;
+      rootPath = ctx.cwd;
+      config = await loadConfig(ctx.cwd);
+      refreshStatus(ctx.ui, config);
+      ctx.ui.notify('LSP servers stopped. Will reinitialize on next tool use.', 'info');
+    },
+  };
+}

package/3p/pi-lsp/extensions/lsp/protocol.ts

@@ -0,0 +1,209 @@
+/**
+ * JSON-RPC over stdio transport for LSP.
+ *
+ * Handles Content-Length framing, request/response matching, and notification dispatch.
+ */
+
+import { spawn, type ChildProcess } from 'node:child_process';
+
+import type { JsonRpcMessage } from './types';
+
+type PendingRequest = {
+  resolve: (value: unknown) => void;
+  reject: (error: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+};
+
+type NotificationHandler = (method: string, params: unknown) => void;
+type ServerRequestHandler = (id: number | string, method: string, params: unknown) => void;
+
+export class LspConnection {
+  private process: ChildProcess | null = null;
+  private buffer = Buffer.alloc(0);
+  private nextId = 1;
+  private pending = new Map<number, PendingRequest>();
+  private onNotification: NotificationHandler = () => {};
+  private onServerRequest: ServerRequestHandler = () => {};
+  private onExit: ((code: number | null) => void) | null = null;
+  private onStderr: ((text: string) => void) | null = null;
+  private disposed = false;
+
+  constructor(
+    private command: string,
+    private args: string[],
+    private options?: { cwd?: string; env?: Record<string, string> },
+  ) {}
+
+  // ── Lifecycle ─────────────────────────────────────────────────────────
+
+  spawn(): void {
+    if (this.process) return;
+
+    this.process = spawn(this.command, this.args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      cwd: this.options?.cwd,
+      env: { ...process.env, ...this.options?.env },
+      shell: process.platform === 'win32',
+    });
+
+    this.process.stdout!.on('data', (chunk: Buffer) => {
+      this.buffer = Buffer.concat([this.buffer, chunk]);
+      this.drainBuffer();
+    });
+
+    this.process.stderr!.on('data', (chunk: Buffer) => {
+      this.onStderr?.(chunk.toString('utf8'));
+    });
+
+    this.process.on('exit', (code) => {
+      this.rejectAllPending('Server process exited');
+      this.onExit?.(code);
+    });
+
+    this.process.on('error', (err) => {
+      this.rejectAllPending(`Server process error: ${err.message}`);
+    });
+  }
+
+  dispose(): void {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.rejectAllPending('Connection disposed');
+
+    if (this.process) {
+      this.process.stdin?.end();
+      this.process.kill();
+      this.process = null;
+    }
+  }
+
+  get alive(): boolean {
+    return this.process !== null && !this.disposed && this.process.exitCode === null;
+  }
+
+  // ── Handlers ──────────────────────────────────────────────────────────
+
+  setNotificationHandler(handler: NotificationHandler): void {
+    this.onNotification = handler;
+  }
+
+  setServerRequestHandler(handler: ServerRequestHandler): void {
+    this.onServerRequest = handler;
+  }
+
+  setExitHandler(handler: (code: number | null) => void): void {
+    this.onExit = handler;
+  }
+
+  setStderrHandler(handler: (text: string) => void): void {
+    this.onStderr = handler;
+  }
+
+  // ── Sending ───────────────────────────────────────────────────────────
+
+  sendRequest(method: string, params: unknown, timeoutMs = 30_000): Promise<unknown> {
+    if (!this.alive) return Promise.reject(new Error('Connection not alive'));
+
+    const id = this.nextId++;
+    return new Promise<unknown>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`LSP request '${method}' timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      this.pending.set(id, { resolve, reject, timer });
+      this.writeMessage({ jsonrpc: '2.0', id, method, params });
+    });
+  }
+
+  sendNotification(method: string, params: unknown): void {
+    if (!this.alive) return;
+    this.writeMessage({ jsonrpc: '2.0', method, params });
+  }
+
+  sendResponse(id: number | string, result: unknown): void {
+    if (!this.alive) return;
+    this.writeMessage({ jsonrpc: '2.0', id, result } as unknown as JsonRpcMessage);
+  }
+
+  // ── Framing ───────────────────────────────────────────────────────────
+
+  private writeMessage(message: JsonRpcMessage): void {
+    const body = JSON.stringify(message);
+    const length = Buffer.byteLength(body, 'utf8');
+    const header = `Content-Length: ${length}\r\n\r\n`;
+    this.process?.stdin?.write(header + body);
+  }
+
+  private drainBuffer(): void {
+    const HEADER_DELIMITER = '\r\n\r\n';
+
+    while (true) {
+      const headerEnd = this.buffer.indexOf(HEADER_DELIMITER);
+      if (headerEnd === -1) break;
+
+      const headerText = this.buffer.subarray(0, headerEnd).toString('ascii');
+      const match = headerText.match(/Content-Length:\s*(\d+)/i);
+      if (!match) {
+        // Malformed header — skip past it
+        this.buffer = this.buffer.subarray(headerEnd + HEADER_DELIMITER.length);
+        continue;
+      }
+
+      const contentLength = parseInt(match[1], 10);
+      const bodyStart = headerEnd + HEADER_DELIMITER.length;
+      const bodyEnd = bodyStart + contentLength;
+
+      if (this.buffer.length < bodyEnd) break; // Incomplete body
+
+      const body = this.buffer.subarray(bodyStart, bodyEnd).toString('utf8');
+      this.buffer = this.buffer.subarray(bodyEnd);
+
+      try {
+        this.handleMessage(JSON.parse(body) as JsonRpcMessage);
+      } catch {
+        // Malformed JSON — skip
+      }
+    }
+  }
+
+  private handleMessage(message: JsonRpcMessage): void {
+    const msg = message as unknown as Record<string, unknown>;
+
+    // Response to one of our requests
+    if (msg.id !== undefined && (msg.result !== undefined || msg.error !== undefined)) {
+      const pending = this.pending.get(msg.id as number);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pending.delete(msg.id as number);
+
+        if (msg.error) {
+          const err = msg.error as { code: number; message: string };
+          pending.reject(new Error(`LSP error ${err.code}: ${err.message}`));
+        } else {
+          pending.resolve(msg.result);
+        }
+      }
+      return;
+    }
+
+    // Notification or server-initiated request
+    if (typeof msg.method === 'string') {
+      if (msg.id !== undefined) {
+        // Server request — needs a response
+        this.onServerRequest(msg.id as number, msg.method, msg.params);
+      } else {
+        // Notification
+        this.onNotification(msg.method, msg.params);
+      }
+    }
+  }
+
+  private rejectAllPending(reason: string): void {
+    for (const [id, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(reason));
+      this.pending.delete(id);
+    }
+  }
+}

package/3p/pi-lsp/extensions/lsp/retry.ts

@@ -0,0 +1,39 @@
+/**
+ * Retry utility for LSP operations that may return empty results during server indexing.
+ *
+ * Only retries when the server was recently initialized (within a configurable window),
+ * avoiding unnecessary delays for servers that are already warmed up.
+ */
+
+export interface RetryOptions {
+  /** Maximum number of retry attempts. Default: 2 */
+  maxRetries?: number;
+  /** Delay between retries in milliseconds. Default: 2000 */
+  delayMs?: number;
+}
+
+/**
+ * Retry an async operation if the result is considered "empty".
+ *
+ * Useful for LSP operations that return empty results while the server is still indexing
+ * (e.g. workspaceSymbol, hover, definition, references).
+ */
+export async function withRetry<T>(
+  operation: () => Promise<T>,
+  isEmpty: (result: T) => boolean,
+  options?: RetryOptions,
+): Promise<T> {
+  const maxRetries = options?.maxRetries ?? 2;
+  const delayMs = options?.delayMs ?? 2000;
+
+  let result = await operation();
+  let attempt = 0;
+
+  while (isEmpty(result) && attempt < maxRetries) {
+    attempt++;
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+    result = await operation();
+  }
+
+  return result;
+}