bonecode 1.0.0 → 1.1.0

package/src/engine/util/filesystem.ts

@@ -1,252 +1,252 @@
-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, relative, resolve as pathResolve, win32 } from "path"
-import { Readable } from "stream"
-import { pipeline } from "stream/promises"
-import { Glob } from "@opencode-ai/core/util/glob"
-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) {
-  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
-}
-
-export * as Filesystem from "./filesystem"
+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, relative, resolve as pathResolve, win32 } from "path"
+import { Readable } from "stream"
+import { pipeline } from "stream/promises"
+import { Glob } from "@opencode-ai/core/util/glob"
+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) {
+  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
+}
+
+export * as Filesystem from "./filesystem"

package/src/engine/util/format.ts

@@ -1,20 +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`
-}
+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/engine/util/iife.ts

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

package/src/engine/util/lazy.ts

@@ -1,20 +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
-}
+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/engine/util/local-context.ts

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