@dreki-gg/pi-lsp 0.2.1 → 0.4.0

package/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;
+}

package/extensions/lsp/tools/programs.ts

@@ -0,0 +1,293 @@
+/**
+ * Effect programs backing the unified `lsp` tool.
+ *
+ * Each operation is an Effect that depends on the `ServerManager` service to
+ * locate the right client, then wraps the client's async LSP calls in
+ * `Effect.tryPromise` so transport failures surface as typed
+ * `LspOperationError`s. Routing/validation failures are typed too
+ * (`LspValidationError`, `NoCapableServerError`, `NoServerAvailableError`).
+ */
+
+import { Context, Effect } from 'effect';
+
+import type { LspClient } from '../client';
+import {
+  LspOperationError,
+  LspValidationError,
+  NoCapableServerError,
+  NoServerAvailableError,
+  type LspExtensionError,
+} from '../errors';
+import {
+  formatCallHierarchy,
+  formatCodeActions,
+  formatDiagnostics,
+  formatDocumentSymbols,
+  formatHover,
+  formatIncomingCalls,
+  formatLocations,
+  formatOutgoingCalls,
+  formatWorkspaceSymbols,
+} from '../formatting';
+import type { Diagnostic } from '../types';
+import {
+  FILE_ONLY_OPERATIONS,
+  type LspOperation,
+  POSITION_OPERATIONS,
+  QUERY_OPERATIONS,
+} from '../types';
+
+// ── ServerManager service ─────────────────────────────────────────────────────
+
+export interface ServerManagerService {
+  /** Get all LSP clients that handle a given file extension. */
+  clientsForFile: (filePath: string) => LspClient[];
+  /** Get the first LSP client that handles a file and has a capability. */
+  clientForFileWithCapability: (filePath: string, capability: string) => LspClient | null;
+  /** Get any initialized client (for workspace-wide ops). */
+  anyClient: () => LspClient | null;
+  /** Current root path. */
+  getRootPath: () => string;
+}
+
+export class ServerManager extends Context.Tag('Lsp/ServerManager')<
+  ServerManager,
+  ServerManagerService
+>() {}
+
+export interface ToolResult {
+  content: { type: 'text'; text: string }[];
+  details: Record<string, unknown>;
+}
+
+export interface LspToolParams {
+  operation: LspOperation;
+  filePath?: string;
+  line?: number;
+  character?: number;
+  query?: string;
+}
+
+// ── Capability map ────────────────────────────────────────────────────────────
+
+const CAPABILITY_MAP: Record<LspOperation, string> = {
+  diagnostics: 'textDocumentSync',
+  hover: 'hoverProvider',
+  goToDefinition: 'definitionProvider',
+  findReferences: 'referencesProvider',
+  goToImplementation: 'implementationProvider',
+  documentSymbol: 'documentSymbolProvider',
+  workspaceSymbol: 'workspaceSymbolProvider',
+  prepareCallHierarchy: 'callHierarchyProvider',
+  incomingCalls: 'callHierarchyProvider',
+  outgoingCalls: 'callHierarchyProvider',
+  codeActions: 'codeActionProvider',
+};
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+function cleanPath(path: string): string {
+  return path.replace(/^@/, '');
+}
+
+function toZeroIndexed(oneIndexed: number): number {
+  return Math.max(0, oneIndexed - 1);
+}
+
+function ok(text: string): ToolResult {
+  return { content: [{ type: 'text', text }], details: {} };
+}
+
+/** Server name for error context — tolerates partially-shaped clients. */
+function serverName(client: LspClient): string {
+  return client.config?.name ?? 'lsp';
+}
+
+/** Wrap an async LSP client call as a typed Effect. */
+function call<A>(
+  operation: string,
+  server: string,
+  thunk: () => Promise<A>,
+): Effect.Effect<A, LspOperationError> {
+  return Effect.tryPromise({
+    try: thunk,
+    catch: (cause) => new LspOperationError({ operation, server, cause }),
+  });
+}
+
+function validate(params: LspToolParams): Effect.Effect<void, LspValidationError> {
+  const { operation, filePath, line, character, query } = params;
+  const fail = (reason: string) => Effect.fail(new LspValidationError({ reason }));
+
+  if (POSITION_OPERATIONS.includes(operation)) {
+    if (!filePath) return fail(`Operation '${operation}' requires filePath`);
+    if (line === undefined) return fail(`Operation '${operation}' requires line`);
+    if (character === undefined) return fail(`Operation '${operation}' requires character`);
+  }
+  if (FILE_ONLY_OPERATIONS.includes(operation)) {
+    if (!filePath) return fail(`Operation '${operation}' requires filePath`);
+  }
+  if (QUERY_OPERATIONS.includes(operation)) {
+    if (!query) return fail(`Operation '${operation}' requires query`);
+  }
+  return Effect.void;
+}
+
+// ── Program ────────────────────────────────────────────────────────────────────
+
+export function lspToolProgram(
+  raw: LspToolParams,
+): Effect.Effect<ToolResult, LspExtensionError, ServerManager> {
+  return Effect.gen(function* () {
+    yield* validate(raw);
+
+    const mgr = yield* ServerManager;
+    const operation = raw.operation;
+    const filePath = raw.filePath ? cleanPath(raw.filePath) : undefined;
+    const rootPath = mgr.getRootPath();
+
+    if (operation === 'diagnostics') {
+      return yield* diagnosticsProgram(mgr, filePath!);
+    }
+
+    if (operation === 'workspaceSymbol') {
+      return yield* workspaceSymbolProgram(mgr, raw.query!, rootPath);
+    }
+
+    const capability = CAPABILITY_MAP[operation];
+    const client = mgr.clientForFileWithCapability(filePath!, capability);
+    if (!client) {
+      return yield* new NoCapableServerError({ operation, filePath: filePath! });
+    }
+
+    const server = serverName(client);
+    const line = raw.line!;
+    const character = raw.character!;
+    const pos = { line: toZeroIndexed(line), character: toZeroIndexed(character) };
+
+    switch (operation) {
+      case 'hover': {
+        const result = yield* call(operation, server, () => client.hover(filePath!, pos));
+        return ok(formatHover(result, filePath!, pos.line, pos.character));
+      }
+      case 'goToDefinition': {
+        const locs = yield* call(operation, server, () => client.definition(filePath!, pos));
+        return ok(
+          formatLocations(locs, 'Definition', filePath!, pos.line, pos.character, rootPath),
+        );
+      }
+      case 'findReferences': {
+        const locs = yield* call(operation, server, () => client.references(filePath!, pos));
+        return ok(
+          formatLocations(locs, 'References', filePath!, pos.line, pos.character, rootPath),
+        );
+      }
+      case 'goToImplementation': {
+        const locs = yield* call(operation, server, () => client.implementation(filePath!, pos));
+        return ok(
+          formatLocations(locs, 'Implementation', filePath!, pos.line, pos.character, rootPath),
+        );
+      }
+      case 'documentSymbol': {
+        const symbols = yield* call(operation, server, () => client.documentSymbol(filePath!));
+        return ok(formatDocumentSymbols(symbols, filePath!, rootPath));
+      }
+      case 'prepareCallHierarchy': {
+        const items = yield* call(operation, server, () =>
+          client.prepareCallHierarchy(filePath!, pos),
+        );
+        return ok(formatCallHierarchy(items, filePath!, pos.line, pos.character, rootPath));
+      }
+      case 'incomingCalls': {
+        const items = yield* call(operation, server, () =>
+          client.prepareCallHierarchy(filePath!, pos),
+        );
+        if (items.length === 0) {
+          return ok(`No call hierarchy item at ${filePath!}:${line}:${character}`);
+        }
+        const calls = yield* call(operation, server, () => client.incomingCalls(items[0]));
+        return ok(formatIncomingCalls(calls, items[0], rootPath));
+      }
+      case 'outgoingCalls': {
+        const items = yield* call(operation, server, () =>
+          client.prepareCallHierarchy(filePath!, pos),
+        );
+        if (items.length === 0) {
+          return ok(`No call hierarchy item at ${filePath!}:${line}:${character}`);
+        }
+        const calls = yield* call(operation, server, () => client.outgoingCalls(items[0]));
+        return ok(formatOutgoingCalls(calls, items[0], rootPath));
+      }
+      case 'codeActions': {
+        const diagsForFile = yield* call(operation, server, () => client.getDiagnostics(filePath!));
+        const zeroLine = toZeroIndexed(line);
+        const lineDiags = diagsForFile.filter(
+          (d) => d.range.start.line <= zeroLine && d.range.end.line >= zeroLine,
+        );
+        const range = {
+          start: { line: zeroLine, character: 0 },
+          end: { line: zeroLine, character: Number.MAX_SAFE_INTEGER },
+        };
+        const actions = yield* call(operation, server, () =>
+          client.codeActions(filePath!, range, { diagnostics: lineDiags }),
+        );
+        return ok(formatCodeActions(actions, filePath!, zeroLine));
+      }
+      default:
+        return yield* new LspValidationError({ reason: `Unknown operation: ${operation}` });
+    }
+  });
+}
+
+function diagnosticsProgram(
+  mgr: ServerManagerService,
+  filePath: string,
+): Effect.Effect<ToolResult, never> {
+  return Effect.gen(function* () {
+    const groups: { source: string; diagnostics: Diagnostic[] }[] = [];
+    const errors: string[] = [];
+
+    for (const client of mgr.clientsForFile(filePath)) {
+      const name = serverName(client);
+      const result = yield* call('diagnostics', name, () => client.getDiagnostics(filePath)).pipe(
+        Effect.either,
+      );
+
+      if (result._tag === 'Right') {
+        if (result.right.length > 0) {
+          groups.push({ source: name, diagnostics: result.right });
+        }
+      } else {
+        errors.push(`${name}: ${result.left.message}`);
+      }
+    }
+
+    const text = formatDiagnostics(filePath, groups);
+    const errorNote = errors.length > 0 ? `\n\nNote: ${errors.join('; ')}` : '';
+
+    return {
+      content: [{ type: 'text' as const, text: text + errorNote }],
+      details: {
+        groups: groups.map((g) => ({ source: g.source, count: g.diagnostics.length })),
+        errors,
+      },
+    };
+  });
+}
+
+function workspaceSymbolProgram(
+  mgr: ServerManagerService,
+  query: string,
+  rootPath: string,
+): Effect.Effect<ToolResult, LspExtensionError> {
+  return Effect.gen(function* () {
+    const client = mgr.anyClient();
+    if (!client) {
+      return yield* new NoServerAvailableError({ operation: 'workspace symbol search' });
+    }
+    const symbols = yield* call('workspaceSymbol', serverName(client), () =>
+      client.workspaceSymbol(query),
+    );
+    return ok(formatWorkspaceSymbols(symbols, query, rootPath));
+  });
+}

