@gamaze/hicortex 0.3.15 → 0.3.17

package/dist/consolidate.js

@@ -307,9 +307,10 @@ async function stageLinks(db, memories, embedFn, dryRun) {
             for (const neighbor of neighbors) {
                 const similarity = 1.0 - neighbor.distance;
                 if (similarity > CONSOLIDATE_LINK_THRESHOLD) {
+                    const relationship = classifyRelationship(mem, neighbor, similarity);
                     if (!dryRun) {
                         try {
-                            storage.addLink(db, mem.id, neighbor.id, "relates_to", similarity);
+                            storage.addLink(db, mem.id, neighbor.id, relationship, similarity);
                             autoLinked++;
                         }
                         catch {
@@ -328,6 +329,29 @@ async function stageLinks(db, memories, embedFn, dryRun) {
     }
     return { auto_linked: autoLinked, failed };
 }
+/**
+ * Classify the relationship between two memories based on type, temporal ordering, and similarity.
+ */
+function classifyRelationship(source, target, similarity) {
+    // Lesson derived from episode(s)
+    if (source.memory_type === "lesson" && target.memory_type === "episode")
+        return "derives";
+    if (target.memory_type === "lesson" && source.memory_type === "episode")
+        return "derives";
+    // Same type + very high similarity + different timestamps → newer updates older
+    if (source.memory_type === target.memory_type &&
+        similarity > 0.8 &&
+        source.created_at !== target.created_at) {
+        return "updates";
+    }
+    // Same project, moderate similarity → extends
+    if (source.project && target.project &&
+        source.project === target.project &&
+        similarity > 0.55 && similarity <= 0.8) {
+        return "extends";
+    }
+    return "relates_to";
+}
 // ---------------------------------------------------------------------------
 // Stage 4: Decay & Prune
 // ---------------------------------------------------------------------------

package/dist/db.js

@@ -103,7 +103,8 @@ CREATE TABLE IF NOT EXISTS memories (
     source_session TEXT,
     project TEXT,
     privacy TEXT DEFAULT 'WORK',
-    memory_type TEXT DEFAULT 'episode'
+    memory_type TEXT DEFAULT 'episode',
+    updated_at TIMESTAMP
 );
 
 CREATE TABLE IF NOT EXISTS memory_links (
@@ -184,6 +185,9 @@ function migrate(db) {
         db.exec("UPDATE memories SET ingested_at = created_at");
         db.exec("CREATE INDEX IF NOT EXISTS idx_memories_ingested ON memories(ingested_at)");
     }
+    if (!colNames.has("updated_at")) {
+        db.exec("ALTER TABLE memories ADD COLUMN updated_at TIMESTAMP");
+    }
 }
 /**
  * Return database statistics.

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/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/dist/storage.js

@@ -77,21 +77,22 @@ const ALLOWED_UPDATE_FIELDS = new Set([
     "project",
     "privacy",
     "memory_type",
+    "updated_at",
 ]);
 /**
  * Update specific fields on a memory.
  */
 function updateMemory(db, memoryId, fields) {
-    const keys = Object.keys(fields);
-    if (keys.length === 0)
-        return;
+    // Auto-set updated_at timestamp
+    const fieldsWithTimestamp = { ...fields, updated_at: new Date().toISOString() };
+    const keys = Object.keys(fieldsWithTimestamp);
     for (const k of keys) {
         if (!ALLOWED_UPDATE_FIELDS.has(k)) {
             throw new Error(`Cannot update field: ${k}`);
         }
     }
     const setClause = keys.map((k) => `"${k}" = ?`).join(", ");
-    const values = keys.map((k) => fields[k]);
+    const values = keys.map((k) => fieldsWithTimestamp[k]);
     values.push(memoryId);
     db.prepare(`UPDATE memories SET ${setClause} WHERE id = ?`).run(...values);
 }

package/dist/types.d.ts

@@ -16,6 +16,7 @@ export interface Memory {
     project: string | null;
     privacy: "PUBLIC" | "WORK" | "PERSONAL" | "SENSITIVE";
     memory_type: "episode" | "lesson" | "fact" | "decision";
+    updated_at: string | null;
 }
 /** A link between two memories. */
 export interface MemoryLink {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.3.15",
+  "version": "0.3.17",
   "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": {