vgxness 1.1.0 → 1.1.1

package/README.md

@@ -58,7 +58,7 @@ npm run probe:bun
 npm run probe:bun -- --yes   # mutates dependencies only after explicit consent
 ```
 
-Runtime SQLite readiness is proven with `bun:sqlite`. `bun run verify:bun-sqlite` copies the source migrations into a temporary directory, applies them against a temporary database, checks foreign keys, busy timeout, FTS/search, transaction rollback, integrity, and cleanup. `bun run verify:node-sqlite` remains optional Node native-binding tooling coverage only.
+Runtime SQLite readiness is proven only with `bun:sqlite`. `bun run verify:bun-sqlite` copies the source migrations into a temporary directory, applies them against a temporary database, checks foreign keys, busy timeout, FTS/search, transaction rollback, integrity, and cleanup. Node.js remains development/build/test tooling, but real local SQLite storage is supported through the Bun runtime path.
 
 #### Bun package evidence
 

package/dist/mcp/doctor.js

@@ -66,7 +66,7 @@ async function runRealMcpSmoke(options) {
     const client = new Client({ name: 'vgxness-doctor', version: '0.1.0' }, { capabilities: {} });
     const invocation = resolveDoctorCliInvocation(options.databasePath);
     const transport = new StdioClientTransport({
-        command: process.execPath,
+        command: invocation.command,
         args: invocation.args,
         cwd: options.cwd,
         stderr: 'pipe',
@@ -173,11 +173,17 @@ function parseMcpToolResult(result) {
         return { ok: false, error: { code: 'validation_failed', message: 'MCP response did not contain text JSON' } };
     return JSON.parse(text);
 }
-export function resolveDoctorCliInvocation(databasePath, moduleUrl = import.meta.url) {
+export function resolveDoctorCliInvocation(databasePath, moduleUrl = import.meta.url, options = {}) {
+    const runtime = options.runtime ?? currentRuntime();
     const builtCliPath = fileURLToPath(new URL('../cli/index.js', moduleUrl));
     if (existsSync(builtCliPath))
-        return { args: [builtCliPath, 'mcp', 'start', '--db', databasePath] };
-    return { args: ['--import', import.meta.resolve('tsx'), cliSourcePath(moduleUrl), 'mcp', 'start', '--db', databasePath] };
+        return { command: process.execPath, args: [builtCliPath, 'mcp', 'start', '--db', databasePath] };
+    if (runtime === 'bun')
+        return { command: process.execPath, args: [cliSourcePath(moduleUrl), 'mcp', 'start', '--db', databasePath] };
+    return { command: process.execPath, args: ['--import', import.meta.resolve('tsx'), cliSourcePath(moduleUrl), 'mcp', 'start', '--db', databasePath] };
+}
+function currentRuntime() {
+    return typeof globalThis.Bun === 'undefined' ? 'node' : 'bun';
 }
 function cliSourcePath(moduleUrl) {
     return fileURLToPath(new URL('../cli/index.ts', moduleUrl));

package/dist/memory/sqlite/database.js

@@ -1,17 +1,10 @@
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 const migrationsDirectory = join(dirname(fileURLToPath(import.meta.url)), 'migrations');
 export const sqliteBusyTimeoutMs = 5000;
-const nativeBindingDiagnosticGuidance = 'Detected a likely better-sqlite3 native binding problem. Ensure npm install scripts are enabled, then rebuild or reinstall dependencies for the active Node.js version (for example: npm rebuild better-sqlite3 --ignore-scripts=false).';
-const nativeBindingFailurePatterns = [
-    /better_sqlite3\.node/i,
-    /better-sqlite3/i,
-    /NODE_MODULE_VERSION/i,
-    /ERR_DLOPEN_FAILED/i,
-    /Could not locate the bindings file/i,
-    /compiled against a different Node\.js version/i,
-];
+const bunRequiredGuidance = 'Real local SQLite storage requires Bun. Use the installed Bun-backed vgxness/vgx runtime, or run Bun storage verification with bun run verify:bun-sqlite.';
 export class MemoryDatabase {
     connection;
     constructor(connection) {
@@ -99,39 +92,37 @@ export function openMemoryDatabase(options) {
 }
 export function buildMemoryStoreUnavailableMessage(path, cause) {
     const message = `Unable to open local memory store at ${path}`;
-    if (!isLikelyBetterSqlite3NativeBindingFailure(cause))
+    if (!isUnsupportedSqliteRuntimeError(cause))
         return message;
-    return `${message}. ${nativeBindingDiagnosticGuidance}`;
+    return `${message}. ${bunRequiredGuidance}`;
 }
-export function isLikelyBetterSqlite3NativeBindingFailure(cause) {
-    const values = collectDiagnosticValues(cause);
-    return values.some((value) => nativeBindingFailurePatterns.some((pattern) => pattern.test(value)));
-}
-const sqliteDriver = await resolveSqliteDriver();
 function openSqliteConnection(options) {
-    return sqliteDriver(options);
+    return resolveSqliteDriver()(options);
 }
-async function resolveSqliteDriver() {
+function resolveSqliteDriver() {
     if (isBunRuntime())
         return resolveBunSqliteDriver();
-    return resolveBetterSqlite3Driver();
+    throw createUnsupportedSqliteRuntimeError();
 }
 function isBunRuntime() {
     return typeof globalThis.Bun !== 'undefined';
 }
-async function resolveBetterSqlite3Driver() {
-    const module = await import('better-sqlite3');
-    const BetterSqlite3Database = module.default;
-    return (options) => new BetterSqlite3Database(options.path, { readonly: options.readonly ?? false });
-}
-async function resolveBunSqliteDriver() {
-    const bunSqliteSpecifier = 'bun:sqlite';
-    const module = (await import(bunSqliteSpecifier));
+function resolveBunSqliteDriver() {
+    const require = createRequire(import.meta.url);
+    const module = require('bun:sqlite');
     const BunDatabase = module.Database;
     if (typeof BunDatabase !== 'function')
         throw new Error('bun:sqlite Database constructor is unavailable');
     return (options) => createBunSqliteConnection(new BunDatabase(options.path, { readonly: options.readonly ?? false, strict: true }));
 }
+function createUnsupportedSqliteRuntimeError() {
+    const error = new Error(bunRequiredGuidance);
+    error.name = 'UnsupportedSqliteRuntimeError';
+    return error;
+}
+function isUnsupportedSqliteRuntimeError(cause) {
+    return cause instanceof Error && cause.name === 'UnsupportedSqliteRuntimeError';
+}
 function createBunSqliteConnection(database) {
     const record = database;
     return {
@@ -139,7 +130,7 @@ function createBunSqliteConnection(database) {
             const prepare = record.prepare;
             if (typeof prepare !== 'function')
                 throw new Error('bun:sqlite prepare() is unavailable');
-            return prepare.call(database, sql);
+            return createBunSqliteStatement(prepare.call(database, sql));
         },
         exec(sql) {
             const exec = record.exec;
@@ -174,6 +165,30 @@ function createBunSqliteConnection(database) {
         },
     };
 }
+function createBunSqliteStatement(statement) {
+    const record = statement;
+    return {
+        get(...params) {
+            const get = record.get;
+            if (typeof get !== 'function')
+                throw new Error('bun:sqlite statement.get() is unavailable');
+            const row = get.call(statement, ...params);
+            return row === null ? undefined : row;
+        },
+        all(...params) {
+            const all = record.all;
+            if (typeof all !== 'function')
+                throw new Error('bun:sqlite statement.all() is unavailable');
+            return all.call(statement, ...params);
+        },
+        run(...params) {
+            const run = record.run;
+            if (typeof run !== 'function')
+                throw new Error('bun:sqlite statement.run() is unavailable');
+            return run.call(statement, ...params);
+        },
+    };
+}
 function runBunPragma(database, statement) {
     const normalizedStatement = statement.trim();
     if (isPragmaSetter(normalizedStatement)) {
@@ -211,26 +226,3 @@ function migrationFailure(message, cause) {
         error.cause = cause;
     return { ok: false, error };
 }
-function collectDiagnosticValues(value, seen = new Set()) {
-    if (value === undefined || value === null)
-        return [];
-    if (typeof value === 'string')
-        return [value];
-    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint' || typeof value === 'symbol')
-        return [String(value)];
-    if (typeof value !== 'object')
-        return [];
-    if (seen.has(value))
-        return [];
-    seen.add(value);
-    const diagnosticValues = [];
-    const record = value;
-    for (const key of ['code', 'message', 'stack', 'name']) {
-        const property = record[key];
-        if (property !== undefined)
-            diagnosticValues.push(...collectDiagnosticValues(property, seen));
-    }
-    if (record.cause !== undefined)
-        diagnosticValues.push(...collectDiagnosticValues(record.cause, seen));
-    return diagnosticValues;
-}

package/docs/cli.md

@@ -77,12 +77,13 @@ bun install --frozen-lockfile
 bun run check:bun-lock
 bun run verify:typecheck
 bun run verify:test
+bun run verify:test:bun-storage
 bun run verify:bun-sqlite
 bun run verify:package
 bun run package:bun:evidence -- --require-pass
 ```
 
