saeeol 1.2.5 → 1.2.7

package/test/cli/tui/editor-context-zed.test.ts

@@ -1,356 +0,0 @@
-import { Database } from "bun:sqlite"
-import { mkdir, symlink } from "node:fs/promises"
-import os from "node:os"
-import path from "node:path"
-import { expect, spyOn, test } from "bun:test"
-import { offsetToPosition, resolveZedDbPath, resolveZedSelection } from "../../../src/cli/cmd/tui/context/editor-zed"
-import { tmpdir } from "../../fixture/fixture"
-
-type ZedFixtureOptions = {
-  workspacePaths?: string | null
-  itemKind?: string
-  editor?: boolean
-  selectionStart?: number | null
-  selectionEnd?: number | null
-  selections?: Array<{ start: number | null; end: number | null }>
-  contents?: string
-}
-
-async function writeZedFixture(dir: string, options: ZedFixtureOptions = {}) {
-  const dbPath = path.join(dir, "zed.sqlite")
-  const filePath = path.join(dir, "file.ts")
-  const contents = options.contents ?? "one\ntwo\nthree"
-  await Bun.write(filePath, contents)
-
-  const db = new Database(dbPath)
-  db.run("create table workspaces (workspace_id integer, paths text, timestamp text)")
-  db.run("create table panes (pane_id integer, workspace_id integer, active integer)")
-  db.run("create table items (item_id integer, workspace_id integer, pane_id integer, active integer, kind text)")
-  db.run("create table editors (item_id integer, workspace_id integer, buffer_path text, contents text)")
-  db.run("create table editor_selections (editor_id integer, workspace_id integer, start integer, end integer)")
-  db.run("insert into workspaces values (1, ?, ?)", [options.workspacePaths ?? JSON.stringify([dir]), "2026-04-27"])
-  db.run("insert into panes values (1, 1, 1)")
-  db.run("insert into items values (1, 1, 1, 1, ?)", [options.itemKind ?? "Editor"])
-  if (options.editor !== false) {
-    db.run("insert into editors values (1, 1, ?, ?)", [filePath, contents])
-    ;(
-      options.selections ?? [
-        {
-          start: options.selectionStart === undefined ? 4 : options.selectionStart,
-          end: options.selectionEnd === undefined ? 7 : options.selectionEnd,
-        },
-      ]
-    ).forEach((selection) =>
-      db.run("insert into editor_selections values (1, 1, ?, ?)", [selection.start, selection.end]),
-    )
-  }
-  db.close()
-
-  return { dbPath, filePath }
-}
-
-function utf8ByteOffset(text: string, offset: number) {
-  return new TextEncoder().encode(text.slice(0, offset)).length
-}
-
-test("offsetToPosition converts Zed offsets to 1-based editor positions", () => {
-  expect(offsetToPosition("one\ntwo\nthree", 0)).toEqual({ line: 1, character: 1 })
-  expect(offsetToPosition("one\ntwo\nthree", 4)).toEqual({ line: 2, character: 1 })
-  expect(offsetToPosition("one\ntwo\nthree", 6)).toEqual({ line: 2, character: 3 })
-  expect(offsetToPosition("one\ntwo\nthree", 100)).toEqual({ line: 3, character: 6 })
-  expect(offsetToPosition("Ж\nabc", utf8ByteOffset("Ж\nabc", "Ж\nabc".indexOf("a")))).toEqual({
-    line: 2,
-    character: 1,
-  })
-  expect(offsetToPosition("😀\nabc", utf8ByteOffset("😀\nabc", "😀\nabc".indexOf("a")))).toEqual({
-    line: 2,
-    character: 1,
-  })
-})
-
-test("resolveZedDbPath skips candidates that cannot be stated", async () => {
-  await using tmp = await tmpdir()
-  const loop = path.join(tmp.path, "loop")
-  await symlink(loop, loop)
-  const home = spyOn(os, "homedir").mockImplementation(() => tmp.path)
-  const previous = process.env.SAEEOL_ZED_DB
-  process.env.SAEEOL_ZED_DB = loop
-
-  try {
-    expect(resolveZedDbPath()).toBeUndefined()
-  } finally {
-    if (previous === undefined) delete process.env.SAEEOL_ZED_DB
-    else process.env.SAEEOL_ZED_DB = previous
-    home.mockRestore()
-  }
-})
-
-test("resolveZedSelection returns active editor selection", async () => {
-  await using tmp = await tmpdir()
-  const fixture = await writeZedFixture(tmp.path)
-
-  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
-    type: "selection",
-    selection: {
-      filePath: fixture.filePath,
-      source: "zed",
-      ranges: [
-        {
-          text: "two",
-          selection: {
-            start: { line: 2, character: 1 },
-            end: { line: 2, character: 4 },
-          },
-        },
-      ],
-    },
-  })
-})
-
-test("resolveZedSelection returns all active editor selections sorted by offset", async () => {
-  await using tmp = await tmpdir()
-  const contents = "one\ntwo\nthree\nfour"
-  const fixture = await writeZedFixture(tmp.path, {
-    contents,
-    selections: [
-      {
-        start: utf8ByteOffset(contents, contents.indexOf("four")),
-        end: utf8ByteOffset(contents, contents.indexOf("four") + 4),
-      },
-      {
-        start: utf8ByteOffset(contents, contents.indexOf("two")),
-        end: utf8ByteOffset(contents, contents.indexOf("two") + 3),
-      },
-    ],
-  })
-
-  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
-    type: "selection",
-    selection: {
-      filePath: fixture.filePath,
-      source: "zed",
-      ranges: [
-        {
-          text: "two",
-          selection: {
-            start: { line: 2, character: 1 },
-            end: { line: 2, character: 4 },
-          },
-        },
-        {
-          text: "four",
-          selection: {
-            start: { line: 4, character: 1 },
-            end: { line: 4, character: 5 },
-          },
-        },
-      ],
-    },
-  })
-})
-
-test("resolveZedSelection converts Zed UTF-8 byte offsets to string offsets", async () => {
-  await using tmp = await tmpdir()
-  const contents = "a\nЖЖЖЖЖЖЖЖЖЖ\nb\nTARGET\nz"
-  const start = contents.indexOf("TARGET")
-  const fixture = await writeZedFixture(tmp.path, {
-    contents,
-    selectionStart: utf8ByteOffset(contents, start),
-    selectionEnd: utf8ByteOffset(contents, start + "TARGET".length),
-  })
-
-  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
-    type: "selection",
-    selection: {
-      filePath: fixture.filePath,
-      source: "zed",
-      ranges: [
-        {
-          text: "TARGET",
-          selection: {
-            start: { line: 4, character: 1 },
-            end: { line: 4, character: 7 },
-          },
-        },
-      ],
-    },
-  })
-})
-
-test("resolveZedSelection handles non-ASCII text inside the selected range", async () => {
-  await using tmp = await tmpdir()
-  const contents = "a\npre\nвыбор\nz"
-  const start = contents.indexOf("выбор")
-  const fixture = await writeZedFixture(tmp.path, {
-    contents,
-    selectionStart: utf8ByteOffset(contents, start),
-    selectionEnd: utf8ByteOffset(contents, start + "выбор".length),
-  })
-
-  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
-    type: "selection",
-    selection: {
-      filePath: fixture.filePath,
-      source: "zed",
-      ranges: [
-        {
-          text: "выбор",
-          selection: {
-            start: { line: 3, character: 1 },
-            end: { line: 3, character: 6 },
-          },
-        },
-      ],
-    },
-  })
-})
-
-test("resolveZedSelection handles emoji before the selected range", async () => {
-  await using tmp = await tmpdir()
-  const contents = "😀\nTARGET\nz"
-  const start = contents.indexOf("TARGET")
-  const fixture = await writeZedFixture(tmp.path, {
-    contents,
-    selectionStart: utf8ByteOffset(contents, start),
-    selectionEnd: utf8ByteOffset(contents, start + "TARGET".length),
-  })
-
-  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
-    type: "selection",
-    selection: {
-      filePath: fixture.filePath,
-      source: "zed",
-      ranges: [
-        {
-          text: "TARGET",
-          selection: {
-            start: { line: 2, character: 1 },
-            end: { line: 2, character: 7 },
-          },
-        },
-      ],
-    },
-  })
-})
-
-test("resolveZedSelection handles reversed Zed byte offsets", async () => {
-  await using tmp = await tmpdir()
-  const contents = "a\nЖЖЖ\nTARGET\nz"
-  const start = contents.indexOf("TARGET")
-  const fixture = await writeZedFixture(tmp.path, {
-    contents,
-    selectionStart: utf8ByteOffset(contents, start + "TARGET".length),
-    selectionEnd: utf8ByteOffset(contents, start),
-  })
-
-  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
-    type: "selection",
-    selection: {
-      filePath: fixture.filePath,
-      source: "zed",
-      ranges: [
-        {
-          text: "TARGET",
-          selection: {
-            start: { line: 3, character: 1 },
-            end: { line: 3, character: 7 },
-          },
-        },
-      ],
-    },
-  })
-})
-
-test("resolveZedSelection returns empty when no workspace matches", async () => {
-  await using tmp = await tmpdir()
-  const fixture = await writeZedFixture(tmp.path, {
-    workspacePaths: JSON.stringify([path.join(path.dirname(tmp.path), "other-workspace")]),
-  })
-
-  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({ type: "empty" })
-})
-
-test("resolveZedSelection matches a Zed workspace that contains the session directory", async () => {
-  await using tmp = await tmpdir()
-  const fixture = await writeZedFixture(tmp.path)
-
-  expect(await resolveZedSelection(fixture.dbPath, path.join(tmp.path, "packages", "app"))).toEqual({
-    type: "selection",
-    selection: {
-      filePath: fixture.filePath,
-      source: "zed",
-      ranges: [
-        {
-          text: "two",
-          selection: {
-            start: { line: 2, character: 1 },
-            end: { line: 2, character: 4 },
-          },
-        },
-      ],
-    },
-  })
-})
-
-test("resolveZedSelection prefers the most specific containing Zed workspace", async () => {
-  await using tmp = await tmpdir()
-  const fixture = await writeZedFixture(tmp.path)
-  const child = path.join(tmp.path, "packages")
-  const childFile = path.join(child, "child.ts")
-  await mkdir(child, { recursive: true })
-  await Bun.write(childFile, "child")
-
-  const db = new Database(fixture.dbPath)
-  db.run("insert into workspaces values (2, ?, ?)", [JSON.stringify([child]), "2026-01-01"])
-  db.run("insert into panes values (2, 2, 1)")
-  db.run("insert into items values (2, 2, 2, 1, ?)", ["Editor"])
-  db.run("insert into editors values (2, 2, ?, ?)", [childFile, "child"])
-  db.run("insert into editor_selections values (2, 2, 0, 5)")
-  db.close()
-
-  expect(await resolveZedSelection(fixture.dbPath, path.join(child, "app"))).toEqual({
-    type: "selection",
-    selection: {
-      filePath: childFile,
-      source: "zed",
-      ranges: [
-        {
-          text: "child",
-          selection: {
-            start: { line: 1, character: 1 },
-            end: { line: 1, character: 6 },
-          },
-        },
-      ],
-    },
-  })
-})
-
-test("resolveZedSelection ignores a Zed workspace nested inside the session directory", async () => {
-  await using tmp = await tmpdir()
-  const child = path.join(tmp.path, "effect-lab")
-  await mkdir(child, { recursive: true })
-  const fixture = await writeZedFixture(child)
-
-  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({ type: "empty" })
-})
-
-test("resolveZedSelection returns unavailable when a Zed terminal is active", async () => {
-  await using tmp = await tmpdir()
-  const fixture = await writeZedFixture(tmp.path, { itemKind: "Terminal", editor: false })
-
-  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({ type: "unavailable" })
-})
-
-test("resolveZedSelection returns unavailable when the database cannot be queried", async () => {
-  await using tmp = await tmpdir()
-
-  expect(await resolveZedSelection(path.join(tmp.path, "missing.sqlite"), tmp.path)).toEqual({ type: "unavailable" })
-})
-
-test("resolveZedSelection returns unavailable when active selection is missing offsets", async () => {
-  await using tmp = await tmpdir()
-  const fixture = await writeZedFixture(tmp.path, { selectionStart: null, selectionEnd: null })
-
-  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({ type: "unavailable" })
-})

