vgxness 1.20.4 → 1.20.6

package/dist/storage/memory/repositories/observations.js

@@ -0,0 +1,217 @@
+import { randomUUID } from 'node:crypto';
+import { normalizeLimit, toFtsMatchQuery } from '../../../application/memory/search.js';
+export class ObservationRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    save(input) {
+        const result = this.db.transaction(() => {
+            const existing = input.topicKey ? this.topic(input) : undefined;
+            const id = existing?.id ?? randomUUID();
+            const now = new Date().toISOString();
+            if (existing)
+                this.db.connection
+                    .prepare('UPDATE observations SET title=@title, content=@content, updated_at=@updatedAt WHERE id=@id')
+                    .run({ id, title: input.title, content: input.content, updatedAt: now });
+            else
+                this.db.connection
+                    .prepare(`INSERT INTO observations(id, project, scope, type, title, content, topic_key, created_at, updated_at)
+        VALUES (@id, @project, @scope, @type, @title, @content, @topicKey, @createdAt, @updatedAt)`)
+                    .run({ ...input, id, topicKey: input.topicKey ?? null, createdAt: now, updatedAt: now });
+            this.appendRevision(id, input.topicKey === undefined
+                ? { type: input.type, title: input.title, content: input.content, createdAt: now }
+                : { type: input.type, title: input.title, content: input.content, topicKey: input.topicKey, createdAt: now });
+            const found = this.getById(id);
+            if (!found.ok)
+                throw new Error(found.error.message);
+            return found.value;
+        });
+        return result.ok ? result : fail(result.error.message, result.error.cause);
+    }
+    getById(id) {
+        try {
+            const row = this.db.connection.prepare('SELECT * FROM observations WHERE id=?').get(id);
+            return row ? ok(map(row)) : missing(`Observation not found: ${id}`);
+        }
+        catch (cause) {
+            return fail('Failed to read observation', cause);
+        }
+    }
+    update(input) {
+        const existing = this.getById(input.id);
+        if (!existing.ok)
+            return existing;
+        const result = this.db.transaction(() => {
+            const next = { ...existing.value, ...input, updatedAt: new Date().toISOString() };
+            this.db.connection
+                .prepare(`UPDATE observations SET type=@type, title=@title, content=@content, topic_key=@topicKey, updated_at=@updatedAt WHERE id=@id`)
+                .run({
+                id: input.id,
+                type: next.type,
+                title: next.title,
+                content: next.content,
+                topicKey: next.topicKey ?? null,
+                updatedAt: next.updatedAt,
+            });
+            const found = this.getById(input.id);
+            if (!found.ok)
+                throw new Error(found.error.message);
+            return found.value;
+        });
+        return result.ok ? result : fail(result.error.message, result.error.cause);
+    }
+    getByTopic(input) {
+        try {
+            const row = input.topicKey ? this.topic(input) : undefined;
+            return row ? ok(map(row)) : missing(`Observation topic not found: ${input.topicKey ?? ''}`);
+        }
+        catch (cause) {
+            return fail('Failed to read observation by topic', cause);
+        }
+    }
+    search(filters) {
+        try {
+            const params = { limit: normalizeLimit(filters.limit) };
+            const where = [];
+            let from = 'observations o';
+            if (filters.query?.trim()) {
+                from = 'observations o JOIN observations_fts fts ON fts.rowid=o.rowid';
+                where.push('observations_fts MATCH @query');
+                params.query = toFtsMatchQuery(filters.query);
+            }
+            for (const [key, column] of [
+                ['project', 'project'],
+                ['scope', 'scope'],
+                ['type', 'type'],
+            ]) {
+                const value = filters[key];
+                if (value) {
+                    where.push(`o.${column}=@${key}`);
+                    params[key] = value;
+                }
+            }
+            if (filters.topicKey) {
+                const topicKeyFilter = normalizeTopicKeySearchFilter(filters.topicKey);
+                if (topicKeyFilter.kind === 'exact') {
+                    where.push('o.topic_key=@topicKey');
+                    params.topicKey = topicKeyFilter.value;
+                }
+                else if (topicKeyFilter.kind === 'prefix') {
+                    where.push(`(o.topic_key=@topicKey OR o.topic_key LIKE @topicKeyPrefix ESCAPE '\\')`);
+                    params.topicKey = topicKeyFilter.value;
+                    params.topicKeyPrefix = `${escapeLike(topicKeyFilter.value)}/%`;
+                }
+            }
+            const rows = this.db.connection
+                .prepare(`SELECT o.* FROM ${from} ${where.length ? `WHERE ${where.join(' AND ')}` : ''} ORDER BY o.updated_at DESC LIMIT @limit`)
+                .all(params);
+            return ok(rows.map(map));
+        }
+        catch (cause) {
+            return fail('Failed to search observations', cause);
+        }
+    }
+    searchPreviews(filters) {
+        const result = this.search(filters);
+        if (!result.ok)
+            return result;
+        return ok(result.value.map(toSearchResult));
+    }
+    listRevisions(observationId) {
+        try {
+            const rows = this.db.connection.prepare('SELECT * FROM observation_revisions WHERE observation_id=? ORDER BY revision ASC').all(observationId);
+            return ok(rows.map(mapRevision));
+        }
+        catch (cause) {
+            return fail('Failed to read observation revisions', cause);
+        }
+    }
+    topic(input) {
+        return this.db.connection.prepare('SELECT * FROM observations WHERE project=@project AND scope=@scope AND type=@type AND topic_key=@topicKey').get(input);
+    }
+    appendRevision(observationId, input) {
+        const current = this.db.connection
+            .prepare('SELECT COALESCE(MAX(revision), 0) AS revision FROM observation_revisions WHERE observation_id=?')
+            .get(observationId);
+        this.db.connection
+            .prepare(`INSERT INTO observation_revisions(id, observation_id, revision, type, title, content, topic_key, created_at)
+      VALUES (@id, @observationId, @revision, @type, @title, @content, @topicKey, @createdAt)`)
+            .run({
+            id: randomUUID(),
+            observationId,
+            revision: Number(current?.revision ?? 0) + 1,
+            type: input.type,
+            title: input.title,
+            content: input.content,
+            topicKey: input.topicKey ?? null,
+            createdAt: input.createdAt,
+        });
+    }
+}
+function normalizeTopicKeySearchFilter(topicKey) {
+    if (topicKey === '*')
+        return { kind: 'all' };
+    if (!topicKey.includes('/'))
+        return { kind: 'prefix', value: topicKey };
+    return { kind: 'exact', value: topicKey };
+}
+function escapeLike(value) {
+    return value.replace(/[\\%_]/g, (match) => `\\${match}`);
+}
+function map(row) {
+    const value = {
+        id: row.id,
+        project: row.project,
+        scope: row.scope,
+        type: row.type,
+        title: row.title,
+        content: row.content,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+    if (row.topic_key !== null)
+        value.topicKey = row.topic_key;
+    return value;
+}
+function mapRevision(row) {
+    const value = {
+        id: row.id,
+        observationId: row.observation_id,
+        revision: row.revision,
+        type: row.type,
+        title: row.title,
+        content: row.content,
+        createdAt: row.created_at,
+    };
+    if (row.topic_key !== null)
+        value.topicKey = row.topic_key;
+    return value;
+}
+function toSearchResult(observation) {
+    const value = {
+        id: observation.id,
+        project: observation.project,
+        scope: observation.scope,
+        type: observation.type,
+        title: observation.title,
+        preview: preview(observation.content),
+        createdAt: observation.createdAt,
+        updatedAt: observation.updatedAt,
+    };
+    if (observation.topicKey !== undefined)
+        value.topicKey = observation.topicKey;
+    return value;
+}
+function preview(content) {
+    return content.length <= 160 ? content : `${content.slice(0, 157)}...`;
+}
+function ok(value) {
+    return { ok: true, value };
+}
+function missing(message) {
+    return { ok: false, error: { code: 'not_found', message } };
+}
+function fail(message, cause) {
+    return { ok: false, error: { code: 'validation_failed', message, cause } };
+}

package/dist/storage/memory/repositories/sessions.js

@@ -0,0 +1,125 @@
+import { randomUUID } from 'node:crypto';
+export class SessionRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    save(input) {
+        const result = this.db.transaction(() => {
+            const id = input.id ?? randomUUID();
+            this.db.connection
+                .prepare(`INSERT INTO sessions(id, project, directory, started_at) VALUES (@id, @project, @directory, @startedAt)
+        ON CONFLICT(id) DO UPDATE SET project=excluded.project, directory=excluded.directory`)
+                .run({ id, project: input.project, directory: input.directory ?? null, startedAt: new Date().toISOString() });
+            const session = this.getById(id);
+            if (!session.ok)
+                throw new Error(session.error.message);
+            return session.value;
+        });
+        return result.ok ? result : fail(result.error.message, result.error.cause);
+    }
+    getById(id) {
+        try {
+            const row = this.db.connection.prepare('SELECT * FROM sessions WHERE id=?').get(id);
+            if (!row)
+                return { ok: false, error: { code: 'not_found', message: `Session not found: ${id}` } };
+            return { ok: true, value: mapSession(row) };
+        }
+        catch (cause) {
+            return fail('Failed to read session', cause);
+        }
+    }
+    restoreLatest(input) {
+        try {
+            const row = this.db.connection
+                .prepare(`
+        SELECT * FROM sessions
+        WHERE project = @project
+          AND ended_at IS NOT NULL
+          AND summary IS NOT NULL
+          AND TRIM(summary) <> ''
+          AND (@directory IS NULL OR directory = @directory)
+        ORDER BY ended_at DESC, started_at DESC, id DESC
+        LIMIT 1
+      `)
+                .get({ project: input.project, directory: input.directory ?? null });
+            if (!row)
+                return missing(`No closed session summary found for project: ${input.project}`);
+            return { ok: true, value: mapSession(row) };
+        }
+        catch (cause) {
+            return fail('Failed to restore session', cause);
+        }
+    }
+    appendActivity(input) {
+        const session = this.getById(input.sessionId);
+        if (!session.ok)
+            return session;
+        const result = this.db.transaction(() => {
+            const next = this.db.connection
+                .prepare('SELECT COALESCE(MAX(sequence), 0) + 1 AS sequence FROM session_activity WHERE session_id=?')
+                .get(input.sessionId);
+            const activity = { id: randomUUID(), sequence: next.sequence, createdAt: new Date().toISOString(), ...input };
+            this.db.connection
+                .prepare(`INSERT INTO session_activity(id, session_id, sequence, actor, kind, payload_json, created_at)
+        VALUES (@id, @sessionId, @sequence, @actor, @kind, @payloadJson, @createdAt)`)
+                .run(activity);
+            return activity;
+        });
+        return result.ok ? result : fail(result.error.message, result.error.cause);
+    }
+    closeSession(input) {
+        const summary = input.summary.trim();
+        if (summary.length === 0)
+            return fail('summary must not be empty');
+        const result = this.db.transaction(() => {
+            const existing = this.db.connection.prepare('SELECT 1 FROM sessions WHERE id=?').get(input.sessionId);
+            if (!existing)
+                throw new SessionValidationError(`Session not found: ${input.sessionId}`);
+            const endedAt = new Date().toISOString();
+            this.db.connection
+                .prepare('UPDATE sessions SET summary=@summary, ended_at=@endedAt WHERE id=@sessionId')
+                .run({ sessionId: input.sessionId, summary, endedAt });
+            const next = this.db.connection
+                .prepare('SELECT COALESCE(MAX(sequence), 0) + 1 AS sequence FROM session_activity WHERE session_id=?')
+                .get(input.sessionId);
+            this.db.connection
+                .prepare(`INSERT INTO session_activity(id, session_id, sequence, actor, kind, payload_json, created_at)
+        VALUES (@id, @sessionId, @sequence, @actor, 'summary', @payloadJson, @createdAt)`)
+                .run({
+                id: randomUUID(),
+                sessionId: input.sessionId,
+                sequence: next.sequence,
+                actor: input.actor,
+                payloadJson: JSON.stringify({ summary }),
+                createdAt: endedAt,
+            });
+            const session = this.getById(input.sessionId);
+            if (!session.ok)
+                throw new SessionValidationError(session.error.message);
+            return session.value;
+        });
+        return result.ok ? result : fail(errorMessage(result.error.cause) ?? result.error.message, result.error.cause);
+    }
+}
+function fail(message, cause) {
+    return { ok: false, error: { code: 'validation_failed', message, cause } };
+}
+function missing(message) {
+    return { ok: false, error: { code: 'not_found', message } };
+}
+function mapSession(row) {
+    const session = { id: row.id, project: row.project, startedAt: row.started_at };
+    if (row.directory !== null)
+        session.directory = row.directory;
+    if (row.ended_at !== null)
+        session.endedAt = row.ended_at;
+    if (row.summary !== null)
+        session.summary = row.summary;
+    return session;
+}
+class SessionValidationError extends Error {
+}
+function errorMessage(cause) {
+    return cause instanceof SessionValidationError ? cause.message : undefined;
+}

