@andespindola/brainlink 0.1.0-beta.141 → 0.1.0-beta.143

package/dist/application/get-graph-stream-chunk.js

@@ -0,0 +1,285 @@
+import { getGraphLayout } from './get-graph-layout.js';
+const layoutCacheBySignature = new Map();
+const maxLayoutCacheEntries = 6;
+const farScaleThreshold = 0.22;
+const midScaleThreshold = 0.78;
+const viewportPaddingFactor = 0.18;
+const maxNearEdgePerNode = 24;
+const maxMidEdgePerNode = 12;
+const maxFarEdgePerCluster = 8;
+const inViewport = (item, input, padding) => {
+    const radius = item.radius ?? 24;
+    const paddedX = input.x - padding;
+    const paddedY = input.y - padding;
+    const paddedWidth = input.width + padding * 2;
+    const paddedHeight = input.height + padding * 2;
+    return (item.x + radius >= paddedX &&
+        item.x - radius <= paddedX + paddedWidth &&
+        item.y + radius >= paddedY &&
+        item.y - radius <= paddedY + paddedHeight);
+};
+const nodeDistanceToCenter = (item, input) => {
+    const cx = input.x + input.width / 2;
+    const cy = input.y + input.height / 2;
+    return Math.hypot(item.x - cx, item.y - cy);
+};
+const rankNodeRelevance = (node, input, degrees) => {
+    const degree = degrees.get(node.id) ?? 0;
+    const centerDistance = nodeDistanceToCenter(node, input);
+    const viewportRadius = Math.max(input.width, input.height) / 2;
+    const centerScore = 1 - Math.min(1, centerDistance / Math.max(viewportRadius, 1));
+    const degreeScore = Math.log1p(Math.max(0, degree));
+    const tagScore = Math.min(node.tags.length, 6) * 0.18;
+    return degreeScore * 1.1 + centerScore * 1.3 + tagScore;
+};
+const rankGroupRelevance = (group, input) => {
+    const centerDistance = nodeDistanceToCenter(group, input);
+    const viewportRadius = Math.max(input.width, input.height) / 2;
+    const centerScore = 1 - Math.min(1, centerDistance / Math.max(viewportRadius, 1));
+    const massScore = Math.log1p(group.nodeIds.length + group.childGroupIds.length * 2);
+    const edgeScore = Math.log1p(group.externalEdges.length + group.internalEdges.length);
+    return centerScore * 1.3 + massScore + edgeScore * 0.5;
+};
+const edgePriorityScore = (priority) => {
+    if (priority === 'critical')
+        return 4;
+    if (priority === 'high')
+        return 3;
+    if (priority === 'normal')
+        return 2;
+    return 1;
+};
+const edgeRank = (edge) => edge.weight * 1.35 + edgePriorityScore(edge.priority);
+const createLayoutCache = (signature, nodes, edges, groups) => {
+    const nodeById = new Map(nodes.map((node) => [node.id, node]));
+    const groupById = new Map(groups.map((group) => [group.id, group]));
+    const degrees = new Map();
+    const adjacencyByNodeId = new Map();
+    for (let index = 0; index < edges.length; index += 1) {
+        const edge = edges[index];
+        degrees.set(edge.source, (degrees.get(edge.source) ?? 0) + edge.weight);
+        const sourceAdjacency = adjacencyByNodeId.get(edge.source) ?? [];
+        sourceAdjacency.push(index);
+        adjacencyByNodeId.set(edge.source, sourceAdjacency);
+        if (!edge.target) {
+            continue;
+        }
+        degrees.set(edge.target, (degrees.get(edge.target) ?? 0) + edge.weight);
+        const targetAdjacency = adjacencyByNodeId.get(edge.target) ?? [];
+        targetAdjacency.push(index);
+        adjacencyByNodeId.set(edge.target, targetAdjacency);
+    }
+    return {
+        signature,
+        degrees,
+        nodeById,
+        groupById,
+        adjacencyByNodeId
+    };
+};
+const getOrCreateLayoutCache = (signature, nodes, edges, groups) => {
+    const cached = layoutCacheBySignature.get(signature);
+    if (cached) {
+        return cached;
+    }
+    const next = createLayoutCache(signature, nodes, edges, groups);
+    layoutCacheBySignature.set(signature, next);
+    while (layoutCacheBySignature.size > maxLayoutCacheEntries) {
+        const oldest = layoutCacheBySignature.keys().next().value;
+        if (!oldest)
+            break;
+        layoutCacheBySignature.delete(oldest);
+    }
+    return next;
+};
+const selectTopByRelevance = (items, relevanceById, budget) => [...items]
+    .sort((left, right) => {
+    const relevanceDelta = (relevanceById.get(right.id) ?? 0) - (relevanceById.get(left.id) ?? 0);
+    if (relevanceDelta !== 0)
+        return relevanceDelta;
+    return left.id.localeCompare(right.id);
+})
+    .slice(0, Math.max(1, budget));
+const selectNearNodes = (nodes, cache, input) => {
+    const padding = Math.max(input.width, input.height) * viewportPaddingFactor;
+    const viewportNodes = nodes.filter((node) => inViewport(node, input, padding));
+    const relevance = new Map();
+    for (let index = 0; index < viewportNodes.length; index += 1) {
+        const node = viewportNodes[index];
+        relevance.set(node.id, rankNodeRelevance(node, input, cache.degrees));
+    }
+    const selected = selectTopByRelevance(viewportNodes, relevance, input.nodeBudget);
+    return selected.map((node) => [
+        node.id,
+        node.title,
+        node.x,
+        node.y,
+        node.group,
+        node.segment,
+        'node',
+        relevance.get(node.id) ?? 0
+    ]);
+};
+const selectMidNodes = (nodes, cache, input) => {
+    const padding = Math.max(input.width, input.height) * (viewportPaddingFactor + 0.08);
+    const viewportNodes = nodes.filter((node) => inViewport(node, input, padding));
+    const relevance = new Map();
+    for (let index = 0; index < viewportNodes.length; index += 1) {
+        const node = viewportNodes[index];
+        relevance.set(node.id, rankNodeRelevance(node, input, cache.degrees) * 1.1);
+    }
+    const selected = selectTopByRelevance(viewportNodes, relevance, input.nodeBudget);
+    return selected.map((node) => [
+        node.id,
+        node.title,
+        node.x,
+        node.y,
+        node.group,
+        node.segment,
+        'node',
+        relevance.get(node.id) ?? 0
+    ]);
+};
+const selectFarClusters = (groups, input, nodeBudget) => {
+    const roots = groups.filter((group) => group.parentId === null);
+    const padding = Math.max(input.width, input.height) * 0.12;
+    const candidates = roots.filter((group) => inViewport(group, input, padding));
+    const relevance = new Map();
+    for (let index = 0; index < candidates.length; index += 1) {
+        const group = candidates[index];
+        relevance.set(group.id, rankGroupRelevance(group, input));
+    }
+    const selected = selectTopByRelevance(candidates, relevance, nodeBudget);
+    return selected.map((group) => [
+        `cluster:${group.id}`,
+        group.title,
+        group.x,
+        group.y,
+        group.group,
+        group.segment,
+        'cluster',
+        relevance.get(group.id) ?? 0
+    ]);
+};
+const collectEdgesForNodes = (allEdges, cache, nodeRows, edgeBudget, maxEdgesPerNode) => {
+    const isClusterMode = nodeRows.length > 0 && nodeRows[0]?.[6] === 'cluster';
+    if (isClusterMode) {
+        const clusterIds = new Set(nodeRows.map((row) => row[0].replace(/^cluster:/, '')));
+        const clusterEdges = new Map();
+        for (let index = 0; index < allEdges.length; index += 1) {
+            const edge = allEdges[index];
+            if (!edge.target)
+                continue;
+            const sourceNode = cache.nodeById.get(edge.source);
+            const targetNode = cache.nodeById.get(edge.target);
+            if (!sourceNode || !targetNode)
+                continue;
+            const sourceCluster = sourceNode.group;
+            const targetCluster = targetNode.group;
+            if (!clusterIds.has(sourceCluster) || !clusterIds.has(targetCluster) || sourceCluster === targetCluster)
+                continue;
+            const key = sourceCluster < targetCluster ? `${sourceCluster}|${targetCluster}` : `${targetCluster}|${sourceCluster}`;
+            const current = clusterEdges.get(key);
+            if (!current || edgeRank(edge) > edgeRank(current)) {
+                clusterEdges.set(key, edge);
+            }
+        }
+        return [...clusterEdges.values()]
+            .sort((left, right) => edgeRank(right) - edgeRank(left))
+            .slice(0, Math.max(1, edgeBudget))
+            .map((edge) => [
+            `cluster:${cache.nodeById.get(edge.source)?.group ?? ''}`,
+            `cluster:${cache.nodeById.get(edge.target ?? '')?.group ?? ''}`,
+            edge.weight,
+            edge.priority
+        ])
+            .filter((edge) => edge[0] !== edge[1] && edge[0] !== 'cluster:' && edge[1] !== 'cluster:');
+    }
+    const nodeIds = new Set(nodeRows.map((row) => row[0]));
+    const collected = new Map();
+    for (const nodeId of nodeIds) {
+        const adjacency = cache.adjacencyByNodeId.get(nodeId);
+        if (!adjacency || adjacency.length === 0) {
+            continue;
+        }
+        let perNodeCount = 0;
+        const rankedAdjacency = [...adjacency].sort((leftIndex, rightIndex) => edgeRank(allEdges[rightIndex]) - edgeRank(allEdges[leftIndex]));
+        for (let index = 0; index < rankedAdjacency.length; index += 1) {
+            if (perNodeCount >= maxEdgesPerNode) {
+                break;
+            }
+            const edge = allEdges[rankedAdjacency[index]];
+            if (!edge.target || !nodeIds.has(edge.source) || !nodeIds.has(edge.target)) {
+                continue;
+            }
+            const key = edge.source < edge.target ? `${edge.source}|${edge.target}` : `${edge.target}|${edge.source}`;
+            const current = collected.get(key);
+            if (!current || edgeRank(edge) > edgeRank(current)) {
+                collected.set(key, edge);
+            }
+            perNodeCount += 1;
+        }
+    }
+    return [...collected.values()]
+        .sort((left, right) => edgeRank(right) - edgeRank(left))
+        .slice(0, Math.max(1, edgeBudget))
+        .map((edge) => [edge.source, edge.target ?? '', edge.weight, edge.priority])
+        .filter((edge) => edge[1].length > 0);
+};
+const normalizeBudget = (value, fallback, min, max) => {
+    if (!Number.isFinite(value)) {
+        return fallback;
+    }
+    const rounded = Math.round(value);
+    if (rounded < min)
+        return min;
+    if (rounded > max)
+        return max;
+    return rounded;
+};
+export const getGraphStreamChunk = async (vaultPath, input) => {
+    const nodeBudget = normalizeBudget(input.nodeBudget, 1800, 80, 12_000);
+    const edgeBudget = normalizeBudget(input.edgeBudget, 5000, 120, 60_000);
+    const { signature, layout } = await getGraphLayout(vaultPath, input.agentId);
+    const groups = layout.groups ?? [];
+    const cache = getOrCreateLayoutCache(signature, layout.nodes, layout.edges, groups);
+    if (layout.nodes.length === 0) {
+        return {
+            signature,
+            mode: 'near',
+            nodes: [],
+            edges: [],
+            totals: {
+                nodes: 0,
+                edges: 0
+            }
+        };
+    }
+    const mode = input.scale < farScaleThreshold
+        ? 'far'
+        : input.scale < midScaleThreshold
+            ? 'mid'
+            : 'near';
+    const nodes = mode === 'far' && groups.length > 0
+        ? selectFarClusters(groups, input, nodeBudget)
+        : mode === 'mid'
+            ? selectMidNodes(layout.nodes, cache, {
+                ...input,
+                nodeBudget
+            })
+            : selectNearNodes(layout.nodes, cache, {
+                ...input,
+                nodeBudget
+            });
+    const edges = collectEdgesForNodes(layout.edges, cache, nodes, edgeBudget, mode === 'near' ? maxNearEdgePerNode : mode === 'mid' ? maxMidEdgePerNode : maxFarEdgePerCluster);
+    return {
+        signature,
+        mode,
+        nodes,
+        edges,
+        totals: {
+            nodes: layout.nodes.length,
+            edges: layout.edges.length
+        }
+    };
+};

