soraacode 0.2.0 → 0.2.2

package/script/publish.ts

@@ -1,213 +0,0 @@
-#!/usr/bin/env bun
-import { $ } from "bun"
-import pkg from "../package.json"
-import { Script } from "@soraacode/script"
-import { fileURLToPath } from "url"
-
-const dir = fileURLToPath(new URL("..", import.meta.url))
-process.chdir(dir)
-
-async function published(name: string, version: string) {
-  return (await $`npm view ${name}@${version} version`.nothrow()).exitCode === 0
-}
-
-async function publish(dir: string, name: string, version: string) {
-  // GitHub artifact downloads can drop the executable bit, and Docker uses the
-  // unpacked dist binaries directly rather than the published tarball.
-  if (process.platform !== "win32") await $`chmod -R 755 .`.cwd(dir)
-  if (await published(name, version)) {
-    console.log(`already published ${name}@${version}`)
-    return
-  }
-  await $`bun pm pack`.cwd(dir)
-  await $`npm publish *.tgz --access public --tag ${Script.channel}`.cwd(dir)
-}
-
-const binaries: Record<string, string> = {}
-for (const filepath of new Bun.Glob("*/package.json").scanSync({ cwd: "./dist" })) {
-  const pkg = await Bun.file(`./dist/${filepath}`).json()
-  binaries[pkg.name] = pkg.version
-}
-console.log("binaries", binaries)
-const version = Object.values(binaries)[0]
-
-await $`mkdir -p ./dist/${pkg.name}`
-await $`mkdir -p ./dist/${pkg.name}/bin`
-await $`cp ./script/postinstall.mjs ./dist/${pkg.name}/postinstall.mjs`
-await Bun.file(`./dist/${pkg.name}/LICENSE`).write(await Bun.file("../../LICENSE").text())
-await Bun.file(`./dist/${pkg.name}/bin/${pkg.name}.exe`).write(
-  [
-    `echo "Error: ${pkg.name}-ai's postinstall script was not run." >&2`,
-    'echo "" >&2',
-    'echo "This occurs when using --ignore-scripts during installation, or when using a" >&2',
-    'echo "package manager like pnpm that does not run postinstall scripts by default." >&2',
-    'echo "" >&2',
-    'echo "To fix this, run the postinstall script manually:" >&2',
-    `echo "  cd node_modules/${pkg.name}-ai && node postinstall.mjs" >&2`,
-    'echo "" >&2',
-    `echo "Or reinstall ${pkg.name}-ai without the --ignore-scripts flag." >&2`,
-    "exit 1",
-    "",
-  ].join("\n"),
-)
-
-await Bun.file(`./dist/${pkg.name}/package.json`).write(
-  JSON.stringify(
-    {
-      name: pkg.name + "-ai",
-      bin: {
-        [pkg.name]: `./bin/${pkg.name}.exe`,
-      },
-      scripts: {
-        postinstall: "node ./postinstall.mjs",
-      },
-      version: version,
-      license: pkg.license,
-      os: ["darwin", "linux", "win32"],
-      cpu: ["arm64", "x64"],
-      optionalDependencies: binaries,
-    },
-    null,
-    2,
-  ),
-)
-
-const tasks = Object.entries(binaries).map(async ([name]) => {
-  await publish(`./dist/${name}`, name, binaries[name])
-})
-await Promise.all(tasks)
-await publish(`./dist/${pkg.name}`, `${pkg.name}-ai`, version)
-
-const image = "ghcr.io/anomalyco/opencode"
-const platforms = "linux/amd64,linux/arm64"
-const tags = [`${image}:${version}`, `${image}:${Script.channel}`]
-const tagFlags = tags.flatMap((t) => ["-t", t])
-
-// registries
-if (!Script.preview) {
-  await $`docker buildx build --platform ${platforms} ${tagFlags} --push .`
-  // Calculate SHA values
-  const arm64Sha = await $`sha256sum ./dist/opencode-linux-arm64.tar.gz | cut -d' ' -f1`.text().then((x) => x.trim())
-  const x64Sha = await $`sha256sum ./dist/opencode-linux-x64.tar.gz | cut -d' ' -f1`.text().then((x) => x.trim())
-  const macX64Sha = await $`sha256sum ./dist/opencode-darwin-x64.zip | cut -d' ' -f1`.text().then((x) => x.trim())
-  const macArm64Sha = await $`sha256sum ./dist/opencode-darwin-arm64.zip | cut -d' ' -f1`.text().then((x) => x.trim())
-
-  const [pkgver, _subver = ""] = Script.version.split(/(-.*)/, 2)
-
-  // arch
-  const binaryPkgbuild = [
-    "# Maintainer: dax",
-    "# Maintainer: adam",
-    "",
-    "pkgname='opencode-bin'",
-    `pkgver=${pkgver}`,
-    `_subver=${_subver}`,
-    "options=('!debug' '!strip')",
-    "pkgrel=1",
-    "pkgdesc='The AI coding agent built for the terminal.'",
-    "url='https://github.com/anomalyco/opencode'",
-    "arch=('aarch64' 'x86_64')",
-    "license=('MIT')",
-    "provides=('opencode')",
-    "conflicts=('opencode')",
-    "depends=('ripgrep')",
-    "",
-    `source_aarch64=("\${pkgname}_\${pkgver}_aarch64.tar.gz::https://github.com/anomalyco/opencode/releases/download/v\${pkgver}\${_subver}/opencode-linux-arm64.tar.gz")`,
-    `sha256sums_aarch64=('${arm64Sha}')`,
-
-    `source_x86_64=("\${pkgname}_\${pkgver}_x86_64.tar.gz::https://github.com/anomalyco/opencode/releases/download/v\${pkgver}\${_subver}/opencode-linux-x64.tar.gz")`,
-    `sha256sums_x86_64=('${x64Sha}')`,
-    "",
-    "package() {",
-    '  install -Dm755 ./opencode "${pkgdir}/usr/bin/opencode"',
-    "}",
-    "",
-  ].join("\n")
-
-  for (const [pkg, pkgbuild] of [["opencode-bin", binaryPkgbuild]]) {
-    for (let i = 0; i < 30; i++) {
-      try {
-        await $`rm -rf ./dist/aur-${pkg}`
-        await $`git clone ssh://aur@aur.archlinux.org/${pkg}.git ./dist/aur-${pkg}`
-        await $`cd ./dist/aur-${pkg} && git checkout master`
-        await Bun.file(`./dist/aur-${pkg}/PKGBUILD`).write(pkgbuild)
-        await $`cd ./dist/aur-${pkg} && makepkg --printsrcinfo > .SRCINFO`
-        await $`cd ./dist/aur-${pkg} && git add PKGBUILD .SRCINFO`
-        if ((await $`cd ./dist/aur-${pkg} && git diff --cached --quiet`.nothrow()).exitCode === 0) break
-        await $`cd ./dist/aur-${pkg} && git commit -m "Update to v${Script.version}"`
-        await $`cd ./dist/aur-${pkg} && git push`
-        break
-      } catch {
-        continue
-      }
-    }
-  }
-
-  // Homebrew formula
-  const homebrewFormula = [
-    "# typed: false",
-    "# frozen_string_literal: true",
-    "",
-    "# This file was generated by GoReleaser. DO NOT EDIT.",
-    "class Opencode < Formula",
-    `  desc "The AI coding agent built for the terminal."`,
-    `  homepage "https://github.com/anomalyco/opencode"`,
-    `  version "${Script.version.split("-")[0]}"`,
-    "",
-    `  depends_on "ripgrep"`,
-    "",
-    "  on_macos do",
-    "    if Hardware::CPU.intel?",
-    `      url "https://github.com/anomalyco/opencode/releases/download/v${Script.version}/opencode-darwin-x64.zip"`,
-    `      sha256 "${macX64Sha}"`,
-    "",
-    "      def install",
-    '        bin.install "opencode"',
-    "      end",
-    "    end",
-    "    if Hardware::CPU.arm?",
-    `      url "https://github.com/anomalyco/opencode/releases/download/v${Script.version}/opencode-darwin-arm64.zip"`,
-    `      sha256 "${macArm64Sha}"`,
-    "",
-    "      def install",
-    '        bin.install "opencode"',
-    "      end",
-    "    end",
-    "  end",
-    "",
-    "  on_linux do",
-    "    if Hardware::CPU.intel? and Hardware::CPU.is_64_bit?",
-    `      url "https://github.com/anomalyco/opencode/releases/download/v${Script.version}/opencode-linux-x64.tar.gz"`,
-    `      sha256 "${x64Sha}"`,
-    "      def install",
-    '        bin.install "opencode"',
-    "      end",
-    "    end",
-    "    if Hardware::CPU.arm? and Hardware::CPU.is_64_bit?",
-    `      url "https://github.com/anomalyco/opencode/releases/download/v${Script.version}/opencode-linux-arm64.tar.gz"`,
-    `      sha256 "${arm64Sha}"`,
-    "      def install",
-    '        bin.install "opencode"',
-    "      end",
-    "    end",
-    "  end",
-    "end",
-    "",
-    "",
-  ].join("\n")
-
-  const token = process.env.GITHUB_TOKEN
-  if (!token) {
-    console.error("GITHUB_TOKEN is required to update homebrew tap")
-    process.exit(1)
-  }
-  const tap = `https://x-access-token:${token}@github.com/anomalyco/homebrew-tap.git`
-  await $`rm -rf ./dist/homebrew-tap`
-  await $`git clone ${tap} ./dist/homebrew-tap`
-  await Bun.file("./dist/homebrew-tap/opencode.rb").write(homebrewFormula)
-  await $`cd ./dist/homebrew-tap && git add opencode.rb`
-  if ((await $`cd ./dist/homebrew-tap && git diff --cached --quiet`.nothrow()).exitCode !== 0) {
-    await $`cd ./dist/homebrew-tap && git commit -m "Update to v${Script.version}"`
-    await $`cd ./dist/homebrew-tap && git push`
-  }
-}

