@andespindola/brainlink 0.1.0-beta.3 → 0.1.0-beta.30

package/dist/infrastructure/config.js

@@ -1,7 +1,8 @@
-import { readFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
 import { sanitizeAgentId } from '../domain/agents.js';
-import { getDefaultVaultPath } from './paths.js';
+import { getBrainlinkHomePath, getDefaultVaultPath } from './paths.js';
 export const defaultBrainlinkConfig = {
     vault: getDefaultVaultPath(),
     host: '127.0.0.1',
@@ -13,15 +14,61 @@ export const defaultBrainlinkConfig = {
     defaultContextTokens: 2000,
     embeddingProvider: 'local',
     defaultSearchMode: 'hybrid',
-    chunkSize: 1200
+    chunkSize: 1200,
+    agentProfiles: {}
 };
 const configFilenames = ['brainlink.config.json', '.brainlink.json'];
+const localConfigFilename = 'brainlink.config.json';
+const globalConfigFilename = 'brainlink.config.json';
+const globalConfigDirectoryMode = 0o700;
+const globalConfigFileMode = 0o600;
+const safeCwd = () => {
+    try {
+        return process.cwd();
+    }
+    catch {
+        return homedir();
+    }
+};
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const embeddingProviders = new Set(['none', 'local']);
 const searchModes = new Set(['fts', 'semantic', 'hybrid']);
 const sanitizeEmbeddingProvider = (value) => typeof value === 'string' && embeddingProviders.has(value) ? value : defaultBrainlinkConfig.embeddingProvider;
 export const sanitizeSearchMode = (value, fallback = defaultBrainlinkConfig.defaultSearchMode) => typeof value === 'string' && searchModes.has(value) ? value : fallback;
 const sanitizeAllowedVaults = (value) => Array.isArray(value) ? value.filter((item) => typeof item === 'string' && item.trim().length > 0) : [];
+const sanitizePositiveNumber = (value) => typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : undefined;
+const sanitizeAgentProfile = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const defaultSearchLimit = sanitizePositiveNumber(value.defaultSearchLimit);
+    const defaultContextTokens = sanitizePositiveNumber(value.defaultContextTokens);
+    const defaultSearchMode = typeof value.defaultSearchMode === 'string' && searchModes.has(value.defaultSearchMode)
+        ? value.defaultSearchMode
+        : undefined;
+    const profile = {
+        ...(defaultSearchLimit ? { defaultSearchLimit } : {}),
+        ...(defaultContextTokens ? { defaultContextTokens } : {}),
+        ...(defaultSearchMode ? { defaultSearchMode } : {})
+    };
+    return Object.keys(profile).length > 0 ? profile : null;
+};
+const sanitizeAgentProfiles = (value) => {
+    if (!isRecord(value)) {
+        return {};
+    }
+    return Object.entries(value).reduce((state, [key, profile]) => {
+        const normalizedKey = key === '*' ? '*' : sanitizeAgentId(key);
+        const sanitizedProfile = sanitizeAgentProfile(profile);
+        if (!sanitizedProfile || normalizedKey.length === 0) {
+            return state;
+        }
+        return {
+            ...state,
+            [normalizedKey]: sanitizedProfile
+        };
+    }, {});
+};
 const readAllowedVaultsFromEnv = () => (process.env.BRAINLINK_ALLOWED_VAULTS ?? '')
     .split(',')
     .map((value) => value.trim())
@@ -39,6 +86,34 @@ const readJsonConfig = async (path) => {
         throw error;
     }
 };
