@toolkit-cli/toolkode 1.3.7 → 1.3.9

package/test/util/lock.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Lock } from "../../src/util/lock"
-
-function tick() {
-  return new Promise<void>((r) => queueMicrotask(r))
-}
-
-async function flush(n = 5) {
-  for (let i = 0; i < n; i++) await tick()
-}
-
-describe("util.lock", () => {
-  test("writer exclusivity: blocks reads and other writes while held", async () => {
-    const key = "lock:" + Math.random().toString(36).slice(2)
-
-    const state = {
-      writer2: false,
-      reader: false,
-      writers: 0,
-    }
-
-    // Acquire writer1
-    using writer1 = await Lock.write(key)
-    state.writers++
-    expect(state.writers).toBe(1)
-
-    // Start writer2 candidate (should block)
-    const writer2Task = (async () => {
-      const w = await Lock.write(key)
-      state.writers++
-      expect(state.writers).toBe(1)
-      state.writer2 = true
-      // Hold for a tick so reader cannot slip in
-      await tick()
-      return w
-    })()
-
-    // Start reader candidate (should block)
-    const readerTask = (async () => {
-      const r = await Lock.read(key)
-      state.reader = true
-      return r
-    })()
-
-    // Flush microtasks and assert neither acquired
-    await flush()
-    expect(state.writer2).toBe(false)
-    expect(state.reader).toBe(false)
-
-    // Release writer1
-    writer1[Symbol.dispose]()
-    state.writers--
-
-    // writer2 should acquire next
-    const writer2 = await writer2Task
-    expect(state.writer2).toBe(true)
-
-    // Reader still blocked while writer2 held
-    await flush()
-    expect(state.reader).toBe(false)
-
-    // Release writer2
-    writer2[Symbol.dispose]()
-    state.writers--
-
-    // Reader should now acquire
-    const reader = await readerTask
-    expect(state.reader).toBe(true)
-
-    reader[Symbol.dispose]()
-  })
-})

package/test/util/module.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import path from "path"
-import { Module } from "@toolkit-cli/util/module"
-import { Filesystem } from "../../src/util/filesystem"
-import { tmpdir } from "../fixture/fixture"
-
-describe("util.module", () => {
-  test("resolves package subpaths from the provided dir", async () => {
-    await using tmp = await tmpdir()
-    const root = path.join(tmp.path, "proj")
-    const file = path.join(root, "node_modules/typescript/lib/tsserver.js")
-    await Filesystem.write(file, "export {}\n")
-    await Filesystem.writeJson(path.join(root, "node_modules/typescript/package.json"), { name: "typescript" })
-
-    expect(Module.resolve("typescript/lib/tsserver.js", root)).toBe(file)
-  })
-
-  test("resolves packages through ancestor node_modules", async () => {
-    await using tmp = await tmpdir()
-    const root = path.join(tmp.path, "proj")
-    const cwd = path.join(root, "apps/web")
-    const file = path.join(root, "node_modules/eslint/lib/api.js")
-    await Filesystem.write(file, "export {}\n")
-    await Filesystem.writeJson(path.join(root, "node_modules/eslint/package.json"), {
-      name: "eslint",
-      main: "lib/api.js",
-    })
-    await Filesystem.write(path.join(cwd, ".keep"), "")
-
-    expect(Module.resolve("eslint", cwd)).toBe(file)
-  })
-
-  test("resolves relative to the provided dir", async () => {
-    await using tmp = await tmpdir()
-    const a = path.join(tmp.path, "a")
-    const b = path.join(tmp.path, "b")
-    const left = path.join(a, "node_modules/biome/index.js")
-    const right = path.join(b, "node_modules/biome/index.js")
-    await Filesystem.write(left, "export {}\n")
-    await Filesystem.write(right, "export {}\n")
-    await Filesystem.writeJson(path.join(a, "node_modules/biome/package.json"), {
-      name: "biome",
-      main: "index.js",
-    })
-    await Filesystem.writeJson(path.join(b, "node_modules/biome/package.json"), {
-      name: "biome",
-      main: "index.js",
-    })
-
-    expect(Module.resolve("biome", a)).toBe(left)
-    expect(Module.resolve("biome", b)).toBe(right)
-    expect(Module.resolve("biome", a)).not.toBe(Module.resolve("biome", b))
-  })
-
-  test("returns undefined when resolution fails", async () => {
-    await using tmp = await tmpdir()
-    expect(Module.resolve("missing-package", tmp.path)).toBeUndefined()
-  })
-})

