soraacode 0.2.0 → 0.2.2

package/parsers-config.ts

@@ -1 +0,0 @@
-export { default } from "@soraacode/tui/parsers-config"

package/script/bench-search.ts

@@ -1,94 +0,0 @@
-import { Effect } from "effect"
-import { Fff } from "@soraacode/core/filesystem/fff.bun"
-import { AppRuntime } from "@/effect/app-runtime"
-import { FileSystem } from "@soraacode/core/filesystem"
-import { AbsolutePath } from "@soraacode/core/schema"
-import { InstanceStore } from "@/project/instance-store"
-
-const dir = AbsolutePath.make(process.cwd())
-
-const FILE_QUERIES = ["fff", "package.json", "tools/ experiment"]
-const GREP_QUERIES = ["FileFinder", "import", "grep", "autocomplete"]
-const GLOB_QUERIES = ["**/*.test.ts"]
-
-const FILE_LIMIT = 100
-const GREP_LIMIT = 50
-const GLOB_LIMIT = 50
-
-const run = <A, R>(effect: Effect.Effect<A, unknown, R>) =>
-  AppRuntime.runPromise(
-    InstanceStore.Service.use((store) => store.provide({ directory: dir }, effect as never)),
-  ) as Promise<A>
-
-// --- raw Fff picker ---
-const t0 = performance.now()
-const made = Fff.create({ basePath: dir, aiMode: true })
-if (!made.ok) {
-  console.error("Fff.create failed:", made.error)
-  process.exit(1)
-}
-const picker = made.value
-console.log(`picker create: ${(performance.now() - t0).toFixed(1)}ms`)
-
-const tw = performance.now()
-await picker.waitForScan(2_500)
-console.log(`wait for scan: ${(performance.now() - tw).toFixed(1)}ms`)
-
-// warmup grep to let the content index build
-const tWarmup = performance.now()
-picker.grep("_warmup_", { mode: "regex", maxMatchesPerFile: 1, timeBudgetMs: 1_500 })
-console.log(`grep warmup: ${(performance.now() - tWarmup).toFixed(1)}ms`)
-
-console.log()
-console.log("--- raw picker (warm) ---")
-
-for (const q of FILE_QUERIES) {
-  const t = performance.now()
-  const r = picker.fileSearch(q, { pageSize: Math.max(FILE_LIMIT, 100) })
-  const count = r.ok ? r.value.items.length : "err"
-  console.log(`[picker] fileSearch "${q}": ${(performance.now() - t).toFixed(1)}ms (${count} results)`)
-}
-
-for (const q of GREP_QUERIES) {
-  const t = performance.now()
-  const r = picker.grep(q, { mode: "regex", pageSize: GREP_LIMIT, timeBudgetMs: 1_500 })
-  const count = r.ok ? r.value.items.length : "err"
-  console.log(`[picker] grep "${q}": ${(performance.now() - t).toFixed(1)}ms (${count} matches)`)
-}
-
-picker.destroy()
-
-// --- Search service: init breakdown ---
-console.log()
-
-// 1) runtime + InstanceState + picker create + scan poll
-const tRuntime = performance.now()
-console.log(`[Search] init file (runtime + picker + scan): ${(performance.now() - tRuntime).toFixed(1)}ms`)
-
-// 2) grep warmup (content index cold-start inside the Search service picker)
-const tGrepWarmup = performance.now()
-await run(FileSystem.Service.use((svc) => svc.grep({ pattern: "_warmup_grep_", limit: 1 })))
-console.log(`[Search] init grep (content index warmup):    ${(performance.now() - tGrepWarmup).toFixed(1)}ms`)
-
-console.log()
-console.log("--- Search service (warm) ---")
-
-for (const q of FILE_QUERIES) {
-  const t = performance.now()
-  const r = await run(FileSystem.Service.use((svc) => svc.find({ query: q, limit: FILE_LIMIT })))
-  console.log(`[Search.find] "${q}": ${(performance.now() - t).toFixed(1)}ms (${r.length} results)`)
-}
-
-for (const q of GREP_QUERIES) {
-  const t = performance.now()
-  const r = await run(FileSystem.Service.use((svc) => svc.grep({ pattern: q, limit: GREP_LIMIT })))
-  console.log(`[Search.grep] "${q}": ${(performance.now() - t).toFixed(1)}ms (${r.length} matches)`)
-}
-
-for (const q of GLOB_QUERIES) {
-  const t = performance.now()
-  const r = await run(FileSystem.Service.use((svc) => svc.glob({ pattern: q, limit: GLOB_LIMIT })))
-  console.log(`[Search.glob] "${q}": ${(performance.now() - t).toFixed(1)}ms (${r.length} files)`)
-}
-
-process.exit(0)

