@openanonymity/nanomem 0.1.0 → 0.1.2

package/src/browser.js

@@ -0,0 +1,227 @@
+/**
+ * Browser-safe nanomem entrypoint.
+ *
+ * This mirrors createMemoryBank from index.js but excludes the filesystem
+ * backend so browser bundlers do not try to resolve node:* imports.
+ */
+/** @import { MemoryBank, MemoryBankConfig, MemoryBankLLMConfig, Message, IngestOptions, AugmentQueryResult, RetrievalResult, StorageBackend } from './types.js' */
+
+import { createOpenAIClient } from './llm/openai.js';
+import { createAnthropicClient } from './llm/anthropic.js';
+import { MemoryBulletIndex } from './bullets/bulletIndex.js';
+import { MemoryRetriever } from './engine/retriever.js';
+import { MemoryIngester } from './engine/ingester.js';
+import { MemoryCompactor } from './engine/compactor.js';
+import { InMemoryStorage } from './backends/ram.js';
+import { importData as importMemoryData } from './imports/importData.js';
+import { serialize, toZip } from './utils/portability.js';
+import { buildOmfExport, previewOmfImport, importOmf, parseOmfText, validateOmf } from './omf.js';
+
+/**
+ * Remove review-only [[user_data]] markers before sending the final prompt to
+ * the frontier model.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+export function stripUserDataTags(text) {
+    return String(text ?? '')
+        .replace(/\[\[user_data\]\]/g, '')
+        .replace(/\[\[\/user_data\]\]/g, '');
+}
+
+/**
+ * @param {MemoryBankConfig} [config]
+ * @returns {MemoryBank}
+ */
+export function createMemoryBank(config = {}) {
+    const llmClient = config.llmClient || createBrowserLlmClient(config.llm);
+    const model = config.model || config.llm?.model || 'gpt-4o';
+    const backend = createBrowserBackend(config.storage);
+    const bulletIndex = new MemoryBulletIndex(backend);
+
+    const retrieval = new MemoryRetriever({
+        backend,
+        bulletIndex,
+        llmClient,
+        model,
+        onProgress: config.onProgress,
+        onModelText: config.onModelText
+    });
+    const ingester = new MemoryIngester({
+        backend,
+        bulletIndex,
+        llmClient,
+        model,
+        onToolCall: config.onToolCall
+    });
+    const compactor = new MemoryCompactor({
+        backend,
+        bulletIndex,
+        llmClient,
+        model,
+        onProgress: config.onCompactProgress
+    });
+
+    async function write(path, content) {
+        await backend.write(path, content);
+        await bulletIndex.refreshPath(path);
+    }
+
+    async function remove(path) {
+        await backend.delete(path);
+        await bulletIndex.refreshPath(path);
+    }
+
+    async function rebuildTree() {
+        await backend.rebuildTree();
+        await bulletIndex.rebuild();
+    }
+
+    return {
+        init: () => backend.init(),
+        retrieve: (query, conversationText) => retrieval.retrieveForQuery(query, conversationText),
+        augmentQuery: (query, conversationText) => retrieval.augmentQueryForPrompt(query, conversationText),
+        ingest: (messages, options) => ingester.ingest(messages, options),
+        importData: (input, options) => importMemoryData({
+            init: () => backend.init(),
+            ingest: (messages, ingestOptions) => ingester.ingest(messages, ingestOptions)
+        }, input, options),
+        exportOmf: async () => {
+            await backend.init();
+            return buildOmfExport({
+                read: (path) => backend.read(path),
+                write: (path, content) => write(path, content),
+                delete: (path) => remove(path),
+                exists: (path) => backend.exists(path),
+                search: (query) => backend.search(query),
+                ls: (dirPath) => backend.ls(dirPath),
+                getTree: () => backend.getTree(),
+                rebuildTree: () => rebuildTree(),
+                exportAll: () => backend.exportAll(),
+                clear: () => backend.clear(),
+            }, { sourceApp: 'nanomem' });
+        },
+        previewOmfImport: async (doc, options) => {
+            await backend.init();
+            return previewOmfImport({
+                read: (path) => backend.read(path),
+                write: (path, content) => write(path, content),
+                delete: (path) => remove(path),
+                exists: (path) => backend.exists(path),
+                search: (query) => backend.search(query),
+                ls: (dirPath) => backend.ls(dirPath),
+                getTree: () => backend.getTree(),
+                rebuildTree: () => rebuildTree(),
+                exportAll: () => backend.exportAll(),
+                clear: () => backend.clear(),
+            }, doc, options);
+        },
+        importOmf: async (doc, options) => {
+            await backend.init();
+            return importOmf({
+                read: (path) => backend.read(path),
+                write: (path, content) => write(path, content),
+                delete: (path) => remove(path),
+                exists: (path) => backend.exists(path),
+                search: (query) => backend.search(query),
+                ls: (dirPath) => backend.ls(dirPath),
+                getTree: () => backend.getTree(),
+                rebuildTree: () => rebuildTree(),
+                exportAll: () => backend.exportAll(),
+                clear: () => backend.clear(),
+            }, doc, options);
+        },
+        compact: () => compactor.compactAll(),
+        storage: {
+            read: (path) => backend.read(path),
+            resolvePath: (path) => backend.resolvePath ? backend.resolvePath(path) : Promise.resolve(null),
+            write: (path, content) => write(path, content),
+            delete: (path) => remove(path),
+            exists: (path) => backend.exists(path),
+            search: (query) => backend.search(query),
+            ls: (dirPath) => backend.ls(dirPath),
+            getTree: () => backend.getTree(),
+            rebuildTree: () => rebuildTree(),
+            exportAll: () => backend.exportAll(),
+            clear: () => backend.clear()
+        },
+        serialize: async () => serialize(await backend.exportAll()),
+        toZip: async () => toZip(await backend.exportAll()),
+        _backend: backend,
+        _bulletIndex: bulletIndex
+    };
+}
+
+function createBrowserLlmClient(llmConfig = /** @type {MemoryBankLLMConfig} */ ({ apiKey: '' })) {
+    const { apiKey, baseUrl, headers, provider } = llmConfig;
+    if (!apiKey) {
+        throw new Error('createMemoryBank: config.llm.apiKey is required (or provide config.llmClient)');
+    }
+
+    const detectedProvider = provider || detectProvider(baseUrl);
+    if (detectedProvider === 'anthropic') {
+        return createAnthropicClient({ apiKey, baseUrl, headers });
+    }
+    if (detectedProvider === 'tinfoil') {
+        throw new Error(
+            'createMemoryBank(browser): Tinfoil provider requires the Node.js entry (src/index.js). ' +
+            'Use provider "openai" with baseUrl "https://inference.tinfoil.sh/v1" for browser builds.'
+        );
+    }
+    return createOpenAIClient({ apiKey, baseUrl, headers });
+}
+
+function detectProvider(baseUrl) {
+    if (!baseUrl) return 'openai';
+    const lower = baseUrl.toLowerCase();
+    if (lower.includes('anthropic.com')) return 'anthropic';
+    if (lower.includes('tinfoil.sh')) return 'tinfoil';
+    return 'openai';
+}
+
+function createBrowserBackend(storage) {
+    if (storage && typeof storage === 'object' && typeof storage.read === 'function') {
+        return storage;
+    }
+
+    const storageType = typeof storage === 'string' ? storage : 'ram';
+    switch (storageType) {
+        case 'indexeddb':
+            return asyncBackend(() => import('./backends/indexeddb.js').then((module) => new module.IndexedDBStorage()));
+        case 'filesystem':
+            throw new Error('createMemoryBank(browser): filesystem storage is not available in the browser entrypoint.');
+        case 'ram':
+        default:
+            return new InMemoryStorage();
+    }
+}
+
+function asyncBackend(loader) {
+    let backend = null;
+    let loading = null;
+
+    async function resolve() {
+        if (backend) return backend;
+        if (!loading) {
+            loading = loader().then((instance) => {
+                backend = instance;
+                return backend;
+            });
+        }
+        return loading;
+    }
+
+    const methods = ['init', 'read', 'resolvePath', 'write', 'delete', 'exists', 'ls', 'search', 'getTree', 'rebuildTree', 'exportAll', 'clear'];
+    const proxy = {};
+    for (const method of methods) {
+        proxy[method] = async (...args) => {
+            const resolved = await resolve();
+            return resolved[method](...args);
+        };
+    }
+    return /** @type {StorageBackend} */ (proxy);
+}
+
+export * from './bullets/index.js';
+export { buildOmfExport, previewOmfImport, importOmf, parseOmfText, validateOmf } from './omf.js';