package/script/run-workspace-server

@@ -1,106 +0,0 @@
-#!/usr/bin/env bun
-
-// This script runs a separate OpenCode server to be used as a remote
-// workspace, simulating a remote environment but all local to make
-// debugger easier
-//
-// *Important*: make sure you add the debug workspace plugin first.
-// In `.opencode/opencode.jsonc` in the root of this project add:
-//
-// "plugin": ["../packages/opencode/src/control-plane/dev/debug-workspace-plugin.ts"]
-//
-// Afterwards, run `./packages/opencode/script/run-workspace-server`
-
-import { stat } from "node:fs/promises"
-import { setTimeout as sleep } from "node:timers/promises"
-
-const DEV_DATA_FILE = "/tmp/opencode-workspace-dev-data.json"
-const RESTART_POLL_INTERVAL = 250
-
-async function readData() {
-  return await Bun.file(DEV_DATA_FILE).json()
-}
-
-async function readDataMtime() {
-  return await stat(DEV_DATA_FILE)
-    .then((info) => info.mtimeMs)
-    .catch((error) => {
-      if (typeof error === "object" && error && "code" in error && error.code === "ENOENT") {
-        return undefined
-      }
-
-      throw error
-    })
-}
-
-async function readSnapshot() {
-  while (true) {
-    try {
-      const before = await readDataMtime()
-      if (before === undefined) {
-        await sleep(RESTART_POLL_INTERVAL)
-        continue
-      }
-
-      const data = await readData()
-      const after = await readDataMtime()
-
-      if (before === after) {
-        return { data, mtime: after }
-      }
-    } catch (error) {
-      if (typeof error === "object" && error && "code" in error && error.code === "ENOENT") {
-        await sleep(RESTART_POLL_INTERVAL)
-        continue
-      }
-
-      throw error
-    }
-  }
-}
-
-function startDevServer(data: any) {
-  const env = Object.fromEntries(Object.entries(data.env ?? {}).filter(([, value]) => value !== undefined))
-
-  return Bun.spawn(["bun", "run", "dev", "serve", "--port", String(data.port), "--print-logs"], {
-    env: {
-      ...process.env,
-      ...env,
-      XDG_DATA_HOME: "/tmp/data",
-    },
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
-  })
-}
-
-async function waitForRestartSignal(mtime: number, signal: AbortSignal) {
-  while (!signal.aborted) {
-    await sleep(RESTART_POLL_INTERVAL)
-    if (signal.aborted) return false
-    if ((await readDataMtime()) !== mtime) return true
-  }
-
-  return false
-}
-
-while (true) {
-  const { data, mtime } = await readSnapshot()
-  const proc = startDevServer(data)
-  const restartAbort = new AbortController()
-
-  const result = await Promise.race([
-    proc.exited.then((code) => ({ type: "exit" as const, code })),
-    waitForRestartSignal(mtime, restartAbort.signal).then((restart) => ({ type: "restart" as const, restart })),
-  ])
-
-  restartAbort.abort()
-
-  if (result.type === "restart" && result.restart) {
-    proc.kill()
-    await proc.exited
-    continue
-  }
-
-  process.exit(result.code)
-}

