@sleepy-ai/cli 0.1.6 → 0.1.8

package/src/util/error.ts

@@ -1,78 +0,0 @@
-import { isRecord } from "./record"
-
-export function errorFormat(error: unknown): string {
-  if (error instanceof Error) {
-    return error.stack ?? `${error.name}: ${error.message}`
-  }
-
-  if (typeof error === "object" && error !== null) {
-    try {
-      return JSON.stringify(error, null, 2)
-    } catch {
-      return "Unexpected error (unserializable)"
-    }
-  }
-
-  return String(error)
-}
-
-export function errorMessage(error: unknown): string {
-  if (error instanceof Error) {
-    if (error.message) return error.message
-    if (error.name) return error.name
-  }
-
-  if (isRecord(error) && typeof error.message === "string" && error.message) {
-    return error.message
-  }
-
-  const text = String(error)
-  if (text && text !== "[object Object]") return text
-
-  const formatted = errorFormat(error)
-  if (formatted && formatted !== "{}") return formatted
-  return "unknown error"
-}
-
-export function errorData(error: unknown) {
-  if (error instanceof Error) {
-    return {
-      type: error.name,
-      message: errorMessage(error),
-      stack: error.stack,
-      cause: error.cause === undefined ? undefined : errorFormat(error.cause),
-      formatted: errorFormatted(error),
-    }
-  }
-
-  if (!isRecord(error)) {
-    return {
-      type: typeof error,
-      message: errorMessage(error),
-      formatted: errorFormatted(error),
-    }
-  }
-
-  const data = Object.getOwnPropertyNames(error).reduce<Record<string, unknown>>((acc, key) => {
-    const value = error[key]
-    if (value === undefined) return acc
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      acc[key] = value
-      return acc
-    }
-    // oxlint-disable-next-line no-base-to-string -- intentional coercion of arbitrary error properties
-    acc[key] = value instanceof Error ? value.message : String(value)
-    return acc
-  }, {})
-
-  if (typeof data.message !== "string") data.message = errorMessage(error)
-  if (typeof data.type !== "string") data.type = error.constructor?.name
-  data.formatted = errorFormatted(error)
-  return data
-}
-
-function errorFormatted(error: unknown) {
-  const formatted = errorFormat(error)
-  if (formatted !== "{}") return formatted
-  return String(error)
-}

package/src/util/filesystem.ts

