tulingcode 0.1.0

package/src/util/fn.ts

@@ -0,0 +1,21 @@
+import { z } from "zod"
+
+export function fn<T extends z.ZodType, Result>(schema: T, cb: (input: z.infer<T>) => Result) {
+  const result = (input: z.infer<T>) => {
+    let parsed
+    try {
+      parsed = schema.parse(input)
+    } catch (e) {
+      console.trace("schema validation failure stack trace:")
+      if (e instanceof z.ZodError) {
+        console.error("schema validation issues:", JSON.stringify(e.issues, null, 2))
+      }
+      throw e
+    }
+
+    return cb(parsed)
+  }
+  result.force = (input: z.infer<T>) => cb(input)
+  result.schema = schema
+  return result
+}

package/src/util/format.ts

@@ -0,0 +1,20 @@
+export function formatDuration(secs: number) {
+  if (secs <= 0) return ""
+  if (secs < 60) return `${secs}s`
+  if (secs < 3600) {
+    const mins = Math.floor(secs / 60)
+    const remaining = secs % 60
+    return remaining > 0 ? `${mins}m ${remaining}s` : `${mins}m`
+  }
+  if (secs < 86400) {
+    const hours = Math.floor(secs / 3600)
+    const remaining = Math.floor((secs % 3600) / 60)
+    return remaining > 0 ? `${hours}h ${remaining}m` : `${hours}h`
+  }
+  if (secs < 604800) {
+    const days = Math.floor(secs / 86400)
+    return days === 1 ? "~1 day" : `~${days} days`
+  }
+  const weeks = Math.floor(secs / 604800)
+  return weeks === 1 ? "~1 week" : `~${weeks} weeks`
+}

package/src/util/iife.ts

@@ -0,0 +1,3 @@
+export function iife<T>(fn: () => T) {
+  return fn()
+}

package/src/util/index.ts

@@ -0,0 +1,12 @@
+export * as Archive from "./archive"
+export * as Color from "./color"
+export * as Filesystem from "./filesystem"
+export * as Keybind from "./keybind"
+export * as LocalContext from "./local-context"
+export * as Locale from "./locale"
+export * as Lock from "./lock"
+export * as Log from "./log"
+export * as Process from "./process"
+export * as Rpc from "./rpc"
+export * as Token from "./token"
+export * as Wildcard from "./wildcard"

package/src/util/keybind.ts

@@ -0,0 +1,101 @@
+import { isDeepEqual } from "remeda"
+import type { ParsedKey } from "@opentui/core"
+
+/**
+ * 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/src/util/lazy.ts

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

package/src/util/local-context.ts

@@ -0,0 +1,23 @@
+import { AsyncLocalStorage } from "async_hooks"
+
+export class NotFound extends Error {
+  constructor(public override readonly name: string) {
+    super(`No context found for ${name}`)
+  }
+}
+
+export function create<T>(name: string) {
+  const storage = new AsyncLocalStorage<T>()
+  return {
+    use() {
+      const result = storage.getStore()
+      if (!result) {
+        throw new NotFound(name)
+      }
+      return result
+    },
+    provide<R>(value: T, fn: () => R) {
+      return storage.run(value, fn)
+    },
+  }
+}

package/src/util/locale.ts

@@ -0,0 +1,79 @@
+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,96 @@
+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,197 @@
+import path from "path"
+import fs from "fs/promises"
+import { createWriteStream } from "fs"
+import { Global } from "../global"
+import z from "zod"
+import { Glob } from "@tuling-ai/shared/util/glob"
+
+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,
+}
+const keep = 10
+
+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
+  void 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",
+  )
+  if (options.dev) {
+    // Preserve previous dev.log as dev.log.<timestamp> for hang/incident
+    // forensics. cleanup() above already prunes old timestamped logs.
+    try {
+      const stat = await fs.stat(logpath).catch(() => null)
+      if (stat && stat.size > 0) {
+        const stamp = new Date().toISOString().split(".")[0].replace(/:/g, "")
+        await fs.rename(logpath, `${logpath}.${stamp}`).catch(() => {})
+      }
+    } catch {}
+  } else {
+    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: false,
+      include: "file",
+    }).catch(() => [])
+  )
+    .filter((file) => path.basename(file) === file)
+    .sort()
+  if (files.length <= keep) return
+
+  const doomed = files.slice(0, -keep)
+  await Promise.all(doomed.map((file) => fs.unlink(path.join(dir, 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 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/media.ts

@@ -0,0 +1,26 @@
+const startsWith = (bytes: Uint8Array, prefix: number[]) => prefix.every((value, index) => bytes[index] === value)
+
+export function isPdfAttachment(mime: string) {
+  return mime === "application/pdf"
+}
+
+export function isMedia(mime: string) {
+  return mime.startsWith("image/") || isPdfAttachment(mime)
+}
+
+export function isImageAttachment(mime: string) {
+  return mime.startsWith("image/") && mime !== "image/svg+xml" && mime !== "image/vnd.fastbidsheet"
+}
+
+export function sniffAttachmentMime(bytes: Uint8Array, fallback: string) {
+  if (startsWith(bytes, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) return "image/png"
+  if (startsWith(bytes, [0xff, 0xd8, 0xff])) return "image/jpeg"
+  if (startsWith(bytes, [0x47, 0x49, 0x46, 0x38])) return "image/gif"
+  if (startsWith(bytes, [0x42, 0x4d])) return "image/bmp"
+  if (startsWith(bytes, [0x25, 0x50, 0x44, 0x46, 0x2d])) return "application/pdf"
+  if (startsWith(bytes, [0x52, 0x49, 0x46, 0x46]) && startsWith(bytes.subarray(8), [0x57, 0x45, 0x42, 0x50])) {
+    return "image/webp"
+  }
+
+  return fallback
+}

package/src/util/mimo-process.ts

@@ -0,0 +1,24 @@
+export const tulingcode_RUN_ID = "tulingcode_RUN_ID"
+export const tulingcode_PROCESS_ROLE = "tulingcode_PROCESS_ROLE"
+
+export function ensureRunID() {
+  return (process.env[tulingcode_RUN_ID] ??= crypto.randomUUID())
+}
+
+export function ensureProcessRole(fallback: "main" | "worker") {
+  return (process.env[tulingcode_PROCESS_ROLE] ??= fallback)
+}
+
+export function ensureProcessMetadata(fallback: "main" | "worker") {
+  return {
+    runID: ensureRunID(),
+    processRole: ensureProcessRole(fallback),
+  }
+}
+
+export function sanitizedProcessEnv(overrides?: Record<string, string>) {
+  const env = Object.fromEntries(
+    Object.entries(process.env).filter((entry): entry is [string, string] => entry[1] !== undefined),
+  )
+  return overrides ? Object.assign(env, overrides) : env
+}

package/src/util/network.ts

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