package/script/schema.ts

@@ -1,77 +0,0 @@
-#!/usr/bin/env bun
-
-import { Config } from "@/config/config"
-import { ConfigV1 } from "@soraacode/core/v1/config/config"
-import { TuiConfig } from "@soraacode/tui/config"
-import { Schema } from "effect"
-
-type JsonSchema = Record<string, unknown>
-const MODEL_REF = "https://models.dev/model-schema.json#/$defs/Model"
-
-function generateEffect(schema: Schema.Top) {
-  const document = Schema.toJsonSchemaDocument(schema)
-  const normalized = normalize({
-    $schema: "https://json-schema.org/draft/2020-12/schema",
-    ...document.schema,
-    $defs: document.definitions,
-  })
-  if (!isRecord(normalized)) throw new Error("schema generator produced a non-object schema")
-  const restored = restoreModelRefs(normalized)
-  if (!isRecord(restored)) throw new Error("schema generator produced a non-object schema")
-  restored.allowComments = true
-  restored.allowTrailingCommas = true
-  return restored
-}
-
-function normalize(value: unknown): unknown {
-  if (Array.isArray(value)) return value.map(normalize)
-  if (!isRecord(value)) return value
-
-  const schema = Object.fromEntries(Object.entries(value).map(([key, item]) => [key, normalize(item)]))
-
-  if (Array.isArray(schema.anyOf)) {
-    const anyOf = schema.anyOf.filter((item) => !isRecord(item) || item.type !== "null")
-    if (anyOf.length !== schema.anyOf.length) {
-      const { anyOf: _, ...rest } = schema
-      if (anyOf.length === 1 && isRecord(anyOf[0])) return normalize({ ...anyOf[0], ...rest })
-      return { ...rest, anyOf }
-    }
-  }
-
-  if (Array.isArray(schema.allOf) && schema.allOf.length === 1 && isRecord(schema.allOf[0])) {
-    const { allOf: _, ...rest } = schema
-    return normalize({ ...schema.allOf[0], ...rest })
-  }
-
-  if (schema.type === "integer" && schema.maximum === undefined) {
-    return { ...schema, maximum: Number.MAX_SAFE_INTEGER }
-  }
-
-  return schema
-}
-
-function restoreModelRefs(value: unknown, key?: string): unknown {
-  if (Array.isArray(value)) return value.map((item) => restoreModelRefs(item))
-  if (!isRecord(value)) return value
-
-  const schema = Object.fromEntries(Object.entries(value).map(([name, item]) => [name, restoreModelRefs(item, name)]))
-  if ((key === "model" || key === "small_model") && schema.type === "string") {
-    return { ...schema, $ref: MODEL_REF }
-  }
-  return schema
-}
-
-function isRecord(value: unknown): value is JsonSchema {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-}
-
-const configFile = process.argv[2]
-const tuiFile = process.argv[3]
-
-console.log(configFile)
-await Bun.write(configFile, JSON.stringify(generateEffect(ConfigV1.Info), null, 2))
-
-if (tuiFile) {
-  console.log(tuiFile)
-  await Bun.write(tuiFile, JSON.stringify(generateEffect(TuiConfig.Info), null, 2))
-}