package/test/cli/tui/editor-context.test.tsx

@@ -1,228 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises"
-import os from "node:os"
-import path from "node:path"
-import { afterEach, expect, spyOn, test } from "bun:test"
-import { createRoot } from "solid-js"
-import { EditorContextProvider, useEditorContext } from "../../../src/cli/cmd/tui/context/editor"
-import { tmpdir } from "../../fixture/fixture"
-import { FakeWebSocket } from "../../lib/websocket"
-
-const originalClaudePort = process.env.CLAUDE_CODE_SSE_PORT
-const originalEditorPort = process.env.SAEEOL_EDITOR_SSE_PORT
-
-afterEach(() => {
-  process.env.CLAUDE_CODE_SSE_PORT = originalClaudePort
-  process.env.SAEEOL_EDITOR_SSE_PORT = originalEditorPort
-})
-
-function nextTick() {
-  return new Promise<void>((resolve) => queueMicrotask(resolve))
-}
-
-function mountEditorContext(WebSocketImpl?: typeof WebSocket) {
-  let editor!: ReturnType<typeof useEditorContext>
-  let dispose!: () => void
-
-  createRoot((nextDispose) => {
-    dispose = nextDispose
-
-    const Consumer = () => {
-      editor = useEditorContext()
-      return null
-    }
-
-    return (
-      <EditorContextProvider WebSocketImpl={WebSocketImpl}>
-        <Consumer />
-      </EditorContextProvider>
-    )
-  })
-
-  return {
-    editor,
-    dispose,
-  }
-}
-
-function createWebSocketImpl(...sockets: FakeWebSocket[]) {
-  let index = 0
-
-  return class {
-    constructor(url: string, options?: { headers?: Record<string, string> }) {
-      const socket = sockets[index]
-      index += 1
-      expect(socket).toBeDefined()
-      expect(url).toBe(socket!.url)
-      expect(options).toEqual(socket!.options)
-      return socket as unknown as object
-    }
-  } as unknown as typeof WebSocket
-}
-
-test("useEditorContext reconnect switches editor server by session directory", async () => {
-  await using tmp = await tmpdir()
-  const startupDirectory = path.join(tmp.path, "startup")
-  const sessionDirectory = path.join(tmp.path, "session")
-  const ideDirectory = path.join(tmp.path, ".claude", "ide")
-  await mkdir(startupDirectory, { recursive: true })
-  await mkdir(sessionDirectory, { recursive: true })
-  await mkdir(ideDirectory, { recursive: true })
-  await writeFile(
-    path.join(ideDirectory, "3001.lock"),
-    JSON.stringify({
-      transport: "ws",
-      workspaceFolders: [startupDirectory],
-    }),
-  )
-  await writeFile(
-    path.join(ideDirectory, "3002.lock"),
-    JSON.stringify({
-      transport: "ws",
-      workspaceFolders: [sessionDirectory],
-    }),
-  )
-
-  process.env.CLAUDE_CODE_SSE_PORT = undefined
-  process.env.SAEEOL_EDITOR_SSE_PORT = undefined
-  spyOn(process, "cwd").mockImplementation(() => startupDirectory)
-  spyOn(os, "homedir").mockImplementation(() => tmp.path)
-  const firstSocket = new FakeWebSocket("ws://127.0.0.1:3001")
-  const secondSocket = new FakeWebSocket("ws://127.0.0.1:3002")
-
-  const mounted = mountEditorContext(createWebSocketImpl(firstSocket, secondSocket))
-  await nextTick()
-
-  expect(firstSocket.closed).toBeFalse()
-
-  mounted.editor.reconnect(sessionDirectory)
-  await nextTick()
-
-  expect(firstSocket.closed).toBeTrue()
-  expect(secondSocket.closed).toBeFalse()
-
-  mounted.dispose()
-})
-
-test("useEditorContext favors configured port over lock files", async () => {
-  await using tmp = await tmpdir()
-  const startupDirectory = path.join(tmp.path, "startup")
-  const ideDirectory = path.join(tmp.path, ".claude", "ide")
-  await mkdir(startupDirectory, { recursive: true })
-  await mkdir(ideDirectory, { recursive: true })
-  await writeFile(
-    path.join(ideDirectory, "3001.lock"),
-    JSON.stringify({
-      transport: "ws",
-      workspaceFolders: [startupDirectory],
-    }),
-  )
-
-  process.env.CLAUDE_CODE_SSE_PORT = "4010"
-  process.env.SAEEOL_EDITOR_SSE_PORT = undefined
-  spyOn(process, "cwd").mockImplementation(() => startupDirectory)
-  spyOn(os, "homedir").mockImplementation(() => tmp.path)
-  const socket = new FakeWebSocket("ws://127.0.0.1:4010")
-
-  const mounted = mountEditorContext(createWebSocketImpl(socket))
-  await nextTick()
-
-  expect(socket.closed).toBeFalse()
-
-  mounted.dispose()
-})
-
-test("useEditorContext resets selection when reconnecting", async () => {
-  await using tmp = await tmpdir()
-  const startupDirectory = path.join(tmp.path, "startup")
-  const ideDirectory = path.join(tmp.path, ".claude", "ide")
-  await mkdir(startupDirectory, { recursive: true })
-  await mkdir(ideDirectory, { recursive: true })
-  await writeFile(
-    path.join(ideDirectory, "3001.lock"),
-    JSON.stringify({
-      transport: "ws",
-      workspaceFolders: [startupDirectory],
-    }),
-  )
-
-  process.env.CLAUDE_CODE_SSE_PORT = undefined
-  process.env.SAEEOL_EDITOR_SSE_PORT = undefined
-  spyOn(process, "cwd").mockImplementation(() => startupDirectory)
-  spyOn(os, "homedir").mockImplementation(() => tmp.path)
-  const socket = new FakeWebSocket("ws://127.0.0.1:3001")
-
-  const mounted = mountEditorContext(createWebSocketImpl(socket))
-  await nextTick()
-
-  expect(socket.closed).toBeFalse()
-  expect(mounted.editor.selection()).toBeUndefined()
-  expect(mounted.editor.connected()).toBeFalse()
-
-  socket.open()
-  socket.message(
-    JSON.stringify({
-      jsonrpc: "2.0",
-      id: 1,
-      result: {
-        protocolVersion: "2025-11-25",
-        serverInfo: { name: "test", version: "0.0.0" },
-      },
-    }),
-  )
-  socket.message(
-    JSON.stringify({
-      jsonrpc: "2.0",
-      method: "selection_changed",
-      params: {
-        text: "foo",
-        filePath: path.join(startupDirectory, "file.ts"),
-        selection: {
-          start: { line: 1, character: 1 },
-          end: { line: 1, character: 4 },
-        },
-      },
-    }),
-  )
-
-  expect(mounted.editor.connected()).toBeTrue()
-  expect(mounted.editor.server()).toEqual({
-    protocolVersion: "2025-11-25",
-    serverInfo: { name: "test", version: "0.0.0" },
-  })
-  expect(mounted.editor.selection()).toEqual({
-    filePath: path.join(startupDirectory, "file.ts"),
-    source: "websocket",
-    ranges: [
-      {
-        text: "foo",
-        selection: {
-          start: { line: 1, character: 1 },
-          end: { line: 1, character: 4 },
-        },
-      },
-    ],
-  })
-
-  mounted.editor.reconnect(startupDirectory)
-
-  expect(socket.closed).toBeFalse()
-  expect(mounted.editor.connected()).toBeTrue()
-  expect(mounted.editor.selection()).toBeUndefined()
-
-  mounted.dispose()
-})
-
-test("useEditorContext connects with SAEEOL_EDITOR_SSE_PORT", async () => {
-  await using tmp = await tmpdir()
-  process.env.CLAUDE_CODE_SSE_PORT = undefined
-  process.env.SAEEOL_EDITOR_SSE_PORT = "4020"
-  spyOn(process, "cwd").mockImplementation(() => tmp.path)
-  const socket = new FakeWebSocket("ws://127.0.0.1:4020")
-
-  const mounted = mountEditorContext(createWebSocketImpl(socket))
-  await nextTick()
-
-  expect(socket.closed).toBeFalse()
-
-  mounted.dispose()
-})

