@toolkit-cli/toolkode 1.3.8 → 1.3.9

package/test/keybind.test.ts

@@ -1,421 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { Keybind } from "../src/util/keybind"
-
-describe("Keybind.toString", () => {
-  test("should convert simple key to string", () => {
-    const info: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "f" }
-    expect(Keybind.toString(info)).toBe("f")
-  })
-
-  test("should convert ctrl modifier to string", () => {
-    const info: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "x" }
-    expect(Keybind.toString(info)).toBe("ctrl+x")
-  })
-
-  test("should convert leader key to string", () => {
-    const info: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: true, name: "f" }
-    expect(Keybind.toString(info)).toBe("<leader> f")
-  })
-
-  test("should convert multiple modifiers to string", () => {
-    const info: Keybind.Info = { ctrl: true, meta: true, shift: false, leader: false, name: "g" }
-    expect(Keybind.toString(info)).toBe("ctrl+alt+g")
-  })
-
-  test("should convert all modifiers to string", () => {
-    const info: Keybind.Info = { ctrl: true, meta: true, shift: true, leader: true, name: "h" }
-    expect(Keybind.toString(info)).toBe("<leader> ctrl+alt+shift+h")
-  })
-
-  test("should convert shift modifier to string", () => {
-    const info: Keybind.Info = {
-      ctrl: false,
-      meta: false,
-      shift: true,
-      leader: false,
-      name: "return",
-    }
-    expect(Keybind.toString(info)).toBe("shift+return")
-  })
-
-  test("should convert function key to string", () => {
-    const info: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "f2" }
-    expect(Keybind.toString(info)).toBe("f2")
-  })
-
-  test("should convert special key to string", () => {
-    const info: Keybind.Info = {
-      ctrl: false,
-      meta: false,
-      shift: false,
-      leader: false,
-      name: "pgup",
-    }
-    expect(Keybind.toString(info)).toBe("pgup")
-  })
-
-  test("should handle empty name", () => {
-    const info: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "" }
-    expect(Keybind.toString(info)).toBe("ctrl")
-  })
-
-  test("should handle only modifiers", () => {
-    const info: Keybind.Info = { ctrl: true, meta: true, shift: true, leader: true, name: "" }
-    expect(Keybind.toString(info)).toBe("<leader> ctrl+alt+shift")
-  })
-
-  test("should handle only leader with no other parts", () => {
-    const info: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: true, name: "" }
-    expect(Keybind.toString(info)).toBe("<leader>")
-  })
-
-  test("should convert super modifier to string", () => {
-    const info: Keybind.Info = { ctrl: false, meta: false, shift: false, super: true, leader: false, name: "z" }
-    expect(Keybind.toString(info)).toBe("super+z")
-  })
-
-  test("should convert super+shift modifier to string", () => {
-    const info: Keybind.Info = { ctrl: false, meta: false, shift: true, super: true, leader: false, name: "z" }
-    expect(Keybind.toString(info)).toBe("super+shift+z")
-  })
-
-  test("should handle super with ctrl modifier", () => {
-    const info: Keybind.Info = { ctrl: true, meta: false, shift: false, super: true, leader: false, name: "a" }
-    expect(Keybind.toString(info)).toBe("ctrl+super+a")
-  })
-
-  test("should handle super with all modifiers", () => {
-    const info: Keybind.Info = { ctrl: true, meta: true, shift: true, super: true, leader: false, name: "x" }
-    expect(Keybind.toString(info)).toBe("ctrl+alt+super+shift+x")
-  })
-
-  test("should handle undefined super field (omitted)", () => {
-    const info: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "c" }
-    expect(Keybind.toString(info)).toBe("ctrl+c")
-  })
-})
-
-describe("Keybind.match", () => {
-  test("should match identical keybinds", () => {
-    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "x" }
-    const b: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "x" }
-    expect(Keybind.match(a, b)).toBe(true)
-  })
-
-  test("should not match different key names", () => {
-    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "x" }
-    const b: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "y" }
-    expect(Keybind.match(a, b)).toBe(false)
-  })
-
-  test("should not match different modifiers", () => {
-    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "x" }
-    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "x" }
-    expect(Keybind.match(a, b)).toBe(false)
-  })
-
-  test("should match leader keybinds", () => {
-    const a: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: true, name: "f" }
-    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: true, name: "f" }
-    expect(Keybind.match(a, b)).toBe(true)
-  })
-
-  test("should not match leader vs non-leader", () => {
-    const a: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: true, name: "f" }
-    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "f" }
-    expect(Keybind.match(a, b)).toBe(false)
-  })
-
-  test("should match complex keybinds", () => {
-    const a: Keybind.Info = { ctrl: true, meta: true, shift: false, leader: false, name: "g" }
-    const b: Keybind.Info = { ctrl: true, meta: true, shift: false, leader: false, name: "g" }
-    expect(Keybind.match(a, b)).toBe(true)
-  })
-
-  test("should not match with one modifier different", () => {
-    const a: Keybind.Info = { ctrl: true, meta: true, shift: false, leader: false, name: "g" }
-    const b: Keybind.Info = { ctrl: true, meta: true, shift: true, leader: false, name: "g" }
-    expect(Keybind.match(a, b)).toBe(false)
-  })
-
-  test("should match simple key without modifiers", () => {
-    const a: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "a" }
-    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "a" }
-    expect(Keybind.match(a, b)).toBe(true)
-  })
-
-  test("should match super modifier keybinds", () => {
-    const a: Keybind.Info = { ctrl: false, meta: false, shift: false, super: true, leader: false, name: "z" }
-    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, super: true, leader: false, name: "z" }
-    expect(Keybind.match(a, b)).toBe(true)
-  })
-
-  test("should not match super vs non-super", () => {
-    const a: Keybind.Info = { ctrl: false, meta: false, shift: false, super: true, leader: false, name: "z" }
-    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, super: false, leader: false, name: "z" }
-    expect(Keybind.match(a, b)).toBe(false)
-  })
-
-  test("should match undefined super with false super", () => {
-    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "c" }
-    const b: Keybind.Info = { ctrl: true, meta: false, shift: false, super: false, leader: false, name: "c" }
-    expect(Keybind.match(a, b)).toBe(true)
-  })
-
-  test("should match super+shift combination", () => {
-    const a: Keybind.Info = { ctrl: false, meta: false, shift: true, super: true, leader: false, name: "z" }
-    const b: Keybind.Info = { ctrl: false, meta: false, shift: true, super: true, leader: false, name: "z" }
-    expect(Keybind.match(a, b)).toBe(true)
-  })
-
-  test("should not match when only super differs", () => {
-    const a: Keybind.Info = { ctrl: true, meta: true, shift: true, super: true, leader: false, name: "a" }
-    const b: Keybind.Info = { ctrl: true, meta: true, shift: true, super: false, leader: false, name: "a" }
-    expect(Keybind.match(a, b)).toBe(false)
-  })
-})
-
-describe("Keybind.parse", () => {
-  test("should parse simple key", () => {
-    const result = Keybind.parse("f")
-    expect(result).toEqual([
-      {
-        ctrl: false,
-        meta: false,
-        shift: false,
-        leader: false,
-        name: "f",
-      },
-    ])
-  })
-
-  test("should parse leader key syntax", () => {
-    const result = Keybind.parse("<leader>f")
-    expect(result).toEqual([
-      {
-        ctrl: false,
-        meta: false,
-        shift: false,
-        leader: true,
-        name: "f",
-      },
-    ])
-  })
-
-  test("should parse ctrl modifier", () => {
-    const result = Keybind.parse("ctrl+x")
-    expect(result).toEqual([
-      {
-        ctrl: true,
-        meta: false,
-        shift: false,
-        leader: false,
-        name: "x",
-      },
-    ])
-  })
-
-  test("should parse multiple modifiers", () => {
-    const result = Keybind.parse("ctrl+alt+u")
-    expect(result).toEqual([
-      {
-        ctrl: true,
-        meta: true,
-        shift: false,
-        leader: false,
-        name: "u",
-      },
-    ])
-  })
-
-  test("should parse shift modifier", () => {
-    const result = Keybind.parse("shift+f2")
-    expect(result).toEqual([
-      {
-        ctrl: false,
-        meta: false,
-        shift: true,
-        leader: false,
-        name: "f2",
-      },
-    ])
-  })
-
-  test("should parse meta/alt modifier", () => {
-    const result = Keybind.parse("meta+g")
-    expect(result).toEqual([
-      {
-        ctrl: false,
-        meta: true,
-        shift: false,
-        leader: false,
-        name: "g",
-      },
-    ])
-  })
-
-  test("should parse leader with modifier", () => {
-    const result = Keybind.parse("<leader>h")
-    expect(result).toEqual([
-      {
-        ctrl: false,
-        meta: false,
-        shift: false,
-        leader: true,
-        name: "h",
-      },
-    ])
-  })
-
-  test("should parse multiple keybinds separated by comma", () => {
-    const result = Keybind.parse("ctrl+c,<leader>q")
-    expect(result).toEqual([
-      {
-        ctrl: true,
-        meta: false,
-        shift: false,
-        leader: false,
-        name: "c",
-      },
-      {
-        ctrl: false,
-        meta: false,
-        shift: false,
-        leader: true,
-        name: "q",
-      },
-    ])
-  })
-
-  test("should parse shift+return combination", () => {
-    const result = Keybind.parse("shift+return")
-    expect(result).toEqual([
-      {
-        ctrl: false,
-        meta: false,
-        shift: true,
-        leader: false,
-        name: "return",
-      },
-    ])
-  })
-
-  test("should parse ctrl+j combination", () => {
-    const result = Keybind.parse("ctrl+j")
-    expect(result).toEqual([
-      {
-        ctrl: true,
-        meta: false,
-        shift: false,
-        leader: false,
-        name: "j",
-      },
-    ])
-  })
-
-  test("should handle 'none' value", () => {
-    const result = Keybind.parse("none")
-    expect(result).toEqual([])
-  })
-
-  test("should handle special keys", () => {
-    const result = Keybind.parse("pgup")
-    expect(result).toEqual([
-      {
-        ctrl: false,
-        meta: false,
-        shift: false,
-        leader: false,
-        name: "pgup",
-      },
-    ])
-  })
-
-  test("should handle function keys", () => {
-    const result = Keybind.parse("f2")
-    expect(result).toEqual([
-      {
-        ctrl: false,
-        meta: false,
-        shift: false,
-        leader: false,
-        name: "f2",
-      },
-    ])
-  })
-
-  test("should handle complex multi-modifier combination", () => {
-    const result = Keybind.parse("ctrl+alt+g")
-    expect(result).toEqual([
-      {
-        ctrl: true,
-        meta: true,
-        shift: false,
-        leader: false,
-        name: "g",
-      },
-    ])
-  })
-
-  test("should be case insensitive", () => {
-    const result = Keybind.parse("CTRL+X")
-    expect(result).toEqual([
-      {
-        ctrl: true,
-        meta: false,
-        shift: false,
-        leader: false,
-        name: "x",
-      },
-    ])
-  })
-
-  test("should parse super modifier", () => {
-    const result = Keybind.parse("super+z")
-    expect(result).toEqual([
-      {
-        ctrl: false,
-        meta: false,
-        shift: false,
-        super: true,
-        leader: false,
-        name: "z",
-      },
-    ])
-  })
-
-  test("should parse super with shift modifier", () => {
-    const result = Keybind.parse("super+shift+z")
-    expect(result).toEqual([
-      {
-        ctrl: false,
-        meta: false,
-        shift: true,
-        super: true,
-        leader: false,
-        name: "z",
-      },
-    ])
-  })
-
-  test("should parse multiple keybinds with super", () => {
-    const result = Keybind.parse("ctrl+-,super+z")
-    expect(result).toEqual([
-      {
-        ctrl: true,
-        meta: false,
-        shift: false,
-        leader: false,
-        name: "-",
-      },
-      {
-        ctrl: false,
-        meta: false,
-        shift: false,
-        super: true,
-        leader: false,
-        name: "z",
-      },
-    ])
-  })
-})

