alchemylab-opencode 1.0.6 → 1.0.8

package/packages/sdk/src/v2/index.ts

@@ -1,21 +0,0 @@
-export * from "./client.js"
-export * from "./server.js"
-
-import { createOpencodeClient } from "./client.js"
-import { createOpencodeServer } from "./server.js"
-import type { ServerOptions } from "./server.js"
-
-export async function createOpencode(options?: ServerOptions) {
-  const server = await createOpencodeServer({
-    ...options,
-  })
-
-  const client = createOpencodeClient({
-    baseUrl: server.url,
-  })
-
-  return {
-    client,
-    server,
-  }
-}

package/packages/sdk/src/v2/server.ts

@@ -1,134 +0,0 @@
-import launch from "cross-spawn"
-import { type Config } from "./gen/types.gen.js"
-import { stop, bindAbort } from "../process.js"
-
-export type ServerOptions = {
-  hostname?: string
-  port?: number
-  signal?: AbortSignal
-  timeout?: number
-  config?: Config
-}
-
-export type TuiOptions = {
-  project?: string
-  model?: string
-  session?: string
-  agent?: string
-  signal?: AbortSignal
-  config?: Config
-}
-
-export async function createOpencodeServer(options?: ServerOptions) {
-  options = Object.assign(
-    {
-      hostname: "127.0.0.1",
-      port: 4096,
-      timeout: 5000,
-    },
-    options ?? {},
-  )
-
-  const args = [`serve`, `--hostname=${options.hostname}`, `--port=${options.port}`]
-  if (options.config?.logLevel) args.push(`--log-level=${options.config.logLevel}`)
-
-  const proc = launch(`opencode`, args, {
-    env: {
-      ...process.env,
-      OPENCODE_CONFIG_CONTENT: JSON.stringify(options.config ?? {}),
-    },
-  })
-  let clear = () => {}
-
-  const url = await new Promise<string>((resolve, reject) => {
-    const id = setTimeout(() => {
-      clear()
-      stop(proc)
-      reject(new Error(`Timeout waiting for server to start after ${options.timeout}ms`))
-    }, options.timeout)
-    let output = ""
-    let resolved = false
-    proc.stdout?.on("data", (chunk) => {
-      if (resolved) return
-      output += chunk.toString()
-      const lines = output.split("\n")
-      for (const line of lines) {
-        if (line.startsWith("opencode server listening")) {
-          const match = line.match(/on\s+(https?:\/\/[^\s]+)/)
-          if (!match) {
-            clear()
-            stop(proc)
-            clearTimeout(id)
-            reject(new Error(`Failed to parse server url from output: ${line}`))
-            return
-          }
-          clearTimeout(id)
-          resolved = true
-          resolve(match[1]!)
-          return
-        }
-      }
-    })
-    proc.stderr?.on("data", (chunk) => {
-      output += chunk.toString()
-    })
-    proc.on("exit", (code) => {
-      clearTimeout(id)
-      let msg = `Server exited with code ${code}`
-      if (output.trim()) {
-        msg += `\nServer output: ${output}`
-      }
-      reject(new Error(msg))
-    })
-    proc.on("error", (error) => {
-      clearTimeout(id)
-      reject(error)
-    })
-    clear = bindAbort(proc, options.signal, () => {
-      clearTimeout(id)
-      reject(options.signal?.reason)
-    })
-  })
-
-  return {
-    url,
-    close() {
-      clear()
-      stop(proc)
-    },
-  }
-}
-
-export function createOpencodeTui(options?: TuiOptions) {
-  const args = []
-
-  if (options?.project) {
-    args.push(`--project=${options.project}`)
-  }
-  if (options?.model) {
-    args.push(`--model=${options.model}`)
-  }
-  if (options?.session) {
-    args.push(`--session=${options.session}`)
-  }
-  if (options?.agent) {
-    args.push(`--agent=${options.agent}`)
-  }
-
-  const proc = launch(`opencode`, args, {
-    stdio: "inherit",
-    env: {
-      ...process.env,
-      OPENCODE_CONFIG_CONTENT: JSON.stringify(options?.config ?? {}),
-    },
-  })
-
-  const clear = bindAbort(proc, options?.signal)
-
-  return {
-    close() {
-      clear()
-      stop(proc)
-    },
-  }
-}

package/packages/util/package.json

@@ -1,20 +0,0 @@
-{
-  "name": "@opencode-ai/util",
-  "version": "1.3.17",
-  "private": true,
-  "type": "module",
-  "license": "MIT",
-  "exports": {
-    "./*": "./src/*.ts"
-  },
-  "scripts": {
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "zod": "4.1.8"
-  },
-  "devDependencies": {
-    "typescript": "5.8.2",
-    "@types/bun": "1.3.11"
-  }
-}

