bonecode 1.0.0 → 1.2.0

package/src/engine/util/repository.ts

@@ -1,158 +1,158 @@
-import path from "path"
-import { fileURLToPath } from "url"
-import { Global } from "@opencode-ai/core/global"
-
-export type Reference = {
-  host: string
-  path: string
-  segments: string[]
-  owner?: string
-  repo: string
-  remote: string
-  label: string
-  protocol?: string
-}
-
-function normalize(input: string) {
-  return input
-    .trim()
-    .replace(/^git\+/, "")
-    .replace(/#.*$/, "")
-    .replace(/\/+$/, "")
-}
-
-function trimGitSuffix(input: string) {
-  return input.replace(/\.git$/, "")
-}
-
-function parts(input: string) {
-  return input
-    .split("/")
-    .map((item) => trimGitSuffix(item.trim()))
-    .filter(Boolean)
-}
-
-function safeHost(input: string) {
-  return Boolean(input) && !input.startsWith("-") && !/[\s/\\]/.test(input)
-}
-
-function safeSegment(input: string) {
-  return input !== "." && input !== ".." && !input.includes(":") && !/[\s/\\]/.test(input)
-}
-
-function hostLike(input: string) {
-  return input.includes(".") || input.includes(":") || input === "localhost"
-}
-
-function withSlash(input: string) {
-  return input.endsWith("/") ? input : `${input}/`
-}
-
-function githubRemote(pathname: string) {
-  const base = process.env.OPENCODE_REPO_CLONE_GITHUB_BASE_URL
-  if (!base) return `https://github.com/${pathname}.git`
-  return new URL(`${pathname}.git`, withSlash(base)).href
-}
-
-function build(input: { host: string; segments: string[]; remote?: string; protocol?: string }) {
-  const segments = input.segments.map(trimGitSuffix).filter(Boolean)
-  if (!safeHost(input.host) || !segments.length || segments.some((segment) => !safeSegment(segment))) return null
-  const pathname = segments.join("/")
-  const repo = segments[segments.length - 1]
-  const host = input.host.toLowerCase()
-  return {
-    host,
-    path: pathname,
-    segments,
-    owner: segments.length === 2 ? segments[0] : undefined,
-    repo,
-    remote: input.remote ?? (host === "github.com" ? githubRemote(pathname) : `https://${host}/${pathname}.git`),
-    label: host === "github.com" && segments.length === 2 ? pathname : `${host}/${pathname}`,
-    protocol: input.protocol,
-  } satisfies Reference
-}
-
-function buildFile(input: { url: URL; remote: string }) {
-  const filePath = path.normalize(fileURLToPath(input.url))
-  const segments = filePath.split(/[\\/]+/).filter(Boolean)
-  if (!segments.length) return null
-  return {
-    host: "file",
-    path: filePath,
-    segments: segments.map((segment) => segment.replace(/:$/, "")),
-    owner: undefined,
-    repo: trimGitSuffix(segments[segments.length - 1]),
-    remote: input.remote,
-    label: filePath,
-    protocol: "file:",
-  } satisfies Reference
-}
-
-export function parseRepositoryReference(input: string) {
-  const cleaned = normalize(input)
-  if (!cleaned) return null
-
-  const githubPrefixed = cleaned.match(/^github:([^/\s]+)\/([^/\s]+)$/)
-  if (githubPrefixed) return build({ host: "github.com", segments: [githubPrefixed[1], githubPrefixed[2]] })
-
-  if (!cleaned.includes("://")) {
-    const scp = cleaned.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/)
-    if (scp) return build({ host: scp[1], segments: parts(scp[2]), remote: cleaned })
-
-    const direct = parts(cleaned)
-    if (direct.length >= 2 && hostLike(direct[0])) {
-      return build({ host: direct[0], segments: direct.slice(1) })
-    }
-
-    if (direct.length === 2) {
-      return build({ host: "github.com", segments: direct })
-    }
-  }
-
-  try {
-    const url = new URL(cleaned)
-    if (url.protocol === "file:") return buildFile({ url, remote: cleaned })
-    const pathname = parts(url.pathname)
-    const host = url.host
-    return build({
-      host,
-      segments: pathname,
-      remote: host === "github.com" ? githubRemote(pathname.join("/")) : cleaned,
-      protocol: url.protocol,
-    })
-  } catch {
-    return null
-  }
-}
-
-export function parseRemoteRepositoryReference(input: string) {
-  const reference = parseRepositoryReference(input)
-  if (!reference) throw new Error("Repository must be a git URL, host/path reference, or GitHub owner/repo shorthand")
-  if (reference.protocol === "file:") throw new Error("Local file repositories are not supported")
-  return reference
-}
-
-export function validateRepositoryBranch(branch: string) {
-  if (!/^[A-Za-z0-9/_.-]+$/.test(branch) || branch.startsWith("-") || branch.includes("..")) {
-    throw new Error(
-      "Branch must contain only alphanumeric characters, /, _, ., and -, and cannot start with - or contain ..",
-    )
-  }
-}
-
-export function parseGitHubRemote(input: string) {
-  const cleaned = normalize(input)
-  if (!cleaned.includes("://") && !cleaned.match(/^(?:[^@/\s]+@)?github\.com:/)) return null
-
-  const parsed = parseRepositoryReference(cleaned)
-  if (!parsed || parsed.host !== "github.com" || !parsed.owner || parsed.segments.length !== 2) return null
-  return { owner: parsed.owner, repo: parsed.repo }
-}
-
-export function repositoryCachePath(input: Reference) {
-  return path.join(Global.Path.repos, ...input.host.split(":"), ...input.segments)
-}
-
-export function sameRepositoryReference(left: Reference, right: Reference) {
-  return left.host === right.host && left.path === right.path
-}
+import path from "path"
+import { fileURLToPath } from "url"
+import { Global } from "@opencode-ai/core/global"
+
+export type Reference = {
+  host: string
+  path: string
+  segments: string[]
+  owner?: string
+  repo: string
+  remote: string
+  label: string
+  protocol?: string
+}
+
+function normalize(input: string) {
+  return input
+    .trim()
+    .replace(/^git\+/, "")
+    .replace(/#.*$/, "")
+    .replace(/\/+$/, "")
+}
+
+function trimGitSuffix(input: string) {
+  return input.replace(/\.git$/, "")
+}
+
+function parts(input: string) {
+  return input
+    .split("/")
+    .map((item) => trimGitSuffix(item.trim()))
+    .filter(Boolean)
+}
+
+function safeHost(input: string) {
+  return Boolean(input) && !input.startsWith("-") && !/[\s/\\]/.test(input)
+}
+
+function safeSegment(input: string) {
+  return input !== "." && input !== ".." && !input.includes(":") && !/[\s/\\]/.test(input)
+}
+
+function hostLike(input: string) {
+  return input.includes(".") || input.includes(":") || input === "localhost"
+}
+
+function withSlash(input: string) {
+  return input.endsWith("/") ? input : `${input}/`
+}
+
+function githubRemote(pathname: string) {
+  const base = process.env.OPENCODE_REPO_CLONE_GITHUB_BASE_URL
+  if (!base) return `https://github.com/${pathname}.git`
+  return new URL(`${pathname}.git`, withSlash(base)).href
+}
+
+function build(input: { host: string; segments: string[]; remote?: string; protocol?: string }) {
+  const segments = input.segments.map(trimGitSuffix).filter(Boolean)
+  if (!safeHost(input.host) || !segments.length || segments.some((segment) => !safeSegment(segment))) return null
+  const pathname = segments.join("/")
+  const repo = segments[segments.length - 1]
+  const host = input.host.toLowerCase()
+  return {
+    host,
+    path: pathname,
+    segments,
+    owner: segments.length === 2 ? segments[0] : undefined,
+    repo,
+    remote: input.remote ?? (host === "github.com" ? githubRemote(pathname) : `https://${host}/${pathname}.git`),
+    label: host === "github.com" && segments.length === 2 ? pathname : `${host}/${pathname}`,
+    protocol: input.protocol,
+  } satisfies Reference
+}
+
+function buildFile(input: { url: URL; remote: string }) {
+  const filePath = path.normalize(fileURLToPath(input.url))
+  const segments = filePath.split(/[\\/]+/).filter(Boolean)
+  if (!segments.length) return null
+  return {
+    host: "file",
+    path: filePath,
+    segments: segments.map((segment) => segment.replace(/:$/, "")),
+    owner: undefined,
+    repo: trimGitSuffix(segments[segments.length - 1]),
+    remote: input.remote,
+    label: filePath,
+    protocol: "file:",
+  } satisfies Reference
+}
+
+export function parseRepositoryReference(input: string) {
+  const cleaned = normalize(input)
+  if (!cleaned) return null
+
+  const githubPrefixed = cleaned.match(/^github:([^/\s]+)\/([^/\s]+)$/)
+  if (githubPrefixed) return build({ host: "github.com", segments: [githubPrefixed[1], githubPrefixed[2]] })
+
+  if (!cleaned.includes("://")) {
+    const scp = cleaned.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/)
+    if (scp) return build({ host: scp[1], segments: parts(scp[2]), remote: cleaned })
+
+    const direct = parts(cleaned)
+    if (direct.length >= 2 && hostLike(direct[0])) {
+      return build({ host: direct[0], segments: direct.slice(1) })
+    }
+
+    if (direct.length === 2) {
+      return build({ host: "github.com", segments: direct })
+    }
+  }
+
+  try {
+    const url = new URL(cleaned)
+    if (url.protocol === "file:") return buildFile({ url, remote: cleaned })
+    const pathname = parts(url.pathname)
+    const host = url.host
+    return build({
+      host,
+      segments: pathname,
+      remote: host === "github.com" ? githubRemote(pathname.join("/")) : cleaned,
+      protocol: url.protocol,
+    })
+  } catch {
+    return null
+  }
+}
+
+export function parseRemoteRepositoryReference(input: string) {
+  const reference = parseRepositoryReference(input)
+  if (!reference) throw new Error("Repository must be a git URL, host/path reference, or GitHub owner/repo shorthand")
+  if (reference.protocol === "file:") throw new Error("Local file repositories are not supported")
+  return reference
+}
+
+export function validateRepositoryBranch(branch: string) {
+  if (!/^[A-Za-z0-9/_.-]+$/.test(branch) || branch.startsWith("-") || branch.includes("..")) {
+    throw new Error(
+      "Branch must contain only alphanumeric characters, /, _, ., and -, and cannot start with - or contain ..",
+    )
+  }
+}
+
+export function parseGitHubRemote(input: string) {
+  const cleaned = normalize(input)
+  if (!cleaned.includes("://") && !cleaned.match(/^(?:[^@/\s]+@)?github\.com:/)) return null
+
+  const parsed = parseRepositoryReference(cleaned)
+  if (!parsed || parsed.host !== "github.com" || !parsed.owner || parsed.segments.length !== 2) return null
+  return { owner: parsed.owner, repo: parsed.repo }
+}
+
+export function repositoryCachePath(input: Reference) {
+  return path.join(Global.Path.repos, ...input.host.split(":"), ...input.segments)
+}
+
+export function sameRepositoryReference(left: Reference, right: Reference) {
+  return left.host === right.host && left.path === right.path
+}

