easc-cli 1.1.37 → 1.1.41

package/script/build.ts

@@ -1,172 +0,0 @@
-#!/usr/bin/env bun
-
-import solidPlugin from "../node_modules/@opentui/solid/scripts/solid-plugin"
-import path from "path"
-import fs from "fs"
-import { $ } from "bun"
-import { fileURLToPath } from "url"
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const dir = path.resolve(__dirname, "..")
-
-process.chdir(dir)
-
-import pkg from "../package.json"
-import { Script } from "@eliseart.ai/script"
-
-const singleFlag = process.argv.includes("--single")
-const baselineFlag = process.argv.includes("--baseline")
-const skipInstall = process.argv.includes("--skip-install")
-
-const allTargets: {
-  os: string
-  arch: "arm64" | "x64"
-  abi?: "musl"
-  avx2?: false
-}[] = [
-    {
-      os: "linux",
-      arch: "arm64",
-    },
-    {
-      os: "linux",
-      arch: "x64",
-    },
-    {
-      os: "linux",
-      arch: "x64",
-      avx2: false,
-    },
-    {
-      os: "linux",
-      arch: "arm64",
-      abi: "musl",
-    },
-    {
-      os: "linux",
-      arch: "x64",
-      abi: "musl",
-    },
-    {
-      os: "linux",
-      arch: "x64",
-      abi: "musl",
-      avx2: false,
-    },
-    {
-      os: "darwin",
-      arch: "arm64",
-    },
-    {
-      os: "darwin",
-      arch: "x64",
-    },
-    {
-      os: "darwin",
-      arch: "x64",
-      avx2: false,
-    },
-    {
-      os: "win32",
-      arch: "x64",
-    },
-    {
-      os: "win32",
-      arch: "x64",
-      avx2: false,
-    },
-  ]
-
-const targets = singleFlag
-  ? allTargets.filter((item) => {
-    if (item.os !== process.platform || item.arch !== process.arch) {
-      return false
-    }
-
-    // When building for the current platform, prefer a single native binary by default.
-    // Baseline binaries require additional Bun artifacts and can be flaky to download.
-    if (item.avx2 === false) {
-      return baselineFlag
-    }
-
-    // also skip abi-specific builds for the same reason
-    if (item.abi !== undefined) {
-      return false
-    }
-
-    return true
-  })
-  : allTargets
-
-await $`rm -rf dist`
-
-const binaries: Record<string, string> = {}
-if (!skipInstall) {
-  await $`bun install --os="*" --cpu="*" @opentui/core@${pkg.dependencies["@opentui/core"]}`
-  await $`bun install --os="*" --cpu="*" @parcel/watcher@${pkg.dependencies["@parcel/watcher"]}`
-}
-for (const item of targets) {
-  const name = [
-    "easc",
-    // changing to win32 flags npm for some reason
-    item.os === "win32" ? "windows" : item.os,
-    item.arch,
-    item.avx2 === false ? "baseline" : undefined,
-    item.abi === undefined ? undefined : item.abi,
-  ]
-    .filter(Boolean)
-    .join("-")
-  console.log(`building ${name}`)
-  await $`mkdir -p dist/${name}/bin`
-
-  const parserWorker = fs.realpathSync(path.resolve(dir, "./node_modules/@opentui/core/parser.worker.js"))
-  const workerPath = "./src/cli/cmd/tui/worker.ts"
-
-  // Use platform-specific bunfs root path based on target OS
-  const bunfsRoot = item.os === "win32" ? "B:/~BUN/root/" : "/$bunfs/root/"
-  const workerRelativePath = path.relative(dir, parserWorker).replaceAll("\\", "/")
-
-  await Bun.build({
-    conditions: ["browser"],
-    tsconfig: "./tsconfig.json",
-    plugins: [solidPlugin],
-    sourcemap: "external",
-    compile: {
-      autoloadBunfig: false,
-      autoloadDotenv: false,
-      //@ts-ignore (bun types aren't up to date)
-      autoloadTsconfig: true,
-      autoloadPackageJson: true,
-      target: name.replace("easc", "bun") as any,
-      outfile: `dist/${name}/bin/easc`,
-      execArgv: [`--user-agent=easc/${Script.version}`, "--use-system-ca", "--"],
-      windows: {},
-    },
-    entrypoints: ["./src/index.ts", parserWorker, workerPath],
-    define: {
-      EASC_VERSION: `'${Script.version}'`,
-      OTUI_TREE_SITTER_WORKER_PATH: bunfsRoot + workerRelativePath,
-      EASC_WORKER_PATH: workerPath,
-      EASC_CHANNEL: `'${Script.channel}'`,
-      EASC_LIBC: item.os === "linux" ? `'${item.abi ?? "glibc"}'` : "",
-    },
-  })
-
-  await $`rm -rf ./dist/${name}/bin/tui`
-  await Bun.file(`dist/${name}/package.json`).write(
-    JSON.stringify(
-      {
-        name,
-        version: Script.version,
-        os: [item.os],
-        cpu: [item.arch],
-      },
-      null,
-      2,
-    ),
-  )
-  binaries[name] = Script.version
-}
-
-export { binaries }

