@miaws/miaw 1.18.5 → 1.18.6

package/test/lib/snapshot.ts

@@ -1,73 +0,0 @@
-// Shared normalization helpers for cross-OS-stable snapshot tests.
-//
-// Every snapshot test that captures subprocess output, file paths, or other
-// OS-flavored strings hits the same two issues:
-//   1. Bun emits CRLF line endings on Windows stderr; LF elsewhere.
-//   2. Path separators differ (\ on Windows, / on POSIX), and macOS's
-//      /var/folders symlink resolves to /private/var/folders.
-//
-// These helpers exist so each test doesn't reinvent the same regexes.
-//
-// Use individually for fine-grained control, or compose them via
-// `normalizeForSnapshot` for the common "snapshot subprocess output" path.
-import fs from "node:fs"
-import os from "node:os"
-
-const TMP = os.tmpdir()
-const REAL_TMP = fs.realpathSync(TMP)
-
-/**
- * Collapses CRLF to LF. Bun's subprocess pipes emit native line endings —
- * snapshots captured on macOS/Linux contain LF, so a Windows run without
- * this step always diffs.
- */
-export function stripCrlf(text: string): string {
-  return text.replaceAll("\r\n", "\n")
-}
-
-/**
- * Converts Windows-style `\` separators to POSIX `/` so paths render
- * identically across OSes. Use for path strings you want stable in a
- * snapshot, not for filesystem operations.
- */
-export function toPosixPath(p: string): string {
-  return p.replaceAll("\\", "/")
-}
-
-/**
- * Strips both the OS-level `os.tmpdir()` and its realpath form (macOS
- * `/var/folders` → `/private/var/folders`) from text, replacing each
- * occurrence with `marker` (default `<TMPDIR>`).
- */
-export function withTmpdirStripped(text: string, marker = "<TMPDIR>"): string {
-  return text.replaceAll(REAL_TMP, marker).replaceAll(TMP, marker)
-}
-
-/**
- * Separator-agnostic match class for path-style strings. Use inside a
- * larger regex when you want to match both `/` (POSIX) and `\` (Windows)
- * boundaries — e.g. `<TMPDIR>${PATH_SEP}oc-cli-[a-z0-9]+`.
- */
-export const PATH_SEP = "[/\\\\]"
-
-/**
- * One-shot normalization for the common case: strip CRLF, strip tmpdir,
- * then apply any caller-supplied path regex substitutions. Does NOT
- * blanket-replace `\` with `/` — that would mangle non-path backslash
- * content (regex literals in help text, etc.). Use `toPosixPath` or
- * `PATH_SEP` in your own regex when you need separator agnosticism.
- */
-export function normalizeForSnapshot(
-  text: string,
-  options?: {
-    readonly tmpdirMarker?: string
-    readonly pathReplacements?: ReadonlyArray<readonly [RegExp, string]>
-  },
-): string {
-  let out = stripCrlf(text)
-  out = withTmpdirStripped(out, options?.tmpdirMarker)
-  for (const [pattern, replacement] of options?.pathReplacements ?? []) {
-    out = out.replace(pattern, replacement)
-  }
-  return out
-}

package/test/lib/test-provider.ts

@@ -1,37 +0,0 @@
-// Shared provider config for tests that need miaw to talk to a fake LLM
-// over a real HTTP endpoint. Registers a single provider `test` with a single
-// model `test-model` (i.e. `--model test/test-model`), pointed at the URL the
-// caller supplies (typically a TestLLMServer instance).
-//
-// Used by:
-//   - test/lib/run-process.ts          (subprocess CLI tests)
-//   - test/server/httpapi-sdk.test.ts  (in-process SDK tests)
-export function testProviderConfig(llmUrl: string) {
-  return {
-    formatter: false,
-    lsp: false,
-    provider: {
-      test: {
-        name: "Test",
-        id: "test",
-        env: [],
-        npm: "@ai-sdk/openai-compatible",
-        models: {
-          "test-model": {
-            id: "test-model",
-            name: "Test Model",
-            attachment: false,
-            reasoning: false,
-            temperature: false,
-            tool_call: true,
-            release_date: "2025-01-01",
-            limit: { context: 100_000, output: 10_000 },
-            cost: { input: 0, output: 0 },
-            options: {},
-          },
-        },
-        options: { apiKey: "test-key", baseURL: llmUrl },
-      },
-    },
-  }
-}