+export const getGlobalConfigPath = () => join(getBrainlinkHomePath(), globalConfigFilename);
+export const getLocalConfigPath = (cwd = safeCwd()) => resolve(cwd, localConfigFilename);
+export const resolveConfigPath = (scope, cwd = safeCwd()) => scope === 'global' ? getGlobalConfigPath() : getLocalConfigPath(cwd);
+export const loadRawConfig = async (scope, cwd = safeCwd()) => readJsonConfig(resolveConfigPath(scope, cwd));
+export const loadLegacyLocalRawConfig = async (cwd = safeCwd()) => readJsonConfig(resolve(cwd, '.brainlink.json'));
+export const detectVaultConfigSource = async (cwd = safeCwd()) => {
+    const [globalConfig, localConfig, legacyLocalConfig] = await Promise.all([
+        loadRawConfig('global', cwd),
+        loadRawConfig('local', cwd),
+        loadLegacyLocalRawConfig(cwd)
+    ]);
+    if (typeof legacyLocalConfig.vault === 'string' && legacyLocalConfig.vault.trim().length > 0) {
+        return 'local-legacy';
+    }
+    if (typeof localConfig.vault === 'string' && localConfig.vault.trim().length > 0) {
+        return 'local';
+    }
+    if (typeof globalConfig.vault === 'string' && globalConfig.vault.trim().length > 0) {
+        return 'global';
+    }
+    return 'default';
+};
+export const writeRawConfig = async (scope, value, cwd = safeCwd()) => {
+    const path = resolveConfigPath(scope, cwd);
+    await mkdir(dirname(path), { recursive: true, mode: globalConfigDirectoryMode });
+    await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode: globalConfigFileMode });
+    return path;
+};
 const sanitizeConfig = (value) => ({
     ...defaultBrainlinkConfig,
     ...value,
@@ -56,11 +131,22 @@ const sanitizeConfig = (value) => ({
     allowedVaults: [...sanitizeAllowedVaults(value.allowedVaults), ...readAllowedVaultsFromEnv()],
     chunkSize: typeof value.chunkSize === 'number' && value.chunkSize > 0 ? value.chunkSize : defaultBrainlinkConfig.chunkSize,
     embeddingProvider: sanitizeEmbeddingProvider(value.embeddingProvider),
-    defaultSearchMode: sanitizeSearchMode(value.defaultSearchMode)
+    defaultSearchMode: sanitizeSearchMode(value.defaultSearchMode),
+    agentProfiles: sanitizeAgentProfiles(value.agentProfiles)
 });
-export const loadBrainlinkConfig = async (cwd = process.cwd()) => {
-    const configs = await Promise.all(configFilenames.map((filename) => readJsonConfig(resolve(cwd, filename))));
-    const merged = configs.reduce((state, config) => ({
+export const resolveAgentRuntimeDefaults = (config, agent) => {
+    const normalizedAgent = agent?.trim().length ? sanitizeAgentId(agent) : undefined;
+    const profile = (normalizedAgent ? config.agentProfiles[normalizedAgent] : undefined) ?? config.agentProfiles['*'];
+    return {
+        defaultSearchLimit: profile?.defaultSearchLimit ?? config.defaultSearchLimit,
+        defaultContextTokens: profile?.defaultContextTokens ?? config.defaultContextTokens,
+        defaultSearchMode: profile?.defaultSearchMode ?? config.defaultSearchMode
+    };
+};
+export const loadBrainlinkConfig = async (cwd = safeCwd()) => {
+    const globalConfig = await readJsonConfig(getGlobalConfigPath());
+    const localConfigs = await Promise.all(configFilenames.map((filename) => readJsonConfig(resolve(cwd, filename))));
+    const merged = [globalConfig, ...localConfigs].reduce((state, config) => ({
         ...state,
         ...config
     }), {});

package/dist/infrastructure/file-index.js

@@ -0,0 +1,294 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { cosineSimilarity } from '../domain/embeddings.js';
+const queryTokenPattern = /[\p{L}\p{N}_-]+/gu;
+const emptyIndex = () => ({
+    version: 1,
+    updatedAt: new Date().toISOString(),
+    documents: [],
+    chunks: [],
+    links: []
+});
+export const indexStoragePath = (vaultPath) => join(vaultPath, '.brainlink', 'index.json');
+const readIndex = async (vaultPath) => {
+    try {
+        const parsed = JSON.parse(await readFile(indexStoragePath(vaultPath), 'utf8'));
+        return {
+            version: 1,
+            updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : new Date().toISOString(),
+            documents: Array.isArray(parsed.documents) ? parsed.documents : [],
+            chunks: Array.isArray(parsed.chunks) ? parsed.chunks : [],
+            links: Array.isArray(parsed.links) ? parsed.links : []
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return emptyIndex();
+        }
+        return emptyIndex();
+    }
+};
+const writeIndex = async (vaultPath, index) => {
+    const target = indexStoragePath(vaultPath);
+    const temp = `${target}.tmp`;
+    await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+    await writeFile(temp, `${JSON.stringify(index)}\n`, { encoding: 'utf8', mode: 0o600 });
+    await rename(temp, target);
+};
+const normalizeToken = (value) => value
+    .normalize('NFKD')
+    .replace(/\p{Diacritic}/gu, '')
+    .toLowerCase();
+const tokenize = (query) => query
+    .match(queryTokenPattern)
+    ?.map(normalizeToken)
+    .filter((token) => token.length > 1) ?? [];
+const countOccurrences = (text, token) => {
+    let hits = 0;
+    let cursor = 0;
+    while (cursor < text.length) {
+        const index = text.indexOf(token, cursor);
+        if (index < 0) {
+            break;
+        }
+        hits += 1;
+        cursor = index + token.length;
+    }
+    return hits;
+};
+const textScore = (row, tokens) => {
+    if (tokens.length === 0) {
+        return 0;
+    }
+    const title = normalizeToken(row.title);
+    const path = normalizeToken(row.path);
+    const content = normalizeToken(row.content);
+    const tags = normalizeToken(row.tags.join(' '));
+    return tokens.reduce((score, token) => {
+        const titleHits = countOccurrences(title, token);
+        const tagHits = countOccurrences(tags, token);
+        const pathHits = countOccurrences(path, token);
+        const contentHits = countOccurrences(content, token);
+        return score + titleHits * 5 + tagHits * 4 + pathHits * 2 + Math.min(contentHits, 6);
+    }, 0);
+};
+const semanticScore = (row, queryEmbedding) => queryEmbedding.length > 0 && row.embedding.length > 0 ? cosineSimilarity(queryEmbedding, row.embedding) : 0;
+const toResult = (row, mode, text, semantic) => {
+    const score = mode === 'fts' ? text : mode === 'semantic' ? semantic : text + semantic * 8;
+    return {
+        documentId: row.documentId,
+        agentId: row.agentId,
+        title: row.title,
+        path: row.path,
+        chunkId: row.chunkId,
+        chunkOrdinal: row.chunkOrdinal,
+        content: row.content,
+        score,
+        textScore: text,
+        semanticScore: semantic,
+        searchMode: mode,
+        tags: row.tags
+    };
+};
+const toGraphLink = (link, documentsById) => {
+    const source = documentsById.get(link.fromDocumentId);
+    const target = link.toDocumentId ? documentsById.get(link.toDocumentId) : undefined;
+    return {
+        agentId: source?.agentId ?? 'shared',
+        fromTitle: source?.title ?? 'Unknown',
+        fromPath: source?.path ?? 'Unknown',
+        toTitle: target?.title ?? link.toTitle,
+        toPath: target?.path ?? null,
+        weight: link.weight,
+        priority: link.priority
+    };
+};
+export const openFileIndex = (vaultPath) => {
+    const load = async () => readIndex(vaultPath);
+    const persist = async (index) => writeIndex(vaultPath, index);
+    return {
+        reset: async () => {
+            await persist(emptyIndex());
+        },
+        saveDocuments: async (documents) => {
+            const chunks = documents.flatMap((document) => document.chunks);
+            const links = documents.flatMap((document) => document.links);
+            await persist({
+                version: 1,
+                updatedAt: new Date().toISOString(),
+                documents: documents.map((document) => document.document),
+                chunks,
+                links
+            });
+        },
+        search: async (query, limit, agentId, mode = 'hybrid', queryEmbedding = []) => {
+            const index = await load();
+            const documentsById = new Map(index.documents.map((document) => [document.id, document]));
+            const rows = index.chunks.flatMap((chunk) => {
+                const document = documentsById.get(chunk.documentId);
+                if (!document) {
+                    return [];
+                }
+                if (agentId && document.agentId !== agentId) {
+                    return [];
+                }
+                return [
+                    {
+                        documentId: document.id,
+                        agentId: document.agentId,
+                        title: document.title,
+                        path: document.path,
+                        chunkId: chunk.id,
+                        chunkOrdinal: chunk.ordinal,
+                        content: chunk.content,
+                        tags: document.tags,
+                        embedding: chunk.embedding
+                    }
+                ];
+            });
+            const tokens = tokenize(query);
+            const results = rows
+                .map((row) => {
+                const text = textScore(row, tokens);
+                const semantic = semanticScore(row, queryEmbedding);
+                return toResult(row, mode, text, semantic);
+            })
+                .filter((row) => row.score > 0 || tokens.length === 0)
+                .sort((left, right) => right.score - left.score || left.title.localeCompare(right.title))
+                .slice(0, Math.max(0, limit));
+            return results;
+        },
+        listLinks: async (agentId) => {
+            const index = await load();
+            const documentsById = new Map(index.documents.map((document) => [document.id, document]));
+            return index.links
+                .filter((link) => {
+                const source = documentsById.get(link.fromDocumentId);
+                return agentId ? source?.agentId === agentId : true;
+            })
+                .map((link) => toGraphLink(link, documentsById))
+                .sort((left, right) => left.fromTitle.localeCompare(right.fromTitle));
+        },
+        listBacklinks: async (title, agentId) => {
+            const index = await load();
+            const titleKey = title.toLowerCase();
+            const documentsById = new Map(index.documents.map((document) => [document.id, document]));
+            return index.links
+                .filter((link) => link.toTitle.toLowerCase() === titleKey)
+                .filter((link) => {
+                const source = documentsById.get(link.fromDocumentId);
+                return agentId ? source?.agentId === agentId : true;
+            })
+                .map((link) => toGraphLink(link, documentsById))
+                .sort((left, right) => right.weight - left.weight || left.fromTitle.localeCompare(right.fromTitle));
+        },
+        getGraph: async (agentId) => {
+            const index = await load();
+            const documents = agentId ? index.documents.filter((document) => document.agentId === agentId) : index.documents;
+            const documentIds = new Set(documents.map((document) => document.id));
+            const edges = index.links
+                .filter((link) => documentIds.has(link.fromDocumentId))
+                .map((link) => ({
+                source: link.fromDocumentId,
+                target: link.toDocumentId,
+                targetTitle: link.toTitle,
+                weight: link.weight,
+                priority: link.priority
+            }));
+            return {
+                nodes: documents.map((document) => ({
+                    id: document.id,
+                    agentId: document.agentId,
+                    title: document.title,
+                    path: document.path,
+                    content: document.content,
+                    tags: document.tags
+                })),
+                edges
+            };
+        },
+        getGraphSummary: async (agentId) => {
+            const graph = await (async () => {
+                const index = await load();
+                const documents = agentId ? index.documents.filter((document) => document.agentId === agentId) : index.documents;
+                const documentIds = new Set(documents.map((document) => document.id));
+                const edges = index.links
+                    .filter((link) => documentIds.has(link.fromDocumentId))
+                    .map((link) => ({
+                    source: link.fromDocumentId,
+                    target: link.toDocumentId,
+                    targetTitle: link.toTitle,
+                    weight: link.weight,
+                    priority: link.priority
+                }));
+                return {
+                    nodes: documents.map((document) => ({
+                        id: document.id,
+                        agentId: document.agentId,
+                        title: document.title,
+                        path: document.path,
+                        content: '',
+                        tags: document.tags
+                    })),
+                    edges
+                };
+            })();
+            return graph;
+        },
+        getGraphNode: async (id, agentId) => {
+            const index = await load();
+            const document = index.documents.find((row) => row.id === id && (!agentId || row.agentId === agentId));
+            return document
+                ? {
+                    id: document.id,
+                    agentId: document.agentId,
+                    title: document.title,
+                    path: document.path,
+                    content: document.content,
+                    tags: document.tags
+                }
+                : undefined;
+        },
+        searchGraphNodeIds: async (query, limit, agentId) => {
+            const index = await load();
+            const normalized = normalizeToken(query);
+            if (normalized.length === 0 || limit <= 0) {
+                return [];
+            }
+            const tokens = tokenize(query);
+            const scored = index.documents
+                .filter((document) => (!agentId || document.agentId === agentId))
+                .map((document) => {
+                const score = textScore({
+                    documentId: document.id,
+                    agentId: document.agentId,
+                    title: document.title,
+                    path: document.path,
+                    chunkId: document.id,
+                    chunkOrdinal: 0,
+                    content: document.content,
+                    tags: document.tags,
+                    embedding: []
+                }, tokens);
+                return { id: document.id, score };
+            })
+                .filter((row) => row.score > 0)
+                .sort((left, right) => right.score - left.score || left.id.localeCompare(right.id))
+                .slice(0, limit);
+            return scored.map((row) => row.id);
+        },
+        listAgents: async () => {
+            const index = await load();
+            const counts = index.documents.reduce((state, document) => {
+                state.set(document.agentId, (state.get(document.agentId) ?? 0) + 1);
+                return state;
+            }, new Map());
+            return Array.from(counts.entries())
+                .sort((left, right) => left[0].localeCompare(right[0]))
+                .map(([id, documentCount]) => ({ id, documentCount }));
+        },
+        close: () => {
+            // File-based index has no persistent connection.
+        }
+    };
+};

package/dist/infrastructure/file-system-vault.js

@@ -16,6 +16,17 @@ const walkMarkdownFiles = async (directory) => {
     }));
     return nested.flat();
 };
+const walkVaultFiles = async (directory) => {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const nested = await Promise.all(entries.map(async (entry) => {
+        const absolutePath = join(directory, entry.name);
+        if (entry.isDirectory()) {
+            return excludedDirectories.has(entry.name) ? [] : walkVaultFiles(absolutePath);
+        }
+        return entry.isFile() ? [absolutePath] : [];
+    }));
+    return nested.flat();
+};
 export const resolveVaultPath = (vaultPath) => isBucketVaultUri(vaultPath) ? getBucketVaultCachePath(vaultPath) : resolvePath(vaultPath);
 export const isBucketVaultPath = (vaultPath) => isBucketVaultUri(vaultPath);
 const isPathInside = (parent, child) => {
@@ -65,6 +76,10 @@ export const readMarkdownFiles = async (vaultPath) => {
         };
     }));
 };
+export const listVaultFiles = async (vaultPath) => {
+    const absoluteVaultPath = await ensureVault(vaultPath);
+    return walkVaultFiles(absoluteVaultPath);
+};
 export const writeMarkdownFile = async (vaultPath, filename, content) => {
     if (isBucketVaultUri(vaultPath)) {
         return writeBucketMarkdownFile(vaultPath, filename, content);

package/dist/infrastructure/paths.js

@@ -2,8 +2,16 @@ import { homedir } from 'node:os';
 import { isAbsolute, join, resolve } from 'node:path';
 const defaultHomeDirectoryName = '.brainlink';
 const defaultVaultDirectoryName = 'vault';
+const resolveSafeCwd = () => {
+    try {
+        return process.cwd();
+    }
+    catch {
+        return homedir();
+    }
+};
 export const expandHomePath = (path) => path === '~' || path.startsWith('~/') ? join(homedir(), path.slice(2)) : path;
-export const resolvePath = (path, cwd = process.cwd()) => {
+export const resolvePath = (path, cwd = resolveSafeCwd()) => {
     const expandedPath = expandHomePath(path);
     return isAbsolute(expandedPath) ? expandedPath : resolve(cwd, expandedPath);
 };

package/dist/infrastructure/private-pack-codec.js

@@ -0,0 +1,73 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from 'node:crypto';
+import { brotliCompressSync, brotliDecompressSync } from 'node:zlib';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { getBrainlinkHomePath } from './paths.js';
+const magic = Buffer.from('BLPK2', 'ascii');
+const version = 1;
+const nonceLength = 12;
+const authTagLength = 16;
+const algorithm = 'aes-256-gcm';
+const keyFilePath = (vaultPath) => {
+    const vaultHash = createHash('sha256').update(vaultPath).digest('hex').slice(0, 24);
+    return join(getBrainlinkHomePath(), 'keys', `search-pack-${vaultHash}.key`);
+};
+const deriveKeyFromSecret = (secret) => createHash('sha256').update(secret, 'utf8').digest();
+const readOrCreateKey = async (vaultPath) => {
+    const envSecret = process.env.BRAINLINK_SEARCH_PACK_KEY?.trim();
+    if (envSecret && envSecret.length > 0) {
+        return deriveKeyFromSecret(envSecret);
+    }
+    const path = keyFilePath(vaultPath);
+    try {
+        const existing = (await readFile(path, 'utf8')).trim();
+        if (existing.length > 0) {
+            return deriveKeyFromSecret(existing);
+        }
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !('code' in error) || error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    const secret = randomBytes(48).toString('base64url');
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, `${secret}\n`, { encoding: 'utf8', mode: 0o600 });
+    return deriveKeyFromSecret(secret);
+};
+const parseHeader = (payload) => {
+    if (payload.length < magic.length + 1 + nonceLength + authTagLength) {
+        throw new Error('Invalid private pack payload: too short.');
+    }
+    const payloadMagic = payload.subarray(0, magic.length);
+    const payloadVersion = payload[magic.length];
+    if (!payloadMagic.equals(magic) || payloadVersion !== version) {
+        throw new Error('Invalid private pack payload: unsupported format.');
+    }
+    const nonceStart = magic.length + 1;
+    const authTagStart = nonceStart + nonceLength;
+    const dataStart = authTagStart + authTagLength;
+    return {
+        nonce: payload.subarray(nonceStart, authTagStart),
+        authTag: payload.subarray(authTagStart, dataStart),
+        ciphertext: payload.subarray(dataStart)
+    };
+};
+export const encodePrivatePack = async (vaultPath, content) => {
+    const key = await readOrCreateKey(vaultPath);
+    const nonce = randomBytes(nonceLength);
+    const compressed = brotliCompressSync(content);
+    const cipher = createCipheriv(algorithm, key, nonce);
+    const ciphertext = Buffer.concat([cipher.update(compressed), cipher.final()]);
+    const authTag = cipher.getAuthTag();
+    return Buffer.concat([magic, Buffer.from([version]), nonce, authTag, ciphertext]);
+};
+export const decodePrivatePack = async (vaultPath, payload) => {
+    const key = await readOrCreateKey(vaultPath);
+    const { nonce, authTag, ciphertext } = parseHeader(payload);
+    const decipher = createDecipheriv(algorithm, key, nonce);
+    decipher.setAuthTag(authTag);
+    const compressed = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+    return brotliDecompressSync(compressed);
+};
+export const isPrivatePackPayload = (payload) => payload.length >= magic.length + 1 && payload.subarray(0, magic.length).equals(magic);