package/test/util/process.test.ts

@@ -1,128 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-import { Process } from "../../src/util/process"
-import { tmpdir } from "../fixture/fixture"
-
-function node(script: string) {
-  return [process.execPath, "-e", script]
-}
-
-describe("util.process", () => {
-  test("captures stdout and stderr", async () => {
-    const out = await Process.run(node('process.stdout.write("out");process.stderr.write("err")'))
-    expect(out.code).toBe(0)
-    expect(out.stdout.toString()).toBe("out")
-    expect(out.stderr.toString()).toBe("err")
-  })
-
-  test("returns code when nothrow is enabled", async () => {
-    const out = await Process.run(node("process.exit(7)"), { nothrow: true })
-    expect(out.code).toBe(7)
-  })
-
-  test("throws RunFailedError on non-zero exit", async () => {
-    const err = await Process.run(node('process.stderr.write("bad");process.exit(3)')).catch((error) => error)
-    expect(err).toBeInstanceOf(Process.RunFailedError)
-    if (!(err instanceof Process.RunFailedError)) throw err
-    expect(err.code).toBe(3)
-    expect(err.stderr.toString()).toBe("bad")
-  })
-
-  test("aborts a running process", async () => {
-    const abort = new AbortController()
-    const started = Date.now()
-    setTimeout(() => abort.abort(), 25)
-
-    const out = await Process.run(node("setInterval(() => {}, 1000)"), {
-      abort: abort.signal,
-      nothrow: true,
-    })
-
-    expect(out.code).not.toBe(0)
-    expect(Date.now() - started).toBeLessThan(1000)
-  }, 3000)
-
-  test("kills after timeout when process ignores terminate signal", async () => {
-    if (process.platform === "win32") return
-
-    const abort = new AbortController()
-    const started = Date.now()
-    setTimeout(() => abort.abort(), 25)
-
-    const out = await Process.run(node('process.on("SIGTERM", () => {}); setInterval(() => {}, 1000)'), {
-      abort: abort.signal,
-      nothrow: true,
-      timeout: 25,
-    })
-
-    expect(out.code).not.toBe(0)
-    expect(Date.now() - started).toBeLessThan(1000)
-  }, 3000)
-
-  test("uses cwd when spawning commands", async () => {
-    await using tmp = await tmpdir()
-    const out = await Process.run(node("process.stdout.write(process.cwd())"), {
-      cwd: tmp.path,
-    })
-    expect(out.stdout.toString()).toBe(tmp.path)
-  })
-
-  test("merges environment overrides", async () => {
-    const out = await Process.run(node('process.stdout.write(process.env.OPENCODE_TEST ?? "")'), {
-      env: {
-        OPENCODE_TEST: "set",
-      },
-    })
-    expect(out.stdout.toString()).toBe("set")
-  })
-
-  test("uses shell in run on Windows", async () => {
-    if (process.platform !== "win32") return
-
-    const out = await Process.run(["set", "OPENCODE_TEST_SHELL"], {
-      shell: true,
-      env: {
-        OPENCODE_TEST_SHELL: "ok",
-      },
-    })
-
-    expect(out.code).toBe(0)
-    expect(out.stdout.toString()).toContain("OPENCODE_TEST_SHELL=ok")
-  })
-
-  test("runs cmd scripts with spaces on Windows without shell", 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 = Process.spawn([file, "--stdio"], {
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "pipe",
-    })
-
-    expect(await proc.exited).toBe(0)
-  })
-
-  test("rejects missing commands without leaking unhandled errors", async () => {
-    await using tmp = await tmpdir()
-    const cmd = path.join(tmp.path, "missing" + (process.platform === "win32" ? ".cmd" : ""))
-    const err = await Process.spawn([cmd], {
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "pipe",
-    }).exited.catch((err) => err)
-
-    expect(err).toBeInstanceOf(Error)
-    if (!(err instanceof Error)) throw err
-    expect(err).toMatchObject({
-      code: "ENOENT",
-    })
-  })
-})

package/test/util/timeout.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { withTimeout } from "../../src/util/timeout"
-
-describe("util.timeout", () => {
-  test("should resolve when promise completes before timeout", async () => {
-    const fastPromise = new Promise<string>((resolve) => {
-      setTimeout(() => resolve("fast"), 10)
-    })
-
-    const result = await withTimeout(fastPromise, 100)
-    expect(result).toBe("fast")
-  })
-
-  test("should reject when promise exceeds timeout", async () => {
-    const slowPromise = new Promise<string>((resolve) => {
-      setTimeout(() => resolve("slow"), 200)
-    })
-
-    await expect(withTimeout(slowPromise, 50)).rejects.toThrow("Operation timed out after 50ms")
-  })
-})

