@arnilo/prism-tools 0.0.0-stage → 0.13.1

package/coding/src/agent/language/client.ts

@@ -0,0 +1,429 @@
+/**
+ * Minimal JSON-RPC LSP client over child stdio (LSP 3.17 framing).
+ * Lazy start; bounded pending requests, message bytes, timeout, restart budget.
+ */
+
+import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
+import { buildChildEnv, DEFAULT_CHILD_ENV_INHERIT } from "../env.js";
+import { encodeLspFrame, LspFrameError, LspFrameReader } from "./framing.js";
+import { LanguageIntelligenceError, type ResolvedLanguageIntelligenceLimits } from "./types.js";
+
+export interface LspServerSpec {
+  readonly name: string;
+  readonly command: string;
+  readonly args: readonly string[];
+  readonly env?: Readonly<Record<string, string>>;
+  readonly cwd: string;
+  readonly rootUri: string;
+}
+
+type Pending = {
+  readonly resolve: (value: unknown) => void;
+  readonly reject: (error: Error) => void;
+  readonly timer: ReturnType<typeof setTimeout>;
+  readonly abortHandler?: () => void;
+  readonly signal?: AbortSignal;
+};
+
+/** Socket-loss codes Node reports when the peer dies between the writable check and the write. */
+const SOCKET_LOSS_CODES = new Set(["EPIPE", "ECONNRESET", "ERR_STREAM_DESTROYED", "ERR_STREAM_WRITE_AFTER_END"]);
+
+/**
+ * A write to a server that died is a server error, not an unknown transport crash: hosts switch on
+ * LanguageIntelligenceError codes, and an unclassified socket error escapes as an uncaught `write
+ * EPIPE` (plan 071 Task 13). Typed errors and unrelated failures pass through unchanged.
+ */
+function classifySocketLoss(error: unknown, serverName: string): Error {
+  if (error instanceof LanguageIntelligenceError) return error;
+  const code = typeof error === "object" && error !== null && "code" in error ? error.code : undefined;
+  if (typeof code === "string" && SOCKET_LOSS_CODES.has(code)) {
+    return new LanguageIntelligenceError("ERR_PRISM_LSP_SERVER", `LSP server ${serverName} stdin write failed (${code})`);
+  }
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+export class LspClient {
+  private child: ChildProcessWithoutNullStreams | undefined;
+  private reader: LspFrameReader;
+  private nextId = 1;
+  private pending = new Map<number, Pending>();
+  private startPromise: Promise<void> | undefined;
+  private disposed = false;
+  private shuttingDown = false;
+  private capabilities: Record<string, unknown> = {};
+  /** file URI → latest diagnostics payload from publishDiagnostics */
+  readonly diagnosticsByUri = new Map<string, unknown>();
+  /** file URI → monotonic document version (didOpen=1, each didChange += 1) */
+  readonly documentVersions = new Map<string, number>();
+  /** file URI → last pull-diagnostic resultId (textDocument/diagnostic) */
+  readonly pullResultIds = new Map<string, string>();
+  private readonly onUnexpectedExit: () => void;
+
+  constructor(
+    readonly spec: LspServerSpec,
+    private readonly limits: ResolvedLanguageIntelligenceLimits,
+    hooks?: { onUnexpectedExit?: () => void },
+  ) {
+    this.reader = new LspFrameReader(limits.maxMessageBytes);
+    this.onUnexpectedExit = hooks?.onUnexpectedExit ?? (() => {});
+  }
+
+  get started(): boolean {
+    return this.child !== undefined && !this.disposed;
+  }
+
+  async ensureStarted(signal?: AbortSignal): Promise<void> {
+    if (this.disposed) {
+      throw new LanguageIntelligenceError("ERR_PRISM_LSP_SERVER", `LSP server ${this.spec.name} is disposed`);
+    }
+    if (this.child) return;
+    if (!this.startPromise) {
+      this.startPromise = this.spawnAndInitialize(signal).finally(() => {
+        this.startPromise = undefined;
+      });
+    }
+    await this.startPromise;
+  }
+
+  async request(method: string, params: unknown, signal?: AbortSignal): Promise<unknown> {
+    await this.ensureStarted(signal);
+    if (this.pending.size >= this.limits.maxPendingRequests) {
+      throw new LanguageIntelligenceError("ERR_PRISM_LSP_LIMIT", `LSP pending requests exceed ${this.limits.maxPendingRequests}`);
+    }
+    const id = this.nextId++;
+    const payload = { jsonrpc: "2.0", id, method, params };
+    return new Promise<unknown>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        cleanupAbort();
+        reject(
+          new LanguageIntelligenceError("ERR_PRISM_LSP_TIMEOUT", `LSP request ${method} timed out after ${this.limits.requestTimeoutMs}ms`),
+        );
+      }, this.limits.requestTimeoutMs);
+
+      const abortHandler = () => {
+        this.pending.delete(id);
+        clearTimeout(timer);
+        reject(new LanguageIntelligenceError("ERR_PRISM_LSP_TIMEOUT", "LSP request aborted"));
+      };
+      const cleanupAbort = () => {
+        if (signal && abortHandler) signal.removeEventListener("abort", abortHandler);
+      };
+
+      if (signal) {
+        if (signal.aborted) {
+          clearTimeout(timer);
+          reject(new LanguageIntelligenceError("ERR_PRISM_LSP_TIMEOUT", "LSP request aborted"));
+          return;
+        }
+        signal.addEventListener("abort", abortHandler, { once: true });
+      }
+
+      this.pending.set(id, { resolve, reject, timer, abortHandler, signal });
+      try {
+        this.write(payload);
+      } catch (error) {
+        this.pending.delete(id);
+        clearTimeout(timer);
+        cleanupAbort();
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+
+  notify(method: string, params: unknown): void {
+    if (!this.child) return;
+    this.write({ jsonrpc: "2.0", method, params });
+  }
+
+  /**
+   * Full-content textDocument/didChange (LSP 3.17; protocol-valid, no diff
+   * engine needed). Monotonic version: didOpen stamps 1, each didChange
+   * increments. No-op when the document was never opened.
+   */
+  didChange(uri: string, text: string): void {
+    const version = (this.documentVersions.get(uri) ?? 0) + 1;
+    this.documentVersions.set(uri, version);
+    this.notify("textDocument/didChange", {
+      textDocument: { uri, version },
+      contentChanges: [{ text }],
+    });
+  }
+
+  /** true when the server advertises textDocument/diagnostic (pull diagnostics). */
+  hasPullDiagnostics(): boolean {
+    const provider = this.capabilities.diagnosticProvider;
+    if (!provider || provider === false) return false;
+    return true;
+  }
+
+  /**
+   * Pull diagnostics for one opened document (textDocument/diagnostic) with
+   * resultId reuse: `kind: "full"` replaces the set, `kind: "unchanged"`
+   * reuses the previous payload. Returns the version at request time so the
+   * caller can drop stale responses. Falls back to the push cache when the
+   * server has no pull support.
+   */
+  async pullDiagnostics(
+    uri: string,
+    signal?: AbortSignal,
+  ): Promise<{
+    kind: "full" | "unchanged";
+    diagnostics: unknown;
+    resultId?: string;
+    version: number;
+  }> {
+    const version = this.documentVersions.get(uri) ?? 1;
+    if (!this.hasPullDiagnostics()) {
+      return { kind: "full", diagnostics: this.diagnosticsByUri.get(uri) ?? [], version };
+    }
+    const previousResultId = this.pullResultIds.get(uri);
+    const result = (await this.request(
+      "textDocument/diagnostic",
+      { textDocument: { uri }, ...(previousResultId === undefined ? {} : { previousResultId }) },
+      signal,
+    )) as { kind?: string; items?: unknown; resultId?: string } | undefined;
+    if (!result || typeof result !== "object") {
+      return { kind: "full", diagnostics: this.diagnosticsByUri.get(uri) ?? [], version };
+    }
+    if (result.kind === "unchanged") {
+      const cached = this.diagnosticsByUri.get(uri) ?? [];
+      if (typeof result.resultId === "string") this.pullResultIds.set(uri, result.resultId);
+      return { kind: "unchanged", diagnostics: cached, resultId: result.resultId, version };
+    }
+    const items = Array.isArray(result.items) ? result.items : [];
+    this.diagnosticsByUri.set(uri, items);
+    if (typeof result.resultId === "string") this.pullResultIds.set(uri, result.resultId);
+    return { kind: "full", diagnostics: items, resultId: result.resultId, version };
+  }
+
+  hasCapability(key: string): boolean {
+    return this.capabilities[key] !== undefined && this.capabilities[key] !== false;
+  }
+
+  async dispose(): Promise<void> {
+    this.disposed = true;
+    this.shuttingDown = true;
+    this.rejectAll(new LanguageIntelligenceError("ERR_PRISM_LSP_SERVER", `LSP server ${this.spec.name} disposed`));
+    const child = this.child;
+    this.child = undefined;
+    if (!child) return;
+    try {
+      child.stdin.end();
+    } catch {
+      /* ignore */
+    }
+    if (!child.killed) {
+      child.kill("SIGTERM");
+    }
+    await new Promise<void>((resolve) => {
+      if (child.exitCode !== null) {
+        resolve();
+        return;
+      }
+      const t = setTimeout(() => {
+        child.kill("SIGKILL");
+        resolve();
+      }, 2_000);
+      child.once("exit", () => {
+        clearTimeout(t);
+        resolve();
+      });
+    });
+  }
+
+  private write(message: unknown): void {
+    if (!this.child?.stdin.writable) {
+      throw new LanguageIntelligenceError("ERR_PRISM_LSP_SERVER", `LSP server ${this.spec.name} stdin closed`);
+    }
+    const frame = encodeLspFrame(message);
+    if (frame.length > this.limits.maxMessageBytes + 64) {
+      // header overhead small; body already sized by JSON
+      throw new LanguageIntelligenceError("ERR_PRISM_LSP_LIMIT", "Outgoing LSP frame exceeds message byte cap");
+    }
+    try {
+      this.child.stdin.write(frame);
+    } catch (error) {
+      // Some platforms throw the socket loss synchronously instead of emitting it; both shapes are
+      // the same server error to a host.
+      throw classifySocketLoss(error, this.spec.name);
+    }
+  }
+
+  private async spawnAndInitialize(signal?: AbortSignal): Promise<void> {
+    if (signal?.aborted) {
+      throw new LanguageIntelligenceError("ERR_PRISM_LSP_TIMEOUT", "LSP start aborted");
+    }
+    this.reader = new LspFrameReader(this.limits.maxMessageBytes);
+    const child = spawn(this.spec.command, [...this.spec.args], {
+      cwd: this.spec.cwd,
+      env: buildChildEnv({ inherit: DEFAULT_CHILD_ENV_INHERIT, set: this.spec.env }), // allow-list; never pass process.env through
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true,
+    });
+    this.child = child;
+
+    child.stdout.on("data", (chunk: Buffer) => {
+      try {
+        for (const msg of this.reader.push(chunk)) this.onMessage(msg);
+      } catch (error) {
+        this.failTransport(error);
+      }
+    });
+    child.stdin.on("error", (error) => {
+      // The peer's death lands here, not in the write's call stack: Node reports the failed pipe
+      // write asynchronously on the socket (which still reads as `writable`). Reject pending
+      // requests with the typed server error and let the exit handler do the restart accounting —
+      // disposing here would skip onUnexpectedExit and the restart budget would never trip.
+      this.rejectAll(classifySocketLoss(error, this.spec.name));
+    });
+    child.stderr.on("data", () => {
+      /* discard; hosts can redirect via env if needed */
+    });
+    child.on("error", (error) => {
+      this.failTransport(new LanguageIntelligenceError("ERR_PRISM_LSP_SERVER", `LSP spawn failed: ${error.message}`));
+    });
+    child.on("exit", (code, signalName) => {
+      if (this.disposed || this.shuttingDown) return;
+      this.child = undefined;
+      this.rejectAll(
+        new LanguageIntelligenceError("ERR_PRISM_LSP_SERVER", `LSP server ${this.spec.name} exited (code=${code}, signal=${signalName})`),
+      );
+      this.onUnexpectedExit();
+    });
+
+    try {
+      const initResult = (await this.requestUnlocked(
+        "initialize",
+        {
+          processId: process.pid,
+          rootUri: this.spec.rootUri,
+          capabilities: {
+            workspace: { applyEdit: true },
+            textDocument: {
+              hover: { contentFormat: ["plaintext", "markdown"] },
+              publishDiagnostics: {},
+              diagnostic: { dynamicRegistration: false },
+            },
+          },
+          workspaceFolders: [{ uri: this.spec.rootUri, name: "workspace" }],
+        },
+        signal,
+      )) as { capabilities?: Record<string, unknown> };
+
+      this.capabilities = initResult?.capabilities ?? {};
+      this.notify("initialized", {});
+    } catch (error) {
+      this.shuttingDown = true;
+      this.child = undefined;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+        /* ignore */
+      }
+      throw error;
+    }
+  }
+
+  /** Internal request used during initialize before ensureStarted recursion. */
+  private requestUnlocked(method: string, params: unknown, signal?: AbortSignal): Promise<unknown> {
+    if (this.pending.size >= this.limits.maxPendingRequests) {
+      throw new LanguageIntelligenceError("ERR_PRISM_LSP_LIMIT", `LSP pending requests exceed ${this.limits.maxPendingRequests}`);
+    }
+    const id = this.nextId++;
+    const payload = { jsonrpc: "2.0", id, method, params };
+    return new Promise<unknown>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        cleanupAbort();
+        reject(
+          new LanguageIntelligenceError("ERR_PRISM_LSP_TIMEOUT", `LSP request ${method} timed out after ${this.limits.requestTimeoutMs}ms`),
+        );
+      }, this.limits.requestTimeoutMs);
+
+      const abortHandler = () => {
+        this.pending.delete(id);
+        clearTimeout(timer);
+        reject(new LanguageIntelligenceError("ERR_PRISM_LSP_TIMEOUT", "LSP request aborted"));
+      };
+      const cleanupAbort = () => {
+        if (signal) signal.removeEventListener("abort", abortHandler);
+      };
+
+      if (signal) {
+        if (signal.aborted) {
+          clearTimeout(timer);
+          reject(new LanguageIntelligenceError("ERR_PRISM_LSP_TIMEOUT", "LSP request aborted"));
+          return;
+        }
+        signal.addEventListener("abort", abortHandler, { once: true });
+      }
+
+      this.pending.set(id, { resolve, reject, timer, abortHandler, signal });
+      try {
+        this.write(payload);
+      } catch (error) {
+        this.pending.delete(id);
+        clearTimeout(timer);
+        cleanupAbort();
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+
+  private onMessage(msg: unknown): void {
+    if (!msg || typeof msg !== "object") {
+      throw new LspFrameError("ERR_PRISM_LSP_FRAMING", "LSP message is not an object");
+    }
+    const m = msg as {
+      id?: number | string;
+      method?: string;
+      params?: unknown;
+      result?: unknown;
+      error?: { message?: string; code?: number };
+    };
+
+    if (m.method && m.id === undefined) {
+      if (m.method === "textDocument/publishDiagnostics" && m.params && typeof m.params === "object") {
+        const p = m.params as { uri?: string; diagnostics?: unknown };
+        if (typeof p.uri === "string") this.diagnosticsByUri.set(p.uri, p.diagnostics ?? []);
+      }
+      return;
+    }
+
+    if (m.id === undefined) return;
+    const id = typeof m.id === "number" ? m.id : Number(m.id);
+    const pending = this.pending.get(id);
+    if (!pending) return;
+    this.pending.delete(id);
+    clearTimeout(pending.timer);
+    if (pending.signal && pending.abortHandler) {
+      pending.signal.removeEventListener("abort", pending.abortHandler);
+    }
+    if (m.error) {
+      pending.reject(new LanguageIntelligenceError("ERR_PRISM_LSP_SERVER", m.error.message ?? `LSP error code ${m.error.code}`));
+      return;
+    }
+    pending.resolve(m.result);
+  }
+
+  private failTransport(error: unknown): void {
+    const err =
+      error instanceof LanguageIntelligenceError
+        ? error
+        : error instanceof LspFrameError
+          ? new LanguageIntelligenceError(error.code, error.message)
+          : new LanguageIntelligenceError("ERR_PRISM_LSP_FRAMING", error instanceof Error ? error.message : String(error));
+    this.rejectAll(err);
+    void this.dispose();
+  }
+
+  private rejectAll(error: Error): void {
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      if (p.signal && p.abortHandler) p.signal.removeEventListener("abort", p.abortHandler);
+      p.reject(error);
+    }
+    this.pending.clear();
+  }
+}

