@dreki-gg/pi-lsp 0.2.1 → 0.4.0

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-');

package/test/effects.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from 'bun:test';
+import { Effect, Layer } from 'effect';
+
+import { loadConfigEffect, scaffoldGlobalConfigEffect } from '../extensions/lsp/config';
+import { CommandResolver, type CommandAvailability } from '../extensions/lsp/effects/command';
+import { FileSystem, type FileSystemService } from '../extensions/lsp/effects/filesystem';
+import { ConfigReadError } from '../extensions/lsp/errors';
+
+/** Build an in-memory FileSystem service over a path→content map. */
+function fakeFs(files: Record<string, string>, writes?: Record<string, string>): FileSystemService {
+  return {
+    readTextFile: (path) =>
+      path in files
+        ? Effect.succeed(files[path])
+        : Effect.fail(new ConfigReadError({ path, cause: new Error('ENOENT') })),
+    fileExists: (path) => Effect.succeed(path in files),
+    writeTextFile: (path, content) =>
+      Effect.sync(() => {
+        if (writes) writes[path] = content;
+        files[path] = content;
+      }),
+  };
+}
+
+function fakeResolver(availability: CommandAvailability) {
+  return Layer.succeed(CommandResolver, { resolve: () => Effect.succeed(availability) });
+}
+
+describe('effect services', () => {
+  test('loadConfigEffect resolves servers via injected services (no disk, no shell)', async () => {
+    const home = process.env.HOME ?? '';
+    const globalPath = `${home}/.pi/agent/extensions/lsp/config.json`;
+    const fs = fakeFs({
+      [globalPath]: JSON.stringify({
+        lsp: { ts: { command: ['ts-ls', '--stdio'], extensions: ['.ts'] } },
+      }),
+    });
+
+    const layer = Layer.merge(Layer.succeed(FileSystem, fs), fakeResolver('global'));
+    const config = await Effect.runPromise(
+      loadConfigEffect('/workspace').pipe(Effect.provide(layer)),
+    );
+
+    expect(config.globalDisabled).toBe(false);
+    expect(config.servers).toEqual([
+      {
+        name: 'ts',
+        command: 'ts-ls',
+        args: ['--stdio'],
+        extensions: ['.ts'],
+        env: {},
+        initializationOptions: {},
+      },
+    ]);
+  });
+
+  test('loadConfigEffect rewrites command to npx when only available via npx', async () => {
+    const home = process.env.HOME ?? '';
+    const globalPath = `${home}/.pi/agent/extensions/lsp/config.json`;
+    const fs = fakeFs({
+      [globalPath]: JSON.stringify({
+        lsp: { ts: { command: ['ts-ls', '--stdio'], extensions: ['.ts'] } },
+      }),
+    });
+
+    const layer = Layer.merge(Layer.succeed(FileSystem, fs), fakeResolver('npx'));
+    const config = await Effect.runPromise(
+      loadConfigEffect('/workspace').pipe(Effect.provide(layer)),
+    );
+
+    expect(config.servers[0]?.command).toBe('npx');
+    expect(config.servers[0]?.args).toEqual(['--yes', 'ts-ls', '--stdio']);
+  });
+
+  test('loadConfigEffect drops servers whose command cannot be resolved', async () => {
+    const home = process.env.HOME ?? '';
+    const globalPath = `${home}/.pi/agent/extensions/lsp/config.json`;
+    const fs = fakeFs({
+      [globalPath]: JSON.stringify({
+        lsp: { ts: { command: ['missing-ls'], extensions: ['.ts'] } },
+      }),
+    });
+
+    const layer = Layer.merge(Layer.succeed(FileSystem, fs), fakeResolver(null));
+    const config = await Effect.runPromise(
+      loadConfigEffect('/workspace').pipe(Effect.provide(layer)),
+    );
+
+    expect(config.servers).toEqual([]);
+  });
+
+  test('scaffoldGlobalConfigEffect writes the starter template when nothing exists', async () => {
+    const writes: Record<string, string> = {};
+    const fs = fakeFs({}, writes);
+
+    const created = await Effect.runPromise(
+      scaffoldGlobalConfigEffect('/workspace').pipe(Effect.provideService(FileSystem, fs)),
+    );
+
+    expect(created).toBe(true);
+    const written = Object.values(writes)[0] ?? '';
+    const parsed = JSON.parse(written);
+    for (const server of Object.values(parsed.lsp as Record<string, { disabled?: boolean }>)) {
+      expect(server.disabled).toBe(true);
+    }
+  });
+});

package/test/formatting.test.ts