package/src/engine/util/rpc.ts

@@ -1,66 +1,66 @@
-type Definition = {
-  [method: string]: (input: any) => any
-}
-
-export function listen(rpc: Definition) {
-  onmessage = async (evt) => {
-    const parsed = JSON.parse(evt.data)
-    if (parsed.type === "rpc.request") {
-      const result = await rpc[parsed.method](parsed.input)
-      postMessage(JSON.stringify({ type: "rpc.result", result, id: parsed.id }))
-    }
-  }
-}
-
-export function emit(event: string, data: unknown) {
-  postMessage(JSON.stringify({ type: "rpc.event", event, data }))
-}
-
-export function client<T extends Definition>(target: {
-  postMessage: (data: string) => void | null
-  onmessage: ((this: Worker, ev: MessageEvent<any>) => any) | null
-}) {
-  const pending = new Map<number, (result: any) => void>()
-  const listeners = new Map<string, Set<(data: any) => void>>()
-  let id = 0
-  target.onmessage = async (evt) => {
-    const parsed = JSON.parse(evt.data)
-    if (parsed.type === "rpc.result") {
-      const resolve = pending.get(parsed.id)
-      if (resolve) {
-        resolve(parsed.result)
-        pending.delete(parsed.id)
-      }
-    }
-    if (parsed.type === "rpc.event") {
-      const handlers = listeners.get(parsed.event)
-      if (handlers) {
-        for (const handler of handlers) {
-          handler(parsed.data)
-        }
-      }
-    }
-  }
-  return {
-    call<Method extends keyof T>(method: Method, input: Parameters<T[Method]>[0]): Promise<ReturnType<T[Method]>> {
-      const requestId = id++
-      return new Promise((resolve) => {
-        pending.set(requestId, resolve)
-        target.postMessage(JSON.stringify({ type: "rpc.request", method, input, id: requestId }))
-      })
-    },
-    on<Data>(event: string, handler: (data: Data) => void) {
-      let handlers = listeners.get(event)
-      if (!handlers) {
-        handlers = new Set()
-        listeners.set(event, handlers)
-      }
-      handlers.add(handler)
-      return () => {
-        handlers!.delete(handler)
-      }
-    },
-  }
-}
-
-export * as Rpc from "./rpc"
+type Definition = {
+  [method: string]: (input: any) => any
+}
+
+export function listen(rpc: Definition) {
+  onmessage = async (evt) => {
+    const parsed = JSON.parse(evt.data)
+    if (parsed.type === "rpc.request") {
+      const result = await rpc[parsed.method](parsed.input)
+      postMessage(JSON.stringify({ type: "rpc.result", result, id: parsed.id }))
+    }
+  }
+}
+
+export function emit(event: string, data: unknown) {
+  postMessage(JSON.stringify({ type: "rpc.event", event, data }))
+}
+
+export function client<T extends Definition>(target: {
+  postMessage: (data: string) => void | null
+  onmessage: ((this: Worker, ev: MessageEvent<any>) => any) | null
+}) {
+  const pending = new Map<number, (result: any) => void>()
+  const listeners = new Map<string, Set<(data: any) => void>>()
+  let id = 0
+  target.onmessage = async (evt) => {
+    const parsed = JSON.parse(evt.data)
+    if (parsed.type === "rpc.result") {
+      const resolve = pending.get(parsed.id)
+      if (resolve) {
+        resolve(parsed.result)
+        pending.delete(parsed.id)
+      }
+    }
+    if (parsed.type === "rpc.event") {
+      const handlers = listeners.get(parsed.event)
+      if (handlers) {
+        for (const handler of handlers) {
+          handler(parsed.data)
+        }
+      }
+    }
+  }
+  return {
+    call<Method extends keyof T>(method: Method, input: Parameters<T[Method]>[0]): Promise<ReturnType<T[Method]>> {
+      const requestId = id++
+      return new Promise((resolve) => {
+        pending.set(requestId, resolve)
+        target.postMessage(JSON.stringify({ type: "rpc.request", method, input, id: requestId }))
+      })
+    },
+    on<Data>(event: string, handler: (data: Data) => void) {
+      let handlers = listeners.get(event)
+      if (!handlers) {
+        handlers = new Set()
+        listeners.set(event, handlers)
+      }
+      handlers.add(handler)
+      return () => {
+        handlers!.delete(handler)
+      }
+    },
+  }
+}
+
+export * as Rpc from "./rpc"

