@andespindola/brainlink 0.1.0-beta.7 → 0.1.0-beta.8

package/README.md

@@ -561,9 +561,11 @@ Every command works with either `brainlink` or `blink`.
 ```bash
 blink init
 blink init ./vault
+blink init ./team-vault --migrate-from ~/.brainlink/vault
 ```
 
 Initializes vault metadata. Without an argument, Brainlink initializes the default vault at `$HOME/.brainlink/vault`.
+When initializing an empty custom vault, existing Markdown content from the default vault is copied into it and reindexed so context is not left behind. Use `--no-migrate-existing` to start with an empty custom vault, or `--migrate-from <vault>` to copy from a specific source. Existing target files are never overwritten; conflicting source files are preserved with a `.conflict-<timestamp>` suffix.
 
 ### `add`
 

package/dist/application/migrate-vault.js

@@ -0,0 +1,61 @@
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, extname, isAbsolute, join, relative } from 'node:path';
+import { ensureVault, listVaultFiles, resolveVaultPath } from '../infrastructure/file-system-vault.js';
+const directoryMode = 0o700;
+const fileMode = 0o600;
+const timestamp = () => new Date().toISOString().replace(/[-:]/g, '').replace(/\..+$/, 'Z');
+const isPathInside = (parent, child) => {
+    const path = relative(parent, child);
+    return path === '' || (!path.startsWith('..') && !isAbsolute(path));
+};
+const conflictPath = (targetPath) => {
+    const extension = extname(targetPath);
+    const base = extension ? targetPath.slice(0, -extension.length) : targetPath;
+    return `${base}.conflict-${timestamp()}${extension}`;
+};
+const writePreservedFile = async (absolutePath, content) => {
+    await mkdir(dirname(absolutePath), { recursive: true, mode: directoryMode });
+    await writeFile(absolutePath, content, { mode: fileMode });
+    await chmod(absolutePath, fileMode);
+};
+export const migrateVaultContent = async (sourceVault, targetVault) => {
+    const source = await ensureVault(sourceVault);
+    const target = await ensureVault(targetVault);
+    if (source === target) {
+        return { source, target, copied: 0, unchanged: 0, conflicted: 0 };
+    }
+    const sourceFiles = await listVaultFiles(source);
+    const migrated = await sourceFiles.reduce(async (statePromise, sourceFile) => {
+        const state = await statePromise;
+        const targetFile = join(target, relative(source, sourceFile));
+        if (!isPathInside(target, targetFile)) {
+            return state;
+        }
+        const sourceContent = await readFile(sourceFile);
+        try {
+            const targetContent = await readFile(targetFile);
+            if (sourceContent.equals(targetContent)) {
+                return { ...state, unchanged: state.unchanged + 1 };
+            }
+            await writePreservedFile(conflictPath(targetFile), sourceContent);
+            return { ...state, conflicted: state.conflicted + 1 };
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !('code' in error) || error.code !== 'ENOENT') {
+                throw error;
+            }
+            await writePreservedFile(targetFile, sourceContent);
+            return { ...state, copied: state.copied + 1 };
+        }
+    }, Promise.resolve({ source, target, copied: 0, unchanged: 0, conflicted: 0 }));
+    return migrated;
+};
+export const shouldMigrateDefaultVault = async (sourceVault, targetVault) => {
+    const source = resolveVaultPath(sourceVault);
+    const target = resolveVaultPath(targetVault);
+    if (source === target) {
+        return false;
+    }
+    const [sourceFiles, targetFiles] = await Promise.all([listVaultFiles(source), listVaultFiles(target)]);
+    return sourceFiles.length > 0 && targetFiles.length === 0;
+};

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

@@ -1,9 +1,11 @@
 import { readFileSync } from 'node:fs';
 import { addNote } from '../../application/add-note.js';
 import { indexVault } from '../../application/index-vault.js';
+import { migrateVaultContent, shouldMigrateDefaultVault } from '../../application/migrate-vault.js';
 import { startServer } from '../../application/start-server.js';
 import { startVaultWatcher } from '../../application/watch-vault.js';
 import { doctorVault } from '../../application/analyze-vault.js';
+import { defaultBrainlinkConfig } from '../../infrastructure/config.js';
 import { loadBrainlinkConfig } from '../../infrastructure/config.js';
 import { assertVaultAllowed, ensureVault } from '../../infrastructure/file-system-vault.js';
 import { parsePositiveInteger, print, resolveOptions } from '../runtime.js';
@@ -20,12 +22,26 @@ export const registerWriteCommands = (program) => {
     program
         .command('init')
         .argument('[vault]', 'vault directory')
+        .option('--migrate-from <vault>', 'copy existing vault content into the initialized vault')
+        .option('--no-migrate-existing', 'skip automatic migration from the default Brainlink vault into an empty custom vault')
         .option('--json', 'print machine-readable JSON')
         .description('initialize a Brainlink vault')
         .action(async (vault, options) => {
         const config = await loadBrainlinkConfig();
-        const path = await ensureVault(assertVaultAllowed(vault ?? config.vault, config.allowedVaults));
-        print(options.json, { path }, () => `Initialized Brainlink vault at ${path}`);
+        const targetVault = assertVaultAllowed(vault ?? config.vault, config.allowedVaults);
+        const path = await ensureVault(targetVault);
+        const explicitSource = options.migrateFrom ? assertVaultAllowed(options.migrateFrom, config.allowedVaults) : undefined;
+        const shouldAutoMigrate = explicitSource === undefined &&
+            options.migrateExisting !== false &&
+            (await shouldMigrateDefaultVault(defaultBrainlinkConfig.vault, targetVault));
+        const migration = explicitSource || shouldAutoMigrate ? await migrateVaultContent(explicitSource ?? defaultBrainlinkConfig.vault, targetVault) : undefined;
+        const index = migration && migration.copied + migration.conflicted > 0 ? await indexVault(targetVault) : undefined;
+        print(options.json, { path, ...(migration ? { migration } : {}), ...(index ? { index } : {}) }, () => {
+            const migrated = migration
+                ? ` Migrated ${migration.copied} files, preserved ${migration.conflicted} conflicts and kept ${migration.unchanged} unchanged files.`
+                : '';
+            return `Initialized Brainlink vault at ${path}.${migrated}`;
+        });
     });
     program
         .command('add')

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/docs/AGENT_USAGE.md

@@ -341,7 +341,7 @@ $HOME/.brainlink/vault/
   .brainlink/
 ```
 
-`blink init ./vault` creates a custom vault instead.
+`blink init ./vault` creates a custom vault instead. If the custom vault is empty and the default `$HOME/.brainlink/vault` already has Markdown memory, Brainlink copies that content into the custom vault and reindexes it. Use `blink init ./vault --no-migrate-existing` to intentionally start empty, or `blink init ./vault --migrate-from <old-vault>` to migrate from a specific previous vault. Existing target files are not overwritten; conflicting source files are preserved with a `.conflict-<timestamp>` suffix.
 
 ### Add A Note
 

package/package.json

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