package/test/lib/effect.ts

@@ -1,37 +0,0 @@
-import { test, type TestOptions } from "bun:test"
-import { Cause, Effect, Exit, Layer } from "effect"
-import type * as Scope from "effect/Scope"
-import * as TestConsole from "effect/testing/TestConsole"
-
-type Body<A, E, R> = Effect.Effect<A, E, R> | (() => Effect.Effect<A, E, R>)
-const env = TestConsole.layer
-
-const body = <A, E, R>(value: Body<A, E, R>) => Effect.suspend(() => (typeof value === "function" ? value() : value))
-
-const run = <A, E, R, E2>(value: Body<A, E, R | Scope.Scope>, layer: Layer.Layer<R, E2, never>) =>
-  Effect.gen(function* () {
-    const exit = yield* body(value).pipe(Effect.scoped, Effect.provide(layer), Effect.exit)
-    if (Exit.isFailure(exit)) {
-      for (const err of Cause.prettyErrors(exit.cause)) {
-        yield* Effect.logError(err)
-      }
-    }
-    return yield* exit
-  }).pipe(Effect.runPromise)
-
-const make = <R, E>(layer: Layer.Layer<R, E, never>) => {
-  const effect = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
-    test(name, () => run(value, layer), opts)
-
-  effect.only = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
-    test.only(name, () => run(value, layer), opts)
-
-  effect.skip = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
-    test.skip(name, () => run(value, layer), opts)
-
-  return { effect }
-}
-
-export const it = make(env)
-
-export const testEffect = <R, E>(layer: Layer.Layer<R, E, never>) => make(Layer.provideMerge(layer, env))