package/src/engine/util/signal.ts

@@ -1,12 +1,12 @@
-export function signal() {
-  let resolve: any
-  const promise = new Promise((r) => (resolve = r))
-  return {
-    trigger() {
-      return resolve()
-    },
-    wait() {
-      return promise
-    },
-  }
-}
+export function signal() {
+  let resolve: any
+  const promise = new Promise((r) => (resolve = r))
+  return {
+    trigger() {
+      return resolve()
+    },
+    wait() {
+      return promise
+    },
+  }
+}

package/src/engine/util/timeout.ts

@@ -1,13 +1,13 @@
-export function withTimeout<T>(promise: Promise<T>, ms: number, label?: string): Promise<T> {
-  let timeout: NodeJS.Timeout
-  return Promise.race([
-    promise.finally(() => {
-      clearTimeout(timeout)
-    }),
-    new Promise<never>((_, reject) => {
-      timeout = setTimeout(() => {
-        reject(new Error(label ?? `Operation timed out after ${ms}ms`))
-      }, ms)
-    }),
-  ])
-}
+export function withTimeout<T>(promise: Promise<T>, ms: number, label?: string): Promise<T> {
+  let timeout: NodeJS.Timeout
+  return Promise.race([
+    promise.finally(() => {
+      clearTimeout(timeout)
+    }),
+    new Promise<never>((_, reject) => {
+      timeout = setTimeout(() => {
+        reject(new Error(label ?? `Operation timed out after ${ms}ms`))
+      }, ms)
+    }),
+  ])
+}

