alchemy 2.0.0-beta.36 → 2.0.0-beta.38

package/src/Agent/lsp/client.ts

@@ -1,293 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,317 +0,0 @@
-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;
-  });