anymous 1.3.0 → 1.3.2

package/src/util/bom.ts

@@ -1,27 +0,0 @@
-import { Effect } from "effect"
-import type { FSUtil } from "@anymous-ai/core/fs-util"
-
-const BOM_CODE = 0xfeff
-const BOM = String.fromCharCode(BOM_CODE)
-
-export function split(text: string) {
-  if (text.charCodeAt(0) !== BOM_CODE) return { bom: false, text }
-  return { bom: true, text: text.slice(1) }
-}
-
-export function join(text: string, bom: boolean) {
-  const stripped = split(text).text
-  if (!bom) return stripped
-  return BOM + stripped
-}
-
-export const readFile = Effect.fn("Bom.readFile")(function* (fs: FSUtil.Interface, filePath: string) {
-  return split(new TextDecoder("utf-8", { ignoreBOM: true }).decode(yield* fs.readFile(filePath)))
-})
-
-export const syncFile = Effect.fn("Bom.syncFile")(function* (fs: FSUtil.Interface, filePath: string, bom: boolean) {
-  const current = yield* readFile(fs, filePath)
-  if (current.bom === bom) return current.text
-  yield* fs.writeWithDirs(filePath, join(current.text, bom))
-  return current.text
-})

package/src/util/data-url.ts

@@ -1,9 +0,0 @@
-export function decodeDataUrl(url: string) {
-  const idx = url.indexOf(",")
-  if (idx === -1) return ""
-
-  const head = url.slice(0, idx)
-  const body = url.slice(idx + 1)
-  if (head.includes(";base64")) return Buffer.from(body, "base64").toString("utf8")
-  return decodeURIComponent(body)
-}

package/src/util/defer.ts

@@ -1,10 +0,0 @@
-export function defer(fn: () => void | Promise<void>): AsyncDisposable & Disposable {
-  return {
-    [Symbol.dispose]() {
-      void fn()
-    },
-    [Symbol.asyncDispose]() {
-      return Promise.resolve(fn())
-    },
-  }
-}

package/src/util/effect-http-client.ts

@@ -1,11 +0,0 @@
-import { Schedule } from "effect"
-import { HttpClient } from "effect/unstable/http"
-
-export const withTransientReadRetry = <E, R>(client: HttpClient.HttpClient.With<E, R>) =>
-  client.pipe(
-    HttpClient.retryTransient({
-      retryOn: "errors-and-responses",
-      times: 2,
-      schedule: Schedule.exponential(200).pipe(Schedule.jittered),
-    }),
-  )

package/src/util/error.ts

@@ -1 +0,0 @@
-export * from "@anymous-ai/tui/util/error"

package/src/util/filesystem.ts

@@ -1,251 +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, isAbsolute, join, resolve as pathResolve, win32 } from "path"
-import { Readable } from "stream"
-import { pipeline } from "stream/promises"
-import { Glob } from "@anymous-ai/core/util/glob"
-import { FSUtil } from "@anymous-ai/core/fs-util"
-import { fileURLToPath } from "url"
-
-// 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 resolveFilePath(root: string, file: string): string {
-  const raw = file.startsWith("file://") ? fileURLToPath(file) : file
-  if (isAbsolute(raw)) return raw
-  return pathResolve(root, raw)
-}
-
-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) {
-  return FSUtil.overlaps(a, b)
-}
-
-export function contains(parent: string, child: string) {
-  return FSUtil.contains(parent, child)
-}
-
-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
-}
-
-export * as Filesystem from "./filesystem"

package/src/util/html.ts

@@ -1,8 +0,0 @@
-export function escapeHtml(value: string) {
-  return value
-    .replaceAll("&", "&")
-    .replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;")
-    .replaceAll('"', "&quot;")
-    .replaceAll("'", "&#39;")
-}

package/src/util/iife.ts

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

package/src/util/lazy.ts

@@ -1,20 +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
-  }
-
-  result.loaded = () => loaded
-
-  return result
-}

package/src/util/local-context.ts

@@ -1,25 +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)
-    },
-  }
-}
-
-export * as LocalContext from "./local-context"

package/src/util/locale.ts

@@ -1,2 +0,0 @@
-export * from "@anymous-ai/tui/util/locale"
-export { Locale } from "@anymous-ai/tui/util/locale"

package/src/util/media.ts

@@ -1,26 +0,0 @@
-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/process.ts

@@ -1,177 +0,0 @@
-import { type ChildProcess } from "child_process"
-import type { Stream } from "node:stream"
-import launch from "cross-spawn"
-import { buffer } from "node:stream/consumers"
-import { errorMessage } from "./error"
-
-export type Stdio = "inherit" | "pipe" | "ignore" | number | Stream
-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
-// `anymous` 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)
-}
-
-export * as Process from "./process"

package/src/util/proxy-env.ts

@@ -1,72 +0,0 @@
-/*
- * Adapted from proxy-from-env: https://github.com/Rob--W/proxy-from-env
- *
- * The MIT License
- *
- * Copyright (C) 2016-2018 Rob Wu <rob@robwu.nl>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of
- * this software and associated documentation files (the "Software"), to deal in
- * the Software without restriction, including without limitation the rights to
- * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is furnished to do
- * so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-const DEFAULT_PORTS: Record<string, number> = {
-  ftp: 21,
-  gopher: 70,
-  http: 80,
-  https: 443,
-  ws: 80,
-  wss: 443,
-}
-
-export function getProxyForUrl(input: string | URL) {
-  const url = typeof input === "string" ? (URL.canParse(input) ? new URL(input) : undefined) : input
-  if (!url) return
-
-  const protocol = url.protocol.split(":", 1)[0]
-  const hostname = url.host.replace(/:\d*$/, "")
-  const port = Number.parseInt(url.port) || DEFAULT_PORTS[protocol] || 0
-  if (!shouldProxy(hostname, port)) return
-
-  const proxy = env(`${protocol}_proxy`) || env("all_proxy")
-  if (!proxy) return
-  return proxy.includes("://") ? proxy : `${protocol}://${proxy}`
-}
-
-function shouldProxy(hostname: string, port: number) {
-  const noProxy = env("no_proxy").toLowerCase()
-  if (!noProxy) return true
-  if (noProxy === "*") return false
-
-  return noProxy.split(/[,\s]/).every((proxy) => {
-    if (!proxy) return true
-
-    const parsed = proxy.match(/^(.+):(\d+)$/)
-    const proxyHostname = parsed ? parsed[1] : proxy
-    const proxyPort = parsed ? Number.parseInt(parsed[2]) : 0
-    if (proxyPort && proxyPort !== port) return true
-
-    if (!/^[.*]/.test(proxyHostname)) return hostname !== proxyHostname
-    return !hostname.endsWith(proxyHostname.startsWith("*") ? proxyHostname.slice(1) : proxyHostname)
-  })
-}
-
-function env(key: string) {
-  return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || ""
-}
-
-export * as ProxyEnv from "./proxy-env"

package/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)
-      }
-    }),
-  )
-}

package/src/util/record.ts

@@ -1 +0,0 @@
-export * from "@anymous-ai/tui/util/record"