@andespindola/brainlink 0.1.0-beta.9 → 0.1.0-beta.90

package/dist/application/start-server.js

@@ -1,9 +1,78 @@
 import { createServer } from 'node:http';
+import { brotliCompressSync, constants, gzipSync } from 'node:zlib';
 import { indexVault } from './index-vault.js';
 import { startVaultWatcher } from './watch-vault.js';
 import { assertLoopbackHost } from './server/host-security.js';
 import { contentTypes, createJsonResponse, isHttpError } from './server/http.js';
 import { route } from './server/routes.js';
+const compressionThresholdBytes = 1024;
+const normalizeEncodingToken = (value) => value.trim().toLowerCase();
+const supportsEncoding = (acceptEncoding, target) => {
+    if (!acceptEncoding) {
+        return false;
+    }
+    return acceptEncoding
+        .split(',')
+        .map((entry) => entry.split(';')[0] ?? '')
+        .map(normalizeEncodingToken)
+        .includes(target);
+};
+const isCompressibleContentType = (contentType) => {
+    const normalized = contentType?.toLowerCase() ?? '';
+    return (normalized.includes('application/json') ||
+        normalized.includes('text/javascript') ||
+        normalized.includes('text/css') ||
+        normalized.includes('text/html') ||
+        normalized.startsWith('text/'));
+};
+const maybeCompressResponse = (requestHeaders, statusCode, headers, body) => {
+    if (statusCode === 204 || statusCode === 304) {
+        return { headers, body: '' };
+    }
+    if (!isCompressibleContentType(headers['content-type'])) {
+        return { headers, body };
+    }
+    const bodyBuffer = Buffer.from(body, 'utf8');
+    if (bodyBuffer.byteLength < compressionThresholdBytes) {
+        return { headers, body };
+    }
+    if (headers['content-encoding']) {
+        return { headers, body };
+    }
+    const acceptEncodingHeader = Array.isArray(requestHeaders['accept-encoding'])
+        ? requestHeaders['accept-encoding'].join(',')
+        : requestHeaders['accept-encoding'];
+    const vary = headers.vary ? `${headers.vary}, Accept-Encoding` : 'Accept-Encoding';
+    const withVary = {
+        ...headers,
+        vary
+    };
+    if (supportsEncoding(acceptEncodingHeader, 'br')) {
+        return {
+            headers: {
+                ...withVary,
+                'content-encoding': 'br'
+            },
+            body: brotliCompressSync(bodyBuffer, {
+                params: {
+                    [constants.BROTLI_PARAM_QUALITY]: 5
+                }
+            })
+        };
+    }
+    if (supportsEncoding(acceptEncodingHeader, 'gzip')) {
+        return {
+            headers: {
+                ...withVary,
+                'content-encoding': 'gzip'
+            },
+            body: gzipSync(bodyBuffer, {
+                level: 6
+            })
+        };
+    }
+    return { headers: withVary, body };
+};
 export const startServer = async (input) => {
     assertLoopbackHost(input.host);
     if (input.shouldIndex) {
@@ -19,14 +88,16 @@ export const startServer = async (input) => {
         const url = new URL(request.url ?? '/', `http://${request.headers.host ?? input.host}`);
         route(request, url, input.vaultPath)
             .then((result) => {
-            response.writeHead(result.statusCode, result.headers);
-            response.end(result.body);
+            const encoded = maybeCompressResponse(request.headers, result.statusCode, result.headers, result.body);
+            response.writeHead(result.statusCode, encoded.headers);
+            response.end(encoded.body);
         })
             .catch((error) => {
             const message = error instanceof Error ? error.message : String(error);
             const statusCode = isHttpError(error) ? error.statusCode : 500;
-            response.writeHead(statusCode, { 'content-type': contentTypes['.json'] });
-            response.end(createJsonResponse({ error: message }));
+            const fallback = maybeCompressResponse(request.headers, statusCode, { 'content-type': contentTypes['.json'] }, createJsonResponse({ error: message }));
+            response.writeHead(statusCode, fallback.headers);
+            response.end(fallback.body);
         });
     });
     await new Promise((resolve, reject) => {

package/dist/application/watch-vault.js

@@ -1,5 +1,5 @@
 import { watch } from 'node:fs';
-import { indexVault } from './index-vault.js';
+import { indexVaultWithOptions } from './index-vault.js';
 import { isBucketVaultPath, resolveVaultPath } from '../infrastructure/file-system-vault.js';
 const shouldIgnore = (filename) => {
     if (!filename) {
@@ -14,6 +14,27 @@ export const startVaultWatcher = (input) => {
     const absoluteVaultPath = resolveVaultPath(input.vaultPath);
     const debounceMs = input.debounceMs ?? 350;
     let timeout = null;
+    let running = false;
+    let pending = false;
+    const runIndex = () => {
+        if (running) {
+            pending = true;
+            return;
+        }
+        running = true;
+        indexVaultWithOptions(absoluteVaultPath, {
+            onProgress: input.onProgress
+        })
+            .then(input.onIndex)
+            .catch(input.onError)
+            .finally(() => {
+            running = false;
+            if (pending) {
+                pending = false;
+                runIndex();
+            }
+        });
+    };
     const schedule = (filename) => {
         if (shouldIgnore(filename)) {
             return;
@@ -22,7 +43,7 @@ export const startVaultWatcher = (input) => {
             clearTimeout(timeout);
         }
         timeout = setTimeout(() => {
-            indexVault(absoluteVaultPath).then(input.onIndex).catch(input.onError);
+            runIndex();
         }, debounceMs);
     };
     const watcher = watch(absoluteVaultPath, { recursive: true }, (_eventType, filename) => {

package/dist/benchmarks/large-vault.js

@@ -21,7 +21,7 @@ const readOptions = (args) => ({
 });
 const topics = [
     'authentication jwt token refresh policy',
-    'sqlite graph backlinks markdown vault indexing',
+    'graph backlinks markdown vault indexing',
     'frontend canvas layout graph interaction',
     'agent memory context retrieval summarization',
     'security local server vault path allowlist',

package/dist/cli/commands/agent-commands.js

@@ -4,7 +4,7 @@ import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { promisify } from 'node:util';
 import { loadBrainlinkConfig } from '../../infrastructure/config.js';
-import { getBootstrapPolicy, getBootstrapSessionStatus, getSessionStatePath, setBootstrapPolicy } from '../../infrastructure/session-state.js';
+import { getBootstrapPolicy, getBootstrapSessionStatus, getContextSessionStatus, getSessionStatePath, setBootstrapPolicy } from '../../infrastructure/session-state.js';
 import { print } from '../runtime.js';
 const getCodexConfigPath = () => join(homedir(), '.codex', 'config.toml');
 const getMarketplacePath = () => join(homedir(), '.agents', 'plugins', 'marketplace.json');
@@ -141,6 +141,12 @@ const parseAllowedVaults = (value) => {
 export const installAgentIntegration = async (input) => {
     const codexConfigPath = getCodexConfigPath();
     const allowedVaults = parseAllowedVaults(input.allowedVaults);
+    const bootstrapPolicy = await setBootstrapPolicy({
+        enforceBootstrap: true,
+        enforceContextFirst: true,
+        autoBootstrapOnRead: true,
+        autoBootstrapOnStartup: true
+    });
     await upsertCodexMcpConfig(codexConfigPath, {
         allowedVaults,
         brainlinkHome: input.brainlinkHome
@@ -195,6 +201,7 @@ export const installAgentIntegration = async (input) => {
         codexConfigPath,
         mcpServer: 'brainlink',
         command: 'brainlink-mcp',
+        bootstrapPolicy,
         ...(input.mcpOnly !== true ? { pluginSourcePath, pluginSymlinkPath, marketplacePath } : {}),
         ...(selfTestResult ? { selfTest: selfTestResult } : {}),
         ...(warnings.length > 0 ? { warnings } : {})
@@ -243,6 +250,7 @@ const applyPolicyPreset = (preset) => {
     if (preset === 'fully-auto') {
         return {
             enforceBootstrap: true,
+            enforceContextFirst: true,
             autoBootstrapOnRead: true,
             autoBootstrapOnStartup: true
         };
@@ -250,6 +258,7 @@ const applyPolicyPreset = (preset) => {
     if (preset === 'strict') {
         return {
             enforceBootstrap: true,
+            enforceContextFirst: true,
             autoBootstrapOnRead: false,
             autoBootstrapOnStartup: false
         };
@@ -307,6 +316,7 @@ export const registerAgentCommands = (program) => {
         .command('policy')
         .option('--preset <preset>', 'policy preset: fully-auto or strict')
         .option('--enforce-bootstrap <true|false>', 'override enforceBootstrap')
+        .option('--enforce-context-first <true|false>', 'override enforceContextFirst')
         .option('--auto-bootstrap-on-read <true|false>', 'override autoBootstrapOnRead')
         .option('--auto-bootstrap-on-startup <true|false>', 'override autoBootstrapOnStartup')
         .option('--stale-after-minutes <minutes>', 'override staleAfterMinutes with positive integer')
@@ -315,11 +325,13 @@ export const registerAgentCommands = (program) => {
         .action(async (options) => {
         const presetPatch = applyPolicyPreset(options.preset);
         const enforceBootstrap = parseBooleanOption(options.enforceBootstrap, '--enforce-bootstrap');
+        const enforceContextFirst = parseBooleanOption(options.enforceContextFirst, '--enforce-context-first');
         const autoBootstrapOnRead = parseBooleanOption(options.autoBootstrapOnRead, '--auto-bootstrap-on-read');
         const autoBootstrapOnStartup = parseBooleanOption(options.autoBootstrapOnStartup, '--auto-bootstrap-on-startup');
         const staleAfterMinutes = parsePositiveIntegerOption(options.staleAfterMinutes, '--stale-after-minutes');
         const overridePatch = {
             ...(enforceBootstrap !== undefined ? { enforceBootstrap } : {}),
+            ...(enforceContextFirst !== undefined ? { enforceContextFirst } : {}),
             ...(autoBootstrapOnRead !== undefined ? { autoBootstrapOnRead } : {}),
             ...(autoBootstrapOnStartup !== undefined ? { autoBootstrapOnStartup } : {}),
             ...(staleAfterMinutes !== undefined ? { staleAfterMinutes } : {})
@@ -335,6 +347,7 @@ export const registerAgentCommands = (program) => {
         }, () => [
             ...(options.preset ? [`presetApplied=${options.preset}`] : []),
             `enforceBootstrap=${policy.enforceBootstrap}`,
+            `enforceContextFirst=${policy.enforceContextFirst}`,
             `autoBootstrapOnRead=${policy.autoBootstrapOnRead}`,
             `autoBootstrapOnStartup=${policy.autoBootstrapOnStartup}`,
             `staleAfterMinutes=${policy.staleAfterMinutes}`
@@ -373,6 +386,7 @@ export const registerAgentCommands = (program) => {
         const config = await loadBrainlinkConfig();
         const policy = await getBootstrapPolicy();
         const bootstrapStatus = await getBootstrapSessionStatus(config.vault, options.agent ?? config.defaultAgent);
+        const contextStatus = await getContextSessionStatus(config.vault, options.agent ?? config.defaultAgent);
         const sessionStatePath = getSessionStatePath();
         print(options.json, {
             configured: hasMcpSection && hasCommand,
@@ -387,7 +401,8 @@ export const registerAgentCommands = (program) => {
             vault: config.vault,
             agent: options.agent ?? config.defaultAgent ?? '*',
             bootstrapPolicy: policy,
-            bootstrapStatus
+            bootstrapStatus,
+            contextStatus
         }, () => [
             `codexConfigPath=${codexConfigPath}`,
             `configured=${hasMcpSection && hasCommand}`,
@@ -396,7 +411,9 @@ export const registerAgentCommands = (program) => {
             `vault=${config.vault}`,
             `agent=${options.agent ?? config.defaultAgent ?? '*'}`,
             `bootstrapReady=${bootstrapStatus.ready}`,
-            `bootstrapStale=${bootstrapStatus.stale}`
+            `bootstrapStale=${bootstrapStatus.stale}`,
+            `contextReady=${contextStatus.ready}`,
+            `contextStale=${contextStatus.stale}`
         ].join('\n'));
     });
 };