bonecode 1.0.0 → 1.1.0

package/src/db_adapter.ts

@@ -0,0 +1,354 @@
+/**
+ * BoneCode Database Adapter
+ *
+ * Provides a unified pool.query() interface that works with either:
+ *   - PostgreSQL (full experience — RAG, pgvector, durable events)
+ *   - SQLite    (zero-setup fallback — sessions and agent turns only, no RAG)
+ *
+ * Detection order:
+ *   1. If DATABASE_URL is set and Postgres is reachable → use Postgres
+ *   2. If Docker is available → offer to auto-start the bonecode-postgres container
+ *   3. Otherwise → fall back to SQLite at ~/.bonecode/bonecode.db
+ *
+ * The SQLite adapter translates the pg Pool.query() interface so all existing
+ * code that calls pool.query(sql, params) works without changes.
+ * Postgres-specific syntax (RETURNING, ON CONFLICT, jsonb, vector) is
+ * translated or stubbed where needed.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+export type DBMode = "postgres" | "sqlite";
+
+let _mode: DBMode | null = null;
+
+export function getDBMode(): DBMode {
+  return _mode || "sqlite";
+}
+
+// ─── SQLite pool shim ─────────────────────────────────────────────────────────
+// Wraps better-sqlite3 in a pg Pool-compatible interface.
+
+function createSQLitePool(dbPath: string) {
+  const Database = require("better-sqlite3");
+  fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+  const db = new Database(dbPath);
+
+  // Enable WAL mode for better concurrent read performance
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+
+  // Translate common Postgres-isms to SQLite
+  function translateSQL(sql: string): string {
+    return sql
+      // $1, $2 → ? placeholders
+      .replace(/\$\d+/g, "?")
+      // RETURNING * / RETURNING id → handled below
+      // NOW() → datetime('now')
+      .replace(/\bNOW\(\)/gi, "datetime('now')")
+      // ILIKE → LIKE (SQLite is case-insensitive for ASCII by default)
+      .replace(/\bILIKE\b/gi, "LIKE")
+      // ::text, ::jsonb, ::vector casts → remove
+      .replace(/::[a-z_[\]()0-9]+/gi, "")
+      // gen_random_uuid() → (not needed — we use uuid() from JS)
+      .replace(/gen_random_uuid\(\)/gi, "lower(hex(randomblob(4)))||'-'||lower(hex(randomblob(2)))||'-4'||substr(lower(hex(randomblob(2))),2)||'-'||substr('89ab',abs(random())%4+1,1)||substr(lower(hex(randomblob(2))),2)||'-'||lower(hex(randomblob(6)))")
+      // JSONB operators → not supported, strip
+      .replace(/->>?\s*'[^']*'/g, "")
+      // json_agg(...) FILTER (...) → NULL (SQLite doesn't support this)
+      .replace(/json_agg\([^)]+\)\s*FILTER\s*\([^)]+\)/gi, "NULL")
+      // to_tsvector / to_tsquery / ts_rank → stub (FTS not available in SQLite fallback)
+      .replace(/to_tsvector\([^)]+\)/gi, "''")
+      .replace(/to_tsquery\([^)]+\)/gi, "''")
+      .replace(/ts_rank\([^)]+\)/gi, "0");
+  }
+
+  const pool = {
+    query: async (sql: string, params?: any[]): Promise<{ rows: any[]; rowCount: number }> => {
+      try {
+        const translated = translateSQL(sql);
+        const flatParams = (params || []).map((p: any) =>
+          typeof p === "object" && p !== null ? JSON.stringify(p) : p
+        );
+
+        // Detect RETURNING clause — SQLite doesn't support it
+        const hasReturning = /\bRETURNING\b/i.test(sql);
+        const returningMatch = sql.match(/RETURNING\s+(.+)$/i);
+
+        // Strip RETURNING from the translated SQL
+        const execSQL = translated.replace(/\s+RETURNING\s+.+$/i, "");
+
+        const isSelect = /^\s*(SELECT|WITH|PRAGMA)/i.test(execSQL);
+
+        if (isSelect) {
+          const stmt = db.prepare(execSQL);
+          const rows = stmt.all(...flatParams);
+          return { rows, rowCount: rows.length };
+        } else {
+          const stmt = db.prepare(execSQL);
+          const info = stmt.run(...flatParams);
+
+          // If RETURNING was requested, fetch the last inserted/updated row
+          if (hasReturning && info.lastInsertRowid) {
+            // Try to get the table name from the SQL
+            const tableMatch = sql.match(/(?:INSERT INTO|UPDATE)\s+(\w+)/i);
+            if (tableMatch) {
+              try {
+                const row = db.prepare(`SELECT * FROM ${tableMatch[1]} WHERE rowid = ?`).get(info.lastInsertRowid);
+                return { rows: row ? [row] : [], rowCount: info.changes };
+              } catch { /* table might not have rowid */ }
+            }
+          }
+
+          return { rows: [], rowCount: info.changes };
+        }
+      } catch (e: any) {
+        // Silently ignore errors for Postgres-specific features not in SQLite
+        if (
+          e.message?.includes("no such function") ||
+          e.message?.includes("no such column") ||
+          e.message?.includes("syntax error")
+        ) {
+          return { rows: [], rowCount: 0 };
+        }
+        throw e;
+      }
+    },
+
+    connect: async () => {
+      // Return a fake client for transaction support
+      return {
+        query: async (sql: string, params?: any[]) => pool.query(sql, params),
+        release: () => {},
+      };
+    },
+
+    end: async () => {
+      db.close();
+    },
+
+    on: (_event: string, _handler: any) => {},
+  };
+
+  return pool;
+}
+
+// ─── SQLite schema ────────────────────────────────────────────────────────────
+// Minimal schema for sessions, messages, parts, projects — enough for the
+// core agent loop without RAG.
+
+const SQLITE_SCHEMA = `
+CREATE TABLE IF NOT EXISTS projects (
+  id TEXT PRIMARY KEY,
+  root_commit_hash TEXT,
+  worktree TEXT,
+  vcs TEXT DEFAULT 'git',
+  name TEXT,
+  sandboxes TEXT DEFAULT '[]',
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  slug TEXT,
+  project_id TEXT,
+  parent_id TEXT,
+  directory TEXT,
+  title TEXT,
+  version TEXT DEFAULT '1.0.0',
+  state TEXT DEFAULT 'created',
+  summary_files INTEGER,
+  summary_additions INTEGER,
+  summary_deletions INTEGER,
+  share_url TEXT,
+  workspace_id TEXT,
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+  id TEXT PRIMARY KEY,
+  session_id TEXT,
+  role TEXT,
+  model_id TEXT,
+  provider_id TEXT,
+  tokens_input INTEGER DEFAULT 0,
+  tokens_output INTEGER DEFAULT 0,
+  cost_usd REAL DEFAULT 0,
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS parts (
+  id TEXT PRIMARY KEY,
+  message_id TEXT,
+  session_id TEXT,
+  part_type TEXT,
+  data TEXT DEFAULT '{}',
+  order_index INTEGER DEFAULT 0,
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS agent_instances (
+  id TEXT PRIMARY KEY,
+  session_id TEXT,
+  model_id TEXT,
+  provider_id TEXT,
+  context_window_used INTEGER DEFAULT 0,
+  context_window_max INTEGER DEFAULT 200000,
+  total_cost_usd REAL DEFAULT 0,
+  total_tokens_in INTEGER DEFAULT 0,
+  total_tokens_out INTEGER DEFAULT 0,
+  config TEXT DEFAULT '{}',
+  state TEXT DEFAULT 'running',
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS tool_calls (
+  id TEXT PRIMARY KEY,
+  session_id TEXT,
+  agent_id TEXT,
+  tool_name TEXT,
+  tool_input TEXT DEFAULT '{}',
+  tool_output TEXT,
+  state TEXT DEFAULT 'running',
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS permissions (
+  id TEXT PRIMARY KEY,
+  session_id TEXT,
+  tool_name TEXT,
+  decision TEXT,
+  created_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+CREATE INDEX IF NOT EXISTS idx_parts_message ON parts(message_id);
+CREATE INDEX IF NOT EXISTS idx_parts_session ON parts(session_id);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_session ON tool_calls(session_id);
+`;
+
+// ─── Postgres availability check ──────────────────────────────────────────────
+
+async function checkPostgres(url: string): Promise<boolean> {
+  try {
+    const { Pool } = require("pg");
+    const testPool = new Pool({ connectionString: url, connectionTimeoutMillis: 3000, max: 1 });
+    await testPool.query("SELECT 1");
+    await testPool.end();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ─── Auto-start Docker container ─────────────────────────────────────────────
+
+async function tryStartDockerPostgres(): Promise<boolean> {
+  try {
+    const { execSync } = require("child_process");
+    // Check if docker is available
+    execSync("docker --version", { stdio: "ignore" });
+
+    // Check if container already exists
+    try {
+      const status = execSync(
+        "docker inspect --format={{.State.Running}} bonecode-postgres",
+        { stdio: "pipe" }
+      ).toString().trim();
+      if (status === "true") return true; // already running
+      // Exists but stopped — start it
+      execSync("docker start bonecode-postgres", { stdio: "ignore" });
+      await new Promise(r => setTimeout(r, 2000));
+      return true;
+    } catch {
+      // Container doesn't exist — create it
+      execSync(
+        "docker run -d --name bonecode-postgres -e POSTGRES_DB=bonecode -e POSTGRES_USER=postgres -e POSTGRES_PASSWORD=postgres -p 5434:5432 pgvector/pgvector:pg16",
+        { stdio: "ignore" }
+      );
+      // Wait for Postgres to be ready
+      for (let i = 0; i < 15; i++) {
+        await new Promise(r => setTimeout(r, 1000));
+        if (await checkPostgres("postgresql://postgres:postgres@localhost:5434/bonecode")) {
+          return true;
+        }
+      }
+      return false;
+    }
+  } catch {
+    return false; // Docker not available
+  }
+}
+
+// ─── Main init ────────────────────────────────────────────────────────────────
+
+export async function initDatabase(silent = false): Promise<{
+  pool: any;
+  mode: DBMode;
+  pgAvailable: boolean;
+}> {
+  const log = (msg: string) => { if (!silent) process.stdout.write(msg + "\n"); };
+
+  // 1. Try configured DATABASE_URL
+  const dbUrl = process.env.DATABASE_URL;
+  if (dbUrl && !dbUrl.startsWith("sqlite")) {
+    if (await checkPostgres(dbUrl)) {
+      _mode = "postgres";
+      const { Pool } = require("pg");
+      const pgPool = new Pool({ connectionString: dbUrl, max: 20 });
+      pgPool.on("error", (err: Error) => {
+        if (process.env.NODE_ENV !== "test") {
+          process.stderr.write(`[DB] Pool error: ${err.message}\n`);
+        }
+      });
+      return { pool: pgPool, mode: "postgres", pgAvailable: true };
+    }
+    log(`\x1b[33m[BoneCode] Postgres not reachable at ${dbUrl.replace(/:[^:@]+@/, ":***@")} — trying Docker...\x1b[0m`);
+  }
+
+  // 2. Try auto-starting Docker
+  const dockerStarted = await tryStartDockerPostgres();
+  if (dockerStarted) {
+    // Use port 5434 (our standard bonecode-postgres container)
+    const dockerUrl = "postgresql://postgres:postgres@localhost:5434/bonecode";
+    if (await checkPostgres(dockerUrl)) {
+      process.env.DATABASE_URL = dockerUrl;
+      _mode = "postgres";
+      const { Pool } = require("pg");
+      const pgPool = new Pool({ connectionString: dockerUrl, max: 20 });
+      pgPool.on("error", (err: Error) => {
+        if (process.env.NODE_ENV !== "test") {
+          process.stderr.write(`[DB] Pool error: ${err.message}\n`);
+        }
+      });
+      log(`\x1b[32m[BoneCode] PostgreSQL ready (Docker) — full RAG enabled\x1b[0m`);
+      return { pool: pgPool, mode: "postgres", pgAvailable: true };
+    }
+  }
+
+  // 3. Fall back to SQLite
+  const dbDir = path.join(os.homedir(), ".bonecode");
+  const dbPath = path.join(dbDir, "bonecode.db");
+  _mode = "sqlite";
+
+  log(`\x1b[33m[BoneCode] Using SQLite (${dbPath})\x1b[0m`);
+  log(`\x1b[2m  For full RAG support, install Docker: https://docs.docker.com/get-docker/\x1b[0m`);
+
+  const sqlitePool = createSQLitePool(dbPath);
+
+  // Run schema
+  const Database = require("better-sqlite3");
+  const db = new Database(dbPath);
+  db.exec(SQLITE_SCHEMA);
+  db.close();
+
+  return { pool: sqlitePool, mode: "sqlite", pgAvailable: false };
+}

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

@@ -1,39 +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] })],
-)
+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] })],
+)