package/test/util/which.test.ts

@@ -1,100 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-import { which } from "../../src/util/which"
-import { tmpdir } from "../fixture/fixture"
-
-async function cmd(dir: string, name: string, exec = true) {
-  const ext = process.platform === "win32" ? ".cmd" : ""
-  const file = path.join(dir, name + ext)
-  const body = process.platform === "win32" ? "@echo off\r\n" : "#!/bin/sh\n"
-  await fs.writeFile(file, body)
-  if (process.platform !== "win32") {
-    await fs.chmod(file, exec ? 0o755 : 0o644)
-  }
-  return file
-}
-
-function env(PATH: string): NodeJS.ProcessEnv {
-  return {
-    PATH,
-    PATHEXT: process.env["PATHEXT"],
-  }
-}
-
-function envPath(Path: string): NodeJS.ProcessEnv {
-  return {
-    Path,
-    PathExt: process.env["PathExt"] ?? process.env["PATHEXT"],
-  }
-}
-
-function same(a: string | null, b: string) {
-  if (process.platform === "win32") {
-    expect(a?.toLowerCase()).toBe(b.toLowerCase())
-    return
-  }
-
-  expect(a).toBe(b)
-}
-
-describe("util.which", () => {
-  test("returns null when command is missing", () => {
-    expect(which("opencode-missing-command-for-test")).toBeNull()
-  })
-
-  test("finds a command from PATH override", async () => {
-    await using tmp = await tmpdir()
-    const bin = path.join(tmp.path, "bin")
-    await fs.mkdir(bin)
-    const file = await cmd(bin, "tool")
-
-    same(which("tool", env(bin)), file)
-  })
-
-  test("uses first PATH match", async () => {
-    await using tmp = await tmpdir()
-    const a = path.join(tmp.path, "a")
-    const b = path.join(tmp.path, "b")
-    await fs.mkdir(a)
-    await fs.mkdir(b)
-    const first = await cmd(a, "dupe")
-    await cmd(b, "dupe")
-
-    same(which("dupe", env([a, b].join(path.delimiter))), first)
-  })
-
-  test("returns null for non-executable file on unix", async () => {
-    if (process.platform === "win32") return
-
-    await using tmp = await tmpdir()
-    const bin = path.join(tmp.path, "bin")
-    await fs.mkdir(bin)
-    await cmd(bin, "noexec", false)
-
-    expect(which("noexec", env(bin))).toBeNull()
-  })
-
-  test("uses PATHEXT on windows", async () => {
-    if (process.platform !== "win32") return
-
-    await using tmp = await tmpdir()
-    const bin = path.join(tmp.path, "bin")
-    await fs.mkdir(bin)
-    const file = path.join(bin, "pathext.CMD")
-    await fs.writeFile(file, "@echo off\r\n")
-
-    expect(which("pathext", { PATH: bin, PATHEXT: ".CMD" })).toBe(file)
-  })
-
-  test("uses Windows Path casing fallback", async () => {
-    if (process.platform !== "win32") return
-
-    await using tmp = await tmpdir()
-    const bin = path.join(tmp.path, "bin")
-    await fs.mkdir(bin)
-    const file = await cmd(bin, "mixed")
-
-    same(which("mixed", envPath(bin)), file)
-  })
-})

package/test/util/wildcard.test.ts

