@gamaze/hicortex 0.3.14 → 0.3.16

package/dist/index.js

@@ -352,11 +352,88 @@ exports.default = {
                 }
             },
         }), { name: "hicortex_lessons" });
+        api.registerTool((_ctx) => ({
+            name: "hicortex_update",
+            description: "Update an existing memory. Use after searching to fix incorrect information. If content changes, the embedding is re-computed.",
+            parameters: {
+                type: "object",
+                properties: {
+                    id: { type: "string", description: "Memory ID (from search results, first 8 chars or full UUID)" },
+                    content: { type: "string", description: "New content text" },
+                    project: { type: "string", description: "New project name" },
+                    memory_type: { type: "string", enum: ["episode", "lesson", "fact", "decision"], description: "New memory type" },
+                },
+                required: ["id"],
+            },
+            async execute(_callId, args, _ctx) {
+                if (!db)
+                    return { error: "Hicortex not initialized" };
+                try {
+                    const fullId = resolveMemoryId(db, args.id);
+                    if (!fullId)
+                        return { error: `Memory not found: ${args.id}` };
+                    const fields = {};
+                    if (args.content !== undefined)
+                        fields.content = args.content;
+                    if (args.project !== undefined)
+                        fields.project = args.project;
+                    if (args.memory_type !== undefined)
+                        fields.memory_type = args.memory_type;
+                    if (Object.keys(fields).length === 0)
+                        return { error: "No fields to update" };
+                    storage.updateMemory(db, fullId, fields);
+                    if (args.content !== undefined) {
+                        const embedding = await (0, embedder_js_1.embed)(args.content);
+                        db.prepare("DELETE FROM memory_vectors WHERE id = ?").run(fullId);
+                        db.prepare("INSERT INTO memory_vectors (id, embedding) VALUES (?, ?)").run(fullId, Buffer.from(embedding.buffer));
+                    }
+                    return { content: [{ type: "text", text: `Memory updated (id: ${fullId.slice(0, 8)})` }] };
+                }
+                catch (err) {
+                    return { error: `Update failed: ${err instanceof Error ? err.message : String(err)}` };
+                }
+            },
+        }), { name: "hicortex_update" });
+        api.registerTool((_ctx) => ({
+            name: "hicortex_delete",
+            description: "Permanently delete a memory and its links. Use when a memory is incorrect and should be removed entirely.",
+            parameters: {
+                type: "object",
+                properties: {
+                    id: { type: "string", description: "Memory ID (from search results, first 8 chars or full UUID)" },
+                },
+                required: ["id"],
+            },
+            execute(_callId, args, _ctx) {
+                if (!db)
+                    return { error: "Hicortex not initialized" };
+                try {
+                    const fullId = resolveMemoryId(db, args.id);
+                    if (!fullId)
+                        return { error: `Memory not found: ${args.id}` };
+                    storage.deleteMemory(db, fullId);
+                    return { content: [{ type: "text", text: `Memory deleted (id: ${fullId.slice(0, 8)})` }] };
+                }
+                catch (err) {
+                    return { error: `Delete failed: ${err instanceof Error ? err.message : String(err)}` };
+                }
+            },
+        }), { name: "hicortex_delete" });
     },
 };
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
+function resolveMemoryId(database, idPrefix) {
+    if (idPrefix.length >= 36) {
+        const row = database.prepare("SELECT id FROM memories WHERE id = ?").get(idPrefix);
+        return row?.id ?? null;
+    }
+    const rows = database.prepare("SELECT id FROM memories WHERE id LIKE ?").all(`${idPrefix}%`);
+    if (rows.length === 1)
+        return rows[0].id;
+    return null;
+}
 // ---------------------------------------------------------------------------
 // Auto-configure LLM: resolve config → test connection → persist if new
 // ---------------------------------------------------------------------------
