alchemy-effect 0.5.0 → 0.6.2

package/src/Agent/lsp/client.ts

@@ -0,0 +1,293 @@
+import type { Subprocess } from "bun";
+import * as Effect from "effect/Effect";
+import * as HashMap from "effect/HashMap";
+import * as Option from "effect/Option";
+import * as PubSub from "effect/PubSub";
+import * as Ref from "effect/Ref";
+import * as S from "effect/Schema";
+import * as Stream from "effect/Stream";
+import { make as makeJsonRpc } from "./jsonrpc.ts";
+
+/**
+ * LSP Position (0-indexed line and character)
+ */
+export const Position = S.Struct({
+  line: S.Number,
+  character: S.Number,
+});
+export type Position = S.Schema.Type<typeof Position>;
+
+/**
+ * LSP Range (start and end positions)
+ */
+export const Range = S.Struct({
+  start: Position,
+  end: Position,
+});
+export type Range = S.Schema.Type<typeof Range>;
+
+/**
+ * LSP Diagnostic severity
+ */
+export const DiagnosticSeverity = {
+  Error: 1,
+  Warning: 2,
+  Information: 3,
+  Hint: 4,
+} as const;
+
+/**
+ * LSP Diagnostic
+ */
+export const Diagnostic = S.Struct({
+  range: Range,
+  severity: S.optional(S.Number),
+  message: S.String,
+  source: S.optional(S.String),
+  code: S.optional(S.Union([S.String, S.Number])),
+});
+export type Diagnostic = S.Schema.Type<typeof Diagnostic>;
+
+/**
+ * publishDiagnostics notification params
+ */
+const PublishDiagnosticsParams = S.Struct({
+  uri: S.String,
+  diagnostics: S.Array(Diagnostic),
+});
+
+/**
+ * A single LSP client connected to one server.
+ */
+export interface LSPClient {
+  readonly id: string;
+
+  /**
+   * Notify the server that a file has changed.
+   */
+  readonly notifyFileChanged: (
+    path: string,
+    content: string,
+  ) => Effect.Effect<void>;
+
+  /**
+   * Wait for diagnostics for a file with debouncing.
+   */
+  readonly waitForDiagnostics: (
+    path: string,
+    timeout?: number,
+  ) => Effect.Effect<Diagnostic[]>;
+
+  /**
+   * Get current diagnostics for a file.
+   */
+  readonly getDiagnostics: (path: string) => Effect.Effect<Diagnostic[]>;
+
+  /**
+   * Register a callback for when diagnostics are received.
+   */
+  readonly onDiagnostics: (
+    callback: (uri: string, diagnostics: Diagnostic[]) => Effect.Effect<void>,
+  ) => Effect.Effect<void>;
+
+  /**
+   * Shutdown the client.
+   */
+  readonly shutdown: Effect.Effect<void>;
+}
+
+/**
+ * Create an LSP client from a subprocess.
+ */
+export const makeLSPClient = (id: string, proc: Subprocess, root: string) =>
+  Effect.gen(function* () {
+    const rpc = yield* makeJsonRpc(proc);
+
+    // Diagnostics storage: uri -> Diagnostic[]
+    const diagnosticsMap = yield* Ref.make(
+      HashMap.empty<string, Diagnostic[]>(),
+    );
+
+    // PubSub for diagnostic events
+    const diagnosticsPubSub = yield* PubSub.unbounded<{ uri: string }>();
+
+    // Track open files and their versions
+    const openFiles = yield* Ref.make(HashMap.empty<string, number>());
+
+    // External diagnostic callbacks
+    const diagnosticCallbacks = yield* Ref.make<
+      Array<(uri: string, diagnostics: Diagnostic[]) => Effect.Effect<void>>
+    >([]);
+
+    // Handle publishDiagnostics notifications
+    yield* rpc.onNotification(
+      "textDocument/publishDiagnostics",
+      (params: unknown) =>
+        Effect.gen(function* () {
+          const decoded = yield* S.decodeUnknownEffect(
+            PublishDiagnosticsParams,
+          )(params).pipe(Effect.catch(() => Effect.succeed(null)));
+
+          if (!decoded) return;
+
+          // Convert readonly array to mutable for storage
+          const diagnostics = [...decoded.diagnostics] as Diagnostic[];
+
+          yield* Ref.update(diagnosticsMap, (m) =>
+            HashMap.set(m, decoded.uri, diagnostics),
+          );
+
+          yield* PubSub.publish(diagnosticsPubSub, { uri: decoded.uri });
+
+          // Call external callbacks
+          const callbacks = yield* Ref.get(diagnosticCallbacks);
+          yield* Effect.forEach(
+            callbacks,
+            (cb) => cb(decoded.uri, diagnostics),
+            { concurrency: "unbounded" },
+          ).pipe(Effect.catch(() => Effect.void));
+        }),
+    );
+
+    // LSP initialize handshake
+    yield* rpc.request("initialize", {
+      processId: process.pid,
+      rootUri: `file://${root}`,
+      capabilities: {
+        textDocument: {
+          synchronization: {
+            didOpen: true,
+            didChange: true,
+            willSave: false,
+            willSaveWaitUntil: false,
+            didSave: false,
+          },
+          publishDiagnostics: {
+            relatedInformation: true,
+          },
+        },
+      },
+    });
+
+    yield* rpc.notify("initialized", {});
+
+    return {
+      id,
+
+      notifyFileChanged: (path: string, content: string) =>
+        Effect.gen(function* () {
+          const uri = `file://${path}`;
+          const maybeVersion = yield* Ref.get(openFiles).pipe(
+            Effect.map((m) => HashMap.get(m, path)),
+          );
+
+          if (Option.isNone(maybeVersion)) {
+            // File not open yet, send didOpen
+            yield* rpc.notify("textDocument/didOpen", {
+              textDocument: {
+                uri,
+                languageId: getLanguageId(path),
+                version: 0,
+                text: content,
+              },
+            });
+            yield* Ref.update(openFiles, (m) => HashMap.set(m, path, 0));
+          } else {
+            // File already open, send didChange with incremented version
+            const newVersion = maybeVersion.value + 1;
+            yield* rpc.notify("textDocument/didChange", {
+              textDocument: { uri, version: newVersion },
+              contentChanges: [{ text: content }],
+            });
+            yield* Ref.update(openFiles, (m) =>
+              HashMap.set(m, path, newVersion),
+            );
+          }
+        }),
+
+      waitForDiagnostics: (path: string, timeout = 3000) =>
+        Effect.gen(function* () {
+          const uri = `file://${path}`;
+
+          // Wait for diagnostics with 150ms debounce, scoped
+          yield* Effect.scoped(
+            Effect.gen(function* () {
+              const subscription = yield* PubSub.subscribe(diagnosticsPubSub);
+              yield* Stream.fromSubscription(subscription).pipe(
+                Stream.filter((e) => e.uri === uri),
+                Stream.debounce(150),
+                Stream.take(1),
+                Stream.runDrain,
+              );
+            }),
+          ).pipe(
+            Effect.timeout(timeout),
+            Effect.catch(() => Effect.void),
+          );
+
+          // Return diagnostics for this file
+          const diags = yield* Ref.get(diagnosticsMap).pipe(
+            Effect.map((m) => HashMap.get(m, uri)),
+          );
+
+          return Option.getOrElse(diags, () => [] as Diagnostic[]);
+        }),
+
+      getDiagnostics: (path: string) =>
+        Effect.gen(function* () {
+          const uri = `file://${path}`;
+          const diags = yield* Ref.get(diagnosticsMap).pipe(
+            Effect.map((m) => HashMap.get(m, uri)),
+          );
+          return Option.getOrElse(diags, () => []);
+        }),
+
+      onDiagnostics: (
+        callback: (
+          uri: string,
+          diagnostics: Diagnostic[],
+        ) => Effect.Effect<void>,
+      ) => Ref.update(diagnosticCallbacks, (cbs) => [...cbs, callback]),
+
+      shutdown: Effect.gen(function* () {
+        yield* rpc
+          .request("shutdown", null)
+          .pipe(Effect.catch(() => Effect.void));
+        yield* rpc.notify("exit", null);
+        yield* rpc.shutdown;
+      }),
+    };
+  });
+
+/**
+ * Get LSP language ID from file path.
+ */
+const getLanguageId = (path: string): string => {
+  const ext = path.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "ts":
+    case "mts":
+    case "cts":
+      return "typescript";
+    case "tsx":
+    case "mtsx":
+    case "ctsx":
+      return "typescriptreact";
+    case "js":
+    case "mjs":
+    case "cjs":
+      return "javascript";
+    case "jsx":
+      return "javascriptreact";
+    case "json":
+      return "json";
+    case "vue":
+      return "vue";
+    case "svelte":
+      return "svelte";
+    case "astro":
+      return "astro";
+    default:
+      return "plaintext";
+  }
+};