package/dist/application/server/routes.js

@@ -4,6 +4,7 @@ import { getGraph } from '../get-graph.js';
 import { getGraphNode } from '../get-graph-node.js';
 import { getGraphLayout } from '../get-graph-layout.js';
 import { getGraphView } from '../get-graph-view.js';
+import { getGraphStreamChunk } from '../get-graph-stream-chunk.js';
 import { listAgents } from '../list-agents.js';
 import { listBacklinks, listLinks } from '../list-links.js';
 import { searchGraphNodeIds } from '../search-graph-node-ids.js';
@@ -13,6 +14,7 @@ import { createClientCss } from '../frontend/client-css.js';
 import { createClientHtml } from '../frontend/client-html.js';
 import { createClientJs } from '../frontend/client-js.js';
 import { createClientWorkerJs } from '../frontend/client-worker-js.js';
+import { createClientRenderWorkerJs } from '../frontend/client-render-worker-js.js';
 import { contentTypes, createJsonResponse, isReadMethod, parsePositiveInteger } from './http.js';
 const readSearchMode = async (url) => {
     const config = await loadBrainlinkConfig();
@@ -65,6 +67,7 @@ let cachedClientHtml = null;
 let cachedClientCss = null;
 let cachedClientJs = null;
 let cachedClientWorkerJs = null;
+let cachedClientRenderWorkerJs = null;
 const readClientHtml = () => {
     if (cachedClientHtml === null) {
         cachedClientHtml = createClientHtml();
@@ -89,6 +92,12 @@ const readClientWorkerJs = () => {
     }
     return cachedClientWorkerJs;
 };
+const readClientRenderWorkerJs = () => {
+    if (cachedClientRenderWorkerJs === null) {
+        cachedClientRenderWorkerJs = createClientRenderWorkerJs();
+    }
+    return cachedClientRenderWorkerJs;
+};
 const compactGraphLayoutEdgeLimitFor = (nodeCount) => {
     if (nodeCount > 100_000)
         return 15_000;
@@ -202,6 +211,9 @@ export const route = async (request, url, vaultPath) => {
     if (isReadMethod(request) && url.pathname === '/app-worker.js') {
         return createResponse(readClientWorkerJs(), 200, contentTypes['.js']);
     }
+    if (isReadMethod(request) && url.pathname === '/render-worker.js') {
+        return createResponse(readClientRenderWorkerJs(), 200, contentTypes['.js']);
+    }
     if (isReadMethod(request) && url.pathname === '/api/graph') {
         return createResponse(createJsonResponse(await getGraph(vaultPath, readAgentQuery(url))), 200, contentTypes['.json']);
     }
@@ -244,6 +256,25 @@ export const route = async (request, url, vaultPath) => {
             agentId: readAgentQuery(url)
         })), 200, contentTypes['.json']);
     }
