@andespindola/brainlink 0.1.0-beta.1 → 0.1.0-beta.11

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-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/search-packs.js

@@ -0,0 +1,151 @@
+import { gunzipSync, gzipSync } from 'node:zlib';
+import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const packsDirectoryName = 'search-packs';
+const manifestFileName = 'manifest.json';
+const rowChunkSize = 5_000;
+const queryTokenPattern = /[\p{L}\p{N}_-]+/gu;
+const toPackDirectory = (vaultPath) => join(vaultPath, '.brainlink', packsDirectoryName);
+const toManifestPath = (vaultPath) => join(toPackDirectory(vaultPath), manifestFileName);
+const parseRowsFromPack = (content) => gunzipSync(content)
+    .toString('utf8')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .map((line) => JSON.parse(line));
+const toRows = (documents) => documents.flatMap((document) => document.chunks.map((chunk) => ({
+    documentId: document.document.id,
+    agentId: document.document.agentId,
+    title: document.document.title,
+    path: document.document.path,
+    chunkId: chunk.id,
+    content: chunk.content,
+    tags: document.document.tags
+})));
+const writeManifest = async (vaultPath, manifest) => {
+    await writeFile(toManifestPath(vaultPath), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+};
+const chunkRows = (rows, size) => {
+    const chunks = [];
+    for (let index = 0; index < rows.length; index += size) {
+        chunks.push(rows.slice(index, index + size));
+    }
+    return chunks;
+};
+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 start = 0;
+    while (start < text.length) {
+        const index = text.indexOf(token, start);
+        if (index < 0) {
+            break;
+        }
+        hits += 1;
+        start = index + token.length;
+    }
+    return hits;
+};
+const computeTextScore = (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, 5);
+    }, 0);
+};
+const toSearchResult = (row, score) => ({
+    documentId: row.documentId,
+    agentId: row.agentId,
+    title: row.title,
+    path: row.path,
+    chunkId: row.chunkId,
+    content: row.content,
+    score,
+    textScore: score,
+    semanticScore: 0,
+    searchMode: 'fts',
+    tags: row.tags
+});
+const sortedPackFiles = async (vaultPath) => {
+    try {
+        const files = await readdir(toPackDirectory(vaultPath));
+        return files
+            .filter((file) => file.endsWith('.jsonl.gz'))
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+};
+export const buildSearchPacks = async (vaultPath, documents) => {
+    const directory = toPackDirectory(vaultPath);
+    const rows = toRows(documents);
+    await mkdir(directory, { recursive: true });
+    const current = await readdir(directory);
+    await Promise.all(current
+        .filter((name) => name.endsWith('.jsonl.gz') || name === manifestFileName)
+        .map((name) => rm(join(directory, name), { force: true })));
+    const chunks = chunkRows(rows, rowChunkSize);
+    await Promise.all(chunks.map(async (chunk, index) => {
+        const fileName = `pack-${String(index + 1).padStart(4, '0')}.jsonl.gz`;
+        const serialized = `${chunk.map((row) => JSON.stringify(row)).join('\n')}\n`;
+        const compressed = gzipSync(Buffer.from(serialized, 'utf8'), { level: 6 });
+        await writeFile(join(directory, fileName), compressed);
+    }));
+    await writeManifest(vaultPath, {
+        version: 1,
+        createdAt: new Date().toISOString(),
+        packCount: chunks.length,
+        recordCount: rows.length
+    });
+    return {
+        packCount: chunks.length,
+        recordCount: rows.length
+    };
+};
+export const searchInPacks = async (vaultPath, query, limit, agentId) => {
+    const normalizedAgent = agentId?.trim();
+    const tokens = tokenize(query);
+    if (limit <= 0 || tokens.length === 0) {
+        return [];
+    }
+    const files = await sortedPackFiles(vaultPath);
+    if (files.length === 0) {
+        return [];
+    }
+    const scored = [];
+    for (const file of files) {
+        const rows = parseRowsFromPack(await readFile(join(toPackDirectory(vaultPath), file)));
+        rows.forEach((row) => {
+            if (normalizedAgent && row.agentId !== normalizedAgent) {
+                return;
+            }
+            const score = computeTextScore(row, tokens);
+            if (score > 0) {
+                scored.push(toSearchResult(row, score));
+            }
+        });
+    }
+    return scored
+        .sort((left, right) => right.score - left.score || left.title.localeCompare(right.title))
+        .slice(0, limit);
+};

package/dist/infrastructure/session-state.js

@@ -0,0 +1,172 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { getBrainlinkHomePath } from './paths.js';
+const defaultPolicy = {
+    enforceBootstrap: true,
+    enforceContextFirst: true,
+    autoBootstrapOnRead: true,
+    autoBootstrapOnStartup: true,
+    staleAfterMinutes: 120
+};
+const defaultState = {
+    policy: defaultPolicy,
+    bootstraps: [],
+    contexts: []
+};
+const sessionStatePath = () => join(getBrainlinkHomePath(), 'session-state.json');
+const normalizeAgent = (agent) => agent?.trim() ? agent.trim() : '*';
+const safePositive = (value, fallback) => typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : fallback;
+const sanitizeState = (value) => {
+    if (typeof value !== 'object' || value === null) {
+        return defaultState;
+    }
+    const record = value;
+    const policyRecord = typeof record.policy === 'object' && record.policy !== null ? record.policy : {};
+    const rawBootstraps = Array.isArray(record.bootstraps) ? record.bootstraps : [];
+    const rawContexts = Array.isArray(record.contexts) ? record.contexts : [];
+    const bootstraps = rawBootstraps.flatMap((entry) => {
+        if (typeof entry !== 'object' || entry === null) {
+            return [];
+        }
+        const row = entry;
+        const vault = typeof row.vault === 'string' && row.vault.trim().length > 0 ? row.vault.trim() : undefined;
+        const agent = typeof row.agent === 'string' && row.agent.trim().length > 0 ? row.agent.trim() : undefined;
+        const lastBootstrappedAt = typeof row.lastBootstrappedAt === 'string' && row.lastBootstrappedAt.trim().length > 0 ? row.lastBootstrappedAt.trim() : undefined;
+        return vault && agent && lastBootstrappedAt ? [{ vault, agent, lastBootstrappedAt }] : [];
+    });
+    const contexts = rawContexts.flatMap((entry) => {
+        if (typeof entry !== 'object' || entry === null) {
+            return [];
+        }
+        const row = entry;
+        const vault = typeof row.vault === 'string' && row.vault.trim().length > 0 ? row.vault.trim() : undefined;
+        const agent = typeof row.agent === 'string' && row.agent.trim().length > 0 ? row.agent.trim() : undefined;
+        const lastContextAt = typeof row.lastContextAt === 'string' && row.lastContextAt.trim().length > 0 ? row.lastContextAt.trim() : undefined;
+        return vault && agent && lastContextAt ? [{ vault, agent, lastContextAt }] : [];
+    });
+    return {
+        policy: {
+            enforceBootstrap: typeof policyRecord.enforceBootstrap === 'boolean' ? policyRecord.enforceBootstrap : defaultPolicy.enforceBootstrap,
+            enforceContextFirst: typeof policyRecord.enforceContextFirst === 'boolean'
+                ? policyRecord.enforceContextFirst
+                : defaultPolicy.enforceContextFirst,
+            autoBootstrapOnRead: typeof policyRecord.autoBootstrapOnRead === 'boolean'
+                ? policyRecord.autoBootstrapOnRead
+                : defaultPolicy.autoBootstrapOnRead,
+            autoBootstrapOnStartup: typeof policyRecord.autoBootstrapOnStartup === 'boolean'
+                ? policyRecord.autoBootstrapOnStartup
+                : defaultPolicy.autoBootstrapOnStartup,
+            staleAfterMinutes: safePositive(policyRecord.staleAfterMinutes, defaultPolicy.staleAfterMinutes)
+        },
+        bootstraps,
+        contexts
+    };
+};
+const readState = async () => {
+    try {
+        const content = await readFile(sessionStatePath(), 'utf8');
+        return sanitizeState(JSON.parse(content));
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return defaultState;
+        }
+        throw error;
+    }
+};
+const writeState = async (state) => {
+    const path = sessionStatePath();
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, `${JSON.stringify(state, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+};
+export const getSessionStatePath = () => sessionStatePath();
+export const getBootstrapPolicy = async () => (await readState()).policy;
+export const setBootstrapPolicy = async (patch) => {
+    const state = await readState();
+    const next = {
+        enforceBootstrap: typeof patch.enforceBootstrap === 'boolean' ? patch.enforceBootstrap : state.policy.enforceBootstrap,
+        enforceContextFirst: typeof patch.enforceContextFirst === 'boolean' ? patch.enforceContextFirst : state.policy.enforceContextFirst,
+        autoBootstrapOnRead: typeof patch.autoBootstrapOnRead === 'boolean' ? patch.autoBootstrapOnRead : state.policy.autoBootstrapOnRead,
+        autoBootstrapOnStartup: typeof patch.autoBootstrapOnStartup === 'boolean' ? patch.autoBootstrapOnStartup : state.policy.autoBootstrapOnStartup,
+        staleAfterMinutes: safePositive(patch.staleAfterMinutes, state.policy.staleAfterMinutes)
+    };
+    await writeState({
+        ...state,
+        policy: next
+    });
+    return next;
+};
+export const touchBootstrapSession = async (vault, agent) => {
+    const state = await readState();
+    const normalizedAgent = normalizeAgent(agent);
+    const entry = {
+        vault,
+        agent: normalizedAgent,
+        lastBootstrappedAt: new Date().toISOString()
+    };
+    const bootstraps = [
+        entry,
+        ...state.bootstraps.filter((item) => !(item.vault === entry.vault && item.agent === entry.agent))
+    ].slice(0, 500);
+    await writeState({
+        ...state,
+        bootstraps
+    });
+    return entry;
+};
+export const touchContextSession = async (vault, agent) => {
+    const state = await readState();
+    const normalizedAgent = normalizeAgent(agent);
+    const entry = {
+        vault,
+        agent: normalizedAgent,
+        lastContextAt: new Date().toISOString()
+    };
+    const contexts = [
+        entry,
+        ...state.contexts.filter((item) => !(item.vault === entry.vault && item.agent === entry.agent))
+    ].slice(0, 500);
+    await writeState({
+        ...state,
+        contexts
+    });
+    return entry;
+};
+export const getBootstrapSessionStatus = async (vault, agent) => {
+    const state = await readState();
+    const normalizedAgent = normalizeAgent(agent);
+    const match = state.bootstraps.find((entry) => entry.vault === vault && entry.agent === normalizedAgent);
+    if (!match) {
+        return {
+            ready: false,
+            stale: true
+        };
+    }
+    const ageMinutes = Math.max(0, (Date.now() - new Date(match.lastBootstrappedAt).getTime()) / 60000);
+    const stale = ageMinutes > state.policy.staleAfterMinutes;
+    return {
+        ready: !stale,
+        stale,
+        lastBootstrappedAt: match.lastBootstrappedAt,
+        ageMinutes
+    };
+};
+export const getContextSessionStatus = async (vault, agent) => {
+    const state = await readState();
+    const normalizedAgent = normalizeAgent(agent);
+    const match = state.contexts.find((entry) => entry.vault === vault && entry.agent === normalizedAgent);
+    if (!match) {
+        return {
+            ready: false,
+            stale: true
+        };
+    }
+    const ageMinutes = Math.max(0, (Date.now() - new Date(match.lastContextAt).getTime()) / 60000);
+    const stale = ageMinutes > state.policy.staleAfterMinutes;
+    return {
+        ready: !stale,
+        stale,
+        lastContextAt: match.lastContextAt,
+        ageMinutes
+    };
+};