@smyslenny/agent-memory 4.0.0-alpha.1 → 4.1.0-alpha.1

package/dist/mcp/server.js

@@ -89,6 +89,11 @@ function migrateDatabase(db, from, to) {
       v = 5;
       continue;
     }
+    if (v === 5) {
+      migrateV5ToV6(db);
+      v = 6;
+      continue;
+    }
     throw new Error(`Unsupported schema migration path: v${from} \u2192 v${to} (stuck at v${v})`);
   }
 }
@@ -174,6 +179,8 @@ function inferSchemaVersion(db) {
   const hasV4Embeddings = hasEmbeddings && tableHasColumn(db, "embeddings", "provider_id") && tableHasColumn(db, "embeddings", "status") && tableHasColumn(db, "embeddings", "content_hash") && tableHasColumn(db, "embeddings", "id");
   const hasMaintenanceJobs = tableExists(db, "maintenance_jobs");
   const hasFeedbackEvents = tableExists(db, "feedback_events");
+  const hasEmotionTag = tableHasColumn(db, "memories", "emotion_tag");
+  if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings && hasMaintenanceJobs && hasFeedbackEvents && hasEmotionTag) return 6;
   if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings && hasMaintenanceJobs && hasFeedbackEvents) return 5;
   if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings) return 4;
   if (hasAgentScopedPaths && hasAgentScopedLinks && hasEmbeddings) return 3;