package/dist/storage/memory/repositories/traces.js

@@ -0,0 +1,78 @@
+import { randomUUID } from 'node:crypto';
+export class TraceRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    write(input) {
+        try {
+            const trace = toTrace(input);
+            this.db.connection
+                .prepare(`INSERT INTO traces(id, actor, session_id, operation, target_type, target_id, topic_key, status, error_code, error_message, created_at)
+        VALUES (@id, @actor, @sessionId, @operation, @targetType, @targetId, @topicKey, @status, @errorCode, @errorMessage, @createdAt)`)
+                .run({
+                id: trace.id,
+                actor: trace.actor,
+                sessionId: trace.sessionId ?? null,
+                operation: trace.operation,
+                targetType: trace.targetType,
+                targetId: trace.targetId ?? null,
+                topicKey: trace.topicKey ?? null,
+                status: trace.status,
+                errorCode: trace.errorCode ?? null,
+                errorMessage: trace.errorMessage ?? null,
+                createdAt: trace.createdAt,
+            });
+            return { ok: true, value: trace };
+        }
+        catch (cause) {
+            return fail('Failed to write trace', cause);
+        }
+    }
+    list() {
+        try {
+            return { ok: true, value: this.db.connection.prepare('SELECT * FROM traces ORDER BY created_at ASC').all().map(map) };
+        }
+        catch (cause) {
+            return fail('Failed to list traces', cause);
+        }
+    }
+}
+function toTrace(input) {
+    const trace = {
+        id: randomUUID(),
+        actor: input.actor,
+        operation: input.operation,
+        targetType: input.targetType,
+        status: input.status,
+        createdAt: new Date().toISOString(),
+    };
+    if (input.sessionId !== undefined)
+        trace.sessionId = input.sessionId;
+    if (input.targetId !== undefined)
+        trace.targetId = input.targetId;
+    if (input.topicKey !== undefined)
+        trace.topicKey = input.topicKey;
+    if (input.errorCode !== undefined)
+        trace.errorCode = input.errorCode;
+    if (input.errorMessage !== undefined)
+        trace.errorMessage = input.errorMessage;
+    return trace;
+}
+function map(row) {
+    const trace = { id: row.id, actor: row.actor, operation: row.operation, targetType: row.target_type, status: row.status, createdAt: row.created_at };
+    if (row.session_id !== null)
+        trace.sessionId = row.session_id;
+    if (row.target_id !== null)
+        trace.targetId = row.target_id;
+    if (row.topic_key !== null)
+        trace.topicKey = row.topic_key;
+    if (row.error_code !== null)
+        trace.errorCode = row.error_code;
+    if (row.error_message !== null)
+        trace.errorMessage = row.error_message;
+    return trace;
+}
+function fail(message, cause) {
+    return { ok: false, error: { code: 'validation_failed', message, cause } };
+}

package/dist/storage/memory/sqlite/database.js

@@ -0,0 +1,228 @@
+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 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) {
+        this.connection = connection;
+    }
+    static open(options) {
+        try {
+            const connection = openSqliteConnection(options);
+            connection.pragma('foreign_keys = ON');
+            connection.pragma(`busy_timeout = ${sqliteBusyTimeoutMs}`);
+            const memoryDatabase = new MemoryDatabase(connection);
+            if (!(options.readonly ?? false)) {
+                const migration = memoryDatabase.applyMigrations();
+                if (!migration.ok) {
+                    connection.close();
+                    return migration;
+                }
+            }
+            return { ok: true, value: memoryDatabase };
+        }
+        catch (cause) {
+            return {
+                ok: false,
+                error: {
+                    code: 'store_unavailable',
+                    message: buildMemoryStoreUnavailableMessage(options.path, cause),
+                    cause,
+                },
+            };
+        }
+    }
+    applyMigrations() {
+        if (!existsSync(migrationsDirectory)) {
+            return migrationFailure(`Migrations directory not found: ${migrationsDirectory}`);
+        }
+        const migrationFiles = readdirSync(migrationsDirectory)
+            .filter((file) => file.endsWith('.sql'))
+            .sort();
+        try {
+            const run = this.connection.transaction(() => {
+                this.connection.exec(`
+          CREATE TABLE IF NOT EXISTS schema_migrations (
+            version TEXT PRIMARY KEY,
+            applied_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+          );
+        `);
+                const hasMigration = this.connection.prepare('SELECT 1 FROM schema_migrations WHERE version = ?');
+                const recordMigration = this.connection.prepare('INSERT INTO schema_migrations(version) VALUES (?)');
+                for (const file of migrationFiles) {
+                    if (hasMigration.get(file))
+                        continue;
+                    this.connection.exec(readFileSync(join(migrationsDirectory, file), 'utf8'));
+                    recordMigration.run(file);
+                }
+            });
+            run();
+            return { ok: true, value: undefined };
+        }
+        catch (cause) {
+            return migrationFailure('Failed to apply local memory migrations', cause);
+        }
+    }
+    transaction(operation) {
+        try {
+            const run = this.connection.transaction(operation);
+            return { ok: true, value: run.immediate() };
+        }
+        catch (cause) {
+            return {
+                ok: false,
+                error: {
+                    code: 'transaction_failed',
+                    message: 'Local memory transaction failed and was rolled back',
+                    cause,
+                },
+            };
+        }
+    }
+    close() {
+        this.connection.close();
+    }
+}
+export function openMemoryDatabase(options) {
+    return MemoryDatabase.open(options);
+}
+export function buildMemoryStoreUnavailableMessage(path, cause) {
+    const message = `Unable to open local memory store at ${path}`;
+    if (!isUnsupportedSqliteRuntimeError(cause))
+        return message;
+    return `${message}. ${bunRequiredGuidance}`;
+}
+function openSqliteConnection(options) {
+    return resolveSqliteDriver()(options);
+}
+function resolveSqliteDriver() {
+    if (isBunRuntime())
+        return resolveBunSqliteDriver();
+    throw createUnsupportedSqliteRuntimeError();
+}
+function isBunRuntime() {
+    return typeof globalThis.Bun !== 'undefined';
+}
+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 {
+        prepare(sql) {
+            const prepare = record.prepare;
+            if (typeof prepare !== 'function')
+                throw new Error('bun:sqlite prepare() is unavailable');
+            return createBunSqliteStatement(prepare.call(database, sql));
+        },
+        exec(sql) {
+            const exec = record.exec;
+            if (typeof exec === 'function')
+                return exec.call(database, sql);
+            const run = record.run;
+            if (typeof run === 'function')
+                return run.call(database, sql);
+            throw new Error('bun:sqlite exec() is unavailable');
+        },
+        pragma(statement) {
+            return runBunPragma(database, statement);
+        },
+        transaction(operation) {
+            const transaction = record.transaction;
+            if (typeof transaction !== 'function')
+                throw new Error('bun:sqlite transaction() is unavailable');
+            const run = transaction.call(database, operation);
+            if (typeof run !== 'function')
+                throw new Error('bun:sqlite transaction() did not return a callable transaction');
+            const transactionRunner = run;
+            if (typeof transactionRunner.immediate !== 'function') {
+                throw new Error('bun:sqlite transaction().immediate() is unavailable');
+            }
+            return transactionRunner;
+        },
+        close() {
+            const close = record.close;
+            if (typeof close !== 'function')
+                return;
+            close.call(database, false);
+        },
+    };
+}
+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)) {
+        const exec = database.exec;
+        if (typeof exec !== 'function')
+            throw new Error('bun:sqlite exec() is unavailable for PRAGMA setter');
+        return exec.call(database, `PRAGMA ${normalizedStatement}`);
+    }
+    const prepare = database.prepare;
+    if (typeof prepare !== 'function')
+        throw new Error('bun:sqlite prepare() is unavailable for PRAGMA reader');
+    const rows = prepare.call(database, `PRAGMA ${normalizedStatement}`).all();
+    if (/^busy_timeout\b/i.test(normalizedStatement))
+        return normalizeBusyTimeoutRows(rows);
+    return rows;
+}
+function isPragmaSetter(statement) {
+    return /=/.test(statement);
+}
+function normalizeBusyTimeoutRows(rows) {
+    return rows.map((row) => {
+        if (row === null || typeof row !== 'object')
+            return row;
+        const record = row;
+        if (typeof record.timeout === 'number')
+            return row;
+        if (typeof record.busy_timeout === 'number')
+            return { timeout: record.busy_timeout };
+        return row;
+    });
+}
+function migrationFailure(message, cause) {
+    const error = { code: 'migration_failed', message };
+    if (cause !== undefined)
+        error.cause = cause;
+    return { ok: false, error };
+}