@andespindola/brainlink 0.1.0-beta.16 → 0.1.0-beta.160

package/dist/application/get-graph-view.js

@@ -0,0 +1,246 @@
+import { getGraphLayout } from './get-graph-layout.js';
+const macroScale = 0.24;
+const microCoverage = 0.72;
+const nodeLimit = 1000;
+const edgeLimit = 1400;
+const groupEdgeLimit = 900;
+const inViewport = (item, input) => {
+    const radius = item.radius ?? 48;
+    return (item.x + radius >= input.x &&
+        item.x - radius <= input.x + input.width &&
+        item.y + radius >= input.y &&
+        item.y - radius <= input.y + input.height);
+};
+const groupCoverage = (group, input) => {
+    const viewportRadius = Math.max(input.width, input.height) / 2;
+    const centerX = input.x + input.width / 2;
+    const centerY = input.y + input.height / 2;
+    const centerDistance = Math.hypot(group.x - centerX, group.y - centerY);
+    const fitCoverage = Math.min(1, childGraphRenderRadius(group) / Math.max(viewportRadius, 1));
+    const centerCoverage = 1 - Math.min(1, centerDistance / Math.max(viewportRadius, 1));
+    return fitCoverage * 0.72 + centerCoverage * 0.28;
+};
+const childGraphRenderRadius = (group) => {
+    const childCount = Math.max(group.nodeIds.length, group.childGroupIds.length, 1);
+    return Math.max(420, Math.min(1800, Math.sqrt(childCount) * 24));
+};
+const groupRenderRadius = (group) => {
+    const childCount = Math.max(group.nodeIds.length, group.childGroupIds.length, 1);
+    return 10 + Math.min(Math.log2(childCount + 1) * 4.2, 22);
+};
+const arrangeGraphLevelGroups = (groups) => {
+    if (groups.length <= 1) {
+        return groups.map((group) => ({ ...group, radius: groupRenderRadius(group) }));
+    }
+    const centerGroup = groups
+        .map((group) => ({
+        group,
+        score: Math.max(group.nodeIds.length, group.childGroupIds.length, 1) + group.externalEdges.length
+    }))
+        .sort((left, right) => right.score - left.score || left.group.title.localeCompare(right.group.title))[0]?.group;
+    const outerGroups = groups
+        .filter((group) => group.id !== centerGroup?.id)
+        .sort((left, right) => left.segment.localeCompare(right.segment) || left.title.localeCompare(right.title));
+    const baseRadius = Math.max(520, Math.min(2200, Math.sqrt(groups.length) * 135));
+    const goldenAngle = Math.PI * (3 - Math.sqrt(5));
+    const arranged = centerGroup
+        ? [{ ...centerGroup, x: 0, y: 0, radius: groupRenderRadius(centerGroup) }]
+        : [];
+    outerGroups.forEach((group, index) => {
+        const ringRadius = baseRadius * Math.sqrt((index + 1) / Math.max(outerGroups.length, 1));
+        const angle = index * goldenAngle;
+        arranged.push({
+            ...group,
+            x: Math.cos(angle) * ringRadius,
+            y: Math.sin(angle) * ringRadius,
+            radius: groupRenderRadius(group)
+        });
+    });
+    return arranged;
+};
+const distanceToViewportCenter = (item, input) => {
+    const centerX = input.x + input.width / 2;
+    const centerY = input.y + input.height / 2;
+    return Math.hypot(item.x - centerX, item.y - centerY);
+};
+const selectViewportItemsWithFill = (items, input, limit = nodeLimit) => {
+    const visible = items.filter((item) => inViewport(item, input));
+    if (visible.length >= limit) {
+        return visible.slice(0, limit);
+    }
+    const selectedIds = new Set(visible.map((item) => item.id));
+    const fill = items
+        .filter((item) => !selectedIds.has(item.id))
+        .sort((left, right) => distanceToViewportCenter(left, input) - distanceToViewportCenter(right, input) || left.id.localeCompare(right.id))
+        .slice(0, Math.max(0, limit - visible.length));
+    return visible.concat(fill);
+};
+const groupNode = (group) => [
+    `group:${group.id}`,
+    group.title,
+    group.x,
+    group.y,
+    group.group,
+    group.segment,
+    'group'
+];
+const realNode = (node) => [
+    node.id,
+    node.title,
+    node.x,
+    node.y,
+    node.group,
+    node.segment,
+    'node'
+];
+const descendants = (group, groupById) => group.nodeIds.length > 0
+    ? group.nodeIds
+    : group.childGroupIds.flatMap((childId) => {
+        const child = groupById.get(childId);
+        return child ? descendants(child, groupById) : [];
+    });
+const aggregateGroupEdges = (groups, edges, groupById) => {
+    const groupNodeByNodeId = new Map();
+    groups.forEach((group) => {
+        descendants(group, groupById).forEach((nodeId) => groupNodeByNodeId.set(nodeId, `group:${group.id}`));
+    });
+    const selected = new Map();
+    edges.forEach((edge) => {
+        if (!edge.target)
+            return;
+        const source = groupNodeByNodeId.get(edge.source);
+        const target = groupNodeByNodeId.get(edge.target);
+        if (!source || !target || source === target)
+            return;
+        const key = source < target ? `${source}|${target}` : `${target}|${source}`;
+        const current = selected.get(key);
+        if (current && current[2] >= edge.weight)
+            return;
+        selected.set(key, [source, target, edge.weight, edge.priority]);
+    });
+    const degreeCounts = new Map();
+    return Array.from(selected.values())
+        .sort((left, right) => right[2] - left[2] || left[0].localeCompare(right[0]) || left[1].localeCompare(right[1]))
+        .filter((edge) => {
+        const sourceCount = degreeCounts.get(edge[0]) ?? 0;
+        const targetCount = degreeCounts.get(edge[1]) ?? 0;
+        if (sourceCount >= 3 || targetCount >= 3) {
+            return false;
+        }
+        degreeCounts.set(edge[0], sourceCount + 1);
+        degreeCounts.set(edge[1], targetCount + 1);
+        return true;
+    })
+        .slice(0, groupEdgeLimit);
+};
+const realEdges = (edges, nodeIds) => edges
+    .filter((edge) => Boolean(edge.target && nodeIds.has(edge.source) && nodeIds.has(edge.target)))
+    .slice(0, edgeLimit)
+    .map((edge) => [edge.source, edge.target, edge.weight, edge.priority]);
+const degreeMap = (edges) => edges.reduce((degrees, edge) => {
+    degrees.set(edge.source, (degrees.get(edge.source) ?? 0) + edge.weight);
+    if (edge.target) {
+        degrees.set(edge.target, (degrees.get(edge.target) ?? 0) + edge.weight);
+    }
+    return degrees;
+}, new Map());
+const arrangeChildGraphNodes = (nodes, group, degrees) => {
+    if (nodes.length <= 1) {
+        return nodes.map((node) => ({ ...node, x: group.x, y: group.y }));
+    }
+    const centerNode = nodes
+        .map((node) => ({
+        node,
+        score: (degrees.get(node.id) ?? 0) + node.tags.length
+    }))
+        .sort((left, right) => right.score - left.score || left.node.title.localeCompare(right.node.title))[0]?.node;
+    const outerNodes = nodes
+        .filter((node) => node.id !== centerNode?.id)
+        .sort((left, right) => {
+        const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
+        if (degreeDelta !== 0)
+            return degreeDelta;
+        return left.title.localeCompare(right.title);
+    });
+    const targetRadius = childGraphRenderRadius(group);
+    const goldenAngle = Math.PI * (3 - Math.sqrt(5));
+    const arranged = centerNode
+        ? [{ ...centerNode, x: group.x, y: group.y }]
+        : [];
+    outerNodes.forEach((node, index) => {
+        const ringRadius = targetRadius * Math.sqrt((index + 1) / Math.max(outerNodes.length, 1));
+        const angle = index * goldenAngle;
+        arranged.push({
+            ...node,
+            x: group.x + Math.cos(angle) * ringRadius,
+            y: group.y + Math.sin(angle) * ringRadius
+        });
+    });
+    return arranged;
+};
+const limitEdges = (edges) => edges.slice(0, edgeLimit);
+export const getGraphView = async (vaultPath, input) => {
+    const { signature, layout } = await getGraphLayout(vaultPath, {
+        agentId: input.agentId,
+        context: input.context
+    });
+    const groups = layout.groups ?? [];
+    const degrees = degreeMap(layout.edges);
+    const groupById = new Map(groups.map((group) => [group.id, group]));
+    if (groups.length === 0) {
+        const nodes = layout.nodes.filter((node) => inViewport(node, input)).slice(0, nodeLimit);
+        const nodeIds = new Set(nodes.map((node) => node.id));
+        const viewNodes = nodes.map(realNode);
+        return {
+            signature,
+            mode: 'flat',
+            nodes: viewNodes,
+            edges: limitEdges(realEdges(layout.edges, nodeIds)),
+            totals: {
+                nodes: layout.nodes.length,
+                edges: layout.edges.length
+            }
+        };
+    }
+    const rootGroups = arrangeGraphLevelGroups(groups.filter((group) => group.parentId === null));
+    const leafGroups = arrangeGraphLevelGroups(groups.filter((group) => group.nodeIds.length > 0));
+    const visibleGroups = selectViewportItemsWithFill(rootGroups, input);
+    const focused = leafGroups
+        .filter((group) => group.nodeIds.length > 0 && inViewport(group, input))
+        .map((group) => ({ group, coverage: groupCoverage(group, input) }))
+        .sort((left, right) => right.coverage - left.coverage)[0];
+    if (focused && input.scale >= macroScale && focused.coverage >= microCoverage) {
+        const nodeIds = new Set(focused.group.nodeIds);
+        const arrangedNodes = arrangeChildGraphNodes(layout.nodes.filter((node) => nodeIds.has(node.id)), focused.group, degrees);
+        const nodesInViewport = arrangedNodes
+            .filter((node) => inViewport(node, input))
+            .slice(0, nodeLimit);
+        const nodes = nodesInViewport.length > 0
+            ? nodesInViewport
+            : arrangedNodes.slice(0, nodeLimit);
+        const visibleNodeIds = new Set(nodes.map((node) => node.id));
+        const viewNodes = nodes.map(realNode);
+        return {
+            signature,
+            mode: 'micro',
+            nodes: viewNodes,
+            edges: limitEdges(realEdges(layout.edges, visibleNodeIds)),
+            totals: {
+                nodes: layout.nodes.length,
+                edges: layout.edges.length
+            }
+        };
+    }
+    const groupsToRender = visibleGroups.slice(0, nodeLimit);
+    const viewNodes = groupsToRender.map(groupNode);
+    return {
+        signature,
+        mode: 'macro',
+        nodes: viewNodes,
+        edges: limitEdges(aggregateGroupEdges(groupsToRender, layout.edges, groupById)),
+        totals: {
+            nodes: layout.nodes.length,
+            edges: layout.edges.length
+        }
+    };
+};

package/dist/application/graph-view-state.js

@@ -0,0 +1,66 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+const stateVersion = 1;
+const graphViewStatePath = (vaultPath) => join(vaultPath, '.brainlink', 'graph-view-state.json');
+const stateKey = (input) => [input.signature, input.agentId ?? 'all-agents', input.context ?? 'all-contexts'].join(':');
+const emptyPersistedState = () => ({
+    version: stateVersion,
+    states: {}
+});
+const readPersistedState = async (vaultPath) => {
+    try {
+        const parsed = JSON.parse(await readFile(graphViewStatePath(vaultPath), 'utf8'));
+        return parsed.version === stateVersion && parsed.states && typeof parsed.states === 'object' ? parsed : emptyPersistedState();
+    }
+    catch {
+        return emptyPersistedState();
+    }
+};
+const writePersistedState = async (vaultPath, state) => {
+    const target = graphViewStatePath(vaultPath);
+    const temp = `${target}.tmp`;
+    await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+    await writeFile(temp, `${JSON.stringify(state)}\n`, { encoding: 'utf8', mode: 0o600 });
+    await rename(temp, target);
+};
+const normalizePositions = (positions) => positions.flatMap((position) => {
+    const id = typeof position.id === 'string' ? position.id.trim() : '';
+    const x = Number(position.x);
+    const y = Number(position.y);
+    return id && Number.isFinite(x) && Number.isFinite(y) ? [{ id, x, y }] : [];
+});
+export const getGraphViewState = async (vaultPath, input) => {
+    const persisted = await readPersistedState(vaultPath);
+    const state = persisted.states[stateKey(input)];
+    return state ?? {
+        ...input,
+        positions: []
+    };
+};
+export const saveGraphViewState = async (vaultPath, input) => {
+    const persisted = await readPersistedState(vaultPath);
+    const nextState = {
+        ...input,
+        positions: normalizePositions(input.positions)
+    };
+    await writePersistedState(vaultPath, {
+        version: stateVersion,
+        states: {
+            ...persisted.states,
+            [stateKey(input)]: nextState
+        }
+    });
+    return nextState;
+};
+export const deleteGraphViewState = async (vaultPath, input) => {
+    const persisted = await readPersistedState(vaultPath);
+    const { [stateKey(input)]: _removed, ...states } = persisted.states;
+    await writePersistedState(vaultPath, {
+        version: stateVersion,
+        states
+    });
+    return {
+        ...input,
+        positions: []
+    };
+};

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