+    if (isReadMethod(request) && url.pathname === '/api/graph-stream') {
+        const x = parseNumber(url.searchParams.get('x'), -1000);
+        const y = parseNumber(url.searchParams.get('y'), -1000);
+        const width = parseNumber(url.searchParams.get('w'), 2000);
+        const height = parseNumber(url.searchParams.get('h'), 2000);
+        const scale = parseNumber(url.searchParams.get('scale'), 0.24);
+        const nodeBudget = parsePositiveInteger(url.searchParams.get('nodeBudget'), 1800);
+        const edgeBudget = parsePositiveInteger(url.searchParams.get('edgeBudget'), 5000);
+        return createResponse(createJsonResponse(await getGraphStreamChunk(vaultPath, {
+            x,
+            y,
+            width,
+            height,
+            scale,
+            nodeBudget,
+            edgeBudget,
+            agentId: readAgentQuery(url)
+        })), 200, contentTypes['.json']);
+    }
     if (isReadMethod(request) && url.pathname === '/api/graph-node') {
         const id = url.searchParams.get('id')?.trim() ?? '';
         if (!id) {

package/dist/cli/runtime.js

@@ -1,11 +1,19 @@
-import { loadBrainlinkConfig, resolveAgentRuntimeDefaults } from '../infrastructure/config.js';
+import { autoMigrateConfiguredVaultIfChanged } from '../application/auto-migrate-configured-vault.js';
+import { loadBrainlinkConfigWithSource, resolveAgentRuntimeDefaults } from '../infrastructure/config.js';
 import { assertVaultAllowed } from '../infrastructure/file-system-vault.js';
 export const parsePositiveInteger = (value, fallback) => {
     const parsed = Number.parseInt(value, 10);
     return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 };
 export const resolveOptions = async (options) => {
-    const config = await loadBrainlinkConfig();
+    const { config, vaultSource } = await loadBrainlinkConfigWithSource();
+    if (options.vault === undefined) {
+        const sourceKey = vaultSource.sourcePath ? `${vaultSource.source}:${vaultSource.sourcePath}` : vaultSource.source;
+        await autoMigrateConfiguredVaultIfChanged({
+            configKey: sourceKey,
+            configuredVault: config.vault
+        });
+    }
     const vault = options.vault ?? config.vault;
     const allowedVault = assertVaultAllowed(vault, config.allowedVaults);
     const agent = options.agent ?? config.defaultAgent;

package/dist/infrastructure/config.js

@@ -181,12 +181,87 @@ export const resolveAgentRuntimeDefaults = (config, agent) => {
         defaultSearchMode: profile?.defaultSearchMode ?? config.defaultSearchMode
     };
 };
+const mergeConfigLayers = (layers) => layers.reduce((state, config) => ({
+    ...state,
+    ...config
+}), {});
+export const getVaultConfigSourceDetails = 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 {
+            source: 'local-legacy',
+            sourcePath: resolve(cwd, '.brainlink.json')
+        };
+    }
+    if (typeof localConfig.vault === 'string' && localConfig.vault.trim().length > 0) {
+        return {
+            source: 'local',
+            sourcePath: getLocalConfigPath(cwd)
+        };
+    }
+    if (typeof globalConfig.vault === 'string' && globalConfig.vault.trim().length > 0) {
+        return {
+            source: 'global',
+            sourcePath: getGlobalConfigPath()
+        };
+    }
+    return {
+        source: 'default',
+        sourcePath: null
+    };
+};
 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
