@dreki-gg/pi-lsp 0.3.0 → 0.4.1

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',
@@ -144,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.3.0",
+  "version": "0.4.1",
   "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",

package/test/config.test.ts

@@ -56,6 +56,40 @@ describe('config loader', () => {
     expect(again).toBe(false);
   });
 
+  test('scaffolded starter config does not enable typescript (or any) server by default', async () => {
+    const home = await makeTempDir('pi-lsp-home-');
+    const cwd = await makeTempDir('pi-lsp-cwd-');
+    process.env.HOME = home;
+
+    await scaffoldGlobalConfig(cwd);
+
+    const globalConfigPath = join(home, '.pi', 'agent', 'extensions', 'lsp', 'config.json');
+    const parsed = JSON.parse(await readFile(globalConfigPath, 'utf8'));
+    // Every example server is opt-in (disabled), so typescript is not a default.
+    for (const server of Object.values(parsed.lsp as Record<string, { disabled?: boolean }>)) {
+      expect(server.disabled).toBe(true);
+    }
+
+    const config = await loadConfig(cwd);
+    expect(config.globalDisabled).toBe(false);
+    expect(config.servers).toEqual([]);
+  });
+
+  test('disabled servers are excluded even when their command exists', async () => {
+    const home = await makeTempDir('pi-lsp-home-');
+    const cwd = await makeTempDir('pi-lsp-cwd-');
+    process.env.HOME = home;
+
+    await writeJson(join(cwd, '.pi', 'lsp.json'), {
+      lsp: {
+        node: { command: ['node'], extensions: ['.js'], disabled: true },
+      },
+    });
+
+    const config = await loadConfig(cwd);
+    expect(config.servers).toEqual([]);
+  });
+
   test('does not scaffold when project config exists', async () => {
     const home = await makeTempDir('pi-lsp-home-');
     const cwd = await makeTempDir('pi-lsp-cwd-');