package/packages/util/src/array.ts

@@ -1,10 +0,0 @@
-export function findLast<T>(
-  items: readonly T[],
-  predicate: (item: T, index: number, items: readonly T[]) => boolean,
-): T | undefined {
-  for (let i = items.length - 1; i >= 0; i -= 1) {
-    const item = items[i]
-    if (predicate(item, i, items)) return item
-  }
-  return undefined
-}

package/packages/util/src/binary.ts

@@ -1,41 +0,0 @@
-export namespace Binary {
-  export function search<T>(array: T[], id: string, compare: (item: T) => string): { found: boolean; index: number } {
-    let left = 0
-    let right = array.length - 1
-
-    while (left <= right) {
-      const mid = Math.floor((left + right) / 2)
-      const midId = compare(array[mid])
-
-      if (midId === id) {
-        return { found: true, index: mid }
-      } else if (midId < id) {
-        left = mid + 1
-      } else {
-        right = mid - 1
-      }
-    }
-
-    return { found: false, index: left }
-  }
-
-  export function insert<T>(array: T[], item: T, compare: (item: T) => string): T[] {
-    const id = compare(item)
-    let left = 0
-    let right = array.length
-
-    while (left < right) {
-      const mid = Math.floor((left + right) / 2)
-      const midId = compare(array[mid])
-
-      if (midId < id) {
-        left = mid + 1
-      } else {
-        right = mid
-      }
-    }
-
-    array.splice(left, 0, item)
-    return array
-  }
-}

package/packages/util/src/encode.ts

@@ -1,51 +0,0 @@
-export function base64Encode(value: string) {
-  const bytes = new TextEncoder().encode(value)
-  const binary = Array.from(bytes, (b) => String.fromCharCode(b)).join("")
-  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "")
-}
-
-export function base64Decode(value: string) {
-  const binary = atob(value.replace(/-/g, "+").replace(/_/g, "/"))
-  const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0))
-  return new TextDecoder().decode(bytes)
-}
-
-export async function hash(content: string, algorithm = "SHA-256"): Promise<string> {
-  const encoder = new TextEncoder()
-  const data = encoder.encode(content)
-  const hashBuffer = await crypto.subtle.digest(algorithm, data)
-  const hashArray = Array.from(new Uint8Array(hashBuffer))
-  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("")
-  return hashHex
-}
-
-export function checksum(content: string): string | undefined {
-  if (!content) return undefined
-  let hash = 0x811c9dc5
-  for (let i = 0; i < content.length; i++) {
-    hash ^= content.charCodeAt(i)
-    hash = Math.imul(hash, 0x01000193)
-  }
-  return (hash >>> 0).toString(36)
-}
-
-export function sampledChecksum(content: string, limit = 500_000): string | undefined {
-  if (!content) return undefined
-  if (content.length <= limit) return checksum(content)
-
-  const size = 4096
-  const points = [
-    0,
-    Math.floor(content.length * 0.25),
-    Math.floor(content.length * 0.5),
-    Math.floor(content.length * 0.75),
-    content.length - size,
-  ]
-  const hashes = points
-    .map((point) => {
-      const start = Math.max(0, Math.min(content.length - size, point - Math.floor(size / 2)))
-      return checksum(content.slice(start, start + size)) ?? ""
-    })
-    .join(":")
-  return `${content.length}:${hashes}`
-}

package/packages/util/src/error.ts

@@ -1,54 +0,0 @@
-import z from "zod"
-
-export abstract class NamedError extends Error {
-  abstract schema(): z.core.$ZodType
-  abstract toObject(): { name: string; data: any }
-
-  static create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data) {
-    const schema = z
-      .object({
-        name: z.literal(name),
-        data,
-      })
-      .meta({
-        ref: name,
-      })
-    const result = class extends NamedError {
-      public static readonly Schema = schema
-
-      public override readonly name = name as Name
-
-      constructor(
-        public readonly data: z.input<Data>,
-        options?: ErrorOptions,
-      ) {
-        super(name, options)
-        this.name = name
-      }
-
-      static isInstance(input: any): input is InstanceType<typeof result> {
-        return typeof input === "object" && "name" in input && input.name === name
-      }
-
-      schema() {
-        return schema
-      }
-
-      toObject() {
-        return {
-          name: name,
-          data: this.data,
-        }
-      }
-    }
-    Object.defineProperty(result, "name", { value: name })
-    return result
-  }
-
-  public static readonly Unknown = NamedError.create(
-    "UnknownError",
-    z.object({
-      message: z.string(),
-    }),
-  )
-}