-    }), {});
+    const merged = mergeConfigLayers([globalConfig, ...localConfigs]);
     return sanitizeConfig(merged);
 };
+export const loadBrainlinkConfigWithSource = async (cwd = safeCwd()) => {
+    const globalConfigPath = getGlobalConfigPath();
+    const localConfigPath = getLocalConfigPath(cwd);
+    const legacyLocalConfigPath = resolve(cwd, '.brainlink.json');
+    const [globalConfig, localConfig, legacyLocalConfig] = await Promise.all([
+        readJsonConfig(globalConfigPath),
+        readJsonConfig(localConfigPath),
+        readJsonConfig(legacyLocalConfigPath)
+    ]);
+    const config = sanitizeConfig(mergeConfigLayers([globalConfig, localConfig, legacyLocalConfig]));
+    if (typeof legacyLocalConfig.vault === 'string' && legacyLocalConfig.vault.trim().length > 0) {
+        return {
+            config,
+            vaultSource: {
+                source: 'local-legacy',
+                sourcePath: legacyLocalConfigPath
+            }
+        };
+    }
+    if (typeof localConfig.vault === 'string' && localConfig.vault.trim().length > 0) {
+        return {
+            config,
+            vaultSource: {
+                source: 'local',
+                sourcePath: localConfigPath
+            }
+        };
+    }
+    if (typeof globalConfig.vault === 'string' && globalConfig.vault.trim().length > 0) {
+        return {
+            config,
+            vaultSource: {
+                source: 'global',
+                sourcePath: globalConfigPath
+            }
+        };
+    }
+    return {
+        config,
+        vaultSource: {
+            source: 'default',
+            sourcePath: null
+        }
+    };
+};