package/script/time.ts

@@ -1,6 +0,0 @@
-#!/usr/bin/env bun
-
-import path from "path"
-const toDynamicallyImport = path.join(process.cwd(), process.argv[2])
-await import(toDynamicallyImport)
-console.log(performance.now())

package/script/trace-imports.ts

@@ -1,153 +0,0 @@
-#!/usr/bin/env bun
-import * as path from "path"
-import * as ts from "typescript"
-
-const BASE_DIR = "/home/thdxr/dev/projects/anomalyco/opencode/packages/opencode"
-
-// Get entry file from command line arg or use default
-const ENTRY_FILE = process.argv[2] || "src/plugin/tui/runtime.ts"
-
-const visited = new Set<string>()
-
-function resolveImport(importPath: string, fromFile: string): string | null {
-  if (importPath.startsWith("@/")) {
-    return path.join(BASE_DIR, "src", importPath.slice(2))
-  }
-
-  if (importPath.startsWith("./") || importPath.startsWith("../")) {
-    const dir = path.dirname(fromFile)
-    return path.resolve(dir, importPath)
-  }
-
-  return null
-}
-
-function isInternalImport(importPath: string): boolean {
-  return importPath.startsWith("@/") || importPath.startsWith("./") || importPath.startsWith("../")
-}
-
-async function tryExtensions(filePath: string): Promise<string | null> {
-  const extensions = [".ts", ".tsx", ".js", ".jsx"]
-
-  try {
-    const file = Bun.file(filePath)
-    const stat = await file.stat()
-
-    if (stat?.isDirectory()) {
-      for (const ext of extensions) {
-        const indexPath = path.join(filePath, "index" + ext)
-        const indexFile = Bun.file(indexPath)
-        if (await indexFile.exists()) return indexPath
-      }
-      return null
-    }
-
-    // It's a file
-    return filePath
-  } catch {
-    // Path doesn't exist, try adding extensions
-    for (const ext of extensions) {
-      const withExt = filePath + ext
-      const extFile = Bun.file(withExt)
-      if (await extFile.exists()) return withExt
-    }
-    return null
-  }
-}
-
-function extractImports(sourceFile: ts.SourceFile): string[] {
-  const imports: string[] = []
-
-  function visit(node: ts.Node) {
-    // import x from "path" or import { x } from "path"
-    if (ts.isImportDeclaration(node)) {
-      // Skip type-only imports
-      if (node.importClause?.isTypeOnly) return
-
-      const moduleSpec = node.moduleSpecifier
-      if (ts.isStringLiteral(moduleSpec)) {
-        imports.push(moduleSpec.text)
-      }
-    }
-
-    // export { x } from "path"
-    if (ts.isExportDeclaration(node) && node.moduleSpecifier) {
-      if (ts.isStringLiteral(node.moduleSpecifier)) {
-        imports.push(node.moduleSpecifier.text)
-      }
-    }
-
-    // Dynamic import: import("path")
-    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
-      const arg = node.arguments[0]
-      if (arg && ts.isStringLiteral(arg)) {
-        imports.push(arg.text)
-      }
-    }
-
-    ts.forEachChild(node, visit)
-  }
-
-  visit(sourceFile)
-  return imports
-}
-
-async function traceFile(filePath: string, depth = 0): Promise<void> {
-  const normalizedPath = path.relative(BASE_DIR, filePath)
-
-  if (visited.has(filePath)) {
-    return
-  }
-
-  // Only trace TypeScript/JavaScript files
-  if (!filePath.match(/\.(ts|tsx|js|jsx)$/)) {
-    return
-  }
-
-  visited.add(filePath)
-  console.log("\t".repeat(depth) + normalizedPath)
-
-  let content: string
-  try {
-    content = await Bun.file(filePath).text()
-  } catch {
-    return
-  }
-
-  const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true)
-
-  const imports = extractImports(sourceFile)
-  const internalImports = imports.filter(isInternalImport)
-  const externalImports = imports.filter((imp) => !isInternalImport(imp))
-
-  // Print external imports
-  for (const imp of externalImports) {
-    console.log("\t".repeat(depth + 1) + `[ext] ${imp}`)
-  }
-
-  for (const imp of internalImports) {
-    const resolved = resolveImport(imp, filePath)
-    if (!resolved) continue
-
-    const actualPath = await tryExtensions(resolved)
-    if (!actualPath) continue
-
-    await traceFile(actualPath, depth + 1)
-  }
-}
-
-async function main() {
-  const entryPath = path.join(BASE_DIR, ENTRY_FILE)
-
-  // Check if file exists
-  const file = Bun.file(entryPath)
-  if (!(await file.exists())) {
-    console.error(`File not found: ${ENTRY_FILE}`)
-    console.error(`Resolved to: ${entryPath}`)
-    process.exit(1)
-  }
-
-  await traceFile(entryPath)
-}
-
-main().catch(console.error)