alchemylab-opencode 1.0.6 → 1.0.8

package/packages/opencode/src/util/keybind.ts

@@ -1,103 +0,0 @@
-import { isDeepEqual } from "remeda"
-import type { ParsedKey } from "@opentui/core"
-
-export namespace Keybind {
-  /**
-   * Keybind info derived from OpenTUI's ParsedKey with our custom `leader` field.
-   * This ensures type compatibility and catches missing fields at compile time.
-   */
-  export type Info = Pick<ParsedKey, "name" | "ctrl" | "meta" | "shift" | "super"> & {
-    leader: boolean // our custom field
-  }
-
-  export function match(a: Info | undefined, b: Info): boolean {
-    if (!a) return false
-    const normalizedA = { ...a, super: a.super ?? false }
-    const normalizedB = { ...b, super: b.super ?? false }
-    return isDeepEqual(normalizedA, normalizedB)
-  }
-
-  /**
-   * Convert OpenTUI's ParsedKey to our Keybind.Info format.
-   * This helper ensures all required fields are present and avoids manual object creation.
-   */
-  export function fromParsedKey(key: ParsedKey, leader = false): Info {
-    return {
-      name: key.name === " " ? "space" : key.name,
-      ctrl: key.ctrl,
-      meta: key.meta,
-      shift: key.shift,
-      super: key.super ?? false,
-      leader,
-    }
-  }
-
-  export function toString(info: Info | undefined): string {
-    if (!info) return ""
-    const parts: string[] = []
-
-    if (info.ctrl) parts.push("ctrl")
-    if (info.meta) parts.push("alt")
-    if (info.super) parts.push("super")
-    if (info.shift) parts.push("shift")
-    if (info.name) {
-      if (info.name === "delete") parts.push("del")
-      else parts.push(info.name)
-    }
-
-    let result = parts.join("+")
-
-    if (info.leader) {
-      result = result ? `<leader> ${result}` : `<leader>`
-    }
-
-    return result
-  }
-
-  export function parse(key: string): Info[] {
-    if (key === "none") return []
-
-    return key.split(",").map((combo) => {
-      // Handle <leader> syntax by replacing with leader+
-      const normalized = combo.replace(/<leader>/g, "leader+")
-      const parts = normalized.toLowerCase().split("+")
-      const info: Info = {
-        ctrl: false,
-        meta: false,
-        shift: false,
-        leader: false,
-        name: "",
-      }
-
-      for (const part of parts) {
-        switch (part) {
-          case "ctrl":
-            info.ctrl = true
-            break
-          case "alt":
-          case "meta":
-          case "option":
-            info.meta = true
-            break
-          case "super":
-            info.super = true
-            break
-          case "shift":
-            info.shift = true
-            break
-          case "leader":
-            info.leader = true
-            break
-          case "esc":
-            info.name = "escape"
-            break
-          default:
-            info.name = part
-            break
-        }
-      }
-
-      return info
-    })
-  }
-}

package/packages/opencode/src/util/lazy.ts

@@ -1,23 +0,0 @@
-export function lazy<T>(fn: () => T) {
-  let value: T | undefined
-  let loaded = false
-
-  const result = (): T => {
-    if (loaded) return value as T
-    try {
-      value = fn()
-      loaded = true
-      return value as T
-    } catch (e) {
-      // Don't mark as loaded if initialization failed
-      throw e
-    }
-  }
-
-  result.reset = () => {
-    loaded = false
-    value = undefined
-  }
-
-  return result
-}

package/packages/opencode/src/util/locale.ts

