pi-warden 0.74.0 → 0.74.1

package/CHANGELOG.md

@@ -8,6 +8,12 @@ How to keep this current: add the entry in the same pull request as the change,
 
 <!-- Empty. Next release starts here. -->
 
+## 0.74.1
+
+### Fixed
+
+- Learning features work when Pi runs on Bun. Pi's release binaries (`pi-linux-x64.tar.gz` and the rest) are Bun `--compile` executables in which `import("node:sqlite")` fails with `No such built-in module: node:sqlite`, so `holds.db` never opened and learning was off for every release-binary user. `node:sqlite` is still tried first and is unchanged; only when that import fails and the process runs on Bun does `src/sqlite-adapter.ts` open the database through `bun:sqlite` behind the `DatabaseSync` subset learning uses. With neither module loading, learning stays off behind one warning that now names both modules.
+
 ## 0.74.0
 
 ### Added

package/dist/learning.d.ts

@@ -1,6 +1,9 @@
+import type { SqliteDriver } from "./sqlite-adapter.js";
 import type { HostDirs } from "./host-dirs.js";
 import type { CallScores } from "./holds.js";
 export declare const HOLDS_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS holds (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    timestamp INTEGER NOT NULL,\n    project_root TEXT NOT NULL,\n    tool TEXT NOT NULL,\n    signature_hash TEXT NOT NULL,\n    command_preview TEXT,\n    task TEXT,\n    plan TEXT,\n    context_summary TEXT,\n    preceding_actions TEXT,\n    scores TEXT NOT NULL,\n    level TEXT NOT NULL,\n    held INTEGER NOT NULL,\n    reasons TEXT,\n    agent_reason TEXT,\n    outcome TEXT,\n    outcome_at INTEGER,\n    confidence REAL\n  );\n  CREATE INDEX IF NOT EXISTS idx_holds_project_signature ON holds(project_root, signature_hash);\n  CREATE INDEX IF NOT EXISTS idx_holds_outcome ON holds(outcome);\n  CREATE INDEX IF NOT EXISTS idx_holds_timestamp ON holds(timestamp);\n";