-`bun run verify:bun-sqlite` is the SQLite runtime release gate. It uses `bun:sqlite` against a temporary database, copies/applies the source migrations, and checks foreign keys, busy timeout, FTS/search, transaction rollback, integrity, and cleanup. `bun run verify:node-sqlite` is optional Node native-binding tooling coverage only.
+`bun run verify:bun-sqlite` is the SQLite runtime release gate. It uses `bun:sqlite` against a temporary database, copies/applies the source migrations, and checks foreign keys, busy timeout, FTS/search, transaction rollback, integrity, and cleanup. `bun run verify:test:bun-storage` covers storage-backed tests under Bun. Node.js remains development/build/test tooling, but real local SQLite storage is supported through the Bun runtime path.
 
 Keep lockfile changes intentional: when `package.json` dependency specifiers change, refresh and review the root `bun.lock` diff. The read-only drift check does not run `bun install` and does not mutate `node_modules`:
 

package/docs/funcionamiento-del-sistema.md

@@ -43,13 +43,12 @@ Esa capa no reemplaza a OpenCode, Claude Code o futuros adapters. Los coordina.
 
 ## Como esta construido
 
-El proyecto esta escrito en TypeScript y corre sobre Node.js 22 o superior.
+El proyecto esta escrito en TypeScript. Node.js 22 o superior sigue siendo tooling de desarrollo/build/tests; la persistencia local real en SQLite corre por el runtime Bun soportado.
 
 Dependencias principales:
 
 | Dependencia | Uso |
 |---|---|
