@farhanic017/octocode 3.5.0

package/script/bench-search.ts

@@ -0,0 +1,115 @@
+import { Effect } from "effect"
+import { Fff } from "@octocode-ai/core/filesystem/fff.bun"
+import { AppRuntime } from "@/effect/app-runtime"
+import { Search } from "@octocode-ai/core/filesystem/search"
+import { InstanceStore } from "@/project/instance-store"
+
+const dir = 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>(effect: Effect.Effect<A, unknown, Search.Service>) =>
+  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()
+
+// --- Ripgrep service (via Search with file:["."] to force rg path) ---
+console.log()
+console.log("--- Ripgrep (via Search service) ---")
+
+// warmup
+await run(Search.Service.use((svc) => svc.search({ cwd: dir, pattern: "_warmup_rg_", limit: 1, file: ["."] })))
+
+for (const q of GREP_QUERIES) {
+  const t = performance.now()
+  const r = await run(Search.Service.use((svc) => svc.search({ cwd: dir, pattern: q, limit: GREP_LIMIT, file: ["."] })))
+  console.log(
+    `[ripgrep] grep "${q}": ${(performance.now() - t).toFixed(1)}ms (${r.items.length} total, limit is per-file not total)`,
+  )
+}
+
+// --- Search service: init breakdown ---
+console.log()
+
+// 1) runtime + InstanceState + picker create + scan poll
+const tRuntime = performance.now()
+await run(Search.Service.use((svc) => svc.file({ cwd: dir, query: "_warmup_file_", limit: 1 })))
+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(Search.Service.use((svc) => svc.search({ cwd: dir, 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(Search.Service.use((svc) => svc.file({ cwd: dir, query: q, limit: FILE_LIMIT })))
+  console.log(
+    `[Search.file] "${q}": ${(performance.now() - t).toFixed(1)}ms (${r?.length ?? "undefined (cache fallback)"} results)`,
+  )
+}
+
+for (const q of GREP_QUERIES) {
+  const t = performance.now()
+  const r = await run(Search.Service.use((svc) => svc.search({ cwd: dir, pattern: q, limit: GREP_LIMIT })))
+  console.log(
+    `[Search.search] "${q}": ${(performance.now() - t).toFixed(1)}ms (${r.items.length} matches, engine=${r.engine})`,
+  )
+}
+
+for (const q of GLOB_QUERIES) {
+  const t = performance.now()
+  const r = await run(Search.Service.use((svc) => svc.glob({ cwd: dir, pattern: q, limit: GLOB_LIMIT })))
+  console.log(
+    `[Search.glob] "${q}": ${(performance.now() - t).toFixed(1)}ms (${r.files.length} files, truncated=${r.truncated})`,
+  )
+}
+
+process.exit(0)

package/script/bench-test-suite.ts

@@ -0,0 +1,52 @@
+// 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.ts

@@ -0,0 +1,243 @@
+#!/usr/bin/env bun
+
+import { $ } from "bun"
+import fs from "fs"
+import path from "path"
+import { fileURLToPath } from "url"
+import { createSolidTransformPlugin } from "@opentui/solid/bun-plugin"
+
+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 "@octocode-ai/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 plugin = createSolidTransformPlugin()
+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 $`OCTOCODE_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 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 skipArm64Linux = allTargets.filter((item) => !(item.os === "linux" && item.arch === "arm64"))
+
+const targets = singleFlag
+  ? skipArm64Linux.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
+    })
+  : skipArm64Linux
+
+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 = [
+    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 localPath = path.resolve(dir, "node_modules/@opentui/core/parser.worker.js")
+  const rootPath = path.resolve(dir, "../../node_modules/@opentui/core/parser.worker.js")
+  const parserWorker = fs.realpathSync(fs.existsSync(localPath) ? localPath : rootPath)
+  const workerPath = "./src/cli/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: ["node"],
+    tsconfig: "./tsconfig.json",
+    plugins: [plugin],
+    external: ["node-gyp", "playwright", "playwright-core", "chromium-bidi"],
+    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/octo`,
+      execArgv: [`--user-agent=octo/${Script.version}`, "--use-system-ca", "--"],
+      windows: {},
+    },
+    files: embeddedFileMap ? { "octocode-web-ui.gen.ts": embeddedFileMap } : {},
+    entrypoints: ["./src/index.ts", parserWorker, workerPath, ...(embeddedFileMap ? ["octocode-web-ui.gen.ts"] : [])],
+    define: {
+      OCTOCODE_VERSION: `'${Script.version}'`,
+      OCTOCODE_MODELS_DEV: generated.modelsData,
+      OTUI_TREE_SITTER_WORKER_PATH: bunfsRoot + workerRelativePath,
+      OCTOCODE_WORKER_PATH: workerPath,
+      OCTOCODE_CHANNEL: `'${Script.channel}'`,
+      OCTOCODE_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/octo`
+    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

@@ -0,0 +1,14 @@
+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.OCTOCODE_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

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

package/script/octo-shim.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "child_process"
+import { existsSync } from "fs"
+import path from "path"
+import { fileURLToPath } from "url"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const isWindows = process.platform === "win32"
+const binaryPath = path.join(__dirname, isWindows ? "octocode.exe" : "octocode")
+
+if (!existsSync(binaryPath)) {
+  console.error("Error: octocode-ai's postinstall script was not run.")
+  console.error("")
+  console.error("This occurs when using --ignore-scripts during installation, or when using a")
+  console.error("package manager like pnpm that does not run postinstall scripts by default.")
+  console.error("")
+  console.error("To fix this, run the postinstall script manually:")
+  console.error("  cd node_modules/octocode-ai && node postinstall.mjs")
+  console.error("")
+  console.error("Or reinstall octocode-ai without the --ignore-scripts flag.")
+  process.exit(1)
+}
+
+const result = spawnSync(binaryPath, process.argv.slice(2), {
+  stdio: "inherit",
+  windowsHide: false,
+})
+
+if (result.error) {
+  throw result.error
+}
+
+process.exit(result.status ?? 1)

package/script/postinstall.mjs

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+
+import childProcess from "child_process"
+import fs from "fs"
+import os from "os"
+import path from "path"
+import { fileURLToPath } from "url"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+let packageJsonPath = path.join(__dirname, "package.json")
+if (!fs.existsSync(packageJsonPath)) {
+  packageJsonPath = path.join(__dirname, "..", "package.json")
+}
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"))
+const version = packageJson.version
+
+const platformMap = { darwin: "darwin", linux: "linux", win32: "windows" }
+const archMap = { x64: "x64", arm64: "arm64", arm: "arm" }
+
+const platform = platformMap[os.platform()] ?? os.platform()
+const arch = archMap[os.arch()] ?? os.arch()
+const sourceBinary = platform === "windows" ? "octo.exe" : "octo"
+
+let packageDir = __dirname
+if (!fs.existsSync(path.join(packageDir, "package.json"))) {
+  packageDir = path.join(__dirname, "..")
+}
+const targetBinary = path.join(packageDir, "bin", platform === "windows" ? "octocode.exe" : "octocode")
+
+function supportsAvx2() {
+  if (arch !== "x64") return false
+  if (platform === "linux") {
+    try { return /(^|\s)avx2(\s|$)/i.test(fs.readFileSync("/proc/cpuinfo", "utf8")) }
+    catch { return false }
+  }
+  if (platform === "darwin") {
+    try {
+      const r = childProcess.spawnSync("sysctl", ["-n", "hw.optional.avx2_0"], { encoding: "utf8", timeout: 1500 })
+      return r.status === 0 && (r.stdout || "").trim() === "1"
+    } catch { return false }
+  }
+  if (platform === "windows") {
+    const cmd = '(Add-Type -MemberDefinition "[DllImport(""kernel32.dll"")] public static extern bool IsProcessorFeaturePresent(int ProcessorFeature);" -Name Kernel32 -Namespace Win32 -PassThru)::IsProcessorFeaturePresent(40)'
+    for (const exe of ["powershell.exe", "pwsh.exe", "pwsh", "powershell"]) {
+      try {
+        const r = childProcess.spawnSync(exe, ["-NoProfile", "-NonInteractive", "-Command", cmd], { encoding: "utf8", timeout: 3000, windowsHide: true })
+        if (r.status !== 0) continue
+        const out = (r.stdout || "").trim().toLowerCase()
+        if (out === "true" || out === "1") return true
+        if (out === "false" || out === "0") return false
+      } catch { continue }
+    }
+  }
+  return false
+}
+
+function isMusl() {
+  if (platform !== "linux") return false
+  try { if (fs.existsSync("/etc/alpine-release")) return true } catch {}
+  try {
+    const r = childProcess.spawnSync("ldd", ["--version"], { encoding: "utf8" })
+    return `${r.stdout || ""}${r.stderr || ""}`.toLowerCase().includes("musl")
+  } catch { return false }
+}
+
+function getTarget() {
+  const baseline = arch === "x64" && !supportsAvx2()
+  const musl = isMusl()
+  let target = `${platform}-${arch}`
+  if (baseline) target += "-baseline"
+  if (musl) target += "-musl"
+  return target
+}
+
+function getTempDir() {
+  const tmp = os.tmpdir()
+  if (!tmp.includes(" ")) return tmp
+  const fallback = path.join(path.parse(tmp).root, "octocode-temp")
+  try { fs.mkdirSync(fallback, { recursive: true }) } catch {}
+  return fallback
+}
+
+function fetchLatestVersion() {
+  const r = childProcess.spawnSync("curl", ["-sL", "https://api.github.com/repos/farhanic017/octocode/releases/latest"], {
+    encoding: "utf8", timeout: 10000, windowsHide: true,
+  })
+  if (r.status !== 0) return version
+  try {
+    const tag = JSON.parse(r.stdout).tag_name || ""
+    return tag.replace(/^v/, "")
+  } catch { return version }
+}
+
+function downloadSync(url, dest) {
+  if (platform === "windows") {
+    childProcess.execSync(
+      `powershell.exe -NoProfile -NonInteractive -Command "[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; Invoke-WebRequest -Uri '${url}' -OutFile '${dest}' -UseBasicParsing"`,
+      { stdio: "ignore", windowsHide: true, timeout: 300000 }
+    )
+  } else {
+    const r = childProcess.spawnSync("curl", ["-sL", "-o", dest, url], {
+      stdio: "ignore", timeout: 300000,
+    })
+    if (r.status !== 0) throw new Error("curl download failed")
+  }
+}
+
+function downloadFromGitHub() {
+  const target = getTarget()
+  const ext = platform === "linux" ? ".tar.gz" : ".zip"
+  const filename = `octo-${target}${ext}`
+
+  let releaseVersion = version
+  try { releaseVersion = fetchLatestVersion() } catch {}
+
+  const url = `https://github.com/farhanic017/octocode/releases/download/v${releaseVersion}/${filename}`
+
+  process.stdout.write(`Downloading ${filename}... `)
+  const temp = fs.mkdtempSync(path.join(getTempDir(), "octocode-"))
+  const archivePath = path.join(temp, filename)
+
+  downloadSync(url, archivePath)
+
+  const extractDir = path.join(temp, "extract")
+  fs.mkdirSync(extractDir, { recursive: true })
+
+  if (platform === "linux") {
+    childProcess.spawnSync("tar", ["-xzf", archivePath, "-C", extractDir], { stdio: "ignore" })
+  } else if (platform === "windows") {
+    childProcess.spawnSync("powershell.exe", [
+      "-NoProfile", "-NonInteractive", "-Command",
+      `Expand-Archive -Path '${archivePath}' -DestinationPath '${extractDir}' -Force`
+    ], { stdio: "ignore", windowsHide: true })
+  } else {
+    childProcess.spawnSync("unzip", ["-q", archivePath, "-d", extractDir], { stdio: "ignore" })
+  }
+
+  const extractedBinary = path.join(extractDir, sourceBinary)
+  if (!fs.existsSync(extractedBinary)) {
+    throw new Error(`Binary not found after extraction: ${extractedBinary}`)
+  }
+
+  fs.mkdirSync(path.dirname(targetBinary), { recursive: true })
+  if (fs.existsSync(targetBinary)) fs.unlinkSync(targetBinary)
+  fs.copyFileSync(extractedBinary, targetBinary)
+  fs.chmodSync(targetBinary, 0o755)
+
+  fs.rmSync(temp, { recursive: true, force: true })
+  console.log("done")
+}
+
+function verifyBinary() {
+  const r = childProcess.spawnSync(targetBinary, ["--version"], {
+    encoding: "utf8", stdio: "ignore", windowsHide: true, shell: true,
+  })
+  return r.status === 0
+}
+
+function isInstalled() {
+  if (!fs.existsSync(targetBinary)) return false
+  const r = childProcess.spawnSync(targetBinary, ["--version"], {
+    encoding: "utf8", stdio: "pipe", windowsHide: true, shell: true,
+  })
+  if (r.status !== 0) return false
+  const installed = (r.stdout || "").trim()
+  // Treat dev builds (0.0.0-*) as not installed so they get replaced
+  if (installed.startsWith("0.0.0-")) return false
+  return true
+}
+
+function main() {
+  if (verifyBinary()) return
+
+  // 1. Try local binary (monorepo/dev)
+  const localPath = path.join(__dirname, "..", "dist", `octocode-${getTarget()}`, "bin", sourceBinary)
+  if (fs.existsSync(localPath)) {
+    fs.mkdirSync(path.dirname(targetBinary), { recursive: true })
+    if (fs.existsSync(targetBinary)) fs.unlinkSync(targetBinary)
+    fs.copyFileSync(localPath, targetBinary)
+    fs.chmodSync(targetBinary, 0o755)
+    if (verifyBinary()) return
+  }
+
+  // 2. Download from GitHub releases (synchronous)
+  downloadFromGitHub()
+  if (!verifyBinary()) throw new Error("Binary verification failed after download")
+}
+
+try {
+  main()
+} catch (error) {
+  console.error(error.message)
+  console.error("")
+  console.error("Download manually from: https://github.com/farhanic017/octocode/releases")
+  process.exit(1)
+}