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

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()
-    };
-};