@@ -1,81 +0,0 @@
-export namespace Locale {
-  export function titlecase(str: string) {
-    return str.replace(/\b\w/g, (c) => c.toUpperCase())
-  }
-
-  export function time(input: number): string {
-    const date = new Date(input)
-    return date.toLocaleTimeString(undefined, { timeStyle: "short" })
-  }
-
-  export function datetime(input: number): string {
-    const date = new Date(input)
-    const localTime = time(input)
-    const localDate = date.toLocaleDateString()
-    return `${localTime} · ${localDate}`
-  }
-
-  export function todayTimeOrDateTime(input: number): string {
-    const date = new Date(input)
-    const now = new Date()
-    const isToday =
-      date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth() && date.getDate() === now.getDate()
-
-    if (isToday) {
-      return time(input)
-    } else {
-      return datetime(input)
-    }
-  }
-
-  export function number(num: number): string {
-    if (num >= 1000000) {
-      return (num / 1000000).toFixed(1) + "M"
-    } else if (num >= 1000) {
-      return (num / 1000).toFixed(1) + "K"
-    }
-    return num.toString()
-  }
-
-  export function duration(input: number) {
-    if (input < 1000) {
-      return `${input}ms`
-    }
-    if (input < 60000) {
-      return `${(input / 1000).toFixed(1)}s`
-    }
-    if (input < 3600000) {
-      const minutes = Math.floor(input / 60000)
-      const seconds = Math.floor((input % 60000) / 1000)
-      return `${minutes}m ${seconds}s`
-    }
-    if (input < 86400000) {
-      const hours = Math.floor(input / 3600000)
-      const minutes = Math.floor((input % 3600000) / 60000)
-      return `${hours}h ${minutes}m`
-    }
-    const hours = Math.floor(input / 3600000)
-    const days = Math.floor((input % 3600000) / 86400000)
-    return `${days}d ${hours}h`
-  }
-
-  export function truncate(str: string, len: number): string {
-    if (str.length <= len) return str
-    return str.slice(0, len - 1) + "…"
-  }
-
-  export function truncateMiddle(str: string, maxLength: number = 35): string {
-    if (str.length <= maxLength) return str
-
-    const ellipsis = "…"
-    const keepStart = Math.ceil((maxLength - ellipsis.length) / 2)
-    const keepEnd = Math.floor((maxLength - ellipsis.length) / 2)
-
-    return str.slice(0, keepStart) + ellipsis + str.slice(-keepEnd)
-  }
-
-  export function pluralize(count: number, singular: string, plural: string): string {
-    const template = count === 1 ? singular : plural
-    return template.replace("{}", count.toString())
-  }
-}

package/packages/opencode/src/util/lock.ts

@@ -1,98 +0,0 @@
-export namespace Lock {
-  const locks = new Map<
-    string,
-    {
-      readers: number
-      writer: boolean
-      waitingReaders: (() => void)[]
-      waitingWriters: (() => void)[]
-    }
-  >()
-
-  function get(key: string) {
-    if (!locks.has(key)) {
-      locks.set(key, {
-        readers: 0,
-        writer: false,
-        waitingReaders: [],
-        waitingWriters: [],
-      })
-    }
-    return locks.get(key)!
-  }
-
-  function process(key: string) {
-    const lock = locks.get(key)
-    if (!lock || lock.writer || lock.readers > 0) return
-
-    // Prioritize writers to prevent starvation
-    if (lock.waitingWriters.length > 0) {
-      const nextWriter = lock.waitingWriters.shift()!
-      nextWriter()
-      return
-    }
-
-    // Wake up all waiting readers
-    while (lock.waitingReaders.length > 0) {
-      const nextReader = lock.waitingReaders.shift()!
-      nextReader()
-    }
-
-    // Clean up empty locks
-    if (lock.readers === 0 && !lock.writer && lock.waitingReaders.length === 0 && lock.waitingWriters.length === 0) {
-      locks.delete(key)
-    }
-  }
-
-  export async function read(key: string): Promise<Disposable> {
-    const lock = get(key)
-
-    return new Promise((resolve) => {
-      if (!lock.writer && lock.waitingWriters.length === 0) {
-        lock.readers++
-        resolve({
-          [Symbol.dispose]: () => {
-            lock.readers--
-            process(key)
-          },
-        })
-      } else {
-        lock.waitingReaders.push(() => {
-          lock.readers++
-          resolve({
-            [Symbol.dispose]: () => {
-              lock.readers--
-              process(key)
-            },
-          })
-        })
-      }
-    })
-  }
-
-  export async function write(key: string): Promise<Disposable> {
-    const lock = get(key)
-
-    return new Promise((resolve) => {
-      if (!lock.writer && lock.readers === 0) {
-        lock.writer = true
-        resolve({
-          [Symbol.dispose]: () => {
-            lock.writer = false
-            process(key)
-          },
-        })
-      } else {
-        lock.waitingWriters.push(() => {
-          lock.writer = true
-          resolve({
-            [Symbol.dispose]: () => {
-              lock.writer = false
-              process(key)
-            },
-          })
-        })
-      }
-    })
-  }
-}

package/packages/opencode/src/util/log.ts

@@ -1,182 +0,0 @@
-import path from "path"
-import fs from "fs/promises"
-import { createWriteStream } from "fs"
-import { Global } from "../global"
-import z from "zod"
-import { Glob } from "./glob"
-
-export namespace Log {
-  export const Level = z.enum(["DEBUG", "INFO", "WARN", "ERROR"]).meta({ ref: "LogLevel", description: "Log level" })
-  export type Level = z.infer<typeof Level>
-
-  const levelPriority: Record<Level, number> = {
-    DEBUG: 0,
-    INFO: 1,
-    WARN: 2,
-    ERROR: 3,
-  }
-
-  let level: Level = "INFO"
-
-  function shouldLog(input: Level): boolean {
-    return levelPriority[input] >= levelPriority[level]
-  }
-
-  export type Logger = {
-    debug(message?: any, extra?: Record<string, any>): void
-    info(message?: any, extra?: Record<string, any>): void
-    error(message?: any, extra?: Record<string, any>): void
-    warn(message?: any, extra?: Record<string, any>): void
-    tag(key: string, value: string): Logger
-    clone(): Logger
-    time(
-      message: string,
-      extra?: Record<string, any>,
-    ): {
-      stop(): void
-      [Symbol.dispose](): void
-    }
-  }
-
-  const loggers = new Map<string, Logger>()
-
-  export const Default = create({ service: "default" })
-
-  export interface Options {
-    print: boolean
-    dev?: boolean
-    level?: Level
-  }
-
-  let logpath = ""
-  export function file() {
-    return logpath
-  }
-  let write = (msg: any) => {
-    process.stderr.write(msg)
-    return msg.length
-  }
-
-  export async function init(options: Options) {
-    if (options.level) level = options.level
-    cleanup(Global.Path.log)
-    if (options.print) return
-    logpath = path.join(
-      Global.Path.log,
-      options.dev ? "dev.log" : new Date().toISOString().split(".")[0].replace(/:/g, "") + ".log",
-    )
-    await fs.truncate(logpath).catch(() => {})
-    const stream = createWriteStream(logpath, { flags: "a" })
-    write = async (msg: any) => {
-      return new Promise((resolve, reject) => {
-        stream.write(msg, (err) => {
-          if (err) reject(err)
-          else resolve(msg.length)
-        })
-      })
-    }
-  }
-
-  async function cleanup(dir: string) {
-    const files = await Glob.scan("????-??-??T??????.log", {
-      cwd: dir,
-      absolute: true,
-      include: "file",
-    })
-    if (files.length <= 5) return
-
-    const filesToDelete = files.slice(0, -10)
-    await Promise.all(filesToDelete.map((file) => fs.unlink(file).catch(() => {})))
-  }
-
-  function formatError(error: Error, depth = 0): string {
-    const result = error.message
-    return error.cause instanceof Error && depth < 10
-      ? result + " Caused by: " + formatError(error.cause, depth + 1)
-      : result
-  }
-
-  let last = Date.now()
-  export function create(tags?: Record<string, any>) {
-    tags = tags || {}
-
-    const service = tags["service"]
-    if (service && typeof service === "string") {
-      const cached = loggers.get(service)
-      if (cached) {
-        return cached
-      }
-    }
-
-    function build(message: any, extra?: Record<string, any>) {
-      const prefix = Object.entries({
-        ...tags,
-        ...extra,
-      })
-        .filter(([_, value]) => value !== undefined && value !== null)
-        .map(([key, value]) => {
-          const prefix = `${key}=`
-          if (value instanceof Error) return prefix + formatError(value)
-          if (typeof value === "object") return prefix + JSON.stringify(value)
-          return prefix + value
-        })
-        .join(" ")
-      const next = new Date()
-      const diff = next.getTime() - last
-      last = next.getTime()
-      return [next.toISOString().split(".")[0], "+" + diff + "ms", prefix, message].filter(Boolean).join(" ") + "\n"
-    }
-    const result: Logger = {
-      debug(message?: any, extra?: Record<string, any>) {
-        if (shouldLog("DEBUG")) {
-          write("DEBUG " + build(message, extra))
-        }
-      },
-      info(message?: any, extra?: Record<string, any>) {
-        if (shouldLog("INFO")) {
-          write("INFO  " + build(message, extra))
-        }
-      },
-      error(message?: any, extra?: Record<string, any>) {
-        if (shouldLog("ERROR")) {
-          write("ERROR " + build(message, extra))
-        }
-      },
-      warn(message?: any, extra?: Record<string, any>) {
-        if (shouldLog("WARN")) {
-          write("WARN  " + build(message, extra))
-        }
-      },
-      tag(key: string, value: string) {
-        if (tags) tags[key] = value
-        return result
-      },
-      clone() {
-        return Log.create({ ...tags })
-      },
-      time(message: string, extra?: Record<string, any>) {
-        const now = Date.now()
-        result.info(message, { status: "started", ...extra })
-        function stop() {
-          result.info(message, {
-            status: "completed",
-            duration: Date.now() - now,
-            ...extra,
-          })
-        }
-        return {
-          stop,
-          [Symbol.dispose]() {
-            stop()
-          },
-        }
-      },
-    }
-
-    if (service && typeof service === "string") {
-      loggers.set(service, result)
-    }
-
-    return result
-  }
-}