package/src/Agent/lsp/diagnostics.ts

@@ -0,0 +1,64 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { DiagnosticSeverity, type Diagnostic } from "./client.ts";
+import { LSPManager } from "./manager.ts";
+
+const MAX_DIAGNOSTICS_PER_FILE = 10;
+
+/**
+ * Get diagnostics from LSP if available, otherwise return empty array.
+ */
+export const getDiagnosticsIfAvailable = (
+  filePath: string,
+  content: string,
+): Effect.Effect<Diagnostic[]> =>
+  Effect.serviceOption(LSPManager).pipe(
+    Effect.flatMap((maybeManager) => {
+      if (Option.isNone(maybeManager)) {
+        return Effect.succeed([] as Diagnostic[]);
+      }
+      const manager = maybeManager.value;
+      return manager
+        .notifyFileChanged(filePath, content)
+        .pipe(Effect.andThen(manager.waitForDiagnostics(filePath)));
+    }),
+    Effect.catch(() => Effect.succeed([] as Diagnostic[])),
+  );
+
+/**
+ * Format a single diagnostic for display.
+ */
+export const formatDiagnostic = (d: Diagnostic): string => {
+  const severityMap: Record<number, string> = {
+    [DiagnosticSeverity.Error]: "ERROR",
+    [DiagnosticSeverity.Warning]: "WARN",
+    [DiagnosticSeverity.Information]: "INFO",
+    [DiagnosticSeverity.Hint]: "HINT",
+  };
+  const severity = severityMap[d.severity ?? DiagnosticSeverity.Error];
+  const line = d.range.start.line + 1;
+  const col = d.range.start.character + 1;
+  return `${severity} [${line}:${col}] ${d.message}`;
+};
+
+/**
+ * Format diagnostics for display (matching opencode format).
+ * Only shows errors, limits output, and wraps in XML tags.
+ */
+export const formatDiagnostics = (diagnostics: Diagnostic[]): string => {
+  const errors = diagnostics.filter(
+    (d) => d.severity === DiagnosticSeverity.Error,
+  );
+
+  if (errors.length === 0) {
+    return "";
+  }
+
+  const limited = errors.slice(0, MAX_DIAGNOSTICS_PER_FILE);
+  const suffix =
+    errors.length > MAX_DIAGNOSTICS_PER_FILE
+      ? `\n... and ${errors.length - MAX_DIAGNOSTICS_PER_FILE} more`
+      : "";
+
+  return `This file has errors, please fix\n<file_diagnostics>\n${limited.map(formatDiagnostic).join("\n")}${suffix}\n</file_diagnostics>`;
+};

