@andespindola/brainlink 0.1.0-beta.24 → 0.1.0-beta.26

package/README.md

@@ -668,6 +668,18 @@ blink migrate-vault --from ~/.brainlink/vault --to ./team-vault --report ./migra
 Runs explicit markdown migration between vaults while preserving conflicts as `.conflict-<timestamp>` files.  
 Use `--dry-run` to preview `copied`, `conflicted` and `unchanged` counts before writing.
 
+### `db-import`
+
+```bash
+blink db-import --vault ./team-vault
+blink db-import --vault ./team-vault --db ./legacy/brainlink.db
+blink db-import --vault ./team-vault --db ./legacy/brainlink.db --table legacy_notes --dry-run
+```
+
+Imports durable memory from a legacy SQLite database into Markdown notes (`agents/<agent-id>/*.md`) and reindexes by default.
+When `--db` is omitted, Brainlink auto-detects common legacy paths such as `<vault>/.brainlink/brainlink.db`.
+Use `--agent <id>` to force all imported rows into one namespace, `--limit` for incremental imports, `--dry-run` to preview without writing files, and `--no-index` to defer reindexing.
+
 ### `init`
 
 ```bash

package/dist/application/frontend/client-js.js

@@ -156,14 +156,14 @@ const graphBounds = nodes => {
 }
 
 const fitScaleBiasByNodeCount = nodeCount => {
-  if (nodeCount <= 6) return 2.4
-  if (nodeCount <= 20) return 1.9
-  if (nodeCount <= 60) return 1.5
-  if (nodeCount <= 180) return 1.25
-  if (nodeCount <= 600) return 1.05
+  if (nodeCount <= 6) return 2.8
+  if (nodeCount <= 20) return 2.2
+  if (nodeCount <= 60) return 1.72
+  if (nodeCount <= 180) return 1.34
+  if (nodeCount <= 600) return 1.08
   if (nodeCount <= 2000) return 0.9
   if (nodeCount <= 6000) return 0.72
-  return 0.62
+  return 0.58
 }
 
 const fitView = (options = { useFiltered: true }) => {
@@ -178,13 +178,34 @@ const fitView = (options = { useFiltered: true }) => {
     return
   }
 
-  const padding = 100
+  const paddingByNodeCount = nodeCount => {
+    if (nodeCount <= 6) return 28
+    if (nodeCount <= 20) return 44
+    if (nodeCount <= 60) return 68
+    if (nodeCount <= 180) return 86
+    if (nodeCount <= 600) return 110
+    if (nodeCount <= 2000) return 140
+    return 180
+  }
+  const minFitScaleByNodeCount = nodeCount => {
+    if (nodeCount <= 6) return 2.4
+    if (nodeCount <= 20) return 1.8
+    if (nodeCount <= 60) return 1.2
+    if (nodeCount <= 180) return 0.86
+    if (nodeCount <= 600) return 0.58
+    if (nodeCount <= 2000) return 0.34
+    if (nodeCount <= 6000) return 0.2
+    return 0.13
+  }
+
+  const padding = paddingByNodeCount(nodes.length)
   const scaleX = width / (bounds.width + padding * 2)
   const scaleY = height / (bounds.height + padding * 2)
   const fitScale = clampScale(Math.min(scaleX, scaleY))
   const biasedScale = clampScale(fitScale * fitScaleBiasByNodeCount(nodes.length))
+  const minimumScale = minFitScaleByNodeCount(nodes.length)
   const minimumLargeGraphScale = nodes.length > largeGraphNodeThreshold ? 0.13 : zoomRange.min
-  const scale = Math.max(biasedScale, minimumLargeGraphScale)
+  const scale = Math.max(biasedScale, minimumScale, minimumLargeGraphScale)
   const centerX = (bounds.minX + bounds.maxX) / 2
   const centerY = (bounds.minY + bounds.maxY) / 2
 
@@ -653,16 +674,17 @@ const zoomAtPoint = (screenX, screenY, factor) => {
 
 const wheelZoomFactor = event => {
   const isModifierZoom = event.metaKey || event.ctrlKey
-  const delta = Math.abs(event.deltaY)
+  const deltaModeFactor = event.deltaMode === 1 ? 16 : event.deltaMode === 2 ? 120 : 1
+  const normalizedDelta = Math.min(Math.abs(event.deltaY * deltaModeFactor), 1200) / 220
 
-  if (delta < 1) {
-    return event.deltaY < 0 ? 1.04 : 0.96
+  if (normalizedDelta <= 0.0001) {
+    return 1
   }
 
-  const zoomInFactor = isModifierZoom ? 1.12 : 1.08
-  const zoomOutFactor = isModifierZoom ? 0.88 : 0.92
+  const sensitivity = isModifierZoom ? 0.2 : 0.14
+  const direction = event.deltaY < 0 ? 1 : -1
 
-  return event.deltaY < 0 ? zoomInFactor : zoomOutFactor
+  return Math.exp(direction * normalizedDelta * sensitivity)
 }
 
 const bindEvents = () => {
@@ -749,6 +771,9 @@ const bindEvents = () => {
     state.pointer = { x: 0, y: 0, down: false, dragNode: null, moved: false }
     canvas.releasePointerCapture(event.pointerId)
   })
+  canvas.addEventListener('pointercancel', () => {
+    state.pointer = { x: 0, y: 0, down: false, dragNode: null, moved: false }
+  })
 }
 
 const loadAgents = async () => {

package/dist/application/import-legacy-sqlite.js

@@ -0,0 +1,280 @@
+import { execFile } from 'node:child_process';
+import { access } from 'node:fs/promises';
+import { basename, extname, join, relative, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { extractTags, extractWikiLinks } from '../domain/markdown.js';
+import { sanitizeAgentId, sharedAgentId } from '../domain/agents.js';
+import { ensureVault, listVaultFiles, writeMarkdownFile } from '../infrastructure/file-system-vault.js';
+import { getBrainlinkHomePath } from '../infrastructure/paths.js';
+const execFileAsync = promisify(execFile);
+const fieldSeparator = '\u001f';
+const rowSeparator = '\u001e';
+const contentColumnCandidates = ['content', 'markdown', 'body', 'text', 'note'];
+const titleColumnCandidates = ['title', 'note_title', 'name', 'headline'];
+const pathColumnCandidates = ['path', 'file_path', 'filepath', 'source_path', 'source'];
+const agentColumnCandidates = ['agent', 'agent_id', 'namespace', 'scope'];
+const tagColumnCandidates = ['tags', 'tag_list', 'keywords'];
+const createdColumnCandidates = ['created_at', 'createdat', 'created', 'ctime'];
+const updatedColumnCandidates = ['updated_at', 'updatedat', 'updated', 'mtime'];
+const systemHubTitle = 'Memory Hub';
+const systemRootTitle = 'Knowledge Root';
+const normalizeTitle = (title) => title.trim().replace(/\.md$/i, '').toLowerCase();
+const slugify = (title) => title
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+const quoteIdentifier = (value) => `"${value.replaceAll('"', '""')}"`;
+const pickColumn = (columns, candidates) => {
+    const byLower = new Map(columns.map((column) => [column.toLowerCase(), column]));
+    return candidates.map((candidate) => byLower.get(candidate)).find((column) => Boolean(column)) ?? null;
+};
+const parseDelimitedRows = (rawOutput) => {
+    const normalized = rawOutput.trim();
+    if (normalized.length === 0) {
+        return [];
+    }
+    return normalized
+        .split(rowSeparator)
+        .map((row) => row.trim())
+        .filter(Boolean)
+        .map((row) => row.split(fieldSeparator));
+};
+const runSqliteQuery = async (databasePath, sql) => {
+    try {
+        const { stdout } = await execFileAsync('sqlite3', ['-readonly', '-noheader', '-separator', fieldSeparator, '-newline', rowSeparator, databasePath, sql], { maxBuffer: 1024 * 1024 * 64 });
+        return parseDelimitedRows(stdout);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const lower = message.toLowerCase();
+        if (lower.includes('enoent') || lower.includes('not found')) {
+            throw new Error('sqlite3 CLI was not found. Install sqlite3 to use db-import.');
+        }
+        throw new Error(`Unable to read SQLite database: ${message}`);
+    }
+};
+const detectLegacyDbPath = async (vaultPath, explicitPath) => {
+    if (explicitPath) {
+        return resolve(explicitPath);
+    }
+    const vaultRoot = await ensureVault(vaultPath);
+    const candidates = [
+        join(vaultRoot, '.brainlink', 'brainlink.db'),
+        join(vaultRoot, '.brainlink', 'index.db'),
+        join(getBrainlinkHomePath(), 'brainlink.db'),
+        join(getBrainlinkHomePath(), 'vault', '.brainlink', 'brainlink.db')
+    ];
+    for (const candidate of candidates) {
+        try {
+            await access(candidate);
+            return candidate;
+        }
+        catch { }
+    }
+    throw new Error(`No legacy SQLite database found. Checked: ${candidates.join(', ')}. Use --db <path-to-db> to import explicitly.`);
+};
+const listTables = async (dbPath) => {
+    const rows = await runSqliteQuery(dbPath, `SELECT name
+     FROM sqlite_master
+     WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+     ORDER BY name`);
+    return rows.map((columns) => columns[0]).filter(Boolean);
+};
+const listColumns = async (dbPath, table) => {
+    const rows = await runSqliteQuery(dbPath, `PRAGMA table_info(${quoteIdentifier(table)})`);
+    return rows.map((columns) => columns[1]).filter(Boolean);
+};
+const tableScore = (columns) => {
+    const contentColumn = pickColumn(columns, contentColumnCandidates);
+    const titleColumn = pickColumn(columns, titleColumnCandidates);
+    const pathColumn = pickColumn(columns, pathColumnCandidates);
+    const agentColumn = pickColumn(columns, agentColumnCandidates);
+    return (contentColumn ? 6 : 0) + (titleColumn ? 4 : 0) + (pathColumn ? 2 : 0) + (agentColumn ? 1 : 0);
+};
+const detectTableMapping = async (dbPath, tableOverride) => {
+    const tables = await listTables(dbPath);
+    if (tables.length === 0) {
+        throw new Error('Legacy SQLite database has no readable tables.');
+    }
+    const mappings = await Promise.all(tables.map(async (table) => {
+        const columns = await listColumns(dbPath, table);
+        return {
+            table,
+            columns,
+            titleColumn: pickColumn(columns, titleColumnCandidates),
+            contentColumn: pickColumn(columns, contentColumnCandidates),
+            pathColumn: pickColumn(columns, pathColumnCandidates),
+            agentColumn: pickColumn(columns, agentColumnCandidates),
+            tagsColumn: pickColumn(columns, tagColumnCandidates),
+            createdColumn: pickColumn(columns, createdColumnCandidates),
+            updatedColumn: pickColumn(columns, updatedColumnCandidates),
+            score: tableScore(columns)
+        };
+    }));
+    if (tableOverride) {
+        const overridden = mappings.find((mapping) => mapping.table === tableOverride);
+        if (!overridden) {
+            throw new Error(`Table not found in SQLite database: ${tableOverride}`);
+        }
+        if (!overridden.contentColumn) {
+            throw new Error(`Table ${tableOverride} does not expose a readable content column.`);
+        }
+        return { mapping: overridden, detectedTables: tables };
+    }
+    const selected = [...mappings]
+        .filter((mapping) => mapping.contentColumn)
+        .sort((left, right) => right.score - left.score)[0];
+    if (!selected) {
+        throw new Error('Could not detect a legacy table with content column in SQLite database.');
+    }
+    return { mapping: selected, detectedTables: tables };
+};
+const hexExpression = (column) => column ? `hex(COALESCE(CAST(${quoteIdentifier(column)} AS BLOB), X''))` : `hex(X'')`;
+const decodeHexUtf8 = (value) => value ? Buffer.from(value, 'hex').toString('utf8') : '';
+const parseLegacyTags = (value) => Array.from(new Set(value
+    .split(/[\s,;|]+/)
+    .map((item) => item.trim().replace(/^#/, '').toLowerCase())
+    .filter((item) => /^[a-z0-9][a-z0-9_-]*$/i.test(item))));
+const titleFromPath = (pathValue) => basename(pathValue).replace(extname(pathValue), '').replace(/[-_]+/g, ' ').trim();
+const appendMissingTags = (content, tags) => {
+    if (tags.length === 0) {
+        return content;
+    }
+    const existingTags = new Set(extractTags(content).map((tag) => tag.toLowerCase()));
+    const missing = tags.filter((tag) => !existingTags.has(tag.toLowerCase()));
+    if (missing.length === 0) {
+        return content;
+    }
+    return `${content.trim()}\n\nTags: ${missing.map((tag) => `#${tag}`).join(' ')}`;
+};
+const buildNote = (title, content, agentId) => [
+    '---',
+    `title: "${title.replaceAll('"', '\\"')}"`,
+    `agent: "${agentId}"`,
+    '---',
+    '',
+    `# ${title}`,
+    '',
+    content.trim(),
+    ''
+].join('\n');
+const parseLegacyRow = (columns, rowIndex) => {
+    const [titleHex, contentHex, pathHex, agentHex, tagsHex] = columns;
+    const content = decodeHexUtf8(contentHex).trim();
+    const path = decodeHexUtf8(pathHex).trim();
+    const titleCandidate = decodeHexUtf8(titleHex).trim();
+    const fallbackTitleFromPath = path ? titleFromPath(path) : '';
+    const title = titleCandidate || fallbackTitleFromPath || `Imported Memory ${rowIndex + 1}`;
+    return {
+        title,
+        content,
+        path,
+        agent: decodeHexUtf8(agentHex).trim(),
+        tags: parseLegacyTags(decodeHexUtf8(tagsHex))
+    };
+};
+const noteRelativePath = (agentId, slug, suffix = 0) => `agents/${agentId}/${suffix > 0 ? `${slug}-${suffix + 1}` : slug || 'untitled'}.md`;
+const reserveUniquePath = (agentId, title, reserved) => {
+    const slug = slugify(title);
+    for (let suffix = 0; suffix < 10_000; suffix += 1) {
+        const relativePath = noteRelativePath(agentId, slug, suffix);
+        if (!reserved.has(relativePath)) {
+            reserved.add(relativePath);
+            return relativePath;
+        }
+    }
+    throw new Error(`Could not allocate unique path for imported note: ${title}`);
+};
+const ensureSystemNote = async (vaultPath, reserved, created, agentId, title, content, dryRun) => {
+    const filename = noteRelativePath(agentId, slugify(title));
+    if (reserved.has(filename)) {
+        return;
+    }
+    reserved.add(filename);
+    created.add(filename);
+    if (dryRun) {
+        return;
+    }
+    await writeMarkdownFile(vaultPath, filename, buildNote(title, content, agentId));
+};
+const applyConnectivityRule = async (vaultPath, reserved, created, title, content, agentId, dryRun) => {
+    const links = extractWikiLinks(content).filter((link) => normalizeTitle(link) !== normalizeTitle(title));
+    if (links.length > 0) {
+        return content.trim();
+    }
+    const normalized = normalizeTitle(title);
+    if (normalized === normalizeTitle(systemHubTitle)) {
+        await ensureSystemNote(vaultPath, reserved, created, agentId, systemRootTitle, `Entry point for agent memory. [[${systemHubTitle}]] #memory #root`, dryRun);
+        return `${content.trim()}\n\nRelated: [[${systemRootTitle}]]`;
+    }
+    await ensureSystemNote(vaultPath, reserved, created, agentId, systemHubTitle, 'Central memory index for this agent namespace. #memory #hub', dryRun);
+    return `${content.trim()}\n\nRelated: [[${systemHubTitle}]]`;
+};
+const importRowsFromMapping = async (vaultPath, dbPath, mapping, options, reserved) => {
+    const limit = Number.isFinite(options.limit) && (options.limit ?? 0) > 0 ? Math.floor(options.limit ?? 0) : undefined;
+    const sql = [
+        'SELECT',
+        `${hexExpression(mapping.titleColumn)} AS title_hex,`,
+        `${hexExpression(mapping.contentColumn)} AS content_hex,`,
+        `${hexExpression(mapping.pathColumn)} AS path_hex,`,
+        `${hexExpression(mapping.agentColumn)} AS agent_hex,`,
+        `${hexExpression(mapping.tagsColumn)} AS tags_hex,`,
+        `${hexExpression(mapping.createdColumn)} AS created_hex,`,
+        `${hexExpression(mapping.updatedColumn)} AS updated_hex`,
+        `FROM ${quoteIdentifier(mapping.table)}`,
+        ...(limit ? [`LIMIT ${limit}`] : [])
+    ].join(' ');
+    const rows = await runSqliteQuery(dbPath, sql);
+    const createdSystemNotes = new Set();
+    const importedFiles = [];
+    let imported = 0;
+    let skipped = 0;
+    for (let rowIndex = 0; rowIndex < rows.length; rowIndex += 1) {
+        const row = parseLegacyRow(rows[rowIndex], rowIndex);
+        if (!row.content) {
+            skipped += 1;
+            continue;
+        }
+        const agentId = sanitizeAgentId(options.agentOverride || row.agent || sharedAgentId);
+        const filename = reserveUniquePath(agentId, row.title, reserved);
+        const mergedContent = appendMissingTags(row.content, row.tags);
+        const connectedContent = await applyConnectivityRule(vaultPath, reserved, createdSystemNotes, row.title, mergedContent, agentId, options.dryRun === true);
+        const note = buildNote(row.title, connectedContent, agentId);
+        if (options.dryRun !== true) {
+            await writeMarkdownFile(vaultPath, filename, note);
+        }
+        importedFiles.push(filename);
+        imported += 1;
+    }
+    return {
+        rowsRead: rows.length,
+        imported,
+        skipped,
+        createdSystemNotes: createdSystemNotes.size,
+        importedFiles
+    };
+};
+export const importLegacySqliteDatabase = async (vaultPath, options = {}) => {
+    const vault = await ensureVault(vaultPath);
+    const dbPath = await detectLegacyDbPath(vaultPath, options.dbPath);
+    const { mapping, detectedTables } = await detectTableMapping(dbPath, options.table);
+    const existingFiles = (await listVaultFiles(vaultPath))
+        .filter((path) => extname(path).toLowerCase() === '.md')
+        .map((path) => relative(vault, path));
+    const reserved = new Set(existingFiles);
+    const imported = await importRowsFromMapping(vaultPath, dbPath, mapping, options, reserved);
+    return {
+        vault,
+        dbPath,
+        table: mapping.table,
+        detectedTables,
+        rowsRead: imported.rowsRead,
+        imported: imported.imported,
+        skipped: imported.skipped,
+        createdSystemNotes: imported.createdSystemNotes,
+        dryRun: options.dryRun === true,
+        importedFiles: imported.importedFiles
+    };
+};

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

@@ -3,6 +3,7 @@ import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname, relative, resolve } from 'node:path';
 import { addNote } from '../../application/add-note.js';
 import { buildContextPackage } from '../../application/build-context.js';
+import { importLegacySqliteDatabase } from '../../application/import-legacy-sqlite.js';
 import { indexVault } from '../../application/index-vault.js';
 import { migrateVaultContent, planVaultMigration, previewVaultMigration, shouldMigrateDefaultVault } from '../../application/migrate-vault.js';
 import { startServer } from '../../application/start-server.js';
@@ -99,6 +100,37 @@ export const registerWriteCommands = (program) => {
             return `${summary}${indexMessage}${reportMessage}`;
         });
     });