-| `better-sqlite3` | Persistencia local en SQLite. |
 | `@modelcontextprotocol/sdk` | Servidor MCP por stdio. |
 | `zod` | Validacion de schemas de entrada. |
 | `tsx` | Ejecucion TypeScript en desarrollo. |
@@ -135,9 +134,9 @@ Archivo clave:
 src/memory/sqlite/database.ts
 ```
 
-Al abrir la base, el sistema:
+Al abrir la base con el runtime Bun, el sistema:
 
-1. Crea una conexion con `better-sqlite3`.
+1. Crea una conexion SQLite usando `bun:sqlite`.
 2. Activa `foreign_keys`.
 3. Configura `busy_timeout`.
 4. Aplica migraciones SQL si la base no esta en modo readonly.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vgxness",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "CLI and MCP control plane for guided AI-agent workflows, SDD, memory, and OpenCode setup.",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
@@ -22,12 +22,12 @@
   "scripts": {
     "cli": "tsx src/cli/index.ts",
     "build": "tsc -p tsconfig.build.json && node scripts/copy-migrations.mjs",
-    "verify": "bun run verify:typecheck && bun run verify:test && bun run verify:bun-sqlite && bun run verify:package",
+    "verify": "bun run verify:typecheck && bun run verify:test && bun run verify:test:bun-storage && bun run verify:bun-sqlite && bun run verify:package",
     "verify:typecheck": "tsc --noEmit",
-    "verify:test": "node --import tsx --test \"test/**/*.test.ts\"",
+    "verify:test": "node scripts/run-node-tests.mjs",
+    "verify:test:bun-storage": "node scripts/run-bun-storage-tests.mjs",
     "verify:package": "bun run package:bun:evidence",
     "verify:bun-sqlite": "bun scripts/probe-bun-sqlite.mjs",
-    "verify:node-sqlite": "node scripts/probe-native-sqlite.mjs",
     "ci:bun": "bun run check:bun-lock && bun run verify",
     "check:bun-lock": "node scripts/check-bun-lock.mjs",
     "check:vgxcode:bun-lock": "node scripts/check-bun-lock.mjs --package-json packages/vgxcode/package.json --bun-lock packages/vgxcode/bun.lock",
@@ -36,7 +36,7 @@
     "probe:bun-runtime": "node scripts/probe-bun-runtime-cli-mcp.mjs",
     "verify:bun-runtime": "node scripts/probe-bun-runtime-cli-mcp.mjs --require-pass",
     "package:bun:evidence": "node scripts/probe-bun-package-evidence.mjs",
-    "test": "node --import tsx --test \"test/**/*.test.ts\"",
+    "test": "node scripts/run-node-tests.mjs",
     "typecheck": "tsc --noEmit"
   },
   "bin": {
@@ -58,10 +58,8 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.15.18",
     "@types/react": "^19.2.15",
-    "better-sqlite3": "^12.10.0",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3"
   },