@@ -1,243 +0,0 @@
-import { chmod, mkdir, readFile, stat as statFile, writeFile } from "fs/promises"
-import { createWriteStream, existsSync, statSync } from "fs"
-import { realpathSync } from "fs"
-import { dirname, join, relative, resolve as pathResolve, win32 } from "path"
-import { Readable } from "stream"
-import { pipeline } from "stream/promises"
-import { Glob } from "@sleepy-ai/shared/util/glob"
-
-// Fast sync version for metadata checks
-export async function exists(p: string): Promise<boolean> {
-  return existsSync(p)
-}
-
-export async function isDir(p: string): Promise<boolean> {
-  try {
-    return statSync(p).isDirectory()
-  } catch {
-    return false
-  }
-}
-
-export function stat(p: string): ReturnType<typeof statSync> | undefined {
-  return statSync(p, { throwIfNoEntry: false }) ?? undefined
-}
-
-export async function statAsync(p: string): Promise<ReturnType<typeof statSync> | undefined> {
-  return statFile(p).catch((e) => {
-    if (isEnoent(e)) return undefined
-    throw e
-  })
-}
-
-export async function size(p: string): Promise<number> {
-  const s = stat(p)?.size ?? 0
-  return typeof s === "bigint" ? Number(s) : s
-}
-
-export async function readText(p: string): Promise<string> {
-  return readFile(p, "utf-8")
-}
-
-export async function readJson<T = unknown>(p: string): Promise<T> {
-  return JSON.parse(await readFile(p, "utf-8"))
-}
-
-export async function readBytes(p: string): Promise<Buffer> {
-  return readFile(p)
-}
-
-export async function readArrayBuffer(p: string): Promise<ArrayBuffer> {
-  const buf = await readFile(p)
-  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength) as ArrayBuffer
-}
-
-function isEnoent(e: unknown): e is { code: "ENOENT" } {
-  return typeof e === "object" && e !== null && "code" in e && (e as { code: string }).code === "ENOENT"
-}
-
-export async function write(p: string, content: string | Buffer | Uint8Array, mode?: number): Promise<void> {
-  try {
-    if (mode) {
-      await writeFile(p, content, { mode })
-    } else {
-      await writeFile(p, content)
-    }
-  } catch (e) {
-    if (isEnoent(e)) {
-      await mkdir(dirname(p), { recursive: true })
-      if (mode) {
-        await writeFile(p, content, { mode })
-      } else {
-        await writeFile(p, content)
-      }
-      return
-    }
-    throw e
-  }
-}
-
-export async function writeJson(p: string, data: unknown, mode?: number): Promise<void> {
-  return write(p, JSON.stringify(data, null, 2), mode)
-}
-
-export async function writeStream(
-  p: string,
-  stream: ReadableStream<Uint8Array> | Readable,
-  mode?: number,
-): Promise<void> {
-  const dir = dirname(p)
-  if (!existsSync(dir)) {
-    await mkdir(dir, { recursive: true })
-  }
-
-  const nodeStream = stream instanceof ReadableStream ? Readable.fromWeb(stream as any) : stream
-  const writeStream = createWriteStream(p)
-  await pipeline(nodeStream, writeStream)
-
-  if (mode) {
-    await chmod(p, mode)
-  }
-}
-
-export async function mimeType(p: string): Promise<string> {
-  const { lookup } = await import("mime-types")
-  return lookup(p) || "application/octet-stream"
-}
-
-/**
- * On Windows, normalize a path to its canonical casing using the filesystem.
- * This is needed because Windows paths are case-insensitive but LSP servers
- * may return paths with different casing than what we send them.
- */
-export function normalizePath(p: string): string {
-  if (process.platform !== "win32") return p
-  const resolved = win32.normalize(win32.resolve(windowsPath(p)))
-  try {
-    return realpathSync.native(resolved)
-  } catch {
-    return resolved
-  }
-}
-
-export function normalizePathPattern(p: string): string {
-  if (process.platform !== "win32") return p
-  if (p === "*") return p
-  const match = p.match(/^(.*)[\\/]\*$/)
-  if (!match) return normalizePath(p)
-  const dir = /^[A-Za-z]:$/.test(match[1]) ? match[1] + "\\" : match[1]
-  return join(normalizePath(dir), "*")
-}
-
-// We cannot rely on path.resolve() here because git.exe may come from Git Bash, Cygwin, or MSYS2, so we need to translate these paths at the boundary.
-// Also resolves symlinks so that callers using the result as a cache key
-// always get the same canonical path for a given physical directory.
-export function resolve(p: string): string {
-  const resolved = pathResolve(windowsPath(p))
-  try {
-    return normalizePath(realpathSync(resolved))
-  } catch (e) {
-    if (isEnoent(e)) return normalizePath(resolved)
-    throw e
-  }
-}
-
-export function windowsPath(p: string): string {
-  if (process.platform !== "win32") return p
-  return (
-    p
-      .replace(/^\/([a-zA-Z]):(?:[\\/]|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
-      // Git Bash for Windows paths are typically /<drive>/...
-      .replace(/^\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
-      // Cygwin git paths are typically /cygdrive/<drive>/...
-      .replace(/^\/cygdrive\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
-      // WSL paths are typically /mnt/<drive>/...
-      .replace(/^\/mnt\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
-  )
-}
-export function overlaps(a: string, b: string) {
-  const relA = relative(a, b)
-  const relB = relative(b, a)
-  return !relA || !relA.startsWith("..") || !relB || !relB.startsWith("..")
-}
-
-export function contains(parent: string, child: string) {
-  return !relative(parent, child).startsWith("..")
-}
-
-export async function findUp(
-  target: string,
-  start: string,
-  stop?: string,
-  options?: { rootFirst?: boolean },
-): Promise<string[]>
-export async function findUp(
-  target: string[],
-  start: string,
-  stop?: string,
-  options?: { rootFirst?: boolean },
-): Promise<string[]>
-export async function findUp(
-  target: string | string[],
-  start: string,
-  stop?: string,
-  options?: { rootFirst?: boolean },
-) {
-  const dirs = [start]
-  let current = start
-  while (true) {
-    if (stop === current) break
-    const parent = dirname(current)
-    if (parent === current) break
-    dirs.push(parent)
-    current = parent
-  }
-
-  const targets = Array.isArray(target) ? target : [target]
-  const result = []
-  for (const dir of options?.rootFirst ? dirs.toReversed() : dirs) {
-    for (const item of targets) {
-      const search = join(dir, item)
-      if (await exists(search)) result.push(search)
-    }
-  }
-  return result
-}
-
-export async function* up(options: { targets: string[]; start: string; stop?: string }) {
-  const { targets, start, stop } = options
-  let current = start
-  while (true) {
-    for (const target of targets) {
-      const search = join(current, target)
-      if (await exists(search)) yield search
-    }
-    if (stop === current) break
-    const parent = dirname(current)
-    if (parent === current) break
-    current = parent
-  }
-}
-
-export async function globUp(pattern: string, start: string, stop?: string) {
-  let current = start
-  const result = []
-  while (true) {
-    try {
-      const matches = await Glob.scan(pattern, {
-        cwd: current,
-        absolute: true,
-        include: "file",
-        dot: true,
-      })
-      result.push(...matches)
-    } catch {
-      // Skip invalid glob patterns
-    }
-    if (stop === current) break
-    const parent = dirname(current)
-    if (parent === current) break
-    current = parent
-  }
-  return result
-}

package/src/util/fn.ts

@@ -1,21 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

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

package/src/util/index.ts

@@ -1,14 +0,0 @@
-export * as Archive from "./archive"
-export * as Color from "./color"
-export { getEnvInfo } from "./env-info"
-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 ToolCompat from "./tool-compat"
-export * as Wildcard from "./wildcard"

package/src/util/keybind.ts

@@ -1,101 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

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