@hiveai/mcp 0.2.1 → 0.2.3

package/dist/server.js

@@ -80,7 +80,10 @@ var MemListInputSchema = {
   scope: z3.enum(["personal", "team", "module"]).optional(),
   type: z3.enum(["convention", "decision", "gotcha", "architecture", "glossary"]).optional(),
   module: z3.string().optional(),
-  tag: z3.string().optional()
+  tag: z3.string().optional(),
+  status: z3.enum(["draft", "proposed", "validated", "deprecated", "stale", "rejected"]).optional().describe("Filter by a single status. Omit to return all statuses."),
+  exclude_rejected: z3.boolean().default(false).describe("When true, exclude memories with status=rejected from results."),
+  include_body: z3.boolean().default(false).describe("Include full body text. Default false to save tokens \u2014 use mem_get for a single memory's full content.")
 };
 async function memList(input, ctx) {
   if (!existsSync3(ctx.paths.memoriesDir)) {
@@ -93,10 +96,13 @@ async function memList(input, ctx) {
     if (input.type && fm.type !== input.type) return false;
     if (input.module && fm.module !== input.module) return false;
     if (input.tag && !fm.tags.includes(input.tag)) return false;
+    if (input.status && fm.status !== input.status) return false;
+    if (input.exclude_rejected && fm.status === "rejected") return false;
     return true;
   });
   const memories = filtered.map(({ memory, filePath }) => {
     const fm = memory.frontmatter;
+    const snippet = memory.body.replace(/\s+/g, " ").trim().slice(0, 120);
     return {
       id: fm.id,
       scope: fm.scope,
@@ -104,7 +110,9 @@ async function memList(input, ctx) {
       ...fm.module ? { module: fm.module } : {},
       status: fm.status,
       tags: fm.tags,
-      file_path: filePath
+      snippet,
+      file_path: filePath,
+      ...input.include_body ? { body: memory.body } : {}
     };
   });
   return { memories };
@@ -188,6 +196,8 @@ var MemSearchInputSchema = {
   scope: z5.enum(["personal", "team", "module"]).optional().describe("Restrict results to a single scope"),
   type: z5.enum(["convention", "decision", "gotcha", "architecture", "glossary"]).optional().describe("Restrict results to a memory type"),
   module: z5.string().optional().describe("Restrict results to a module"),
+  status: z5.enum(["draft", "proposed", "validated", "deprecated", "stale", "rejected"]).optional().describe("Filter by a single status. Omit to return all statuses."),
+  exclude_rejected: z5.boolean().default(false).describe("When true, exclude memories with status=rejected from results."),
   limit: z5.number().int().positive().max(100).default(20).describe("Max results"),
   semantic: z5.boolean().default(false).describe(
     "Use semantic similarity from the embeddings index (requires `haive embeddings index`)."
@@ -229,6 +239,8 @@ function passesFilters(fm, input) {
   if (input.scope && fm.scope !== input.scope) return false;
   if (input.type && fm.type !== input.type) return false;
   if (input.module && fm.module !== input.module) return false;
+  if (input.status && fm.status !== input.status) return false;
+  if (input.exclude_rejected && fm.status === "rejected") return false;
   return true;
 }
 function buildLiteralResult(input, filtered, usage) {
@@ -330,6 +342,14 @@ async function memVerify(input, ctx) {
     const isAnchored = memory.frontmatter.anchor.paths.length > 0 || memory.frontmatter.anchor.symbols.length > 0;
     if (!isAnchored) {
       anchorless++;
+      results.push({
+        id: memory.frontmatter.id,
+        file_path: filePath,
+        stale: false,
+        reason: null,
+        status_after: memory.frontmatter.status,
+        skipped: true
+      });
       continue;
     }
     const result = await verifyAnchor(memory, { projectRoot: ctx.paths.root });
@@ -387,12 +407,14 @@ function applyVerification(mem, result) {
 }
 
 // src/tools/mem-reject.ts
+import { writeFile as writeFile4 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
 import {
   loadMemoriesFromDir as loadMemoriesFromDir4,
   loadUsageIndex as loadUsageIndex2,
   recordRejection,
-  saveUsageIndex
+  saveUsageIndex,
+  serializeMemory as serializeMemory3
 } from "@hiveai/core";
 import { z as z7 } from "zod";
 var MemRejectInputSchema = {
@@ -404,16 +426,23 @@ async function memReject(input, ctx) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
   const memories = await loadMemoriesFromDir4(ctx.paths.memoriesDir);
-  const exists = memories.some((m) => m.memory.frontmatter.id === input.id);
-  if (!exists) {
-    throw new Error(`No memory with id "${input.id}".`);
-  }
+  const loaded = memories.find((m) => m.memory.frontmatter.id === input.id);
+  if (!loaded) throw new Error(`No memory with id "${input.id}".`);
+  await writeFile4(
+    loaded.filePath,
+    serializeMemory3({
+      frontmatter: { ...loaded.memory.frontmatter, status: "rejected" },
+      body: loaded.memory.body
+    }),
+    "utf8"
+  );
   const idx = await loadUsageIndex2(ctx.paths);
   recordRejection(idx, input.id, input.reason ?? null);
   await saveUsageIndex(ctx.paths, idx);
   const u = idx.by_id[input.id];
   return {
     id: input.id,
+    status: "rejected",
     rejected_count: u?.rejected_count ?? 0,
     last_rejected_at: u?.last_rejected_at ?? null,
     rejection_reason: u?.rejection_reason ?? null
@@ -601,20 +630,80 @@ async function memDelete(input, ctx) {
   return { id: input.id, deleted_file: found.filePath, usage_removed: usageRemoved };
 }
 
-// src/tools/mem-pending.ts
+// src/tools/mem-update.ts
+import { writeFile as writeFile5 } from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
+import { loadMemoriesFromDir as loadMemoriesFromDir8, serializeMemory as serializeMemory4 } from "@hiveai/core";
+import { z as z11 } from "zod";
+var MemUpdateInputSchema = {
+  id: z11.string().min(1).describe("Id of the memory to update"),
+  body: z11.string().optional().describe("New Markdown body \u2014 replaces the existing body"),
+  tags: z11.array(z11.string()).optional().describe("New tags array \u2014 fully replaces existing tags"),
+  paths: z11.array(z11.string()).optional().describe("New anchor paths \u2014 fully replaces existing anchor.paths"),
+  symbols: z11.array(z11.string()).optional().describe("New anchor symbols \u2014 fully replaces existing anchor.symbols"),
+  commit: z11.string().optional().describe("New anchor commit SHA"),
+  domain: z11.string().optional().describe("New domain label"),
+  author: z11.string().optional().describe("New author handle or email")
+};
+async function memUpdate(input, ctx) {
+  if (!existsSync11(ctx.paths.memoriesDir)) {
+    throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
+  }
+  const memories = await loadMemoriesFromDir8(ctx.paths.memoriesDir);
+  const loaded = memories.find((m) => m.memory.frontmatter.id === input.id);
+  if (!loaded) throw new Error(`No memory with id "${input.id}".`);
+  const { frontmatter, body } = loaded.memory;
+  const updated_fields = [];
+  const newAnchor = { ...frontmatter.anchor };
+  if (input.paths !== void 0) {
+    newAnchor.paths = input.paths;
+    updated_fields.push("anchor.paths");
+  }
+  if (input.symbols !== void 0) {
+    newAnchor.symbols = input.symbols;
+    updated_fields.push("anchor.symbols");
+  }
+  if (input.commit !== void 0) {
+    newAnchor.commit = input.commit;
+    updated_fields.push("anchor.commit");
+  }
+  const newFrontmatter = {
+    ...frontmatter,
+    anchor: newAnchor,
+    ...input.tags !== void 0 ? { tags: input.tags } : {},
+    ...input.domain !== void 0 ? { domain: input.domain } : {},
+    ...input.author !== void 0 ? { author: input.author } : {}
+  };
+  if (input.tags !== void 0) updated_fields.push("tags");
+  if (input.domain !== void 0) updated_fields.push("domain");
+  if (input.author !== void 0) updated_fields.push("author");
+  const newBody = input.body !== void 0 ? input.body : body;
+  if (input.body !== void 0) updated_fields.push("body");
+  if (updated_fields.length === 0) {
+    throw new Error("No fields to update \u2014 provide at least one of: body, tags, paths, symbols, commit, domain, author.");
+  }
+  await writeFile5(
+    loaded.filePath,
+    serializeMemory4({ frontmatter: newFrontmatter, body: newBody }),
+    "utf8"
+  );
+  return { id: input.id, file_path: loaded.filePath, updated_fields };
+}
+
+// src/tools/mem-pending.ts
+import { existsSync as existsSync12 } from "fs";
 import {
   getUsage as getUsage4,
-  loadMemoriesFromDir as loadMemoriesFromDir8,
+  loadMemoriesFromDir as loadMemoriesFromDir9,
   loadUsageIndex as loadUsageIndex6
 } from "@hiveai/core";
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var MemPendingInputSchema = {
-  scope: z11.enum(["personal", "team", "module"]).optional()
+  scope: z12.enum(["personal", "team", "module"]).optional()
 };
 async function memPending(input, ctx) {
-  if (!existsSync11(ctx.paths.memoriesDir)) return { pending: [] };
-  const all = await loadMemoriesFromDir8(ctx.paths.memoriesDir);
+  if (!existsSync12(ctx.paths.memoriesDir)) return { pending: [] };
+  const all = await loadMemoriesFromDir9(ctx.paths.memoriesDir);
   const usage = await loadUsageIndex6(ctx.paths);
   const now = Date.now();
   const proposed = all.filter(({ memory }) => {
@@ -645,21 +734,21 @@ async function memPending(input, ctx) {
 }
 
 // src/tools/mem-approve.ts
-import { writeFile as writeFile4 } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
+import { writeFile as writeFile6 } from "fs/promises";
+import { existsSync as existsSync13 } from "fs";
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir9,
-  serializeMemory as serializeMemory3
+  loadMemoriesFromDir as loadMemoriesFromDir10,
+  serializeMemory as serializeMemory5
 } from "@hiveai/core";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var MemApproveInputSchema = {
-  id: z12.string().min(1).describe("Memory id to approve (sets status=validated immediately)")
+  id: z13.string().min(1).describe("Memory id to approve (sets status=validated immediately)")
 };
 async function memApprove(input, ctx) {
-  if (!existsSync12(ctx.paths.memoriesDir)) {
+  if (!existsSync13(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir9(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir10(ctx.paths.memoriesDir);
   const found = all.find((m) => m.memory.frontmatter.id === input.id);
   if (!found) throw new Error(`No memory with id "${input.id}".`);
   const previous = found.memory.frontmatter.status;
@@ -667,7 +756,7 @@ async function memApprove(input, ctx) {
     frontmatter: { ...found.memory.frontmatter, status: "validated" },
     body: found.memory.body
   };
-  await writeFile4(found.filePath, serializeMemory3(next), "utf8");
+  await writeFile6(found.filePath, serializeMemory5(next), "utf8");
   return {
     id: input.id,
     previous_status: previous,
@@ -678,7 +767,7 @@ async function memApprove(input, ctx) {
 
 // src/tools/get-briefing.ts
 import { readFile as readFile3, readdir as readdir3 } from "fs/promises";
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import path5 from "path";
 import {
   allocateBudget,
@@ -687,37 +776,41 @@ import {
   getUsage as getUsage5,
   inferModulesFromPaths as inferModulesFromPaths2,
   literalMatchesAllTokens as literalMatchesAllTokens2,
-  loadMemoriesFromDir as loadMemoriesFromDir10,
+  loadMemoriesFromDir as loadMemoriesFromDir11,
   loadUsageIndex as loadUsageIndex7,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
   tokenizeQuery as tokenizeQuery2,
   trackReads as trackReads3,
   truncateToTokens
 } from "@hiveai/core";
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var GetBriefingInputSchema = {
-  task: z13.string().optional().describe(
+  task: z14.string().optional().describe(
     "What you are about to do, in 1\u20132 sentences. Used to rank relevant memories semantically."
   ),
-  files: z13.array(z13.string()).default([]).describe("Project-relative file paths the agent is currently looking at or about to edit"),
-  max_tokens: z13.number().int().positive().default(8e3).describe(
+  files: z14.array(z14.string()).default([]).describe("Project-relative file paths the agent is currently looking at or about to edit"),
+  max_tokens: z14.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: z13.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
-  include_project_context: z13.boolean().default(true),
-  include_module_contexts: z13.boolean().default(true),
-  semantic: z13.boolean().default(true).describe(
+  max_memories: z14.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
+  include_project_context: z14.boolean().default(true),
+  include_module_contexts: z14.boolean().default(true),
+  semantic: z14.boolean().default(true).describe(
     "Use semantic ranking when a task is provided (requires `haive embeddings index`)."
   ),
-  track: z13.boolean().default(true).describe("Increment read_count on returned memories")
+  track: z14.boolean().default(true).describe("Increment read_count on returned memories")
 };
 async function getBriefing(input, ctx) {
   const inferred = inferModulesFromPaths2(input.files);
   const memories = [];
-  if (existsSync13(ctx.paths.memoriesDir)) {
-    const allMemories = await loadMemoriesFromDir10(ctx.paths.memoriesDir);
+  let searchMode = "literal";
+  if (existsSync14(ctx.paths.memoriesDir)) {
+    const allMemories = await loadMemoriesFromDir11(ctx.paths.memoriesDir);
     const usage = await loadUsageIndex7(ctx.paths);
     const semanticHits = input.task && input.semantic ? await trySemanticHits(ctx, input.task, allMemories.length * 2) : null;
+    if (input.task && input.semantic) {
+      searchMode = semanticHits ? "semantic" : "literal_fallback";
+    }
     const seen = /* @__PURE__ */ new Map();
     const addOrUpdate = (loaded, reason, score) => {
       const fm = loaded.memory.frontmatter;
@@ -783,7 +876,7 @@ async function getBriefing(input, ctx) {
       await trackReads3(ctx.paths, memories.map((m) => m.id));
     }
   }
-  const projectContext = input.include_project_context && existsSync13(ctx.paths.projectContext) ? await readFile3(ctx.paths.projectContext, "utf8") : "";
+  const projectContext = input.include_project_context && existsSync14(ctx.paths.projectContext) ? await readFile3(ctx.paths.projectContext, "utf8") : "";
   const moduleContents = input.include_module_contexts ? await loadModuleContexts2(ctx, inferred) : [];
   const memoriesText = memories.map((m) => `### ${m.id} (${m.scope}/${m.type}, ${m.confidence})
 ${m.body.trim()}`).join("\n\n---\n\n");
@@ -825,6 +918,7 @@ ${m.content}`).join("\n\n---\n\n"),
   const totalTokens = projectSlice.estimatedTokens + modulesSlice.estimatedTokens + memoriesSlice.estimatedTokens;
   return {
     ...input.task ? { task: input.task } : {},
+    search_mode: searchMode,
     inferred_modules: inferred,
     project_context: projectContext ? { content: projectSlice.text, truncated: projectSlice.truncated } : null,
     module_contexts: trimmedModules,
@@ -853,7 +947,7 @@ async function trySemanticHits(ctx, task, limit) {
 }
 async function loadModuleContexts2(ctx, modules) {
   if (modules.length === 0) return [];
-  if (!existsSync13(ctx.paths.modulesContextDir)) return [];
+  if (!existsSync14(ctx.paths.modulesContextDir)) return [];
   const available = new Set(
     (await readdir3(ctx.paths.modulesContextDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name)
   );
@@ -861,7 +955,7 @@ async function loadModuleContexts2(ctx, modules) {
   for (const m of modules) {
     if (!available.has(m)) continue;
     const file = path5.join(ctx.paths.modulesContextDir, m, "context.md");
-    if (existsSync13(file)) {
+    if (existsSync14(file)) {
       out.push({ name: m, content: await readFile3(file, "utf8") });
     }
   }
@@ -870,11 +964,11 @@ async function loadModuleContexts2(ctx, modules) {
 
 // src/tools/code-map.ts
 import { loadCodeMap, queryCodeMap } from "@hiveai/core";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var CodeMapInputSchema = {
-  file: z14.string().optional().describe("Filter to files whose path contains this substring"),
-  symbol: z14.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
-  max_files: z14.number().int().positive().default(40).describe("Cap on returned files")
+  file: z15.string().optional().describe("Filter to files whose path contains this substring"),
+  symbol: z15.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
+  max_files: z15.number().int().positive().default(40).describe("Cap on returned files")
 };
 async function codeMapTool(input, ctx) {
   const map = await loadCodeMap(ctx.paths);
@@ -900,12 +994,12 @@ async function codeMapTool(input, ctx) {
 }
 
 // src/prompts/bootstrap-project.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var BootstrapProjectArgsSchema = {
-  module: z15.string().optional().describe(
+  module: z16.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z15.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z16.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -988,7 +1082,7 @@ ${template}\`\`\`
 
 // src/server.ts
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.2.1";
+var SERVER_VERSION = "0.2.3";
 function jsonResult(data) {
   return {
     content: [
@@ -1077,6 +1171,12 @@ function createHaiveServer(options = {}) {
     MemDeleteInputSchema,
     async (input) => jsonResult(await memDelete(input, context))
   );
+  server.tool(
+    "mem_update",
+    "Update the body, tags, or anchor of an existing memory without changing its id or losing usage history.",
+    MemUpdateInputSchema,
+    async (input) => jsonResult(await memUpdate(input, context))
+  );
   server.tool(
     "mem_pending",
     "List 'proposed' memories awaiting review, sorted by reads (most-read first).",