@@ -200,6 +207,9 @@ function ensureIndexes(db) {
   if (tableExists(db, "maintenance_jobs")) {
     db.exec("CREATE INDEX IF NOT EXISTS idx_maintenance_jobs_phase_status ON maintenance_jobs(phase, status, started_at DESC);");
   }
+  if (tableHasColumn(db, "memories", "emotion_tag")) {
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memories_emotion_tag ON memories(emotion_tag) WHERE emotion_tag IS NOT NULL;");
+  }
   if (tableExists(db, "feedback_events")) {
     db.exec("CREATE INDEX IF NOT EXISTS idx_feedback_events_memory ON feedback_events(memory_id, created_at DESC);");
     if (tableHasColumn(db, "feedback_events", "agent_id") && tableHasColumn(db, "feedback_events", "source")) {
@@ -333,11 +343,30 @@ function migrateV4ToV5(db) {
     throw e;
   }
 }
+function migrateV5ToV6(db) {
+  if (tableHasColumn(db, "memories", "emotion_tag")) {
+    db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('version', ?)").run(String(6));
+    return;
+  }
+  try {
+    db.exec("BEGIN");
+    db.exec("ALTER TABLE memories ADD COLUMN emotion_tag TEXT;");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memories_emotion_tag ON memories(emotion_tag) WHERE emotion_tag IS NOT NULL;");
+    db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('version', ?)").run(String(6));
+    db.exec("COMMIT");
+  } catch (e) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {
+    }
+    throw e;
+  }
+}
 var SCHEMA_VERSION, SCHEMA_SQL;
 var init_db = __esm({
   "src/core/db.ts"() {
     "use strict";
-    SCHEMA_VERSION = 5;
+    SCHEMA_VERSION = 6;
     SCHEMA_SQL = `
 -- Memory entries
 CREATE TABLE IF NOT EXISTS memories (
@@ -355,6 +384,7 @@ CREATE TABLE IF NOT EXISTS memories (
   source        TEXT,
   agent_id      TEXT NOT NULL DEFAULT 'default',
   hash          TEXT,
+  emotion_tag   TEXT,
   UNIQUE(hash, agent_id)
 );
 
@@ -934,8 +964,8 @@ function createMemory(db, input) {
   const timestamp = now();
   db.prepare(
     `INSERT INTO memories (id, content, type, priority, emotion_val, vitality, stability,
-     access_count, created_at, updated_at, source, agent_id, hash)
-     VALUES (?, ?, ?, ?, ?, 1.0, ?, 0, ?, ?, ?, ?, ?)`
+     access_count, created_at, updated_at, source, agent_id, hash, emotion_tag)
+     VALUES (?, ?, ?, ?, ?, 1.0, ?, 0, ?, ?, ?, ?, ?, ?)`
   ).run(
     id,
     input.content,
@@ -947,7 +977,8 @@ function createMemory(db, input) {
     timestamp,
     input.source ?? null,
     agentId,
-    hash2
+    hash2,
+    input.emotion_tag ?? null
   );
   db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)").run(id, tokenizeForIndex(input.content));
   markEmbeddingDirtyIfNeeded(db, id, hash2, resolveEmbeddingProviderId(input.embedding_provider_id));
@@ -991,6 +1022,10 @@ function updateMemory(db, id, input) {
     fields.push("source = ?");
     values.push(input.source);
   }
+  if (input.emotion_tag !== void 0) {
+    fields.push("emotion_tag = ?");
+    values.push(input.emotion_tag);
+  }
   fields.push("updated_at = ?");
   values.push(now());
   values.push(id);
@@ -1032,6 +1067,10 @@ function listMemories(db, opts) {
     conditions.push("vitality >= ?");
     params.push(opts.min_vitality);
   }
+  if (opts?.emotion_tag) {
+    conditions.push("emotion_tag = ?");
+    params.push(opts.emotion_tag);
+  }
   const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
   const limit = opts?.limit ?? 100;
   const offset = opts?.offset ?? 0;
@@ -14901,8 +14940,68 @@ function getPathsByPrefix(db, prefix, agent_id = "default") {
 
 // src/sleep/boot.ts
 init_memory();
+function formatRelativeDate(isoDate) {
+  const diffMs = Date.now() - new Date(isoDate).getTime();
+  const diffDays = Math.floor(diffMs / 864e5);
+  if (diffDays <= 0) return "\u4ECA\u5929";
+  if (diffDays === 1) return "\u6628\u5929";
+  if (diffDays <= 7) return `${diffDays}\u5929\u524D`;
+  return isoDate.slice(0, 10);
+}
+function loadWarmBootLayers(db, agentId) {
+  const identity = listMemories(db, { agent_id: agentId, type: "identity", limit: 50 });
+  const emotion = listMemories(db, { agent_id: agentId, type: "emotion", limit: 5 });
+  const event = listMemories(db, { agent_id: agentId, type: "event", limit: 7 });
+  const knowledge = listMemories(db, {
+    agent_id: agentId,
+    type: "knowledge",
+    min_vitality: 0.5,
+    limit: 10
+  });
+  return { identity, emotion, event, knowledge };
+}
+function formatNarrativeBoot(layers, agentName) {
+  const lines = [];
+  lines.push(`# ${agentName}\u7684\u56DE\u5FC6`);
+  lines.push("");
+  if (layers.identity.length > 0) {
+    lines.push("## \u6211\u662F\u8C01");
+    for (const mem of layers.identity) {
+      lines.push(`- ${mem.content.split("\n")[0].slice(0, 200)}`);
+    }
+    lines.push("");
+  }
+  if (layers.emotion.length > 0) {
+    lines.push("## \u6700\u8FD1\u7684\u5FC3\u60C5");
+    for (const mem of layers.emotion) {
+      const tag = mem.emotion_tag;
+      const time3 = formatRelativeDate(mem.updated_at);
+      const tagStr = tag ? `${tag}, ${time3}` : time3;
+      lines.push(`- ${mem.content.split("\n")[0].slice(0, 200)} (${tagStr})`);
+    }
+    lines.push("");
+  }
+  if (layers.event.length > 0) {
+    lines.push("## \u6700\u8FD1\u53D1\u751F\u7684\u4E8B");
+    for (const mem of layers.event) {
+      const time3 = formatRelativeDate(mem.updated_at);
+      lines.push(`- ${mem.content.split("\n")[0].slice(0, 200)} (${time3})`);
+    }
+    lines.push("");
+  }
+  if (layers.knowledge.length > 0) {
+    lines.push("## \u8FD8\u8BB0\u5F97\u7684\u77E5\u8BC6");
+    for (const mem of layers.knowledge) {
+      lines.push(`- ${mem.content.split("\n")[0].slice(0, 200)}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
 function boot(db, opts) {
   const agentId = opts?.agent_id ?? "default";
+  const format = opts?.format ?? "json";
+  const agentName = opts?.agent_name ?? "Agent";
   const corePaths = opts?.corePaths ?? [
     "core://agent",
     "core://user",
@@ -14946,10 +15045,16 @@ function boot(db, opts) {
       }
     }
   }
-  return {
+  const result = {
     identityMemories: [...memories.values()],
     bootPaths
   };
+  if (format === "narrative") {
+    const layers = loadWarmBootLayers(db, agentId);
+    result.layers = layers;
+    result.narrative = formatNarrativeBoot(layers, agentName);
+  }
+  return result;
 }
 
 // src/sleep/sync.ts
@@ -15550,7 +15655,8 @@ async function syncOne(db, input) {
     agent_id: input.agent_id,
     uri: input.uri,
     provider: input.provider,
-    conservative: input.conservative
+    conservative: input.conservative,
+    emotion_tag: input.emotion_tag
   };
   const guardResult = await guard(db, memInput);
   switch (guardResult.action) {
@@ -15830,21 +15936,26 @@ async function rememberMemory(db, input) {
     source: input.source,
     agent_id: input.agent_id,
     provider: input.provider,
-    conservative: input.conservative
+    conservative: input.conservative,
+    emotion_tag: input.emotion_tag
   });
 }
 
 // src/app/recall.ts
 async function recallMemory(db, input) {
-  return recallMemories(db, input.query, {
+  const result = await recallMemories(db, input.query, {
     agent_id: input.agent_id,
-    limit: input.limit,
+    limit: input.emotion_tag ? (input.limit ?? 10) * 3 : input.limit,
     min_vitality: input.min_vitality,
     lexicalLimit: input.lexicalLimit,
     vectorLimit: input.vectorLimit,
     provider: input.provider,
     recordAccess: input.recordAccess
   });
+  if (input.emotion_tag) {
+    result.results = result.results.filter((r) => r.memory.emotion_tag === input.emotion_tag).slice(0, input.limit ?? 10);
+  }
+  return result;
 }
 
 // src/app/surface.ts
@@ -16093,7 +16204,7 @@ async function surfaceMemories(db, input) {
       signals.set(memory.id, { memory });
     }
   }
-  const results = [...signals.values()].map((signal) => signal.memory).filter((memory) => memory.vitality >= minVitality).filter((memory) => input.types?.length ? input.types.includes(memory.type) : true).map((memory) => {
+  const results = [...signals.values()].map((signal) => signal.memory).filter((memory) => memory.vitality >= minVitality).filter((memory) => input.types?.length ? input.types.includes(memory.type) : true).filter((memory) => input.emotion_tag ? memory.emotion_tag === input.emotion_tag : true).map((memory) => {
     const signal = signals.get(memory.id) ?? { memory };
     const memoryTokens = new Set(tokenize(memory.content));
     const lexicalOverlap = overlapScore2(memoryTokens, queryTokens);
@@ -16763,10 +16874,11 @@ function createMcpServer(dbPath, agentId) {
       uri: external_exports.string().optional().describe("URI path (e.g. core://user/name, emotion://2026-02-20/love)"),
       emotion_val: external_exports.number().min(-1).max(1).default(0).describe("Emotional valence (-1 negative to +1 positive)"),
       source: external_exports.string().optional().describe("Source annotation (e.g. session ID, date)"),
-      agent_id: external_exports.string().optional().describe("Override agent scope (defaults to current agent)")
+      agent_id: external_exports.string().optional().describe("Override agent scope (defaults to current agent)"),
+      emotion_tag: external_exports.string().optional().describe("Emotion label for emotion-type memories (e.g. \u5B89\u5FC3, \u5F00\u5FC3, \u62C5\u5FC3)")
     },
-    async ({ content, type, uri, emotion_val, source, agent_id }) => {
-      const result = await rememberMemory(db, { content, type, uri, emotion_val, source, agent_id: agent_id ?? aid });
+    async ({ content, type, uri, emotion_val, source, agent_id, emotion_tag }) => {
+      const result = await rememberMemory(db, { content, type, uri, emotion_val, source, agent_id: agent_id ?? aid, emotion_tag });
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
@@ -16776,10 +16888,11 @@ function createMcpServer(dbPath, agentId) {
     {
       query: external_exports.string().describe("Search query (natural language)"),
       limit: external_exports.number().default(10).describe("Max results to return"),
-      agent_id: external_exports.string().optional().describe("Override agent scope (defaults to current agent)")
+      agent_id: external_exports.string().optional().describe("Override agent scope (defaults to current agent)"),
+      emotion_tag: external_exports.string().optional().describe("Filter results by emotion tag (e.g. \u5B89\u5FC3, \u5F00\u5FC3)")
     },
-    async ({ query, limit, agent_id }) => {
-      const result = await recallMemory(db, { query, limit, agent_id: agent_id ?? aid });
+    async ({ query, limit, agent_id, emotion_tag }) => {
+      const result = await recallMemory(db, { query, limit, agent_id: agent_id ?? aid, emotion_tag });
       return { content: [{ type: "text", text: JSON.stringify(formatRecallPayload(result), null, 2) }] };
     }
   );
@@ -16827,19 +16940,20 @@ function createMcpServer(dbPath, agentId) {
     "boot",
     "Load startup memories. Default output is narrative markdown; pass format=json for legacy output.",
     {
-      format: external_exports.enum(["narrative", "json"]).default("narrative").optional()
+      format: external_exports.enum(["narrative", "json"]).default("narrative").optional(),
+      agent_name: external_exports.string().optional().describe("Agent name for narrative header (default: Agent)")
     },
-    async ({ format }) => {
+    async ({ format, agent_name }) => {
       const outputFormat = format ?? "narrative";
-      const base = boot(db, { agent_id: aid });
+      const result = boot(db, { agent_id: aid, format: outputFormat, agent_name: agent_name ?? void 0 });
       if (outputFormat === "json") {
         return {
           content: [{
             type: "text",
             text: JSON.stringify({
-              count: base.identityMemories.length,
-              bootPaths: base.bootPaths,
-              memories: base.identityMemories.map((memory) => ({
+              count: result.identityMemories.length,
+              bootPaths: result.bootPaths,
+              memories: result.identityMemories.map((memory) => ({
                 id: memory.id,
                 content: memory.content,
                 type: memory.type,
@@ -16849,12 +16963,15 @@ function createMcpServer(dbPath, agentId) {
           }]
         };
       }
+      if (result.narrative) {
+        return { content: [{ type: "text", text: result.narrative }] };
+      }
       const identity = listMemories(db, { agent_id: aid, type: "identity", limit: 12 });
       const emotion = listMemories(db, { agent_id: aid, type: "emotion", min_vitality: 0.1, limit: 12 }).sort((a, b) => b.vitality - a.vitality);
       const knowledge = listMemories(db, { agent_id: aid, type: "knowledge", min_vitality: 0.1, limit: 16 }).sort((a, b) => b.vitality - a.vitality);
       const event = listMemories(db, { agent_id: aid, type: "event", min_vitality: 0, limit: 24 }).sort((a, b) => b.vitality - a.vitality);
       const stats = countMemories(db, aid);
-      return { content: [{ type: "text", text: formatWarmBootNarrative(identity.length > 0 ? identity : base.identityMemories, emotion, knowledge, event, stats) }] };
+      return { content: [{ type: "text", text: formatWarmBootNarrative(identity.length > 0 ? identity : result.identityMemories, emotion, knowledge, event, stats) }] };
     }
   );
   server.tool(