@erichll/pi-auto-review 0.22.0 → 0.22.1

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.22.1 - 2026-10-01
+
+- Fix permission-policy auditing being disabled on Bun with
+  `No such built-in module: node:sqlite`. Bun, including Bun-compiled Pi, now
+  uses its built-in `bun:sqlite`; Node continues to use `node:sqlite`.
+- Preserve audit statistics and request deduplication when switching between
+  Node and Bun by sharing the existing database schema and HMAC key.
+- Finalize Bun's cached SQLite statements when closing the database so the
+  last WAL connection can checkpoint and release its resources.
+- Add regression coverage for database migration, redaction, retention,
+  failure handling, concurrent Node/Bun writers, and persistent audit reports
+  in a real Bun-compiled Pi process.
+- Update the permission-system example for current MCP tool names, including
+  `codemode`, `tool_search`, `mcp__atlassian__*`, and `mcp__pencil__*`.
+
 ## 0.22.0 - 2026-09-30
 
 - Raise the `@earendil-works/pi-ai` and `@earendil-works/pi-coding-agent` peer

package/README.md

@@ -34,9 +34,10 @@ that dependency is a hard prerequisite (see [Install and enable](#install-and-en
 > extension. This release line requires Pi 0.99.1 or later and supports
 > permission-system 36.0.0 and later:
 
-Node.js 22.13.0 or newer is required. Permission auditing uses Node's built-in
-`node:sqlite`; it does not require a SQLite CLI, system SQLite library, or npm
-SQLite package.
+Node-based Pi requires Node.js 22.13.0 or newer. Permission auditing uses the
+host runtime's built-in SQLite: `node:sqlite` on Node and `bun:sqlite` on Bun,
+including Bun-compiled Pi (verified with Bun 1.3.14). It does not require a
+SQLite CLI, system SQLite library, or npm SQLite package.
 
 ```bash
 pi install npm:@gotgenes/pi-permission-system
@@ -374,7 +375,9 @@ project-specific labels; inspect suggestions before copying them.
 
 Data lives at
 `~/.pi/agent/extensions/pi-auto-review/policy-audit.sqlite`, beside an
-owner-only HMAC key. The directory is mode `0700`; the key, database, WAL, and
+owner-only HMAC key. Node and Bun use the same database schema and key, so
+switching runtimes preserves statistics and request deduplication.
+The directory is mode `0700`; the key, database, WAL, and
 SHM are mode `0600`. Initialization, lock, write, or corruption failures disable
 auditing and warn once without changing any permission result. A corrupt
 database is not deleted or rebuilt automatically. Disable new collection with:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@erichll/pi-auto-review",
-  "version": "0.22.0",
+  "version": "0.22.1",
   "description": "Fail-closed, model-backed approval broker for Pi: deterministically hard-denies dangerous operations, reviews dangerous boundaries with a reviewer model, and issues one-shot expiring grants that OS sandbox adapters must consume before retrying.",
   "type": "module",
   "license": "MIT",

package/src/policy-audit/sqlite.ts

@@ -0,0 +1,55 @@
+type Statement = {
+  run(...params: unknown[]): { changes: number | bigint };
+  // Node returns undefined for a missing row; Bun returns null.
+  get(...params: unknown[]): Record<string, unknown> | null | undefined;
+  all(...params: unknown[]): Record<string, unknown>[];
+};
+
+export type SqliteDatabase = {
+  exec(sql: string): void;
+  prepare(sql: string): Statement;
+  close(): void;
+};
+
+export type SqliteModule = {
+  DatabaseSync: new (path: string, options?: Record<string, unknown>) => SqliteDatabase;
+};
+
+type BunDatabase = Omit<SqliteDatabase, "prepare"> & {
+  query(sql: string): Statement;
+};
+
+/** Load the host's built-in SQLite lazily, including inside Bun-compiled Pi. */
+export async function loadSqlite(): Promise<SqliteModule> {
+  if (process.versions.bun) {
+    // A runtime specifier avoids requiring Bun's ambient types in Node builds.
+    const specifier = "bun:sqlite";
+    const sqlite = await import(specifier) as {
+      Database: new (path: string, options?: Record<string, unknown>) => BunDatabase;
+    };
+    return {
+      DatabaseSync: class implements SqliteDatabase {
+        private readonly database: BunDatabase;
+
+        constructor(path: string, options?: Record<string, unknown>) {
+          this.database = new sqlite.Database(path, options);
+        }
+
+        exec(sql: string): void {
+          this.database.exec(sql);
+        }
+
+        prepare(sql: string): Statement {
+          // Bun finalizes cached queries on close. Uncached prepare() statements
+          // can outlive the connection, retaining locks and delaying checkpoints.
+          return this.database.query(sql);
+        }
+
+        close(): void {
+          this.database.close();
+        }
+      },
+    };
+  }
+  return import("node:sqlite") as Promise<SqliteModule>;
+}

package/src/policy-audit/store.ts

@@ -11,24 +11,12 @@ import {
 } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import type { ClassifiedPermission } from "./classifier.ts";
+import { loadSqlite, type SqliteDatabase, type SqliteModule } from "./sqlite.ts";
 
 export const POLICY_AUDIT_SCHEMA_VERSION = 2;
 export const POLICY_AUDIT_DATABASE_NAME = "policy-audit.sqlite";
 export const POLICY_AUDIT_KEY_NAME = "policy-audit.key";
 
-type RunResult = { changes: number | bigint };
-type Statement = {
-  run(...params: unknown[]): RunResult;
-  get(...params: unknown[]): Record<string, unknown> | undefined;
-  all(...params: unknown[]): Record<string, unknown>[];
-};
-type Database = {
-  exec(sql: string): void;
-  prepare(sql: string): Statement;
-  close(): void;
-};
-type SqliteModule = { DatabaseSync: new (path: string, options?: Record<string, unknown>) => Database };
-
 export type SanitizedPermissionDecision = ClassifiedPermission & {
   requestId: string;
   result: "allow" | "deny";
@@ -124,7 +112,7 @@ export class PolicyAuditStore {
     mkdirSync(options.directory, { recursive: true, mode: 0o700 });
     chmodSync(options.directory, 0o700);
     const key = loadOrCreateKey(options.directory);
-    const sqlite = await (options.sqliteLoader ?? (() => import("node:sqlite") as Promise<SqliteModule>))();
+    const sqlite = await (options.sqliteLoader ?? loadSqlite)();
     const databasePath = join(options.directory, POLICY_AUDIT_DATABASE_NAME);
     const db = new sqlite.DatabaseSync(databasePath);
     chmodSync(databasePath, 0o600);
@@ -139,7 +127,7 @@ export class PolicyAuditStore {
   }
 
   private constructor(
-    private readonly db: Database,
+    private readonly db: SqliteDatabase,
     private readonly key: Buffer,
     private readonly databasePath: string,
     private readonly retentionDays: number,