@hiveai/mcp 0.2.11 → 0.2.13

package/dist/server.js

@@ -119,6 +119,7 @@ async function memList(input, ctx) {
 }
 
 // src/tools/mem-save.ts
+import { createHash } from "crypto";
 import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 import path3 from "path";
@@ -130,7 +131,9 @@ import {
 } from "@hiveai/core";
 import { z as z4 } from "zod";
 var MemSaveInputSchema = {
-  type: z4.enum(["convention", "decision", "gotcha", "architecture", "glossary", "attempt"]).describe("Kind of memory being saved. Use 'attempt' for failed approaches (auto-validated)."),
+  type: z4.enum(["convention", "decision", "gotcha", "architecture", "glossary", "attempt", "session_recap"]).describe(
+    "Kind of memory being saved. Use 'attempt' for failed approaches (auto-validated). Use 'session_recap' via mem_session_end instead."
+  ),
   slug: z4.string().min(1).describe("Short human-readable identifier \u2014 becomes part of the filename"),
   body: z4.string().describe("Markdown body of the memory"),
   scope: z4.enum(["personal", "team", "module"]).default("personal").describe("Visibility scope: personal | team | module"),
@@ -140,14 +143,61 @@ var MemSaveInputSchema = {
   author: z4.string().optional().describe("Author handle or email"),
   paths: z4.array(z4.string()).default([]).describe("Anchor paths (file paths this memory references)"),
   symbols: z4.array(z4.string()).default([]).describe("Anchor symbols (function/class names this memory references)"),
-  commit: z4.string().optional().describe("Anchor commit SHA (for staleness detection later)")
+  commit: z4.string().optional().describe("Anchor commit SHA (for staleness detection later)"),
+  topic: z4.string().optional().describe(
+    "Stable key for this memory. If a memory with the same topic already exists in this scope, it is updated in-place (revision_count++). Use for knowledge that evolves over time."
+  )
 };
+function bodyHash(body) {
+  return createHash("sha256").update(body.trim()).digest("hex").slice(0, 12);
+}
 async function memSave(input, ctx) {
   if (!existsSync4(ctx.paths.haiveDir)) {
     throw new Error(
       `No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`
     );
   }
+  const existing = existsSync4(ctx.paths.memoriesDir) ? await loadMemoriesFromDir2(ctx.paths.memoriesDir) : [];
+  const incomingHash = bodyHash(input.body);
+  const hashDuplicate = existing.find(
+    ({ memory }) => bodyHash(memory.body) === incomingHash && memory.frontmatter.scope === input.scope
+  );
+  if (hashDuplicate) {
+    throw new Error(
+      `Duplicate content detected \u2014 identical body already saved as "${hashDuplicate.memory.frontmatter.id}". Use mem_update to modify it, or change the body to add new information.`
+    );
+  }
+  if (input.topic) {
+    const topicMatch = existing.find(
+      ({ memory }) => memory.frontmatter.topic === input.topic && memory.frontmatter.scope === input.scope && (!input.module || memory.frontmatter.module === input.module)
+    );
+    if (topicMatch) {
+      const fm = topicMatch.memory.frontmatter;
+      const newFrontmatter = {
+        ...fm,
+        body: input.body,
+        tags: input.tags.length ? input.tags : fm.tags,
+        revision_count: (fm.revision_count ?? 0) + 1,
+        anchor: {
+          commit: input.commit ?? fm.anchor.commit,
+          paths: input.paths.length ? input.paths : fm.anchor.paths,
+          symbols: input.symbols.length ? input.symbols : fm.anchor.symbols
+        }
+      };
+      await writeFile2(
+        topicMatch.filePath,
+        serializeMemory({ frontmatter: newFrontmatter, body: input.body }),
+        "utf8"
+      );
+      return {
+        id: fm.id,
+        scope: fm.scope,
+        file_path: topicMatch.filePath,
+        action: "updated",
+        revision_count: newFrontmatter.revision_count
+      };
+    }
+  }
   const frontmatter = buildFrontmatter({
     type: input.type,
     slug: input.slug,
@@ -158,7 +208,8 @@ async function memSave(input, ctx) {
     author: input.author,
     paths: input.paths,
     symbols: input.symbols,
-    commit: input.commit
+    commit: input.commit,
+    topic: input.topic
   });
   const file = memoryFilePath(
     ctx.paths,
@@ -171,15 +222,16 @@ async function memSave(input, ctx) {
     throw new Error(`Memory already exists at ${file}`);
   }
   let warning;
-  if (existsSync4(ctx.paths.memoriesDir)) {
-    const existing = await loadMemoriesFromDir2(ctx.paths.memoriesDir);
+  let similar_found;
+  if (existing.length > 0) {
     const slugTokens = input.slug.toLowerCase().split(/[-_\s]+/).filter(Boolean);
     const similar = existing.filter(({ memory }) => {
       const id = memory.frontmatter.id.toLowerCase();
       return slugTokens.length >= 2 && slugTokens.filter((t) => id.includes(t)).length >= Math.ceil(slugTokens.length * 0.6);
     });
     if (similar.length > 0) {
-      warning = `Possible duplicate detected. Similar memories: ${similar.map((m) => m.memory.frontmatter.id).join(", ")}. Consider updating one of these instead.`;
+      similar_found = similar.map((m) => m.memory.frontmatter.id);
+      warning = `Possible duplicate: similar memories already exist (${similar_found.join(", ")}). Consider updating one of these instead.`;
     }
   }
   await writeFile2(file, serializeMemory({ frontmatter, body: input.body }), "utf8");
@@ -187,7 +239,9 @@ async function memSave(input, ctx) {
     id: frontmatter.id,
     scope: frontmatter.scope,
     file_path: file,
-    ...warning ? { warning } : {}
+    action: "created",
+    ...warning ? { warning } : {},
+    ...similar_found ? { similar_found } : {}
   };
 }
 
@@ -947,10 +1001,120 @@ async function memObserve(input, ctx) {
   return { id: frontmatter.id, scope: frontmatter.scope, file_path: file };
 }
 
-// src/tools/get-briefing.ts
-import { readFile as readFile3, readdir as readdir3 } from "fs/promises";
+// src/tools/mem-session-end.ts
+import { writeFile as writeFile9, mkdir as mkdir5 } from "fs/promises";
 import { existsSync as existsSync16 } from "fs";
 import path7 from "path";
+import {
+  buildFrontmatter as buildFrontmatter4,
+  loadMemoriesFromDir as loadMemoriesFromDir12,
+  memoryFilePath as memoryFilePath4,
+  serializeMemory as serializeMemory8
+} from "@hiveai/core";
+import { z as z16 } from "zod";
+var MemSessionEndInputSchema = {
+  goal: z16.string().min(1).describe("What you were trying to accomplish this session (1\u20132 sentences)"),
+  accomplished: z16.string().describe("What was actually done \u2014 bullet list recommended"),
+  discoveries: z16.string().default("").describe(
+    "Any bugs, inconsistencies, surprises, or missing knowledge found during this session. Empty if nothing surprising was found."
+  ),
+  files_touched: z16.array(z16.string()).default([]).describe("Key files that were read or modified \u2014 used as anchor paths"),
+  next_steps: z16.string().default("").describe("What should happen next (for the next session or a teammate)"),
+  scope: z16.enum(["personal", "team", "module"]).default("personal").describe("Visibility: personal = private to you, team = shared with the team"),
+  module: z16.string().optional().describe("Module name (required when scope=module)")
+};
+function recapTopic(scope, module) {
+  return module ? `session-recap-${scope}-${module}` : `session-recap-${scope}`;
+}
+function buildBody(input) {
+  const lines = [];
+  lines.push(`## Goal
+${input.goal}`);
+  lines.push(`
+## Accomplished
+${input.accomplished}`);
+  if (input.discoveries.trim()) {
+    lines.push(`
+## Discoveries & surprises
+${input.discoveries}`);
+  }
+  if (input.files_touched.length > 0) {
+    lines.push(`
+## Files touched
+${input.files_touched.map((f) => `- \`${f}\``).join("\n")}`);
+  }
+  if (input.next_steps.trim()) {
+    lines.push(`
+## Next steps
+${input.next_steps}`);
+  }
+  return lines.join("\n");
+}
+async function memSessionEnd(input, ctx) {
+  if (!existsSync16(ctx.paths.haiveDir)) {
+    throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`);
+  }
+  const body = buildBody(input);
+  const topic = recapTopic(input.scope, input.module);
+  const existing = existsSync16(ctx.paths.memoriesDir) ? await loadMemoriesFromDir12(ctx.paths.memoriesDir) : [];
+  const topicMatch = existing.find(
+    ({ memory }) => memory.frontmatter.topic === topic && memory.frontmatter.scope === input.scope && (!input.module || memory.frontmatter.module === input.module)
+  );
+  if (topicMatch) {
+    const fm = topicMatch.memory.frontmatter;
+    const revisionCount = (fm.revision_count ?? 0) + 1;
+    const newFrontmatter = {
+      ...fm,
+      revision_count: revisionCount,
+      anchor: {
+        ...fm.anchor,
+        paths: input.files_touched.length ? input.files_touched : fm.anchor.paths
+      }
+    };
+    await writeFile9(
+      topicMatch.filePath,
+      serializeMemory8({ frontmatter: newFrontmatter, body }),
+      "utf8"
+    );
+    return {
+      id: fm.id,
+      scope: fm.scope,
+      file_path: topicMatch.filePath,
+      action: "updated",
+      revision_count: revisionCount
+    };
+  }
+  const frontmatter = buildFrontmatter4({
+    type: "session_recap",
+    slug: "recap",
+    scope: input.scope,
+    module: input.module,
+    tags: ["session", "recap"],
+    paths: input.files_touched,
+    topic,
+    status: "validated"
+  });
+  const file = memoryFilePath4(
+    ctx.paths,
+    frontmatter.scope,
+    frontmatter.id,
+    frontmatter.module
+  );
+  await mkdir5(path7.dirname(file), { recursive: true });
+  await writeFile9(file, serializeMemory8({ frontmatter, body }), "utf8");
+  return {
+    id: frontmatter.id,
+    scope: frontmatter.scope,
+    file_path: file,
+    action: "created",
+    revision_count: 0
+  };
+}
+
+// src/tools/get-briefing.ts
+import { readFile as readFile3, readdir as readdir3 } from "fs/promises";
+import { existsSync as existsSync17 } from "fs";
+import path8 from "path";
 import {
   allocateBudget,
   deriveConfidence as deriveConfidence4,
@@ -959,31 +1123,31 @@ import {
   inferModulesFromPaths as inferModulesFromPaths2,
   isDecaying,
   literalMatchesAllTokens as literalMatchesAllTokens2,
-  loadMemoriesFromDir as loadMemoriesFromDir12,
+  loadMemoriesFromDir as loadMemoriesFromDir13,
   loadUsageIndex as loadUsageIndex7,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
   tokenizeQuery as tokenizeQuery2,
   trackReads as trackReads3,
   truncateToTokens
 } from "@hiveai/core";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var GetBriefingInputSchema = {
-  task: z16.string().optional().describe(
+  task: z17.string().optional().describe(
     "What you are about to do, in 1\u20132 sentences. Used to rank relevant memories semantically."
   ),
-  files: z16.array(z16.string()).default([]).describe("Project-relative file paths the agent is currently looking at or about to edit"),
-  max_tokens: z16.number().int().positive().default(8e3).describe(
+  files: z17.array(z17.string()).default([]).describe("Project-relative file paths the agent is currently looking at or about to edit"),
+  max_tokens: z17.number().int().positive().default(8e3).describe(
     "Approximate token budget for the entire briefing. Each section is allocated a share and truncated to fit."
   ),
-  max_memories: z16.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
-  include_project_context: z16.boolean().default(true),
-  include_module_contexts: z16.boolean().default(true),
-  semantic: z16.boolean().default(true).describe(
+  max_memories: z17.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
+  include_project_context: z17.boolean().default(true),
+  include_module_contexts: z17.boolean().default(true),
+  semantic: z17.boolean().default(true).describe(
     "Use semantic ranking when a task is provided (requires `haive embeddings index`)."
   ),
-  include_stale: z16.boolean().default(false).describe("Include stale memories (excluded by default \u2014 they may be outdated)"),
-  track: z16.boolean().default(true).describe("Increment read_count on returned memories"),
-  format: z16.enum(["full", "compact"]).default("full").describe(
+  include_stale: z17.boolean().default(false).describe("Include stale memories (excluded by default \u2014 they may be outdated)"),
+  track: z17.boolean().default(true).describe("Increment read_count on returned memories"),
+  format: z17.enum(["full", "compact"]).default("full").describe(
     "Output format: 'full' returns complete memory bodies; 'compact' returns id + 1-line summary only (call mem_get for details)."
   )
 };
@@ -993,12 +1157,27 @@ async function getBriefing(input, ctx) {
   let searchMode = "literal";
   let usage = { version: 1, updated_at: "", by_id: {} };
   let byId = /* @__PURE__ */ new Map();
-  if (existsSync16(ctx.paths.memoriesDir)) {
-    const allLoaded = await loadMemoriesFromDir12(ctx.paths.memoriesDir);
+  let lastSession;
+  if (existsSync17(ctx.paths.memoriesDir)) {
+    const allLoaded = await loadMemoriesFromDir13(ctx.paths.memoriesDir);
+    const recaps = allLoaded.filter(({ memory }) => memory.frontmatter.type === "session_recap").sort(
+      (a, b) => new Date(b.memory.frontmatter.created_at).getTime() - new Date(a.memory.frontmatter.created_at).getTime()
+    );
+    if (recaps.length > 0) {
+      const r = recaps[0];
+      const fm = r.memory.frontmatter;
+      lastSession = {
+        id: fm.id,
+        scope: fm.scope,
+        revision_count: fm.revision_count ?? 0,
+        body: r.memory.body
+      };
+    }
     const allMemories = allLoaded.filter(({ memory }) => {
       const s = memory.frontmatter.status;
       if (s === "rejected" || s === "deprecated") return false;
       if (!input.include_stale && s === "stale") return false;
+      if (memory.frontmatter.type === "session_recap") return false;
       return true;
     });
     usage = await loadUsageIndex7(ctx.paths);
@@ -1088,7 +1267,7 @@ async function getBriefing(input, ctx) {
       await trackReads3(ctx.paths, memories.map((m) => m.id));
     }
   }
-  const projectContext = input.include_project_context && existsSync16(ctx.paths.projectContext) ? await readFile3(ctx.paths.projectContext, "utf8") : "";
+  const projectContext = input.include_project_context && existsSync17(ctx.paths.projectContext) ? await readFile3(ctx.paths.projectContext, "utf8") : "";
   const moduleContents = input.include_module_contexts ? await loadModuleContexts2(ctx, inferred) : [];
   const memoriesText = memories.map((m) => {
     const unverified = m.status === "proposed" ? " [UNVERIFIED \u2014 not yet validated]" : "";
@@ -1154,6 +1333,7 @@ ${m.content}`).join("\n\n---\n\n"),
     ...input.task ? { task: input.task } : {},
     search_mode: searchMode,
     inferred_modules: inferred,
+    ...lastSession ? { last_session: lastSession } : {},
     project_context: projectContext ? { content: projectSlice.text, truncated: projectSlice.truncated } : null,
     module_contexts: trimmedModules,
     memories: outputMemories,
@@ -1189,15 +1369,15 @@ async function trySemanticHits(ctx, task, limit) {
 }
 async function loadModuleContexts2(ctx, modules) {
   if (modules.length === 0) return [];
-  if (!existsSync16(ctx.paths.modulesContextDir)) return [];
+  if (!existsSync17(ctx.paths.modulesContextDir)) return [];
   const available = new Set(
     (await readdir3(ctx.paths.modulesContextDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name)
   );
   const out = [];
   for (const m of modules) {
     if (!available.has(m)) continue;
-    const file = path7.join(ctx.paths.modulesContextDir, m, "context.md");
-    if (existsSync16(file)) {
+    const file = path8.join(ctx.paths.modulesContextDir, m, "context.md");
+    if (existsSync17(file)) {
       out.push({ name: m, content: await readFile3(file, "utf8") });
     }
   }
@@ -1206,11 +1386,11 @@ async function loadModuleContexts2(ctx, modules) {
 
 // src/tools/code-map.ts
 import { loadCodeMap, queryCodeMap } from "@hiveai/core";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var CodeMapInputSchema = {
-  file: z17.string().optional().describe("Filter to files whose path contains this substring"),
-  symbol: z17.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
-  max_files: z17.number().int().positive().default(40).describe("Cap on returned files")
+  file: z18.string().optional().describe("Filter to files whose path contains this substring"),
+  symbol: z18.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
+  max_files: z18.number().int().positive().default(40).describe("Cap on returned files")
 };
 async function codeMapTool(input, ctx) {
   const map = await loadCodeMap(ctx.paths);
@@ -1236,18 +1416,18 @@ async function codeMapTool(input, ctx) {
 }
 
 // src/tools/mem-diff.ts
-import { existsSync as existsSync17 } from "fs";
-import { loadMemoriesFromDir as loadMemoriesFromDir13 } from "@hiveai/core";
-import { z as z18 } from "zod";
+import { existsSync as existsSync18 } from "fs";
+import { loadMemoriesFromDir as loadMemoriesFromDir14 } from "@hiveai/core";
+import { z as z19 } from "zod";
 var MemDiffInputSchema = {
-  id_a: z18.string().min(1).describe("First memory id"),
-  id_b: z18.string().min(1).describe("Second memory id")
+  id_a: z19.string().min(1).describe("First memory id"),
+  id_b: z19.string().min(1).describe("Second memory id")
 };
 async function memDiff(input, ctx) {
-  if (!existsSync17(ctx.paths.memoriesDir)) {
+  if (!existsSync18(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir13(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir14(ctx.paths.memoriesDir);
   const foundA = all.find((m) => m.memory.frontmatter.id === input.id_a);
   const foundB = all.find((m) => m.memory.frontmatter.id === input.id_b);
   if (!foundA) throw new Error(`No memory with id "${input.id_a}".`);
@@ -1281,12 +1461,12 @@ async function memDiff(input, ctx) {
 }
 
 // src/prompts/bootstrap-project.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var BootstrapProjectArgsSchema = {
-  module: z19.string().optional().describe(
+  module: z20.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z19.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z20.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -1368,10 +1548,10 @@ ${template}\`\`\`
 }
 
 // src/prompts/post-task.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var PostTaskArgsSchema = {
-  task_summary: z20.string().optional().describe("One sentence describing what you just did"),
-  files_touched: z20.array(z20.string()).optional().describe("Files you created or modified during the task")
+  task_summary: z21.string().optional().describe("One sentence describing what you just did"),
+  files_touched: z21.array(z21.string()).optional().describe("Files you created or modified during the task")
 };
 function postTaskPrompt(args, ctx) {
   const taskLine = args.task_summary ? `
@@ -1428,7 +1608,18 @@ Examples of things to look for:
 - Skip sections where you genuinely have nothing to add. Don't fabricate memories.
 - **Question 0 is not optional** \u2014 always scan your exploration history for code-level discoveries.
 
-When done, respond with a brief summary: "Saved N memories: [list of IDs]" or "Nothing new to save."
+### 6. Close the session \u2014 always
+Call **\`mem_session_end\`** with:
+- \`goal\`: what you set out to do
+- \`accomplished\`: what was actually done (bullet list)
+- \`discoveries\`: anything surprising or broken found during this session (leave empty if none)
+- \`files_touched\`: the key files you read or modified
+- \`next_steps\`: what remains for the next session or a teammate
+- \`scope\`: "team" if this task affects the whole team, "personal" otherwise
+
+This creates/updates a single rolling recap that **get_briefing automatically surfaces** at the start of every subsequent session \u2014 no token waste re-explaining what happened.
+
+When done, respond with a brief summary: "Saved N memories: [list of IDs]. Session recap saved."
 `;
   return {
     description: "Post-task reflection: capture what you learned before closing the session",
@@ -1442,12 +1633,12 @@ When done, respond with a brief summary: "Saved N memories: [list of IDs]" or "N
 }
 
 // src/prompts/import-docs.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var ImportDocsArgsSchema = {
-  content: z21.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
-  source: z21.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
-  scope: z21.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
-  dry_run: z21.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
+  content: z22.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
+  source: z22.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
+  scope: z22.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
+  dry_run: z22.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
 };
 function importDocsPrompt(args, ctx) {
   const sourceLine = args.source ? `
@@ -1512,7 +1703,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
 
 // src/server.ts
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.2.11";
+var SERVER_VERSION = "0.2.13";
 function jsonResult(data) {
   return {
     content: [
@@ -1637,6 +1828,12 @@ function createHaiveServer(options = {}) {
     MemObserveInputSchema,
     async (input) => jsonResult(await memObserve(input, context))
   );
+  server.tool(
+    "mem_session_end",
+    "Save a structured end-of-session recap (goal / accomplished / discoveries / next steps). Uses topic-upsert: one recap per scope is kept and updated in-place so the next session always has fresh context. Call this before closing every significant session. get_briefing automatically surfaces the latest recap at the top of the next session's briefing.",
+    MemSessionEndInputSchema,
+    async (input) => jsonResult(await memSessionEnd(input, context))
+  );
   server.prompt(
     "bootstrap_project",
     "Instructions for the AI client to analyze the project and save the context.",