@openanonymity/nanomem 0.1.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Open Anonymity Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -24,6 +24,7 @@ Retrieval is only one part of memory. `nanomem` is built for the maintenance lay
 - **Compaction and cleanup.** Collapse repeated signals into stable knowledge and move stale memory into history.
 - **Conflict-aware updates.** Resolve outdated or contradictory facts using recency, source, and confidence.
 - **Import your existing history.** Start from ChatGPT exports, [OA Chat](https://chat.openanonymity.ai) exports, transcripts, message arrays, markdown notes, or whole markdown directories.
+- **Portable memory exchange.** Export full memory state as plain text, ZIP, or Open Memory Format (OMF), and merge OMF documents back in programmatically.
 - **Flexible storage.** Run on local files, IndexedDB, in-memory storage, or a custom backend.
 - **Built to plug in.** Use it from the CLI, as a library, or as a memory layer for other agents.
 
@@ -32,7 +33,7 @@ Retrieval is only one part of memory. `nanomem` is built for the maintenance lay
 Install:
 
 ```bash
-npm install -g @openanonymity/nanomem
+npm i @openanonymity/nanomem
 ```
 
 Set up once:
@@ -43,6 +44,13 @@ nanomem login
 
 This walks you through provider, model, API key, and where to store your memory. Config is saved to `~/.config/nanomem/config.json`. Filesystem memory lives in `~/nanomem/` by default.
 
+Add facts directly:
+
+```bash
+nanomem add "I moved to Seattle and started a new job at Acme."
+nanomem update "Actually I moved to Portland, not Seattle."
+```
+
 Import history or notes:
 
 ```bash
@@ -58,6 +66,13 @@ nanomem retrieve "what are my hobbies?"
 nanomem retrieve "what are my hobbies?" --render
 ```
 
+Delete facts from memory:
+
+```bash
+nanomem delete "I have a dog named Mochi"
+nanomem delete "I have a dog named Mochi" --deep
+```
+
 Compact and clean up memory:
 
 ```bash
@@ -73,6 +88,17 @@ nanomem login --provider anthropic --api-key sk-ant-... --model claude-sonnet-4-
 
 Supported providers include OpenAI, Anthropic, Tinfoil, OpenRouter, and OpenAI-compatible endpoints via `--base-url`.
 
+When `provider` is `tinfoil`, nanomem now uses the Tinfoil SDK and fails
+closed on enclave attestation verification before any inference request is
+sent. Browser consumers load a vendored SDK bundle, construct `TinfoilAI`,
+and require `await client.getVerificationDocument()` to report
+`securityVerified === true` before inference. The vendored bundle lives at
+`src/vendor/tinfoil.browser.js`; refresh it after SDK upgrades with:
+
+```bash
+npm run vendor:tinfoil
+```
+
 ## How it works
 
 ```text
@@ -89,7 +115,9 @@ conversation / notes / exports
             |  memory retrieve
             |  file selection + bullet-level scoring
             v
-      assembled memory context
+   prompt crafting / retrieval
+   retrieve -> augment_query(user_query, memory_files)
+   -> minimized reviewable prompt
             |
             v
        memory compact
@@ -144,17 +172,25 @@ await memory.ingest([
 
 const result = await memory.retrieve('Where do I live now?');
 await memory.compact();
+
+const omf = await memory.exportOmf();
+const preview = await memory.previewOmfImport(omf);
+await memory.importOmf(omf);
 ```
 
 ## Common commands
 
 ```bash
-nanomem import <file|dir|->
-nanomem retrieve <query> [--context <file>]
-nanomem tree
-nanomem compact
-nanomem export --format zip
-nanomem status
+nanomem add <text>                           # add new facts
+nanomem update <text>                        # correct existing facts
+nanomem delete <query>                       # delete facts matching a query
+nanomem delete <query> --deep                # delete across all files (thorough)
+nanomem import <file|dir|->                  # import history or notes
+nanomem retrieve <query> [--context <file>]  # retrieve relevant context
+nanomem tree                                 # browse memory files
+nanomem compact                              # deduplicate and archive
+nanomem export --format zip                  # export everything
+nanomem status                               # show config and stats
 ```
 
 For terminal use, `--render` will format markdown-heavy output like `read` and `retrieve` into a more readable ANSI-rendered view while leaving `--json` and piped output unchanged.
@@ -189,6 +225,8 @@ nanomem import my-notes.md --format markdown   # document mode (explicit)
 
 Internals: [docs/memory-system.md](./docs/memory-system.md)
 
+OMF spec: [docs/omf.md](./docs/omf.md)
+
 ## License
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openanonymity/nanomem",
-    "version": "0.1.0",
+    "version": "0.1.1",
     "description": "LLM-driven personal memory with agentic retrieval, extraction, and compaction",
     "type": "module",
     "bin": {
@@ -17,7 +17,9 @@
         "url": "https://github.com/openanonymity/nanomem/issues"
     },
     "scripts": {
-        "prepublishOnly": "npm run build:types",
+        "test": "node --test test/**/*.test.js",
+        "vendor:tinfoil": "node scripts/vendor-tinfoil.mjs",
+        "prepublishOnly": "npm run vendor:tinfoil && npm run build:types",
         "build:types": "tsc",
         "prepack": "tsc"
     },
@@ -72,10 +74,12 @@
     "license": "MIT",
     "devDependencies": {
         "@types/node": "^25.5.2",
+        "esbuild": "^0.27.2",
         "typescript": "^6.0.2"
     },
     "dependencies": {
-        "@pierre/diffs": "^1.1.12"
+        "@pierre/diffs": "^1.1.12",
+        "tinfoil": "^1.1.3"
     },
     "directories": {
         "doc": "docs"

package/src/backends/BaseStorage.js

@@ -20,7 +20,7 @@
  *   getTree()      → string
  */
 /** @import { ExportRecord, ListResult, SearchResult, StorageMetadata } from '../types.js' */
-import { parseBullets, extractTitles, countBullets } from '../bullets/index.js';
+import { parseBullets, extractTitles, countBullets, normalizeFactText } from '../bullets/index.js';
 
 export class BaseStorage {
 
@@ -42,7 +42,41 @@ export class BaseStorage {
      * @returns {Promise<string | null>}
      */
     async read(path) {
-        return this._readRaw(path);
+        const requestedPath = this._normalizeRequestedPath(path);
+        if (!requestedPath) return null;
+
+        const exact = await this._readRaw(requestedPath);
+        if (exact !== null) {
+            return exact;
+        }
+
+        const resolvedPath = await this._resolveReadablePath(requestedPath);
+        if (!resolvedPath || resolvedPath === requestedPath) {
+            return null;
+        }
+
+        return this._readRaw(resolvedPath);
+    }
+
+    /**
+     * Resolve a user/model-supplied path to the canonical readable path.
+     *
+     * Returns the exact stored path when possible, or a normalized fallback
+     * match when the requested path is only approximately correct.
+     *
+     * @param {string} path
+     * @returns {Promise<string | null>}
+     */
+    async resolvePath(path) {
+        const requestedPath = this._normalizeRequestedPath(path);
+        if (!requestedPath) return null;
+
+        const exact = await this._readRaw(requestedPath);
+        if (exact !== null) {
+            return requestedPath;
+        }
+
+        return this._resolveReadablePath(requestedPath);
     }
 
     /**
@@ -135,7 +169,10 @@ export class BaseStorage {
     /** Override for efficient path listing. Default uses exportAll(). */
     async _listAllPaths() {
         const all = await this.exportAll();
-        return all.map(r => r.path);
+        return all
+            .filter((record) => typeof record?.path === 'string')
+            .filter((record) => this._isInternalPath(record.path) || typeof record?.content === 'string')
+            .map((record) => record.path);
     }
 
     _parentPath(filePath) {
@@ -143,6 +180,113 @@ export class BaseStorage {
         return lastSlash === -1 ? '' : filePath.slice(0, lastSlash);
     }
 
+    _basenamePath(filePath) {
+        const normalized = this._normalizeRequestedPath(filePath);
+        if (!normalized) return '';
+        const lastSlash = normalized.lastIndexOf('/');
+        return lastSlash === -1 ? normalized : normalized.slice(lastSlash + 1);
+    }
+
+    _normalizeRequestedPath(path) {
+        return String(path || '')
+            .trim()
+            .replace(/\\/g, '/')
+            .replace(/^\.\//, '')
+            .replace(/^\/+/, '')
+            .replace(/\/+/g, '/');
+    }
+
+    _normalizeLookupKey(path, { stripExtension = false } = {}) {
+        let normalized = this._normalizeRequestedPath(path);
+        if (!normalized) return '';
+
+        if (stripExtension) {
+            normalized = normalized.replace(/\.md$/i, '');
+        }
+
+        if (typeof normalized.normalize === 'function') {
+            normalized = normalized.normalize('NFKD').replace(/[\u0300-\u036f]/g, '');
+        }
+
+        return normalizeFactText(normalized.replace(/[\/_]/g, ' '));
+    }
+
+    async _listReadablePaths() {
+        const all = await this.exportAll();
+        return all
+            .filter((record) => typeof record?.path === 'string')
+            .filter((record) => !this._isInternalPath(record.path))
+            .filter((record) => typeof record?.content === 'string')
+            .map((record) => record.path);
+    }
+
+    async _resolveReadablePath(path) {
+        const requestedPath = this._normalizeRequestedPath(path);
+        if (!requestedPath) return null;
+
+        const readablePaths = await this._listReadablePaths();
+        if (readablePaths.length === 0) return null;
+
+        const fullKey = this._normalizeLookupKey(requestedPath);
+        const extlessKey = this._normalizeLookupKey(requestedPath, { stripExtension: true });
+
+        const fullMatches = readablePaths.filter((candidate) => this._normalizeLookupKey(candidate) === fullKey);
+        if (fullMatches.length > 0) {
+            return this._choosePreferredPath(fullMatches, requestedPath);
+        }
+
+        const extlessMatches = readablePaths.filter((candidate) => this._normalizeLookupKey(candidate, { stripExtension: true }) === extlessKey);
+        if (extlessMatches.length > 0) {
+            return this._choosePreferredPath(extlessMatches, requestedPath);
+        }
+
+        const basenameKey = this._normalizeLookupKey(this._basenamePath(requestedPath), { stripExtension: true });
+        if (!basenameKey) return null;
+
+        const basenameMatches = readablePaths.filter((candidate) => (
+            this._normalizeLookupKey(this._basenamePath(candidate), { stripExtension: true }) === basenameKey
+        ));
+        if (basenameMatches.length > 0) {
+            return this._choosePreferredPath(basenameMatches, requestedPath);
+        }
+
+        return null;
+    }
+
+    _choosePreferredPath(candidates, requestedPath) {
+        if (!Array.isArray(candidates) || candidates.length === 0) return null;
+        if (candidates.length === 1) return candidates[0];
+
+        const requestedParent = this._normalizeLookupKey(this._parentPath(requestedPath));
+        const requestedBase = this._normalizeLookupKey(this._basenamePath(requestedPath), { stripExtension: true });
+
+        return [...candidates]
+            .sort((left, right) => {
+                const leftScore = this._pathMatchScore(left, requestedParent, requestedBase);
+                const rightScore = this._pathMatchScore(right, requestedParent, requestedBase);
+                if (leftScore !== rightScore) return rightScore - leftScore;
+                if (left.length !== right.length) return left.length - right.length;
+                return left.localeCompare(right);
+            })[0];
+    }
+
+    _pathMatchScore(candidate, requestedParent, requestedBase) {
+        let score = 0;
+        if (requestedParent) {
+            if (this._normalizeLookupKey(this._parentPath(candidate)) === requestedParent) {
+                score += 4;
+            }
+        } else if (!this._parentPath(candidate)) {
+            score += 1;
+        }
+
+        if (requestedBase && this._normalizeLookupKey(this._basenamePath(candidate), { stripExtension: true }) === requestedBase) {
+            score += 2;
+        }
+
+        return score;
+    }
+
     /** Generate a one-line summary of file content for the index. */
     _generateOneLiner(content) {
         if (!content) return '';

package/src/backends/indexeddb.js

@@ -45,6 +45,9 @@ class IndexedDBStorage extends BaseStorage {
                 try { await this._bootstrap(); } catch (err) {
                     console.warn('[IndexedDBStorage] Init error:', err);
                 }
+                try { await this.rebuildTree(); } catch (err) {
+                    console.warn('[IndexedDBStorage] Tree rebuild error:', err);
+                }
                 resolve(/** @type {IDBDatabase} */ (this.db));
             };
 
@@ -100,9 +103,9 @@ class IndexedDBStorage extends BaseStorage {
 
         await /** @type {Promise<void>} */ (new Promise((resolve, reject) => {
             const tx = /** @type {IDBDatabase} */ (this.db).transaction(STORE_NAME, 'readwrite');
-            const request = tx.objectStore(STORE_NAME).put(record);
-            request.onsuccess = () => resolve();
-            request.onerror = () => reject(request.error);
+            tx.objectStore(STORE_NAME).put(record);
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
         }));
     }
 
@@ -116,9 +119,9 @@ class IndexedDBStorage extends BaseStorage {
 
         await /** @type {Promise<void>} */ (new Promise((resolve, reject) => {
             const tx = /** @type {IDBDatabase} */ (this.db).transaction(STORE_NAME, 'readwrite');
-            const request = tx.objectStore(STORE_NAME).delete(path);
-            request.onsuccess = () => resolve();
-            request.onerror = () => reject(request.error);
+            tx.objectStore(STORE_NAME).delete(path);
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
         }));
         await this.rebuildTree();
     }
@@ -153,7 +156,7 @@ class IndexedDBStorage extends BaseStorage {
     /** @returns {Promise<void>} */
     async rebuildTree() {
         await this.init();
-        const all = await this._getAll();
+        const all = this._sanitizeRecords(await this._getAll());
         const files = all
             .filter((r) => !this._isInternalPath(r.path))
             .sort((a, b) => a.path.localeCompare(b.path));
@@ -181,7 +184,7 @@ class IndexedDBStorage extends BaseStorage {
     /** @returns {Promise<ExportRecord[]>} */
     async exportAll() {
         await this.init();
-        return this._getAll();
+        return this._sanitizeRecords(await this._getAll());
     }
 
     // ─── Internal IndexedDB helpers ──────────────────────────────
@@ -203,6 +206,16 @@ class IndexedDBStorage extends BaseStorage {
             request.onerror = () => reject(request.error);
         });
     }
+
+    _sanitizeRecords(records) {
+        return (records || [])
+            .filter((record) => typeof record?.path === 'string' && record.path.trim())
+            .map((record) => ({
+                ...record,
+                path: record.path.trim()
+            }))
+            .filter((record) => this._isInternalPath(record.path) || typeof record?.content === 'string');
+    }
 }
 
 export { IndexedDBStorage };

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/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');