+    program
+        .command('db-import')
+        .option('-v, --vault <vault>', 'vault directory')
+        .option('--db <path>', 'legacy SQLite database path (default: <vault>/.brainlink/brainlink.db)')
+        .option('--table <name>', 'legacy table name override')
+        .option('-a, --agent <agent>', 'force imported notes into a target agent namespace')
+        .option('-l, --limit <limit>', 'maximum number of rows to import')
+        .option('--dry-run', 'preview import without writing Markdown files')
+        .option('--no-index', 'skip reindexing after import')
+        .option('--json', 'print machine-readable JSON')
+        .description('import legacy SQLite memory into Markdown vault and current index model')
+        .action(async (options) => {
+        const resolved = await resolveOptions(options);
+        const result = await importLegacySqliteDatabase(resolved.vault, {
+            dbPath: options.db,
+            table: options.table,
+            agentOverride: options.agent ? resolved.agent : undefined,
+            limit: options.limit ? parsePositiveInteger(options.limit, 100_000) : undefined,
+            dryRun: Boolean(options.dryRun)
+        });
+        const shouldIndex = options.index !== false && !result.dryRun && result.imported > 0;
+        const index = shouldIndex ? await indexVault(resolved.vault) : undefined;
+        print(options.json, { ...result, ...(index ? { index } : {}) }, () => {
+            const summary = `Imported ${result.imported}/${result.rowsRead} rows from ${result.table} (skipped ${result.skipped}).`;
+            const indexMessage = index
+                ? ` Indexed ${index.documentCount} documents, ${index.chunkCount} chunks and ${index.linkCount} links.`
+                : '';
+            const dryRunMessage = result.dryRun ? ' Dry run only; no files were written.' : '';
+            return `${summary}${indexMessage}${dryRunMessage}`;
+        });
+    });
     program
         .command('add')
         .argument('<title>', 'note title')

