@openanonymity/nanomem 0.1.0 → 0.1.1

package/src/cli/commands.js

@@ -161,10 +161,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, 'conversation', mem, { showProgress, spinnerHolder, status: 'added', showDiff: true });
+    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, 'update', mem, { showProgress, spinnerHolder, status: 'updated', showDiff: true });
 }
 
 async function ingestConversations(conversations, extractionMode, mem, { showProgress, spinnerHolder, status, showDiff = false }) {
@@ -180,7 +188,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 +267,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,7 +97,7 @@ 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) {
@@ -107,6 +109,7 @@ async function main() {
             delete_memory:   'cleaning up',
             read_file:       'reading',
             list_files:      'scanning',
+            delete_bullet:   'deleting',
         };
         memOpts.onToolCall = (name) => {
             const label = TOOL_LABELS[name] || name;

package/src/engine/deleter.js

@@ -0,0 +1,187 @@
+/**
+ * MemoryDeleter — targeted bullet deletion via agentic tool-calling.
+ *
+ * Takes a plain-text query (e.g. "my job at Acme") and uses the LLM to find
+ * and delete only the matching bullets. Mirrors the retriever pattern but
+ * writes instead of reads.
+ *
+ * Two modes:
+ *   default — LLM searches the index for relevant files, reads and deletes.
+ *   deep    — all files are enumerated upfront; LLM reads every one.
+ */
+/** @import { LLMClient, StorageBackend } from '../types.js' */
+import { runAgenticToolLoop } from './toolLoop.js';
+import { createDeletionExecutors } from './executors.js';
+import { resolvePromptSet } from '../prompt_sets/index.js';
+
+/** Tools used in default (index-guided) delete mode. */
+const DELETION_TOOLS = [
+    {
+        type: 'function',
+        function: {
+            name: 'list_directory',
+            description: 'List all files and subdirectories in a directory.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    dir_path: { type: 'string', description: 'Directory path (e.g. "health", "personal", "work"). Use empty string for root.' }
+                },
+                required: ['dir_path']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'retrieve_file',
+            description: 'Search memory files by keyword. Returns paths of files whose content or path matches the query.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'Keyword to search for in file contents.' }
+                },
+                required: ['query']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'read_file',
+            description: 'Read the full content of a memory file by its path.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'File path to read (e.g. personal/about.md)' }
+                },
+                required: ['path']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'delete_bullet',
+            description: 'PERMANENTLY delete a specific bullet from a memory file. Use ONLY for bullets that are about the target subject. This cannot be undone. Pass the EXACT bullet text as it appears in the file, including all | metadata.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'File path containing the bullet (e.g. personal/about.md)' },
+                    bullet_text: { type: 'string', description: 'The EXACT text of the bullet to delete, as it appears in the file, including all | metadata.' }
+                },
+                required: ['path', 'bullet_text']
+            }
+        }
+    }
+];
+
+/** Tools used in deep delete mode — no discovery tools needed since all paths are listed upfront. */
+const DEEP_DELETION_TOOLS = DELETION_TOOLS.filter(t =>
+    ['read_file', 'delete_bullet'].includes(t.function.name)
+);
+
+export class MemoryDeleter {
+    /**
+     * @param {{ backend: StorageBackend, bulletIndex: object, llmClient: LLMClient, model: string, onToolCall?: Function }} options
+     */
+    constructor({ backend, bulletIndex, llmClient, model, onToolCall }) {
+        this._backend = backend;
+        this._bulletIndex = bulletIndex;
+        this._llmClient = llmClient;
+        this._model = model;
+        this._onToolCall = onToolCall || null;
+    }
+
+    /**
+     * Delete memory content matching the given query.
+     *
+     * @param {string} query  Plain-text description of what to delete.
+     * @param {{ deep?: boolean, mode?: string }} [options]
+     * @returns {Promise<{ status: string, deleteCalls: number, writes: Array }>}
+     */
+    async deleteForQuery(query, options = {}) {
+        if (!query || !query.trim()) {
+            return { status: 'skipped', deleteCalls: 0, writes: [] };
+        }
+
+        const isDocument = options.mode === 'document';
+
+        return options.deep
+            ? this._deepDelete(query, isDocument)
+            : this._standardDelete(query, isDocument);
+    }
+
+    async _standardDelete(query, isDocument) {
+        await this._backend.init();
+        const index = await this._backend.getTree() || '';
+
+        const promptKey = isDocument ? 'document_delete' : 'delete';
+        const { ingestionPrompt } = resolvePromptSet(promptKey);
+        const systemPrompt = ingestionPrompt
+            .replace('{QUERY}', query)
+            .replace('{INDEX}', index);
+
+        return this._runDeletionLoop(query, systemPrompt, DELETION_TOOLS, 8);
+    }
+
+    async _deepDelete(query, isDocument) {
+        await this._backend.init();
+
+        const allFiles = await this._backend.exportAll();
+        const paths = allFiles
+            .map(f => f.path)
+            .filter(p => !p.endsWith('_tree.md'))
+            .sort();
+
+        if (paths.length === 0) {
+            return { status: 'skipped', deleteCalls: 0, writes: [] };
+        }
+
+        const fileList = paths.map(p => `- ${p}`).join('\n');
+
+        const promptKey = isDocument ? 'document_deep_delete' : 'deep_delete';
+        const { ingestionPrompt } = resolvePromptSet(promptKey);
+        const systemPrompt = ingestionPrompt
+            .replace('{QUERY}', query)
+            .replace('{FILE_LIST}', fileList);
+
+        // Each file needs a read + potentially multiple deletes; allow enough iterations.
+        const maxIterations = Math.max(30, paths.length * 3);
+
+        return this._runDeletionLoop(query, systemPrompt, DEEP_DELETION_TOOLS, maxIterations);
+    }
+
+    async _runDeletionLoop(query, systemPrompt, tools, maxIterations) {
+        const writes = [];
+        const onToolCall = this._onToolCall;
+
+        const toolExecutors = createDeletionExecutors(this._backend, {
+            refreshIndex: (path) => this._bulletIndex.refreshPath(path),
+            onWrite: (path, before, after) => writes.push({ path, before, after }),
+        });
+
+        try {
+            await runAgenticToolLoop({
+                llmClient: this._llmClient,
+                model: this._model,
+                tools,
+                toolExecutors,
+                messages: [
+                    { role: 'system', content: systemPrompt },
+                    { role: 'user', content: query }
+                ],
+                maxIterations,
+                maxOutputTokens: 2000,
+                temperature: 0,
+                onToolCall: (name, args, result) => {
+                    onToolCall?.(name, args, result);
+                }
+            });
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { status: 'error', deleteCalls: 0, writes: [], error: message };
+        }
+
+        return { status: 'processed', deleteCalls: writes.length, writes };
+    }
+}