@soleri/core 9.0.4 → 9.3.0

package/src/__tests__/lsp-transport.test.ts

@@ -1,442 +0,0 @@
-/**
- * LSP Transport Tests — lsp-server.ts
- *
- * Tests the LSP JSON-RPC server using in-memory PassThrough streams.
- */
-
-import { describe, test, expect, afterEach, vi } from 'vitest';
-import { PassThrough } from 'node:stream';
-import { LspServer } from '../transport/index.js';
-import type {
-  LspServerCallbacks,
-  LspCompletionItem,
-  LspDiagnostic,
-  LspHover,
-  LspCodeAction,
-} from '../transport/index.js';
-
-// =============================================================================
-// HELPERS
-// =============================================================================
-
-/** Encode a message in LSP wire format */
-function encodeLsp(obj: unknown): string {
-  const json = JSON.stringify(obj);
-  const len = Buffer.byteLength(json, 'utf-8');
-  return `Content-Length: ${len}\r\n\r\n${json}`;
-}
-
-/** Parse one LSP response from a buffer string. Returns parsed JSON and remaining buffer. */
-function parseLspResponse(buffer: string): { message: any; remaining: string } | null {
-  const headerEnd = buffer.indexOf('\r\n\r\n');
-  if (headerEnd < 0) return null;
-
-  const headers = buffer.substring(0, headerEnd);
-  const match = headers.match(/Content-Length:\s*(\d+)/i);
-  if (!match) return null;
-
-  const contentLength = parseInt(match[1], 10);
-  const bodyStart = headerEnd + 4;
-  const bodyBytes = Buffer.from(buffer.substring(bodyStart), 'utf-8');
-  if (bodyBytes.length < contentLength) return null;
-
-  const body = bodyBytes.subarray(0, contentLength).toString('utf-8');
-  const remaining = bodyBytes.subarray(contentLength).toString('utf-8');
-
-  return { message: JSON.parse(body), remaining };
-}
-
-/** Collect all LSP messages from output stream until timeout */
-function collectMessages(output: PassThrough, count = 1, timeoutMs = 3000): Promise<any[]> {
-  return new Promise((resolve, reject) => {
-    const messages: any[] = [];
-    let buffer = '';
-    const timer = setTimeout(() => {
-      if (messages.length > 0) resolve(messages);
-      else reject(new Error(`Timeout waiting for ${count} messages, got ${messages.length}`));
-    }, timeoutMs);
-
-    output.on('data', (chunk: Buffer) => {
-      buffer += chunk.toString();
-      let parsed = parseLspResponse(buffer);
-      while (parsed) {
-        messages.push(parsed.message);
-        buffer = parsed.remaining;
-        if (messages.length >= count) {
-          clearTimeout(timer);
-          resolve(messages);
-          return;
-        }
-        parsed = parseLspResponse(buffer);
-      }
-    });
-  });
-}
-
-/** Send a request and get the response */
-async function sendRequest(
-  input: PassThrough,
-  output: PassThrough,
-  method: string,
-  id: number,
-  params?: unknown,
-): Promise<any> {
-  const promise = collectMessages(output, 1);
-  input.write(encodeLsp({ jsonrpc: '2.0', id, method, params }));
-  const [response] = await promise;
-  return response;
-}
-
-/** Send a notification (no response expected) */
-function sendNotification(input: PassThrough, method: string, params?: unknown): void {
-  input.write(encodeLsp({ jsonrpc: '2.0', method, params }));
-}
-
-// =============================================================================
-// TESTS
-// =============================================================================
-
-describe('LspServer', () => {
-  let server: LspServer | undefined;
-  let input: PassThrough;
-  let output: PassThrough;
-
-  function createTestServer(
-    overrides: Partial<LspServerCallbacks> = {},
-    capabilities?: import('../transport/types.js').LspCapabilities,
-  ): LspServer {
-    input = new PassThrough();
-    output = new PassThrough();
-    const callbacks: LspServerCallbacks = {
-      onCompletion: overrides.onCompletion,
-      onHover: overrides.onHover,
-      onDiagnostics: overrides.onDiagnostics,
-      onCodeAction: overrides.onCodeAction,
-      onInitialize: overrides.onInitialize,
-      onDocumentChange: overrides.onDocumentChange,
-      onShutdown: overrides.onShutdown,
-    };
-    server = new LspServer({ capabilities }, callbacks, input, output);
-    return server;
-  }
-
-  afterEach(async () => {
-    if (server) {
-      await server.stop();
-      server = undefined;
-    }
-    input?.destroy();
-    output?.destroy();
-  });
-
-  test('constructs without error', () => {
-    const s = createTestServer();
-    expect(s).toBeDefined();
-    expect(s.isRunning).toBe(false);
-  });
-
-  test('start and stop', async () => {
-    const s = createTestServer();
-    s.start();
-    expect(s.isRunning).toBe(true);
-    await s.stop();
-    expect(s.isRunning).toBe(false);
-  });
-
-  test('initialize returns server capabilities', async () => {
-    const s = createTestServer({
-      onInitialize: async () => ({ name: 'test-agent', version: '1.0.0' }),
-    });
-    s.start();
-
-    const response = await sendRequest(input, output, 'initialize', 1, {
-      capabilities: {},
-    });
-
-    expect(response.jsonrpc).toBe('2.0');
-    expect(response.id).toBe(1);
-    expect(response.result.serverInfo.name).toBe('test-agent');
-    expect(response.result.serverInfo.version).toBe('1.0.0');
-    expect(response.result.capabilities.textDocumentSync).toBeDefined();
-    expect(response.result.capabilities.completionProvider).toBeDefined();
-    expect(response.result.capabilities.hoverProvider).toBe(true);
-  });
-
-  test('initialize with default server info', async () => {
-    const s = createTestServer();
-    s.start();
-
-    const response = await sendRequest(input, output, 'initialize', 1, {
-      capabilities: {},
-    });
-
-    expect(response.result.serverInfo.name).toBe('soleri-lsp');
-    expect(response.result.serverInfo.version).toBe('0.1.0');
-  });
-
-  test('initialize respects disabled capabilities', async () => {
-    const s = createTestServer({}, { completions: false, hover: false, codeActions: false });
-    s.start();
-
-    const response = await sendRequest(input, output, 'initialize', 1, {
-      capabilities: {},
-    });
-
-    expect(response.result.capabilities.completionProvider).toBeUndefined();
-    expect(response.result.capabilities.hoverProvider).toBeUndefined();
-    expect(response.result.capabilities.codeActionProvider).toBeUndefined();
-    // textDocumentSync always present
-    expect(response.result.capabilities.textDocumentSync).toBeDefined();
-  });
-
-  test('completion returns items', async () => {
-    const items: LspCompletionItem[] = [
-      { label: '@pattern', kind: 15, detail: 'Design pattern', insertText: '@pattern' },
-      { label: '@antipattern', kind: 15, detail: 'Anti-pattern' },
-    ];
-    const s = createTestServer({
-      onCompletion: async () => items,
-    });
-    s.start();
-
-    // Must initialize first
-    await sendRequest(input, output, 'initialize', 1, { capabilities: {} });
-
-    const response = await sendRequest(input, output, 'textDocument/completion', 2, {
-      textDocument: { uri: 'file:///test.ts' },
-      position: { line: 0, character: 1 },
-    });
-
-    expect(response.id).toBe(2);
-    expect(response.result).toHaveLength(2);
-    expect(response.result[0].label).toBe('@pattern');
-    expect(response.result[1].label).toBe('@antipattern');
-  });
-
-  test('completion returns empty when disabled', async () => {
-    const s = createTestServer(
-      { onCompletion: async () => [{ label: 'should-not-appear' }] },
-      { completions: false },
-    );
-    s.start();
-
-    const response = await sendRequest(input, output, 'textDocument/completion', 1, {
-      textDocument: { uri: 'file:///test.ts' },
-      position: { line: 0, character: 0 },
-    });
-
-    expect(response.result).toEqual([]);
-  });
-
-  test('hover returns documentation', async () => {
-    const hover: LspHover = {
-      contents: { kind: 'markdown', value: '# Pattern\nUse semantic tokens.' },
-    };
-    const s = createTestServer({
-      onHover: async () => hover,
-    });
-    s.start();
-
-    const response = await sendRequest(input, output, 'textDocument/hover', 1, {
-      textDocument: { uri: 'file:///test.ts' },
-      position: { line: 5, character: 10 },
-    });
-
-    expect(response.result.contents.kind).toBe('markdown');
-    expect(response.result.contents.value).toContain('semantic tokens');
-  });
-
-  test('hover returns null when no info', async () => {
-    const s = createTestServer({
-      onHover: async () => null,
-    });
-    s.start();
-
-    const response = await sendRequest(input, output, 'textDocument/hover', 1, {
-      textDocument: { uri: 'file:///test.ts' },
-      position: { line: 0, character: 0 },
-    });
-
-    expect(response.result).toBeNull();
-  });
-
-  test('diagnostics published on document open', async () => {
-    const diagnostics: LspDiagnostic[] = [
-      {
-        range: { start: { line: 0, character: 0 }, end: { line: 0, character: 10 } },
-        severity: 2,
-        source: 'soleri',
-        message: 'Hardcoded color detected',
-        code: 'no-raw-color',
-      },
-    ];
-    const s = createTestServer({
-      onDiagnostics: async () => diagnostics,
-    });
-    s.start();
-
-    // Send didOpen notification — this triggers diagnostics push
-    const promise = collectMessages(output, 1);
-    sendNotification(input, 'textDocument/didOpen', {
-      textDocument: { uri: 'file:///test.ts', text: 'color: #ff0000;' },
-    });
-
-    const [notification] = await promise;
-    expect(notification.method).toBe('textDocument/publishDiagnostics');
-    expect(notification.params.uri).toBe('file:///test.ts');
-    expect(notification.params.diagnostics).toHaveLength(1);
-    expect(notification.params.diagnostics[0].message).toBe('Hardcoded color detected');
-  });
-
-  test('diagnostics published on document change', async () => {
-    const s = createTestServer({
-      onDiagnostics: async (_uri, content) => {
-        if (content.includes('#')) {
-          return [
-            {
-              range: { start: { line: 0, character: 0 }, end: { line: 0, character: 7 } },
-              severity: 2,
-              message: 'Raw color',
-              source: 'soleri',
-            },
-          ];
-        }
-        return [];
-      },
-    });
-    s.start();
-
-    const promise = collectMessages(output, 1);
-    sendNotification(input, 'textDocument/didChange', {
-      textDocument: { uri: 'file:///test.css' },
-      contentChanges: [{ text: 'background: #000;' }],
-    });
-
-    const [notification] = await promise;
-    expect(notification.params.diagnostics).toHaveLength(1);
-    expect(notification.params.diagnostics[0].message).toBe('Raw color');
-  });
-
-  test('code actions returned when enabled', async () => {
-    const actions: LspCodeAction[] = [
-      {
-        title: 'Replace with semantic token',
-        kind: 'quickfix',
-        command: { title: 'Fix', command: 'soleri.replaceToken', arguments: ['bg-surface'] },
-      },
-    ];
-    const s = createTestServer({ onCodeAction: async () => actions }, { codeActions: true });
-    s.start();
-
-    const response = await sendRequest(input, output, 'textDocument/codeAction', 1, {
-      textDocument: { uri: 'file:///test.ts' },
-      range: { start: { line: 0, character: 0 }, end: { line: 0, character: 10 } },
-      context: { diagnostics: [] },
-    });
-
-    expect(response.result).toHaveLength(1);
-    expect(response.result[0].title).toBe('Replace with semantic token');
-    expect(response.result[0].command.command).toBe('soleri.replaceToken');
-  });
-
-  test('unknown method returns MethodNotFound', async () => {
-    const s = createTestServer();
-    s.start();
-
-    const response = await sendRequest(input, output, 'custom/unknownMethod', 99);
-
-    expect(response.error).toBeDefined();
-    expect(response.error.code).toBe(-32601);
-    expect(response.error.message).toContain('Method not found');
-  });
-
-  test('shutdown calls callback', async () => {
-    const onShutdown = vi.fn(async () => {});
-    const s = createTestServer({ onShutdown });
-    s.start();
-
-    const response = await sendRequest(input, output, 'shutdown', 1);
-
-    expect(response.result).toBeNull();
-    expect(onShutdown).toHaveBeenCalledTimes(1);
-  });
-
-  test('exit stops the server', async () => {
-    const s = createTestServer();
-    s.start();
-    expect(s.isRunning).toBe(true);
-
-    sendNotification(input, 'exit');
-
-    // Wait a tick for the notification to be processed
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    expect(s.isRunning).toBe(false);
-  });
-
-  test('notify sends notification to client', async () => {
-    const s = createTestServer();
-    s.start();
-
-    const promise = collectMessages(output, 1);
-    s.notify('custom/event', { data: 'test' });
-
-    const [notification] = await promise;
-    expect(notification.method).toBe('custom/event');
-    expect(notification.params.data).toBe('test');
-  });
-
-  test('publishDiagnostics sends proper notification', async () => {
-    const s = createTestServer();
-    s.start();
-
-    const promise = collectMessages(output, 1);
-    s.publishDiagnostics('file:///test.ts', [
-      {
-        range: { start: { line: 1, character: 0 }, end: { line: 1, character: 5 } },
-        severity: 1,
-        message: 'Error found',
-      },
-    ]);
-
-    const [notification] = await promise;
-    expect(notification.method).toBe('textDocument/publishDiagnostics');
-    expect(notification.params.uri).toBe('file:///test.ts');
-    expect(notification.params.diagnostics[0].severity).toBe(1);
-  });
-
-  test('handles multiple sequential messages', async () => {
-    let callCount = 0;
-    const s = createTestServer({
-      onCompletion: async () => {
-        callCount++;
-        return [{ label: `item-${callCount}` }];
-      },
-    });
-    s.start();
-
-    const r1 = await sendRequest(input, output, 'textDocument/completion', 1, {
-      textDocument: { uri: 'file:///a.ts' },
-      position: { line: 0, character: 0 },
-    });
-    expect(r1.result[0].label).toBe('item-1');
-
-    const r2 = await sendRequest(input, output, 'textDocument/completion', 2, {
-      textDocument: { uri: 'file:///b.ts' },
-      position: { line: 0, character: 0 },
-    });
-    expect(r2.result[0].label).toBe('item-2');
-  });
-
-  test('onDocumentChange called on didOpen', async () => {
-    const onDocumentChange = vi.fn(async () => {});
-    const s = createTestServer({ onDocumentChange }, { diagnostics: false });
-    s.start();
-
-    sendNotification(input, 'textDocument/didOpen', {
-      textDocument: { uri: 'file:///test.ts', text: 'const x = 1;' },
-    });
-
-    await vi.waitFor(() => expect(onDocumentChange).toHaveBeenCalledTimes(1));
-    expect(onDocumentChange).toHaveBeenCalledWith('file:///test.ts', expect.any(String));
-  });
-});

