refactor(core): move database schema ownership

.opencode/opencode.jsonc

@@ -2,6 +2,9 @@
   "$schema": "https://opencode.ai/config.json",
   "provider": {},
   "permission": {},
+  "reference": {
+    "effect": "github.com/Effect-TS/effect-smol",
+  },
   "mcp": {},
   "tools": {
     "github-triage": false,

AGENTS.md

@@ -49,6 +49,12 @@ obj.b
 const { a, b } = obj
 ```
 
+### Imports
+
+- Never alias imports. Do not use `import { foo as bar } from "..."` or renamed imports like `resolve as pathResolve`.
+- Never use star imports. Do not use `import * as Foo from "..."` or `import type * as Foo from "..."`.
+- If a namespace-style value is needed, import the module's own exported namespace by name, for example `import { Project } from "@opencode-ai/core/project"`, then reference `Project.ID`.
+
 ### Variables
 
 Prefer `const` over `let`. Use ternaries or early returns instead of reassignment.

packages/opencode/drizzle.config.ts → packages/core/drizzle.config.ts

@@ -2,7 +2,7 @@ import { defineConfig } from "drizzle-kit"
 
 export default defineConfig({
   dialect: "sqlite",
-  schema: "./src/**/*.sql.ts",
+  schema: ["./src/**/*.sql.ts", "./src/**/sql.ts"],
   out: "./migration",
   dbCredentials: {
     url: "/home/thdxr/.local/share/opencode/opencode.db",

packages/core/package.json

@@ -6,6 +6,8 @@
   "license": "MIT",
   "private": true,
   "scripts": {
+    "db": "bun drizzle-kit",
+    "migration": "bun run script/migration.ts",
     "test": "bun test",
     "test:ci": "mkdir -p .artifacts/unit && bun test --timeout 30000 --reporter=junit --reporter-outfile=.artifacts/unit/junit.xml",
     "typecheck": "tsgo --noEmit"
@@ -16,14 +18,21 @@
   "exports": {
     "./*": "./src/*.ts"
   },
-  "imports": {},
+  "imports": {
+    "#sqlite": {
+      "bun": "./src/database/sqlite.bun.ts",
+      "node": "./src/database/sqlite.node.ts",
+      "default": "./src/database/sqlite.bun.ts"
+    }
+  },
   "devDependencies": {
     "@tsconfig/bun": "catalog:",
     "@types/bun": "catalog:",
     "@types/cross-spawn": "catalog:",
     "@types/npm-package-arg": "6.1.4",
     "@types/npmcli__arborist": "6.3.3",
-    "@types/semver": "catalog:"
+    "@types/semver": "catalog:",
+    "drizzle-kit": "catalog:"
   },
   "dependencies": {
     "@ai-sdk/alibaba": "1.0.17",
@@ -49,15 +58,19 @@
     "@aws-sdk/credential-providers": "3.993.0",
     "@effect/opentelemetry": "catalog:",
     "@effect/platform-node": "catalog:",
+    "@effect/sql-sqlite-bun": "catalog:",
     "@npmcli/arborist": "9.4.0",
     "@npmcli/config": "10.8.1",
+    "@opencode-ai/effect-drizzle-sqlite": "workspace:*",
+    "@opencode-ai/effect-sqlite-node": "workspace:*",
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/context-async-hooks": "2.6.1",
     "@opentelemetry/exporter-trace-otlp-http": "0.214.0",
     "@opentelemetry/sdk-trace-base": "2.6.1",
     "@openrouter/ai-sdk-provider": "2.8.1",
     "ai-gateway-provider": "3.1.2",
     "cross-spawn": "catalog:",
+    "drizzle-orm": "catalog:",
     "effect": "catalog:",
     "gitlab-ai-provider": "6.7.0",
     "glob": "13.0.5",

packages/core/script/migration.ts

@@ -0,0 +1,113 @@
+#!/usr/bin/env bun
+
+import { $ } from "bun"
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import { pathToFileURL } from "url"
+
+const root = path.resolve(import.meta.dirname, "../../..")
+const sqlDir = path.join(root, "packages/core/migration")
+const tsDir = path.join(root, "packages/core/src/database/migration")
+const registry = path.join(root, "packages/core/src/database/migration.gen.ts")
+
+if (Bun.argv.includes("--check")) {
+  await check()
+  process.exit(0)
+}
+
+await $`bun drizzle-kit generate`.cwd(path.join(root, "packages/core"))
+
+const sqlMigrations = (await Array.fromAsync(new Bun.Glob("*/migration.sql").scan({ cwd: sqlDir })))
+  .map((file) => file.split("/")[0])
+  .filter((name) => name !== undefined)
+  .sort()
+
+for (const name of sqlMigrations) {
+  if (await Bun.file(path.join(tsDir, `${name}.ts`)).exists()) continue
+  await Bun.write(path.join(tsDir, `${name}.ts`), renderMigration(name, await Bun.file(path.join(sqlDir, name, "migration.sql")).text()))
+}
+
+await Bun.write(registry, renderRegistry(sqlMigrations))
+
+async function check() {
+  const temporary = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-core-migration-check-"))
+  const output = path.join(temporary, "migration")
+  try {
+    await fs.cp(sqlDir, output, { recursive: true })
+    const config = path.join(temporary, "drizzle.config.ts")
+    await Bun.write(
+      config,
+      `import config from ${JSON.stringify(pathToFileURL(path.join(root, "packages/core/drizzle.config.ts")).href)}
+
+export default { ...config, out: ${JSON.stringify(output)} }
+`,
+    )
+    const before = await snapshot(output)
+    await $`bun drizzle-kit generate --config ${config}`.cwd(path.join(root, "packages/core"))
+    const after = await snapshot(output)
+    if (JSON.stringify(after) !== JSON.stringify(before)) {
+      throw new Error("Core schema has ungenerated database migrations. Run `bun script/migration.ts` from packages/core.")
+    }
+
+    const migrations = before
+      .map((entry) => entry.path.split("/")[0])
+      .filter((name, index, all) => name !== undefined && all.indexOf(name) === index)
+      .sort()
+    for (const name of migrations) {
+      if (await Bun.file(path.join(tsDir, `${name}.ts`)).exists()) continue
+      throw new Error(`Database migration TypeScript wrapper is missing for ${name}. Run \`bun script/migration.ts\` from packages/core.`)
+    }
+    if ((await Bun.file(registry).text()) !== renderRegistry(migrations)) {
+      throw new Error("Database migration registry is stale. Run `bun script/migration.ts` from packages/core.")
+    }
+  } finally {
+    await fs.rm(temporary, { recursive: true, force: true })
+  }
+}
+
+async function snapshot(directory: string) {
+  const files = await Array.fromAsync(new Bun.Glob("**/*").scan({ cwd: directory, onlyFiles: true }))
+  return Promise.all(
+    files.sort().map(async (file) => ({ path: file, contents: await Bun.file(path.join(directory, file)).text() })),
+  )
+}
+
+function renderMigration(name: string, sql: string) {
+  return `import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration"
+
+export default {
+  id: ${JSON.stringify(name)},
+  up(tx) {
+    return Effect.gen(function* () {
+${sql
+  .split("--> statement-breakpoint")
+  .map((statement) => statement.trim())
+  .filter((statement) => statement.length > 0)
+  .map(renderRun)
+  .join("\n")}
+    })
+  },
+} satisfies DatabaseMigration.Migration
+`
+}
+
+function renderRun(statement: string) {
+  const lines = statement.replaceAll("\t", "  ").split("\n")
+  if (lines.length === 1) return `      yield* tx.run(\`${escapeTemplate(lines[0])}\`)`
+  return `      yield* tx.run(\`\n${lines.map((line) => `        ${escapeTemplate(line)}`).join("\n")}\n      \`)`
+}
+
+function escapeTemplate(line: string) {
+  return line.replaceAll("\\", "\\\\").replaceAll("`", "\\`").replaceAll("${", "\\${")
+}
+
+function renderRegistry(names: string[]) {
+  return `import type { DatabaseMigration } from "./migration"
+
+export const migrations = (await Promise.all([
+${names.map((name) => `  import("./migration/${name}"),`).join("\n")}
+])).map((module) => module.default) satisfies DatabaseMigration.Migration[]
+`
+}