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

package/README.md

@@ -694,6 +694,7 @@ blink config set-vault "s3://my-memory-bucket/brainlink" --global
 
 `config set-vault` writes configuration through CLI (no manual file edits required).  
 By default it writes local config (`./brainlink.config.json`), appends the vault to `allowedVaults`, and migrates Markdown memory from the current configured vault when the target is empty.  
+When the configured default vault is changed manually in config files, Brainlink also performs automatic migration on the next command that uses the configured vault (without explicit `--vault`).
 Use `--global` to write to `$BRAINLINK_HOME/brainlink.config.json`, `--no-migrate` to skip migration, and `--no-index` to skip post-migration indexing.
 `config doctor` is dry-run by default; use `--fix` to apply safe config normalization and allowlist fixes.
 

package/dist/application/auto-migrate-configured-vault.js

@@ -0,0 +1,37 @@
+import { indexVault } from './index-vault.js';
+import { migrateVaultContent } from './migrate-vault.js';
+import { getLastConfiguredVaultForKey, setLastConfiguredVaultForKey } from '../infrastructure/vault-migration-state.js';
+export const autoMigrateConfiguredVaultIfChanged = async (input) => {
+    const configKey = input.configKey.trim();
+    const configuredVault = input.configuredVault.trim();
+    if (configKey.length === 0 || configuredVault.length === 0) {
+        return {
+            changed: false,
+            migrated: false
+        };
+    }
+    const previousVault = await getLastConfiguredVaultForKey(configKey);
+    if (!previousVault) {
+        await setLastConfiguredVaultForKey(configKey, configuredVault);
+        return {
+            changed: false,
+            migrated: false
+        };
+    }
+    if (previousVault === configuredVault) {
+        return {
+            changed: false,
+            migrated: false
+        };
+    }
+    const migration = await migrateVaultContent(previousVault, configuredVault);
+    const shouldIndex = migration.copied + migration.conflicted > 0;
+    if (shouldIndex) {
+        await indexVault(configuredVault);
+    }
+    await setLastConfiguredVaultForKey(configKey, configuredVault);
+    return {
+        changed: true,
+        migrated: shouldIndex
+    };
+};

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.142",
   "description": "Local-first knowledge memory for agents with Markdown, backlinks, indexing and context retrieval.",
   "type": "module",
   "license": "MIT",