package/script/bench-test-suite.ts

@@ -1,52 +0,0 @@
-// Full-suite timing harness for the test-speed research in ../../perf/test-suite.md.
-// Use this for periodic sanity checks; use profile-test-files.ts for discovery.
-// Env: BENCH_WARMUPS=0 BENCH_RUNS=1 bun run bench:test
-const warmups = Number(Bun.env.BENCH_WARMUPS ?? 0)
-const runs = Number(Bun.env.BENCH_RUNS ?? 1)
-const timings: number[] = []
-
-if (!Number.isInteger(warmups) || warmups < 0) {
-  console.error("BENCH_WARMUPS must be a non-negative integer")
-  process.exit(1)
-}
-if (!Number.isInteger(runs) || runs < 1) {
-  console.error("BENCH_RUNS must be a positive integer")
-  process.exit(1)
-}
-
-for (const index of Array.from({ length: warmups + runs }, (_, index) => index)) {
-  const measured = index >= warmups
-  const label = measured ? `run ${index - warmups + 1}/${runs}` : `warmup ${index + 1}/${warmups}`
-  const start = performance.now()
-  console.log(`bench:test ${label}`)
-
-  const proc = Bun.spawn(["bun", "test", "--timeout", "30000"], {
-    cwd: import.meta.dir + "/..",
-    stdout: "inherit",
-    stderr: "inherit",
-    env: Bun.env,
-  })
-
-  const exitCode = await proc.exited
-  if (exitCode !== 0) {
-    console.error(`bench:test failed during ${label} with exit code ${exitCode}`)
-    process.exit(exitCode)
-  }
-
-  const seconds = (performance.now() - start) / 1000
-  console.log(`bench:test ${label} ${seconds.toFixed(3)}s`)
-  if (measured) timings.push(seconds)
-}
-
-const sorted = timings.toSorted((a, b) => a - b)
-const median = sorted[Math.floor(sorted.length / 2)]
-const mean = timings.reduce((sum, timing) => sum + timing, 0) / timings.length
-const best = sorted[0] ?? median
-const worst = sorted.at(-1) ?? median
-
-console.log(
-  `bench:test median=${median.toFixed(3)}s mean=${mean.toFixed(3)}s best=${best.toFixed(3)}s worst=${worst.toFixed(3)}s`,
-)
-console.log(`METRIC test_suite_seconds=${median.toFixed(3)}`)
-console.log(`METRIC test_suite_best_seconds=${best.toFixed(3)}`)
-console.log(`METRIC test_suite_worst_seconds=${worst.toFixed(3)}`)

package/script/build-headless.ts

@@ -1,51 +0,0 @@
-#!/usr/bin/env bun
-import { $ } from "bun"
-import path from "path"
-import { fileURLToPath } from "url"
-
-const dir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
-process.chdir(dir)
-
-const pkg = await import("../package.json")
-
-console.log(`building soraacode-linux-x64`)
-await $`mkdir -p dist/soraacode-linux-x64/bin`
-
-await Bun.build({
-  conditions: ["bun", "node"],
-  tsconfig: "./tsconfig.headless.json",
-  external: ["node-gyp"],
-  format: "esm",
-  minify: true,
-  sourcemap: "none",
-  splitting: true,
-  compile: {
-    autoloadBunfig: false,
-    autoloadDotenv: false,
-    autoloadTsconfig: true,
-    autoloadPackageJson: true,
-    target: "bun-linux-x64",
-    outfile: "dist/soraacode-linux-x64/bin/soraacode",
-    execArgv: ["--user-agent=soraacode/0.2.0", "--use-system-ca", "--"],
-    windows: {},
-  },
-  define: {
-    OPENCODE_VERSION: "'0.2.0'",
-    OPENCODE_MODELS_DEV: "null",
-    OPENCODE_CHANNEL: "'stable'",
-    OPENCODE_LIBC: "'glibc'",
-  },
-  entrypoints: ["./src/index-headless.ts"],
-})
-
-const binaryPath = "dist/soraacode-linux-x64/bin/soraacode"
-console.log(`smoke test: ${binaryPath} --version`)
-try {
-  const v = await $`${binaryPath} --version`.text()
-  console.log(`OK: ${v.trim()}`)
-} catch (e) {
-  console.error("smoke test failed:", e)
-  process.exit(1)
-}
-
-console.log("done")