package/src/Agent/lsp/jsonrpc.ts

@@ -0,0 +1,317 @@
+import type { Subprocess } from "bun";
+import * as Data from "effect/Data";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import * as HashMap from "effect/HashMap";
+import * as Option from "effect/Option";
+import * as Ref from "effect/Ref";
+import * as Stream from "effect/Stream";
+
+/**
+ * JSON-RPC 2.0 message types
+ */
+export interface JsonRpcRequest {
+  jsonrpc: "2.0";
+  id: number;
+  method: string;
+  params?: unknown;
+}
+
+export interface JsonRpcNotification {
+  jsonrpc: "2.0";
+  method: string;
+  params?: unknown;
+}
+
+export interface JsonRpcResponse {
+  jsonrpc: "2.0";
+  id: number;
+  result?: unknown;
+  error?: {
+    code: number;
+    message: string;
+    data?: unknown;
+  };
+}
+
+export type JsonRpcMessage =
+  | JsonRpcRequest
+  | JsonRpcNotification
+  | JsonRpcResponse;
+
+/**
+ * Error from JSON-RPC protocol.
+ */
+export class JsonRpcProtocolError extends Data.TaggedError(
+  "JsonRpcProtocolError",
+)<{
+  readonly code: number;
+  readonly message: string;
+  readonly data?: unknown;
+}> {}
+
+/**
+ * Error parsing JSON-RPC messages from stream.
+ */
+export class JsonRpcParseError extends Data.TaggedError("JsonRpcParseError")<{
+  readonly cause: unknown;
+}> {}
+
+/**
+ * Encode a JSON-RPC message with LSP wire format headers.
+ * Format: Content-Length: <length>\r\n\r\n<json>
+ */
+export const encodeMessage = (msg: JsonRpcMessage): Uint8Array => {
+  const json = JSON.stringify(msg);
+  const body = new TextEncoder().encode(json);
+  const header = `Content-Length: ${body.byteLength}\r\n\r\n`;
+  const headerBytes = new TextEncoder().encode(header);
+
+  const result = new Uint8Array(headerBytes.length + body.length);
+  result.set(headerBytes);
+  result.set(body, headerBytes.length);
+  return result;
+};
+
+/**
+ * Parse LSP messages from a byte buffer.
+ * Returns parsed messages and remaining buffer.
+ * Works with bytes to correctly handle Content-Length (which is in bytes, not characters).
+ */
+export const parseBuffer = (
+  buffer: Uint8Array,
+): { messages: JsonRpcMessage[]; remaining: Uint8Array<ArrayBuffer> } => {
+  const messages: JsonRpcMessage[] = [];
+  let offset = 0;
+  const decoder = new TextDecoder();
+
+  while (offset < buffer.length) {
+    // Look for \r\n\r\n header terminator
+    const headerEnd = findHeaderEnd(buffer, offset);
+    if (headerEnd === -1) break;
+
+    const headerPart = decoder.decode(buffer.subarray(offset, headerEnd));
+    const match = /Content-Length:\s*(\d+)/i.exec(headerPart);
+    if (!match) break;
+
+    const contentLength = parseInt(match[1], 10);
+    const bodyStart = headerEnd + 4; // Skip \r\n\r\n
+    const bodyEnd = bodyStart + contentLength;
+
+    // Check if we have the full body (in bytes)
+    if (buffer.length < bodyEnd) break;
+
+    const body = decoder.decode(buffer.subarray(bodyStart, bodyEnd));
+    try {
+      const parsed = JSON.parse(body) as JsonRpcMessage;
+      messages.push(parsed);
+    } catch {
+      // Invalid JSON, skip this message
+    }
+
+    offset = bodyEnd;
+  }
+
+  // Create a new array for remaining bytes to ensure ArrayBuffer type
+  const remainingLength = buffer.length - offset;
+  const remaining = new Uint8Array(remainingLength);
+  remaining.set(buffer.subarray(offset));
+
+  return { messages, remaining };
+};
+
+/**
+ * Find the index of \r\n\r\n in a byte array starting from offset.
+ */
+const findHeaderEnd = (buffer: Uint8Array, offset: number): number => {
+  const CR = 13; // \r
+  const LF = 10; // \n
+  for (let i = offset; i < buffer.length - 3; i++) {
+    if (
+      buffer[i] === CR &&
+      buffer[i + 1] === LF &&
+      buffer[i + 2] === CR &&
+      buffer[i + 3] === LF
+    ) {
+      return i;
+    }
+  }
+  return -1;
+};
+
+/**
+ * Concatenate two Uint8Arrays.
+ */
+const concatBytes = (a: Uint8Array, b: Uint8Array): Uint8Array<ArrayBuffer> => {
+  const result = new Uint8Array(a.length + b.length);
+  result.set(a);
+  result.set(b, a.length);
+  return result;
+};
+
+/**
+ * Parse LSP messages from a ReadableStream.
+ * Uses Stream.mapAccum to maintain buffer state across chunks.
+ */
+const parseMessages = (stdout: ReadableStream<Uint8Array>) =>
+  Stream.fromReadableStream({
+    evaluate: () => stdout,
+    onError: (cause) => new JsonRpcParseError({ cause }),
+  }).pipe(
+    Stream.mapAccum(
+      () => new Uint8Array(0) as Uint8Array<ArrayBuffer>,
+      (buffer, chunk): [Uint8Array<ArrayBuffer>, JsonRpcMessage[]] => {
+        const combined = concatBytes(buffer, chunk);
+        const { messages, remaining } = parseBuffer(combined);
+        return [remaining, messages];
+      },
+    ),
+  );
+
+/**
+ * A JSON-RPC connection over stdio.
+ */
+export interface JsonRpcConnection {
+  /**
+   * Send a request and wait for a response.
+   */
+  readonly request: <A>(
+    method: string,
+    params: unknown,
+  ) => Effect.Effect<A, JsonRpcProtocolError>;
+
+  /**
+   * Send a notification (no response expected).
+   */
+  readonly notify: (method: string, params: unknown) => Effect.Effect<void>;
+
+  /**
+   * Register a handler for server notifications.
+   */
+  readonly onNotification: (
+    method: string,
+    handler: (params: unknown) => Effect.Effect<void>,
+  ) => Effect.Effect<void>;
+
+  /**
+   * Shutdown the connection.
+   */
+  readonly shutdown: Effect.Effect<void>;
+}
+
+/**
+ * Create a JSON-RPC connection from a subprocess.
+ */
+export const make = (proc: Subprocess) =>
+  Effect.gen(function* () {
+    // Pending requests: id -> Deferred<response>
+    const pending = yield* Ref.make(
+      HashMap.empty<number, Deferred.Deferred<unknown, JsonRpcProtocolError>>(),
+    );
+    const nextId = yield* Ref.make(0);
+
+    // Notification handlers
+    const notificationHandlers = yield* Ref.make(
+      HashMap.empty<string, (params: unknown) => Effect.Effect<void>>(),
+    );
+
+    // Background fiber reading stdout
+    const reader = yield* parseMessages(
+      proc.stdout as ReadableStream<Uint8Array>,
+    ).pipe(
+      Stream.runForEach((msg) =>
+        Effect.gen(function* () {
+          if ("id" in msg && ("result" in msg || "error" in msg)) {
+            // Response to our request
+            const response = msg as JsonRpcResponse;
+            const maybeDeferred = yield* Ref.get(pending).pipe(
+              Effect.map((m) => HashMap.get(m, response.id)),
+            );
+
+            if (Option.isSome(maybeDeferred)) {
+              if (response.error) {
+                yield* Deferred.fail(
+                  maybeDeferred.value,
+                  new JsonRpcProtocolError({
+                    code: response.error.code,
+                    message: response.error.message,
+                    data: response.error.data,
+                  }),
+                );
+              } else {
+                yield* Deferred.succeed(maybeDeferred.value, response.result);
+              }
+              // Clean up the pending request
+              yield* Ref.update(pending, (m) => HashMap.remove(m, response.id));
+            }
+          } else if ("method" in msg && !("id" in msg)) {
+            // Notification from server
+            const notification = msg as JsonRpcNotification;
+            const maybeHandler = yield* Ref.get(notificationHandlers).pipe(
+              Effect.map((m) => HashMap.get(m, notification.method)),
+            );
+
+            if (Option.isSome(maybeHandler)) {
+              yield* maybeHandler.value(notification.params);
+            }
+          }
+        }),
+      ),
+      Effect.catch((e) => Effect.logWarning(`JSON-RPC reader error: ${e}`)),
+      Effect.forkDetach,
+    );
+
+    const connection: JsonRpcConnection = {
+      request: <A>(method: string, params: unknown) =>
+        Effect.gen(function* () {
+          const id = yield* Ref.getAndUpdate(nextId, (n) => n + 1);
+          const deferred = yield* Deferred.make<A, JsonRpcProtocolError>();
+          yield* Ref.update(pending, (m) =>
+            HashMap.set(
+              m,
+              id,
+              deferred as Deferred.Deferred<unknown, JsonRpcProtocolError>,
+            ),
+          );
+
+          yield* Effect.sync(() => {
+            const msg: JsonRpcRequest = { jsonrpc: "2.0", id, method, params };
+            const stdin = proc.stdin;
+            if (stdin && typeof stdin === "object" && "write" in stdin) {
+              (stdin as { write: (data: Uint8Array) => void }).write(
+                encodeMessage(msg),
+              );
+            }
+          });
+
+          return yield* Deferred.await(deferred);
+        }),
+
+      notify: (method: string, params: unknown) =>
+        Effect.sync(() => {
+          const msg: JsonRpcNotification = { jsonrpc: "2.0", method, params };
+          const stdin = proc.stdin;
+          if (stdin && typeof stdin === "object" && "write" in stdin) {
+            (stdin as { write: (data: Uint8Array) => void }).write(
+              encodeMessage(msg),
+            );
+          }
+        }),
+
+      onNotification: (
+        method: string,
+        handler: (params: unknown) => Effect.Effect<void>,
+      ) =>
+        Ref.update(notificationHandlers, (m) =>
+          HashMap.set(m, method, handler),
+        ),
+
+      shutdown: Effect.gen(function* () {
+        yield* Fiber.interrupt(reader);
+        yield* Effect.sync(() => proc.kill());
+      }),
+    };
+
+    return connection;
+  });