woozlit 2.3.0 → 2.3.1

package/script/build.ts

@@ -1,269 +0,0 @@
-#!/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"
-
-export const VERSION = "2.2.9"
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const dir = path.resolve(__dirname, "..")
-
-process.chdir(dir)
-
-await import("./generate.ts")
-
-import { Script } from "@woozlit/script"
-import pkg from "../package.json"
-
-const BINARY_PREFIX = "woozlit"
-
-// Load migrations from migration directories
-const migrationDirs = (
-  await fs.promises.readdir(path.join(dir, "migration"), {
-    withFileTypes: true,
-  })
-)
-  .filter((entry) => entry.isDirectory() && /^\d{4}\d{2}\d{2}\d{2}\d{2}\d{2}/.test(entry.name))
-  .map((entry) => entry.name)
-  .sort()
-
-const migrations = await Promise.all(
-  migrationDirs.map(async (name) => {
-    const file = path.join(dir, "migration", name, "migration.sql")
-    const sql = await Bun.file(file).text()
-    const match = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/.exec(name)
-    const timestamp = match
-      ? Date.UTC(
-          Number(match[1]),
-          Number(match[2]) - 1,
-          Number(match[3]),
-          Number(match[4]),
-          Number(match[5]),
-          Number(match[6]),
-        )
-      : 0
-    return { sql, timestamp, name }
-  }),
-)
-console.log(`Loaded ${migrations.length} migrations`)
-
-const singleFlag = process.argv.includes("--single")
-const baselineFlag = process.argv.includes("--baseline")
-const skipInstall = process.argv.includes("--skip-install")
-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 $`bun run --cwd ${appDir} build`
-  const files = (await Array.fromAsync(new Bun.Glob("**/*").scan({ cwd: dist })))
-    .map((file) => file.replaceAll("\\", "/"))
-    .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 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 = [
-    BINARY_PREFIX,
-    // 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/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: [plugin],
-    external: ["node-gyp"],
-    format: "esm",
-    minify: true,
-    splitting: true,
-    compile: {
-      autoloadBunfig: false,
-      autoloadDotenv: false,
-      autoloadTsconfig: true,
-      autoloadPackageJson: true,
-      target: name.replace(BINARY_PREFIX, "bun") as any,
-      outfile: `dist/${name}/bin/woozlit`,
-      execArgv: [`--user-agent=WOOZLIT_CODE/${Script.version}`, "--use-system-ca", "--"],
-      windows: {},
-    },
-    files: embeddedFileMap ? { "opencode-web-ui.gen.ts": embeddedFileMap } : {},
-    entrypoints: ["./src/index.ts", parserWorker, workerPath, ...(embeddedFileMap ? ["opencode-web-ui.gen.ts"] : [])],
-    define: {
-      OPENCODE_VERSION: `'${Script.version}'`,
-      OPENCODE_MIGRATIONS: JSON.stringify(migrations),
-      OTUI_TREE_SITTER_WORKER_PATH: bunfsRoot + workerRelativePath,
-      OPENCODE_WORKER_PATH: workerPath,
-      OPENCODE_CHANNEL: `'${Script.channel}'`,
-      OPENCODE_LIBC: item.os === "linux" ? `'${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/woozlit`
-    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,
-        os: [item.os],
-        cpu: [item.arch],
-      },
-      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/check-migrations.ts

@@ -1,16 +0,0 @@
-#!/usr/bin/env bun
-
-import { $ } from "bun"
-
-// drizzle-kit check compares schema to migrations, exits non-zero if drift
-const result = await $`bun drizzle-kit check`.quiet().nothrow()
-
-if (result.exitCode !== 0) {
-  console.error("Schema has changes not captured in migrations!")
-  console.error("Run: bun drizzle-kit generate")
-  console.error("")
-  console.error(result.stderr.toString())
-  process.exit(1)
-}
-
-console.log("Migrations are up to date")

package/script/fix-node-pty.ts

@@ -1,28 +0,0 @@
-#!/usr/bin/env bun
-
-import fs from "fs/promises"
-import path from "path"
-import { fileURLToPath } from "url"
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const dir = path.resolve(__dirname, "..")
-
-if (process.platform !== "win32") {
-  const root = path.join(dir, "node_modules", "node-pty", "prebuilds")
-  const dirs = await fs.readdir(root, { withFileTypes: true }).catch(() => [])
-  const files = dirs.filter((x) => x.isDirectory()).map((x) => path.join(root, x.name, "spawn-helper"))
-  const result = await Promise.all(
-    files.map(async (file) => {
-      const stat = await fs.stat(file).catch(() => undefined)
-      if (!stat) return
-      if ((stat.mode & 0o111) === 0o111) return
-      await fs.chmod(file, stat.mode | 0o755)
-      return file
-    }),
-  )
-  const fixed = result.filter(Boolean)
-  if (fixed.length) {
-    console.log(`fixed node-pty permissions for ${fixed.length} helper${fixed.length === 1 ? "" : "s"}`)
-  }
-}

package/script/generate.ts

@@ -1,23 +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.WOOZLIT_CODE_MODELS_URL || "https://models.dev"
-// Fetch and generate models.dev snapshot
-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())
-await Bun.write(
-  path.join(dir, "src/provider/models-snapshot.js"),
-  `// @ts-nocheck\n// Auto-generated by build.ts - do not edit\nexport const snapshot = ${modelsData}\n`,
-)
-await Bun.write(
-  path.join(dir, "src/provider/models-snapshot.d.ts"),
-  `// Auto-generated by build.ts - do not edit\nexport declare const snapshot: Record<string, unknown>\n`,
-)
-console.log("Generated models-snapshot.js")

