mnueron 0.1.0

package/dist/cli.js

@@ -0,0 +1,685 @@
+#!/usr/bin/env node
+/**
+ * mnueron CLI.
+ *   mnueron init                  — write Claude Desktop config entry
+ *   mnueron import <file> [--ns]  — bulk import a Claude/OpenAI export
+ *   mnueron stats                 — counts by namespace
+ *   mnueron search <query>        — quick search from terminal
+ *   mnueron namespaces            — list namespaces
+ */
+import { readFile, stat } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadConfig, makeProvider } from './config.js';
+import { importClaudeExport } from './import/claude.js';
+import { importOpenAIExport } from './import/openai.js';
+import { runSetup, formatReport } from './setup.js';
+const HERE = dirname(fileURLToPath(import.meta.url));
+async function main() {
+    const [cmd, ...rest] = process.argv.slice(2);
+    switch (cmd) {
+        case 'setup': return cmdSetup(rest);
+        case 'init': return cmdSetup(rest); // alias kept for older docs
+        case 'import': return cmdImport(rest);
+        case 'stats': return cmdStats();
+        case 'search': return cmdSearch(rest);
+        case 'namespaces': return cmdNamespaces();
+        case 'dashboard': return cmdDashboard(rest);
+        case 'rebuild-embeddings': return cmdRebuildEmbeddings(rest);
+        case 'rechunk': return cmdRechunk(rest);
+        case 'migrate-to-hosted': return cmdMigrateToHosted(rest);
+        case 'plugin': return cmdPlugin(rest);
+        case 'help':
+        case '--help':
+        case '-h':
+        case undefined: return printHelp();
+        default:
+            console.error(`Unknown command: ${cmd}\n`);
+            printHelp();
+            process.exit(1);
+    }
+}
+function printHelp() {
+    console.log(`mnueron — persistent memory for AI agents
+
+Commands:
+  mnueron setup                   Detect installed AI tools and configure each one
+       [--only <tool>]            Only configure one tool (claude-desktop|claude-code|cursor|windsurf|cline)
+       [--hosted <url> --token <t>]   Configure for hosted mode (default: local SQLite)
+       [--dry-run]                Show what would change without writing
+       [--uninstall]              Remove mnueron from all detected tools
+  mnueron import <file>           Bulk-import a Claude or OpenAI export
+       [--ns <name>]              Target namespace (default: "default")
+       [--format claude|openai]   Skip format auto-detection
+  mnueron search <query>          Search memories from the terminal
+       [--ns <name>] [--k <n>]
+  mnueron stats                   Show counts by namespace
+  mnueron namespaces              List all namespaces
+  mnueron dashboard               Launch the local web dashboard
+       [--port <n>]               Port to bind (default 3122)
+       [--no-open]                Don't open the browser automatically
+  mnueron rebuild-embeddings      Generate vector embeddings for memories saved
+                                  before semantic-search support was added. Run
+                                  once after upgrading to v0.2+.
+  mnueron rechunk                 Split existing oversized memories (long backfilled
+       [--threshold <n>]            chats) into per-turn atomic memories. Improves
+       [--keep-original]            search granularity. Run once after first backfill.
+       [--dry-run]
+  mnueron migrate-to-hosted       Upload your local SQLite memories to a hosted
+       --url <https://...>          mnueron backend. Idempotent via source_ref dedup.
+       --token <mnu_...>            After completion, optionally flips the active provider
+       [--batch <n>]                so all subsequent reads/writes go to hosted.
+       [--namespace <name>]         Filter to one namespace if you only want a subset.
+       [--dry-run]
+       [--no-flip]                  Upload but don't change the active provider.
+  mnueron plugin <action> [name]  Manage plugins enabled in ~/.mnueron/config.json
+       list                         Show enabled + installed plugins.
+       enable <name>                Add to enabledPlugins list.
+       disable <name>               Remove from enabledPlugins list.
+       add <name>                   Alias for enable; also reminds about npm install.
+       remove <name>                Alias for disable.
+
+Environment:
+  MNUERON_DB_PATH    Local SQLite location (default: ~/.mnueron/memories.db)
+  MNUERON_API_URL    Hosted backend URL (enables remote mode)
+  MNUERON_API_TOKEN  Token for remote mode
+  MNUERON_NAMESPACE  Default namespace (default: "default")
+`);
+}
+async function cmdSetup(args) {
+    const opts = {};
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--only' && args[i + 1]) {
+            opts.only = (opts.only ?? []).concat(args[++i]);
+        }
+        else if (a === '--hosted' && args[i + 1] && args[i + 2] && args[i + 2] !== '--token') {
+            // tolerate `--hosted URL --token TOKEN` and `--hosted URL --token TOKEN`
+            const url = args[++i];
+            const next = args[i + 1];
+            if (next === '--token' && args[i + 2]) {
+                i++;
+                opts.hosted = { url, token: args[++i] };
+            }
+            else {
+                console.error('--hosted requires --token <value>');
+                process.exit(1);
+            }
+        }
+        else if (a === '--hosted' && args[i + 1]) {
+            // alt parse: --hosted URL --token TOKEN
+            const url = args[++i];
+            const tokenIdx = args.indexOf('--token', i);
+            if (tokenIdx === -1 || !args[tokenIdx + 1]) {
+                console.error('--hosted requires --token <value>');
+                process.exit(1);
+            }
+            opts.hosted = { url, token: args[tokenIdx + 1] };
+        }
+        else if (a === '--dry-run') {
+            opts.dryRun = true;
+        }
+        else if (a === '--uninstall') {
+            opts.uninstall = true;
+        }
+        else if (a === '--yes' || a === '-y') {
+            opts.yes = true;
+        }
+    }
+    const banner = `\n  🧠  mnueron — persistent memory for AI dev tools\n` +
+        `      mode: ${opts.hosted ? 'hosted (' + opts.hosted.url + ')' : 'local SQLite'}\n` +
+        (opts.dryRun ? `      DRY RUN — no files will be changed\n` : '') +
+        (opts.uninstall ? `      REMOVING — will unregister from detected tools\n` : '');
+    console.log(banner);
+    const reports = await runSetup(opts);
+    console.log(formatReport(reports));
+    const ok = reports.some(r => r.status === 'configured' || r.status === 'updated' || r.status === 'uninstalled');
+    if (ok && !opts.dryRun && !opts.uninstall) {
+        console.log(`\n✨ Done. Restart any running AI tool to load the memory plugin.`);
+        console.log(`   Then ask it: "What memory tools do you have?"\n`);
+    }
+    else if (!opts.dryRun && !opts.uninstall) {
+        console.log(`\n  No supported AI tools detected on this machine.`);
+        console.log(`  Install one of: Claude Desktop, Claude Code, Cursor, Windsurf, Cline\n`);
+    }
+}
+async function cmdImport(args) {
+    if (args.length === 0) {
+        console.error('Usage: mnueron import <file> [--ns <namespace>] [--format claude|openai]');
+        process.exit(1);
+    }
+    const file = args[0];
+    let ns = 'default';
+    let format = 'auto';
+    for (let i = 1; i < args.length; i++) {
+        if (args[i] === '--ns' && args[i + 1]) {
+            ns = args[++i];
+        }
+        else if (args[i] === '--format' && args[i + 1]) {
+            const f = args[++i];
+            if (f === 'claude' || f === 'openai')
+                format = f;
+        }
+    }
+    if (!existsSync(file)) {
+        console.error(`File not found: ${file}`);
+        process.exit(1);
+    }
+    const sz = (await stat(file)).size;
+    console.log(`Reading ${file} (${(sz / 1024).toFixed(1)} KB)...`);
+    if (format === 'auto') {
+        const head = (await readFile(file, 'utf8')).slice(0, 4000);
+        if (head.includes('"chat_messages"'))
+            format = 'claude';
+        else if (head.includes('"mapping"'))
+            format = 'openai';
+        else
+            format = 'claude';
+        console.log(`Detected format: ${format}`);
+    }
+    const items = format === 'claude'
+        ? await importClaudeExport(file, ns)
+        : await importOpenAIExport(file, ns);
+    console.log(`Parsed ${items.length} conversations. Saving...`);
+    const provider = makeProvider(loadConfig());
+    const result = await provider.bulkSave(items);
+    await provider.close();
+    console.log(`✓ Saved ${result.saved}, errors ${result.errors}, namespace="${ns}"`);
+}
+async function cmdStats() {
+    const provider = makeProvider(loadConfig());
+    const namespaces = await provider.namespaces();
+    await provider.close();
+    if (namespaces.length === 0) {
+        console.log('No memories yet.');
+        return;
+    }
+    const total = namespaces.reduce((s, n) => s + n.count, 0);
+    console.log(`Total: ${total} memories across ${namespaces.length} namespaces\n`);
+    for (const ns of namespaces) {
+        const date = ns.last_updated ? new Date(ns.last_updated).toISOString().slice(0, 10) : '—';
+        console.log(`  ${ns.name.padEnd(24)} ${String(ns.count).padStart(6)}  last: ${date}`);
+    }
+}
+async function cmdSearch(args) {
+    if (args.length === 0) {
+        console.error('Usage: mnueron search <query> [--ns <namespace>] [--k <n>]');
+        process.exit(1);
+    }
+    let ns;
+    let k = 5;
+    const queryParts = [];
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--ns' && args[i + 1]) {
+            ns = args[++i];
+        }
+        else if (args[i] === '--k' && args[i + 1]) {
+            k = parseInt(args[++i], 10) || 5;
+        }
+        else
+            queryParts.push(args[i]);
+    }
+    const query = queryParts.join(' ');
+    const provider = makeProvider(loadConfig());
+    const hits = await provider.search({ query, namespace: ns, k });
+    await provider.close();
+    if (hits.length === 0) {
+        console.log('No matches.');
+        return;
+    }
+    for (const m of hits) {
+        const date = new Date(m.created_at).toISOString().slice(0, 10);
+        const preview = m.content.replace(/\s+/g, ' ').slice(0, 200);
+        console.log(`\n[${date}] ${m.namespace}${m.tags.length ? ` #${m.tags.join(' #')}` : ''}`);
+        console.log(`  ${preview}${m.content.length > 200 ? '…' : ''}`);
+        console.log(`  id: ${m.id}`);
+    }
+}
+async function cmdNamespaces() {
+    const provider = makeProvider(loadConfig());
+    const namespaces = await provider.namespaces();
+    await provider.close();
+    for (const ns of namespaces)
+        console.log(ns.name);
+}
+async function cmdDashboard(args) {
+    let port = 3122;
+    let openBrowser = true;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--port' && args[i + 1]) {
+            port = parseInt(args[++i], 10) || 3122;
+        }
+        else if (args[i] === '--no-open') {
+            openBrowser = false;
+        }
+    }
+    const { startDashboard } = await import('./dashboard/server.js');
+    const provider = makeProvider(loadConfig());
+    const handle = await startDashboard(provider, port).catch((e) => {
+        if (e?.code === 'EADDRINUSE') {
+            console.error(`Port ${port} is already in use. Try --port <other>.`);
+            process.exit(1);
+        }
+        throw e;
+    });
+    console.log(`\n  🧠  mnueron dashboard`);
+    console.log(`      ${handle.url}\n`);
+    console.log(`  Ctrl+C to stop.`);
+    if (openBrowser)
+        openInBrowser(handle.url);
+    const shutdown = async () => {
+        await handle.close().catch(() => { });
+        await provider.close().catch(() => { });
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    // wait forever
+    await new Promise(() => { });
+}
+async function cmdRechunk(args) {
+    let threshold = 6000;
+    let keepOriginal = false;
+    let dryRun = false;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--threshold' && args[i + 1]) {
+            threshold = parseInt(args[++i], 10) || 6000;
+        }
+        else if (args[i] === '--keep-original') {
+            keepOriginal = true;
+        }
+        else if (args[i] === '--dry-run') {
+            dryRun = true;
+        }
+    }
+    const provider = makeProvider(loadConfig());
+    if (typeof provider.findOversizedMemories !== 'function') {
+        console.error('rechunk only supported in local mode.');
+        process.exit(1);
+    }
+    const rows = provider.findOversizedMemories(threshold);
+    if (rows.length === 0) {
+        console.log(`\n  ✓ No memories larger than ${threshold} chars. Nothing to do.\n`);
+        await provider.close();
+        return;
+    }
+    // Sum bytes for the report
+    const totalChars = rows.reduce((s, r) => s + (r.content?.length ?? 0), 0);
+    console.log(`\n  🔪  Rechunk plan`);
+    console.log(`      ${rows.length} memories over ${threshold} chars`);
+    console.log(`      total content: ${(totalChars / 1024).toFixed(1)} KB`);
+    console.log(`      strategy: transcript-aware split (per-turn) with sliding-window fallback`);
+    console.log(`      mode: ${dryRun ? 'DRY RUN (no writes)' : keepOriginal ? 'split + keep originals' : 'split + delete originals'}\n`);
+    const { chunkContent } = await import('./store/chunking.js');
+    let oversize = 0, chunksMade = 0, deleted = 0, errors = 0;
+    for (const row of rows) {
+        oversize++;
+        const chunks = chunkContent(row.content);
+        if (chunks.length < 2) {
+            // Couldn't split — content has no transcript shape AND fits the
+            // sliding window. Skip rather than create a single useless duplicate.
+            continue;
+        }
+        process.stdout.write(`  [${oversize}/${rows.length}] ${row.id.slice(0, 8)}… → ${chunks.length} chunks`);
+        if (dryRun) {
+            console.log(' (dry run)');
+            continue;
+        }
+        try {
+            const tags = JSON.parse(row.tags_json ?? '[]');
+            const meta = row.meta_json ? JSON.parse(row.meta_json) : {};
+            const parentRef = row.source_ref ?? `chunked:${row.id}`;
+            // Build inputs for bulkSave
+            const inputs = chunks.map((c, i) => ({
+                content: c.content,
+                namespace: row.namespace,
+                tags: [...tags, 'chunk', 'rechunked', ...(c.role ? [`role:${c.role}`] : [])],
+                source: row.source,
+                source_ref: parentRef,
+                metadata: {
+                    ...meta,
+                    parent_ref: parentRef,
+                    chunk_index: i,
+                    chunk_count: chunks.length,
+                    ...(c.role ? { role: c.role } : {}),
+                    original_id: row.id,
+                    original_created_at: row.created_at,
+                },
+            }));
+            await provider.bulkSave(inputs);
+            chunksMade += chunks.length;
+            if (!keepOriginal) {
+                await provider.delete(row.id);
+                deleted++;
+            }
+            console.log(' ✓');
+        }
+        catch (e) {
+            errors++;
+            console.log(` ✗ ${e?.message ?? e}`);
+        }
+    }
+    console.log(`\n  Done.`);
+    console.log(`      ${chunksMade} new chunked memories created`);
+    if (!dryRun && !keepOriginal)
+        console.log(`      ${deleted} originals deleted`);
+    if (errors > 0)
+        console.log(`      ${errors} errors`);
+    console.log(`\n  Next: run 'mnueron rebuild-embeddings' so the new chunks have vectors.\n`);
+    await provider.close();
+}
+async function cmdPlugin(args) {
+    const action = args[0] ?? 'list';
+    const name = args[1];
+    const { listEnabledPlugins, enablePlugin, disablePlugin } = await import('./plugins/loader.js');
+    switch (action) {
+        case 'list': {
+            const enabled = await listEnabledPlugins();
+            if (enabled.length === 0) {
+                console.log('No plugins enabled. Try:');
+                console.log('  npm install -g mnueron-plugin-redact-pii    # install');
+                console.log('  mnueron plugin enable mnueron-plugin-redact-pii');
+                return;
+            }
+            console.log(`Enabled plugins (${enabled.length}):`);
+            for (const n of enabled) {
+                // Check whether the plugin's npm package is actually resolvable.
+                let resolved = null;
+                try {
+                    const { createRequire } = await import('node:module');
+                    const require = createRequire(import.meta.url);
+                    resolved = require.resolve(n + '/package.json');
+                }
+                catch { /* not installed */ }
+                const status = resolved ? '✓ installed' : '✗ NOT installed (npm install ' + n + ')';
+                console.log(`  ${n.padEnd(40)}  ${status}`);
+            }
+            return;
+        }
+        case 'enable':
+        case 'add': {
+            if (!name) {
+                console.error('Usage: mnueron plugin enable <name>');
+                process.exit(1);
+            }
+            await enablePlugin(name);
+            console.log(`✓ Enabled ${name} in ~/.mnueron/config.json`);
+            // Check whether it's installed; warn if not.
+            try {
+                const { createRequire } = await import('node:module');
+                const require = createRequire(import.meta.url);
+                require.resolve(name + '/package.json');
+                console.log('  Plugin package is installed — will activate on next MCP server start.');
+            }
+            catch {
+                console.log(`  Plugin package is NOT installed yet. Run:`);
+                console.log(`    npm install -g ${name}`);
+            }
+            console.log(`  Restart any running mnueron processes (Claude Code, dashboard) to pick it up.`);
+            return;
+        }
+        case 'disable':
+        case 'remove': {
+            if (!name) {
+                console.error('Usage: mnueron plugin disable <name>');
+                process.exit(1);
+            }
+            await disablePlugin(name);
+            console.log(`✓ Disabled ${name} in ~/.mnueron/config.json`);
+            console.log(`  Restart any running mnueron processes to drop it.`);
+            return;
+        }
+        default:
+            console.error(`Unknown action "${action}". Try: list | enable | disable | add | remove`);
+            process.exit(1);
+    }
+}
+async function cmdMigrateToHosted(args) {
+    let url = '';
+    let token = '';
+    let batch = 100;
+    let namespace;
+    let dryRun = false;
+    let noFlip = false;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--url' && args[i + 1])
+            url = args[++i];
+        else if (args[i] === '--token' && args[i + 1])
+            token = args[++i];
+        else if (args[i] === '--batch' && args[i + 1])
+            batch = parseInt(args[++i], 10) || 100;
+        else if (args[i] === '--namespace' && args[i + 1])
+            namespace = args[++i];
+        else if (args[i] === '--dry-run')
+            dryRun = true;
+        else if (args[i] === '--no-flip')
+            noFlip = true;
+    }
+    if (!url || !token) {
+        console.error(`Usage: mnueron migrate-to-hosted --url <https://api.mnueron.com> --token <mnu_...>`);
+        console.error(`Tip: sign up at the hosted dashboard to get your token, then paste here.`);
+        process.exit(1);
+    }
+    // We migrate FROM local. Force local mode regardless of env vars so the
+    // user can't accidentally migrate hosted-to-hosted.
+    process.env.MNUERON_API_URL = '';
+    process.env.MNUERON_API_TOKEN = '';
+    const cfg = loadConfig();
+    if (cfg.mode !== 'local') {
+        console.error('migrate-to-hosted reads FROM local mode. Got mode=' + cfg.mode);
+        process.exit(1);
+    }
+    const provider = makeProvider(cfg);
+    // Pull every memory from local
+    const namespaces = await provider.namespaces();
+    const total = namespace
+        ? (namespaces.find(n => n.name === namespace)?.count ?? 0)
+        : namespaces.reduce((s, n) => s + n.count, 0);
+    console.log(`\n  🚀  mnueron migrate-to-hosted`);
+    console.log(`      source:  local SQLite (${total} memories${namespace ? ` in namespace ${namespace}` : ''})`);
+    console.log(`      target:  ${url}`);
+    console.log(`      batch:   ${batch}`);
+    console.log(`      mode:    ${dryRun ? 'DRY RUN (no writes)' : 'live upload'}\n`);
+    if (total === 0) {
+        console.log(`  Nothing to migrate.`);
+        await provider.close();
+        return;
+    }
+    // Ping the target first
+    if (!dryRun) {
+        try {
+            const ping = await fetch(`${url.replace(/\/+$/, '')}/health`);
+            if (!ping.ok)
+                throw new Error(`/health returned ${ping.status}`);
+        }
+        catch (e) {
+            console.error(`Cannot reach ${url}/health: ${e.message}`);
+            console.error(`Check the URL and that the hosted backend is running.`);
+            await provider.close();
+            process.exit(1);
+        }
+    }
+    // Stream memories in chunks of `batch`, oldest first, so the hosted side
+    // ends up with chronological order in dashboards.
+    let cursor;
+    let uploaded = 0, failed = 0;
+    const start = Date.now();
+    while (true) {
+        const page = await provider.list({
+            namespace,
+            limit: batch,
+            before: cursor,
+        });
+        if (page.length === 0)
+            break;
+        // list() returns DESC; we want to upload oldest first, but the hosted
+        // side will reorder on display anyway, so just upload as-is.
+        if (!dryRun) {
+            try {
+                const items = page.map(m => ({
+                    content: m.content,
+                    namespace: m.namespace,
+                    tags: m.tags,
+                    source: m.source,
+                    source_ref: m.source_ref,
+                    metadata: m.metadata,
+                }));
+                const res = await fetch(`${url.replace(/\/+$/, '')}/v1/memories/bulk`, {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${token}`,
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ items }),
+                });
+                if (!res.ok) {
+                    const body = await res.text().catch(() => '');
+                    throw new Error(`${res.status} ${res.statusText}${body ? `: ${body.slice(0, 200)}` : ''}`);
+                }
+                const data = await res.json().catch(() => ({}));
+                uploaded += (data.saved ?? page.length);
+                failed += (data.errors ?? 0);
+            }
+            catch (e) {
+                failed += page.length;
+                console.error(`  batch failed at cursor=${cursor}: ${e.message}`);
+                // Stop on transport error so we don't retry forever
+                if (`${e.message}`.includes('ECONNREFUSED') || `${e.message}`.includes('Cannot reach'))
+                    break;
+            }
+        }
+        else {
+            uploaded += page.length;
+        }
+        cursor = page[page.length - 1].created_at;
+        const pct = Math.round((uploaded + failed) / total * 100);
+        process.stdout.write(`\r  [${'█'.repeat(Math.floor(pct / 4)).padEnd(25, '░')}] ${pct}%  ${uploaded + failed}/${total}`);
+        if (page.length < batch)
+            break;
+    }
+    process.stdout.write('\n');
+    const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+    console.log(`\n  ✓ Done in ${elapsed}s — ${uploaded} uploaded${failed ? `, ${failed} failed` : ''}.\n`);
+    if (!dryRun && !noFlip && failed === 0) {
+        await writeActiveProvider(url, token);
+        console.log(`  🔁  Active provider switched to hosted.`);
+        console.log(`      ~/.mnueron/config.json updated with MNUERON_API_URL + MNUERON_API_TOKEN.`);
+        console.log(`      Restart any running mnueron processes (Claude Code, dashboard) to pick up the change.\n`);
+    }
+    else if (noFlip) {
+        console.log(`  ℹ️  --no-flip set: active provider stays on local.`);
+        console.log(`      Set MNUERON_API_URL=${url} and MNUERON_API_TOKEN=<your token> in your shell when ready.\n`);
+    }
+    await provider.close();
+}
+async function writeActiveProvider(url, token) {
+    const { writeFile, mkdir } = await import('node:fs/promises');
+    const { homedir } = await import('node:os');
+    const { join } = await import('node:path');
+    const dir = join(homedir(), '.mnueron');
+    await mkdir(dir, { recursive: true });
+    const configPath = join(dir, 'config.json');
+    let existing = {};
+    try {
+        const { readFile } = await import('node:fs/promises');
+        existing = JSON.parse(await readFile(configPath, 'utf8'));
+    }
+    catch { /* fresh */ }
+    existing.apiUrl = url;
+    existing.apiToken = token;
+    await writeFile(configPath, JSON.stringify(existing, null, 2), 'utf8');
+}
+async function openInBrowser(url) {
+    const { exec } = await import('node:child_process');
+    const cmd = process.platform === 'win32' ? `cmd /c start "" "${url}"` :
+        process.platform === 'darwin' ? `open "${url}"` :
+            `xdg-open "${url}"`;
+    exec(cmd, () => { });
+}
+async function cmdRebuildEmbeddings(args) {
+    const force = args.includes('--force');
+    const provider = makeProvider(loadConfig());
+    // Only LocalProvider exposes rebuildEmbeddings — type-guard accordingly.
+    const local = provider;
+    if (typeof local.rebuildEmbeddings !== 'function') {
+        console.error('rebuild-embeddings only supported in local mode.');
+        process.exit(1);
+    }
+    // Diagnostics — reach into the DB so we can see what's actually there.
+    // sqlite-vec virtual tables don't always answer LEFT JOIN questions the
+    // way you'd expect, so we print counts directly.
+    const db = local.db;
+    const memCount = db?.prepare('SELECT COUNT(*) c FROM memories').get()?.c ?? 0;
+    let vecCount = 0;
+    let vecOk = false;
+    try {
+        vecCount = db?.prepare('SELECT COUNT(*) c FROM memories_vec').get()?.c ?? 0;
+        vecOk = true;
+    }
+    catch (e) {
+        console.log(`  memories_vec not queryable: ${e.message}`);
+    }
+    const missing = local.countMissingEmbeddings?.() ?? 0;
+    console.log(`\n  📊  Embeddings diagnostic`);
+    console.log(`      memories table:      ${memCount} rows`);
+    console.log(`      memories_vec table:  ${vecOk ? vecCount + ' rows' : 'not available'}`);
+    console.log(`      missing embeddings:  ${missing}`);
+    if (!vecOk) {
+        console.log(`\n  sqlite-vec extension is not loaded. Aborting.\n`);
+        await provider.close();
+        return;
+    }
+    if (missing === 0 && !force) {
+        if (vecCount >= memCount) {
+            console.log(`\n  ✓ All memories already have embeddings. Nothing to do.\n`);
+        }
+        else {
+            console.log(`\n  countMissingEmbeddings returns 0 but vec table has fewer rows than memories.\n` +
+                `  Run with --force to re-embed all memories.\n`);
+        }
+        await provider.close();
+        return;
+    }
+    // If --force was passed, wipe the vec table first so rebuildEmbeddings
+    // re-embeds everything (its built-in query only catches missing rows).
+    if (force && vecOk) {
+        console.log(`\n  --force: wiping memories_vec and re-embedding all ${memCount} memories...`);
+        try {
+            db.prepare(`DELETE FROM memories_vec`).run();
+        }
+        catch (e) {
+            console.log(`  (could not wipe via DELETE: ${e.message}; trying DROP+CREATE)`);
+            db.exec(`
+        DROP TABLE IF EXISTS memories_vec;
+        CREATE VIRTUAL TABLE memories_vec USING vec0(memory_id TEXT PRIMARY KEY, embedding float[384]);
+      `);
+        }
+    }
+    const total = force ? memCount : missing;
+    console.log(`\n  🧠  Rebuilding embeddings for ${missing} memories...`);
+    console.log(`      First run downloads the all-MiniLM-L6-v2 model (~25MB).`);
+    console.log(`      Cached to ~/.mnueron/models/ for subsequent runs.\n`);
+    const start = Date.now();
+    let lastLog = 0;
+    const result = await local.rebuildEmbeddings((done, total, _current) => {
+        // Throttle progress output to once per 250ms or every 16 items.
+        const now = Date.now();
+        if (now - lastLog < 250 && done < total)
+            return;
+        lastLog = now;
+        const pct = Math.round((done / total) * 100);
+        const bar = '█'.repeat(Math.floor(pct / 4)).padEnd(25, '░');
+        process.stdout.write(`\r  [${bar}] ${pct}%  ${done}/${total}`);
+    });
+    process.stdout.write('\n');
+    const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+    console.log(`\n  ✓ Done in ${elapsed}s — ${result.updated} embedded, ` +
+        `${result.skipped} skipped, ${result.errors} errors.\n`);
+    await provider.close();
+}
+main().catch(e => {
+    console.error(e?.stack ?? e);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map