package/test/lib/websocket.ts

@@ -1,46 +0,0 @@
-export class FakeWebSocket {
-  static CONNECTING = 0
-  static OPEN = 1
-  static CLOSING = 2
-  static CLOSED = 3
-
-  readyState = FakeWebSocket.CONNECTING
-  closed = false
-  sent: string[] = []
-  listeners = new Map<string, Set<(event: { data?: unknown }) => void>>()
-
-  constructor(
-    readonly url: string,
-    readonly options?: { headers?: Record<string, string> },
-  ) {}
-
-  addEventListener(type: string, listener: (event: { data?: unknown }) => void) {
-    const current = this.listeners.get(type) ?? new Set<(event: { data?: unknown }) => void>()
-    current.add(listener)
-    this.listeners.set(type, current)
-  }
-
-  send(data: string) {
-    this.sent.push(data)
-  }
-
-  close() {
-    if (this.readyState === FakeWebSocket.CLOSED) return
-    this.closed = true
-    this.readyState = FakeWebSocket.CLOSED
-    this.emit("close", {})
-  }
-
-  open() {
-    this.readyState = FakeWebSocket.OPEN
-    this.emit("open", {})
-  }
-
-  message(data: unknown) {
-    this.emit("message", { data })
-  }
-
-  emit(type: string, event: { data?: unknown }) {
-    this.listeners.get(type)?.forEach((listener) => listener(event))
-  }
-}

package/test/lsp/client.test.ts