@@ -477,6 +554,8 @@ const HICORTEX_TOOLS = [
     "hicortex_context",
     "hicortex_ingest",
     "hicortex_lessons",
+    "hicortex_update",
+    "hicortex_delete",
 ];
 /**
  * Ensure hicortex tools are in tools.allow so they're visible to agents

package/dist/init.js

@@ -116,23 +116,45 @@ function registerCcMcp(serverUrl) {
         console.log(`  ✓ Registered MCP server via claude CLI`);
     }
     catch (err) {
-        // Fallback: write directly to settings.json if claude CLI not available
+        // Fallback: write directly to ~/.claude.json (where CC reads MCP servers)
         const msg = err instanceof Error ? err.message : String(err);
-        console.log(`  ⚠ claude CLI registration failed (${msg}), writing settings.json directly`);
-        let settings = {};
+        console.log(`  ⚠ claude CLI registration failed (${msg}), writing ~/.claude.json directly`);
+        const claudeJsonPath = (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude.json");
+        let config = {};
         try {
-            settings = JSON.parse((0, node_fs_1.readFileSync)(CC_SETTINGS, "utf-8"));
+            config = JSON.parse((0, node_fs_1.readFileSync)(claudeJsonPath, "utf-8"));
         }
         catch { /* create new */ }