@@ -1,90 +0,0 @@
-import { test, expect } from "bun:test"
-import { Wildcard } from "../../src/util/wildcard"
-
-test("match handles glob tokens", () => {
-  expect(Wildcard.match("file1.txt", "file?.txt")).toBe(true)
-  expect(Wildcard.match("file12.txt", "file?.txt")).toBe(false)
-  expect(Wildcard.match("foo+bar", "foo+bar")).toBe(true)
-})
-
-test("match with trailing space+wildcard matches command with or without args", () => {
-  // "ls *" should match "ls" (no args) and "ls -la" (with args)
-  expect(Wildcard.match("ls", "ls *")).toBe(true)
-  expect(Wildcard.match("ls -la", "ls *")).toBe(true)
-  expect(Wildcard.match("ls foo bar", "ls *")).toBe(true)
-
-  // "ls*" (no space) should NOT match "ls" alone — wait, it should because .* matches empty
-  // but it WILL match "lstmeval" which is the dangerous case users should avoid
-  expect(Wildcard.match("ls", "ls*")).toBe(true)
-  expect(Wildcard.match("lstmeval", "ls*")).toBe(true)
-
-  // "ls *" (with space) should NOT match "lstmeval"
-  expect(Wildcard.match("lstmeval", "ls *")).toBe(false)
-
-  // multi-word commands
-  expect(Wildcard.match("git status", "git *")).toBe(true)
-  expect(Wildcard.match("git", "git *")).toBe(true)
-  expect(Wildcard.match("git commit -m foo", "git *")).toBe(true)
-})
-
-test("all picks the most specific pattern", () => {
-  const rules = {
-    "*": "deny",
-    "git *": "ask",
-    "git status": "allow",
-  }
-  expect(Wildcard.all("git status", rules)).toBe("allow")
-  expect(Wildcard.all("git log", rules)).toBe("ask")
-  expect(Wildcard.all("echo hi", rules)).toBe("deny")
-})
-
-test("allStructured matches command sequences", () => {
-  const rules = {
-    "git *": "ask",
-    "git status*": "allow",
-  }
-  expect(Wildcard.allStructured({ head: "git", tail: ["status", "--short"] }, rules)).toBe("allow")
-  expect(Wildcard.allStructured({ head: "npm", tail: ["run", "build", "--watch"] }, { "npm run *": "allow" })).toBe(
-    "allow",
-  )
-  expect(Wildcard.allStructured({ head: "ls", tail: ["-la"] }, rules)).toBeUndefined()
-})
-
-test("allStructured prioritizes flag-specific patterns", () => {
-  const rules = {
-    "find *": "allow",
-    "find * -delete*": "ask",
-    "sort*": "allow",
-    "sort -o *": "ask",
-  }
-  expect(Wildcard.allStructured({ head: "find", tail: ["src", "-delete"] }, rules)).toBe("ask")
-  expect(Wildcard.allStructured({ head: "find", tail: ["src", "-print"] }, rules)).toBe("allow")
-  expect(Wildcard.allStructured({ head: "sort", tail: ["-o", "out.txt"] }, rules)).toBe("ask")
-  expect(Wildcard.allStructured({ head: "sort", tail: ["--reverse"] }, rules)).toBe("allow")
-})
-
-test("allStructured handles sed flags", () => {
-  const rules = {
-    "sed * -i*": "ask",
-    "sed -n*": "allow",
-  }
-  expect(Wildcard.allStructured({ head: "sed", tail: ["-i", "file"] }, rules)).toBe("ask")
-  expect(Wildcard.allStructured({ head: "sed", tail: ["-i.bak", "file"] }, rules)).toBe("ask")
-  expect(Wildcard.allStructured({ head: "sed", tail: ["-n", "1p", "file"] }, rules)).toBe("allow")
-  expect(Wildcard.allStructured({ head: "sed", tail: ["-i", "-n", "/./p", "myfile.txt"] }, rules)).toBe("ask")
-})
-
-test("match normalizes slashes for cross-platform globbing", () => {
-  expect(Wildcard.match("C:\\Windows\\System32\\*", "C:/Windows/System32/*")).toBe(true)
-  expect(Wildcard.match("C:/Windows/System32/drivers", "C:\\Windows\\System32\\*")).toBe(true)
-})
-
-test("match handles case-insensitivity on Windows", () => {
-  if (process.platform === "win32") {
-    expect(Wildcard.match("C:\\windows\\system32\\hosts", "C:/Windows/System32/*")).toBe(true)
-    expect(Wildcard.match("c:/windows/system32/hosts", "C:\\Windows\\System32\\*")).toBe(true)
-  } else {
-    // Unix paths are case-sensitive
-    expect(Wildcard.match("/users/test/file", "/Users/test/*")).toBe(false)
-  }
-})

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "@tsconfig/bun/tsconfig.json",
-  "compilerOptions": {
-    "jsx": "preserve",
-    "jsxImportSource": "@opentui/solid",
-    "lib": ["ESNext", "DOM", "DOM.Iterable"],
-    "types": [],
-    "noUncheckedIndexedAccess": false,
-    "customConditions": ["browser"],
-    "paths": {
-      "@/*": ["./src/*"],
-      "@tui/*": ["./src/cli/cmd/tui/*"]
-    },
-    "plugins": [
-      {
-        "name": "@effect/language-service",
-        "transform": "@effect/language-service/transform",
-        "namespaceImportPackages": ["effect", "@effect/*"]
-      }
-    ]
-  }
-}