@@ -1,488 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import path from "path"
-import { pathToFileURL } from "url"
-import { tmpdir, withTestInstance } from "../fixture/fixture"
-import { LSPClient } from "@/lsp/client"
-import * as LSPServer from "@/lsp/server"
-
-function spawnFakeServer() {
-  const { spawn } = require("child_process")
-  const serverPath = path.join(__dirname, "../fixture/lsp/fake-lsp-server.js")
-  return {
-    process: spawn(process.execPath, [serverPath], {
-      stdio: "pipe",
-    }),
-  }
-}
-
-describe("LSPClient interop", () => {
-  test("handles workspace/workspaceFolders request", async () => {
-    const handle = spawnFakeServer() as any
-
-    const client = await withTestInstance({
-      directory: process.cwd(),
-      fn: (ctx) =>
-        LSPClient.create({
-          serverID: "fake",
-          server: handle as unknown as LSPServer.Handle,
-          root: process.cwd(),
-          directory: process.cwd(),
-          instance: ctx,
-        }),
-    })
-
-    await client.connection.sendNotification("test/trigger", {
-      method: "workspace/workspaceFolders",
-    })
-
-    await new Promise((resolve) => setTimeout(resolve, 100))
-    expect(client.connection).toBeDefined()
-    await client.shutdown()
-  })
-
-  test("handles client/registerCapability request", async () => {
-    const handle = spawnFakeServer() as any
-
-    const client = await withTestInstance({
-      directory: process.cwd(),
-      fn: (ctx) =>
-        LSPClient.create({
-          serverID: "fake",
-          server: handle as unknown as LSPServer.Handle,
-          root: process.cwd(),
-          directory: process.cwd(),
-          instance: ctx,
-        }),
-    })
-
-    await client.connection.sendNotification("test/trigger", {
-      method: "client/registerCapability",
-    })
-
-    await new Promise((resolve) => setTimeout(resolve, 100))
-    expect(client.connection).toBeDefined()
-    await client.shutdown()
-  })
-
-  test("handles client/unregisterCapability request", async () => {
-    const handle = spawnFakeServer() as any
-
-    const client = await withTestInstance({
-      directory: process.cwd(),
-      fn: (ctx) =>
-        LSPClient.create({
-          serverID: "fake",
-          server: handle as unknown as LSPServer.Handle,
-          root: process.cwd(),
-          directory: process.cwd(),
-          instance: ctx,
-        }),
-    })
-
-    await client.connection.sendNotification("test/trigger", {
-      method: "client/unregisterCapability",
-    })
-
-    await new Promise((resolve) => setTimeout(resolve, 100))
-    expect(client.connection).toBeDefined()
-    await client.shutdown()
-  })
-
-  test("initialize does not overclaim unsupported diagnostics capabilities", async () => {
-    const handle = spawnFakeServer() as any
-
-    const client = await withTestInstance({
-      directory: process.cwd(),
-      fn: (ctx) =>
-        LSPClient.create({
-          serverID: "fake",
-          server: handle as unknown as LSPServer.Handle,
-          root: process.cwd(),
-          directory: process.cwd(),
-          instance: ctx,
-        }),
-    })
-
-    const params = await client.connection.sendRequest<any>("test/get-initialize-params", {})
-    expect(params.capabilities.workspace.diagnostics.refreshSupport).toBe(false)
-    expect(params.capabilities.textDocument.publishDiagnostics.versionSupport).toBe(false)
-
-    await client.shutdown()
-  })
-
-  test("workspace/configuration returns one result per requested item", async () => {
-    const handle = spawnFakeServer() as any
-    const initialization = {
-      alpha: {
-        beta: 1,
-      },
-      gamma: true,
-    }
-
-    const client = await withTestInstance({
-      directory: process.cwd(),
-      fn: (ctx) =>
-        LSPClient.create({
-          serverID: "fake",
-          server: {
-            ...(handle as unknown as LSPServer.Handle),
-            initialization,
-          },
-          root: process.cwd(),
-          directory: process.cwd(),
-          instance: ctx,
-        }),
-    })
-
-    const response = await client.connection.sendRequest<any[]>("test/request-configuration", {
-      items: [{ section: "alpha" }, { section: "alpha.beta" }, { section: "missing" }, {}],
-    })
-
-    expect(response).toEqual([{ beta: 1 }, 1, null, initialization])
-
-    await client.shutdown()
-  })
-
-  test("sends ranged didChange for incremental sync servers", async () => {
-    const handle = spawnFakeServer() as any
-    await using tmp = await tmpdir()
-    const file = path.join(tmp.path, "client.ts")
-    await Bun.write(file, "first\n")
-
-    await withTestInstance({
-      directory: tmp.path,
-      fn: async (ctx) => {
-        const client = await LSPClient.create({
-          serverID: "fake",
-          server: handle as unknown as LSPServer.Handle,
-          root: tmp.path,
-          directory: tmp.path,
-          instance: ctx,
-        })
-
-        await client.notify.open({ path: file })
-        await Bun.write(file, "second\nthird\n")
-        await client.notify.open({ path: file })
-
-        const change = await client.connection.sendRequest<{
-          textDocument: { version: number }
-          contentChanges: {
-            range?: { start: { line: number; character: number }; end: { line: number; character: number } }
-            text: string
-          }[]
-        }>("test/get-last-change", {})
-        expect(change.textDocument.version).toBe(1)
-        expect(change.contentChanges).toEqual([
-          {
-            range: {
-              start: { line: 0, character: 0 },
-              end: { line: 1, character: 0 },
-            },
-            text: "second\nthird\n",
-          },
-        ])
-
-        await client.shutdown()
-      },
-    })
-  })
-
-  test("document mode falls back to push diagnostics", async () => {
-    const handle = spawnFakeServer() as any
-    await using tmp = await tmpdir()
-    const file = path.join(tmp.path, "client.ts")
-    await Bun.write(file, "const x = 1\n")
-
-    await withTestInstance({
-      directory: tmp.path,
-      fn: async (ctx) => {
-        const client = await LSPClient.create({
-          serverID: "fake",
-          server: handle as unknown as LSPServer.Handle,
-          root: tmp.path,
-          directory: tmp.path,
-          instance: ctx,
-        })
-
-        const version = await client.notify.open({ path: file })
-        const wait = client.waitForDiagnostics({ path: file, version, mode: "document" })
-        await client.connection.sendNotification("test/publish-diagnostics", {
-          uri: pathToFileURL(file).href,
-          version,
-          diagnostics: [
-            {
-              range: {
-                start: { line: 0, character: 0 },
-                end: { line: 0, character: 5 },
-              },
-              message: "push diagnostic",
-              severity: 1,
-            },
-          ],
-        })
-        await wait
-
-        const diagnostics = client.diagnostics.get(file) ?? []
-        expect(diagnostics).toHaveLength(1)
-        expect(diagnostics[0]?.message).toBe("push diagnostic")
-
-        const count = await client.connection.sendRequest("test/get-diagnostic-request-count", {})
-        expect(count).toBe(0)
-
-        await client.shutdown()
-      },
-    })
-  })
-
-  test("document mode accepts matching push diagnostics published before waiting", async () => {
-    const handle = spawnFakeServer() as any
-    await using tmp = await tmpdir()
-    const file = path.join(tmp.path, "client.ts")
-    await Bun.write(file, "const x = 1\n")
-
-    await withTestInstance({
-      directory: tmp.path,
-      fn: async (ctx) => {
-        const client = await LSPClient.create({
-          serverID: "fake",
-          server: handle as unknown as LSPServer.Handle,
-          root: tmp.path,
-          directory: tmp.path,
-          instance: ctx,
-        })
-
-        const version = await client.notify.open({ path: file })
-        await client.connection.sendNotification("test/publish-diagnostics", {
-          uri: pathToFileURL(file).href,
-          version,
-          diagnostics: [
-            {
-              range: {
-                start: { line: 0, character: 0 },
-                end: { line: 0, character: 5 },
-              },
-              message: "push diagnostic",
-              severity: 1,
-            },
-          ],
-        })
-
-        for (let i = 0; i < 20 && (client.diagnostics.get(file)?.length ?? 0) === 0; i++) {
-          await new Promise((resolve) => setTimeout(resolve, 25))
-        }
-
-        expect(client.diagnostics.get(file)?.[0]?.message).toBe("push diagnostic")
-
-        const started = Date.now()
-        await client.waitForDiagnostics({ path: file, version, mode: "document" })
-        expect(Date.now() - started).toBeLessThan(1_000)
-
-        await client.shutdown()
-      },
-    })
-  })
-
-  test("document mode waits for pull diagnostics", async () => {
-    const handle = spawnFakeServer() as any
-    await using tmp = await tmpdir()
-    const file = path.join(tmp.path, "client.cs")
-    await Bun.write(file, "class C {}\n")
-
-    await withTestInstance({
-      directory: tmp.path,
-      fn: async (ctx) => {
-        const client = await LSPClient.create({
-          serverID: "fake",
-          server: handle as unknown as LSPServer.Handle,
-          root: tmp.path,
-          directory: tmp.path,
-          instance: ctx,
-        })
-
-        await client.connection.sendRequest("test/configure-pull-diagnostics", {
-          registerOn: "didOpen",
-          registrations: [{ identifier: "DocumentCompilerSemantic" }],
-          documentDiagnosticsByIdentifier: {
-            DocumentCompilerSemantic: [
-              {
-                range: {
-                  start: { line: 0, character: 0 },
-                  end: { line: 0, character: 5 },
-                },
-                message: "pull diagnostic",
-                severity: 1,
-              },
-            ],
-          },
-        })
-
-        const version = await client.notify.open({ path: file })
-        await client.waitForDiagnostics({ path: file, version, mode: "document" })
-
-        const diagnostics = client.diagnostics.get(file) ?? []
-        expect(diagnostics).toHaveLength(1)
-        expect(diagnostics[0]?.message).toBe("pull diagnostic")
-
-        const count = await client.connection.sendRequest("test/get-diagnostic-request-count", {})
-        expect(count).toBeGreaterThan(0)
-
-        await client.shutdown()
-      },
-    })
-  })
-
-  test("document mode does not wait for the slowest pull identifier after current-file diagnostics arrive", async () => {
-    const handle = spawnFakeServer() as any
-    await using tmp = await tmpdir()
-    const file = path.join(tmp.path, "client.cs")
-    await Bun.write(file, "class C {}\n")
-
-    await withTestInstance({
-      directory: tmp.path,
-      fn: async (ctx) => {
-        const client = await LSPClient.create({
-          serverID: "fake",
-          server: handle as unknown as LSPServer.Handle,
-          root: tmp.path,
-          directory: tmp.path,
-          instance: ctx,
-        })
-
-        await client.connection.sendRequest("test/configure-pull-diagnostics", {
-          registrations: [{ identifier: "fast" }, { identifier: "slow" }],
-          documentDiagnosticsByIdentifier: {
-            fast: [
-              {
-                range: {
-                  start: { line: 0, character: 0 },
-                  end: { line: 0, character: 5 },
-                },
-                message: "fast diagnostic",
-                severity: 1,
-              },
-            ],
-            slow: [],
-          },
-          documentDelayMsByIdentifier: {
-            slow: 2_500,
-          },
-        })
-
-        const version = await client.notify.open({ path: file })
-        await client.connection.sendRequest("test/register-configured-pull-diagnostics", {})
-        await new Promise((resolve) => setTimeout(resolve, 100))
-        const started = Date.now()
-        await client.waitForDiagnostics({ path: file, version, mode: "document" })
-
-        expect(Date.now() - started).toBeLessThan(1_000)
-        expect(client.diagnostics.get(file)?.[0]?.message).toBe("fast diagnostic")
-        expect(await client.connection.sendRequest("test/get-diagnostic-request-count", {})).toBeGreaterThan(1)
-
-        await client.shutdown()
-      },
-    })
-  })
-
-  test("full mode includes workspace pull diagnostics", async () => {
-    const handle = spawnFakeServer() as any
-    await using tmp = await tmpdir()
-    const file = path.join(tmp.path, "client.cs")
-    const related = path.join(tmp.path, "other.cs")
-    await Bun.write(file, "class C {}\n")
-    await Bun.write(related, "class D {}\n")
-
-    await withTestInstance({
-      directory: tmp.path,
-      fn: async (ctx) => {
-        const client = await LSPClient.create({
-          serverID: "fake",
-          server: handle as unknown as LSPServer.Handle,
-          root: tmp.path,
-          directory: tmp.path,
-          instance: ctx,
-        })
-
-        await client.connection.sendRequest("test/configure-pull-diagnostics", {
-          registerOn: "didOpen",
-          registrations: [
-            { identifier: "DocumentCompilerSemantic" },
-            { identifier: "WorkspaceDocumentsAndProject", workspaceDiagnostics: true },
-          ],
-          documentDiagnosticsByIdentifier: {
-            DocumentCompilerSemantic: [
-              {
-                range: {
-                  start: { line: 0, character: 0 },
-                  end: { line: 0, character: 5 },
-                },
-                message: "current file",
-                severity: 1,
-              },
-            ],
-          },
-          workspaceDiagnosticsByIdentifier: {
-            WorkspaceDocumentsAndProject: [
-              {
-                uri: pathToFileURL(related).href,
-                items: [
-                  {
-                    range: {
-                      start: { line: 0, character: 0 },
-                      end: { line: 0, character: 5 },
-                    },
-                    message: "workspace file",
-                    severity: 1,
-                  },
-                ],
-              },
-            ],
-          },
-        })
-
-        const version = await client.notify.open({ path: file })
-        await client.waitForDiagnostics({ path: file, version, mode: "full" })
-
-        expect(client.diagnostics.get(file)?.[0]?.message).toBe("current file")
-        expect(client.diagnostics.get(related)?.[0]?.message).toBe("workspace file")
-
-        await client.shutdown()
-      },
-    })
-  })
-
-  test("full mode treats an empty workspace pull response as handled", async () => {
-    const handle = spawnFakeServer() as any
-    await using tmp = await tmpdir()
-    const file = path.join(tmp.path, "client.cs")
-    await Bun.write(file, "class C {}\n")
-
-    await withTestInstance({
-      directory: tmp.path,
-      fn: async (ctx) => {
-        const client = await LSPClient.create({
-          serverID: "fake",
-          server: handle as unknown as LSPServer.Handle,
-          root: tmp.path,
-          directory: tmp.path,
-          instance: ctx,
-        })
-
-        await client.connection.sendRequest("test/configure-pull-diagnostics", {
-          registerOn: "didOpen",
-          registrations: [{ identifier: "WorkspaceDocumentsAndProject", workspaceDiagnostics: true }],
-          workspaceDiagnosticsByIdentifier: {
-            WorkspaceDocumentsAndProject: [],
-          },
-        })
-
-        const version = await client.notify.open({ path: file })
-        const started = Date.now()
-        await client.waitForDiagnostics({ path: file, version, mode: "full" })
-
-        expect(Date.now() - started).toBeLessThan(1_000)
-
-        await client.shutdown()
-      },
-    })
-  })
-})