@openanonymity/nanomem 0.1.0 → 0.1.2

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

@@ -1,5 +1,13 @@
 # @openanonymity/nanomem
 
+```
+ __   __     ______     __   __     ______     __    __     ______     __    __
+/\ "-.\ \   /\  __ \   /\ "-.\ \   /\  __ \   /\ "-./  \   /\  ___\   /\ "-./  \
+\ \ \-.  \  \ \  __ \  \ \ \-.  \  \ \ \/\ \  \ \ \-./\ \  \ \  __\   \ \ \-./\ \
+ \ \_\\"\_\  \ \_\ \_\  \ \_\\"\_\  \ \_____\  \ \_\ \ \_\  \ \_____\  \ \_\ \ \_\
+  \/_/ \/_/   \/_/\/_/   \/_/ \/_/   \/_____/   \/_/  \/_/   \/_____/   \/_/  \/_/
+```
+
 **Personal memory you own, in files you can actually read.**
 
 `nanomem` turns chats, notes, and exports into a markdown memory system that an LLM can update and retrieve as facts evolve over time. The result stays inspectable, portable, and user-owned instead of disappearing into hidden vector state.
@@ -23,7 +31,8 @@ Retrieval is only one part of memory. `nanomem` is built for the maintenance lay
 - **Evolving memory state.** Keep facts current as they change over time instead of treating memory as an append-only log.
 - **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.
+- **Import your existing history.** Start from ChatGPT exports, Claude 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 +41,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 +52,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 +74,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 +96,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 +123,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
@@ -109,16 +145,13 @@ Memory is stored as markdown with structured metadata:
 ```md
 # Memory: Work
 
-## Working
-### Current context
+## Working memory (current context subject to change)
 - Preparing for a product launch next month | topic=work | tier=working | status=active | source=user_statement | confidence=high | updated_at=2026-04-07 | review_at=2026-04-20
 
-## Long-Term
-### Stable facts
+## Long-term memory (stable facts that are unlikely to change)
 - Leads the backend team at Acme | topic=work | tier=long_term | status=active | source=user_statement | confidence=high | updated_at=2026-04-07
 
-## History
-### No longer current
+## History (no longer current)
 - Previously lived in New York | topic=personal | tier=history | status=superseded | source=user_statement | confidence=high | updated_at=2024-06-01
 ```
 
@@ -132,7 +165,7 @@ import { createMemoryBank } from '@openanonymity/nanomem';
 const memory = createMemoryBank({
   llm: { apiKey: 'sk-...', model: 'gpt-5.4-mini' },
   storage: 'filesystem',
-  storagePath: './memory'
+  storagePath: '~/nanomem'
 });
 
 await memory.init();
@@ -144,17 +177,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.
@@ -163,7 +204,8 @@ For terminal use, `--render` will format markdown-heavy output like `read` and `
 
 `nanomem import` supports:
 
-- ChatGPT exports
+- ChatGPT exports (`conversations.json` from "Export data")
+- Claude exports (`conversations.json` from "Export data")
 - [OA Chat](https://chat.openanonymity.ai) exports
 - markdown notes
 - recursive markdown directory imports
@@ -173,7 +215,9 @@ For terminal use, `--render` will format markdown-heavy output like `read` and `
 Import can operate in both conversation-oriented and document-oriented modes, depending on the source or explicit flags.
 
 ```bash
-nanomem import conversations.json              # conversation mode
+nanomem import conversations.json              # auto-detects ChatGPT or Claude format
+nanomem import conversations.json --format claude   # explicit Claude format
+nanomem import conversations.json --format chatgpt  # explicit ChatGPT format
 nanomem import ./notes/                        # document mode (auto for directories)
 nanomem import my-notes.md --format markdown   # document mode (explicit)
 ```
@@ -189,6 +233,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.2",
     "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 };