package/script/publish.ts

@@ -1,75 +0,0 @@
-#!/usr/bin/env bun
-import { $ } from "bun"
-import pkg from "../package.json"
-import { Script } from "@woozlit/script"
-import { fileURLToPath } from "url"
-import fs from "node:fs"
-
-const dir = fileURLToPath(new URL("..", import.meta.url))
-process.chdir(dir)
-
-let otpVal = ""
-const otpIdx = process.argv.indexOf("--otp")
-if (otpIdx !== -1 && process.argv[otpIdx + 1]) {
-  otpVal = process.argv[otpIdx + 1]
-} else {
-  const match = process.argv.find((arg) => arg.startsWith("--otp="))
-  if (match) otpVal = match.split("=")[1]
-}
-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) {
-  if (process.platform !== "win32") await $`chmod -R 755 .`.cwd(dir)
-  if (await published(name, version)) {
-    console.log(`already published ${name}@${version}`)
-    return
-  }
-  if (otpVal) {
-    await $`npm publish --access public --tag ${Script.channel} --otp ${otpVal}`.cwd(dir)
-  } else {
-    await $`npm publish --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 pkgDist = await Bun.file(`./dist/${filepath}`).json()
-  if (pkgDist.name !== pkg.name) {
-    binaries[pkgDist.name] = pkgDist.version
-  }
-}
-console.log("binaries", binaries)
-const version = Object.values(binaries)[0] || pkg.version
-
-const targetDir = `./dist/${pkg.name}`
-fs.mkdirSync(targetDir, { recursive: true })
-fs.cpSync("./bin", `${targetDir}/bin`, { recursive: true })
-fs.cpSync("./script/postinstall.mjs", `${targetDir}/postinstall.mjs`)
-const licensePath = fileURLToPath(new URL("../../../LICENSE", import.meta.url))
-await Bun.file(`./dist/${pkg.name}/LICENSE`).write(await Bun.file(licensePath).text())
-
-await Bun.file(`./dist/${pkg.name}/package.json`).write(
-  JSON.stringify(
-    {
-      name: pkg.name,
-      bin: {
-        woozlit: "bin/woozlit",
-      },
-      scripts: {
-        postinstall: "bun ./postinstall.mjs || node ./postinstall.mjs",
-      },
-      version: version,
-      license: pkg.license,
-      optionalDependencies: binaries,
-    },
-    null,
-    2,
-  ),
-)
-
-for (const [name, version] of Object.entries(binaries)) {
-  await publish(`./dist/${name}`, name, version)
-}
-await publish(`./dist/${pkg.name}`, pkg.name, version)

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,63 +0,0 @@
-#!/usr/bin/env bun
-
-import { z } from "zod"
-import { Config } from "../src/config"
-import { TuiConfig } from "../src/cli/cmd/tui/config/tui"
-
-function generate(schema: z.ZodType) {
-  const result = z.toJSONSchema(schema, {
-    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: \`${String(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
-
-  return result
-}
-
-const configFile = process.argv[2]
-const tuiFile = process.argv[3]
-
-console.log(configFile)
-await Bun.write(configFile, JSON.stringify(generate(Config.Info), null, 2))
-
-if (tuiFile) {
-  console.log(tuiFile)
-  await Bun.write(tuiFile, JSON.stringify(generate(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())