package/coding/src/agent/language/framing.ts

@@ -0,0 +1,190 @@
+/**
+ * LSP 3.17 Content-Length framing over stdio (JSON-RPC body).
+ * No vscode-languageserver-protocol dependency.
+ */
+
+export type LspFrameErrorCode = "ERR_PRISM_LSP_FRAMING" | "ERR_PRISM_LSP_LIMIT";
+
+export class LspFrameError extends Error {
+  readonly code: LspFrameErrorCode;
+  constructor(code: LspFrameErrorCode, message: string) {
+    super(message);
+    this.name = "LspFrameError";
+    this.code = code;
+  }
+}
+
+/** Encode one JSON-RPC message as an LSP frame. */
+export function encodeLspFrame(message: unknown): Buffer {
+  const body = Buffer.from(JSON.stringify(message), "utf8");
+  const header = `Content-Length: ${body.length}\r\n\r\n`;
+  return Buffer.concat([Buffer.from(header, "ascii"), body]);
+}
+
+/**
+ * Incremental Content-Length frame reader.
+ * Rejects malformed headers, non-decimal Content-Length, and oversized bodies.
+ */
+export class LspFrameReader {
+  // ponytail: chunk-array accumulator — O(1) append per push, no whole-buffer re-concat
+  // (the 0.2.4 `this.buf = Buffer.concat([this.buf, chunk])` was O(input * chunks)).
+  // A completed frame copies only its header+body region (bounded by maxMessageBytes),
+  // so total copying is O(input). The header separator scan peeks min(retained, 64KiB)
+  // per unparsed frame; for the rare many-frames-per-large-chunk case that is a 64KiB-
+  // per-frame copy (linear, 64x constant) — upgrade to a streaming separator search
+  // if pipelined-frame throughput matters. A separator beyond the 64KiB header bound
+  // is rejected (stricter DoS guard than 0.2.4, which accepted it; no test exercises
+  // >64KiB headers — the bound exists precisely to reject unbounded header growth).
+  private chunks: Buffer[] = [];
+  private offset = 0; // consumed prefix bytes in chunks[0]
+  private retained = 0; // total unconsumed bytes
+  private cachedBodyStart = -1; // -1 = header not yet parsed; else body starts at this absolute unconsumed offset
+  private cachedContentLength = 0;
+  private readonly maxMessageBytes: number;
+
+  constructor(maxMessageBytes: number) {
+    this.maxMessageBytes = maxMessageBytes;
+  }
+
+  /** Push stdout/stderr chunk; return complete parsed JSON values (order preserved). */
+  push(chunk: Buffer): unknown[] {
+    if (chunk.length === 0) return [];
+    this.chunks.push(chunk);
+    this.retained += chunk.length;
+    const out: unknown[] = [];
+    for (;;) {
+      const parsed = this.tryParseOne();
+      if (parsed === undefined) break;
+      out.push(parsed);
+    }
+    return out;
+  }
+
+  /** Copy `n` unconsumed bytes starting at absolute unconsumed offset `start` (no advance). */
+  private peekAt(start: number, n: number): Buffer {
+    const out = Buffer.allocUnsafe(n);
+    let written = 0;
+    let i = 0;
+    let off = this.offset;
+    let skip = start;
+    while (skip > 0) {
+      const c = this.chunks[i];
+      const avail = c.length - off;
+      if (skip >= avail) {
+        skip -= avail;
+        i++;
+        off = 0;
+      } else {
+        off += skip;
+        skip = 0;
+      }
+    }
+    while (written < n) {
+      const c = this.chunks[i];
+      const take = Math.min(c.length - off, n - written);
+      c.copy(out, written, off, off + take);
+      written += take;
+      i++;
+      off = 0;
+    }
+    return out;
+  }
+
+  /** Advance the unconsumed cursor by `n` (drop fully-consumed chunks). */
+  private drop(n: number): void {
+    let remaining = n;
+    while (remaining > 0 && this.chunks.length > 0) {
+      const first = this.chunks[0];
+      const avail = first.length - this.offset;
+      if (remaining >= avail) {
+        remaining -= avail;
+        this.chunks.shift();
+        this.offset = 0;
+      } else {
+        this.offset += remaining;
+        remaining = 0;
+      }
+    }
+    this.retained -= n;
+  }
+
+  private tryParseOne(): unknown | undefined {
+    if (this.retained === 0) return undefined;
+    const headerBound = Math.min(this.maxMessageBytes, 64 * 1024);
+
+    if (this.cachedBodyStart < 0) {
+      // Bound header scan buffer so a missing separator cannot grow forever.
+      const scanLen = Math.min(this.retained, headerBound);
+      const view = this.peekAt(0, scanLen);
+      const sep = indexOfHeaderSep(view);
+      if (sep < 0) {
+        if (this.retained > headerBound) {
+          throw new LspFrameError("ERR_PRISM_LSP_FRAMING", "LSP header exceeds bound without separator");
+        }
+        return undefined;
+      }
+      const headerText = view.subarray(0, sep).toString("ascii");
+      const contentLength = parseContentLength(headerText);
+      if (contentLength > this.maxMessageBytes) {
+        throw new LspFrameError("ERR_PRISM_LSP_LIMIT", `LSP message body ${contentLength} exceeds maxMessageBytes ${this.maxMessageBytes}`);
+      }
+      this.cachedBodyStart = sep + 4;
+      this.cachedContentLength = contentLength;
+    }
+
+    const bodyEnd = this.cachedBodyStart + this.cachedContentLength;
+    if (this.retained < bodyEnd) return undefined;
+
+    const body = this.peekAt(this.cachedBodyStart, this.cachedContentLength);
+    this.drop(bodyEnd);
+    this.cachedBodyStart = -1;
+    this.cachedContentLength = 0;
+    let value: unknown;
+    try {
+      value = JSON.parse(body.toString("utf8"));
+    } catch {
+      throw new LspFrameError("ERR_PRISM_LSP_FRAMING", "LSP message body is not valid JSON");
+    }
+    return value;
+  }
+}
+
+function indexOfHeaderSep(buf: Buffer): number {
+  for (let i = 0; i + 3 < buf.length; i++) {
+    if (buf[i] === 0x0d && buf[i + 1] === 0x0a && buf[i + 2] === 0x0d && buf[i + 3] === 0x0a) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+function parseContentLength(headerText: string): number {
+  const lines = headerText.split("\r\n");
+  let contentLength: number | undefined;
+  for (const line of lines) {
+    if (line.length === 0) continue;
+    const colon = line.indexOf(":");
+    if (colon <= 0) {
+      throw new LspFrameError("ERR_PRISM_LSP_FRAMING", `Malformed LSP header line: ${line}`);
+    }
+    const name = line.slice(0, colon).trim().toLowerCase();
+    const value = line.slice(colon + 1).trim();
+    if (name === "content-length") {
+      if (!/^\d+$/.test(value)) {
+        throw new LspFrameError("ERR_PRISM_LSP_FRAMING", `Invalid Content-Length: ${value}`);
+      }
+      if (contentLength !== undefined) {
+        throw new LspFrameError("ERR_PRISM_LSP_FRAMING", "Duplicate Content-Length header");
+      }
+      contentLength = Number(value);
+      if (!Number.isSafeInteger(contentLength) || contentLength < 0) {
+        throw new LspFrameError("ERR_PRISM_LSP_FRAMING", `Invalid Content-Length: ${value}`);
+      }
+    }
+    // Content-Type and other headers ignored; reject CR/LF injection already split by lines.
+  }
+  if (contentLength === undefined) {
+    throw new LspFrameError("ERR_PRISM_LSP_FRAMING", "Missing Content-Length header");
+  }
+  return contentLength;
+}

package/coding/src/agent/language/index.ts

@@ -0,0 +1,23 @@
+export { LspClient } from "./client.js";
+export { encodeLspFrame, LspFrameError, LspFrameReader } from "./framing.js";
+export {
+  applyTextEdits,
+  createLanguageIntelligence,
+  LanguageIntelligenceError,
+  languageIdForPath,
+  resolveLanguageIntelligenceLimits,
+} from "./intelligence.js";
+export type {
+  CreateLanguageIntelligenceOptions,
+  LanguageDiagnostic,
+  LanguageDiagnosticDeltaRequest,
+  LanguageDiagnosticDeltaResult,
+  LanguageFileDiagnostics,
+  LanguageIntelligence,
+  LanguageIntelligenceLimits,
+  LanguageLocation,
+  LanguageServerSpec,
+  LanguageSymbol,
+  LanguageTextEdit,
+  LanguageWorkspaceEdit,
+} from "./types.js";