@stonerzju/opencode 1.2.16-offline.1 → 1.2.18

package/test/util/iife.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { iife } from "../../src/util/iife"
-
-describe("util.iife", () => {
-  test("should execute function immediately and return result", () => {
-    let called = false
-    const result = iife(() => {
-      called = true
-      return 42
-    })
-
-    expect(called).toBe(true)
-    expect(result).toBe(42)
-  })
-
-  test("should work with async functions", async () => {
-    let called = false
-    const result = await iife(async () => {
-      called = true
-      return "async result"
-    })
-
-    expect(called).toBe(true)
-    expect(result).toBe("async result")
-  })
-
-  test("should handle functions with no return value", () => {
-    let called = false
-    const result = iife(() => {
-      called = true
-    })
-
-    expect(called).toBe(true)
-    expect(result).toBeUndefined()
-  })
-})

package/test/util/lazy.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { lazy } from "../../src/util/lazy"
-
-describe("util.lazy", () => {
-  test("should call function only once", () => {
-    let callCount = 0
-    const getValue = () => {
-      callCount++
-      return "expensive value"
-    }
-
-    const lazyValue = lazy(getValue)
-
-    expect(callCount).toBe(0)
-
-    const result1 = lazyValue()
-    expect(result1).toBe("expensive value")
-    expect(callCount).toBe(1)
-
-    const result2 = lazyValue()
-    expect(result2).toBe("expensive value")
-    expect(callCount).toBe(1)
-  })
-
-  test("should preserve the same reference", () => {
-    const obj = { value: 42 }
-    const lazyObj = lazy(() => obj)
-
-    const result1 = lazyObj()
-    const result2 = lazyObj()
-
-    expect(result1).toBe(obj)
-    expect(result2).toBe(obj)
-    expect(result1).toBe(result2)
-  })
-
-  test("should work with different return types", () => {
-    const lazyString = lazy(() => "string")
-    const lazyNumber = lazy(() => 123)
-    const lazyBoolean = lazy(() => true)
-    const lazyNull = lazy(() => null)
-    const lazyUndefined = lazy(() => undefined)
-
-    expect(lazyString()).toBe("string")
-    expect(lazyNumber()).toBe(123)
-    expect(lazyBoolean()).toBe(true)
-    expect(lazyNull()).toBe(null)
-    expect(lazyUndefined()).toBe(undefined)
-  })
-})

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/process.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Process } from "../../src/util/process"
-
-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)
-})

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/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,16 +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/*"]
-    }
-  }
-}