package/extensions/lsp/tools.ts

@@ -1,97 +1,31 @@
 /**
  * Single unified `lsp` tool registration.
  *
- * 11 operations routed to the right server by file extension.
+ * 11 operations routed to the right server by file extension. The execution
+ * logic lives in `tools/programs.ts` as Effect programs; this module owns the
+ * tool schema/description and runs the program with the live `ServerManager`.
  */
 
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { Effect } from 'effect';
 import { Type } from 'typebox';
 import { StringEnum } from '@earendil-works/pi-ai';
 
-import type { LspClient } from './client';
+import { toNativeError } from './errors';
 import {
-  formatCallHierarchy,
-  formatCodeActions,
-  formatDiagnostics,
-  formatDocumentSymbols,
-  formatHover,
-  formatIncomingCalls,
-  formatLocations,
-  formatOutgoingCalls,
-  formatWorkspaceSymbols,
-} from './formatting';
-import type { Diagnostic } from './types';
-import {
-  FILE_ONLY_OPERATIONS,
-  LSP_OPERATIONS,
-  type LspOperation,
-  POSITION_OPERATIONS,
-  QUERY_OPERATIONS,
-} from './types';
-
-// ── Helpers ─────────────────────────────────────────────────────────────────
-
-function cleanPath(path: string): string {
-  return path.replace(/^@/, '');
-}
-
-function toZeroIndexed(oneIndexed: number): number {
-  return Math.max(0, oneIndexed - 1);
-}
-
-function validateParams(
-  operation: LspOperation,
-  filePath?: string,
-  line?: number,
-  character?: number,
-  query?: string,
-): string | null {
-  if (POSITION_OPERATIONS.includes(operation)) {
-    if (!filePath) return `Operation '${operation}' requires filePath`;
-    if (line === undefined) return `Operation '${operation}' requires line`;
-    if (character === undefined) return `Operation '${operation}' requires character`;
-  }
-  if (FILE_ONLY_OPERATIONS.includes(operation)) {
-    if (!filePath) return `Operation '${operation}' requires filePath`;
-  }
-  if (QUERY_OPERATIONS.includes(operation)) {
-    if (!query) return `Operation '${operation}' requires query`;
-  }
-  return null;
-}
-
-// ── Types ───────────────────────────────────────────────────────────────────
-
-export interface ServerManager {
-  /** Get all LSP clients that handle a given file extension. */
-  clientsForFile: (filePath: string) => LspClient[];
-  /** Get the first LSP client that handles a file and has a capability. */
-  clientForFileWithCapability: (filePath: string, capability: string) => LspClient | null;
-  /** Get any initialized client (for workspace-wide ops). */
-  anyClient: () => LspClient | null;
-  /** Current root path. */
-  getRootPath: () => string;
-}
-
-// ── Capability map ──────────────────────────────────────────────────────────
+  lspToolProgram,
+  ServerManager,
+  type LspToolParams,
+  type ServerManagerService,
+} from './tools/programs';
+import { LSP_OPERATIONS, type LspOperation } from './types';
 