package/packages/util/src/fn.ts

@@ -1,11 +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>) => {
-    const parsed = schema.parse(input)
-    return cb(parsed)
-  }
-  result.force = (input: z.infer<T>) => cb(input)
-  result.schema = schema
-  return result
-}

package/packages/util/src/identifier.ts

@@ -1,48 +0,0 @@
-import { randomBytes } from "crypto"
-
-export namespace Identifier {
-  const LENGTH = 26
-
-  // State for monotonic ID generation
-  let lastTimestamp = 0
-  let counter = 0
-
-  export function ascending() {
-    return create(false)
-  }
-
-  export function descending() {
-    return create(true)
-  }
-
-  function randomBase62(length: number): string {
-    const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-    let result = ""
-    const bytes = randomBytes(length)
-    for (let i = 0; i < length; i++) {
-      result += chars[bytes[i] % 62]
-    }
-    return result
-  }
-
-  export function create(descending: boolean, timestamp?: number): string {
-    const currentTimestamp = timestamp ?? Date.now()
-
-    if (currentTimestamp !== lastTimestamp) {
-      lastTimestamp = currentTimestamp
-      counter = 0
-    }
-    counter++
-
-    let now = BigInt(currentTimestamp) * BigInt(0x1000) + BigInt(counter)
-
-    now = descending ? ~now : now
-
-    const timeBytes = Buffer.alloc(6)
-    for (let i = 0; i < 6; i++) {
-      timeBytes[i] = Number((now >> BigInt(40 - 8 * i)) & BigInt(0xff))
-    }
-
-    return timeBytes.toString("hex") + randomBase62(LENGTH - 12)
-  }
-}

package/packages/util/src/iife.ts

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

package/packages/util/src/lazy.ts

@@ -1,11 +0,0 @@
-export function lazy<T>(fn: () => T) {
-  let value: T | undefined
-  let loaded = false
-
-  return (): T => {
-    if (loaded) return value as T
-    loaded = true
-    value = fn()
-    return value as T
-  }
-}

package/packages/util/src/module.ts

@@ -1,10 +0,0 @@
-import { createRequire } from "node:module"
-import path from "node:path"
-
-export namespace Module {
-  export function resolve(id: string, dir: string) {
-    try {
-      return createRequire(path.join(dir, "package.json")).resolve(id)
-    } catch {}
-  }
-}

package/packages/util/src/path.ts

@@ -1,37 +0,0 @@
-export function getFilename(path: string | undefined) {
-  if (!path) return ""
-  const trimmed = path.replace(/[\/\\]+$/, "")
-  const parts = trimmed.split(/[\/\\]/)
-  return parts[parts.length - 1] ?? ""
-}
-
-export function getDirectory(path: string | undefined) {
-  if (!path) return ""
-  const trimmed = path.replace(/[\/\\]+$/, "")
-  const parts = trimmed.split(/[\/\\]/)
-  return parts.slice(0, parts.length - 1).join("/") + "/"
-}
-
-export function getFileExtension(path: string | undefined) {
-  if (!path) return ""
-  const parts = path.split(".")
-  return parts[parts.length - 1]
-}
-
-export function getFilenameTruncated(path: string | undefined, maxLength: number = 20) {
-  const filename = getFilename(path)
-  if (filename.length <= maxLength) return filename
-  const lastDot = filename.lastIndexOf(".")
-  const ext = lastDot <= 0 ? "" : filename.slice(lastDot)
-  const available = maxLength - ext.length - 1 // -1 for ellipsis
-  if (available <= 0) return filename.slice(0, maxLength - 1) + "…"
-  return filename.slice(0, available) + "…" + ext
-}
-
-export function truncateMiddle(text: string, maxLength: number = 20) {
-  if (text.length <= maxLength) return text
-  const available = maxLength - 1 // -1 for ellipsis
-  const start = Math.ceil(available / 2)
-  const end = Math.floor(available / 2)
-  return text.slice(0, start) + "…" + text.slice(-end)
-}

package/packages/util/src/retry.ts

