bonecode 1.0.0

package/src/context_builder.ts

@@ -0,0 +1,598 @@
+/**
+ * BoneCode Context Builder
+ *
+ * Builds rich codebase context using structural strategies that work
+ * without any embedding model:
+ *   1. Postgres full-text search (BM25-ranked via ts_rank)
+ *   2. Git recency (recently changed files are more relevant)
+ *   3. Session history (files read/edited in this session)
+ *   4. Import graph expansion (pull in direct dependencies)
+ *   5. Instruction file injection (AGENTS.md / CLAUDE.md proximity)
+ *
+ * OPTIONAL UPGRADE — set EMBEDDING_PROVIDER in .env to enable hybrid search:
+ *   When EMBEDDING_PROVIDER is set, vector similarity search is added on top
+ *   of FTS using the bonecode_hybrid_search() stored function (RRF fusion).
+ *   Without it, pure FTS + structural strategies run — still better than
+ *   OpenCode's reactive grep approach.
+ *
+ * To enable embeddings, add to .env:
+ *   EMBEDDING_PROVIDER=openai          # or: ollama, voyage, openai_compatible
+ *   EMBEDDING_MODEL=text-embedding-3-small
+ *   EMBEDDING_API_KEY=sk-...           # defaults to OPENAI_API_KEY
+ *   EMBEDDING_BASE_URL=                # for local/compatible endpoints
+ *   EMBEDDING_DIMENSIONS=1536
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { pool } from "../bone/output/session/src/db";
+import { logger } from "../bone/output/session/src/logger";
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export interface ContextChunk {
+  file_path: string;
+  content: string;
+  start_line: number;
+  end_line: number;
+  language?: string;
+  symbol_name?: string;
+  symbol_type?: string;
+  relevance_score: number;
+  source: "fts" | "vector" | "hybrid" | "import_graph" | "git_recency" | "session_history" | "instruction" | "entrypoint";
+}
+
+export interface ContextResult {
+  chunks: ContextChunk[];
+  instruction_files: string[];
+  summary: string;
+}
+
+export interface ContextOptions {
+  session_id: string;
+  project_id: string;
+  worktree: string;
+  query: string;
+  max_chunks?: number;
+  max_chars?: number;
+}
+
+// ─── Embedding availability check ────────────────────────────────────────────
+
+export function embeddingsEnabled(): boolean {
+  return !!(process.env.EMBEDDING_PROVIDER && process.env.EMBEDDING_PROVIDER !== "none");
+}
+
+// ─── Main entry point ─────────────────────────────────────────────────────────
+
+export async function buildContext(opts: ContextOptions): Promise<ContextResult> {
+  const {
+    session_id, project_id, worktree, query,
+    max_chunks = 12,
+    max_chars = 12_000,
+  } = opts;
+
+  const chunks: ContextChunk[] = [];
+  const seen = new Set<string>(); // deduplicate by file_path:start_line
+
+  // Run structural strategies in parallel (always active)
+  const [ftsChunks, gitChunks, sessionChunks, instructionFiles] = await Promise.all([
+    searchFTS(project_id, query, 20).catch(() => []),
+    getGitRecentFiles(worktree, query, 10).catch(() => []),
+    getSessionHistory(session_id, worktree, 8).catch(() => []),
+    findInstructionFiles(worktree, query).catch(() => []),
+  ]);
+
+  // Optional: vector search upgrade when EMBEDDING_PROVIDER is configured
+  // Replaces FTS with hybrid search (vector + FTS + RRF) for better recall
+  let vectorChunks: ContextChunk[] = [];
+  if (embeddingsEnabled() && query.trim()) {
+    vectorChunks = await searchVector(project_id, query, 20).catch((e) => {
+      logger.error("vector_search_failed", { event: "context", metadata: { error: e.message } });
+      return [];
+    });
+  }
+
+  // Merge: prefer vector/hybrid results over pure FTS when available
+  const primaryChunks = vectorChunks.length > 0 ? vectorChunks : ftsChunks;
+  for (const c of primaryChunks) {
+    const key = `${c.file_path}:${c.start_line}`;
+    if (!seen.has(key)) { seen.add(key); chunks.push(c); }
+  }
+
+  // Add git-recent files not already covered
+  for (const c of gitChunks) {
+    const key = `${c.file_path}:${c.start_line}`;
+    if (!seen.has(key)) { seen.add(key); chunks.push(c); }
+  }
+
+  // Add session history files
+  for (const c of sessionChunks) {
+    const key = `${c.file_path}:${c.start_line}`;
+    if (!seen.has(key)) { seen.add(key); chunks.push(c); }
+  }
+
+  // Expand top results via import graph
+  const topFiles = chunks.slice(0, 5).map(c => c.file_path);
+  const importChunks = await expandImportGraph(worktree, topFiles, seen, 6).catch(() => []);
+  for (const c of importChunks) {
+    const key = `${c.file_path}:${c.start_line}`;
+    if (!seen.has(key)) { seen.add(key); chunks.push(c); }
+  }
+
+  // Sort by relevance score descending
+  chunks.sort((a, b) => b.relevance_score - a.relevance_score);
+
+  // Trim to budget
+  const trimmed = trimToCharBudget(chunks.slice(0, max_chunks), max_chars);
+
+  const mode = embeddingsEnabled() && vectorChunks.length > 0 ? "hybrid" : "structural";
+  const sources = [...new Set(trimmed.map(c => c.source))].join(", ");
+  const summary = trimmed.length > 0
+    ? `${trimmed.length} chunks [${mode}] from ${[...new Set(trimmed.map(c => path.basename(c.file_path)))].slice(0, 5).join(", ")} (${sources})`
+    : "no relevant context found";
+
+  return { chunks: trimmed, instruction_files: instructionFiles, summary };
+}
+
+// ─── Strategy 2: Vector Search (optional — requires EMBEDDING_PROVIDER) ───────
+// Uses the bonecode_hybrid_search() stored function (RRF: vector + FTS).
+// Only called when EMBEDDING_PROVIDER is set in .env.
+
+async function searchVector(project_id: string, query: string, limit: number): Promise<ContextChunk[]> {
+  if (!query.trim()) return [];
+
+  // Embed the query using the configured provider
+  const { embed_text } = await import("../bone/output/rag/src/extensions");
+  const model = process.env.EMBEDDING_MODEL || "text-embedding-nomic-embed-text-v1.5";
+  const queryEmbedding = await embed_text(query, model);
+  const embStr = "[" + queryEmbedding.join(",") + "]";
+
+  // Use the stored hybrid search function (RRF fusion of vector + FTS)
+  const result = await pool.query(`
+    SELECT
+      cf.file_path,
+      cc.content,
+      cc.start_line,
+      cc.end_line,
+      cc.language,
+      cc.symbol_name,
+      cc.symbol_type,
+      h.rrf_score,
+      h.vector_score,
+      h.text_score
+    FROM bonecode_hybrid_search($1, $2::vector, $3, NULL, NULL, $4) h
+    JOIN code_chunks cc ON cc.id = h.chunk_id
+    JOIN code_files cf ON cf.id = cc.code_file_id
+    JOIN knowledge_bases kb ON kb.id = cc.knowledge_base_id
+    WHERE kb.project_id = $5
+    ORDER BY h.rrf_score DESC
+  `, [
+    // knowledge_base_id — find the ready KB for this project
+    await getReadyKBId(project_id),
+    embStr,
+    query,
+    limit,
+    project_id,
+  ]);
+
+  return result.rows.map((row: any) => ({
+    file_path: row.file_path,
+    content: row.content,
+    start_line: Number(row.start_line),
+    end_line: Number(row.end_line),
+    language: row.language,
+    symbol_name: row.symbol_name,
+    symbol_type: row.symbol_type,
+    relevance_score: parseFloat(row.rrf_score) * 1000,
+    source: "hybrid" as const,
+  }));
+}
+
+async function getReadyKBId(project_id: string): Promise<string> {
+  const result = await pool.query(
+    `SELECT id FROM knowledge_bases WHERE project_id = $1 AND state = 'ready' ORDER BY updated_at DESC LIMIT 1`,
+    [project_id]
+  );
+  return result.rows[0]?.id || "";
+}
+
+// ─── Strategy 3: Postgres Full-Text Search ────────────────────────────────────
+// Uses the tsvector index already on code_chunks.content.
+// BM25-ranked via ts_rank — no embedding needed.
+
+async function searchFTS(project_id: string, query: string, limit: number): Promise<ContextChunk[]> {
+  if (!query.trim()) return [];
+
+  // Extract meaningful terms — strip common words, keep identifiers
+  const terms = extractSearchTerms(query);
+  if (terms.length === 0) return [];
+
+  // Sanitize each term: keep only alphanumeric + underscore to prevent tsquery injection.
+  // Each term is passed as a separate $N parameter and assembled server-side via plainto_tsquery
+  // for the rank, and individual prefix-match queries ORed together for the filter.
+  const safeTsQuery = terms
+    .map(t => t.replace(/[^a-z0-9_]/g, ""))
+    .filter(t => t.length >= 2)
+    .map(t => `${t}:*`)
+    .join(" | ");
+
+  if (!safeTsQuery) return [];
+
+  const result = await pool.query(`
+    SELECT
+      cf.file_path,
+      cc.content,
+      cc.start_line,
+      cc.end_line,
+      cc.language,
+      cc.symbol_name,
+      cc.symbol_type,
+      ts_rank(
+        to_tsvector('english', cc.content),
+        to_tsquery('english', $2)
+      ) AS score
+    FROM code_chunks cc
+    JOIN code_files cf ON cf.id = cc.code_file_id
+    JOIN knowledge_bases kb ON kb.id = cc.knowledge_base_id
+    WHERE kb.project_id = $1
+      AND to_tsvector('english', cc.content) @@ to_tsquery('english', $2)
+    ORDER BY score DESC
+    LIMIT $3
+  `, [project_id, safeTsQuery, limit]);
+
+  return result.rows.map((row: any) => ({
+    file_path: row.file_path,
+    content: row.content,
+    start_line: Number(row.start_line),
+    end_line: Number(row.end_line),
+    language: row.language,
+    symbol_name: row.symbol_name,
+    symbol_type: row.symbol_type,
+    relevance_score: parseFloat(row.score) * 100,
+    source: "fts" as const,
+  }));
+}
+
+// ─── Strategy 2: Git Recency ──────────────────────────────────────────────────
+// Files changed in recent commits are more likely to be relevant.
+// Also filters by query terms appearing in the diff.
+
+async function getGitRecentFiles(worktree: string, query: string, limit: number): Promise<ContextChunk[]> {
+  if (!fs.existsSync(path.join(worktree, ".git"))) return [];
+
+  const { execFile } = require("child_process");
+  const { promisify } = require("util");
+  const exec = promisify(execFile);
+
+  // Get files changed in last 20 commits
+  let changedFiles: string[] = [];
+  try {
+    const { stdout } = await exec("git", [
+      "log", "--name-only", "--pretty=format:", "-20", "--diff-filter=AM"
+    ], { cwd: worktree, timeout: 5000 });
+    changedFiles = stdout.split("\n")
+      .map((f: string) => f.trim())
+      .filter((f: string) => f && !f.startsWith("."))
+      .filter((f: string, i: number, arr: string[]) => arr.indexOf(f) === i) // deduplicate
+      .slice(0, 30);
+  } catch {
+    return [];
+  }
+
+  const terms = extractSearchTerms(query);
+  const chunks: ContextChunk[] = [];
+
+  for (const relPath of changedFiles.slice(0, limit * 2)) {
+    const fullPath = path.join(worktree, relPath);
+    if (!fs.existsSync(fullPath)) continue;
+
+    const ext = path.extname(relPath).toLowerCase();
+    const codeExts = new Set([".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java", ".cs", ".cpp", ".c"]);
+    if (!codeExts.has(ext)) continue;
+
+    try {
+      const content = fs.readFileSync(fullPath, "utf-8");
+      const lines = content.split("\n");
+
+      // Score by how many query terms appear in the file
+      const contentLower = content.toLowerCase();
+      const termScore = terms.filter(t => contentLower.includes(t.toLowerCase())).length;
+      if (termScore === 0 && terms.length > 0) continue;
+
+      // Extract the most relevant section (around first term match)
+      const firstMatch = findFirstTermMatch(lines, terms);
+      const startLine = Math.max(0, firstMatch - 10);
+      const endLine = Math.min(lines.length - 1, firstMatch + 40);
+      const snippet = lines.slice(startLine, endLine + 1).join("\n");
+
+      chunks.push({
+        file_path: fullPath,
+        content: snippet,
+        start_line: startLine + 1,
+        end_line: endLine + 1,
+        language: extToLanguage(ext),
+        relevance_score: 30 + termScore * 10,
+        source: "git_recency",
+      });
+
+      if (chunks.length >= limit) break;
+    } catch { continue; }
+  }
+
+  return chunks;
+}
+
+// ─── Strategy 3: Session History ─────────────────────────────────────────────
+// Files the agent has already read/edited in this session are highly relevant.
+
+async function getSessionHistory(session_id: string, worktree: string, limit: number): Promise<ContextChunk[]> {
+  // Look at tool_calls in this session for read_file / edit_file / write_file
+  const result = await pool.query(`
+    SELECT DISTINCT
+      tc.tool_input->>'path' AS file_path,
+      tc.tool_name,
+      tc.created_at
+    FROM tool_calls tc
+    WHERE tc.session_id = $1
+      AND tc.tool_name IN ('read_file', 'edit_file', 'write_file', 'read', 'edit', 'write')
+      AND tc.tool_input->>'path' IS NOT NULL
+      AND tc.state = 'done'
+    ORDER BY tc.created_at DESC
+    LIMIT $2
+  `, [session_id, limit * 2]);
+
+  const chunks: ContextChunk[] = [];
+  const seen = new Set<string>();
+
+  for (const row of result.rows) {
+    let filePath = row.file_path as string;
+    if (!path.isAbsolute(filePath)) filePath = path.join(worktree, filePath);
+    if (seen.has(filePath) || !fs.existsSync(filePath)) continue;
+    seen.add(filePath);
+
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      const lines = content.split("\n");
+      // Take first 60 lines as context (usually the most important part)
+      const snippet = lines.slice(0, 60).join("\n");
+
+      chunks.push({
+        file_path: filePath,
+        content: snippet,
+        start_line: 1,
+        end_line: Math.min(60, lines.length),
+        language: extToLanguage(path.extname(filePath)),
+        relevance_score: 50, // high — agent already touched this file
+        source: "session_history",
+      });
+
+      if (chunks.length >= limit) break;
+    } catch { continue; }
+  }
+
+  return chunks;
+}
+
+// ─── Strategy 4: Import Graph Expansion ──────────────────────────────────────
+// Given a set of relevant files, pull in their direct imports.
+// This ensures the LLM has the types/interfaces/utilities the relevant code depends on.
+
+async function expandImportGraph(
+  worktree: string,
+  seedFiles: string[],
+  seen: Set<string>,
+  limit: number
+): Promise<ContextChunk[]> {
+  const chunks: ContextChunk[] = [];
+  const toExpand = [...seedFiles];
+
+  for (const filePath of toExpand) {
+    if (chunks.length >= limit) break;
+    if (!fs.existsSync(filePath)) continue;
+
+    const imports = extractImports(filePath);
+    for (const importPath of imports) {
+      if (chunks.length >= limit) break;
+
+      const resolved = resolveImport(filePath, importPath, worktree);
+      if (!resolved || seen.has(`${resolved}:1`)) continue;
+
+      try {
+        const content = fs.readFileSync(resolved, "utf-8");
+        const lines = content.split("\n");
+        // For imported files, extract just the exports/public API (first 80 lines usually covers it)
+        const snippet = lines.slice(0, 80).join("\n");
+
+        seen.add(`${resolved}:1`);
+        chunks.push({
+          file_path: resolved,
+          content: snippet,
+          start_line: 1,
+          end_line: Math.min(80, lines.length),
+          language: extToLanguage(path.extname(resolved)),
+          relevance_score: 20, // lower — indirect dependency
+          source: "import_graph",
+        });
+      } catch { continue; }
+    }
+  }
+
+  return chunks;
+}
+
+// ─── Strategy 5: Instruction Files ───────────────────────────────────────────
+// Find AGENTS.md, CLAUDE.md, OPENCODE.md near the worktree root.
+// Same approach as OpenCode's instruction.ts.
+
+async function findInstructionFiles(worktree: string, _query: string): Promise<string[]> {
+  const candidates = ["AGENTS.md", "CLAUDE.md", "OPENCODE.md", ".bonecode/instructions.md", "CONTEXT.md"];
+  const found: string[] = [];
+
+  // Check worktree root and one level down
+  const dirsToCheck = [worktree];
+  try {
+    const entries = fs.readdirSync(worktree, { withFileTypes: true });
+    for (const e of entries) {
+      if (e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules") {
+        dirsToCheck.push(path.join(worktree, e.name));
+      }
+    }
+  } catch {}
+
+  for (const dir of dirsToCheck.slice(0, 5)) {
+    for (const name of candidates) {
+      const p = path.join(dir, name);
+      if (fs.existsSync(p)) {
+        found.push(p);
+        break; // one per directory
+      }
+    }
+  }
+
+  return found;
+}
+
+// ─── Format for LLM ───────────────────────────────────────────────────────────
+
+export function formatContextForPrompt(result: ContextResult, worktree: string): string {
+  if (result.chunks.length === 0 && result.instruction_files.length === 0) return "";
+
+  const parts: string[] = [];
+
+  // Instruction files first (highest priority)
+  for (const instrPath of result.instruction_files) {
+    try {
+      const content = fs.readFileSync(instrPath, "utf-8").trim();
+      if (content) {
+        const rel = path.relative(worktree, instrPath);
+        parts.push(`<!-- Instructions from ${rel} -->\n${content}`);
+      }
+    } catch {}
+  }
+
+  // Code chunks
+  if (result.chunks.length > 0) {
+    parts.push("## Relevant Codebase Context\n");
+    for (let i = 0; i < result.chunks.length; i++) {
+      const c = result.chunks[i];
+      const rel = path.relative(worktree, c.file_path);
+      const header = c.symbol_name
+        ? `[${i + 1}] ${rel}:${c.start_line}-${c.end_line} (${c.symbol_type}: ${c.symbol_name})`
+        : `[${i + 1}] ${rel}:${c.start_line}-${c.end_line}`;
+      parts.push(`${header}\n\`\`\`${c.language || ""}\n${c.content.trim()}\n\`\`\``);
+    }
+  }
+
+  return parts.join("\n\n");
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function extractSearchTerms(query: string): string[] {
+  // Extract meaningful identifiers and terms from the query
+  // Remove common English stop words, keep code identifiers
+  const stopWords = new Set([
+    "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
+    "have", "has", "had", "do", "does", "did", "will", "would", "could",
+    "should", "may", "might", "shall", "can", "need", "dare", "ought",
+    "used", "to", "of", "in", "for", "on", "with", "at", "by", "from",
+    "up", "about", "into", "through", "during", "before", "after",
+    "above", "below", "between", "out", "off", "over", "under",
+    "again", "further", "then", "once", "here", "there", "when",
+    "where", "why", "how", "all", "both", "each", "few", "more",
+    "most", "other", "some", "such", "no", "nor", "not", "only",
+    "own", "same", "so", "than", "too", "very", "just", "but",
+    "and", "or", "if", "as", "it", "its", "this", "that", "these",
+    "those", "i", "me", "my", "we", "our", "you", "your", "he", "she",
+    "him", "her", "they", "them", "what", "which", "who", "whom",
+    "implement", "create", "make", "build", "write", "add", "fix",
+    "update", "change", "modify", "use", "using", "get", "set",
+    "return", "returns", "function", "method", "class", "file",
+    "code", "please", "want", "need", "help", "show", "tell",
+  ]);
+
+  return query
+    .toLowerCase()
+    .replace(/[^\w\s]/g, " ")
+    .split(/\s+/)
+    .filter(t => t.length >= 3 && !stopWords.has(t))
+    .filter((t, i, arr) => arr.indexOf(t) === i) // deduplicate
+    .slice(0, 8); // max 8 terms for FTS query
+}
+
+function findFirstTermMatch(lines: string[], terms: string[]): number {
+  if (terms.length === 0) return 0;
+  for (let i = 0; i < lines.length; i++) {
+    const lower = lines[i].toLowerCase();
+    if (terms.some(t => lower.includes(t))) return i;
+  }
+  return 0;
+}
+
+function extToLanguage(ext: string): string {
+  const map: Record<string, string> = {
+    ".ts": "typescript", ".tsx": "typescript",
+    ".js": "javascript", ".jsx": "javascript", ".mjs": "javascript",
+    ".py": "python", ".go": "go", ".rs": "rust", ".java": "java",
+    ".cs": "csharp", ".cpp": "cpp", ".c": "c", ".rb": "ruby",
+    ".php": "php", ".swift": "swift", ".kt": "kotlin",
+    ".md": "markdown", ".json": "json", ".yaml": "yaml", ".toml": "toml",
+    ".sql": "sql", ".sh": "bash",
+  };
+  return map[ext.toLowerCase()] || "text";
+}
+
+function extractImports(filePath: string): string[] {
+  const ext = path.extname(filePath).toLowerCase();
+  const imports: string[] = [];
+
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+
+    if ([".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(ext)) {
+      // ES imports: import ... from "..."
+      const esImports = content.matchAll(/^import\s+.*?from\s+['"]([^'"]+)['"]/gm);
+      for (const m of esImports) imports.push(m[1]);
+      // require(): const x = require("...")
+      const requires = content.matchAll(/require\s*\(\s*['"]([^'"]+)['"]\s*\)/g);
+      for (const m of requires) imports.push(m[1]);
+    } else if (ext === ".py") {
+      const pyImports = content.matchAll(/^(?:from\s+(\S+)\s+import|import\s+(\S+))/gm);
+      for (const m of pyImports) imports.push((m[1] || m[2]).replace(/\./g, "/"));
+    } else if (ext === ".go") {
+      const goImports = content.matchAll(/"([^"]+)"/g);
+      for (const m of goImports) if (m[1].includes("/")) imports.push(m[1].split("/").slice(-1)[0]);
+    }
+  } catch {}
+
+  // Only keep relative imports (not node_modules)
+  return imports.filter(i => i.startsWith(".") || i.startsWith("/"));
+}
+
+function resolveImport(fromFile: string, importPath: string, worktree: string): string | null {
+  const dir = path.dirname(fromFile);
+  const base = path.isAbsolute(importPath) ? importPath : path.resolve(dir, importPath);
+
+  // Try with various extensions
+  const exts = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.js"];
+  for (const ext of exts) {
+    const candidate = base + ext;
+    if (fs.existsSync(candidate) && candidate.startsWith(worktree)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+function trimToCharBudget(chunks: ContextChunk[], maxChars: number): ContextChunk[] {
+  const result: ContextChunk[] = [];
+  let total = 0;
+  for (const c of chunks) {
+    const size = c.content.length;
+    if (total + size > maxChars && result.length > 0) break;
+    result.push(c);
+    total += size;
+  }
+  return result;
+}

package/src/engine/account/account.sql.ts

@@ -0,0 +1,39 @@
+import { sqliteTable, text, integer, primaryKey } from "drizzle-orm/sqlite-core"
+
+import { type AccessToken, type AccountID, type OrgID, type RefreshToken } from "./schema"
+import { Timestamps } from "../storage/schema.sql"
+
+export const AccountTable = sqliteTable("account", {
+  id: text().$type<AccountID>().primaryKey(),
+  email: text().notNull(),
+  url: text().notNull(),
+  access_token: text().$type<AccessToken>().notNull(),
+  refresh_token: text().$type<RefreshToken>().notNull(),
+  token_expiry: integer(),
+  ...Timestamps,
+})
+
+export const AccountStateTable = sqliteTable("account_state", {
+  id: integer().primaryKey(),
+  active_account_id: text()
+    .$type<AccountID>()
+    .references(() => AccountTable.id, { onDelete: "set null" }),
+  active_org_id: text().$type<OrgID>(),
+})
+
+// LEGACY
+export const ControlAccountTable = sqliteTable(
+  "control_account",
+  {
+    email: text().notNull(),
+    url: text().notNull(),
+    access_token: text().$type<AccessToken>().notNull(),
+    refresh_token: text().$type<RefreshToken>().notNull(),
+    token_expiry: integer(),
+    active: integer({ mode: "boolean" })
+      .notNull()
+      .$default(() => false),
+    ...Timestamps,
+  },
+  (table) => [primaryKey({ columns: [table.email, table.url] })],
+)