package/dist/infrastructure/vault-migration-state.js

@@ -0,0 +1,69 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { getBrainlinkHomePath } from './paths.js';
+const defaultState = {
+    byConfigKey: {}
+};
+const statePath = () => join(getBrainlinkHomePath(), 'vault-migration-state.json');
+const sanitizeState = (value) => {
+    if (typeof value !== 'object' || value === null) {
+        return defaultState;
+    }
+    const record = value;
+    const byConfigKeyRecord = typeof record.byConfigKey === 'object' && record.byConfigKey !== null ? record.byConfigKey : {};
+    const byConfigKey = Object.entries(byConfigKeyRecord).reduce((state, [key, vault]) => {
+        if (typeof key !== 'string' || key.trim().length === 0) {
+            return state;
+        }
+        if (typeof vault !== 'string' || vault.trim().length === 0) {
+            return state;
+        }
+        return {
+            ...state,
+            [key]: vault.trim()
+        };
+    }, {});
+    return {
+        byConfigKey
+    };
+};
+const readState = async () => {
+    try {
+        const raw = await readFile(statePath(), 'utf8');
+        return sanitizeState(JSON.parse(raw));
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return defaultState;
+        }
+        throw error;
+    }
+};
+const writeState = async (state) => {
+    const path = statePath();
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, `${JSON.stringify(state, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+};
+export const getVaultMigrationStatePath = () => statePath();
+export const getLastConfiguredVaultForKey = async (configKey) => {
+    const state = await readState();
+    const value = state.byConfigKey[configKey];
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+};
+export const setLastConfiguredVaultForKey = async (configKey, vault) => {
+    const key = configKey.trim();
+    const value = vault.trim();
+    if (key.length === 0 || value.length === 0) {
+        return;
+    }
+    const state = await readState();
+    if (state.byConfigKey[key] === value) {
+        return;
+    }
+    await writeState({
+        byConfigKey: {
+            ...state.byConfigKey,
+            [key]: value
+        }
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andespindola/brainlink",
-  "version": "0.1.0-beta.141",
+  "version": "0.1.0-beta.143",
   "description": "Local-first knowledge memory for agents with Markdown, backlinks, indexing and context retrieval.",
   "type": "module",
   "license": "MIT",