-const CAPABILITY_MAP: Record<LspOperation, string> = {
-  diagnostics: 'textDocumentSync', // all servers with sync support
-  hover: 'hoverProvider',
-  goToDefinition: 'definitionProvider',
-  findReferences: 'referencesProvider',
-  goToImplementation: 'implementationProvider',
-  documentSymbol: 'documentSymbolProvider',
-  workspaceSymbol: 'workspaceSymbolProvider',
-  prepareCallHierarchy: 'callHierarchyProvider',
-  incomingCalls: 'callHierarchyProvider',
-  outgoingCalls: 'callHierarchyProvider',
-  codeActions: 'codeActionProvider',
-};
+export type { ServerManagerService } from './tools/programs';
+export { ServerManager } from './tools/programs';
 
 // ── Registration ────────────────────────────────────────────────────────────
 
-export function registerLspTool(pi: ExtensionAPI, mgr: ServerManager) {
+export function registerLspTool(pi: ExtensionAPI, mgr: ServerManagerService) {
   pi.registerTool({
     name: 'lsp',
     label: 'LSP',
@@ -103,12 +37,12 @@ export function registerLspTool(pi: ExtensionAPI, mgr: ServerManager) {
       '  findReferences    — find all references to a symbol',
       '  hover             — get type info and documentation for a symbol',
       '  diagnostics       — get type errors and lint warnings for a file',
-      '  documentSymbol    — get all symbols in a file',
+      '  documentSymbol    — get all symbols in a file (with line:column positions)',
       '  workspaceSymbol   — search for symbols across the workspace',
       '  goToImplementation — find implementations of an interface/abstract method',
       '  prepareCallHierarchy — get call hierarchy item at a position',
-      '  incomingCalls     — find callers of a function/method',
-      '  outgoingCalls     — find callees of a function/method',
+      '  incomingCalls     — find callers of a function/method (auto-prepares hierarchy)',
+      '  outgoingCalls     — find callees of a function/method (auto-prepares hierarchy)',
       '  codeActions       — get quick fixes and refactoring suggestions',
       '',
       'Parameters:',
@@ -117,14 +51,24 @@ export function registerLspTool(pi: ExtensionAPI, mgr: ServerManager) {
       '  line      — line number, 1-indexed (required for position-based operations)',
       '  character — column number, 1-indexed (required for position-based operations)',
       '  query     — search string (required for workspaceSymbol)',
+      '',
+      'Tips:',
+      '  — Position the character in the middle of the symbol name for best results.',
+      '  — Use hover before goToDefinition to quickly check signatures and docs.',
+      '  — workspaceSymbol may need a retry if the server is still indexing.',
     ].join('\n'),
     promptSnippet:
       'Interact with LSP servers for code intelligence: definitions, references, hover, diagnostics, symbols, call hierarchy, code actions',
     promptGuidelines: [
-      'Use `diagnostics` after editing files to check for type errors and lint issues.',
-      'Use `hover` to understand types, `goToDefinition` to navigate, `findReferences` before refactoring.',
-      'Line and character are 1-indexed — use the line numbers shown by the read tool.',
-      'LSP servers are auto-detected by file extension. Use /lsp to check status.',
+      'lsp line and character params are 1-indexed — use the values from the read tool or rg output directly.',
+      'lsp `hover` is the fastest way to get a function signature, type params, and doc comment — prefer it over `goToDefinition` for quick type inspection.',
+      'lsp `documentSymbol` returns line:column positions for each symbol — use those values directly for follow-up lsp operations.',
+      'For lsp position-based operations, place the character in the **middle** of the symbol name, not at the first character.',
+      'lsp `incomingCalls` and `outgoingCalls` automatically prepare the call hierarchy — no need to call `prepareCallHierarchy` first.',
+      'lsp `workspaceSymbol` may return empty results while the LSP server is still indexing. If it returns nothing, wait a few seconds and retry.',
+      'lsp `diagnostics` relies on server-pushed notifications which may be slow for some servers. For compiled languages (Rust, Go, C++), prefer running the compiler directly (e.g. `cargo check`, `go build`) for reliable error checking.',
+      'Use lsp for type info, macro-generated symbols, and cross-module navigation. Use rg for simple text search and file discovery — it is faster and needs no server.',
+      'lsp servers are auto-detected by file extension. Use /lsp to check status.',
     ],
     parameters: Type.Object({
       operation: StringEnum(LSP_OPERATIONS),
@@ -134,158 +78,12 @@ export function registerLspTool(pi: ExtensionAPI, mgr: ServerManager) {
       query: Type.Optional(Type.String({ description: 'Search query (for workspaceSymbol)' })),
     }),
     async execute(_toolCallId, params) {
-      const operation = params.operation as LspOperation;
-      const filePath = params.filePath ? cleanPath(params.filePath) : undefined;
-      const line = params.line;
-      const character = params.character;
-      const query = params.query;
-      const rootPath = mgr.getRootPath();
-
-      // Validate required params
-      const validationError = validateParams(operation, filePath, line, character, query);
-      if (validationError) throw new Error(validationError);
-
-      // ── diagnostics (aggregate from all matching servers) ──
-      if (operation === 'diagnostics') {
-        return executeDiagnostics(mgr, filePath!, rootPath);
-      }
-
-      // ── workspaceSymbol (doesn't need a file-based server lookup) ──
-      if (operation === 'workspaceSymbol') {
-        return executeWorkspaceSymbol(mgr, query!, rootPath);
-      }
-
-      // ── all other operations: route to first capable server ──
-      const capability = CAPABILITY_MAP[operation];
-      const client = mgr.clientForFileWithCapability(filePath!, capability);
-      if (!client) {
-        throw new Error(
-          `No LSP server with '${operation}' capability found for ${filePath}. Check /lsp status.`,
-        );
-      }
-
-      const pos = { line: toZeroIndexed(line!), character: toZeroIndexed(character!) };
-
-      switch (operation) {
-        case 'hover': {
-          const result = await client.hover(filePath!, pos);
-          return ok(formatHover(result, filePath!, pos.line, pos.character));
-        }
-
-        case 'goToDefinition': {
-          const locs = await client.definition(filePath!, pos);
-          return ok(
-            formatLocations(locs, 'Definition', filePath!, pos.line, pos.character, rootPath),
-          );
-        }
-
-        case 'findReferences': {
-          const locs = await client.references(filePath!, pos);
-          return ok(
-            formatLocations(locs, 'References', filePath!, pos.line, pos.character, rootPath),
-          );
-        }
-
-        case 'goToImplementation': {
-          const locs = await client.implementation(filePath!, pos);
-          return ok(
-            formatLocations(locs, 'Implementation', filePath!, pos.line, pos.character, rootPath),
-          );
-        }
-
-        case 'documentSymbol': {
-          const symbols = await client.documentSymbol(filePath!);
-          return ok(formatDocumentSymbols(symbols, filePath!, rootPath));
-        }
-
-        case 'prepareCallHierarchy': {
-          const items = await client.prepareCallHierarchy(filePath!, pos);
-          return ok(formatCallHierarchy(items, filePath!, pos.line, pos.character, rootPath));
-        }
-
-        case 'incomingCalls': {
-          const items = await client.prepareCallHierarchy(filePath!, pos);
-          if (items.length === 0) {
-            return ok(`No call hierarchy item at ${filePath!}:${line}:${character}`);
-          }
-          const calls = await client.incomingCalls(items[0]);
-          return ok(formatIncomingCalls(calls, items[0], rootPath));
-        }
-
-        case 'outgoingCalls': {
-          const items = await client.prepareCallHierarchy(filePath!, pos);
-          if (items.length === 0) {
-            return ok(`No call hierarchy item at ${filePath!}:${line}:${character}`);
-          }
-          const calls = await client.outgoingCalls(items[0]);
-          return ok(formatOutgoingCalls(calls, items[0], rootPath));
-        }
-
-        case 'codeActions': {
-          const diagsForFile = await client.getDiagnostics(filePath!);
-          const zeroLine = toZeroIndexed(line!);
-          const lineDiags = diagsForFile.filter(
-            (d) => d.range.start.line <= zeroLine && d.range.end.line >= zeroLine,
-          );
-          const range = {
-            start: { line: zeroLine, character: 0 },
-            end: { line: zeroLine, character: Number.MAX_SAFE_INTEGER },
-          };
-          const actions = await client.codeActions(filePath!, range, { diagnostics: lineDiags });
-          return ok(formatCodeActions(actions, filePath!, zeroLine));
-        }
-
-        default:
-          throw new Error(`Unknown operation: ${operation}`);
-      }
+      const program = lspToolProgram(params as LspToolParams);
+      return Effect.runPromise(
+        program.pipe(Effect.provideService(ServerManager, mgr), Effect.mapError(toNativeError)),
+      );
     },
   });
 }
 
-// ── Operation executors ─────────────────────────────────────────────────────
-
-async function executeDiagnostics(mgr: ServerManager, filePath: string, _rootPath: string) {
-  const groups: { source: string; diagnostics: Diagnostic[] }[] = [];
-  const errors: string[] = [];
-
-  // Gather from all LSP servers that handle this file
-  const clients = mgr.clientsForFile(filePath);
-  for (const client of clients) {
-    try {
-      const diags = await client.getDiagnostics(filePath);
-      if (diags.length > 0) {
-        groups.push({ source: client.config.name, diagnostics: diags });
-      }
-    } catch (err) {
-      errors.push(`${client.config.name}: ${(err as Error).message}`);
-    }
-  }
-
-  const text = formatDiagnostics(filePath, groups);
-  const errorNote = errors.length > 0 ? `\n\nNote: ${errors.join('; ')}` : '';
-
-  return {
-    content: [{ type: 'text' as const, text: text + errorNote }],
-    details: {
-      groups: groups.map((g) => ({ source: g.source, count: g.diagnostics.length })),
-      errors,
-    },
-  };
-}
-
-async function executeWorkspaceSymbol(mgr: ServerManager, query: string, rootPath: string) {
-  const client = mgr.anyClient();
-  if (!client) throw new Error('No LSP server available for workspace symbol search.');
-
-  const symbols = await client.workspaceSymbol(query);
-  return ok(formatWorkspaceSymbols(symbols, query, rootPath));
-}
-
-// ── Helpers ─────────────────────────────────────────────────────────────────
-
-function ok(text: string) {
-  return {
-    content: [{ type: 'text' as const, text }],
-    details: {},
-  };
-}
+export type { LspOperation };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dreki-gg/pi-lsp",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Language-agnostic LSP code intelligence for pi — diagnostics, hover, definitions, references, symbols, and call hierarchy",
   "keywords": [
     "pi-package"
@@ -25,6 +25,9 @@
       "./extensions/lsp"
     ]
   },
+  "dependencies": {
+    "effect": "^3.21.2"
+  },
   "devDependencies": {
     "@earendil-works/pi-ai": "^0.74.0",
     "@types/node": "24",