-        if (!settings.mcpServers)
-            settings.mcpServers = {};
-        settings.mcpServers.hicortex = {
+        if (!config.mcpServers)
+            config.mcpServers = {};
+        config.mcpServers.hicortex = {
             type: "sse",
             url: `${serverUrl}/sse`,
         };
+        (0, node_fs_1.writeFileSync)(claudeJsonPath, JSON.stringify(config, null, 2));
+        console.log(`  ✓ Registered MCP server in ${claudeJsonPath}`);
+    }
+    // Add MCP tool permissions to settings.json so users don't get prompted
+    allowHicortexTools();
+}
+function allowHicortexTools() {
+    let settings = {};
+    try {
+        settings = JSON.parse((0, node_fs_1.readFileSync)(CC_SETTINGS, "utf-8"));
+    }
+    catch { /* create new */ }
+    if (!settings.permissions)
+        settings.permissions = {};
+    const perms = settings.permissions;
+    if (!perms.allow)
+        perms.allow = [];
+    const allow = perms.allow;
+    const rule = "mcp__hicortex__*";
+    if (!allow.includes(rule)) {
+        allow.push(rule);
         (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(CC_SETTINGS), { recursive: true });
         (0, node_fs_1.writeFileSync)(CC_SETTINGS, JSON.stringify(settings, null, 2));
-        console.log(`  ✓ Registered MCP server in ${CC_SETTINGS}`);
+        console.log(`  ✓ Added Hicortex tool permissions to ${CC_SETTINGS}`);
     }
 }
 function installCcCommands() {
@@ -587,6 +609,8 @@ async function runInit() {
     if (!d.ccMcpRegistered) {
         registerCcMcp(serverUrl);
     }
+    // Ensure tool permissions are set (also needed for users upgrading from older versions)
+    allowHicortexTools();
     // Install CC commands
     installCcCommands();
     // Inject CLAUDE.md (only if server has a DB we can read)

package/dist/mcp-server.js

@@ -147,6 +147,64 @@ function createMcpServer() {
             return { content: [{ type: "text", text: `Ingest failed: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
         }
     });
+    // -- hicortex_update --
+    server.tool("hicortex_update", "Update an existing memory. Use after searching to fix incorrect information. If content changes, the embedding is re-computed.", {
+        id: zod_1.z.string().describe("Memory ID (from search results, first 8 chars or full UUID)"),
+        content: zod_1.z.string().optional().describe("New content text"),
+        project: zod_1.z.string().optional().describe("New project name"),
+        memory_type: zod_1.z.enum(["episode", "lesson", "fact", "decision"]).optional().describe("New memory type"),
+    }, async ({ id, content, project, memory_type }) => {
+        if (!db)
+            return { content: [{ type: "text", text: "Hicortex not initialized" }], isError: true };
+        try {
+            // Resolve short ID prefix to full ID
+            const fullId = resolveMemoryId(db, id);
+            if (!fullId)
+                return { content: [{ type: "text", text: `Memory not found: ${id}` }], isError: true };
+            const fields = {};
+            if (content !== undefined)
+                fields.content = content;
+            if (project !== undefined)
+                fields.project = project;
+            if (memory_type !== undefined)
+                fields.memory_type = memory_type;
+            if (Object.keys(fields).length === 0) {
+                return { content: [{ type: "text", text: "No fields to update" }], isError: true };
+            }
+            const before = storage.getMemory(db, fullId);
+            storage.updateMemory(db, fullId, fields);
+            // Re-embed if content changed
+            if (content !== undefined) {
+                const embedding = await (0, embedder_js_1.embed)(content);
+                db.prepare("DELETE FROM memory_vectors WHERE id = ?").run(fullId);
+                db.prepare("INSERT INTO memory_vectors (id, embedding) VALUES (?, ?)").run(fullId, Buffer.from(embedding.buffer));
+            }
+            const changed = Object.keys(fields).map(k => `${k}: "${String(before?.[k] ?? "").slice(0, 80)}" → "${String(fields[k]).slice(0, 80)}"`).join(", ");
+            return { content: [{ type: "text", text: `Memory updated (id: ${fullId.slice(0, 8)}). Changed: ${changed}` }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Update failed: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+    // -- hicortex_delete --
+    server.tool("hicortex_delete", "Permanently delete a memory and its links. Use when a memory is incorrect and should be removed entirely.", {
+        id: zod_1.z.string().describe("Memory ID (from search results, first 8 chars or full UUID)"),
+    }, async ({ id }) => {
+        if (!db)
+            return { content: [{ type: "text", text: "Hicortex not initialized" }], isError: true };
+        try {
+            const fullId = resolveMemoryId(db, id);
+            if (!fullId)
+                return { content: [{ type: "text", text: `Memory not found: ${id}` }], isError: true };
+            const memory = storage.getMemory(db, fullId);
+            storage.deleteMemory(db, fullId);
+            const preview = memory?.content?.slice(0, 200) ?? "(unknown)";
+            return { content: [{ type: "text", text: `Memory deleted (id: ${fullId.slice(0, 8)}). Content was: ${preview}` }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Delete failed: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
     // -- hicortex_lessons --
     server.tool("hicortex_lessons", "Get actionable lessons learned from past sessions. Auto-generated insights about mistakes to avoid.", {
         days: zod_1.z.coerce.number().optional().describe("Look back N days (default 7)"),
@@ -378,6 +436,23 @@ async function startServer(options = {}) {
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
+/**
+ * Resolve a short ID prefix (e.g. "a1b2c3d4") to a full memory UUID.
+ */
+function resolveMemoryId(database, idPrefix) {
+    if (idPrefix.length >= 36) {
+        // Full UUID — check existence
+        const row = database.prepare("SELECT id FROM memories WHERE id = ?").get(idPrefix);
+        return row?.id ?? null;
+    }
+    // Short prefix — find matching memory
+    const rows = database.prepare("SELECT id FROM memories WHERE id LIKE ?").all(`${idPrefix}%`);
+    if (rows.length === 1)
+        return rows[0].id;
+    if (rows.length > 1)
+        return null; // Ambiguous
+    return null;
+}
 /**
  * Read ~/.hicortex/config.json (persisted by init with LLM and license config).
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.3.14",
+  "version": "0.3.16",
   "description": "Human-like memory for self-improving AI agents. Automatic capturing, nightly reflection, and cross-agent learning. Works with Claude Code and OpenClaw.",
   "main": "dist/index.js",
   "bin": {