@andespindola/brainlink 0.1.0-beta.12 → 0.1.0-beta.120

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,83 +0,0 @@
-import Database from 'better-sqlite3';
-import { copyFileSync, existsSync, mkdirSync, renameSync, rmSync, unlinkSync } from 'node:fs';
-import { dirname } 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 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 restoreFromBackupOrReset = (databasePath, backupPath) => {
-    clearSidecars(databasePath);
-    archiveCorruptedDatabase(databasePath);
-    if (existsSync(backupPath)) {
-        copyFileSync(backupPath, databasePath);
-        clearSidecars(databasePath);
-        return;
-    }
-    rmSync(databasePath, { force: true });
-};
-const openCheckedDatabase = (databasePath) => {
-    const database = new Database(databasePath);
-    try {
-        assertQuickCheck(database);
-    }
-    catch (error) {
-        database.close();
-        throw error;
-    }
-    return database;
-};
-export const createRecoverySnapshot = (database, backupPath) => {
-    const backupDirectory = dirname(backupPath);
-    const tempBackupPath = `${backupPath}.tmp`;
-    mkdirSync(backupDirectory, { recursive: true });
-    rmSync(tempBackupPath, { force: true });
-    database.prepare('VACUUM INTO ?').run(tempBackupPath);
-    renameSync(tempBackupPath, 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));
-};

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