package/script/build.ts

@@ -1,245 +0,0 @@
-#!/usr/bin/env bun
-
-import { $ } from "bun"
-import path from "path"
-import { fileURLToPath } from "url"
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const dir = path.resolve(__dirname, "..")
-
-process.chdir(dir)
-
-const generated = await import("./generate.ts")
-
-import { Script } from "@soraacode/script"
-import pkg from "../package.json"
-
-const singleFlag = process.argv.includes("--single")
-const baselineFlag = process.argv.includes("--baseline")
-const skipInstall = process.argv.includes("--skip-install")
-const sourcemapsFlag = process.argv.includes("--sourcemaps")
-const skipTui = process.argv.includes("--skip-tui")
-const skipEmbedWebUi = process.argv.includes("--skip-embed-web-ui")
-
-const createEmbeddedWebUIBundle = async () => {
-  console.log(`Building Web UI to embed in the binary`)
-  const appDir = path.join(import.meta.dirname, "../../app")
-  const dist = path.join(appDir, "dist")
-  await $`OPENCODE_CHANNEL=${Script.channel} bun run --cwd ${appDir} build`
-  const files = (await Array.fromAsync(new Bun.Glob("**/*").scan({ cwd: dist })))
-    .map((file) => file.replaceAll("\\", "/"))
-    .filter((file) => !file.endsWith(".map"))
-    .sort()
-  const imports = files.map((file, i) => {
-    const spec = path.relative(dir, path.join(dist, file)).replaceAll("\\", "/")
-    return `import file_${i} from ${JSON.stringify(spec.startsWith(".") ? spec : `./${spec}`)} with { type: "file" };`
-  })
-  const entries = files.map((file, i) => `  ${JSON.stringify(file)}: file_${i},`)
-  return [
-    `// Import all files as file_$i with type: "file"`,
-    ...imports,
-    `// Export with original mappings`,
-    `export default {`,
-    ...entries,
-    `}`,
-  ].join("\n")
-}
-
-const embeddedFileMap = skipEmbedWebUi ? null : await createEmbeddedWebUIBundle()
-const treeSitterWorker = await Bun.file(fileURLToPath(import.meta.resolve("@opentui/core/parser.worker"))).text()
-
-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: "arm64",
-  },
-  {
-    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"]}`
-  await $`bun install --os="*" --cpu="*" @ff-labs/fff-bun@${pkg.dependencies["@ff-labs/fff-bun"]}`
-}
-for (const item of targets) {
-  const name = [
-    pkg.name,
-    // 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 workerPath = "./src/cli/tui/worker.ts"
-  const treeSitterWorkerPath = "opentui-tree-sitter-worker.js"
-  const bunfsRoot = item.os === "win32" ? "B:/~BUN/root/" : "/$bunfs/root/"
-
-  await Bun.build({
-    conditions: ["bun", "node"],
-    tsconfig: "./tsconfig.json",
-    plugins: skipTui ? [] : [plugin],
-    external: ["node-gyp"],
-    format: "esm",
-    minify: true,
-    sourcemap: sourcemapsFlag ? "linked" : "none",
-    splitting: true,
-    compile: {
-      autoloadBunfig: false,
-      autoloadDotenv: false,
-      autoloadTsconfig: true,
-      autoloadPackageJson: true,
-      target: name.replace(pkg.name, "bun") as any,
-      outfile: `dist/${name}/bin/opencode`,
-      execArgv: [`--user-agent=opencode/${Script.version}`, "--use-system-ca", "--"],
-      windows: {},
-    },
-    files: {
-      [treeSitterWorkerPath]: treeSitterWorker,
-      ...(embeddedFileMap ? { "opencode-web-ui.gen.ts": embeddedFileMap } : {}),
-    },
-    entrypoints: [
-      "./src/index.ts",
-      workerPath,
-      treeSitterWorkerPath,
-      ...(embeddedFileMap ? ["opencode-web-ui.gen.ts"] : []),
-    ],
-    define: {
-      FFF_LIBC: JSON.stringify(item.abi === "musl" ? "musl" : "gnu"),
-      OPENCODE_VERSION: `'${Script.version}'`,
-      OPENCODE_MODELS_DEV: generated.modelsData,
-      OTUI_TREE_SITTER_WORKER_PATH: bunfsRoot + treeSitterWorkerPath,
-      OPENCODE_WORKER_PATH: workerPath,
-      OPENCODE_CHANNEL: `'${Script.channel}'`,
-      OPENCODE_LIBC: item.os === "linux" ? `'${item.abi ?? "glibc"}'` : "",
-      ...(item.os === "linux" ? { "process.env.OPENTUI_LIBC": JSON.stringify(item.abi ?? "glibc") } : {}),
-    },
-  })
-
-  // Smoke test: only run if binary is for current platform
-  if (item.os === process.platform && item.arch === process.arch && !item.abi) {
-    const binaryPath = `dist/${name}/bin/opencode`
-    console.log(`Running smoke test: ${binaryPath} --version`)
-    try {
-      const versionOutput = await $`${binaryPath} --version`.text()
-      console.log(`Smoke test passed: ${versionOutput.trim()}`)
-    } catch (e) {
-      console.error(`Smoke test failed for ${name}:`, e)
-      process.exit(1)
-    }
-  }
-
-  await $`rm -rf ./dist/${name}/bin/tui`
-  await Bun.file(`dist/${name}/package.json`).write(
-    JSON.stringify(
-      {
-        name,
-        version: Script.version,
-        preferUnplugged: true,
-        os: [item.os],
-        cpu: [item.arch],
-        ...(item.abi ? { libc: [item.abi] } : {}),
-      },
-      null,
-      2,
-    ),
-  )
-  binaries[name] = Script.version
-}
-
-if (Script.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`)
-    }
-  }
-  await $`gh release upload v${Script.version} ./dist/*.zip ./dist/*.tar.gz --clobber --repo ${process.env.GH_REPO}`
-}
-
-export { binaries }

package/script/generate.ts

@@ -1,14 +0,0 @@
-import path from "path"
-import { fileURLToPath } from "url"
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const dir = path.resolve(__dirname, "..")
-
-process.chdir(dir)
-
-const modelsUrl = process.env.OPENCODE_MODELS_URL || "https://models.dev"
-export const modelsData = process.env.MODELS_DEV_API_JSON
-  ? await Bun.file(process.env.MODELS_DEV_API_JSON).text()
-  : await fetch(`${modelsUrl}/api.json`).then((x) => x.text())
-console.log("Loaded models.dev snapshot")

package/script/httpapi-exercise.ts

@@ -1 +0,0 @@
-await import("../test/server/httpapi-exercise/index")

package/script/profile-test-files.ts

@@ -1,42 +0,0 @@
-// Per-file profiler for finding candidate test-speed work; see ../../perf/test-suite.md
-// for the benchmark notes, kept wins, and discarded experiments.
-// Example: TEST_PROFILE_GLOB='test/server/**/*.test.ts' TEST_PROFILE_TOP=15 bun run profile:test
-const pattern = Bun.env.TEST_PROFILE_GLOB ?? "test/**/*.test.{ts,tsx}"
-const limit = Number(Bun.env.TEST_PROFILE_LIMIT ?? 0)
-const timeout = Bun.env.TEST_PROFILE_TIMEOUT ?? "30000"
-const files = Array.fromAsync(new Bun.Glob(pattern).scan({ cwd: import.meta.dir + "/..", onlyFiles: true }))
-  .then((files) => files.toSorted())
-  .then((files) => (limit > 0 ? files.slice(0, limit) : files))
-
-const results = []
-for (const file of await files) {
-  const start = performance.now()
-  const proc = Bun.spawn(["bun", "test", "--timeout", timeout, file], {
-    cwd: import.meta.dir + "/..",
-    stdout: "pipe",
-    stderr: "pipe",
-    env: Bun.env,
-  })
-  const [output, error, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited,
-  ])
-  const seconds = (performance.now() - start) / 1000
-  results.push({ file, seconds, exitCode })
-  console.log(`${exitCode === 0 ? "PASS" : "FAIL"} ${seconds.toFixed(3)}s ${file}`)
-  if (exitCode !== 0) console.log((output + error).trim())
-}
-
-const sorted = results.toSorted((a, b) => b.seconds - a.seconds)
-console.log("\nSlowest test files:")
-for (const result of sorted.slice(0, Number(Bun.env.TEST_PROFILE_TOP ?? 20))) {
-  console.log(`${result.seconds.toFixed(3)}s ${result.exitCode === 0 ? "PASS" : "FAIL"} ${result.file}`)
-}
-
-if (sorted[0]) {
-  console.log(`METRIC slowest_test_file_seconds=${sorted[0].seconds.toFixed(3)}`)
-  console.log(`METRIC profiled_test_files=${results.length}`)
-}
-
-if (results.some((result) => result.exitCode !== 0)) process.exit(1)