package/test/lib/filesystem.ts

@@ -1,10 +0,0 @@
-import path from "path"
-import { Effect, FileSystem } from "effect"
-
-export const writeFileStringScoped = Effect.fn("test.writeFileStringScoped")(function* (file: string, text: string) {
-  const fs = yield* FileSystem.FileSystem
-  yield* fs.makeDirectory(path.dirname(file), { recursive: true })
-  yield* fs.writeFileString(file, text)
-  yield* Effect.addFinalizer(() => fs.remove(file, { force: true }).pipe(Effect.orDie))
-  return file
-})

package/test/lsp/client.test.ts

@@ -1,95 +0,0 @@
-import { describe, expect, test, beforeEach } from "bun:test"
-import path from "path"
-import { LSPClient } from "../../src/lsp/client"
-import { LSPServer } from "../../src/lsp/server"
-import { Instance } from "../../src/project/instance"
-import { Log } from "../../src/util/log"
-
-// Minimal fake LSP server that speaks JSON-RPC over stdio
-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", () => {
-  beforeEach(async () => {
-    await Log.init({ print: true })
-  })
-
-  test("handles workspace/workspaceFolders request", async () => {
-    const handle = spawnFakeServer() as any
-
-    const client = await Instance.provide({
-      directory: process.cwd(),
-      fn: () =>
-        LSPClient.create({
-          serverID: "fake",
-          server: handle as unknown as LSPServer.Handle,
-          root: process.cwd(),
-        }),
-    })
-
-    await client.connection.sendNotification("test/trigger", {
-      method: "workspace/workspaceFolders",
-    })
-
-    await new Promise((r) => setTimeout(r, 100))
-
-    expect(client.connection).toBeDefined()
-
-    await client.shutdown()
-  })
-
-  test("handles client/registerCapability request", async () => {
-    const handle = spawnFakeServer() as any
-
-    const client = await Instance.provide({
-      directory: process.cwd(),
-      fn: () =>
-        LSPClient.create({
-          serverID: "fake",
-          server: handle as unknown as LSPServer.Handle,
-          root: process.cwd(),
-        }),
-    })
-
-    await client.connection.sendNotification("test/trigger", {
-      method: "client/registerCapability",
-    })
-
-    await new Promise((r) => setTimeout(r, 100))
-
-    expect(client.connection).toBeDefined()
-
-    await client.shutdown()
-  })
-
-  test("handles client/unregisterCapability request", async () => {
-    const handle = spawnFakeServer() as any
-
-    const client = await Instance.provide({
-      directory: process.cwd(),
-      fn: () =>
-        LSPClient.create({
-          serverID: "fake",
-          server: handle as unknown as LSPServer.Handle,
-          root: process.cwd(),
-        }),
-    })
-
-    await client.connection.sendNotification("test/trigger", {
-      method: "client/unregisterCapability",
-    })
-
-    await new Promise((r) => setTimeout(r, 100))
-
-    expect(client.connection).toBeDefined()
-
-    await client.shutdown()
-  })
-})

