@hiveai/mcp 0.2.16 → 0.3.2

package/README.md

@@ -99,6 +99,7 @@ One-shot onboarding: returns project context + module contexts + ranked relevant
 {
   "task": "add a Stripe payment integration",
   "files": ["src/payments/PaymentService.ts"],
+  "symbols": ["PaymentService", "TenantFilter"],
   "max_tokens": 8000,
   "max_memories": 8,
   "format": "full",
@@ -112,6 +113,7 @@ One-shot onboarding: returns project context + module contexts + ranked relevant
 |---|---|---|
 | `task` | — | What you're about to do. Used to rank memories by relevance. |
 | `files` | `[]` | Files you're editing. Surfaces memories anchored to these files. |
+| `symbols` | `[]` | Symbol names to look up in the code-map (e.g. `["PaymentService"]`). Returns file + line + kind without grepping. Requires `haive index code`. |
 | `max_tokens` | `8000` | Token budget for the entire response. Sections are truncated to fit. |
 | `max_memories` | `8` | Max memories to include. |
 | `format` | `"full"` | `"full"` = complete bodies · `"compact"` = 1-line summaries (call `mem_get` for details) |
@@ -120,10 +122,13 @@ One-shot onboarding: returns project context + module contexts + ranked relevant
 | `track` | `true` | Increment read_count for returned memories. |
 
 **Response includes:**
-- `project_context` — the contents of `.ai/project-context.md`
+- `last_session` — most recent `haive session end` recap (surfaced first so agents start with fresh context)
+- `project_context` — `.ai/project-context.md` (suppressed if still template — `is_template: true`)
 - `module_contexts` — relevant `.ai/modules/<name>/context.md` files
-- `memories` — ranked list of relevant memories with body, confidence, and match reason
-- `decay_warnings` — memory IDs not read in >90 days (review or deprecate)
+- `memories` — ranked memories with `confidence`, `unverified` flag (for draft/proposed), and `match reason`
+- `symbol_locations` — file:line:kind results for each requested symbol (from code-map)
+- `decay_warnings` — memory IDs not read in >90 days
+- `setup_warnings` — actionable warnings (e.g. template project-context, missing init)
 - `search_mode` — `"semantic"` | `"literal_fallback"` | `"literal"`
 
 ---
@@ -149,12 +154,15 @@ Save a new memory. For failed approaches, use `mem_tried` instead — it enforce
 | `slug` | ✅ | Short kebab-case identifier |
 | `scope` | — | `personal` (default) · `team` · `module` |
 | `body` | ✅ | Markdown content |
-| `paths` | — | File paths to anchor to (enables staleness detection) |
+| `paths` | — | File paths to anchor to (enables staleness detection). **Warning returned if path doesn't exist in project.** |
 | `symbols` | — | Function/class names to anchor to |
 | `tags` | — | Tags for filtering |
+| `topic` | — | Stable key for upsert: if a memory with this `topic`+`scope` already exists, it is updated in-place (`revision_count++`) |
 | `domain` | — | Business domain (e.g. `payments`) |
 | `author` | — | Author handle |
 
+**Deduplication:** identical body content (same SHA-256 hash) within the same scope is rejected with an error. Use `mem_update` to modify it instead.
+
 ---
 
 ### `mem_tried` ⭐ Record failures immediately
@@ -263,6 +271,38 @@ Compare two memories side-by-side: shows frontmatter fields that differ and line
 
 ---
 
+### `mem_session_end`
+
+Save a structured end-of-session recap. Topic-upsert: one recap per scope is kept and updated with `revision_count++`. Automatically surfaced at the top of the next `get_briefing`.
+
+```json
+{
+  "goal": "Add Stripe payment integration",
+  "accomplished": "PaymentService done, tests passing, deployed to staging",
+  "discoveries": "Webhook signature requires raw body, not parsed JSON",
+  "files_touched": ["src/payments/PaymentService.ts", "src/payments/webhook.ts"],
+  "next_steps": "Add retry logic for failed webhooks",
+  "scope": "team"
+}
+```
+
+---
+
+### `mem_observe`
+
+Capture a code-level discovery in structured form (found-while, not a convention or decision).
+
+```json
+{
+  "file": "src/payments/PaymentService.ts",
+  "symbol": "processPayment",
+  "observation": "This method calls the external API synchronously — any timeout blocks the entire request thread.",
+  "scope": "team"
+}
+```
+
+---
+
 ### `mem_approve` / `mem_reject` / `mem_pending` / `mem_delete`
 
 Lifecycle operations:

package/dist/index.js

@@ -130,6 +130,7 @@ import { existsSync as existsSync4 } from "fs";
 import path3 from "path";
 import {
   buildFrontmatter,
+  loadConfig,
   loadMemoriesFromDir as loadMemoriesFromDir2,
   memoryFilePath,
   serializeMemory
@@ -207,10 +208,12 @@ async function memSave(input, ctx) {
       };
     }
   }
+  const haiveConfig = await loadConfig(ctx.paths);
+  const resolvedScope = input.scope !== "personal" ? input.scope : haiveConfig.defaultScope ?? "personal";
   const frontmatter = buildFrontmatter({
     type: input.type,
     slug: input.slug,
-    scope: input.scope,
+    scope: resolvedScope,
     module: input.module,
     tags: input.tags,
     domain: input.domain,
@@ -218,7 +221,8 @@ async function memSave(input, ctx) {
     paths: input.paths,
     symbols: input.symbols,
     commit: input.commit,
-    topic: input.topic
+    topic: input.topic,
+    status: haiveConfig.defaultStatus === "validated" ? "validated" : void 0
   });
   const file = memoryFilePath(
     ctx.paths,
@@ -1164,9 +1168,12 @@ import {
   isDecaying,
   literalMatchesAllTokens as literalMatchesAllTokens2,
   literalMatchesAnyToken as literalMatchesAnyToken2,
+  loadCodeMap,
+  loadConfig as loadConfig2,
   loadMemoriesFromDir as loadMemoriesFromDir13,
   loadUsageIndex as loadUsageIndex7,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
+  queryCodeMap,
   tokenizeQuery as tokenizeQuery2,
   trackReads as trackReads3,
   truncateToTokens
@@ -1190,6 +1197,9 @@ var GetBriefingInputSchema = {
   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)."
+  ),
+  symbols: z17.array(z17.string()).default([]).describe(
+    "Symbol names to look up in the code-map (e.g. ['PaymentService', 'TenantFilter']). Returns the file(s) exporting each symbol so agents don't need to grep. Requires `haive index code` to have been run."
   )
 };
 async function getBriefing(input, ctx) {
@@ -1251,6 +1261,7 @@ async function getBriefing(input, ctx) {
         tags: fm.tags,
         status: fm.status,
         confidence: deriveConfidence4(fm, u),
+        ...fm.status === "draft" || fm.status === "proposed" ? { unverified: true } : {},
         read_count: u.read_count,
         reasons: [reason],
         match_quality: matchQuality ?? "partial",
@@ -1316,17 +1327,55 @@ async function getBriefing(input, ctx) {
   }
   const projectContextRaw = input.include_project_context && existsSync17(ctx.paths.projectContext) ? await readFile3(ctx.paths.projectContext, "utf8") : "";
   const isTemplateContext = projectContextRaw.includes("TODO \u2014 high-level overview") || projectContextRaw.includes("Generated by `haive init`");
-  const projectContext = isTemplateContext ? "" : projectContextRaw;
   const setupWarnings = [];
-  if (isTemplateContext) {
-    setupWarnings.push(
-      "project-context.md still contains the default template. Invoke the bootstrap_project MCP prompt to auto-fill it from your codebase. Until then, get_briefing returns no project context."
-    );
-  }
-  if (!existsSync17(ctx.paths.projectContext)) {
-    setupWarnings.push(
-      "No project-context.md found. Run `haive init` then invoke the bootstrap_project MCP prompt."
-    );
+  let autoContextGenerated = false;
+  let projectContext = isTemplateContext ? "" : projectContextRaw;
+  if ((isTemplateContext || !existsSync17(ctx.paths.projectContext)) && input.include_project_context) {
+    const haiveConfig = await loadConfig2(ctx.paths);
+    if (haiveConfig.autoContext) {
+      const codeMap = await loadCodeMap(ctx.paths);
+      if (codeMap) {
+        const totalFiles = Object.keys(codeMap.files).length;
+        const extensions = /* @__PURE__ */ new Map();
+        for (const filePath of Object.keys(codeMap.files)) {
+          const ext = filePath.slice(filePath.lastIndexOf(".") + 1).toLowerCase();
+          extensions.set(ext, (extensions.get(ext) ?? 0) + 1);
+        }
+        const topExts = [...extensions.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([e, n]) => `${e} (${n})`).join(", ");
+        const topSymbols = Object.entries(codeMap.files).flatMap(
+          ([fp, entry]) => entry.exports.slice(0, 3).map((e) => `${e.name} (${fp.split("/").slice(-2).join("/")})`)
+        ).slice(0, 15).join(", ");
+        projectContext = `# Project context (auto-generated by hAIve)
+
+> \u26A0 This is a minimal auto-generated context based on the code-map. Invoke the \`bootstrap_project\` MCP prompt to replace it with a full analysis.
+
+## Codebase overview
+- **${totalFiles} files** indexed in code-map
+- **Main file types:** ${topExts}
+- **Generated at:** ${codeMap.generated_at}
+
+## Key exports (sample)
+` + topSymbols + "\n";
+        autoContextGenerated = true;
+        setupWarnings.push(
+          "project-context.md is still the default template. A minimal auto-generated context has been injected from the code-map. Invoke bootstrap_project to replace it with a full AI-analyzed context."
+        );
+      } else {
+        setupWarnings.push(
+          "project-context.md is still the default template and no code-map found. Run `haive index code` then invoke bootstrap_project for a full context."
+        );
+      }
+    } else {
+      if (isTemplateContext) {
+        setupWarnings.push(
+          "project-context.md still contains the default template. Invoke the bootstrap_project MCP prompt to auto-fill it from your codebase. Until then, get_briefing returns no project context."
+        );
+      } else {
+        setupWarnings.push(
+          "No project-context.md found. Run `haive init` then invoke the bootstrap_project MCP prompt."
+        );
+      }
+    }
   }
   const moduleContents = input.include_module_contexts ? await loadModuleContexts2(ctx, inferred) : [];
   const memoriesText = memories.map((m) => {
@@ -1389,18 +1438,51 @@ ${m.content}`).join("\n\n---\n\n"),
     if (isDecaying(u, createdAt)) decayWarnings.push(m.id);
   }
   const outputMemories = input.format === "compact" ? trimmedMemories.map((m) => ({ ...m, body: compactSummary(m.body) })) : trimmedMemories;
+  let symbolLocations;
+  const symbolsToLookup = new Set(input.symbols);
+  for (const m of outputMemories) {
+    const loaded = byId.get(m.id);
+    for (const sym of loaded?.memory.frontmatter.anchor.symbols ?? []) {
+      symbolsToLookup.add(sym);
+    }
+  }
+  if (symbolsToLookup.size > 0) {
+    const codeMap = await loadCodeMap(ctx.paths);
+    if (codeMap) {
+      symbolLocations = [];
+      for (const sym of symbolsToLookup) {
+        const { files } = queryCodeMap(codeMap, { symbol: sym });
+        if (files.length > 0) {
+          symbolLocations.push({
+            symbol: sym,
+            locations: files.flatMap(
+              (f) => f.entry.exports.filter((e) => e.name.toLowerCase().includes(sym.toLowerCase())).map((e) => ({
+                file: f.path,
+                kind: e.kind,
+                line: e.line,
+                ...e.description ? { description: e.description } : {}
+              }))
+            )
+          });
+        }
+      }
+      if (symbolLocations.length === 0) symbolLocations = void 0;
+    }
+  }
   return {
     ...input.task ? { task: input.task } : {},
     search_mode: searchMode,
     inferred_modules: inferred,
     ...lastSession ? { last_session: lastSession } : {},
-    project_context: projectContextRaw ? {
+    project_context: projectContextRaw || autoContextGenerated ? {
       content: projectSlice.text,
       truncated: projectSlice.truncated,
-      ...isTemplateContext ? { is_template: true } : {}
+      ...isTemplateContext && !autoContextGenerated ? { is_template: true } : {},
+      ...autoContextGenerated ? { auto_generated: true } : {}
     } : null,
     module_contexts: trimmedModules,
     memories: outputMemories,
+    ...symbolLocations ? { symbol_locations: symbolLocations } : {},
     decay_warnings: decayWarnings,
     setup_warnings: setupWarnings,
     estimated_tokens: totalTokens,
@@ -1450,7 +1532,7 @@ async function loadModuleContexts2(ctx, modules) {
 }
 
 // src/tools/code-map.ts
-import { loadCodeMap, queryCodeMap } from "@hiveai/core";
+import { loadCodeMap as loadCodeMap2, queryCodeMap as queryCodeMap2 } from "@hiveai/core";
 import { z as z18 } from "zod";
 var CodeMapInputSchema = {
   file: z18.string().optional().describe("Filter to files whose path contains this substring"),
@@ -1458,7 +1540,7 @@ var CodeMapInputSchema = {
   max_files: z18.number().int().positive().default(40).describe("Cap on returned files")
 };
 async function codeMapTool(input, ctx) {
-  const map = await loadCodeMap(ctx.paths);
+  const map = await loadCodeMap2(ctx.paths);
   if (!map) {
     return {
       available: false,
@@ -1466,7 +1548,7 @@ async function codeMapTool(input, ctx) {
       notice: "No code map found. Run `haive index code` to generate `.ai/code-map.json`."
     };
   }
-  const { files } = queryCodeMap(map, { file: input.file, symbol: input.symbol });
+  const { files } = queryCodeMap2(map, { file: input.file, symbol: input.symbol });
   return {
     available: true,
     generated_at: map.generated_at,
@@ -1766,9 +1848,78 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 
+// src/session-tracker.ts
+import { loadConfig as loadConfig3 } from "@hiveai/core";
+var SessionTracker = class {
+  events = [];
+  startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  config = null;
+  ctx;
+  shutdownRegistered = false;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async init() {
+    this.config = await loadConfig3(this.ctx.paths);
+    if (this.config.autoSessionEnd) {
+      this.registerShutdownHandler();
+    }
+  }
+  record(tool, summary) {
+    this.events.push({ tool, at: (/* @__PURE__ */ new Date()).toISOString(), summary });
+  }
+  registerShutdownHandler() {
+    if (this.shutdownRegistered) return;
+    this.shutdownRegistered = true;
+    const save = async () => {
+      const writingTools = this.events.filter(
+        (e) => ["mem_save", "mem_tried", "mem_observe", "mem_update", "bootstrap_project_save"].includes(e.tool)
+      );
+      const totalCalls = this.events.length;
+      if (totalCalls === 0) return;
+      const toolSummary = summarizeTools(this.events);
+      const filesSet = /* @__PURE__ */ new Set();
+      for (const e of this.events) {
+        if (e.summary) {
+          const matches = e.summary.match(/[^\s"',]+\.[a-zA-Z]{1,6}/g) ?? [];
+          for (const m of matches) filesSet.add(m);
+        }
+      }
+      try {
+        await memSessionEnd(
+          {
+            goal: `Auto-captured session (${totalCalls} tool call${totalCalls === 1 ? "" : "s"})`,
+            accomplished: toolSummary,
+            discoveries: writingTools.length > 0 ? `${writingTools.length} memor${writingTools.length === 1 ? "y" : "ies"} saved during this session.` : "No new memories saved this session.",
+            files_touched: [...filesSet].slice(0, 10),
+            next_steps: "",
+            scope: this.config?.defaultScope ?? "personal",
+            module: void 0
+          },
+          this.ctx
+        );
+      } catch {
+      }
+    };
+    process.once("SIGTERM", () => {
+      void save().finally(() => process.exit(0));
+    });
+    process.once("SIGINT", () => {
+      void save().finally(() => process.exit(0));
+    });
+  }
+};
+function summarizeTools(events) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    counts.set(e.tool, (counts.get(e.tool) ?? 0) + 1);
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1]).map(([t, n]) => `${t} \xD7${n}`).join(", ");
+}
+
 // src/server.ts
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.2.16";
+var SERVER_VERSION = "0.3.2";
 function jsonResult(data) {
   return {
     content: [
@@ -1781,6 +1932,8 @@ function jsonResult(data) {
 }
 function createHaiveServer(options = {}) {
   const context = createContext(options);
+  const tracker = new SessionTracker(context);
+  void tracker.init();
   const server = new McpServer(
     { name: SERVER_NAME, version: SERVER_VERSION },
     { capabilities: { tools: {}, prompts: {} } }
@@ -1789,7 +1942,10 @@ function createHaiveServer(options = {}) {
     "mem_save",
     "Save a new memory (convention, decision, gotcha, architecture, glossary). For failed approaches use mem_tried instead \u2014 it enforces a structured format that is more useful to future agents. Use scope=team to share with the whole team.",
     MemSaveInputSchema,
-    async (input) => jsonResult(await memSave(input, context))
+    async (input) => {
+      tracker.record("mem_save", input.slug);
+      return jsonResult(await memSave(input, context));
+    }
   );
   server.tool(
     "mem_search",
@@ -1813,7 +1969,10 @@ function createHaiveServer(options = {}) {
     "get_briefing",
     "One-shot onboarding: returns project context + module contexts + ranked relevant memories under a token budget. Replaces 4\u20135 separate calls when an agent starts a task.",
     GetBriefingInputSchema,
-    async (input) => jsonResult(await getBriefing(input, context))
+    async (input) => {
+      tracker.record("get_briefing", input.task ?? "");
+      return jsonResult(await getBriefing(input, context));
+    }
   );
   server.tool(
     "code_map",
@@ -1879,7 +2038,10 @@ function createHaiveServer(options = {}) {
     "mem_tried",
     "Preferred way to record a failed approach. Enforces a structured what/why_failed/instead format that is immediately actionable for future agents. Auto-validated (no approval cycle). Use whenever you tried an approach and it failed \u2014 prevents the same mistake from happening in the next session.",
     MemTriedInputSchema,
-    async (input) => jsonResult(await memTried(input, context))
+    async (input) => {
+      tracker.record("mem_tried", input.what.slice(0, 80));
+      return jsonResult(await memTried(input, context));
+    }
   );
   server.tool(
     "mem_diff",
@@ -1891,13 +2053,19 @@ function createHaiveServer(options = {}) {
     "mem_observe",
     "Capture a code-level discovery made during exploration: a bug, inconsistency, missing config, or security gap found by reading existing code that was NOT in the briefing. Use this whenever you read code and spot something that could silently break in production. Auto-validated, anchored to file paths for staleness detection. Prefer this over mem_save for reactive discoveries during code reading.",
     MemObserveInputSchema,
-    async (input) => jsonResult(await memObserve(input, context))
+    async (input) => {
+      tracker.record("mem_observe", input.where);
+      return 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))
+    async (input) => {
+      tracker.record("mem_session_end", input.goal.slice(0, 80));
+      return jsonResult(await memSessionEnd(input, context));
+    }
   );
   server.prompt(
     "bootstrap_project",
@@ -1917,7 +2085,7 @@ function createHaiveServer(options = {}) {
     ImportDocsArgsSchema,
     (args) => importDocsPrompt(args, context)
   );
-  return { server, context };
+  return { server, context, tracker };
 }
 
 // src/index.ts