@@ -1,41 +0,0 @@
-export interface RetryOptions {
-  attempts?: number
-  delay?: number
-  factor?: number
-  maxDelay?: number
-  retryIf?: (error: unknown) => boolean
-}
-
-const TRANSIENT_MESSAGES = [
-  "load failed",
-  "network connection was lost",
-  "network request failed",
-  "failed to fetch",
-  "econnreset",
-  "econnrefused",
-  "etimedout",
-  "socket hang up",
-]
-
-function isTransientError(error: unknown): boolean {
-  if (!error) return false
-  const message = String(error instanceof Error ? error.message : error).toLowerCase()
-  return TRANSIENT_MESSAGES.some((m) => message.includes(m))
-}
-
-export async function retry<T>(fn: () => Promise<T>, options: RetryOptions = {}): Promise<T> {
-  const { attempts = 3, delay = 500, factor = 2, maxDelay = 10000, retryIf = isTransientError } = options
-
-  let lastError: unknown
-  for (let attempt = 0; attempt < attempts; attempt++) {
-    try {
-      return await fn()
-    } catch (error) {
-      lastError = error
-      if (attempt === attempts - 1 || !retryIf(error)) throw error
-      const wait = Math.min(delay * Math.pow(factor, attempt), maxDelay)
-      await new Promise((resolve) => setTimeout(resolve, wait))
-    }
-  }
-  throw lastError
-}

package/packages/util/src/slug.ts

@@ -1,74 +0,0 @@
-export namespace Slug {
-  const ADJECTIVES = [
-    "brave",
-    "calm",
-    "clever",
-    "cosmic",
-    "crisp",
-    "curious",
-    "eager",
-    "gentle",
-    "glowing",
-    "happy",
-    "hidden",
-    "jolly",
-    "kind",
-    "lucky",
-    "mighty",
-    "misty",
-    "neon",
-    "nimble",
-    "playful",
-    "proud",
-    "quick",
-    "quiet",
-    "shiny",
-    "silent",
-    "stellar",
-    "sunny",
-    "swift",
-    "tidy",
-    "witty",
-  ] as const
-
-  const NOUNS = [
-    "cabin",
-    "cactus",
-    "canyon",
-    "circuit",
-    "comet",
-    "eagle",
-    "engine",
-    "falcon",
-    "forest",
-    "garden",
-    "harbor",
-    "island",
-    "knight",
-    "lagoon",
-    "meadow",
-    "moon",
-    "mountain",
-    "nebula",
-    "orchid",
-    "otter",
-    "panda",
-    "pixel",
-    "planet",
-    "river",
-    "rocket",
-    "sailor",
-    "squid",
-    "star",
-    "tiger",
-    "wizard",
-    "wolf",
-  ] as const
-
-  export function create() {
-    return [
-      ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)],
-      NOUNS[Math.floor(Math.random() * NOUNS.length)],
-    ].join("-")
-  }
-}

package/postinstall.cjs

@@ -1,55 +0,0 @@
-#!/usr/bin/env node
-// Creates @opencode-ai/* symlinks so imports resolve correctly.
-// In a workspace monorepo, npm does this automatically.
-// In a published flat package, we do it manually.
-
-const fs = require('fs');
-const path = require('path');
-
-const nodeModules = path.join(__dirname, 'node_modules');
-const packages = path.join(__dirname, 'packages');
-
-const links = {
-  '@opencode-ai/plugin': path.join(packages, 'plugin'),
-  '@opencode-ai/script': path.join(packages, 'script'),
-  '@opencode-ai/sdk': path.join(packages, 'sdk'),
-  '@opencode-ai/util': path.join(packages, 'util'),
-};
-
-// Ensure node_modules/@opencode-ai exists
-const scopeDir = path.join(nodeModules, '@opencode-ai');
-fs.mkdirSync(scopeDir, { recursive: true });
-
-for (const [name, target] of Object.entries(links)) {
-  const linkPath = path.join(nodeModules, name);
-  
-  // Remove existing (might be a directory from npm install)
-  try {
-    const stat = fs.lstatSync(linkPath);
-    if (stat.isSymbolicLink() || stat.isFile()) {
-      fs.unlinkSync(linkPath);
-    } else if (stat.isDirectory()) {
-      fs.rmSync(linkPath, { recursive: true });
-    }
-  } catch (e) {
-    // Doesn't exist, fine
-  }
-  
-  // Create relative symlink
-  const relTarget = path.relative(path.dirname(linkPath), target);
-  fs.symlinkSync(relTarget, linkPath);
-}
-
-// Also fix node-pty if needed
-try {
-  const fixScript = path.join(packages, 'opencode', 'script', 'fix-node-pty.ts');
-  if (fs.existsSync(fixScript)) {
-    // node-pty fix is optional, don't fail install if it errors
-    require('child_process').execSync('node ' + fixScript, { 
-      cwd: path.join(packages, 'opencode'),
-      stdio: 'ignore' 
-    });
-  }
-} catch (e) {
-  // non-fatal
-}