@@ -0,0 +1,266 @@
+import { execFile } from 'node:child_process';
+import { access } from 'node:fs/promises';
+import { basename, extname, join, relative, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { promisify } from 'node:util';
+import { extractTags } 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 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) => {
+    const baseArgs = ['-noheader', '-separator', fieldSeparator, '-newline', rowSeparator, '-cmd', '.timeout 5000'];
+    const runQuery = async (args) => {
+        const { stdout } = await execFileAsync('sqlite3', [...args, sql], { maxBuffer: 1024 * 1024 * 64 });
+        return parseDelimitedRows(stdout);
+    };
+    try {
+        return await runQuery(['--readonly', ...baseArgs, databasePath]);
+    }
+    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.');
+        }
+        if (lower.includes('database is locked') || lower.includes('(5)')) {
+            try {
+                const uri = pathToFileURL(databasePath);
+                uri.search = 'mode=ro&immutable=1';
+                return await runQuery(['-uri', ...baseArgs, uri.toString()]);
+            }
+            catch (fallbackError) {
+                const fallbackMessage = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+                throw new Error(`Unable to read SQLite database (locked). Close writers (server/watch/mcp) or rerun with DB idle. Details: ${fallbackMessage}`);
+            }
+        }
+        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 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 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 note = buildNote(row.title, mergedContent.trim(), agentId);
+        if (options.dryRun !== true) {
+            await writeMarkdownFile(vaultPath, filename, note);
+        }
+        importedFiles.push(filename);
+        imported += 1;
+    }
+    return {
+        rowsRead: rows.length,
+        imported,
+        skipped,
+        createdSystemNotes: 0,
+        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
+    };
+};