package/packages/opencode/src/util/network.ts

@@ -1,9 +0,0 @@
-export function online() {
-  const nav = globalThis.navigator
-  if (!nav || typeof nav.onLine !== "boolean") return true
-  return nav.onLine
-}
-
-export function proxied() {
-  return !!(process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.https_proxy)
-}

package/packages/opencode/src/util/process.ts

@@ -1,176 +0,0 @@
-import { type ChildProcess } from "child_process"
-import launch from "cross-spawn"
-import { buffer } from "node:stream/consumers"
-import { errorMessage } from "./error"
-
-export namespace Process {
-  export type Stdio = "inherit" | "pipe" | "ignore"
-  export type Shell = boolean | string
-
-  export interface Options {
-    cwd?: string
-    env?: NodeJS.ProcessEnv | null
-    stdin?: Stdio
-    stdout?: Stdio
-    stderr?: Stdio
-    shell?: Shell
-    abort?: AbortSignal
-    kill?: NodeJS.Signals | number
-    timeout?: number
-  }
-
-  export interface RunOptions extends Omit<Options, "stdout" | "stderr"> {
-    nothrow?: boolean
-  }
-
-  export interface Result {
-    code: number
-    stdout: Buffer
-    stderr: Buffer
-  }
-
-  export interface TextResult extends Result {
-    text: string
-  }
-
-  export class RunFailedError extends Error {
-    readonly cmd: string[]
-    readonly code: number
-    readonly stdout: Buffer
-    readonly stderr: Buffer
-
-    constructor(cmd: string[], code: number, stdout: Buffer, stderr: Buffer) {
-      const text = stderr.toString().trim()
-      super(
-        text
-          ? `Command failed with code ${code}: ${cmd.join(" ")}\n${text}`
-          : `Command failed with code ${code}: ${cmd.join(" ")}`,
-      )
-      this.name = "ProcessRunFailedError"
-      this.cmd = [...cmd]
-      this.code = code
-      this.stdout = stdout
-      this.stderr = stderr
-    }
-  }
-
-  export type Child = ChildProcess & { exited: Promise<number> }
-
-  export function spawn(cmd: string[], opts: Options = {}): Child {
-    if (cmd.length === 0) throw new Error("Command is required")
-    opts.abort?.throwIfAborted()
-
-    const proc = launch(cmd[0], cmd.slice(1), {
-      cwd: opts.cwd,
-      shell: opts.shell,
-      env: opts.env === null ? {} : opts.env ? { ...process.env, ...opts.env } : undefined,
-      stdio: [opts.stdin ?? "ignore", opts.stdout ?? "ignore", opts.stderr ?? "ignore"],
-      windowsHide: process.platform === "win32",
-    })
-
-    let closed = false
-    let timer: ReturnType<typeof setTimeout> | undefined
-
-    const abort = () => {
-      if (closed) return
-      if (proc.exitCode !== null || proc.signalCode !== null) return
-      closed = true
-
-      proc.kill(opts.kill ?? "SIGTERM")
-
-      const ms = opts.timeout ?? 5_000
-      if (ms <= 0) return
-      timer = setTimeout(() => proc.kill("SIGKILL"), ms)
-    }
-
-    const exited = new Promise<number>((resolve, reject) => {
-      const done = () => {
-        opts.abort?.removeEventListener("abort", abort)
-        if (timer) clearTimeout(timer)
-      }
-
-      proc.once("exit", (code, signal) => {
-        done()
-        resolve(code ?? (signal ? 1 : 0))
-      })
-
-      proc.once("error", (error) => {
-        done()
-        reject(error)
-      })
-    })
-    void exited.catch(() => undefined)
-
-    if (opts.abort) {
-      opts.abort.addEventListener("abort", abort, { once: true })
-      if (opts.abort.aborted) abort()
-    }
-
-    const child = proc as Child
-    child.exited = exited
-    return child
-  }
-
-  export async function run(cmd: string[], opts: RunOptions = {}): Promise<Result> {
-    const proc = spawn(cmd, {
-      cwd: opts.cwd,
-      env: opts.env,
-      stdin: opts.stdin,
-      shell: opts.shell,
-      abort: opts.abort,
-      kill: opts.kill,
-      timeout: opts.timeout,
-      stdout: "pipe",
-      stderr: "pipe",
-    })
-
-    if (!proc.stdout || !proc.stderr) throw new Error("Process output not available")
-
-    const out = await Promise.all([proc.exited, buffer(proc.stdout), buffer(proc.stderr)])
-      .then(([code, stdout, stderr]) => ({
-        code,
-        stdout,
-        stderr,
-      }))
-      .catch((err: unknown) => {
-        if (!opts.nothrow) throw err
-        return {
-          code: 1,
-          stdout: Buffer.alloc(0),
-          stderr: Buffer.from(errorMessage(err)),
-        }
-      })
-    if (out.code === 0 || opts.nothrow) return out
-    throw new RunFailedError(cmd, out.code, out.stdout, out.stderr)
-  }
-
-  // Duplicated in `packages/sdk/js/src/process.ts` because the SDK cannot import
-  // `opencode` without creating a cycle. Keep both copies in sync.
-  export async function stop(proc: ChildProcess) {
-    if (proc.exitCode !== null || proc.signalCode !== null) return
-
-    if (process.platform !== "win32" || !proc.pid) {
-      proc.kill()
-      return
-    }
-
-    const out = await run(["taskkill", "/pid", String(proc.pid), "/T", "/F"], {
-      nothrow: true,
-    })
-
-    if (out.code === 0) return
-    proc.kill()
-  }
-
-  export async function text(cmd: string[], opts: RunOptions = {}): Promise<TextResult> {
-    const out = await run(cmd, opts)
-    return {
-      ...out,
-      text: out.stdout.toString(),
-    }
-  }
-
-  export async function lines(cmd: string[], opts: RunOptions = {}): Promise<string[]> {
-    return (await text(cmd, opts)).text.split(/\r?\n/).filter(Boolean)
-  }
-}

package/packages/opencode/src/util/queue.ts

@@ -1,32 +0,0 @@
-export class AsyncQueue<T> implements AsyncIterable<T> {
-  private queue: T[] = []
-  private resolvers: ((value: T) => void)[] = []
-
-  push(item: T) {
-    const resolve = this.resolvers.shift()
-    if (resolve) resolve(item)
-    else this.queue.push(item)
-  }
-
-  async next(): Promise<T> {
-    if (this.queue.length > 0) return this.queue.shift()!
-    return new Promise((resolve) => this.resolvers.push(resolve))
-  }
-
-  async *[Symbol.asyncIterator]() {
-    while (true) yield await this.next()
-  }
-}
-
-export async function work<T>(concurrency: number, items: T[], fn: (item: T) => Promise<void>) {
-  const pending = [...items]
-  await Promise.all(
-    Array.from({ length: concurrency }, async () => {
-      while (true) {
-        const item = pending.pop()
-        if (item === undefined) return
-        await fn(item)
-      }
-    }),
-  )
-}