bincode-cli 1.0.1

package/src/util/keybind.ts

@@ -0,0 +1,102 @@
+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, b: Info): boolean {
+    // Normalize super field (undefined and false are equivalent)
+    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,
+      ctrl: key.ctrl,
+      meta: key.meta,
+      shift: key.shift,
+      super: key.super ?? false,
+      leader,
+    }
+  }
+
+  export function toString(info: Info): string {
+    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/src/util/lazy.ts

@@ -0,0 +1,11 @@
+export function lazy<T>(fn: () => T) {
+  let value: T | undefined
+  let loaded = false
+
+  return (): T => {
+    if (loaded) return value as T
+    loaded = true
+    value = fn()
+    return value as T
+  }
+}

package/src/util/locale.ts

@@ -0,0 +1,81 @@
+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/src/util/lock.ts

@@ -0,0 +1,98 @@
+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/src/util/log.ts

@@ -0,0 +1,180 @@
+import path from "path"
+import fs from "fs/promises"
+import { Global } from "../global"
+import z from "zod"
+
+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",
+    )
+    const logfile = Bun.file(logpath)
+    await fs.truncate(logpath).catch(() => {})
+    const writer = logfile.writer()
+    write = async (msg: any) => {
+      const num = writer.write(msg)
+      writer.flush()
+      return num
+    }
+  }
+
+  async function cleanup(dir: string) {
+    const glob = new Bun.Glob("????-??-??T??????.log")
+    const files = await Array.fromAsync(
+      glob.scan({
+        cwd: dir,
+        absolute: true,
+      }),
+    )
+    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/src/util/queue.ts

@@ -0,0 +1,32 @@
+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)
+      }
+    }),
+  )
+}

package/src/util/rpc.ts

@@ -0,0 +1,42 @@
+export namespace Rpc {
+  type Definition = {
+    [method: string]: (input: any) => any
+  }
+
+  export function listen(rpc: Definition) {
+    onmessage = async (evt) => {
+      const parsed = JSON.parse(evt.data)
+      if (parsed.type === "rpc.request") {
+        const result = await rpc[parsed.method](parsed.input)
+        postMessage(JSON.stringify({ type: "rpc.result", result, id: parsed.id }))
+      }
+    }
+  }
+
+  export function client<T extends Definition>(target: {
+    postMessage: (data: string) => void | null
+    onmessage: ((this: Worker, ev: MessageEvent<any>) => any) | null
+  }) {
+    const pending = new Map<number, (result: any) => void>()
+    let id = 0
+    target.onmessage = async (evt) => {
+      const parsed = JSON.parse(evt.data)
+      if (parsed.type === "rpc.result") {
+        const resolve = pending.get(parsed.id)
+        if (resolve) {
+          resolve(parsed.result)
+          pending.delete(parsed.id)
+        }
+      }
+    }
+    return {
+      call<Method extends keyof T>(method: Method, input: Parameters<T[Method]>[0]): Promise<ReturnType<T[Method]>> {
+        const requestId = id++
+        return new Promise((resolve) => {
+          pending.set(requestId, resolve)
+          target.postMessage(JSON.stringify({ type: "rpc.request", method, input, id: requestId }))
+        })
+      },
+    }
+  }
+}

package/src/util/scrap.ts

@@ -0,0 +1,10 @@
+export const foo: string = "42"
+export const bar: number = 123
+
+export function dummyFunction(): void {
+  console.log("This is a dummy function")
+}
+
+export function randomHelper(): boolean {
+  return Math.random() > 0.5
+}

package/src/util/signal.ts

@@ -0,0 +1,12 @@
+export function signal() {
+  let resolve: any
+  const promise = new Promise((r) => (resolve = r))
+  return {
+    trigger() {
+      return resolve()
+    },
+    wait() {
+      return promise
+    },
+  }
+}

package/src/util/timeout.ts

@@ -0,0 +1,14 @@
+export function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
+  let timeout: NodeJS.Timeout
+  return Promise.race([
+    promise.then((result) => {
+      clearTimeout(timeout)
+      return result
+    }),
+    new Promise<never>((_, reject) => {
+      timeout = setTimeout(() => {
+        reject(new Error(`Operation timed out after ${ms}ms`))
+      }, ms)
+    }),
+  ])
+}

package/src/util/token.ts

@@ -0,0 +1,7 @@
+export namespace Token {
+  const CHARS_PER_TOKEN = 4
+
+  export function estimate(input: string) {
+    return Math.max(0, Math.round((input || "").length / CHARS_PER_TOKEN))
+  }
+}

package/src/util/wildcard.ts

@@ -0,0 +1,54 @@
+import { sortBy, pipe } from "remeda"
+
+export namespace Wildcard {
+  export function match(str: string, pattern: string) {
+    const regex = new RegExp(
+      "^" +
+        pattern
+          .replace(/[.+^${}()|[\]\\]/g, "\\$&") // escape special regex chars
+          .replace(/\*/g, ".*") // * becomes .*
+          .replace(/\?/g, ".") + // ? becomes .
+        "$",
+      "s", // s flag enables multiline matching
+    )
+    return regex.test(str)
+  }
+
+  export function all(input: string, patterns: Record<string, any>) {
+    const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
+    let result = undefined
+    for (const [pattern, value] of sorted) {
+      if (match(input, pattern)) {
+        result = value
+        continue
+      }
+    }
+    return result
+  }
+
+  export function allStructured(input: { head: string; tail: string[] }, patterns: Record<string, any>) {
+    const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
+    let result = undefined
+    for (const [pattern, value] of sorted) {
+      const parts = pattern.split(/\s+/)
+      if (!match(input.head, parts[0])) continue
+      if (parts.length === 1 || matchSequence(input.tail, parts.slice(1))) {
+        result = value
+        continue
+      }
+    }
+    return result
+  }
+
+  function matchSequence(items: string[], patterns: string[]): boolean {
+    if (patterns.length === 0) return true
+    const [pattern, ...rest] = patterns
+    if (pattern === "*") return matchSequence(items, rest)
+    for (let i = 0; i < items.length; i++) {
+      if (match(items[i], pattern) && matchSequence(items.slice(i + 1), rest)) {
+        return true
+      }
+    }
+    return false
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "$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/*"]
+    }
+  }
+}