package/test/cli/tui/keybind-plugin.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { ParsedKey } from "@opentui/core"
-import { createPluginKeybind } from "../../../src/cli/cmd/tui/context/plugin-keybinds"
-
-describe("createPluginKeybind", () => {
-  const defaults = {
-    open: "ctrl+o",
-    close: "escape",
-  }
-
-  test("uses defaults when overrides are missing", () => {
-    const api = {
-      match: () => false,
-      print: (key: string) => key,
-    }
-    const bind = createPluginKeybind(api, defaults)
-
-    expect(bind.all).toEqual(defaults)
-    expect(bind.get("open")).toBe("ctrl+o")
-    expect(bind.get("close")).toBe("escape")
-  })
-
-  test("applies valid overrides", () => {
-    const api = {
-      match: () => false,
-      print: (key: string) => key,
-    }
-    const bind = createPluginKeybind(api, defaults, {
-      open: "ctrl+alt+o",
-      close: "q",
-    })
-
-    expect(bind.all).toEqual({
-      open: "ctrl+alt+o",
-      close: "q",
-    })
-  })
-
-  test("ignores invalid overrides", () => {
-    const api = {
-      match: () => false,
-      print: (key: string) => key,
-    }
-    const bind = createPluginKeybind(api, defaults, {
-      open: "   ",
-      close: 1,
-      extra: "ctrl+x",
-    })
-
-    expect(bind.all).toEqual(defaults)
-    expect(bind.get("extra")).toBe("extra")
-  })
-
-  test("resolves names for match", () => {
-    const list: string[] = []
-    const api = {
-      match: (key: string) => {
-        list.push(key)
-        return true
-      },
-      print: (key: string) => key,
-    }
-    const bind = createPluginKeybind(api, defaults, {
-      open: "ctrl+shift+o",
-    })
-
-    bind.match("open", { name: "x" } as ParsedKey)
-    bind.match("ctrl+k", { name: "x" } as ParsedKey)
-
-    expect(list).toEqual(["ctrl+shift+o", "ctrl+k"])
-  })
-
-  test("resolves names for print", () => {
-    const list: string[] = []
-    const api = {
-      match: () => false,
-      print: (key: string) => {
-        list.push(key)
-        return `print:${key}`
-      },
-    }
-    const bind = createPluginKeybind(api, defaults, {
-      close: "q",
-    })
-
-    expect(bind.print("close")).toBe("print:q")
-    expect(bind.print("ctrl+p")).toBe("print:ctrl+p")
-    expect(list).toEqual(["q", "ctrl+p"])
-  })
-})