package/src/__tests__/memory-cross-project-ops.test.ts

@@ -1,248 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdirSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { createAgentRuntime } from '../runtime/runtime.js';
-import { createSemanticFacades } from '../runtime/facades/index.js';
-import type { AgentRuntime } from '../runtime/types.js';
-import type { OpDefinition } from '../facades/types.js';
-
-describe('Memory Cross-Project Ops', () => {
-  let runtime: AgentRuntime;
-  let ops: OpDefinition[];
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = join(tmpdir(), 'cross-project-test-' + Date.now());
-    mkdirSync(tempDir, { recursive: true });
-    runtime = createAgentRuntime({
-      agentId: 'test-cross-project',
-      vaultPath: ':memory:',
-      plansPath: join(tempDir, 'plans.json'),
-    });
-    ops = createSemanticFacades(runtime, 'test').flatMap(f => f.ops);
-  });
-
-  afterEach(() => {
-    runtime.close();
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  function findOp(name: string): OpDefinition {
-    const op = ops.find((o) => o.name === name);
-    if (!op) throw new Error(`Op "${name}" not found`);
-    return op;
-  }
-
-  describe('memory_promote_to_global', () => {
-    it('should add _global tag to a vault entry', async () => {
-      // Add an entry first
-      runtime.vault.add({
-        id: 'test-entry-1',
-        type: 'pattern',
-        domain: 'testing',
-        title: 'Test Pattern',
-        severity: 'suggestion',
-        description: 'A test pattern for cross-project sharing',
-        tags: ['test'],
-      });
-
-      const result = (await findOp('memory_promote_to_global').handler({
-        entryId: 'test-entry-1',
-      })) as { promoted: boolean; tags: string[] };
-
-      expect(result.promoted).toBe(true);
-      expect(result.tags).toContain('_global');
-      expect(result.tags).toContain('test');
-
-      // Verify the entry actually has the tag
-      const entry = runtime.vault.get('test-entry-1');
-      expect(entry!.tags).toContain('_global');
-    });
-
-    it('should return error for non-existent entry', async () => {
-      const result = (await findOp('memory_promote_to_global').handler({
-        entryId: 'nonexistent',
-      })) as { promoted: boolean; error: string };
-
-      expect(result.promoted).toBe(false);
-      expect(result.error).toContain('not found');
-    });
-
-    it('should not duplicate _global tag', async () => {
-      runtime.vault.add({
-        id: 'test-entry-2',
-        type: 'pattern',
-        domain: 'testing',
-        title: 'Already Global',
-        severity: 'suggestion',
-        description: 'Already promoted',
-        tags: ['_global'],
-      });
-
-      const result = (await findOp('memory_promote_to_global').handler({
-        entryId: 'test-entry-2',
-      })) as { promoted: boolean; message: string };
-
-      expect(result.promoted).toBe(false);
-      expect(result.message).toContain('already promoted');
-    });
-  });
-
-  describe('memory_configure', () => {
-    it('should configure cross-project settings', async () => {
-      // Register a project first
-      runtime.projectRegistry.register('/test/project-a', 'project-a');
-
-      const result = (await findOp('memory_configure').handler({
-        projectPath: '/test/project-a',
-        crossProjectEnabled: true,
-        extraPaths: ['/test/shared'],
-      })) as { configured: boolean; memoryConfig: Record<string, unknown> };
-
-      expect(result.configured).toBe(true);
-      expect(result.memoryConfig.crossProjectEnabled).toBe(true);
-      expect(result.memoryConfig.extraPaths).toEqual(['/test/shared']);
-    });
-
-    it('should return error for unregistered project', async () => {
-      const result = (await findOp('memory_configure').handler({
-        projectPath: '/unregistered/path',
-        crossProjectEnabled: true,
-      })) as { configured: boolean; error: string };
-
-      expect(result.configured).toBe(false);
-      expect(result.error).toContain('not registered');
-    });
-
-    it('should preserve existing metadata when updating config', async () => {
-      runtime.projectRegistry.register('/test/project-b', 'project-b', { custom: 'value' });
-
-      await findOp('memory_configure').handler({
-        projectPath: '/test/project-b',
-        crossProjectEnabled: false,
-      });
-
-      const project = runtime.projectRegistry.getByPath('/test/project-b');
-      expect(project!.metadata.custom).toBe('value');
-      expect((project!.metadata.memoryConfig as Record<string, unknown>).crossProjectEnabled).toBe(
-        false,
-      );
-    });
-  });
-
-  describe('memory_cross_project_search', () => {
-    it('should search current project memories', async () => {
-      runtime.projectRegistry.register('/test/current', 'current');
-
-      // Capture a memory
-      runtime.vault.captureMemory({
-        projectPath: '/test/current',
-        type: 'lesson',
-        context: 'testing',
-        summary: 'Always use vitest for TypeScript projects',
-        topics: ['testing', 'vitest'],
-        filesModified: [],
-        toolsUsed: [],
-      });
-
-      const result = (await findOp('memory_cross_project_search').handler({
-        query: 'vitest',
-        projectPath: '/test/current',
-      })) as { memories: Array<{ weight: number; source: string }>; totalResults: number };
-
-      expect(result.memories.length).toBeGreaterThanOrEqual(1);
-      expect(result.memories[0].weight).toBe(1.0);
-      expect(result.memories[0].source).toBe('current');
-    });
-
-    it('should include global entries in results', async () => {
-      runtime.projectRegistry.register('/test/current', 'current');
-
-      // Add a global entry
-      runtime.vault.add({
-        id: 'global-pattern',
-        type: 'pattern',
-        domain: 'testing',
-        title: 'Global Testing Pattern',
-        severity: 'suggestion',
-        description: 'A globally promoted testing pattern for vitest',
-        tags: ['_global', 'testing'],
-      });
-
-      const result = (await findOp('memory_cross_project_search').handler({
-        query: 'testing',
-        projectPath: '/test/current',
-      })) as { globalEntries: Array<{ weight: number; source: string }> };
-
-      expect(result.globalEntries.length).toBeGreaterThanOrEqual(1);
-      expect(result.globalEntries[0].weight).toBe(0.9);
-      expect(result.globalEntries[0].source).toBe('global');
-    });
-
-    it('should search linked project memories', async () => {
-      const projA = runtime.projectRegistry.register('/test/project-a', 'project-a');
-      const projB = runtime.projectRegistry.register('/test/project-b', 'project-b');
-      runtime.projectRegistry.link(projA.id, projB.id, 'related');
-
-      // Configure cross-project for project A
-      await findOp('memory_configure').handler({
-        projectPath: '/test/project-a',
-        crossProjectEnabled: true,
-      });
-
-      // Capture memory in project B
-      runtime.vault.captureMemory({
-        projectPath: '/test/project-b',
-        type: 'lesson',
-        context: 'architecture',
-        summary: 'Use facade pattern for clean separation',
-        topics: ['architecture', 'facade'],
-        filesModified: [],
-        toolsUsed: [],
-      });
-
-      const result = (await findOp('memory_cross_project_search').handler({
-        query: 'facade',
-        projectPath: '/test/project-a',
-      })) as {
-        linkedMemories: Array<{ weight: number; source: string; linkedProject: string }>;
-      };
-
-      expect(result.linkedMemories.length).toBeGreaterThanOrEqual(1);
-      expect(result.linkedMemories[0].weight).toBe(0.8);
-      expect(result.linkedMemories[0].source).toBe('linked');
-      expect(result.linkedMemories[0].linkedProject).toBe('/test/project-b');
-    });
-
-    it('should respect crossProjectEnabled=false', async () => {
-      const projA = runtime.projectRegistry.register('/test/disabled-a', 'disabled-a');
-      const projB = runtime.projectRegistry.register('/test/disabled-b', 'disabled-b');
-      runtime.projectRegistry.link(projA.id, projB.id, 'related');
-
-      // Explicitly disable cross-project
-      await findOp('memory_configure').handler({
-        projectPath: '/test/disabled-a',
-        crossProjectEnabled: false,
-      });
-
-      // Capture memory in project B
-      runtime.vault.captureMemory({
-        projectPath: '/test/disabled-b',
-        type: 'lesson',
-        context: 'testing',
-        summary: 'This should not appear in cross-project search',
-        topics: ['hidden'],
-        filesModified: [],
-        toolsUsed: [],
-      });
-
-      const result = (await findOp('memory_cross_project_search').handler({
-        query: 'hidden',
-        projectPath: '/test/disabled-a',
-      })) as { linkedMemories: unknown[] };
-
-      expect(result.linkedMemories).toEqual([]);
-    });
-  });
-});