+/** Which module opened the learning database: "node:sqlite", "bun:sqlite", or undefined while learning is off. */
+export declare function sqliteDriver(): SqliteDriver | undefined;
 export declare function initSchema(retentionDays?: number, dirs?: HostDirs): Promise<void>;
 export interface HoldScores {
     irreversible: number;

package/dist/learning.js

@@ -3,11 +3,14 @@
 import { createHash } from "crypto";
 import { mkdirSync } from "fs";
 import { dirname, join } from "path";
+import { isBunRuntime, openBunSqlite, SqliteUnavailableError } from "./sqlite-adapter.js";
 import { defaultHostDirs } from "./host-dirs.js";
 import { userConfigPath } from "./config.js";
 import { redact } from "./redact.js";
 const dbs = new Map();
 let sqliteAvailable;
+/** Which module opened the learning database; undefined while learning is off. */
+let driver;
 // --- Schema (shared constant) ---
 export const HOLDS_SCHEMA = `
   CREATE TABLE IF NOT EXISTS holds (
@@ -39,6 +42,33 @@ const NOOP_DB = {
     prepare() { return { run() { return { changes: 0, lastInsertRowid: 0 }; }, get() { return undefined; }, all() { return []; } }; },
     pragma() { },
 };
+/** Learning stays off: one warning names both candidate modules so the report says what to look at. */
+function disableLearning(detail) {
+    sqliteAvailable = false;
+    console.warn("pi-warden: node:sqlite unavailable, bun:sqlite unavailable, learning features disabled:", detail);
+    return NOOP_DB;
+}
+/** Pi's release binaries are Bun --compile executables, where node:sqlite may not be a built-in
+ *  module while bun:sqlite always is. On Bun the database opens through the adapter; with neither
+ *  module loading, learning stays off behind one warning. */
+async function openBunFallback(dbPath, nodeFailure) {
+    if (!isBunRuntime())
+        return disableLearning(nodeFailure);
+    try {
+        const db = await openBunSqlite(dbPath);
+        sqliteAvailable = true;
+        driver = "bun:sqlite";
+        return db;
+    }
+    catch (err) {
+        if (err instanceof SqliteUnavailableError)
+            return disableLearning(err);
+        // bun:sqlite did load (this is Bun), so only this path failed, as on the node:sqlite path.
+        sqliteAvailable = true;
+        console.warn(`pi-warden: could not open ${dbPath}:`, err);
+        return NOOP_DB;
+    }
+}
 /** Open one connection; a failure is remembered per path so later calls neither warn again nor retry forever. */
 async function openDb(dbPath) {
     let opened;
@@ -46,11 +76,8 @@ async function openDb(dbPath) {
         // Static import cannot work: node:sqlite is flagged experimental and loads lazily so a missing
         // or broken build of it disables learning features instead of failing the whole process.
         const sqlite = await import("node:sqlite").catch(err => ({ importFailed: err }));
-        if ("importFailed" in sqlite) {
-            sqliteAvailable = false;
-            console.warn("pi-warden: node:sqlite unavailable, learning features disabled:", sqlite.importFailed);
-            return NOOP_DB;
-        }
+        if ("importFailed" in sqlite)
+            return await openBunFallback(dbPath, sqlite.importFailed);
         const { DatabaseSync } = sqlite;
         sqliteAvailable = true;
         // DatabaseSync does not create parent directories; on a fresh machine the folder may not exist yet.
@@ -58,6 +85,7 @@ async function openDb(dbPath) {
         opened = new DatabaseSync(dbPath);
         opened.exec("PRAGMA journal_mode = WAL");
         opened.exec("PRAGMA busy_timeout = 10000");
+        driver = "node:sqlite";
         return opened;
     }
     catch (err) {
@@ -82,6 +110,10 @@ async function getDb(dirs = defaultHostDirs()) {
         dbs.set(dbPath, opening = openDb(dbPath));
     return opening;
 }
+/** Which module opened the learning database: "node:sqlite", "bun:sqlite", or undefined while learning is off. */
+export function sqliteDriver() {
+    return driver;
+}
 export async function initSchema(retentionDays = 365, dirs = defaultHostDirs()) {
     try {
         const d = await getDb(dirs);

package/dist/sqlite-adapter.d.ts

@@ -0,0 +1,48 @@
+/** The driver that opened the learning database. */
+export type SqliteDriver = "node:sqlite" | "bun:sqlite";
+/** Bindable values. Learning binds only positional `?` placeholders, never named keys, so the
+ *  named-parameter prefixes never meet: Bun's default (non-strict) mode already accepts both a
+ *  bare `name` and a `$name` key, and the adapter does not open in strict mode. */
+export type SqliteValue = null | number | bigint | string | ArrayBufferView;
+export type SqliteRow = Record<string, unknown>;
+export interface SqliteRunResult {
+    changes: number | bigint;
+    lastInsertRowid: number | bigint;
+}
+export interface SqliteStatement {
+    run(...params: SqliteValue[]): SqliteRunResult;
+    get(...params: SqliteValue[]): SqliteRow | undefined;
+    all(...params: SqliteValue[]): SqliteRow[];
+}
+/** The DatabaseSync subset learning uses: schema and PRAGMAs through exec, rows through prepare. */
+export interface SqliteDb {
+    exec(sql: string): void;
+    prepare(sql: string): SqliteStatement;
+    close(): void;
+}
+/** bun:sqlite's statement shape, as the adapter reads it. */
+export interface BunSqliteStatement {
+    run(...params: unknown[]): SqliteRunResult;
+    get(...params: unknown[]): SqliteRow | null;
+    all(...params: unknown[]): SqliteRow[];
+}
+/** bun:sqlite's handle shape, as the adapter reads it. */
+export interface BunSqliteHandle {
+    exec(sql: string): unknown;
+    prepare(sql: string): BunSqliteStatement;
+    close(): void;
+}
+/** bun:sqlite could not be loaded. The caller reports "neither module" and learning stays off. */
+export declare class SqliteUnavailableError extends Error {
+    constructor(moduleName: string, cause: unknown);
+}
+/** True when this process is Bun, the only runtime where bun:sqlite can be loaded. */
+export declare function isBunRuntime(): boolean;
+/**
+ * Open the learning database through bun:sqlite. Throws SqliteUnavailableError when the module
+ * does not load; any other error is a path open or PRAGMA failure for this path only, and the
+ * half-open handle is closed first, as the node:sqlite path does.
+ */
+export declare function openBunSqlite(dbPath: string): Promise<SqliteDb>;
+/** Present a bun:sqlite handle as the DatabaseSync subset learning uses. */
+export declare function wrapBunDatabase(db: BunSqliteHandle): SqliteDb;

package/dist/sqlite-adapter.js

@@ -0,0 +1,68 @@
+// src/sqlite-adapter.ts - bun:sqlite fallback for the learning database
+//
+// node:sqlite stays the first choice and is not touched here. Pi's release binaries are Bun
+// --compile executables in which node:sqlite may not be a built-in module, so learning needs a
+// second way in: bun:sqlite, wrapped to answer like the DatabaseSync subset learning calls. One
+// module owns the difference, so src/learning.ts keeps a single code path for both drivers.
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+/** bun:sqlite could not be loaded. The caller reports "neither module" and learning stays off. */
+export class SqliteUnavailableError extends Error {
+    constructor(moduleName, cause) {
+        super(`${moduleName} could not be loaded`, { cause });
+    }
+}
+/** True when this process is Bun, the only runtime where bun:sqlite can be loaded. */
+export function isBunRuntime() {
+    return typeof process.versions.bun === "string" || typeof globalThis.Bun !== "undefined";
+}
+/**
+ * Open the learning database through bun:sqlite. Throws SqliteUnavailableError when the module
+ * does not load; any other error is a path open or PRAGMA failure for this path only, and the
+ * half-open handle is closed first, as the node:sqlite path does.
+ */
+export async function openBunSqlite(dbPath) {
+    let bunSqlite;
+    try {
+        bunSqlite = await import("bun:sqlite");
+    }
+    catch (err) {
+        throw new SqliteUnavailableError("bun:sqlite", err);
+    }
+    // bun:sqlite does not create parent directories either; on a fresh machine the folder is missing.
+    mkdirSync(dirname(dbPath), { recursive: true, mode: 0o700 });
+    const db = wrapBunDatabase(new bunSqlite.Database(dbPath));
+    try {
+        db.exec("PRAGMA journal_mode = WAL");
+        db.exec("PRAGMA busy_timeout = 10000");
+    }
+    catch (err) {
+        try {
+            db.close();
+        }
+        catch { /* already closed */ }
+        throw err;
+    }
+    return db;
+}
+/** Present a bun:sqlite handle as the DatabaseSync subset learning uses. */
+export function wrapBunDatabase(db) {
+    return {
+        exec(sql) {
+            db.exec(sql);
+        },
+        prepare(sql) {
+            const stmt = db.prepare(sql);
+            return {
+                run: (...params) => stmt.run(...params),
+                // Bun answers a miss with null where node:sqlite answers undefined. Learning reads no row
+                // as undefined, so the adapter hands back the node answer.
+                get: (...params) => stmt.get(...params) ?? undefined,
+                all: (...params) => stmt.all(...params),
+            };
+        },
+        close() {
+            db.close();
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-warden",
-  "version": "0.74.0",
+  "version": "0.74.1",
   "description": "Makes the Pi agent follow your project's rules. Jev judges every write against your pi-warden.md and quotes the broken rule back to the agent, names slop, breaks stuck loops, calls out unverified done claims, compresses large tool output, and holds the rare destructive command. Built on pi-typesafe.",
   "type": "module",
   "license": "MIT",
@@ -54,6 +54,7 @@
     "build": "tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
     "test": "node --import tsx --test tests/*.test.ts",
+    "test:bun": "bun test tests/sqlite-adapter.test.ts tests/learning.test.ts",
     "test:live": "node --env-file-if-exists=.env scripts/live-smoke.mjs",
     "dev:pi": "node scripts/dev-pi.mjs",
     "preview": "node scripts/render-preview.mjs",