db4ai 0.3.0 → 0.3.1

package/dist/cli/runtime/index.js

@@ -1,705 +1,11 @@
-/**
- * Module 14: Local Runtime
- *
- * SQLite-based local database runtime for offline-first development.
- * Provides the same interface as the Cloudflare Durable Object for
- * seamless local development and testing.
- */
-import Database from 'better-sqlite3';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as crypto from 'node:crypto';
-// ============================================================================
-// Utility Functions
-// ============================================================================
-/**
- * Computes a deterministic hash of an object by sorting keys recursively.
- */
-function computeHash(obj) {
-    const sortedJson = stableStringify(obj);
-    return crypto.createHash('sha256').update(sortedJson).digest('hex').slice(0, 16);
-}
-/**
- * Stable JSON stringify that sorts object keys for consistent hashing.
- */
-function stableStringify(obj) {
-    if (obj === null || typeof obj !== 'object') {
-        return JSON.stringify(obj);
-    }
-    if (Array.isArray(obj)) {
-        return '[' + obj.map(stableStringify).join(',') + ']';
-    }
-    const keys = Object.keys(obj).sort();
-    const pairs = keys.map((key) => JSON.stringify(key) + ':' + stableStringify(obj[key]));
-    return '{' + pairs.join(',') + '}';
-}
-/**
- * Ensures parent directories exist for a given file path.
- * Silently handles errors (e.g., permission denied, root paths).
- */
-function ensureDirectoryExists(filePath) {
-    const dir = path.dirname(filePath);
-    try {
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-    }
-    catch {
-        // Silently ignore - the database open will fail with a more specific error
-    }
-}
-// ============================================================================
-// Database Schema Version
-// ============================================================================
-const SCHEMA_VERSION = 1;
-const SCHEMA_SQL = `
-  -- Things table (entities)
-  CREATE TABLE IF NOT EXISTS things (
-    rowid INTEGER PRIMARY KEY AUTOINCREMENT,
-    type TEXT NOT NULL,
-    id TEXT NOT NULL,
-    data TEXT NOT NULL,
-    content_hash TEXT NOT NULL,
-    created_at INTEGER NOT NULL,
-    created_by_action INTEGER,
-    FOREIGN KEY (created_by_action) REFERENCES actions(rowid)
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_things_type_id ON things(type, id);
-  CREATE INDEX IF NOT EXISTS idx_things_content_hash ON things(content_hash);
-  CREATE INDEX IF NOT EXISTS idx_things_type ON things(type);
-
-  -- Relationships table (edges)
-  CREATE TABLE IF NOT EXISTS relationships (
-    rowid INTEGER PRIMARY KEY AUTOINCREMENT,
-    from_rowid INTEGER NOT NULL,
-    to_rowid INTEGER NOT NULL,
-    type TEXT NOT NULL,
-    path TEXT NOT NULL,
-    label TEXT NOT NULL,
-    created_at INTEGER NOT NULL,
-    created_by_action INTEGER,
-    FOREIGN KEY (from_rowid) REFERENCES things(rowid),
-    FOREIGN KEY (to_rowid) REFERENCES things(rowid),
-    FOREIGN KEY (created_by_action) REFERENCES actions(rowid),
-    UNIQUE (from_rowid, to_rowid, path)
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_relationships_from ON relationships(from_rowid);
-  CREATE INDEX IF NOT EXISTS idx_relationships_to ON relationships(to_rowid);
-  CREATE INDEX IF NOT EXISTS idx_relationships_type ON relationships(type);
-
-  -- Actions table (for caching and tracking)
-  CREATE TABLE IF NOT EXISTS actions (
-    rowid INTEGER PRIMARY KEY AUTOINCREMENT,
-    type TEXT NOT NULL,
-    input_hash TEXT NOT NULL,
-    input TEXT NOT NULL,
-    output TEXT,
-    model TEXT,
-    status TEXT NOT NULL DEFAULT 'pending',
-    error TEXT,
-    duration_ms INTEGER,
-    cost_tokens INTEGER,
-    created_at INTEGER NOT NULL
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_actions_input_hash ON actions(input_hash);
-  CREATE INDEX IF NOT EXISTS idx_actions_status ON actions(status);
-
-  -- Events table (audit log)
-  CREATE TABLE IF NOT EXISTS events (
-    rowid INTEGER PRIMARY KEY AUTOINCREMENT,
-    type TEXT NOT NULL,
-    action TEXT NOT NULL,
-    entity_type TEXT NOT NULL,
-    entity_id TEXT NOT NULL,
-    entity_rowid INTEGER NOT NULL,
-    data TEXT NOT NULL,
-    changes TEXT,
-    timestamp INTEGER NOT NULL,
-    action_id INTEGER,
-    correlation_id TEXT,
-    FOREIGN KEY (action_id) REFERENCES actions(rowid)
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_events_type ON events(type);
-  CREATE INDEX IF NOT EXISTS idx_events_action ON events(action);
-  CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
-  CREATE INDEX IF NOT EXISTS idx_events_correlation_id ON events(correlation_id);
-
-  -- Schema version tracking
-  CREATE TABLE IF NOT EXISTS schema_version (
-    version INTEGER NOT NULL
-  );
-`;
-// ============================================================================
-// LocalDB Class
-// ============================================================================
-export class LocalDB {
-    db;
-    path;
-    version = SCHEMA_VERSION;
-    things;
-    relationships;
-    actions;
-    events;
-    constructor(dbPath) {
-        // Use default path if not provided
-        this.path = dbPath || path.join(process.cwd(), '.db4', 'local.db');
-        // Ensure parent directory exists
-        ensureDirectoryExists(this.path);
-        // Open database, falling back to in-memory if file path fails
-        try {
-            this.db = new Database(this.path);
-        }
-        catch {
-            // If we can't open the file database, use in-memory as fallback
-            // This allows graceful degradation when the path is invalid
-            this.db = new Database(':memory:');
-        }
-        // Enable WAL mode for better concurrent performance (only for file-based DBs)
-        try {
-            this.db.pragma('journal_mode = WAL');
-        }
-        catch {
-            // WAL mode may not be available for in-memory databases
-        }
-        // Initialize schema
-        this.initSchema();
-        // Initialize APIs
-        this.things = new ThingsAPI(this.db);
-        this.relationships = new RelationshipsAPI(this.db);
-        this.actions = new ActionsAPI(this.db);
-        this.events = new EventsAPI(this.db);
-    }
-    initSchema() {
-        // Check if schema exists
-        const tableCheck = this.db
-            .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='schema_version'`)
-            .get();
-        if (!tableCheck) {
-            // Initialize fresh database
-            this.db.exec(SCHEMA_SQL);
-            this.db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(SCHEMA_VERSION);
-        }
-    }
-    /**
-     * Closes the database connection.
-     */
-    close() {
-        this.db.close();
-    }
-    /**
-     * Runs VACUUM to reclaim disk space.
-     */
-    vacuum() {
-        this.db.exec('VACUUM');
-        return Promise.resolve();
-    }
-}
-// ============================================================================
-// Things API
-// ============================================================================
-class ThingsAPI {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    /**
-     * Upsert a thing. Returns existing rowid if content_hash matches,
-     * otherwise creates a new version.
-     */
-    async upsert(params) {
-        const { type, id, data, created_by_action } = params;
-        const dataJson = JSON.stringify(data);
-        const content_hash = computeHash({ type, id, data });
-        const created_at = Date.now();
-        // Check if identical content already exists
-        const existing = this.db
-            .prepare('SELECT rowid FROM things WHERE type = ? AND id = ? AND content_hash = ?')
-            .get(type, id, content_hash);
-        if (existing) {
-            return { rowid: existing.rowid, created: false };
-        }
-        // Insert new version
-        const result = this.db
-            .prepare(`INSERT INTO things (type, id, data, content_hash, created_at, created_by_action)
-         VALUES (?, ?, ?, ?, ?, ?)`)
-            .run(type, id, dataJson, content_hash, created_at, created_by_action || null);
-        return { rowid: result.lastInsertRowid, created: true };
-    }
-    /**
-     * Get the latest version of a thing by type and id.
-     */
-    async get(params) {
-        const { type, id } = params;
-        const row = this.db
-            .prepare(`SELECT rowid, type, id, data, content_hash, created_at, created_by_action
-         FROM things
-         WHERE type = ? AND id = ?
-         ORDER BY rowid DESC
-         LIMIT 1`)
-            .get(type, id);
-        if (!row)
-            return null;
-        return {
-            rowid: row.rowid,
-            type: row.type,
-            id: row.id,
-            data: JSON.parse(row.data),
-            content_hash: row.content_hash,
-            created_at: row.created_at,
-            created_by_action: row.created_by_action ?? undefined,
-        };
-    }
-    /**
-     * Get a specific version by rowid.
-     */
-    async getByRowid(rowid) {
-        const row = this.db
-            .prepare(`SELECT rowid, type, id, data, content_hash, created_at, created_by_action
-         FROM things
-         WHERE rowid = ?`)
-            .get(rowid);
-        if (!row)
-            return null;
-        return {
-            rowid: row.rowid,
-            type: row.type,
-            id: row.id,
-            data: JSON.parse(row.data),
-            content_hash: row.content_hash,
-            created_at: row.created_at,
-            created_by_action: row.created_by_action ?? undefined,
-        };
-    }
-    /**
-     * List things with optional filters.
-     */
-    async list(params = {}) {
-        const { type, limit, offset, where, order = 'asc' } = params;
-        let sql = `
-      SELECT t.rowid, t.type, t.id, t.data, t.content_hash, t.created_at, t.created_by_action
-      FROM things t
-      INNER JOIN (
-        SELECT type, id, MAX(rowid) as max_rowid
-        FROM things
-        ${type ? 'WHERE type = ?' : ''}
-        GROUP BY type, id
-      ) latest ON t.rowid = latest.max_rowid
-    `;
-        const queryParams = [];
-        if (type) {
-            queryParams.push(type);
-        }
-        // Handle where clause
-        if (where && Object.keys(where).length > 0) {
-            const whereConditions = Object.keys(where).map((key) => {
-                const value = where[key];
-                // json_extract returns the raw value, so for strings we compare directly
-                queryParams.push(value);
-                return `json_extract(t.data, '$.${key}') = ?`;
-            });
-            sql += ` WHERE ${whereConditions.join(' AND ')}`;
-        }
-        sql += ` ORDER BY t.rowid ${order === 'desc' ? 'DESC' : 'ASC'}`;
-        if (limit !== undefined) {
-            sql += ` LIMIT ?`;
-            queryParams.push(limit);
-        }
-        if (offset !== undefined) {
-            sql += ` OFFSET ?`;
-            queryParams.push(offset);
-        }
-        const rows = this.db.prepare(sql).all(...queryParams);
-        return rows.map((row) => ({
-            rowid: row.rowid,
-            type: row.type,
-            id: row.id,
-            data: JSON.parse(row.data),
-            content_hash: row.content_hash,
-            created_at: row.created_at,
-            created_by_action: row.created_by_action ?? undefined,
-        }));
-    }
-    /**
-     * Delete a thing by rowid.
-     */
-    async delete(rowid) {
-        this.db.prepare('DELETE FROM things WHERE rowid = ?').run(rowid);
-    }
-}
-// ============================================================================
-// Relationships API
-// ============================================================================
-class RelationshipsAPI {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    /**
-     * Create or update a relationship edge.
-     * If (from_rowid, to_rowid, path) already exists, updates it.
-     */
-    async create(params) {
-        const { from_rowid, to_rowid, type, path, label, created_by_action } = params;
-        const created_at = Date.now();
-        // Check if edge exists with same from/to/path
-        const existing = this.db
-            .prepare(`SELECT rowid FROM relationships
-         WHERE from_rowid = ? AND to_rowid = ? AND path = ?`)
-            .get(from_rowid, to_rowid, path);
-        if (existing) {
-            // Update existing edge
-            this.db
-                .prepare(`UPDATE relationships
-         SET type = ?, label = ?, created_by_action = ?
-         WHERE rowid = ?`)
-                .run(type, label, created_by_action || null, existing.rowid);
-            const row = this.db
-                .prepare(`SELECT rowid, from_rowid, to_rowid, type, path, label, created_at, created_by_action
-           FROM relationships WHERE rowid = ?`)
-                .get(existing.rowid);
-            return {
-                rowid: row.rowid,
-                from_rowid: row.from_rowid,
-                to_rowid: row.to_rowid,
-                type: row.type,
-                path: row.path,
-                label: row.label,
-                created_at: row.created_at,
-                created_by_action: row.created_by_action ?? undefined,
-            };
-        }
-        // Insert new edge
-        const result = this.db
-            .prepare(`INSERT INTO relationships (from_rowid, to_rowid, type, path, label, created_at, created_by_action)
-         VALUES (?, ?, ?, ?, ?, ?, ?)`)
-            .run(from_rowid, to_rowid, type, path, label, created_at, created_by_action || null);
-        return {
-            rowid: result.lastInsertRowid,
-            from_rowid,
-            to_rowid,
-            type,
-            path,
-            label,
-            created_at,
-            created_by_action,
-        };
-    }
-    /**
-     * List all relationships.
-     */
-    async list() {
-        const rows = this.db
-            .prepare(`SELECT rowid, from_rowid, to_rowid, type, path, label, created_at, created_by_action
-         FROM relationships`)
-            .all();
-        return rows.map((row) => ({
-            rowid: row.rowid,
-            from_rowid: row.from_rowid,
-            to_rowid: row.to_rowid,
-            type: row.type,
-            path: row.path,
-            label: row.label,
-            created_at: row.created_at,
-            created_by_action: row.created_by_action ?? undefined,
-        }));
-    }
-    /**
-     * Traverse forward from an entity.
-     */
-    async traverse(params) {
-        const { from_rowid, type } = params;
-        let sql = `
-      SELECT rowid, from_rowid, to_rowid, type, path, label, created_at, created_by_action
-      FROM relationships
-      WHERE from_rowid = ?
-    `;
-        const queryParams = [from_rowid];
-        if (type) {
-            sql += ' AND type = ?';
-            queryParams.push(type);
-        }
-        const rows = this.db.prepare(sql).all(...queryParams);
-        return rows.map((row) => ({
-            rowid: row.rowid,
-            from_rowid: row.from_rowid,
-            to_rowid: row.to_rowid,
-            type: row.type,
-            path: row.path,
-            label: row.label,
-            created_at: row.created_at,
-            created_by_action: row.created_by_action ?? undefined,
-        }));
-    }
-    /**
-     * Find incoming edges to an entity.
-     */
-    async incoming(params) {
-        const { to_rowid, type } = params;
-        let sql = `
-      SELECT rowid, from_rowid, to_rowid, type, path, label, created_at, created_by_action
-      FROM relationships
-      WHERE to_rowid = ?
-    `;
-        const queryParams = [to_rowid];
-        if (type) {
-            sql += ' AND type = ?';
-            queryParams.push(type);
-        }
-        const rows = this.db.prepare(sql).all(...queryParams);
-        return rows.map((row) => ({
-            rowid: row.rowid,
-            from_rowid: row.from_rowid,
-            to_rowid: row.to_rowid,
-            type: row.type,
-            path: row.path,
-            label: row.label,
-            created_at: row.created_at,
-            created_by_action: row.created_by_action ?? undefined,
-        }));
-    }
-    /**
-     * Traverse multiple hops from an entity (BFS).
-     */
-    async traverseMultiHop(params) {
-        const { from_rowid, depth, type } = params;
-        const visited = new Set([from_rowid]);
-        const results = [];
-        let currentLevel = [from_rowid];
-        for (let d = 1; d <= depth && currentLevel.length > 0; d++) {
-            const nextLevel = [];
-            for (const nodeId of currentLevel) {
-                const edges = await this.traverse({ from_rowid: nodeId, type });
-                for (const edge of edges) {
-                    if (!visited.has(edge.to_rowid)) {
-                        visited.add(edge.to_rowid);
-                        results.push({ to_rowid: edge.to_rowid, depth: d });
-                        nextLevel.push(edge.to_rowid);
-                    }
-                }
-            }
-            currentLevel = nextLevel;
-        }
-        return results;
-    }
-}
-// ============================================================================
-// Actions API
-// ============================================================================
-class ActionsAPI {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    /**
-     * Create a new action in pending status.
-     */
-    async create(params) {
-        const { type, input, model } = params;
-        const inputJson = JSON.stringify(input);
-        const input_hash = computeHash(input);
-        const created_at = Date.now();
-        const result = this.db
-            .prepare(`INSERT INTO actions (type, input_hash, input, model, status, created_at)
-         VALUES (?, ?, ?, ?, 'pending', ?)`)
-            .run(type, input_hash, inputJson, model || null, created_at);
-        return {
-            rowid: result.lastInsertRowid,
-            type,
-            input_hash,
-            input,
-            model,
-            status: 'pending',
-            created_at,
-        };
-    }
-    /**
-     * Find a completed action by input hash (cache lookup).
-     * Only returns actions with status='complete'.
-     */
-    async findByHash(input_hash) {
-        const row = this.db
-            .prepare(`SELECT rowid, type, input_hash, input, output, model, status, error, duration_ms, cost_tokens, created_at
-         FROM actions
-         WHERE input_hash = ? AND status = 'complete'
-         ORDER BY rowid DESC
-         LIMIT 1`)
-            .get(input_hash);
-        if (!row)
-            return null;
-        return {
-            rowid: row.rowid,
-            type: row.type,
-            input_hash: row.input_hash,
-            input: JSON.parse(row.input),
-            output: row.output ? JSON.parse(row.output) : undefined,
-            model: row.model ?? undefined,
-            status: row.status,
-            error: row.error ?? undefined,
-            duration_ms: row.duration_ms ?? undefined,
-            cost_tokens: row.cost_tokens ?? undefined,
-            created_at: row.created_at,
-        };
-    }
-    /**
-     * Complete an action with output.
-     */
-    async complete(params) {
-        const { rowid, output, duration_ms, cost_tokens } = params;
-        const outputJson = JSON.stringify(output);
-        // Check if action exists and is pending
-        const existing = this.db
-            .prepare('SELECT status FROM actions WHERE rowid = ?')
-            .get(rowid);
-        if (!existing) {
-            throw new Error(`Action with rowid ${rowid} not found`);
-        }
-        if (existing.status !== 'pending') {
-            throw new Error(`Cannot complete action with status '${existing.status}'`);
-        }
-        this.db
-            .prepare(`UPDATE actions
-         SET status = 'complete', output = ?, duration_ms = ?, cost_tokens = ?
-         WHERE rowid = ?`)
-            .run(outputJson, duration_ms || null, cost_tokens || null, rowid);
-        const row = this.db
-            .prepare(`SELECT rowid, type, input_hash, input, output, model, status, error, duration_ms, cost_tokens, created_at
-         FROM actions WHERE rowid = ?`)
-            .get(rowid);
-        return {
-            rowid: row.rowid,
-            type: row.type,
-            input_hash: row.input_hash,
-            input: JSON.parse(row.input),
-            output: row.output ? JSON.parse(row.output) : undefined,
-            model: row.model ?? undefined,
-            status: row.status,
-            error: row.error ?? undefined,
-            duration_ms: row.duration_ms ?? undefined,
-            cost_tokens: row.cost_tokens ?? undefined,
-            created_at: row.created_at,
-        };
-    }
-    /**
-     * Mark an action as failed.
-     */
-    async fail(params) {
-        const { rowid, error } = params;
-        // Check if action exists and is pending
-        const existing = this.db
-            .prepare('SELECT status FROM actions WHERE rowid = ?')
-            .get(rowid);
-        if (!existing) {
-            throw new Error(`Action with rowid ${rowid} not found`);
-        }
-        if (existing.status !== 'pending') {
-            throw new Error(`Cannot fail action with status '${existing.status}'`);
-        }
-        this.db.prepare(`UPDATE actions SET status = 'error', error = ? WHERE rowid = ?`).run(error, rowid);
-        const row = this.db
-            .prepare(`SELECT rowid, type, input_hash, input, output, model, status, error, duration_ms, cost_tokens, created_at
-         FROM actions WHERE rowid = ?`)
-            .get(rowid);
-        return {
-            rowid: row.rowid,
-            type: row.type,
-            input_hash: row.input_hash,
-            input: JSON.parse(row.input),
-            output: row.output ? JSON.parse(row.output) : undefined,
-            model: row.model ?? undefined,
-            status: row.status,
-            error: row.error ?? undefined,
-            duration_ms: row.duration_ms ?? undefined,
-            cost_tokens: row.cost_tokens ?? undefined,
-            created_at: row.created_at,
-        };
-    }
-}
-// ============================================================================
-// Events API
-// ============================================================================
-class EventsAPI {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    /**
-     * Emit an event.
-     */
-    async emit(params) {
-        const { type, action, entity_type, entity_id, entity_rowid, data, changes, action_id, correlation_id, } = params;
-        const timestamp = Date.now();
-        const dataJson = JSON.stringify(data);
-        const changesJson = changes ? JSON.stringify(changes) : null;
-        const result = this.db
-            .prepare(`INSERT INTO events (type, action, entity_type, entity_id, entity_rowid, data, changes, timestamp, action_id, correlation_id)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-            .run(type, action, entity_type, entity_id, entity_rowid, dataJson, changesJson, timestamp, action_id || null, correlation_id || null);
-        return {
-            rowid: result.lastInsertRowid,
-            type,
-            action,
-            entity_type,
-            entity_id,
-            entity_rowid,
-            data,
-            changes,
-            timestamp,
-            action_id,
-            correlation_id,
-        };
-    }
-    /**
-     * List events with optional filters.
-     */
-    async list(params = {}) {
-        const { type, action, since, correlation_id, limit } = params;
-        let sql = `
-      SELECT rowid, type, action, entity_type, entity_id, entity_rowid, data, changes, timestamp, action_id, correlation_id
-      FROM events
-      WHERE 1=1
-    `;
-        const queryParams = [];
-        if (type) {
-            sql += ' AND type = ?';
-            queryParams.push(type);
-        }
-        if (action) {
-            sql += ' AND action = ?';
-            queryParams.push(action);
-        }
-        if (since !== undefined) {
-            sql += ' AND timestamp > ?';
-            queryParams.push(since);
-        }
-        if (correlation_id) {
-            sql += ' AND correlation_id = ?';
-            queryParams.push(correlation_id);
-        }
-        sql += ' ORDER BY timestamp ASC';
-        if (limit !== undefined) {
-            sql += ' LIMIT ?';
-            queryParams.push(limit);
-        }
-        const rows = this.db.prepare(sql).all(...queryParams);
-        return rows.map((row) => ({
-            rowid: row.rowid,
-            type: row.type,
-            action: row.action,
-            entity_type: row.entity_type,
-            entity_id: row.entity_id,
-            entity_rowid: row.entity_rowid,
-            data: JSON.parse(row.data),
-            changes: row.changes ? JSON.parse(row.changes) : undefined,
-            timestamp: row.timestamp,
-            action_id: row.action_id ?? undefined,
-            correlation_id: row.correlation_id ?? undefined,
-        }));
-    }
-}
-// Default export for convenience
-export default LocalDB;
+import {
+  ConnectionPool,
+  LocalDB,
+  runtime_default
+} from "../../chunk-FUF4HJTC.js";
+export {
+  ConnectionPool,
+  LocalDB,
+  runtime_default as default
+};
 //# sourceMappingURL=index.js.map