@@ -96,8 +96,8 @@ describe('formatting', () => {
       '/repo',
     );
     expect(docSymbols).toContain('Symbols in src/foo.ts');
-    expect(docSymbols).toContain('Foo (class)');
-    expect(docSymbols).toContain('bar (method)');
+    expect(docSymbols).toContain('Foo (class) line 1:7');
+    expect(docSymbols).toContain('bar (method) line 3:3');
 
     const wsSymbols = formatWorkspaceSymbols(
       [
@@ -115,7 +115,7 @@ describe('formatting', () => {
       '/repo',
     );
     expect(wsSymbols).toContain('Workspace symbols matching "Foo"');
-    expect(wsSymbols).toContain('FooService (class) src/service.ts:12 in services');
+    expect(wsSymbols).toContain('FooService (class) src/service.ts:12:1 in services');
   });
 
   test('formats call hierarchy and code actions', () => {

package/test/index.test.ts

@@ -107,8 +107,9 @@ describe('extension/session layer', () => {
 
     const globalConfigPath = join(home, '.pi', 'agent', 'extensions', 'lsp', 'config.json');
     expect(await fileExists(globalConfigPath)).toBe(true);
-    const text = await readFile(globalConfigPath, 'utf8');
-    expect(text).toContain('typescript-language-server');
+    const parsed = JSON.parse(await readFile(globalConfigPath, 'utf8'));
+    // typescript is present only as a disabled example — never auto-enabled.
+    expect(parsed.lsp.typescript.disabled).toBe(true);
     expect(ui.notifications.some((n) => n.includes('created starter config'))).toBe(true);
   });
 

package/test/mock-lsp-server.ts

@@ -243,20 +243,27 @@ function handleRequest(req: JsonRpcRequest) {
   }
 }
 
-function handleNotification(msg: JsonRpcNotification) {
-  if (msg.method === 'textDocument/didOpen' || msg.method === 'textDocument/didChange') {
-    const textDocument =
-      msg.method === 'textDocument/didOpen' ? msg.params?.textDocument : msg.params?.textDocument;
-    const text =
-      msg.method === 'textDocument/didOpen'
-        ? (msg.params?.textDocument?.text ?? '')
-        : (msg.params?.contentChanges?.[0]?.text ?? '');
-    lastUri = textDocument?.uri ?? lastUri;
-    sendDiagnostics(lastUri, text);
-  }
+function handleDocSync(uri: string, text: string) {
+  lastUri = uri;
+  sendDiagnostics(lastUri, text);
+}
 
-  if (msg.method === 'exit') {
-    process.exit(0);
+function handleNotification(msg: JsonRpcNotification) {
+  switch (msg.method) {
+    case 'textDocument/didOpen':
+      handleDocSync(msg.params?.textDocument?.uri ?? lastUri, msg.params?.textDocument?.text ?? '');
+      break;
+    case 'textDocument/didChange':
+      handleDocSync(
+        msg.params?.textDocument?.uri ?? lastUri,
+        msg.params?.contentChanges?.[0]?.text ?? '',
+      );
+      break;
+    case 'textDocument/didSave':
+      handleDocSync(msg.params?.textDocument?.uri ?? lastUri, msg.params?.text ?? '');
+      break;
+    case 'exit':
+      process.exit(0);
   }
 }
 

package/test/retry.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, test } from 'bun:test';
+
+import { withRetry } from '../extensions/lsp/retry';
+
+describe('withRetry', () => {
+  test('returns immediately when result is not empty', async () => {
+    let callCount = 0;
+    const result = await withRetry(
+      async () => {
+        callCount++;
+        return [1, 2, 3];
+      },
+      (r) => r.length === 0,
+      { maxRetries: 2, delayMs: 10 },
+    );
+
+    expect(result).toEqual([1, 2, 3]);
+    expect(callCount).toBe(1);
+  });
+
+  test('retries until result is not empty', async () => {
+    let callCount = 0;
+    const result = await withRetry(
+      async () => {
+        callCount++;
+        return callCount >= 3 ? ['found'] : [];
+      },
+      (r) => r.length === 0,
+      { maxRetries: 3, delayMs: 10 },
+    );
+
+    expect(result).toEqual(['found']);
+    expect(callCount).toBe(3);
+  });
+
+  test('stops at maxRetries and returns last empty result', async () => {
+    let callCount = 0;
+    const result = await withRetry(
+      async () => {
+        callCount++;
+        return [];
+      },
+      (r) => r.length === 0,
+      { maxRetries: 2, delayMs: 10 },
+    );
+
+    expect(result).toEqual([]);
+    expect(callCount).toBe(3); // 1 initial + 2 retries
+  });
+
+  test('works with null isEmpty check', async () => {
+    let callCount = 0;
+    const result = await withRetry(
+      async () => {
+        callCount++;
+        return callCount >= 2 ? { value: 'ok' } : null;
+      },
+      (r) => r === null,
+      { maxRetries: 3, delayMs: 10 },
+    );
+
+    expect(result).toEqual({ value: 'ok' });
+    expect(callCount).toBe(2);
+  });
+
+  test('uses default options when not provided', async () => {
+    let callCount = 0;
+    const result = await withRetry(
+      async () => {
+        callCount++;
+        return 'immediate';
+      },
+      (r) => r === '',
+    );
+
+    expect(result).toBe('immediate');
+    expect(callCount).toBe(1);
+  });
+});

package/test/tools.test.ts

@@ -3,6 +3,16 @@ import { describe, expect, test } from 'bun:test';
 import { registerLspTool } from '../extensions/lsp/tools';
 import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
 
+function emptyManager(overrides?: Record<string, any>) {
+  return {
+    clientsForFile: () => [],
+    clientForFileWithCapability: () => null,
+    anyClient: () => null,
+    getRootPath: () => '/repo',
+    ...overrides,
+  };
+}
+
 function captureTool() {
   let tool: ToolDefinition<any, any> | null = null;
   const fakePi = {
@@ -20,14 +30,22 @@ function captureTool() {
 }
 
 describe('unified lsp tool dispatch', () => {
+  test('all promptGuidelines mention lsp tool by name', () => {
+    const { register } = captureTool();
+    const tool = register(emptyManager());
+
+    const guidelines = (tool as any).promptGuidelines as string[] | undefined;
+    expect(guidelines).toBeTruthy();
+    expect(guidelines!.length).toBeGreaterThan(0);
+
+    for (const guideline of guidelines!) {
+      expect(guideline.toLowerCase()).toContain('lsp');
+    }
+  });
+
   test('validates required params by operation', async () => {
     const { register } = captureTool();
-    const tool = register({
-      clientsForFile: () => [],
-      clientForFileWithCapability: () => null,
-      anyClient: () => null,
-      getRootPath: () => '/repo',
-    });
+    const tool = register(emptyManager());
 
     await expect(
       tool.execute('1', { operation: 'hover' }, undefined as any, undefined, {} as any),
@@ -40,35 +58,34 @@ describe('unified lsp tool dispatch', () => {
 
   test('aggregates diagnostics from all matching clients', async () => {
     const { register } = captureTool();
-    const tool = register({
-      clientsForFile: () => [
-        {
-          config: { name: 'ts' },
-          getDiagnostics: async () => [
-            {
-              range: { start: { line: 0, character: 0 }, end: { line: 0, character: 3 } },
-              severity: 1,
-              source: 'ts',
-              message: 'Type error',
-            },
-          ],
-        },
-        {
-          config: { name: 'eslint' },
-          getDiagnostics: async () => [
-            {
-              range: { start: { line: 1, character: 0 }, end: { line: 1, character: 3 } },
-              severity: 2,
-              source: 'eslint',
-              message: 'Lint warning',
-            },
-          ],
-        },
-      ],
-      clientForFileWithCapability: () => null,
-      anyClient: () => null,
-      getRootPath: () => '/repo',
-    });
+    const tool = register(
+      emptyManager({
+        clientsForFile: () => [
+          {
+            config: { name: 'ts' },
+            getDiagnostics: async () => [
+              {
+                range: { start: { line: 0, character: 0 }, end: { line: 0, character: 3 } },
+                severity: 1,
+                source: 'ts',
+                message: 'Type error',
+              },
+            ],
+          },
+          {
+            config: { name: 'eslint' },
+            getDiagnostics: async () => [
+              {
+                range: { start: { line: 1, character: 0 }, end: { line: 1, character: 3 } },
+                severity: 2,
+                source: 'eslint',
+                message: 'Lint warning',
+              },
+            ],
+          },
+        ],
+      }),
+    );
 
     const result = await tool.execute(
       '1',
@@ -91,17 +108,16 @@ describe('unified lsp tool dispatch', () => {
   test('routes hover to first capable server and converts positions to zero-indexed', async () => {
     const calls: any[] = [];
     const { register } = captureTool();
-    const tool = register({
-      clientsForFile: () => [],
-      clientForFileWithCapability: () => ({
-        hover: async (filePath: string, pos: { line: number; character: number }) => {
-          calls.push({ filePath, pos });
-          return { contents: { kind: 'markdown', value: 'mock hover' } };
-        },
+    const tool = register(
+      emptyManager({
+        clientForFileWithCapability: () => ({
+          hover: async (filePath: string, pos: { line: number; character: number }) => {
+            calls.push({ filePath, pos });
+            return { contents: { kind: 'markdown', value: 'mock hover' } };
+          },
+        }),
       }),
-      anyClient: () => null,
-      getRootPath: () => '/repo',
-    });
+    );
 
     const result = await tool.execute(
       '1',
@@ -119,24 +135,23 @@ describe('unified lsp tool dispatch', () => {
 
   test('routes workspaceSymbol through anyClient', async () => {
     const { register } = captureTool();
-    const tool = register({
-      clientsForFile: () => [],
-      clientForFileWithCapability: () => null,
-      anyClient: () => ({
-        workspaceSymbol: async (query: string) => [
-          {
-            name: `${query}Service`,
-            kind: 5,
-            location: {
-              uri: 'file:///repo/src/service.ts',
-              range: { start: { line: 9, character: 0 }, end: { line: 9, character: 5 } },
+    const tool = register(
+      emptyManager({
+        anyClient: () => ({
+          workspaceSymbol: async (query: string) => [
+            {
+              name: `${query}Service`,
+              kind: 5,
+              location: {
+                uri: 'file:///repo/src/service.ts',
+                range: { start: { line: 9, character: 0 }, end: { line: 9, character: 5 } },
+              },
+              containerName: 'services',
             },
-            containerName: 'services',
-          },
-        ],
+          ],
+        }),
       }),
-      getRootPath: () => '/repo',
-    });
+    );
 
     const result = await tool.execute(
       '1',
@@ -154,12 +169,7 @@ describe('unified lsp tool dispatch', () => {
 
   test('errors when no capable server is found', async () => {
     const { register } = captureTool();
-    const tool = register({
-      clientsForFile: () => [],
-      clientForFileWithCapability: () => null,
-      anyClient: () => null,
-      getRootPath: () => '/repo',
-    });
+    const tool = register(emptyManager());
 
     await expect(
       tool.execute(
@@ -175,29 +185,28 @@ describe('unified lsp tool dispatch', () => {
   test('codeActions filters diagnostics to the requested line', async () => {
     const { register } = captureTool();
     const seenContexts: any[] = [];
-    const tool = register({
-      clientsForFile: () => [],
-      clientForFileWithCapability: () => ({
-        getDiagnostics: async () => [
-          {
-            range: { start: { line: 2, character: 0 }, end: { line: 2, character: 10 } },
-            severity: 1,
-            message: 'line 3 issue',
-          },
-          {
-            range: { start: { line: 5, character: 0 }, end: { line: 5, character: 10 } },
-            severity: 1,
-            message: 'line 6 issue',
+    const tool = register(
+      emptyManager({
+        clientForFileWithCapability: () => ({
+          getDiagnostics: async () => [
+            {
+              range: { start: { line: 2, character: 0 }, end: { line: 2, character: 10 } },
+              severity: 1,
+              message: 'line 3 issue',
+            },
+            {
+              range: { start: { line: 5, character: 0 }, end: { line: 5, character: 10 } },
+              severity: 1,
+              message: 'line 6 issue',
+            },
+          ],
+          codeActions: async (_filePath: string, range: any, context: any) => {
+            seenContexts.push({ range, context });
+            return [{ title: 'Fix it', kind: 'quickfix' }];
           },
-        ],
-        codeActions: async (_filePath: string, range: any, context: any) => {
-          seenContexts.push({ range, context });
-          return [{ title: 'Fix it', kind: 'quickfix' }];
-        },
+        }),
       }),
-      anyClient: () => null,
-      getRootPath: () => '/repo',
-    });
+    );
 
     const result = await tool.execute(
       '1',

package/test/typescript.integration.test.ts

@@ -6,6 +6,19 @@ import { fileURLToPath } from 'node:url';
 
 import { LspClient } from '../extensions/lsp/client';
 
+/** Resolve a package bin using Node/Bun module resolution (handles hoisting). */
+function resolveBin(pkg: string): string | null {
+  try {
+    const pkgJsonPath = fileURLToPath(import.meta.resolve(`${pkg}/package.json`));
+    const pkgJson = require(pkgJsonPath);
+    const bin = typeof pkgJson.bin === 'string' ? pkgJson.bin : pkgJson.bin?.[pkg];
+    if (!bin) return null;
+    return resolve(dirname(pkgJsonPath), bin);
+  } catch {
+    return null;
+  }
+}
+
 const cleanup: string[] = [];
 
 async function makeFixtureWorkspace() {
@@ -80,8 +93,11 @@ afterEach(async () => {
 describe('real TypeScript integration', () => {
   test('typescript-language-server resolves diagnostics and navigation in a fixture workspace', async () => {
     const workspace = await makeFixtureWorkspace();
-    const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-    const tsServerBin = join(packageRoot, 'node_modules', '.bin', 'typescript-language-server');
+    const tsServerBin = resolveBin('typescript-language-server');
+    if (!tsServerBin) {
+      console.log('Skipping: typescript-language-server not found');
+      return;
+    }
 
     const client = new LspClient(
       {