@@ -1,188 +0,0 @@
-import { sanitizeAgentId } from '../../domain/agents.js';
-import { cosineSimilarity, createEmbeddingBuckets } from '../../domain/embeddings.js';
-const toFtsQuery = (query) => query
-    .toLowerCase()
-    .match(/[\p{L}\p{N}_-]+/gu)
-    ?.map((term) => `"${term.replaceAll('"', '""')}"*`)
-    .join(' OR ') ?? '';
-const normalizeAgentFilter = (agentId) => agentId ? sanitizeAgentId(agentId) : undefined;
-const parseJsonArray = (value) => {
-    if (!value) {
-        return [];
-    }
-    try {
-        const parsed = JSON.parse(value);
-        return Array.isArray(parsed) ? parsed : [];
-    }
-    catch {
-        return [];
-    }
-};
-const toTextScore = (index, total) => total === 0 ? 0 : 1 - index / (total + 1);
-const toSearchResult = (row, score, textScore, semanticScore, searchMode) => ({
-    documentId: row.document_id,
-    agentId: row.agent_id,
-    title: row.title,
-    path: row.path,
-    chunkId: row.chunk_id,
-    content: row.content,
-    score,
-    textScore,
-    semanticScore,
-    searchMode,
-    tags: parseJsonArray(row.tags_json).filter((value) => typeof value === 'string')
-});
-const sortByScore = (results) => [...results].sort((left, right) => right.score - left.score || left.title.localeCompare(right.title));
-const mergeHybridResults = (ftsResults, semanticResults, limit) => {
-    const rows = new Map();
-    [...semanticResults, ...ftsResults].forEach((result) => {
-        const current = rows.get(result.chunkId);
-        const textScore = Math.max(current?.textScore ?? 0, result.textScore);
-        const semanticScore = Math.max(current?.semanticScore ?? 0, result.semanticScore);
-        const score = textScore * 0.62 + semanticScore * 0.38;
-        rows.set(result.chunkId, {
-            ...result,
-            score,
-            textScore,
-            semanticScore,
-            searchMode: 'hybrid'
-        });
-    });
-    return sortByScore(Array.from(rows.values())).slice(0, limit);
-};
-const placeholders = (count) => Array.from({ length: count }, () => '?').join(', ');
-const readBucketedSemanticRows = (database, normalizedAgentId, queryEmbedding, limit) => {
-    const buckets = createEmbeddingBuckets(queryEmbedding);
-    if (buckets.length === 0) {
-        return [];
-    }
-    const agentFilter = normalizedAgentId ? 'AND documents.agent_id = ?' : '';
-    const params = normalizedAgentId ? [...buckets, normalizedAgentId, limit] : [...buckets, limit];
-    return database
-        .prepare(`
-      SELECT
-        documents.id AS document_id,
-        documents.agent_id AS agent_id,
-        documents.title AS title,
-        documents.path AS path,
-        chunks.id AS chunk_id,
-        chunks.content AS content,
-        documents.tags_json AS tags_json,
-        chunks.embedding_json AS embedding_json,
-        count(*) AS score
-      FROM embedding_buckets
-      JOIN chunks ON chunks.id = embedding_buckets.chunk_id
-      JOIN documents ON documents.id = chunks.document_id
-      WHERE embedding_buckets.bucket IN (${placeholders(buckets.length)})
-      ${agentFilter}
-      GROUP BY chunks.id
-      ORDER BY score DESC, chunks.token_count ASC, documents.title ASC
-      LIMIT ?
-    `)
-        .all(...params);
-};
-export const createSearchReader = (database) => (() => {
-    const ftsRowsStatement = database.prepare(`
-      SELECT
-        documents.id AS document_id,
-        documents.agent_id AS agent_id,
-        documents.title AS title,
-        documents.path AS path,
-        chunks_fts.chunk_id AS chunk_id,
-        chunks_fts.content AS content,
-        bm25(chunks_fts) * -1 AS score,
-        documents.tags_json AS tags_json
-      FROM chunks_fts
-      JOIN documents ON documents.id = chunks_fts.document_id
-      WHERE chunks_fts MATCH ?
-      ORDER BY bm25(chunks_fts)
-      LIMIT ?
-    `);
-    const ftsRowsByAgentStatement = database.prepare(`
-      SELECT
-        documents.id AS document_id,
-        documents.agent_id AS agent_id,
-        documents.title AS title,
-        documents.path AS path,
-        chunks_fts.chunk_id AS chunk_id,
-        chunks_fts.content AS content,
-        bm25(chunks_fts) * -1 AS score,
-        documents.tags_json AS tags_json
-      FROM chunks_fts
-      JOIN documents ON documents.id = chunks_fts.document_id
-      WHERE chunks_fts MATCH ?
-        AND documents.agent_id = ?
-      ORDER BY bm25(chunks_fts)
-      LIMIT ?
-    `);
-    const semanticRowsStatement = database.prepare(`
-      SELECT
-        documents.id AS document_id,
-        documents.agent_id AS agent_id,
-        documents.title AS title,
-        documents.path AS path,
-        chunks.id AS chunk_id,
-        chunks.content AS content,
-        documents.tags_json AS tags_json,
-        chunks.embedding_json AS embedding_json
-      FROM chunks
-      JOIN documents ON documents.id = chunks.document_id
-      ORDER BY chunks.token_count ASC, documents.title ASC
-      LIMIT ?
-    `);
-    const semanticRowsByAgentStatement = database.prepare(`
-      SELECT
-        documents.id AS document_id,
-        documents.agent_id AS agent_id,
-        documents.title AS title,
-        documents.path AS path,
-        chunks.id AS chunk_id,
-        chunks.content AS content,
-        documents.tags_json AS tags_json,
-        chunks.embedding_json AS embedding_json
-      FROM chunks
-      JOIN documents ON documents.id = chunks.document_id
-      WHERE documents.agent_id = ?
-      ORDER BY chunks.token_count ASC, documents.title ASC
-      LIMIT ?
-    `);
-    const readAllSemanticRowsForLimit = (normalizedAgentId, limit) => (normalizedAgentId
-        ? semanticRowsByAgentStatement.all(normalizedAgentId, limit)
-        : semanticRowsStatement.all(limit));
-    const readSemanticRows = (normalizedAgentId, queryEmbedding, limit) => {
-        const candidateLimit = Math.min(Math.max(limit * 96, 768), 12_000);
-        const bucketedRows = readBucketedSemanticRows(database, normalizedAgentId, queryEmbedding, candidateLimit);
-        return bucketedRows.length > 0 ? bucketedRows : readAllSemanticRowsForLimit(normalizedAgentId, candidateLimit);
-    };
-    return {
-        search: (query, limit, agentId, mode = 'hybrid', queryEmbedding = []) => {
-            const normalizedQuery = query.trim();
-            if (!normalizedQuery || limit <= 0) {
-                return [];
-            }
-            const normalizedAgentId = normalizeAgentFilter(agentId);
-            const ftsQuery = toFtsQuery(query);
-            const expandedLimit = Math.max(limit * 4, 24);
-            const ftsRows = mode === 'semantic' || !ftsQuery
-                ? []
-                : (normalizedAgentId
-                    ? ftsRowsByAgentStatement.all(ftsQuery, normalizedAgentId, expandedLimit)
-                    : ftsRowsStatement.all(ftsQuery, expandedLimit));
-            const ftsResults = ftsRows.map((row, index) => toSearchResult(row, toTextScore(index, ftsRows.length), toTextScore(index, ftsRows.length), 0, 'fts'));
-            const semanticRows = mode === 'fts' || queryEmbedding.length === 0 ? [] : readSemanticRows(normalizedAgentId, queryEmbedding, expandedLimit);
-            const semanticResults = sortByScore(semanticRows
-                .map((row) => {
-                const semanticScore = Math.max(0, cosineSimilarity(queryEmbedding, parseJsonArray(row.embedding_json).filter((value) => typeof value === 'number')));
-                return toSearchResult(row, semanticScore, 0, semanticScore, 'semantic');
-            })
-                .filter((result) => result.semanticScore > 0)).slice(0, expandedLimit);
-            if (mode === 'fts') {
-                return ftsResults.slice(0, limit);
-            }
-            if (mode === 'semantic') {
-                return semanticResults.slice(0, limit);
-            }
-            return mergeHybridResults(ftsResults, semanticResults, limit);
-        }
-    };
-})();

