crbro-memory 2.9.1 → 2.11.0

package/dist/cli/export.js

@@ -0,0 +1,522 @@
+"use strict";
+// ─── crbro-memory export ─────────────────────────────────────────
+//
+// The brain as something the owner can open without CRBRO: an Obsidian-ready
+// Markdown vault, or one JSON file that `import` reads back. Read-only from
+// the brain folder (safe while a daemon or a client runs: nothing is locked,
+// nothing is written there), every text passes through the same redaction
+// learn applies, and the output can never land inside the brain.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENTRY_KINDS = exports.EXPORT_HELP = exports.VAULT_MARKER = exports.EXPORT_FORMAT_VERSION = exports.EXPORT_FORMAT = void 0;
+exports.readBrain = readBrain;
+exports.deepRedact = deepRedact;
+exports.redactNeuron = redactNeuron;
+exports.entriesOf = entriesOf;
+exports.withoutRetired = withoutRetired;
+exports.buildExport = buildExport;
+exports.renderVault = renderVault;
+exports.checkOutDir = checkOutDir;
+exports.runExport = runExport;
+exports.main = main;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
+const brain_js_1 = require("../engine/brain.js");
+const secrets_js_1 = require("../engine/secrets.js");
+const ops_js_1 = require("../sync/ops.js");
+const hash_js_1 = require("../utils/hash.js");
+const version_js_1 = require("../version.js");
+const common_js_1 = require("./common.js");
+const markdown_js_1 = require("./markdown.js");
+exports.EXPORT_FORMAT = 'crbro-export';
+exports.EXPORT_FORMAT_VERSION = 1;
+exports.VAULT_MARKER = '.crbro-export.json';
+exports.EXPORT_HELP = `
+  crbro-memory export [--out <dir>] [--format md|json] [--include-retired]
+
+  Write the brain to a folder you can read without CRBRO. Read-only: the brain
+  is never written, so it is safe while a client or the daemon is running.
+
+    --out <dir>          Where to write. Must be new or empty, and outside the
+                         brain folder. Default: ./crbro-export-<date>-<time>
+    --format md|json     md (default): an Obsidian-compatible vault, one note per
+                         neuron with YAML frontmatter, entries grouped by kind,
+                         synapses as [[wiki links]], one index note per domain,
+                         the day logs and the open items.
+                         json: crbro-export.json, a faithful dump that
+                         \`crbro-memory import\` reads back.
+    --include-retired    Also export superseded and retracted entries (marked).
+
+  Credentials are redacted exactly as crbro_learn does before anything is
+  written. The brain is the one crbro_* tools use: CRBRO_PATH, else ~/.crbro.
+`;
+async function readJsonFile(file) {
+    const raw = await node_fs_1.promises.readFile(file, 'utf8');
+    return JSON.parse(raw.replace(/^/, ''));
+}
+async function readDir(dir, root, unreadable) {
+    let names = [];
+    try {
+        names = (await node_fs_1.promises.readdir(dir)).filter(n => n.endsWith('.json')).sort();
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const n of names) {
+        const file = node_path_1.default.join(dir, n);
+        try {
+            const st = await node_fs_1.promises.lstat(file);
+            if (!st.isFile())
+                continue;
+            const v = await readJsonFile(file);
+            if (v && typeof v === 'object')
+                out.push(v);
+            else
+                unreadable.push(node_path_1.default.relative(root, file));
+        }
+        catch {
+            unreadable.push(node_path_1.default.relative(root, file));
+        }
+    }
+    return out;
+}
+const looksLikeNeuron = (n) => n && typeof n.id === 'string' && typeof n.name === 'string';
+/** Read the brain folder. Nothing is created, locked or written. */
+async function readBrain(root) {
+    const paths = new brain_js_1.BrainPaths(root);
+    const unreadable = [];
+    const live = (await readDir(paths.cortex, root, unreadable)).filter(looksLikeNeuron);
+    const archived = (await readDir(paths.archives, root, unreadable)).filter(looksLikeNeuron)
+        .map(n => ({ ...n, archived: true }));
+    const synapses = (await readDir(paths.synapses, root, unreadable))
+        .filter(s => Array.isArray(s?.nodes) && s.nodes.length === 2);
+    const sessions = (await readDir(paths.hippocampus, root, unreadable))
+        .filter(s => typeof s?.session_id === 'string')
+        .sort((a, b) => String(b.date || b.session_id).localeCompare(String(a.date || a.session_id)));
+    let context = null;
+    try {
+        context = await readJsonFile(paths.activeContext());
+    }
+    catch { /* none yet */ }
+    return { neurons: [...live, ...archived], synapses, sessions, context, unreadable };
+}
+// ─── Redaction ───────────────────────────────────────────────────
+/** Redact every string value, recursively. Keys are left alone. Counts the markers placed. */
+function deepRedact(value, counter) {
+    if (typeof value === 'string') {
+        const r = (0, secrets_js_1.redact)(value);
+        counter.n += r.found.length;
+        return r.text;
+    }
+    if (Array.isArray(value))
+        return value.map(v => deepRedact(v, counter));
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[k] = deepRedact(v, counter);
+        return out;
+    }
+    return value;
+}
+const SIDECARS = ['entry_dates', 'entry_status', 'entry_source', 'entry_verified', 'entry_verification'];
+/**
+ * Redact one neuron and keep it coherent: an entry whose text changed gets a
+ * new content id, so its sidecar keys (dates, retirement, verification…) move
+ * with it, and a fact's own id is recomputed.
+ */
+function redactNeuron(n, counter) {
+    const out = deepRedact(n, counter);
+    const rekey = (before, after) => {
+        (before || []).forEach((t, i) => {
+            const t2 = after?.[i];
+            if (t2 === undefined || t2 === t)
+                return;
+            const from = (0, ops_js_1.entryId)(t), to = (0, ops_js_1.entryId)(t2);
+            for (const s of SIDECARS) {
+                const map = out[s];
+                if (map && from in map) {
+                    map[to] = map[from];
+                    delete map[from];
+                }
+            }
+        });
+    };
+    rekey(n.patterns, out.patterns);
+    rekey(n.preferences, out.preferences);
+    rekey(n.errors, out.errors);
+    rekey(n.debts, out.debts);
+    rekey((n.decisions || []).map(d => d.text), (out.decisions || []).map(d => d.text));
+    (n.facts || []).forEach((f, i) => {
+        const g = out.facts?.[i];
+        if (g && g.text !== f.text)
+            g.id = (0, hash_js_1.factId)(g.text);
+    });
+    return out;
+}
+exports.ENTRY_KINDS = ['fact', 'decision', 'pattern', 'preference', 'error', 'debt', 'map'];
+/** Every entry of a neuron, active first by kind, with the metadata that sits in its sidecars. */
+function entriesOf(n, includeRetired) {
+    const out = [];
+    for (const f of n.facts || []) {
+        const status = (f.status || 'active');
+        if (status !== 'active' && !includeRetired)
+            continue;
+        out.push({
+            kind: 'fact', id: f.id || (0, hash_js_1.factId)(f.text), text: f.text, date: f.added || '', status,
+            ...(f.verified ? { verified: f.verified } : {}),
+            ...(f.verification ? { verification: f.verification } : {}),
+            ...(f.keys?.length ? { keywords: f.keys } : {}),
+            ...(typeof f.confidence === 'number' ? { confidence: f.confidence } : {}),
+            ...(f.shelf_life ? { shelf_life: f.shelf_life } : {}),
+            ...(f.temporal ? { temporal: f.temporal } : {}),
+            ...(f.reference ? { reference: f.reference } : {}),
+            ...(f.source && f.source !== 'session' && f.source !== 'manual' && !/^session_/.test(f.source) ? { origin: f.source } : {}),
+            ...(f.revision_note ? { revision_note: f.revision_note } : {}),
+        });
+    }
+    const side = (kind, text, date, extra = {}) => {
+        const id = (0, ops_js_1.entryId)(text);
+        const ret = n.entry_status?.[id];
+        if (ret && !includeRetired)
+            return;
+        out.push({
+            kind, id, text, date: date || n.entry_dates?.[id] || '',
+            status: ret ? ret.status : 'active',
+            ...(n.entry_verified?.[id] ? { verified: n.entry_verified[id] } : {}),
+            ...(n.entry_verification?.[id] ? { verification: n.entry_verification[id] } : {}),
+            ...(n.entry_source?.[id] ? { origin: n.entry_source[id] } : {}),
+            ...(ret?.note ? { revision_note: ret.note } : {}),
+            ...extra,
+        });
+    };
+    for (const d of n.decisions || [])
+        side('decision', d.text, d.date || '', d.rationale ? { rationale: d.rationale } : {});
+    for (const t of n.patterns || [])
+        side('pattern', t, '');
+    for (const t of n.preferences || [])
+        side('preference', t, '');
+    for (const t of n.errors || [])
+        side('error', t, '');
+    for (const t of n.debts || [])
+        side('debt', t, '');
+    if (n.map?.text)
+        out.push({ kind: 'map', id: 'map', text: n.map.text, date: n.map.updated || '', status: 'active' });
+    return out;
+}
+/** The neuron with its retired entries (and their sidecar keys) taken out. */
+function withoutRetired(n) {
+    const retired = new Set(Object.keys(n.entry_status || {}));
+    const keep = (t) => !retired.has((0, ops_js_1.entryId)(t));
+    const out = {
+        ...n,
+        facts: (n.facts || []).filter(f => !f.status || f.status === 'active'),
+        decisions: (n.decisions || []).filter(d => keep(d.text)),
+        patterns: (n.patterns || []).filter(keep),
+        preferences: (n.preferences || []).filter(keep),
+        ...(n.errors ? { errors: n.errors.filter(keep) } : {}),
+        ...(n.debts ? { debts: n.debts.filter(keep) } : {}),
+    };
+    for (const s of SIDECARS) {
+        const map = n[s];
+        if (!map)
+            continue;
+        const kept = Object.fromEntries(Object.entries(map).filter(([k]) => !retired.has(k)));
+        out[s] = kept;
+    }
+    delete out.entry_status;
+    return out;
+}
+function buildExport(snap, includeRetired, nowIso = new Date().toISOString()) {
+    const counter = { n: 0 };
+    const neurons = snap.neurons
+        .map(n => redactNeuron(includeRetired ? n : withoutRetired(n), counter))
+        .sort((a, b) => a.id.localeCompare(b.id));
+    const synapses = deepRedact(snap.synapses, counter);
+    const sessions = deepRedact(snap.sessions, counter);
+    const context = deepRedact(snap.context, counter);
+    const entries = neurons.reduce((s, n) => s + entriesOf(n, includeRetired).length, 0);
+    const openItems = (context?.pending_tasks || []).length;
+    return {
+        format: exports.EXPORT_FORMAT,
+        format_version: exports.EXPORT_FORMAT_VERSION,
+        exported_at: nowIso,
+        crbro_version: version_js_1.RUNNING_VERSION,
+        include_retired: includeRetired,
+        redactions: counter.n,
+        counts: {
+            neurons: neurons.length, archived: neurons.filter(n => n.archived).length, entries,
+            synapses: synapses.length, sessions: sessions.length, open_items: openItems,
+        },
+        neurons, synapses, sessions, context,
+    };
+}
+// ─── Markdown vault ──────────────────────────────────────────────
+const KIND_TITLES = {
+    map: 'Map', error: 'Errors', debt: 'Debts', preference: 'Preferences',
+    pattern: 'Patterns', decision: 'Decisions', fact: 'Facts',
+};
+const SECTION_ORDER = ['map', 'error', 'debt', 'preference', 'pattern', 'decision', 'fact'];
+const day = (iso) => (iso && iso.length >= 10 ? iso.slice(0, 10) : iso || '');
+/** Text for a wiki link alias: no brackets or pipes, one line. */
+const alias = (s) => String(s).replace(/[\[\]|#^]/g, ' ').replace(/\s+/g, ' ').trim() || 'untitled';
+function verificationLabel(e) {
+    if (e.verification) {
+        const ref = e.verification.reference ? ` (${e.verification.reference.kind}: ${e.verification.reference.value})` : '';
+        return `verified: ${e.verification.method} ${day(e.verification.at)}${ref}`;
+    }
+    if (e.verified)
+        return `verified: ${day(e.verified)}`;
+    return 'unverified';
+}
+function metaLine(e) {
+    const parts = [`\`${e.kind}\``];
+    if (e.kind !== 'map')
+        parts.push(`id \`${e.id}\``);
+    parts.push(e.date ? day(e.date) : 'undated');
+    parts.push(e.status === 'active' ? 'active' : `**${e.status}**${e.revision_note ? ` (${e.revision_note.replace(/\s+/g, ' ')})` : ''}`);
+    if (e.kind !== 'map')
+        parts.push(verificationLabel(e));
+    if (e.keywords?.length)
+        parts.push(`keywords: ${e.keywords.join(', ')}`);
+    if (e.shelf_life)
+        parts.push(`shelf life: ${e.shelf_life}`);
+    if (e.temporal)
+        parts.push(e.temporal);
+    if (e.origin)
+        parts.push(`origin: ${e.origin}`);
+    return parts.join(' · ');
+}
+/** Every file of the vault, relative to its root. Pure: nothing is written here. */
+function renderVault(data) {
+    const files = [];
+    const used = new Set();
+    const unique = (base) => {
+        let name = base, i = 2;
+        while (used.has(name.toLowerCase()))
+            name = `${base}_${i++}`;
+        used.add(name.toLowerCase());
+        return name;
+    };
+    const noteOf = new Map();
+    for (const n of data.neurons)
+        noteOf.set(n.id, unique((0, common_js_1.safeFileName)(n.id, 'neuron')));
+    const domainNote = new Map();
+    for (const d of [...new Set(data.neurons.map(n => n.domain || 'general'))].sort()) {
+        domainNote.set(d, unique(`index_${(0, common_js_1.safeFileName)(d, 'general')}`));
+    }
+    const nameOf = new Map(data.neurons.map(n => [n.id, n.name]));
+    const link = (id) => (noteOf.has(id) ? `[[${noteOf.get(id)}|${alias(nameOf.get(id) || id)}]]` : `\`${id}\``);
+    // Synapses by neuron.
+    const links = new Map();
+    for (const s of data.synapses) {
+        const [a, b] = s.nodes;
+        (links.get(a) || links.set(a, []).get(a)).push({ other: b, s });
+        (links.get(b) || links.set(b, []).get(b)).push({ other: a, s });
+    }
+    for (const n of data.neurons) {
+        const entries = entriesOf(n, data.include_retired);
+        const dates = entries.map(e => e.date).filter(Boolean).sort();
+        const updated = [n.last_accessed, dates[dates.length - 1]].filter(Boolean).sort().pop();
+        const fm = (0, markdown_js_1.frontmatterBlock)({
+            crbro_export: exports.EXPORT_FORMAT_VERSION,
+            id: n.id, name: n.name, type: n.type, domain: n.domain || 'general',
+            tags: n.tags || [], heat: typeof n.heat === 'number' ? Math.round(n.heat * 1000) / 1000 : 0,
+            created: n.created || '', updated: updated || '',
+            ...(n.archived ? { archived: true } : {}),
+            entries: entries.length,
+        });
+        const lines = [fm, '', `# ${n.name}`, ''];
+        if (n.summary?.trim()) {
+            for (const l of n.summary.trim().split(/\r?\n/))
+                lines.push(`> ${l}`);
+            lines.push('');
+        }
+        const dn = domainNote.get(n.domain || 'general');
+        lines.push(`Domain: [[${dn}|${alias(n.domain || 'general')}]] · type \`${n.type}\` · heat ${(n.heat ?? 0).toFixed(2)}${n.archived ? ' · **archived**' : ''}`, '');
+        for (const kind of SECTION_ORDER) {
+            const group = entries.filter(e => e.kind === kind)
+                .sort((a, b) => (a.status === 'active' ? 0 : 1) - (b.status === 'active' ? 0 : 1) || String(b.date).localeCompare(String(a.date)));
+            if (!group.length)
+                continue;
+            lines.push(`## ${KIND_TITLES[kind]}`, '');
+            for (const e of group) {
+                lines.push((0, markdown_js_1.entryMarker)({ kind: e.kind, id: e.id, status: e.status, ...(e.keywords?.length ? { keywords: e.keywords } : {}) }));
+                lines.push(metaLine(e), '');
+                lines.push((0, markdown_js_1.defuseMarkers)(e.text.trim()));
+                if (e.rationale?.trim())
+                    lines.push('', markdown_js_1.ENTRY_WHY, `**Why:** ${(0, markdown_js_1.defuseMarkers)(e.rationale.trim())}`);
+                lines.push(markdown_js_1.ENTRY_END, '');
+            }
+        }
+        const mine = (links.get(n.id) || []).sort((a, b) => b.s.strength - a.s.strength);
+        if (mine.length) {
+            lines.push('## Synapses', '');
+            for (const { other, s } of mine) {
+                lines.push(`- ${link(other)} — ${s.type} · strength ${Number(s.strength ?? 0).toFixed(2)}${s.context ? ` · ${s.context.replace(/\s+/g, ' ')}` : ''}`);
+            }
+            lines.push('');
+        }
+        files.push({ rel: `neurons/${noteOf.get(n.id)}.md`, content: lines.join('\n') });
+    }
+    // One index note per domain.
+    for (const [d, note] of domainNote) {
+        const members = data.neurons.filter(n => (n.domain || 'general') === d).sort((a, b) => (b.heat ?? 0) - (a.heat ?? 0));
+        const lines = [(0, markdown_js_1.frontmatterBlock)({ crbro_export: exports.EXPORT_FORMAT_VERSION, domain_index: d, neurons: members.length }), '',
+            `# Domain: ${d}`, '', `${members.length} neuron(s), hottest first.`, ''];
+        for (const n of members) {
+            lines.push(`- ${link(n.id)} — \`${n.type}\` · heat ${(n.heat ?? 0).toFixed(2)} · ${entriesOf(n, data.include_retired).length} entries${n.archived ? ' · archived' : ''}`);
+        }
+        files.push({ rel: `domains/${note}.md`, content: lines.join('\n') + '\n' });
+    }
+    // Day logs.
+    for (const s of data.sessions) {
+        const name = unique((0, common_js_1.safeFileName)(s.session_id, 'session'));
+        const lines = [(0, markdown_js_1.frontmatterBlock)({
+                crbro_export: exports.EXPORT_FORMAT_VERSION, session_id: s.session_id, date: s.date || '',
+                topics: s.topics_touched || [],
+            }), '', `# ${s.session_id}`, ''];
+        if (s.summary?.trim())
+            lines.push(s.summary.trim(), '');
+        if (s.topics_touched?.length)
+            lines.push(`Topics: ${s.topics_touched.map(link).join(', ')}`, '');
+        files.push({ rel: `sessions/${name}.md`, content: lines.join('\n') });
+    }
+    // Open items.
+    const open = (data.context?.pending_tasks || []).map(t => (typeof t === 'string' ? { id: '', text: t, added: '' } : t));
+    const closed = data.context?.recently_closed || [];
+    const ol = [(0, markdown_js_1.frontmatterBlock)({ crbro_export: exports.EXPORT_FORMAT_VERSION, open_items: open.length }), '', '# Open items', ''];
+    if (!open.length)
+        ol.push('_None._', '');
+    for (const t of open) {
+        ol.push(`- [ ] ${t.text.replace(/\s*\n\s*/g, ' ')}${t.id ? ` · \`${t.id}\`` : ''}${t.added ? ` · added ${day(t.added)}` : ''}${t.due ? ` · due ${t.due}` : ''}${t.project ? ` · project ${t.project}` : ''}`);
+    }
+    if (closed.length) {
+        ol.push('', '## Recently closed', '');
+        for (const t of closed)
+            ol.push(`- [x] ${t.text.replace(/\s*\n\s*/g, ' ')}${t.closed ? ` · closed ${day(t.closed)}` : ''}`);
+    }
+    files.push({ rel: 'open-items.md', content: ol.join('\n') + '\n' });
+    // The front page.
+    const c = data.counts;
+    const home = [
+        (0, markdown_js_1.frontmatterBlock)({ crbro_export: exports.EXPORT_FORMAT_VERSION, exported_at: data.exported_at, crbro_version: data.crbro_version }), '',
+        '# CRBRO memory', '',
+        `Exported ${day(data.exported_at)} by crbro-memory ${data.crbro_version}: ${c.neurons} neurons (${c.archived} archived), ` +
+            `${c.entries} entries, ${c.synapses} synapses, ${c.sessions} day logs, ${c.open_items} open items.` +
+            (data.include_retired ? ' Retired entries included and marked.' : ' Retired entries left out.'),
+        '',
+        data.redactions ? `${data.redactions} credential(s) were replaced with a [REDACTED: …] marker on the way out.` : 'No credential was found to redact.',
+        '',
+        'This folder is a copy. Editing it does not change the brain: to bring changes back, use `crbro-memory import <this folder>`.',
+        '', '## Domains', '',
+        ...[...domainNote].map(([d, note]) => `- [[${note}|${alias(d)}]]`),
+        '', '## Elsewhere', '', '- [[open-items|Open items]]',
+        ...(data.sessions.length ? ['', '## Latest day logs', '', ...files.filter(f => f.rel.startsWith('sessions/')).slice(0, 10)
+                .map(f => `- [[${node_path_1.default.posix.basename(f.rel, '.md')}]]`)] : []),
+        '',
+    ];
+    files.push({ rel: 'README.md', content: home.join('\n') });
+    return files;
+}
+// ─── Writing ─────────────────────────────────────────────────────
+/** Refuse an output folder inside the brain, or one that already holds anything. */
+async function checkOutDir(out, brainRoot) {
+    const realOut = await (0, common_js_1.realpathNearest)(out);
+    const realBrain = await (0, common_js_1.realpathNearest)(brainRoot);
+    if ((0, common_js_1.isInside)(realOut, realBrain)) {
+        return `refusing to write inside the brain folder (${realBrain}). Pick a folder outside it with --out.`;
+    }
+    try {
+        const st = await node_fs_1.promises.stat(out);
+        if (!st.isDirectory())
+            return `${out} exists and is not a folder.`;
+        const inside = await node_fs_1.promises.readdir(out);
+        if (inside.length)
+            return `${out} is not empty. Export into a new or empty folder.`;
+    }
+    catch { /* does not exist: created */ }
+    return null;
+}
+async function writeNew(root, rel, content) {
+    const file = node_path_1.default.join(root, ...rel.split('/'));
+    // Belt and braces: every relative path is built from safeFileName, but the
+    // final check is on the resolved path.
+    if (!(0, common_js_1.isInside)(file, root) || node_path_1.default.resolve(file) === node_path_1.default.resolve(root))
+        throw new Error(`unsafe output path: ${rel}`);
+    await node_fs_1.promises.mkdir(node_path_1.default.dirname(file), { recursive: true });
+    await node_fs_1.promises.writeFile(file, content, { encoding: 'utf8', flag: 'wx' });
+}
+async function runExport(opts) {
+    try {
+        const st = await node_fs_1.promises.stat(opts.brainRoot);
+        if (!st.isDirectory())
+            throw new Error();
+    }
+    catch {
+        throw new Error(`no brain at ${opts.brainRoot} (set CRBRO_PATH, or run crbro-memory init).`);
+    }
+    const problem = await checkOutDir(opts.out, opts.brainRoot);
+    if (problem)
+        throw new Error(problem);
+    const snap = await readBrain(opts.brainRoot);
+    const data = buildExport(snap, opts.includeRetired);
+    await node_fs_1.promises.mkdir(opts.out, { recursive: true });
+    if (opts.format === 'json') {
+        await writeNew(opts.out, 'crbro-export.json', JSON.stringify(data, null, 2) + '\n');
+        return { out: opts.out, files: 1, data, unreadable: snap.unreadable };
+    }
+    const files = renderVault(data);
+    for (const f of files)
+        await writeNew(opts.out, f.rel, f.content);
+    await writeNew(opts.out, exports.VAULT_MARKER, JSON.stringify({
+        format: `${exports.EXPORT_FORMAT}-md`, format_version: exports.EXPORT_FORMAT_VERSION, exported_at: data.exported_at,
+        crbro_version: data.crbro_version, include_retired: data.include_retired, counts: data.counts,
+    }, null, 2) + '\n');
+    return { out: opts.out, files: files.length + 1, data, unreadable: snap.unreadable };
+}
+function stamp(d = new Date()) {
+    const p = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+/** CLI entry: returns the exit code. */
+async function main(argv) {
+    const a = (0, common_js_1.parseArgs)(argv, { out: 'string', format: 'string', 'include-retired': 'boolean' });
+    if (a.flags.help) {
+        console.log(exports.EXPORT_HELP);
+        return 0;
+    }
+    const format = a.flags.format ?? 'md';
+    if (format !== 'md' && format !== 'json')
+        a.errors.push('--format must be md or json');
+    if (a.positionals.length)
+        a.errors.push(`unexpected argument: ${a.positionals[0]}`);
+    if (a.errors.length) {
+        console.error(`  ❌ ${a.errors.join('; ')}`);
+        console.error('     Usage: crbro-memory export [--out <dir>] [--format md|json] [--include-retired]   (--help for more)');
+        return 2;
+    }
+    const brainRoot = (0, brain_js_1.resolveBrainDir)();
+    const out = node_path_1.default.resolve(a.flags.out ?? `crbro-export-${stamp()}`);
+    try {
+        const r = await runExport({ brainRoot, out, format: format, includeRetired: !!a.flags['include-retired'] });
+        const c = r.data.counts;
+        console.log('');
+        console.log(`  ✅ Exported ${c.neurons} neurons, ${c.entries} entries, ${c.synapses} synapses, ${c.sessions} day logs, ${c.open_items} open items`);
+        console.log(`     ${format === 'json' ? node_path_1.default.join(r.out, 'crbro-export.json') : `${r.out}  (${r.files} files — open the folder as an Obsidian vault)`}`);
+        if (r.data.redactions)
+            console.log(`     ${r.data.redactions} credential(s) redacted on the way out.`);
+        if (r.unreadable.length)
+            console.log(`  ⚠️  ${r.unreadable.length} file(s) could not be read and were left out: ${r.unreadable.slice(0, 5).join(', ')}${r.unreadable.length > 5 ? ', …' : ''}`);
+        console.log('     The brain was only read. Nothing in it changed.');
+        console.log('');
+        return 0;
+    }
+    catch (err) {
+        console.error(`  ❌ export: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+}
+//# sourceMappingURL=export.js.map