@openanonymity/nanomem 0.1.0

package/src/cli/output.js

@@ -0,0 +1,269 @@
+/**
+ * CLI output formatting — JSON for pipes, human-readable for terminals.
+ */
+
+// ─── ANSI helpers ─────────────────────────────────────────────────
+
+const c = {
+    reset:  '\x1b[0m',
+    bold:   '\x1b[1m',
+    dim:    '\x1b[2m',
+    cyan:   '\x1b[36m',
+    green:  '\x1b[32m',
+    red:    '\x1b[31m',
+    yellow: '\x1b[33m',
+    white:  '\x1b[37m',
+    gray:   '\x1b[90m',
+};
+
+function col(code, text) {
+    if (!process.stdout.isTTY) return text;
+    return `${code}${text}${c.reset}`;
+}
+
+const dim    = t => col(c.dim, t);
+const bold   = t => col(c.bold, t);
+const cyan   = t => col(c.cyan, t);
+const green  = t => col(c.green, t);
+const red    = t => col(c.red, t);
+const gray   = t => col(c.gray, t);
+
+// ─── Public ───────────────────────────────────────────────────────
+
+export function formatOutput(result, flags) {
+    if (flags.json || !process.stdout.isTTY) {
+        return JSON.stringify(result, null, 2);
+    }
+    return formatHuman(result, flags);
+}
+
+function formatHuman(result, flags) {
+    if (result == null) return '';
+    if (typeof result === 'string') return maybeRenderMarkdown(result, flags);
+
+    // retrieve → print assembled context directly
+    if (result.assembledContext != null) {
+        return maybeRenderMarkdown(result.assembledContext, flags) || dim('No relevant context found.');
+    }
+
+    // read → print content directly
+    if ('content' in result && 'path' in result) {
+        return maybeRenderMarkdown(result.content ?? '', flags);
+    }
+
+    // ls → list files and dirs
+    if (result.files && result.dirs) {
+        const lines = [];
+        for (const d of result.dirs)  lines.push(cyan(d + '/'));
+        for (const f of result.files) lines.push(gray('  ') + f);
+        return lines.join('\n') || dim('(empty)');
+    }
+
+    // tree
+    if (result.treeLines != null) {
+        return result.treeLines.join('\n') || dim('(empty)');
+    }
+
+    // status → grouped display
+    if ('provider' in result && 'storagePath' in result) {
+        return [
+            '',
+            `  ${bold('LLM')}`,
+            row('Provider',    result.provider),
+            row('Model',       result.model),
+            row('Base URL',    result.baseUrl),
+            '',
+            `  ${bold('Storage')}`,
+            row('Backend',     result.storage),
+            row('Path',        result.storagePath),
+            row('Config',      result.configFile),
+            row('Files',       String(result.files)),
+            row('Directories', result.directories?.length ? result.directories.join(', ') : '(none)'),
+            '',
+        ].join('\n');
+    }
+
+    // search results
+    if (Array.isArray(result)) {
+        if (result.length === 0) return dim('No results.');
+        const query = result._query || '';
+        return result.map(r => {
+            if (!r.path) return JSON.stringify(r);
+            const matchLines = (r.lines || [])
+                .map(line => '  ' + highlightQuery(line, query))
+                .join('\n');
+            return `${bold(r.path)}\n${matchLines}`;
+        }).join('\n\n');
+    }
+
+    // status actions
+    if (result.status) return formatAction(result);
+
+    // generic object → key: value
+    const pad = Math.max(...Object.keys(result).map(k => k.length));
+    return Object.entries(result)
+        .map(([k, v]) => row(k.padEnd(pad), Array.isArray(v) ? v.join(', ') : String(v)))
+        .join('\n');
+}
+
+function formatAction(result) {
+    switch (result.status) {
+        case 'initialized':
+            return section(green('✓ Memory initialized'), [
+                ['Backend', result.storage],
+                ['Path',    result.path],
+            ]);
+        case 'written':
+            return green(`✓ Written to ${result.path}`);
+        case 'deleted':
+            return green(`✓ Deleted ${result.path}`);
+        case 'compacted': {
+            const changed = result.filesChanged ?? 0;
+            const total   = result.filesTotal ?? 0;
+            const detail  = total > 0
+                ? `\n\n    ${dim('Files reviewed')}   ${bold(String(total))}\n    ${dim('Files updated')}    ${bold(String(changed))}`
+                : '';
+            return green('✓ Memory compacted') + detail;
+        }
+        case 'processed':
+            return section(green('✓ Facts extracted'), [
+                ['Files updated', result.writeCalls],
+            ]);
+        case 'skipped':
+            return dim('– Nothing to extract (conversation too short)');
+        case 'imported':
+            return section(green('✓ Chat history imported'), [
+                ['Sessions',      result.sessions],
+                ['Files updated', result.totalWriteCalls],
+            ]);
+        case 'added':
+            return section(green('✓ Text added to memory'), [
+                ['Sessions',      result.sessions],
+                ['Files updated', result.totalWriteCalls],
+            ]);
+        case 'exported':
+            return section(green('✓ Memory exported'), [
+                ['Files',  result.files],
+                ['Format', result.format],
+                ['Path',   result.path],
+            ]);
+        case 'cleared':
+            return section(green('✓ Memory cleared'), [
+                ['Files deleted', result.filesDeleted],
+                ['Path',         result.path],
+            ]);
+        case 'logged_in':
+            return section(green('✓ Logged in'), [
+                ['Provider', result.provider],
+                ['Config',   result.configFile],
+            ]);
+        case 'logged_in_interactive':
+            return null; // already printed by the interactive prompt
+        case 'error':
+            return red(`✗ Extraction failed: ${result.error || 'unknown error'}`);
+        default:
+            return green(`✓ ${result.status}`);
+    }
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────
+
+function row(key, value) {
+    return `    ${dim(key.padEnd(14))}  ${value}`;
+}
+
+function section(heading, rows) {
+    if (!rows || rows.length === 0) return heading;
+    const pad = Math.max(...rows.map(([k]) => String(k).length));
+    const detail = rows
+        .map(([k, v]) => `    ${dim(String(k).padEnd(pad))}   ${bold(String(v ?? ''))}`)
+        .join('\n');
+    return `${heading}\n\n${detail}`;
+}
+
+function highlightQuery(text, query) {
+    if (!query) return text;
+    const re = new RegExp(`(${query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})`, 'gi');
+    return text.replace(re, `\x1b[33;1m$1\x1b[0m`);
+}
+
+function maybeRenderMarkdown(text, flags = {}) {
+    if (!text) return text;
+    if (!process.stdout.isTTY) return text;
+    if (!flags['render']) return text;
+    return renderMarkdown(text);
+}
+
+function renderMarkdown(markdown) {
+    const lines = markdown.replace(/\r\n/g, '\n').split('\n');
+    const rendered = [];
+    let inFence = false;
+
+    for (const line of lines) {
+        if (/^\s*```/.test(line)) {
+            inFence = !inFence;
+            if (!inFence) rendered.push('');
+            continue;
+        }
+
+        if (inFence) {
+            rendered.push(`  ${gray(line)}`);
+            continue;
+        }
+
+        const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+        if (heading) {
+            const level = heading[1].length;
+            const text = renderInline(heading[2].trim());
+            rendered.push(level <= 2 ? bold(text) : cyan(text));
+            continue;
+        }
+
+        const quote = /^\s*>\s?(.*)$/.exec(line);
+        if (quote) {
+            rendered.push(`${gray('│')} ${renderInline(quote[1])}`);
+            continue;
+        }
+
+        const bullet = /^(\s*)[-*+]\s+(.*)$/.exec(line);
+        if (bullet) {
+            const indent = ' '.repeat(Math.min(bullet[1].length, 6));
+            rendered.push(`${indent}${cyan('•')} ${renderInline(bullet[2])}`);
+            continue;
+        }
+
+        const numbered = /^(\s*)\d+\.\s+(.*)$/.exec(line);
+        if (numbered) {
+            const indent = ' '.repeat(Math.min(numbered[1].length, 6));
+            rendered.push(`${indent}${cyan('•')} ${renderInline(numbered[2])}`);
+            continue;
+        }
+
+        const rule = /^\s*([-*_])(?:\s*\1){2,}\s*$/.test(line);
+        if (rule) {
+            rendered.push(gray('────────────────────────'));
+            continue;
+        }
+
+        rendered.push(renderInline(line));
+    }
+
+    return rendered.join('\n');
+}
+
+function renderInline(text) {
+    if (!text) return text;
+
+    let out = text;
+    out = out.replace(/`([^`]+)`/g, (_, code) => gray(code));
+    out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, url) => `${underline(label)} ${gray(`<${url}>`)}`);
+    out = out.replace(/\*\*([^*]+)\*\*/g, (_, value) => bold(value));
+    out = out.replace(/__([^_]+)__/g, (_, value) => bold(value));
+    out = out.replace(/(^|[^\*])\*([^*\n]+)\*(?!\*)/g, (_, prefix, value) => `${prefix}${dim(value)}`);
+    out = out.replace(/(^|[^_])_([^_\n]+)_(?!_)/g, (_, prefix, value) => `${prefix}${dim(value)}`);
+    return out;
+}
+
+function underline(text) {
+    return col('\x1b[4m', text);
+}

package/src/cli/spinner.js

@@ -0,0 +1,54 @@
+/**
+ * Minimal TTY spinner — no dependencies.
+ * Writes to stderr so it doesn't pollute stdout piping.
+ */
+
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const INTERVAL_MS = 80;
+
+const c = {
+    reset:  '\x1b[0m',
+    dim:    '\x1b[2m',
+    cyan:   '\x1b[36m',
+    green:  '\x1b[32m',
+    yellow: '\x1b[33m',
+};
+
+/**
+ * Create and start a spinner.
+ *
+ * @param {string} label  Initial label text
+ * @returns {{ update: (label: string) => void, stop: (finalLine?: string) => void }}
+ */
+export function createSpinner(label) {
+    if (!process.stderr.isTTY) {
+        // Non-TTY: just print the label once, no animation
+        process.stderr.write(`  ${label}\n`);
+        return {
+            update: () => {},
+            stop: (finalLine) => { if (finalLine) process.stderr.write(finalLine + '\n'); },
+        };
+    }
+
+    let current = label;
+    let frame = 0;
+
+    function render() {
+        const spinner = FRAMES[frame++ % FRAMES.length];
+        process.stderr.write(`\r  ${c.cyan}${spinner}${c.reset} ${c.dim}${current}${c.reset}  `);
+    }
+
+    render();
+    const timer = setInterval(render, INTERVAL_MS);
+
+    return {
+        update(newLabel) {
+            current = newLabel;
+        },
+        stop(finalLine) {
+            clearInterval(timer);
+            process.stderr.write('\r\x1b[2K'); // clear line
+            if (finalLine) process.stderr.write(finalLine + '\n');
+        },
+    };
+}

package/src/cli.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for @openanonymity/nanomem.
+ *
+ * Usage: nanomem <command> [args] [flags]
+ */
+
+import { parseArgs } from 'node:util';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+import { resolveConfig, createMemoryFromConfig } from './cli/config.js';
+import { GLOBAL_HELP, COMMAND_HELP } from './cli/help.js';
+import { formatOutput } from './cli/output.js';
+import { createSpinner } from './cli/spinner.js';
+import * as commands from './cli/commands.js';
+
+// ─── Parse args ──────────────────────────────────────────────────
+
+const OPTIONS = {
+    'api-key':       { type: 'string' },
+    'model':         { type: 'string' },
+    'provider':      { type: 'string' },
+    'base-url':      { type: 'string' },
+    'storage':       { type: 'string' },
+    'path':          { type: 'string' },
+    'json':          { type: 'boolean', default: false },
+    'help':          { type: 'boolean', short: 'h', default: false },
+    'version':       { type: 'boolean', short: 'v', default: false },
+    'content':       { type: 'string' },
+    'format':        { type: 'string' },
+    'context':       { type: 'string' },
+    'session-id':    { type: 'string' },
+    'session-title': { type: 'string' },
+    'confirm':       { type: 'boolean', default: false },
+    'render': { type: 'boolean', default: false },
+};
+
+const COMMAND_MAP = {
+    add:      commands.add,
+    login:    commands.login,
+    init:     commands.init,
+    retrieve: commands.retrieve,
+    import:   commands.importCmd,
+    compact:  commands.compact,
+    tree:     commands.tree,
+    ls:       commands.ls,
+    read:     commands.read,
+    write:    commands.write,
+    delete:   commands.del,
+    search:   commands.search,
+    export:   commands.exportCmd,
+    clear:    commands.clear,
+    status:   commands.status,
+};
+
+// ─── Main ────────────────────────────────────────────────────────
+
+async function main() {
+    let values, positionals;
+    try {
+        ({ values, positionals } = parseArgs({ options: OPTIONS, allowPositionals: true, strict: true }));
+    } catch (err) {
+        die(err.message);
+    }
+
+    // --version
+    if (values.version) {
+        const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+        const pkg = JSON.parse(await readFile(pkgPath, 'utf-8'));
+        console.log(pkg.version);
+        return;
+    }
+
+    const commandName = positionals[0];
+    const commandArgs = positionals.slice(1);
+
+    // --help (global or per-command)
+    if (values.help || !commandName) {
+        if (commandName && COMMAND_HELP[commandName]) {
+            console.log(COMMAND_HELP[commandName]);
+        } else {
+            console.log(GLOBAL_HELP);
+        }
+        return;
+    }
+
+    const handler = COMMAND_MAP[commandName];
+    if (!handler) {
+        die(`Unknown command: ${commandName}\n\n${GLOBAL_HELP}`);
+    }
+
+    const config = await resolveConfig(values);
+    const memOpts = {};
+
+    // Wire progress for import/extract — spinner per session with live tool call updates
+    const isImport = commandName === 'import' || commandName === 'add' || commandName === 'extract';
+    const showProgress = isImport && !values.json && process.stderr.isTTY;
+    const spinnerHolder = { current: null }; // shared mutable ref between onToolCall and import loop
+    if (showProgress) {
+        const TOOL_LABELS = {
+            create_new_file: 'creating file',
+            append_memory:   'appending',
+            update_memory:   'updating',
+            archive_memory:  'archiving',
+            delete_memory:   'cleaning up',
+            read_file:       'reading',
+            list_files:      'scanning',
+        };
+        memOpts.onToolCall = (name) => {
+            const label = TOOL_LABELS[name] || name;
+            spinnerHolder.current?.update(label + '…');
+        };
+    }
+
+    // Wire progress for retrieve — surface fallback warnings to the user
+    if (commandName === 'retrieve' && !values.json && process.stderr.isTTY) {
+        memOpts.onProgress = ({ stage, message }) => {
+            if (stage === 'fallback') {
+                process.stderr.write(`Warning: ${message}\n`);
+            }
+        };
+    }
+
+    if (commandName === 'compact' && !values.json && process.stderr.isTTY) {
+        const cc = {
+            reset: '\x1b[0m', dim: '\x1b[2m',
+            yellow: '\x1b[33m', gray: '\x1b[90m',
+        };
+        let activeSpinner = null;
+        process.stderr.write('\n');
+        memOpts.onCompactProgress = ({ stage, file, current, total, deduplicated, superseded, expired }) => {
+            if (stage === 'file') {
+                activeSpinner = createSpinner(`${cc.dim}(${current}/${total})${cc.reset} ${file}`);
+            } else if (stage === 'semantic') {
+                activeSpinner?.update(`reviewing working facts… ${cc.dim}${file}${cc.reset}`);
+            } else if (stage === 'file_done') {
+                const changes = [];
+                if (superseded   > 0) changes.push(`${superseded} superseded`);
+                if (deduplicated > 0) changes.push(`${deduplicated} deduplicated`);
+                if (expired      > 0) changes.push(`${expired} expired`);
+                const tag = changes.length > 0
+                    ? `${cc.yellow}${changes.join(', ')}${cc.reset}`
+                    : `${cc.dim}no changes${cc.reset}`;
+                activeSpinner?.stop(`  ${cc.gray}${file.padEnd(36)}${cc.reset}  ${tag}`);
+                activeSpinner = null;
+            }
+        };
+    }
+
+    const mem = createMemoryFromConfig(config, commandName, memOpts);
+
+    // Spinner for operations that give no other feedback
+    const useSpinner = !values.json && process.stderr.isTTY &&
+        (commandName === 'retrieve' || commandName === 'compact');
+    const spinner = useSpinner && commandName === 'retrieve'
+        ? createSpinner('searching memory…')
+        : null;
+
+    const result = await handler(commandArgs, values, mem, config, { showProgress, spinnerHolder });
+
+    spinner?.stop();
+
+    if (result != null) {
+        const output = formatOutput(result, values);
+        if (output) console.log(output);
+    }
+}
+
+function die(message) {
+    console.error(message);
+    process.exit(1);
+}
+
+main().catch(err => {
+    die(err.message || String(err));
+});