package/docs/AGENT_USAGE.md

@@ -377,6 +377,18 @@ blink migrate-vault --from ~/.brainlink/vault --to ./team-vault --report ./migra
 
 Use `--dry-run` to preview `copied`, `conflicted`, `unchanged` before writing files.
 
+### Import Legacy SQLite DB
+
+```bash
+blink db-import --vault ./team-vault
+blink db-import --vault ./team-vault --db ./legacy/brainlink.db
+blink db-import --vault ./team-vault --db ./legacy/brainlink.db --table legacy_notes --dry-run
+```
+
+`db-import` migrates rows from legacy SQLite memory into Markdown notes in the current vault and indexes the result by default.
+Without `--db`, Brainlink auto-detects common legacy database paths.
+Use `--agent` to force namespace, `--limit` for staged migration, `--dry-run` to preview writes, and `--no-index` to postpone indexing.
+
 ### Install Agent Integration
 
 ```bash

package/docs/QUICKSTART.md

@@ -102,3 +102,10 @@ S3 target:
 ```bash
 blink migrate-vault --from ~/.brainlink/vault --to "s3://my-memory-bucket/brainlink" --dry-run
 ```
+
+Legacy SQLite import:
+
+```bash
+blink db-import --vault ./team-vault
+blink db-import --vault ./team-vault --db ./legacy/brainlink.db --dry-run
+```

package/package.json

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