package/test/lsp/index.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, spyOn, test } from "bun:test"
-import path from "path"
-import * as Lsp from "../../src/lsp/index"
-import { LSPServer } from "../../src/lsp/server"
-import { Instance } from "../../src/project/instance"
-import { tmpdir } from "../fixture/fixture"
-
-describe("lsp.spawn", () => {
-  test("does not spawn builtin LSP for files outside instance", async () => {
-    await using tmp = await tmpdir()
-    const spy = spyOn(LSPServer.Typescript, "spawn").mockResolvedValue(undefined)
-
-    try {
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          await Lsp.LSP.touchFile(path.join(tmp.path, "..", "outside.ts"))
-          await Lsp.LSP.hover({
-            file: path.join(tmp.path, "..", "hover.ts"),
-            line: 0,
-            character: 0,
-          })
-        },
-      })
-
-      expect(spy).toHaveBeenCalledTimes(0)
-    } finally {
-      spy.mockRestore()
-      await Instance.disposeAll()
-    }
-  })
-
-  test("would spawn builtin LSP for files inside instance", async () => {
-    await using tmp = await tmpdir()
-    const spy = spyOn(LSPServer.Typescript, "spawn").mockResolvedValue(undefined)
-
-    try {
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          await Lsp.LSP.hover({
-            file: path.join(tmp.path, "src", "inside.ts"),
-            line: 0,
-            character: 0,
-          })
-        },
-      })
-
-      expect(spy).toHaveBeenCalledTimes(1)
-    } finally {
-      spy.mockRestore()
-      await Instance.disposeAll()
-    }
-  })
-})

package/test/lsp/launch.test.ts

@@ -1,22 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-import { spawn } from "../../src/lsp/launch"
-import { tmpdir } from "../fixture/fixture"
-
-describe("lsp.launch", () => {
-  test("spawns cmd scripts with spaces on Windows", async () => {
-    if (process.platform !== "win32") return
-
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "with space")
-    const file = path.join(dir, "echo cmd.cmd")
-
-    await fs.mkdir(dir, { recursive: true })
-    await Bun.write(file, "@echo off\r\nif %~1==--stdio exit /b 0\r\nexit /b 7\r\n")
-
-    const proc = spawn(file, ["--stdio"])
-
-    expect(await proc.exited).toBe(0)
-  })
-})