artificial-code 1.17.13

package/src/util/bom.ts

@@ -0,0 +1,27 @@
+import { Effect } from "effect"
+import { FSUtil } from "@ac/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

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

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

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

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

package/src/util/filesystem.ts

@@ -0,0 +1,251 @@
+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 "@ac/core/util/glob"
+import { FSUtil } from "@ac/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

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

package/src/util/iife.ts

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

package/src/util/lazy.ts

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

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

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

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/process.ts

@@ -0,0 +1,177 @@
+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
+// `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)
+}
+
+export * as Process from "./process"

package/src/util/proxy-env.ts

@@ -0,0 +1,72 @@
+/*
+ * 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

@@ -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/record.ts

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