package/script/deploy.ts

@@ -1,96 +0,0 @@
-import { $ } from "bun"
-import fs from "fs"
-import path from "path"
-import pkg from "../package.json"
-import { fileURLToPath } from "url"
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const root = path.resolve(__dirname, "..")
-
-process.chdir(root)
-
-console.log("🚀 Starting deployment of EASC...")
-
-// 1. Build all binaries
-console.log("\n📦 Building binaries...")
-await $`bun run script/build.ts`
-
-// 2. Publish platform-specific packages FIRST
-const distDir = path.join(root, "dist")
-if (!fs.existsSync(distDir)) {
-    console.error("❌ Build failed: dist directory not found")
-    process.exit(1)
-}
-
-const packages = fs.readdirSync(distDir).filter(f => fs.statSync(path.join(distDir, f)).isDirectory())
-
-console.log(`\n📤 Publishing ${packages.length} platform packages...`)
-
-for (const pkgName of packages) {
-    const pkgDir = path.join(distDir, pkgName)
-    const pkgJsonPath = path.join(pkgDir, "package.json")
-
-    if (!fs.existsSync(pkgJsonPath)) {
-        console.warn(`⚠️ Skipping ${pkgName}: no package.json found`)
-        continue
-    }
-
-    const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"))
-    console.log(`\n   Publishing ${pkgJson.name}@${pkgJson.version}...`)
-
-    // We navigate to the directory to publish
-    try {
-        await $`cd ${pkgDir} && npm publish --access public`
-        console.log(`   ✅ Published ${pkgJson.name}`)
-    } catch (e: any) {
-        console.error(`   ❌ Failed to publish ${pkgJson.name}:`, e.message)
-        // We continue even if one fails, as duplicates might exist
-    }
-}
-
-// 3. Update main package.json optionalDependencies
-console.log(`\n🔄 Updating optionalDependencies in package.json...`)
-const linuxPkg = JSON.parse(fs.readFileSync(path.join(distDir, "easc-linux-x64", "package.json"), "utf-8"))
-const binaryVersion = linuxPkg.version
-
-const mainPkgPath = path.join(root, "package.json")
-const mainPkg = JSON.parse(fs.readFileSync(mainPkgPath, "utf-8"))
-const originalMainPkg = JSON.parse(fs.readFileSync(mainPkgPath, "utf-8")) // keep original
-
-const platforms = [
-    "easc-linux-x64", "easc-linux-arm64",
-    "easc-darwin-x64", "easc-darwin-arm64",
-    "easc-windows-x64"
-]
-
-for (const p of platforms) {
-    mainPkg.optionalDependencies[p] = binaryVersion
-}
-
-// 4. Publish the main wrapper package
-console.log(`\n📤 Publishing main wrapper package (easc-cli@${pkg.version})...`)
-
-// Strip dependencies and devDependencies before publishing
-// The wrapper package only needs optionalDependencies for the platform binaries
-mainPkg.dependencies = {}
-mainPkg.devDependencies = {}
-fs.writeFileSync(mainPkgPath, JSON.stringify(mainPkg, null, 2))
-
-try {
-    // Ensure we are in the root of the package
-    await $`npm publish --access public`
-    console.log(`✅ Published ${pkg.name}`)
-} catch (e: any) {
-    console.error(`❌ Failed to publish ${pkg.name}:`, e.message)
-    // Restore original package.json
-    fs.writeFileSync(mainPkgPath, JSON.stringify(originalMainPkg, null, 2))
-    process.exit(1)
-}
-
-// Restore original package.json with deps intact (but keep updated optionalDeps)
-originalMainPkg.optionalDependencies = mainPkg.optionalDependencies
-fs.writeFileSync(mainPkgPath, JSON.stringify(originalMainPkg, null, 2))
-
-console.log("\n✨ Deployment complete! Users can now install with:")
-console.log("   npm install -g easc-cli")

package/script/publish-registries.ts