package/dist/infrastructure/sqlite/types.js

@@ -1 +0,0 @@
-export {};

package/dist/infrastructure/sqlite-index.js

@@ -1,38 +0,0 @@
-import { chmodSync } from 'node:fs';
-import { join } from 'node:path';
-import { createIndexWriter } from './sqlite/document-writer.js';
-import { createGraphReader } from './sqlite/graph-reader.js';
-import { createRecoverySnapshot, openDatabaseWithRecovery } from './sqlite/recovery.js';
-import { createSchema } from './sqlite/schema.js';
-import { createSearchReader } from './sqlite/search-reader.js';
-export const openSqliteIndex = (vaultPath) => {
-    const databasePath = join(vaultPath, '.brainlink', 'brainlink.db');
-    const backupPath = join(vaultPath, '.brainlink', 'brainlink.db.backup');
-    const database = openDatabaseWithRecovery(databasePath, backupPath);
-    const indexWriter = createIndexWriter(database);
-    chmodSync(databasePath, 0o600);
-    database.exec(`
-    PRAGMA foreign_keys = ON;
-    PRAGMA journal_mode = WAL;
-    PRAGMA synchronous = NORMAL;
-    PRAGMA temp_store = MEMORY;
-    PRAGMA busy_timeout = 5000;
-    PRAGMA cache_size = -20000;
-  `);
-    createSchema(database);
-    return {
-        reset: () => indexWriter.reset(),
-        saveDocuments: (documents) => {
-            indexWriter.saveDocuments(documents);
-            try {
-                createRecoverySnapshot(database, backupPath);
-            }
-            catch {
-                // Snapshot creation is best-effort. Indexing success should not fail because of backup I/O.
-            }
-        },
-        ...createSearchReader(database),
-        ...createGraphReader(database),
-        close: () => database.close()
-    };
-};