package/src/engine/util/token.ts

@@ -1,7 +1,7 @@
-const CHARS_PER_TOKEN = 4
-
-export function estimate(input: string) {
-  return Math.max(0, Math.round((input || "").length / CHARS_PER_TOKEN))
-}
-
-export * as Token from "./token"
+const CHARS_PER_TOKEN = 4
+
+export function estimate(input: string) {
+  return Math.max(0, Math.round((input || "").length / CHARS_PER_TOKEN))
+}
+
+export * as Token from "./token"

package/src/engine/util/util/archive.ts

@@ -1,17 +1,17 @@
-import path from "path"
-import * as Process from "./process"
-
-export async function extractZip(zipPath: string, destDir: string) {
-  if (process.platform === "win32") {
-    const winZipPath = path.resolve(zipPath)
-    const winDestDir = path.resolve(destDir)
-    // $global:ProgressPreference suppresses PowerShell's blue progress bar popup
-    const cmd = `$global:ProgressPreference = 'SilentlyContinue'; Expand-Archive -Path '${winZipPath}' -DestinationPath '${winDestDir}' -Force`
-    await Process.run(["powershell", "-NoProfile", "-NonInteractive", "-Command", cmd])
-    return
-  }
-
-  await Process.run(["unzip", "-o", "-q", zipPath, "-d", destDir])
-}
-
-export * as Archive from "./archive"
+import path from "path"
+import * as Process from "./process"
+
+export async function extractZip(zipPath: string, destDir: string) {
+  if (process.platform === "win32") {
+    const winZipPath = path.resolve(zipPath)
+    const winDestDir = path.resolve(destDir)
+    // $global:ProgressPreference suppresses PowerShell's blue progress bar popup
+    const cmd = `$global:ProgressPreference = 'SilentlyContinue'; Expand-Archive -Path '${winZipPath}' -DestinationPath '${winDestDir}' -Force`
+    await Process.run(["powershell", "-NoProfile", "-NonInteractive", "-Command", cmd])
+    return
+  }
+
+  await Process.run(["unzip", "-o", "-q", zipPath, "-d", destDir])
+}
+
+export * as Archive from "./archive"

package/src/engine/util/util/bom.ts

@@ -1,31 +1,31 @@
-import { Effect } from "effect"
-import { AppFileSystem } from "@opencode-ai/core/filesystem"
-
-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: AppFileSystem.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: AppFileSystem.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
-})
+import { Effect } from "effect"
+import { AppFileSystem } from "@opencode-ai/core/filesystem"
+
+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: AppFileSystem.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: AppFileSystem.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/engine/util/util/data-url.ts

@@ -1,9 +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)
-}
+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/engine/util/util/defer.ts

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