package/src/bullets/parser.js

@@ -33,11 +33,11 @@ export function parseBullets(content) {
         const headingMatch = line.match(HEADING_REGEX);
         if (headingMatch) {
             currentHeading = headingMatch[1].trim() || currentHeading;
-            if (/^(working)$/i.test(currentHeading)) {
+            if (/^working/i.test(currentHeading)) {
                 section = 'working';
-            } else if (/^(long[- ]?term|active)$/i.test(currentHeading)) {
+            } else if (/^(long[- ]?term|active)/i.test(currentHeading)) {
                 section = 'long_term';
-            } else if (/^(history|archive)$/i.test(currentHeading)) {
+            } else if (/^(history|archive)/i.test(currentHeading)) {
                 section = 'history';
             }
             continue;
@@ -120,7 +120,7 @@ export function extractTitles(content) {
 
         const title = headingMatch[1].trim();
         if (!title) continue;
-        if (/^(working|long[- ]?term|history|active|archive|current context|stable facts|no longer current)$/i.test(title)) continue;
+        if (/^(working|long[- ]?term|history|active|archive)/i.test(title)) continue;
         titles.push(title);
     }
 
@@ -160,9 +160,8 @@ function inferDocumentTopic(bullets, fallback = 'general') {
     return firstTopic || fallback;
 }
 
-function renderSection(lines, title, subsectionTitle, bullets, forceHistory = false) {
+function renderSection(lines, title, bullets, forceHistory = false) {
     lines.push(`## ${title}`);
-    lines.push(`### ${subsectionTitle}`);
 
     if (!bullets || bullets.length === 0) {
         lines.push('_No entries yet._');
@@ -189,11 +188,11 @@ export function renderCompactedDocument(working, longTerm, history, options = {}
     const docTopic = normalizeTopic(options.titleTopic || inferDocumentTopic([...working, ...longTerm, ...history], 'general'));
     lines.push(`# Memory: ${topicHeading(docTopic)}`);
     lines.push('');
-    renderSection(lines, 'Working', 'Current context', working);
+    renderSection(lines, 'Working memory (current context subject to change)', working);
     lines.push('');
-    renderSection(lines, 'Long-Term', 'Stable facts', longTerm);
+    renderSection(lines, 'Long-term memory (stable facts that are unlikely to change)', longTerm);
     lines.push('');
-    renderSection(lines, 'History', 'No longer current', history, true);
+    renderSection(lines, 'History (no longer current)', history, true);
 
     return lines.join('\n').trim();
 }

package/src/cli/auth.js

@@ -61,7 +61,7 @@ export async function loginInteractive() {
     process.stderr.write('\n');
     process.stderr.write(`  ${c.bold}${c.cyan}Login${c.reset}\n`);
     process.stderr.write('\n');
-    process.stderr.write(`  ${c.white}simple-memory uses an LLM provider for extraction and retrieval.${c.reset}\n`);
+    process.stderr.write(`  ${c.white}nanomem uses an LLM provider for extraction and retrieval.${c.reset}\n`);
     process.stderr.write(`  ${c.white}Select your provider, model, and paste your API key to get started.${c.reset}\n`);
     process.stderr.write('\n');
 

package/src/cli/commands.js

@@ -8,6 +8,7 @@ import { serialize, toZip } from '../utils/portability.js';
 import { safeDateIso } from '../bullets/normalize.js';
 import { extractSessionsFromOAFastchatExport } from '../imports/oaFastchat.js';
 import { isChatGptExport, parseChatGptExport } from '../imports/chatgpt.js';
+import { isClaudeExport, parseClaudeExport } from '../imports/claude.js';
 import { parseMarkdownFiles } from '../imports/markdown.js';
 import { loginInteractive } from './auth.js';
 import { writeConfigFile, CONFIG_PATH } from './config.js';
@@ -77,6 +78,11 @@ function parseConversations(input, flags) {
             return parseChatGptExport(parsed);
         }
 
+        // Claude export (conversations.json)
+        if (isClaudeExport(parsed)) {
+            return parseClaudeExport(parsed);
+        }
+
         // Plain messages array
         if (Array.isArray(parsed)) {
             return [{ title: null, messages: parsed }];
@@ -129,7 +135,7 @@ export async function retrieve(positionals, flags, mem) {
 
     const result = await mem.retrieve(query, conversationText);
     if (!result || !result.assembledContext) {
-        return { assembledContext: null, message: 'No relevant context found.' };
+        return 'No relevant context found.';
     }
     return result;
 }
@@ -161,10 +167,18 @@ export async function importCmd(positionals, flags, mem, config, { showProgress,
 
 export async function add(positionals, flags, mem, config, { showProgress, spinnerHolder } = {}) {
     const input = positionals[0] ?? (!process.stdin.isTTY ? await readStdin() : null);
-    if (!input) throw new Error('Usage: memory add <text>');
+    if (!input) throw new Error('Usage: nanomem add <text>');
+
+    const conversations = parseConversations(input, flags);
+    return ingestConversations(conversations, 'add', mem, { showProgress, spinnerHolder, status: 'added', showDiff: true });
+}
+
+export async function update(positionals, flags, mem, config, { showProgress, spinnerHolder } = {}) {
+    const input = positionals[0] ?? (!process.stdin.isTTY ? await readStdin() : null);
+    if (!input) throw new Error('Usage: nanomem update <text>');
 
     const conversations = parseConversations(input, flags);
-    return ingestConversations(conversations, 'conversation', mem, { showProgress, spinnerHolder, status: 'added', showDiff: true });
+    return ingestConversations(conversations, 'update', mem, { showProgress, spinnerHolder, status: 'updated', showDiff: true });
 }
 
 async function ingestConversations(conversations, extractionMode, mem, { showProgress, spinnerHolder, status, showDiff = false }) {
@@ -180,7 +194,7 @@ async function ingestConversations(conversations, extractionMode, mem, { showPro
 
     for (let i = 0; i < total; i++) {
         const conv = conversations[i];
-        const label = conv.title || `conversation ${i + 1}`;
+        const label = conv.title || (total > 1 ? `conversation ${i + 1}` : 'conversation');
 
         if (showProgress) {
             const counter = total > 1 ? `${c.gray}(${i + 1}/${total})${c.reset} ` : '';
@@ -259,13 +273,48 @@ export async function write(positionals, flags, mem) {
     return { status: 'written', path };
 }
 
-export async function del(positionals, flags, mem) {
-    const path = positionals[0];
-    if (!path) throw new Error('Usage: memory delete <path>');
+export async function del(positionals, flags, mem, config, { showProgress, spinnerHolder } = {}) {
+    const query = positionals[0] ?? (!process.stdin.isTTY ? await readStdin() : null);
+    if (!query) throw new Error('Usage: nanomem delete <query>');
 
     await mem.init();
-    await mem.storage.delete(path);
-    return { status: 'deleted', path };
+
+    const isTTY = process.stderr.isTTY;
+    const c = isTTY ? { green: '\x1b[32m', yellow: '\x1b[33m', dim: '\x1b[2m', bold: '\x1b[1m', reset: '\x1b[0m' }
+                    : { green: '', yellow: '', dim: '', bold: '', reset: '' };
+
+    let spinner = null;
+    if (showProgress && isTTY) {
+        spinner = createSpinner('thinking…');
+        if (spinnerHolder) spinnerHolder.current = spinner;
+    }
+
+    const result = await mem.deleteContent(query, { deep: !!flags.deep });
+
+    if (spinnerHolder) spinnerHolder.current = null;
+
+    if (showProgress) {
+        if (result.status === 'error') {
+            spinner?.stop(`  ${c.yellow}⚠ ${result.error}${c.reset}`);
+        } else if (result.deleteCalls > 0) {
+            spinner?.stop(`  ${c.green}✓ ${result.deleteCalls} fact${result.deleteCalls === 1 ? '' : 's'} deleted${c.reset}`);
+        } else {
+            spinner?.stop(`  ${c.dim}– nothing matched${c.reset}`);
+        }
+        if (result.writes?.length) {
+            for (const { path, before, after } of result.writes) {
+                if (after === null) {
+                    // Entire file was deleted (no bullets remained)
+                    process.stderr.write(`\n  \x1b[1m\x1b[36m${path}\x1b[0m  \x1b[2mfile deleted\x1b[0m\n`);
+                } else {
+                    printFileDiff(path, before, after);
+                }
+            }
+        }
+    }
+
+    const status = result.status === 'error' ? 'error' : 'deleted_content';
+    return { status, deleteCalls: result.deleteCalls, error: result.error };
 }
 
 export async function search(positionals, flags, mem) {

package/src/cli/config.js

@@ -83,7 +83,7 @@ export async function resolveConfig(flags) {
 
 // ─── Create a memory instance from resolved config ──────────────
 
-const LLM_COMMANDS = new Set(['retrieve', 'extract', 'compact', 'import', 'add']);
+const LLM_COMMANDS = new Set(['retrieve', 'extract', 'compact', 'import', 'add', 'update', 'delete']);
 
 export function createMemoryFromConfig(config, command, { onToolCall, onProgress, onCompactProgress } = {}) {
     const needsLlm = LLM_COMMANDS.has(command);

package/src/cli/help.js

@@ -11,7 +11,8 @@ Commands:
     status                                  Show current config and storage stats
 
   Memory:
-    add <text>                              Add raw text directly and extract facts
+    add <text>                              Add new facts from text (creates or appends files)
+    update <text>                           Edit existing facts from text (only modifies existing files)
     import <file|dir|->                     Import conversations or notes and extract facts
     retrieve <query> [--context <file>]     Retrieve relevant context for a query
     compact                                 Deduplicate and archive stale facts
@@ -39,6 +40,7 @@ Flags:
 Examples:
   nanomem login
   nanomem add "User: I moved to Seattle."
+  nanomem update "User: Actually I moved to Portland, not Seattle."
   nanomem import conversations.json
   nanomem import my-notes.md
   nanomem import ./notes/
@@ -48,7 +50,8 @@ Examples:
 `;
 
 export const COMMAND_HELP = {
-    add: 'Usage: nanomem add <text>\n\nAdd raw text directly and extract facts into memory.\nAccepts quoted text or piped stdin.\nRequires an LLM API key.',
+    add: 'Usage: nanomem add <text>\n\nAdd new facts from text. The LLM will create a new file or append to an existing one.\nAccepts quoted text or piped stdin.\nRequires an LLM API key.',
+    update: 'Usage: nanomem update <text>\n\nEdit existing facts from text. The LLM will only modify files that already exist — no new files are created.\nAccepts quoted text or piped stdin.\nRequires an LLM API key.',
     retrieve: 'Usage: nanomem retrieve <query> [--context <file>]\n\nRetrieve relevant memory context for a query.\nRequires an LLM API key.',
     compact: 'Usage: nanomem compact\n\nDeduplicate and archive stale facts across all memory files.\nRequires an LLM API key.',
     ls: 'Usage: nanomem ls [path]\n\nList files and directories in storage.',

package/src/cli/output.js

@@ -129,6 +129,10 @@ function formatAction(result) {
             return section(green('✓ Facts extracted'), [
                 ['Files updated', result.writeCalls],
             ]);
+        case 'deleted_content':
+            return result.deleteCalls > 0
+                ? section(green('✓ Memory updated'), [['Facts removed', result.deleteCalls]])
+                : dim('– Nothing matched');
         case 'skipped':
             return dim('– Nothing to extract (conversation too short)');
         case 'imported':

package/src/cli.js

@@ -34,11 +34,13 @@ const OPTIONS = {
     'session-id':    { type: 'string' },
     'session-title': { type: 'string' },
     'confirm':       { type: 'boolean', default: false },
-    'render': { type: 'boolean', default: false },
+    'render':        { type: 'boolean', default: false },
+    'deep':          { type: 'boolean', default: false },
 };
 
 const COMMAND_MAP = {
     add:      commands.add,
+    update:   commands.update,
     login:    commands.login,
     init:     commands.init,
     retrieve: commands.retrieve,
@@ -95,18 +97,19 @@ async function main() {
     const memOpts = {};
 
     // Wire progress for import/extract — spinner per session with live tool call updates
-    const isImport = commandName === 'import' || commandName === 'add' || commandName === 'extract';
+    const isImport = commandName === 'import' || commandName === 'add' || commandName === 'update' || commandName === 'extract' || commandName === 'delete';
     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',
+            update_bullets:  'updating',
+            delete_bullet:   'deleting',
         };
         memOpts.onToolCall = (name) => {
             const label = TOOL_LABELS[name] || name;

package/src/engine/compactor.js

@@ -33,16 +33,13 @@ Input is one memory file. Rewrite it into:
 
 # Memory: <Topic>
 
-## Working
-### <Topic>
+## Working memory (current context subject to change)
 - fact | topic=<topic> | tier=working | status=active | source=user_statement|assistant_summary|inference|system | confidence=high|medium|low | updated_at=YYYY-MM-DD | review_at=YYYY-MM-DD(optional) | expires_at=YYYY-MM-DD(optional)
 
-## Long-Term
-### <Topic>
+## Long-term memory (stable facts that are unlikely to change)
 - fact | topic=<topic> | tier=long_term | status=active | source=user_statement|assistant_summary|inference|system | confidence=high|medium|low | updated_at=YYYY-MM-DD | expires_at=YYYY-MM-DD(optional)
 
-## History
-### <Topic>
+## History (no longer current)
 - fact | topic=<topic> | tier=history | status=superseded|expired|uncertain | source=user_statement|assistant_summary|inference|system | confidence=high|medium|low | updated_at=YYYY-MM-DD | expires_at=YYYY-MM-DD(optional)
 
 Rules: