@andespindola/brainlink 0.1.0-beta.14 → 0.1.0-beta.16

package/dist/infrastructure/sqlite/document-writer.js

@@ -1,51 +0,0 @@
-import { createEmbeddingBuckets } from '../../domain/embeddings.js';
-const toTitleKey = (title) => title.toLowerCase();
-export const createIndexWriter = (database) => ({
-    reset: () => {
-        database.exec(`
-      DELETE FROM embedding_buckets;
-      DELETE FROM chunks_fts;
-      DELETE FROM links;
-      DELETE FROM chunks;
-      DELETE FROM documents;
-    `);
-    },
-    saveDocuments: (documents) => {
-        const insertDocument = database.prepare(`
-      INSERT INTO documents (id, agent_id, title, path, content, tags_json, frontmatter_json, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-        const insertChunk = database.prepare(`
-      INSERT INTO chunks (id, document_id, ordinal, content, token_count, embedding_provider, embedding_json)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `);
-        const insertChunkFts = database.prepare(`
-      INSERT INTO chunks_fts (chunk_id, document_id, agent_id, title, content)
-      VALUES (?, ?, ?, ?, ?)
-    `);
-        const insertEmbeddingBucket = database.prepare(`
-      INSERT OR IGNORE INTO embedding_buckets (bucket, chunk_id)
-      VALUES (?, ?)
-    `);
-        const insertLink = database.prepare(`
-      INSERT INTO links (from_document_id, to_title, to_title_key, to_document_id, weight, priority)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `);
-        const transaction = database.transaction(() => {
-            documents.forEach(({ document, chunks, links }) => {
-                insertDocument.run(document.id, document.agentId, document.title, document.path, document.content, JSON.stringify(document.tags), JSON.stringify(document.frontmatter), document.createdAt, document.updatedAt);
-                chunks.forEach((chunk) => {
-                    insertChunk.run(chunk.id, chunk.documentId, chunk.ordinal, chunk.content, chunk.tokenCount, chunk.embeddingProvider, JSON.stringify(chunk.embedding));
-                    insertChunkFts.run(chunk.id, chunk.documentId, document.agentId, document.title, chunk.content);
-                    createEmbeddingBuckets(chunk.embedding).forEach((bucket) => insertEmbeddingBucket.run(bucket, chunk.id));
-                });
-            });
-            documents.forEach(({ links }) => {
-                links.forEach((link) => {
-                    insertLink.run(link.fromDocumentId, link.toTitle, toTitleKey(link.toTitle), link.toDocumentId, link.weight, link.priority);
-                });
-            });
-        });
-        transaction();
-    }
-});

package/dist/infrastructure/sqlite/graph-reader.js

@@ -1,267 +0,0 @@
-import { sanitizeAgentId } from '../../domain/agents.js';
-const toGraphLink = (row) => ({
-    agentId: row.agent_id,
-    fromTitle: row.from_title,
-    fromPath: row.from_path,
-    toTitle: row.to_title,
-    toPath: row.to_path,
-    weight: row.weight,
-    priority: row.priority
-});
-const normalizeAgentFilter = (agentId) => agentId ? sanitizeAgentId(agentId) : undefined;
-const toTitleKey = (title) => title.toLowerCase();
-const toFtsQuery = (query) => query
-    .toLowerCase()
-    .match(/[\p{L}\p{N}_-]+/gu)
-    ?.map((term) => `"${term.replaceAll('"', '""')}"*`)
-    .join(' OR ') ?? '';
-export const createGraphReader = (database) => (() => {
-    const listLinksStatement = database.prepare(`
-      SELECT
-        source.agent_id AS agent_id,
-        source.title AS from_title,
-        source.path AS from_path,
-        COALESCE(target.title, links.to_title) AS to_title,
-        target.path AS to_path,
-        links.weight AS weight,
-        links.priority AS priority
-      FROM links
-      JOIN documents source ON source.id = links.from_document_id
-      LEFT JOIN documents target ON target.id = links.to_document_id
-      ORDER BY source.title, links.weight DESC, to_title
-    `);
-    const listLinksByAgentStatement = database.prepare(`
-      SELECT
-        source.agent_id AS agent_id,
-        source.title AS from_title,
-        source.path AS from_path,
-        COALESCE(target.title, links.to_title) AS to_title,
-        target.path AS to_path,
-        links.weight AS weight,
-        links.priority AS priority
-      FROM links
-      JOIN documents source ON source.id = links.from_document_id
-      LEFT JOIN documents target ON target.id = links.to_document_id
-      WHERE source.agent_id = ?
-      ORDER BY source.title, links.weight DESC, to_title
-    `);
-    const listBacklinksStatement = database.prepare(`
-      SELECT
-        source.agent_id AS agent_id,
-        source.title AS from_title,
-        source.path AS from_path,
-        COALESCE(target.title, links.to_title) AS to_title,
-        target.path AS to_path,
-        links.weight AS weight,
-        links.priority AS priority
-      FROM links
-      JOIN documents source ON source.id = links.from_document_id
-      LEFT JOIN documents target ON target.id = links.to_document_id
-      WHERE links.to_title_key = ?
-      ORDER BY links.weight DESC, source.title
-    `);
-    const listBacklinksByAgentStatement = database.prepare(`
-      SELECT
-        source.agent_id AS agent_id,
-        source.title AS from_title,
-        source.path AS from_path,
-        COALESCE(target.title, links.to_title) AS to_title,
-        target.path AS to_path,
-        links.weight AS weight,
-        links.priority AS priority
-      FROM links
-      JOIN documents source ON source.id = links.from_document_id
-      LEFT JOIN documents target ON target.id = links.to_document_id
-      WHERE links.to_title_key = ? AND source.agent_id = ?
-      ORDER BY links.weight DESC, source.title
-    `);
-    const graphNodesStatement = database.prepare(`
-      SELECT id, agent_id, title, path, content, tags_json
-      FROM documents
-      ORDER BY title
-    `);
-    const graphNodesByAgentStatement = database.prepare(`
-      SELECT id, agent_id, title, path, content, tags_json
-      FROM documents
-      WHERE agent_id = ?
-      ORDER BY title
-    `);
-    const graphSummaryNodesStatement = database.prepare(`
-      SELECT id, agent_id, title, path, '' AS content, tags_json
-      FROM documents
-      ORDER BY title
-    `);
-    const graphSummaryNodesByAgentStatement = database.prepare(`
-      SELECT id, agent_id, title, path, '' AS content, tags_json
-      FROM documents
-      WHERE agent_id = ?
-      ORDER BY title
-    `);
-    const graphEdgesStatement = database.prepare(`
-      SELECT
-        links.from_document_id AS source,
-        links.to_document_id AS target,
-        links.to_title AS target_title,
-        links.weight AS weight,
-        links.priority AS priority
-      FROM links
-      JOIN documents source ON source.id = links.from_document_id
-      ORDER BY links.from_document_id, links.weight DESC, links.to_title
-    `);
-    const graphEdgesByAgentStatement = database.prepare(`
-      SELECT
-        links.from_document_id AS source,
-        links.to_document_id AS target,
-        links.to_title AS target_title,
-        links.weight AS weight,
-        links.priority AS priority
-      FROM links
-      JOIN documents source ON source.id = links.from_document_id
-      WHERE source.agent_id = ?
-      ORDER BY links.from_document_id, links.weight DESC, links.to_title
-    `);
-    const graphNodeByIdStatement = database.prepare(`
-      SELECT id, agent_id, title, path, content, tags_json
-      FROM documents
-      WHERE id = ?
-    `);
-    const graphNodeByIdAndAgentStatement = database.prepare(`
-      SELECT id, agent_id, title, path, content, tags_json
-      FROM documents
-      WHERE id = ? AND agent_id = ?
-    `);
-    const filterNodeIdsMetadataStatement = database.prepare(`
-      SELECT id
-      FROM documents
-      WHERE lower(title) LIKE ?
-         OR lower(path) LIKE ?
-         OR lower(tags_json) LIKE ?
-      ORDER BY title
-      LIMIT ?
-    `);
-    const filterNodeIdsMetadataByAgentStatement = database.prepare(`
-      SELECT id
-      FROM documents
-      WHERE agent_id = ?
-        AND (
-          lower(title) LIKE ?
-          OR lower(path) LIKE ?
-          OR lower(tags_json) LIKE ?
-        )
-      ORDER BY title
-      LIMIT ?
-    `);
-    const filterNodeIdsContentStatement = database.prepare(`
-      SELECT DISTINCT documents.id AS id
-      FROM chunks_fts
-      JOIN documents ON documents.id = chunks_fts.document_id
-      WHERE chunks_fts MATCH ?
-      LIMIT ?
-    `);
-    const filterNodeIdsContentByAgentStatement = database.prepare(`
-      SELECT DISTINCT documents.id AS id
-      FROM chunks_fts
-      JOIN documents ON documents.id = chunks_fts.document_id
-      WHERE chunks_fts MATCH ?
-        AND documents.agent_id = ?
-      LIMIT ?
-    `);
-    const listAgentsStatement = database.prepare(`
-      SELECT agent_id AS id, count(*) AS document_count
-      FROM documents
-      GROUP BY agent_id
-      ORDER BY agent_id
-    `);
-    return {
-        listLinks: (agentId) => {
-            const normalizedAgentId = normalizeAgentFilter(agentId);
-            const rows = (normalizedAgentId
-                ? listLinksByAgentStatement.all(normalizedAgentId)
-                : listLinksStatement.all());
-            return rows.map(toGraphLink);
-        },
-        listBacklinks: (title, agentId) => {
-            const normalizedAgentId = normalizeAgentFilter(agentId);
-            const titleKey = toTitleKey(title);
-            const rows = (normalizedAgentId
-                ? listBacklinksByAgentStatement.all(titleKey, normalizedAgentId)
-                : listBacklinksStatement.all(titleKey));
-            return rows.map(toGraphLink);
-        },
-        getGraph: (agentId) => {
-            const normalizedAgentId = normalizeAgentFilter(agentId);
-            const nodeRows = (normalizedAgentId
-                ? graphNodesByAgentStatement.all(normalizedAgentId)
-                : graphNodesStatement.all());
-            const edgeRows = (normalizedAgentId
-                ? graphEdgesByAgentStatement.all(normalizedAgentId)
-                : graphEdgesStatement.all());
-            return {
-                nodes: nodeRows.map(toGraphNode),
-                edges: edgeRows.map(toGraphEdge)
-            };
-        },
-        getGraphSummary: (agentId) => {
-            const normalizedAgentId = normalizeAgentFilter(agentId);
-            const nodeRows = (normalizedAgentId
-                ? graphSummaryNodesByAgentStatement.all(normalizedAgentId)
-                : graphSummaryNodesStatement.all());
-            const edgeRows = (normalizedAgentId
-                ? graphEdgesByAgentStatement.all(normalizedAgentId)
-                : graphEdgesStatement.all());
-            return {
-                nodes: nodeRows.map(toGraphNode),
-                edges: edgeRows.map(toGraphEdge)
-            };
-        },
-        getGraphNode: (id, agentId) => {
-            const normalizedAgentId = normalizeAgentFilter(agentId);
-            const row = (normalizedAgentId
-                ? graphNodeByIdAndAgentStatement.get(id, normalizedAgentId)
-                : graphNodeByIdStatement.get(id));
-            return row ? toGraphNode(row) : undefined;
-        },
-        searchGraphNodeIds: (query, limit, agentId) => {
-            const normalizedQuery = query.trim().toLowerCase();
-            if (!normalizedQuery || limit <= 0) {
-                return [];
-            }
-            const normalizedAgentId = normalizeAgentFilter(agentId);
-            const likeQuery = `%${normalizedQuery}%`;
-            const metadataRows = (normalizedAgentId
-                ? filterNodeIdsMetadataByAgentStatement.all(normalizedAgentId, likeQuery, likeQuery, likeQuery, limit)
-                : filterNodeIdsMetadataStatement.all(likeQuery, likeQuery, likeQuery, limit));
-            const ids = new Set(metadataRows.map((row) => row.id));
-            const remainingLimit = Math.max(limit - ids.size, 0);
-            if (remainingLimit > 0) {
-                const ftsQuery = toFtsQuery(normalizedQuery);
-                if (ftsQuery) {
-                    const contentRows = (normalizedAgentId
-                        ? filterNodeIdsContentByAgentStatement.all(ftsQuery, normalizedAgentId, remainingLimit)
-                        : filterNodeIdsContentStatement.all(ftsQuery, remainingLimit));
-                    contentRows.forEach((row) => ids.add(row.id));
-                }
-            }
-            return Array.from(ids).slice(0, limit);
-        },
-        listAgents: () => listAgentsStatement.all().map((row) => ({
-            id: row.id,
-            documentCount: row.document_count
-        }))
-    };
-})();
-const toGraphNode = (row) => ({
-    id: row.id,
-    agentId: row.agent_id,
-    title: row.title,
-    path: row.path,
-    content: row.content,
-    tags: JSON.parse(row.tags_json)
-});
-const toGraphEdge = (row) => ({
-    source: row.source,
-    target: row.target,
-    targetTitle: row.target_title,
-    weight: row.weight,
-    priority: row.priority
-});

package/dist/infrastructure/sqlite/recovery.js

@@ -1,163 +0,0 @@
-import Database from 'better-sqlite3';
-import { copyFileSync, existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
-import { basename, dirname, join } from 'node:path';
-const sqliteCorruptionHints = [
-    'database disk image is malformed',
-    'file is not a database',
-    'database is corrupted',
-    'malformed database schema',
-    'sqlite quick_check failed'
-];
-const maxSnapshotFiles = 24;
-const normalizeMessage = (error) => error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
-const isSqliteCorruptionError = (error) => sqliteCorruptionHints.some((hint) => normalizeMessage(error).includes(hint));
-const safeUnlink = (path) => {
-    if (!existsSync(path)) {
-        return;
-    }
-    try {
-        unlinkSync(path);
-    }
-    catch {
-        // Ignore best-effort cleanup failures.
-    }
-};
-const clearSidecars = (databasePath) => {
-    safeUnlink(`${databasePath}-wal`);
-    safeUnlink(`${databasePath}-shm`);
-};
-const assertQuickCheck = (database) => {
-    const rows = database.prepare('PRAGMA quick_check').all();
-    const first = rows[0]?.quick_check?.toLowerCase() ?? 'ok';
-    if (first !== 'ok') {
-        throw new Error(`sqlite quick_check failed: ${first}`);
-    }
-};
-const archiveCorruptedDatabase = (databasePath) => {
-    if (!existsSync(databasePath)) {
-        return;
-    }
-    const archivedPath = `${databasePath}.corrupt-${Date.now()}`;
-    renameSync(databasePath, archivedPath);
-};
-const snapshotDirectoryPath = (backupPath) => join(dirname(backupPath), `${basename(backupPath)}.snapshots`);
-const snapshotFileName = () => `snapshot-${new Date().toISOString().replace(/[:.]/g, '-')}.db`;
-const cleanupSnapshotOverflow = (backupPath) => {
-    const directory = snapshotDirectoryPath(backupPath);
-    if (!existsSync(directory)) {
-        return;
-    }
-    const snapshots = readdirSync(directory)
-        .filter((name) => name.endsWith('.db'))
-        .sort((left, right) => right.localeCompare(left));
-    snapshots.slice(maxSnapshotFiles).forEach((name) => {
-        rmSync(join(directory, name), { force: true });
-    });
-};
-const openCheckedDatabase = (databasePath) => {
-    const database = new Database(databasePath);
-    try {
-        assertQuickCheck(database);
-    }
-    catch (error) {
-        database.close();
-        throw error;
-    }
-    return database;
-};
-const isValidDatabaseSnapshot = (path) => {
-    if (!existsSync(path)) {
-        return false;
-    }
-    try {
-        const size = statSync(path).size;
-        if (size <= 0) {
-            return false;
-        }
-    }
-    catch {
-        return false;
-    }
-    try {
-        const database = new Database(path);
-        try {
-            assertQuickCheck(database);
-            return true;
-        }
-        finally {
-            database.close();
-        }
-    }
-    catch {
-        return false;
-    }
-};
-const candidateBackupFiles = (backupPath) => {
-    const directory = snapshotDirectoryPath(backupPath);
-    const snapshots = existsSync(directory)
-        ? readdirSync(directory)
-            .filter((name) => name.endsWith('.db'))
-            .sort((left, right) => right.localeCompare(left))
-            .map((name) => join(directory, name))
-        : [];
-    return [backupPath, ...snapshots];
-};
-const ensureSnapshotDirectory = (backupPath) => {
-    mkdirSync(snapshotDirectoryPath(backupPath), { recursive: true, mode: 0o700 });
-};
-const writeRecoveryMarker = (backupPath, restoredFrom) => {
-    const markerPath = join(dirname(backupPath), 'recovery-last-restore.json');
-    const payload = {
-        restoredAt: new Date().toISOString(),
-        restoredFrom
-    };
-    writeFileSync(markerPath, `${JSON.stringify(payload, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
-};
-const restoreFromBackupOrReset = (databasePath, backupPath) => {
-    clearSidecars(databasePath);
-    archiveCorruptedDatabase(databasePath);
-    for (const candidate of candidateBackupFiles(backupPath)) {
-        if (!isValidDatabaseSnapshot(candidate)) {
-            continue;
-        }
-        copyFileSync(candidate, databasePath);
-        clearSidecars(databasePath);
-        if (isValidDatabaseSnapshot(databasePath)) {
-            writeRecoveryMarker(backupPath, candidate);
-            return;
-        }
-    }
-    rmSync(databasePath, { force: true });
-};
-export const createRecoverySnapshot = (database, backupPath) => {
-    const backupDirectory = dirname(backupPath);
-    const tempBackupPath = `${backupPath}.tmp`;
-    const snapshotDirectory = snapshotDirectoryPath(backupPath);
-    const snapshotPath = join(snapshotDirectory, snapshotFileName());
-    mkdirSync(backupDirectory, { recursive: true });
-    ensureSnapshotDirectory(backupPath);
-    rmSync(tempBackupPath, { force: true });
-    try {
-        database.pragma('wal_checkpoint(PASSIVE)');
-    }
-    catch {
-        // Checkpoint is best-effort.
-    }
-    database.prepare('VACUUM INTO ?').run(tempBackupPath);
-    renameSync(tempBackupPath, backupPath);
-    copyFileSync(backupPath, snapshotPath);
-    cleanupSnapshotOverflow(backupPath);
-};
-export const openDatabaseWithRecovery = (databasePath, backupPath) => {
-    mkdirSync(dirname(databasePath), { recursive: true });
-    try {
-        return openCheckedDatabase(databasePath);
-    }
-    catch (error) {
-        if (!isSqliteCorruptionError(error)) {
-            throw error;
-        }
-        restoreFromBackupOrReset(databasePath, backupPath);
-        return openCheckedDatabase(databasePath);
-    }
-};

package/dist/infrastructure/sqlite/schema.js

@@ -1,114 +0,0 @@
-const schemaVersion = 6;
-const requiredTableColumns = {
-    documents: ['id', 'agent_id', 'title', 'path', 'content', 'tags_json', 'frontmatter_json', 'created_at', 'updated_at'],
-    chunks: ['id', 'document_id', 'ordinal', 'content', 'token_count', 'embedding_provider', 'embedding_json'],
-    links: ['from_document_id', 'to_title', 'to_title_key', 'to_document_id', 'weight', 'priority'],
-    chunks_fts: ['chunk_id', 'document_id', 'agent_id', 'title', 'content']
-};
-const getStoredSchemaVersion = (database) => {
-    const hasMetadata = database
-        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'metadata'")
-        .get();
-    if (!hasMetadata) {
-        return 0;
-    }
-    const row = database.prepare("SELECT value FROM metadata WHERE key = 'schema_version'").get();
-    return Number.parseInt(row?.value ?? '0', 10);
-};
-const dropDerivedSchema = (database) => {
-    database.exec(`
-    DROP TABLE IF EXISTS embedding_buckets;
-    DROP TABLE IF EXISTS chunks_fts;
-    DROP TABLE IF EXISTS links;
-    DROP TABLE IF EXISTS chunks;
-    DROP TABLE IF EXISTS documents;
-  `);
-};
-const getTableColumns = (database, tableName) => {
-    const rows = database.prepare(`SELECT name FROM pragma_table_info(?)`).all(tableName);
-    return rows.map((row) => row.name);
-};
-const hasCompatibleSchemaShape = (database) => Object.entries(requiredTableColumns).every(([tableName, requiredColumns]) => {
-    const columns = getTableColumns(database, tableName);
-    return columns.length === 0 || requiredColumns.every((column) => columns.includes(column));
-});
-export const createSchema = (database) => {
-    const storedSchemaVersion = getStoredSchemaVersion(database);
-    if ((storedSchemaVersion > 0 && storedSchemaVersion < schemaVersion) || !hasCompatibleSchemaShape(database)) {
-        dropDerivedSchema(database);
-    }
-    database.exec(`
-    CREATE TABLE IF NOT EXISTS metadata (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS documents (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      title TEXT NOT NULL,
-      path TEXT NOT NULL UNIQUE,
-      content TEXT NOT NULL,
-      tags_json TEXT NOT NULL,
-      frontmatter_json TEXT NOT NULL,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS chunks (
-      id TEXT PRIMARY KEY,
-      document_id TEXT NOT NULL,
-      ordinal INTEGER NOT NULL,
-      content TEXT NOT NULL,
-      token_count INTEGER NOT NULL,
-      embedding_provider TEXT NOT NULL,
-      embedding_json TEXT NOT NULL,
-      FOREIGN KEY (document_id) REFERENCES documents(id) ON DELETE CASCADE
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_documents_agent_title ON documents(agent_id, title);
-    CREATE INDEX IF NOT EXISTS idx_documents_agent_id ON documents(agent_id, id);
-    CREATE INDEX IF NOT EXISTS idx_chunks_document_ordinal ON chunks(document_id, ordinal);
-    CREATE INDEX IF NOT EXISTS idx_chunks_token_count ON chunks(token_count);
-
-    CREATE TABLE IF NOT EXISTS embedding_buckets (
-      bucket TEXT NOT NULL,
-      chunk_id TEXT NOT NULL,
-      PRIMARY KEY (bucket, chunk_id),
-      FOREIGN KEY (chunk_id) REFERENCES chunks(id) ON DELETE CASCADE
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_embedding_buckets_bucket ON embedding_buckets(bucket);
-
-    CREATE TABLE IF NOT EXISTS links (
-      from_document_id TEXT NOT NULL,
-      to_title TEXT NOT NULL,
-      to_title_key TEXT NOT NULL,
-      to_document_id TEXT,
-      weight INTEGER NOT NULL,
-      priority TEXT NOT NULL,
-      PRIMARY KEY (from_document_id, to_title_key),
-      FOREIGN KEY (from_document_id) REFERENCES documents(id) ON DELETE CASCADE,
-      FOREIGN KEY (to_document_id) REFERENCES documents(id) ON DELETE SET NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_links_to_document_id ON links(to_document_id);
-    CREATE INDEX IF NOT EXISTS idx_links_to_title_key ON links(to_title_key);
-    CREATE INDEX IF NOT EXISTS idx_links_source_weight ON links(from_document_id, weight DESC, to_title);
-
-    CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
-      chunk_id UNINDEXED,
-      document_id UNINDEXED,
-      agent_id UNINDEXED,
-      title,
-      content
-    );
-  `);
-    database
-        .prepare(`
-      INSERT INTO metadata (key, value)
-      VALUES ('schema_version', ?)
-      ON CONFLICT(key) DO UPDATE SET value = excluded.value
-    `)
-        .run(String(schemaVersion));
-};