synabun 2026.3.307 → 2026.3.310

package/mcp-server/dist/tui.js

@@ -0,0 +1,807 @@
+#!/usr/bin/env node
+// Load .env from parent directory before any service imports
+import { readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname_ = dirname(fileURLToPath(import.meta.url));
+const envPath = process.env.DOTENV_PATH || resolve(__dirname_, '..', '..', '.env');
+try {
+    const envContent = readFileSync(envPath, 'utf-8');
+    for (const line of envContent.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eq = trimmed.indexOf('=');
+        if (eq === -1)
+            continue;
+        const key = trimmed.slice(0, eq).trim();
+        const val = trimmed.slice(eq + 1).trim();
+        if (!process.env[key])
+            process.env[key] = val;
+    }
+}
+catch { /* .env not found, rely on existing env vars */ }
+import { select, input, confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { v4 as uuidv4 } from 'uuid';
+import { ensureCollection, scrollMemories, searchMemories, getMemory, deleteMemory, updatePayload, updateVector, upsertMemory, getMemoryStats, countMemories, updatePayloadByFilter } from './services/sqlite.js';
+import { getAllCategories, getCategories, getCustomCategories, getCategoryDescription, validateCategoryName, addCategory, removeCategory } from './services/categories.js';
+import { generateEmbedding } from './services/local-embeddings.js';
+import { detectProject } from './config.js';
+// ── Box drawing characters ────────────────────────────────────────
+const BOX = {
+    tl: '\u256D', tr: '\u256E', bl: '\u2570', br: '\u256F',
+    h: '\u2500', v: '\u2502',
+    ltee: '\u251C', rtee: '\u2524',
+    dh: '\u2550', dtl: '\u2554', dtr: '\u2557', dbl: '\u255A', dbr: '\u255D', dv: '\u2551',
+};
+const ICONS = {
+    brain: '\u2022', // bullet
+    search: '\u25C9', // fisheye
+    plus: '\u253C', // cross
+    folder: '\u25A0', // square
+    chart: '\u25B2', // triangle
+    exit: '\u25C6', // diamond
+    tag: '#',
+    arrow: '\u25B6', // right triangle
+    dot: '\u2022',
+    star: '\u2605',
+    check: '\u2713',
+    cross: '\u2717',
+    sparkle: '\u2734',
+    memo: '\u2261', // triple bar
+    clock: '\u25CB', // circle
+    link: '\u221E', // infinity
+    edit: '\u270E', // pencil
+    trash: '\u2620', // skull
+    back: '\u25C0', // left triangle
+    more: '\u22EF', // midline ellipsis
+};
+// ── Color helpers ──────────────────────────────────────────────────
+// Dynamic category color palette — cycles through for categories without a preset
+const CATEGORY_COLOR_PALETTE = [
+    '#5B9BD5', '#70AD47', '#FFC000', '#ED7D31', '#44C8F5',
+    '#A5A5A5', '#4472C4', '#FF6B9D', '#00B050', '#E040FB',
+    '#00BFA5', '#7C4DFF', '#FF5252', '#D32F2F', '#64FFDA',
+    '#536DFE', '#FFD740', '#69F0AE', '#18FFFF', '#B2FF59',
+];
+const CATEGORY_ICON_PALETTE = [
+    '\u25C8', '\u25A3', '\u2261', '\u2605', '\u25CF',
+    '\u25AC', '\u25A4', '\u2665', '\u25B2', '\u25C6',
+    '\u25CB', '\u25AA', '\u2726', '\u25D0', '\u25B6',
+    '\u2662', '\u2716', '\u25C9', '\u2756', '\u2318',
+];
+function getCategoryColorFn(cat) {
+    const allCats = getAllCategories();
+    const idx = allCats.indexOf(cat);
+    const hex = idx >= 0 ? CATEGORY_COLOR_PALETTE[idx % CATEGORY_COLOR_PALETTE.length] : '#888888';
+    return chalk.hex(hex);
+}
+function getCategoryIcon(cat) {
+    const allCats = getAllCategories();
+    const idx = allCats.indexOf(cat);
+    return idx >= 0 ? CATEGORY_ICON_PALETTE[idx % CATEGORY_ICON_PALETTE.length] : ICONS.dot;
+}
+const accent = chalk.hex('#7B68EE'); // medium slate blue - main brand color
+const accent2 = chalk.hex('#9370DB'); // medium purple
+const dim = chalk.hex('#555555');
+const success = chalk.hex('#00E676');
+const warn = chalk.hex('#FFAB40');
+const danger = chalk.hex('#FF5252');
+const info = chalk.hex('#40C4FF');
+const muted = chalk.hex('#666666');
+function colorCategory(cat) {
+    const fn = getCategoryColorFn(cat);
+    const icon = getCategoryIcon(cat);
+    return fn(`${icon} ${cat}`);
+}
+function colorCategoryName(cat) {
+    const fn = getCategoryColorFn(cat);
+    return fn(cat);
+}
+function importanceBadge(imp) {
+    if (imp >= 9)
+        return chalk.bgHex('#FF5252').white.bold(` ${imp} `);
+    if (imp >= 8)
+        return chalk.bgHex('#FF7043').white(` ${imp} `);
+    if (imp >= 6)
+        return chalk.bgHex('#FFA726').black(` ${imp} `);
+    if (imp >= 4)
+        return chalk.bgHex('#78909C').white(` ${imp} `);
+    return chalk.bgHex('#455A64').white(` ${imp} `);
+}
+function formatAge(iso) {
+    const ms = Date.now() - new Date(iso).getTime();
+    const mins = Math.floor(ms / 60000);
+    if (mins < 1)
+        return 'just now';
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days === 1)
+        return '1d ago';
+    if (days < 30)
+        return `${days}d ago`;
+    const months = Math.floor(days / 30);
+    if (months === 1)
+        return '1mo ago';
+    if (months < 12)
+        return `${months}mo ago`;
+    const years = Math.floor(months / 12);
+    return years === 1 ? '1y ago' : `${years}y ago`;
+}
+function formatDate(iso) {
+    return new Date(iso).toLocaleDateString('en-US', {
+        year: 'numeric', month: 'short', day: 'numeric',
+        hour: '2-digit', minute: '2-digit',
+    });
+}
+function truncate(s, max) {
+    const line = s.replace(/\n/g, ' ').trim();
+    return line.length <= max ? line : line.slice(0, max - 1) + '\u2026';
+}
+// ── Box & layout helpers ──────────────────────────────────────────
+function boxTop(width, title) {
+    if (title) {
+        const titleStr = ` ${title} `;
+        const stripped = titleStr.replace(/\x1B\[[0-9;]*m/g, '');
+        const remaining = width - stripped.length;
+        const left = Math.max(0, Math.floor(remaining / 2));
+        const right = Math.max(0, remaining - left);
+        return dim(BOX.tl + BOX.h.repeat(left)) + accent.bold(titleStr) + dim(BOX.h.repeat(right) + BOX.tr);
+    }
+    return dim(BOX.tl + BOX.h.repeat(width) + BOX.tr);
+}
+function boxBottom(width) {
+    return dim(BOX.bl + BOX.h.repeat(width) + BOX.br);
+}
+function boxRow(width, content, pad = 1) {
+    // Strip ANSI for length calculation
+    const stripped = content.replace(/\x1B\[[0-9;]*m/g, '');
+    const remaining = width - stripped.length - (pad * 2);
+    const right = Math.max(0, remaining);
+    return dim(BOX.v) + ' '.repeat(pad) + content + ' '.repeat(right + pad) + dim(BOX.v);
+}
+function boxEmpty(width) {
+    return dim(BOX.v) + ' '.repeat(width) + dim(BOX.v);
+}
+function boxSep(width) {
+    return dim(BOX.ltee + BOX.h.repeat(width) + BOX.rtee);
+}
+// Renders a double-bordered row: ║ <centered content padded to W> ║
+function dboxRow(width, content) {
+    const stripped = content.replace(/\x1B\[[0-9;]*m/g, '');
+    const totalPad = width - stripped.length;
+    const left = Math.max(0, Math.floor(totalPad / 2));
+    const right = Math.max(0, totalPad - left);
+    return dim(BOX.dv) + ' '.repeat(left) + content + ' '.repeat(right) + dim(BOX.dv);
+}
+// ── ASCII Art ─────────────────────────────────────────────────────
+function printLogo() {
+    const W = 56;
+    // The art lines with fixed left indent for consistent visual alignment
+    const indent = '  ';
+    const rawArt = [
+        `${indent}  __  __                                `,
+        `${indent} |  \\/  | ___ _ __ ___   ___  _ __ _   _`,
+        `${indent}| |\\/| |/ _ \\ '_ \` _ \\ / _ \\| '__| | | |`,
+        `${indent}| |  | |  __/ | | | | | (_) | |  | |_| |`,
+        `${indent}|_|  |_|\\___|_| |_| |_|\\___/|_|   \\__, |`,
+        `${indent}                                   |___/ `,
+    ];
+    // Fixed-width row: ║ + left pad + content + right pad + ║
+    function artRow(content) {
+        const stripped = content.replace(/\x1B\[[0-9;]*m/g, '');
+        const pad = Math.max(0, W - stripped.length);
+        const left = 3; // fixed left margin
+        const right = Math.max(0, pad - left);
+        return dim(BOX.dv) + ' '.repeat(left) + content + ' '.repeat(right) + dim(BOX.dv);
+    }
+    console.log('');
+    console.log(dim(BOX.dtl + BOX.dh.repeat(W) + BOX.dtr));
+    console.log(dboxRow(W, ''));
+    for (const line of rawArt) {
+        console.log(artRow(accent.bold(line)));
+    }
+    // Empty line before tagline
+    console.log(dboxRow(W, ''));
+    // Tagline (centered)
+    const tagline = accent2('Vector-Powered') + dim(' \u2022 ') + info('SQLite') + dim(' \u2022 ') + chalk.white('v2.0.0');
+    console.log(dboxRow(W, tagline));
+    console.log(dim(BOX.dbl + BOX.dh.repeat(W) + BOX.dbr));
+    console.log('');
+}
+function printScreenHeader(title, subtitle) {
+    const W = 56;
+    console.log('');
+    console.log('  ' + boxTop(W, title));
+    if (subtitle) {
+        console.log('  ' + boxRow(W, muted(subtitle)));
+    }
+    console.log('  ' + boxBottom(W));
+    console.log('');
+}
+function printSpinner(text) {
+    console.log(muted(`\n  ${ICONS.more} ${text}`));
+}
+// ── Prompt wrapper (Ctrl+C -> null instead of crash) ──────────────
+async function safePrompt(fn) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        if (err && typeof err === 'object' && 'name' in err && err.name === 'ExitPromptError') {
+            return null;
+        }
+        throw err;
+    }
+}
+// ── Format memories ───────────────────────────────────────────────
+function formatMemoryDetail(id, p) {
+    const W = 62;
+    const lines = [];
+    lines.push('  ' + boxTop(W, `${ICONS.memo} Memory Detail`));
+    lines.push('  ' + boxEmpty(W));
+    // Content - may be multi-line
+    const contentLines = p.content.split('\n');
+    lines.push('  ' + boxRow(W, chalk.bold('Content')));
+    for (const cl of contentLines) {
+        lines.push('  ' + boxRow(W, `  ${chalk.white(cl)}`));
+    }
+    lines.push('  ' + boxSep(W));
+    // Metadata grid
+    const catColorFn = getCategoryColorFn(p.category);
+    const catIcon = getCategoryIcon(p.category);
+    lines.push('  ' + boxRow(W, `${muted('Category')}    ${catColorFn(`${catIcon} ${p.category}`)}${p.subcategory ? muted(` / ${p.subcategory}`) : ''}`));
+    lines.push('  ' + boxRow(W, `${muted('Project')}     ${info(p.project)}`));
+    lines.push('  ' + boxRow(W, `${muted('Importance')}  ${importanceBadge(p.importance)}`));
+    lines.push('  ' + boxRow(W, `${muted('Source')}      ${chalk.white(p.source)}`));
+    if (p.tags.length) {
+        const tagStr = p.tags.map(t => info(`${ICONS.tag}${t}`)).join(' ');
+        lines.push('  ' + boxRow(W, `${muted('Tags')}        ${tagStr}`));
+    }
+    lines.push('  ' + boxSep(W));
+    // Timestamps
+    lines.push('  ' + boxRow(W, `${muted('Created')}     ${chalk.white(formatDate(p.created_at))} ${dim(`(${formatAge(p.created_at)})`)}`));
+    lines.push('  ' + boxRow(W, `${muted('Updated')}     ${chalk.white(formatDate(p.updated_at))}`));
+    lines.push('  ' + boxRow(W, `${muted('Accessed')}    ${chalk.white(String(p.access_count))} time${p.access_count !== 1 ? 's' : ''} ${dim(`\u2022 last ${formatAge(p.accessed_at)}`)}`));
+    if (p.related_files?.length) {
+        lines.push('  ' + boxSep(W));
+        lines.push('  ' + boxRow(W, `${muted('Files')}       ${p.related_files.map(f => dim(f)).join(', ')}`));
+    }
+    if (p.related_memory_ids?.length) {
+        if (!p.related_files?.length)
+            lines.push('  ' + boxSep(W));
+        lines.push('  ' + boxRow(W, `${muted('Related')}     ${p.related_memory_ids.map(r => dim(r.slice(0, 8) + '\u2026')).join(', ')}`));
+    }
+    lines.push('  ' + boxEmpty(W));
+    lines.push('  ' + boxRow(W, dim(`ID: ${id}`)));
+    lines.push('  ' + boxBottom(W));
+    return lines.join('\n');
+}
+function formatMemoryLine(id, p) {
+    const catColorFn = getCategoryColorFn(p.category);
+    const catIconStr = getCategoryIcon(p.category);
+    const imp = importanceBadge(p.importance);
+    const age = dim(formatAge(p.created_at).padStart(7));
+    const content = chalk.white(truncate(p.content, 38));
+    const cat = catColorFn(catIconStr + ' ' + p.category.slice(0, 4).padEnd(4));
+    return `${imp} ${cat} ${content} ${age}`;
+}
+// ── Screens ───────────────────────────────────────────────────────
+async function detailView(id, payload) {
+    while (true) {
+        console.log('\n' + formatMemoryDetail(id, payload));
+        const action = await safePrompt(() => select({
+            message: accent(`  ${ICONS.arrow} Action`),
+            choices: [
+                { name: `${ICONS.back}  Back`, value: 'back' },
+                { name: `${ICONS.edit}  Edit`, value: 'edit' },
+                { name: `${ICONS.trash}  Delete`, value: 'delete' },
+            ],
+        }));
+        if (action === null || action === 'back')
+            return;
+        if (action === 'delete') {
+            const yes = await safePrompt(() => confirm({ message: danger(`  ${ICONS.trash} Delete this memory permanently?`), default: false }));
+            if (yes) {
+                await deleteMemory(id);
+                console.log(success(`\n  ${ICONS.check} Memory deleted.`));
+                return;
+            }
+            continue;
+        }
+        if (action === 'edit') {
+            await editMemory(id, payload);
+            const refreshed = await getMemory(id);
+            if (refreshed) {
+                payload = refreshed.payload;
+            }
+            else {
+                console.log(warn(`\n  ${ICONS.cross} Memory no longer exists.`));
+                return;
+            }
+        }
+    }
+}
+async function editMemory(id, payload) {
+    printScreenHeader(`${ICONS.edit} Edit Memory`, 'Select a field to modify');
+    const field = await safePrompt(() => select({
+        message: accent('  Field to edit'),
+        choices: [
+            { name: `${ICONS.memo}  Content:     ${muted(truncate(payload.content, 35))}`, value: 'content' },
+            { name: `${ICONS.folder}  Category:    ${colorCategoryName(payload.category)}`, value: 'category' },
+            { name: `${ICONS.star}  Importance:  ${importanceBadge(payload.importance)}`, value: 'importance' },
+            { name: `${ICONS.tag}  Tags:        ${payload.tags.length ? payload.tags.map(t => info(`#${t}`)).join(' ') : muted('none')}`, value: 'tags' },
+            { name: `${ICONS.dot}  Subcategory: ${muted(payload.subcategory || 'none')}`, value: 'subcategory' },
+            { name: `${ICONS.folder}  Project:     ${info(payload.project)}`, value: 'project' },
+            { name: `${ICONS.back}  Cancel`, value: 'cancel' },
+        ],
+    }));
+    if (field === null || field === 'cancel')
+        return;
+    const now = new Date().toISOString();
+    if (field === 'content') {
+        const val = await safePrompt(() => input({ message: '  New content:', default: payload.content }));
+        if (val === null || val === payload.content)
+            return;
+        const merged = { ...payload, content: val, updated_at: now };
+        printSpinner('Re-generating embedding...');
+        const vector = await generateEmbedding(val);
+        await updateVector(id, vector, merged);
+        console.log(success(`  ${ICONS.check} Content updated & re-embedded.`));
+    }
+    else if (field === 'category') {
+        const cats = getAllCategories();
+        const val = await safePrompt(() => select({
+            message: '  Category:',
+            choices: cats.map(c => ({
+                name: `${colorCategory(c)} ${dim(getCategoryDescription(c))}`,
+                value: c,
+            })),
+            default: payload.category,
+        }));
+        if (val === null || val === payload.category)
+            return;
+        await updatePayload(id, { category: val, updated_at: now });
+        console.log(success(`  ${ICONS.check} Category ${ICONS.arrow} ${colorCategoryName(val)}`));
+    }
+    else if (field === 'importance') {
+        const val = await safePrompt(() => input({
+            message: '  Importance (1-10):',
+            default: String(payload.importance),
+            validate: (v) => { const n = Number(v); return (Number.isInteger(n) && n >= 1 && n <= 10) || 'Must be 1-10'; },
+        }));
+        if (val === null)
+            return;
+        const num = Number(val);
+        if (num === payload.importance)
+            return;
+        await updatePayload(id, { importance: num, updated_at: now });
+        console.log(success(`  ${ICONS.check} Importance ${ICONS.arrow} ${importanceBadge(num)}`));
+    }
+    else if (field === 'tags') {
+        const val = await safePrompt(() => input({
+            message: '  Tags (comma-separated):',
+            default: payload.tags.join(', '),
+        }));
+        if (val === null)
+            return;
+        const tags = val.split(',').map(t => t.trim()).filter(Boolean);
+        await updatePayload(id, { tags, updated_at: now });
+        console.log(success(`  ${ICONS.check} Tags updated: ${tags.map(t => info(`#${t}`)).join(' ') || muted('none')}`));
+    }
+    else if (field === 'subcategory') {
+        const val = await safePrompt(() => input({ message: '  Subcategory:', default: payload.subcategory || '' }));
+        if (val === null)
+            return;
+        await updatePayload(id, { subcategory: val || undefined, updated_at: now });
+        console.log(success(`  ${ICONS.check} Subcategory ${ICONS.arrow} ${val || muted('none')}`));
+    }
+    else if (field === 'project') {
+        const val = await safePrompt(() => input({ message: '  Project:', default: payload.project }));
+        if (val === null)
+            return;
+        await updatePayload(id, { project: val, updated_at: now });
+        console.log(success(`  ${ICONS.check} Project ${ICONS.arrow} ${info(val)}`));
+    }
+}
+async function browseScreen() {
+    let offset;
+    while (true) {
+        printScreenHeader(`${ICONS.brain} Browse Memories`, 'Navigate and select a memory to view details');
+        printSpinner('Loading memories...');
+        const result = await scrollMemories(undefined, 20, offset);
+        const points = result.points;
+        if (points.length === 0 && !offset) {
+            console.log(warn(`\n  ${ICONS.cross} No memories found. Create some first!`));
+            await safePrompt(() => input({ message: '  Press Enter to go back' }));
+            return;
+        }
+        // Sort by created_at descending
+        points.sort((a, b) => {
+            const pa = a.payload.created_at;
+            const pb = b.payload.created_at;
+            return pb.localeCompare(pa);
+        });
+        const choices = points.map(pt => ({
+            name: `  ${formatMemoryLine(pt.id, pt.payload)}`,
+            value: pt.id,
+        }));
+        const nextOffset = result.next_page_offset;
+        if (nextOffset) {
+            choices.push({ name: info(`  ${ICONS.more} Load more...`), value: '__more__' });
+        }
+        choices.push({ name: dim(`  ${ICONS.back} Back to menu`), value: '__back__' });
+        const choice = await safePrompt(() => select({
+            message: accent(`  ${ICONS.arrow} Select memory`),
+            choices,
+            pageSize: 15,
+        }));
+        if (choice === null || choice === '__back__')
+            return;
+        if (choice === '__more__') {
+            offset = nextOffset;
+            continue;
+        }
+        const mem = await getMemory(choice);
+        if (mem) {
+            await detailView(mem.id, mem.payload);
+        }
+        offset = undefined;
+    }
+}
+async function searchScreen() {
+    while (true) {
+        printScreenHeader(`${ICONS.search} Search Memories`, 'Semantic search powered by local embeddings');
+        const query = await safePrompt(() => input({ message: accent(`  ${ICONS.search} Query:`) }));
+        if (query === null || query.trim() === '')
+            return;
+        // Optional category filter
+        const cats = getAllCategories();
+        const catFilter = await safePrompt(() => select({
+            message: accent('  Filter by category'),
+            choices: [
+                { name: `${ICONS.sparkle}  All categories`, value: '__all__' },
+                ...cats.map(c => ({ name: `  ${colorCategory(c)}`, value: c })),
+            ],
+        }));
+        if (catFilter === null)
+            return;
+        // Optional importance filter
+        const minImpStr = await safePrompt(() => input({
+            message: accent('  Min importance (1-10, Enter = any):'),
+            default: '',
+            validate: (v) => v === '' || (Number.isInteger(Number(v)) && Number(v) >= 1 && Number(v) <= 10) || 'Must be 1-10 or empty',
+        }));
+        if (minImpStr === null)
+            return;
+        // Build search filter
+        const must = [];
+        if (catFilter !== '__all__') {
+            must.push({ key: 'category', match: { value: catFilter } });
+        }
+        if (minImpStr !== '') {
+            must.push({ key: 'importance', range: { gte: Number(minImpStr) } });
+        }
+        const filter = must.length > 0 ? { must } : undefined;
+        printSpinner('Generating embedding & searching...');
+        const vector = await generateEmbedding(query);
+        const results = await searchMemories(vector, 20, filter, 0.3);
+        if (results.length === 0) {
+            console.log(warn(`\n  ${ICONS.cross} No matching memories found.`));
+            const again = await safePrompt(() => confirm({ message: accent('  Try another search?'), default: true }));
+            if (again === null || !again)
+                return;
+            continue;
+        }
+        const resultHeader = success(`  ${ICONS.check} Found ${results.length} result${results.length !== 1 ? 's' : ''}`);
+        console.log(`\n${resultHeader}\n`);
+        const choices = results.map(r => {
+            const p = r.payload;
+            const pct = Math.round(r.score * 100);
+            const scoreBar = pct >= 80 ? success(`${pct}%`) : pct >= 50 ? warn(`${pct}%`) : dim(`${pct}%`);
+            return {
+                name: `  ${scoreBar.padEnd(18)} ${formatMemoryLine(r.id, p)}`,
+                value: r.id,
+            };
+        });
+        choices.push({ name: info(`  ${ICONS.search} Search again`), value: '__again__' });
+        choices.push({ name: dim(`  ${ICONS.back} Back to menu`), value: '__back__' });
+        const choice = await safePrompt(() => select({
+            message: accent(`  ${ICONS.arrow} Select result`),
+            choices,
+            pageSize: 15,
+        }));
+        if (choice === null || choice === '__back__')
+            return;
+        if (choice === '__again__')
+            continue;
+        const mem = await getMemory(choice);
+        if (mem) {
+            await detailView(mem.id, mem.payload);
+        }
+    }
+}
+async function createScreen() {
+    printScreenHeader(`${ICONS.plus} Create Memory`, 'Store a new piece of knowledge');
+    // Content
+    const content = await safePrompt(() => input({
+        message: accent(`  ${ICONS.memo} Content:`),
+        validate: (v) => v.trim().length > 0 || 'Content is required',
+    }));
+    if (content === null)
+        return;
+    // Category
+    const cats = getAllCategories();
+    const category = await safePrompt(() => select({
+        message: accent(`  ${ICONS.folder} Category:`),
+        choices: cats.map(c => ({
+            name: `  ${colorCategory(c)} ${dim(getCategoryDescription(c))}`,
+            value: c,
+        })),
+    }));
+    if (category === null)
+        return;
+    // Project
+    const defaultProject = detectProject();
+    const project = await safePrompt(() => input({ message: accent(`  ${ICONS.folder} Project:`), default: defaultProject }));
+    if (project === null)
+        return;
+    // Importance
+    const impStr = await safePrompt(() => input({
+        message: accent(`  ${ICONS.star} Importance (1-10):`),
+        default: '5',
+        validate: (v) => { const n = Number(v); return (Number.isInteger(n) && n >= 1 && n <= 10) || 'Must be 1-10'; },
+    }));
+    if (impStr === null)
+        return;
+    const importance = Number(impStr);
+    // Tags
+    const tagsStr = await safePrompt(() => input({ message: accent(`  ${ICONS.tag} Tags (comma-separated):`), default: '' }));
+    if (tagsStr === null)
+        return;
+    const tags = tagsStr.split(',').map(t => t.trim()).filter(Boolean);
+    // Source
+    const source = await safePrompt(() => select({
+        message: accent(`  ${ICONS.arrow} Source:`),
+        choices: [
+            { name: `  ${chalk.white('user-told')}       ${dim('User explicitly shared')}`, value: 'user-told' },
+            { name: `  ${chalk.white('self-discovered')} ${dim('Found during work')}`, value: 'self-discovered' },
+            { name: `  ${chalk.white('auto-saved')}      ${dim('Session context')}`, value: 'auto-saved' },
+        ],
+        default: 'user-told',
+    }));
+    if (source === null)
+        return;
+    // Subcategory (optional)
+    const subcategory = await safePrompt(() => input({ message: accent(`  ${ICONS.dot} Subcategory (optional):`), default: '' }));
+    if (subcategory === null)
+        return;
+    // Build payload
+    const now = new Date().toISOString();
+    const payload = {
+        content,
+        category,
+        project,
+        importance,
+        tags,
+        source,
+        subcategory: subcategory || undefined,
+        created_at: now,
+        updated_at: now,
+        accessed_at: now,
+        access_count: 0,
+    };
+    // Preview
+    console.log('\n' + formatMemoryDetail('(preview)', payload));
+    const ok = await safePrompt(() => confirm({ message: accent(`  ${ICONS.sparkle} Save this memory?`), default: true }));
+    if (ok === null || !ok) {
+        console.log(warn(`  ${ICONS.cross} Cancelled.`));
+        return;
+    }
+    const id = uuidv4();
+    printSpinner('Generating embedding...');
+    const vector = await generateEmbedding(content);
+    await upsertMemory(id, vector, payload);
+    console.log(success(`\n  ${ICONS.check} Memory saved!`) + dim(` ID: ${id}`));
+}
+async function categoriesScreen() {
+    while (true) {
+        printScreenHeader(`${ICONS.folder} Categories`, 'Manage memory categories');
+        const action = await safePrompt(() => select({
+            message: accent(`  ${ICONS.arrow} Action`),
+            choices: [
+                { name: `  ${ICONS.memo}  List all categories`, value: 'list' },
+                { name: `  ${ICONS.plus}  Create custom category`, value: 'create' },
+                { name: `  ${ICONS.trash}  Delete custom category`, value: 'delete' },
+                { name: dim(`  ${ICONS.back}  Back to menu`), value: 'back' },
+            ],
+        }));
+        if (action === null || action === 'back')
+            return;
+        if (action === 'list') {
+            const W = 52;
+            console.log('\n  ' + boxTop(W, 'All Categories'));
+            const allCats = getCategories();
+            for (const c of allCats) {
+                console.log('  ' + boxRow(W, `${colorCategory(c.name)}  ${dim(c.description)}`));
+            }
+            console.log('  ' + boxBottom(W));
+            console.log('');
+        }
+        if (action === 'create') {
+            const name = await safePrompt(() => input({
+                message: accent('  Category name (a-z, 0-9, hyphens):'),
+                validate: (v) => {
+                    const result = validateCategoryName(v);
+                    return result.valid || result.error;
+                },
+            }));
+            if (name === null)
+                continue;
+            const description = await safePrompt(() => input({ message: accent('  Description:'), validate: (v) => v.trim().length > 0 || 'Required' }));
+            if (description === null)
+                continue;
+            addCategory(name, description);
+            console.log(success(`\n  ${ICONS.check} Category "${name}" created.`));
+        }
+        if (action === 'delete') {
+            const custom = getCustomCategories();
+            if (custom.length === 0) {
+                console.log(warn(`\n  ${ICONS.cross} No custom categories to delete.`));
+                continue;
+            }
+            const name = await safePrompt(() => select({
+                message: accent('  Delete which category?'),
+                choices: [
+                    ...custom.map(c => ({
+                        name: `  ${chalk.hex('#FF6B9D')(`${ICONS.sparkle} ${c.name}`)} ${dim(`- ${c.description}`)}`,
+                        value: c.name,
+                    })),
+                    { name: dim(`  ${ICONS.back} Cancel`), value: '__cancel__' },
+                ],
+            }));
+            if (name === null || name === '__cancel__')
+                continue;
+            const count = await countMemories({
+                must: [{ key: 'category', match: { value: name } }],
+            });
+            if (count > 0) {
+                console.log(warn(`\n  ${ICONS.cross} ${count} memories use this category.`));
+                const reassign = await safePrompt(() => confirm({ message: accent('  Reassign them to another category?'), default: true }));
+                if (reassign === null || !reassign)
+                    continue;
+                const target = await safePrompt(() => select({
+                    message: accent('  Reassign to:'),
+                    choices: getAllCategories()
+                        .filter(c => c !== name)
+                        .map(c => ({ name: `  ${colorCategory(c)}`, value: c })),
+                }));
+                if (target === null)
+                    continue;
+                await updatePayloadByFilter({ must: [{ key: 'category', match: { value: name } }] }, { category: target, updated_at: new Date().toISOString() });
+                console.log(success(`  ${ICONS.check} Reassigned ${count} memories to ${colorCategoryName(target)}.`));
+            }
+            const ok = await safePrompt(() => confirm({ message: danger(`  ${ICONS.trash} Delete category "${name}"?`), default: false }));
+            if (ok) {
+                removeCategory(name);
+                console.log(success(`  ${ICONS.check} Category "${name}" deleted.`));
+            }
+        }
+    }
+}
+async function statsScreen() {
+    printScreenHeader(`${ICONS.chart} Statistics`, 'Memory database overview');
+    printSpinner('Loading statistics...');
+    const stats = await getMemoryStats();
+    const W = 56;
+    console.log('\n  ' + boxTop(W, 'Overview'));
+    console.log('  ' + boxRow(W, `${chalk.bold.white(String(stats.total))} total memories stored`));
+    if (stats.oldest) {
+        console.log('  ' + boxRow(W, `${muted('Oldest:')} ${chalk.white(formatDate(stats.oldest))} ${dim(`(${formatAge(stats.oldest)})`)}`));
+    }
+    if (stats.newest) {
+        console.log('  ' + boxRow(W, `${muted('Newest:')} ${chalk.white(formatDate(stats.newest))} ${dim(`(${formatAge(stats.newest)})`)}`));
+    }
+    console.log('  ' + boxBottom(W));
+    // Category chart
+    const catEntries = Object.entries(stats.by_category)
+        .filter(([, count]) => count > 0)
+        .sort((a, b) => b[1] - a[1]);
+    if (catEntries.length > 0) {
+        console.log('\n  ' + boxTop(W, 'By Category'));
+        const maxCount = Math.max(...catEntries.map(([, c]) => c));
+        const barWidth = 24;
+        for (const [cat, count] of catEntries) {
+            const catColorFn = getCategoryColorFn(cat);
+            const catIconStr = getCategoryIcon(cat);
+            const filled = Math.max(1, Math.round((count / maxCount) * barWidth));
+            const empty = barWidth - filled;
+            const bar = catColorFn('\u2588'.repeat(filled)) + dim('\u2591'.repeat(empty));
+            // icon(1) + space(1) + name + padding = 16 chars visual
+            const nameVisual = `${catIconStr} ${cat}`;
+            const padLen = Math.max(1, 16 - nameVisual.length);
+            const label = catColorFn(nameVisual) + ' '.repeat(padLen);
+            console.log('  ' + boxRow(W, `${label}${bar} ${chalk.bold.white(String(count).padStart(3))}`));
+        }
+        console.log('  ' + boxBottom(W));
+    }
+    // Project breakdown
+    const projEntries = Object.entries(stats.by_project)
+        .sort((a, b) => b[1] - a[1]);
+    if (projEntries.length > 0) {
+        console.log('\n  ' + boxTop(W, 'By Project'));
+        for (const [proj, count] of projEntries) {
+            const pct = Math.round((count / stats.total) * 100);
+            const pctBar = dim(`(${pct}%)`);
+            console.log('  ' + boxRow(W, `${info(proj.padEnd(20))} ${chalk.bold.white(String(count).padStart(4))} ${pctBar}`));
+        }
+        console.log('  ' + boxBottom(W));
+    }
+    console.log('');
+    await safePrompt(() => input({ message: dim('  Press Enter to go back') }));
+}
+// ── Main Menu ─────────────────────────────────────────────────────
+async function mainMenu() {
+    printLogo();
+    while (true) {
+        const choice = await safePrompt(() => select({
+            message: accent(`  ${ICONS.arrow} Main Menu`),
+            choices: [
+                { name: `  ${accent2(ICONS.brain)}  ${chalk.white('Browse Memories')}     ${dim('Paginated list')}`, value: 'browse' },
+                { name: `  ${accent2(ICONS.search)}  ${chalk.white('Search Memories')}     ${dim('Semantic search')}`, value: 'search' },
+                { name: `  ${accent2(ICONS.plus)}  ${chalk.white('Create Memory')}       ${dim('Store new knowledge')}`, value: 'create' },
+                { name: `  ${accent2(ICONS.folder)}  ${chalk.white('Manage Categories')}  ${dim('Create & organize')}`, value: 'categories' },
+                { name: `  ${accent2(ICONS.chart)}  ${chalk.white('Statistics')}          ${dim('Database overview')}`, value: 'stats' },
+                { name: dim(`  ${ICONS.exit}  Exit`), value: 'exit' },
+            ],
+        }));
+        if (choice === null || choice === 'exit') {
+            console.log(dim(`\n  ${ICONS.exit} Goodbye!\n`));
+            process.exit(0);
+        }
+        switch (choice) {
+            case 'browse':
+                await browseScreen();
+                break;
+            case 'search':
+                await searchScreen();
+                break;
+            case 'create':
+                await createScreen();
+                break;
+            case 'categories':
+                await categoriesScreen();
+                break;
+            case 'stats':
+                await statsScreen();
+                break;
+        }
+    }
+}
+// ── Entry Point ───────────────────────────────────────────────────
+async function main() {
+    try {
+        // Suppress API key warnings
+        const origWarn = console.warn;
+        console.warn = (...args) => {
+            const msg = String(args[0] || '');
+            if (msg.includes('unsecure connection'))
+                return;
+            origWarn.apply(console, args);
+        };
+        await ensureCollection();
+        console.warn = origWarn;
+        await mainMenu();
+    }
+    catch (err) {
+        console.error(danger(`\n  ${ICONS.cross} Fatal error:`), err);
+        process.exit(1);
+    }
+}
+main();
+//# sourceMappingURL=tui.js.map