@@ -1,187 +0,0 @@
-#!/usr/bin/env bun
-import { $ } from "bun"
-import { Script } from "@eliseart.ai/script"
-
-if (!Script.preview) {
-  // 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")
-
-  // Source-based PKGBUILD for opencode
-  const sourcePkgbuild = [
-    "# Maintainer: dax",
-    "# Maintainer: adam",
-    "",
-    "pkgname='opencode'",
-    `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-bin')",
-    "depends=('ripgrep')",
-    "makedepends=('git' 'bun' 'go')",
-    "",
-    `source=("opencode-\${pkgver}.tar.gz::https://github.com/anomalyco/opencode/archive/v\${pkgver}\${_subver}.tar.gz")`,
-    `sha256sums=('SKIP')`,
-    "",
-    "build() {",
-    `  cd "opencode-\${pkgver}"`,
-    `  bun install`,
-    "  cd ./packages/opencode",
-    `  OPENCODE_CHANNEL=latest OPENCODE_VERSION=${pkgver} bun run ./script/build.ts --single`,
-    "}",
-    "",
-    "package() {",
-    `  cd "opencode-\${pkgver}/packages/opencode"`,
-    '  mkdir -p "${pkgdir}/usr/bin"',
-    '  target_arch="x64"',
-    '  case "$CARCH" in',
-    '    x86_64) target_arch="x64" ;;',
-    '    aarch64) target_arch="arm64" ;;',
-    '    *) printf "unsupported architecture: %s\\n" "$CARCH" >&2 ; return 1 ;;',
-    "  esac",
-    '  libc=""',
-    "  if command -v ldd >/dev/null 2>&1; then",
-    "    if ldd --version 2>&1 | grep -qi musl; then",
-    '      libc="-musl"',
-    "    fi",
-    "  fi",
-    '  if [ -z "$libc" ] && ls /lib/ld-musl-* >/dev/null 2>&1; then',
-    '    libc="-musl"',
-    "  fi",
-    '  base=""',
-    '  if [ "$target_arch" = "x64" ]; then',
-    "    if ! grep -qi avx2 /proc/cpuinfo 2>/dev/null; then",
-    '      base="-baseline"',
-    "    fi",
-    "  fi",
-    '  bin="dist/opencode-linux-${target_arch}${base}${libc}/bin/opencode"',
-    '  if [ ! -f "$bin" ]; then',
-    '    printf "unable to find binary for %s%s%s\\n" "$target_arch" "$base" "$libc" >&2',
-    "    return 1",
-    "  fi",
-    '  install -Dm755 "$bin" "${pkgdir}/usr/bin/opencode"',
-    "}",
-    "",
-  ].join("\n")
-
-  for (const [pkg, pkgbuild] of [
-    ["opencode-bin", binaryPkgbuild],
-    ["opencode", sourcePkgbuild],
-  ]) {
-    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`
-        await $`cd ./dist/aur-${pkg} && git commit -m "Update to v${Script.version}"`
-        await $`cd ./dist/aur-${pkg} && git push`
-        break
-      } catch (e) {
-        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")
-
-  await $`rm -rf ./dist/homebrew-tap`
-  await $`git clone https://${process.env["GITHUB_TOKEN"]}@github.com/sst/homebrew-tap.git ./dist/homebrew-tap`
-  await Bun.file("./dist/homebrew-tap/opencode.rb").write(homebrewFormula)
-  await $`cd ./dist/homebrew-tap && git add opencode.rb`
-  await $`cd ./dist/homebrew-tap && git commit -m "Update to v${Script.version}"`
-  await $`cd ./dist/homebrew-tap && git push`
-}

package/script/publish.ts

@@ -1,70 +0,0 @@
-#!/usr/bin/env bun
-import { $ } from "bun"
-import pkg from "../package.json"
-import { Script } from "@eliseart.ai/script"
-import { fileURLToPath } from "url"
-
-const dir = fileURLToPath(new URL("..", import.meta.url))
-process.chdir(dir)
-
-const { binaries } = await import("./build.ts")
-{
-  const name = `${pkg.name}-${process.platform}-${process.arch}`
-  console.log(`smoke test: running dist/${name}/bin/opencode --version`)
-  await $`./dist/${name}/bin/opencode --version`
-}
-
-await $`mkdir -p ./dist/${pkg.name}`
-await $`cp -r ./bin ./dist/${pkg.name}/bin`
-await $`cp ./script/postinstall.mjs ./dist/${pkg.name}/postinstall.mjs`
-
-await Bun.file(`./dist/${pkg.name}/package.json`).write(
-  JSON.stringify(
-    {
-      name: pkg.name + "-ai",
-      bin: {
-        [pkg.name]: `./bin/${pkg.name}`,
-      },
-      scripts: {
-        postinstall: "bun ./postinstall.mjs || node ./postinstall.mjs",
-      },
-      version: Script.version,
-      optionalDependencies: binaries,
-    },
-    null,
-    2,
-  ),
-)
-
-const tags = [Script.channel]
-
-const tasks = Object.entries(binaries).map(async ([name]) => {
-  if (process.platform !== "win32") {
-    await $`chmod -R 755 .`.cwd(`./dist/${name}`)
-  }
-  await $`bun pm pack`.cwd(`./dist/${name}`)
-  for (const tag of tags) {
-    await $`npm publish *.tgz --access public --tag ${tag}`.cwd(`./dist/${name}`)
-  }
-})
-await Promise.all(tasks)
-for (const tag of tags) {
-  await $`cd ./dist/${pkg.name} && bun pm pack && npm publish *.tgz --access public --tag ${tag}`
-}
-
-if (!Script.preview) {
-  // Create archives for GitHub release
-  for (const key of Object.keys(binaries)) {
-    if (key.includes("linux")) {
-      await $`tar -czf ../../${key}.tar.gz *`.cwd(`dist/${key}/bin`)
-    } else {
-      await $`zip -r ../../${key}.zip *`.cwd(`dist/${key}/bin`)
-    }
-  }
-
-  const image = "ghcr.io/anomalyco/opencode"
-  const platforms = "linux/amd64,linux/arm64"
-  const tags = [`${image}:${Script.version}`, `${image}:latest`]
-  const tagFlags = tags.flatMap((t) => ["-t", t])
-  await $`docker buildx build --platform ${platforms} ${tagFlags} --push .`
-}

package/script/schema.ts

@@ -1,47 +0,0 @@
-#!/usr/bin/env bun
-
-import { z } from "zod"
-import { Config } from "../src/config/config"
-
-const file = process.argv[2]
-console.log(file)
-
-const result = z.toJSONSchema(Config.Info, {
-  io: "input", // Generate input shape (treats optional().default() as not required)
-  /**
-   * We'll use the `default` values of the field as the only value in `examples`.
-   * This will ensure no docs are needed to be read, as the configuration is
-   * self-documenting.
-   *
-   * See https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-00#rfc.section.9.5
-   */
-  override(ctx) {
-    const schema = ctx.jsonSchema
-
-    // Preserve strictness: set additionalProperties: false for objects
-    if (schema && typeof schema === "object" && schema.type === "object" && schema.additionalProperties === undefined) {
-      schema.additionalProperties = false
-    }
-
-    // Add examples and default descriptions for string fields with defaults
-    if (schema && typeof schema === "object" && "type" in schema && schema.type === "string" && schema?.default) {
-      if (!schema.examples) {
-        schema.examples = [schema.default]
-      }
-
-      schema.description = [schema.description || "", `default: \`${schema.default}\``]
-        .filter(Boolean)
-        .join("\n\n")
-        .trim()
-    }
-  },
-}) as Record<string, unknown> & {
-  allowComments?: boolean
-  allowTrailingCommas?: boolean
-}
-
-// used for json lsps since config supports jsonc
-result.allowComments = true
-result.allowTrailingCommas = true
-
-await Bun.write(file, JSON.stringify(result, null, 2))

package/script/seed-e2e.ts

@@ -1,50 +0,0 @@
-const dir = process.env.OPENCODE_E2E_PROJECT_DIR ?? process.cwd()
-const title = process.env.OPENCODE_E2E_SESSION_TITLE ?? "E2E Session"
-const text = process.env.OPENCODE_E2E_MESSAGE ?? "Seeded for UI e2e"
-const model = process.env.OPENCODE_E2E_MODEL ?? "opencode/gpt-5-nano"
-const parts = model.split("/")
-const providerID = parts[0] ?? "opencode"
-const modelID = parts[1] ?? "gpt-5-nano"
-const now = Date.now()
-
-const seed = async () => {
-  const { Instance } = await import("../src/project/instance")
-  const { InstanceBootstrap } = await import("../src/project/bootstrap")
-  const { Session } = await import("../src/session")
-  const { Identifier } = await import("../src/id/id")
-  const { Project } = await import("../src/project/project")
-
-  await Instance.provide({
-    directory: dir,
-    init: InstanceBootstrap,
-    fn: async () => {
-      const session = await Session.create({ title })
-      const messageID = Identifier.descending("message")
-      const partID = Identifier.descending("part")
-      const message = {
-        id: messageID,
-        sessionID: session.id,
-        role: "user" as const,
-        time: { created: now },
-        agent: "build",
-        model: {
-          providerID,
-          modelID,
-        },
-      }
-      const part = {
-        id: partID,
-        sessionID: session.id,
-        messageID,
-        type: "text" as const,
-        text,
-        time: { start: now },
-      }
-      await Session.updateMessage(message)
-      await Session.updatePart(part)
-      await Project.update({ projectID: Instance.project.id, name: "E2E Project" })
-    },
-  })
-}
-
-await seed()