@hiveai/mcp 0.2.3 → 0.2.6

package/dist/index.js

@@ -129,12 +129,13 @@ import { existsSync as existsSync4 } from "fs";
 import path3 from "path";
 import {
   buildFrontmatter,
+  loadMemoriesFromDir as loadMemoriesFromDir2,
   memoryFilePath,
   serializeMemory
 } from "@hiveai/core";
 import { z as z4 } from "zod";
 var MemSaveInputSchema = {
-  type: z4.enum(["convention", "decision", "gotcha", "architecture", "glossary"]).describe("Kind of memory being saved"),
+  type: z4.enum(["convention", "decision", "gotcha", "architecture", "glossary", "attempt"]).describe("Kind of memory being saved. Use 'attempt' for failed approaches (auto-validated)."),
   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"),
@@ -174,11 +175,24 @@ async function memSave(input, ctx) {
   if (existsSync4(file)) {
     throw new Error(`Memory already exists at ${file}`);
   }
+  let warning;
+  if (existsSync4(ctx.paths.memoriesDir)) {
+    const existing = await loadMemoriesFromDir2(ctx.paths.memoriesDir);
+    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.`;
+    }
+  }
   await writeFile2(file, serializeMemory({ frontmatter, body: input.body }), "utf8");
   return {
     id: frontmatter.id,
     scope: frontmatter.scope,
-    file_path: file
+    file_path: file,
+    ...warning ? { warning } : {}
   };
 }
 
@@ -189,7 +203,8 @@ import {
   extractSnippet,
   getUsage,
   literalMatchesAllTokens,
-  loadMemoriesFromDir as loadMemoriesFromDir2,
+  literalMatchesAnyToken,
+  loadMemoriesFromDir as loadMemoriesFromDir3,
   loadUsageIndex,
   pickSnippetNeedle,
   tokenizeQuery,
@@ -199,7 +214,7 @@ import { z as z5 } from "zod";
 var MemSearchInputSchema = {
   query: z5.string().describe("Substring matched against id, tags, and body"),
   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"),
+  type: z5.enum(["convention", "decision", "gotcha", "architecture", "glossary", "attempt"]).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."),
@@ -214,7 +229,7 @@ async function memSearch(input, ctx) {
   if (!existsSync5(ctx.paths.memoriesDir)) {
     return { matches: [], total: 0, mode: input.semantic ? "literal_fallback" : "literal" };
   }
-  const all = await loadMemoriesFromDir2(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir3(ctx.paths.memoriesDir);
   const filtered = all.filter(({ memory }) => passesFilters(memory.frontmatter, input));
   const usage = await loadUsageIndex(ctx.paths);
   let result;
@@ -250,13 +265,23 @@ function passesFilters(fm, input) {
 }
 function buildLiteralResult(input, filtered, usage) {
   const tokens = tokenizeQuery(input.query);
-  const matched = filtered.filter(({ memory }) => literalMatchesAllTokens(memory, tokens));
   const snippetNeedle = pickSnippetNeedle(input.query);
-  const top = matched.slice(0, input.limit);
+  let andMatched = filtered.filter(({ memory }) => literalMatchesAllTokens(memory, tokens));
+  if (andMatched.length > 0) {
+    const top2 = andMatched.slice(0, input.limit);
+    return {
+      matches: top2.map((loaded) => toHit(loaded, snippetNeedle, usage)),
+      total: andMatched.length,
+      mode: "literal"
+    };
+  }
+  const orMatched = filtered.filter(({ memory }) => literalMatchesAnyToken(memory, tokens));
+  const top = orMatched.slice(0, input.limit);
   return {
     matches: top.map((loaded) => toHit(loaded, snippetNeedle, usage)),
-    total: matched.length,
-    mode: "literal"
+    total: orMatched.length,
+    mode: "literal",
+    notice: `No exact match for all tokens. Showing partial matches (OR fallback) \u2014 ${orMatched.length} result${orMatched.length === 1 ? "" : "s"}.`
   };
 }
 async function trySemanticSearch(ctx, input, filtered, usage) {
@@ -320,7 +345,7 @@ function toHit(loaded, needle, usage) {
 import { writeFile as writeFile3 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir3,
+  loadMemoriesFromDir as loadMemoriesFromDir4,
   serializeMemory as serializeMemory2,
   verifyAnchor
 } from "@hiveai/core";
@@ -336,7 +361,7 @@ async function memVerify(input, ctx) {
       summary: { checked: 0, fresh: 0, stale: 0, anchorless_skipped: 0, updated: 0 }
     };
   }
-  const all = await loadMemoriesFromDir3(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir4(ctx.paths.memoriesDir);
   const targets = input.id ? all.filter((m) => m.memory.frontmatter.id === input.id) : all;
   const results = [];
   let fresh = 0;
@@ -415,7 +440,7 @@ function applyVerification(mem, result) {
 import { writeFile as writeFile4 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir4,
+  loadMemoriesFromDir as loadMemoriesFromDir5,
   loadUsageIndex as loadUsageIndex2,
   recordRejection,
   saveUsageIndex,
@@ -430,13 +455,17 @@ async function memReject(input, ctx) {
   if (!existsSync7(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const memories = await loadMemoriesFromDir4(ctx.paths.memoriesDir);
+  const memories = await loadMemoriesFromDir5(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}".`);
   await writeFile4(
     loaded.filePath,
     serializeMemory3({
-      frontmatter: { ...loaded.memory.frontmatter, status: "rejected" },
+      frontmatter: {
+        ...loaded.memory.frontmatter,
+        status: "rejected",
+        stale_reason: input.reason ?? loaded.memory.frontmatter.stale_reason ?? null
+      },
       body: loaded.memory.body
     }),
     "utf8"
@@ -462,7 +491,7 @@ import {
   deriveConfidence as deriveConfidence2,
   getUsage as getUsage2,
   inferModulesFromPaths,
-  loadMemoriesFromDir as loadMemoriesFromDir5,
+  loadMemoriesFromDir as loadMemoriesFromDir6,
   loadUsageIndex as loadUsageIndex3,
   memoryMatchesAnchorPaths,
   trackReads as trackReads2
@@ -484,7 +513,7 @@ async function memForFiles(input, ctx) {
       module_contexts: await loadModuleContexts(ctx, inferred, input.include_module_contexts)
     };
   }
-  const all = await loadMemoriesFromDir5(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir6(ctx.paths.memoriesDir);
   const usage = await loadUsageIndex3(ctx.paths);
   const seen = /* @__PURE__ */ new Set();
   const byAnchor = [];
@@ -563,7 +592,7 @@ import { existsSync as existsSync9 } from "fs";
 import {
   deriveConfidence as deriveConfidence3,
   getUsage as getUsage3,
-  loadMemoriesFromDir as loadMemoriesFromDir6,
+  loadMemoriesFromDir as loadMemoriesFromDir7,
   loadUsageIndex as loadUsageIndex4
 } from "@hiveai/core";
 import { z as z9 } from "zod";
@@ -574,7 +603,7 @@ async function memGet(input, ctx) {
   if (!existsSync9(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir6(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir7(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 fm = found.memory.frontmatter;
@@ -606,7 +635,7 @@ async function memGet(input, ctx) {
 import { existsSync as existsSync10 } from "fs";
 import { unlink } from "fs/promises";
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir7,
+  loadMemoriesFromDir as loadMemoriesFromDir8,
   loadUsageIndex as loadUsageIndex5,
   saveUsageIndex as saveUsageIndex2
 } from "@hiveai/core";
@@ -619,7 +648,7 @@ async function memDelete(input, ctx) {
   if (!existsSync10(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir7(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir8(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}".`);
   await unlink(found.filePath);
@@ -638,7 +667,7 @@ async function memDelete(input, ctx) {
 // 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 { loadMemoriesFromDir as loadMemoriesFromDir9, 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"),
@@ -654,7 +683,7 @@ 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 memories = await loadMemoriesFromDir9(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;
@@ -699,7 +728,7 @@ async function memUpdate(input, ctx) {
 import { existsSync as existsSync12 } from "fs";
 import {
   getUsage as getUsage4,
-  loadMemoriesFromDir as loadMemoriesFromDir9,
+  loadMemoriesFromDir as loadMemoriesFromDir10,
   loadUsageIndex as loadUsageIndex6
 } from "@hiveai/core";
 import { z as z12 } from "zod";
@@ -708,7 +737,7 @@ var MemPendingInputSchema = {
 };
 async function memPending(input, ctx) {
   if (!existsSync12(ctx.paths.memoriesDir)) return { pending: [] };
-  const all = await loadMemoriesFromDir9(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir10(ctx.paths.memoriesDir);
   const usage = await loadUsageIndex6(ctx.paths);
   const now = Date.now();
   const proposed = all.filter(({ memory }) => {
@@ -742,7 +771,7 @@ async function memPending(input, ctx) {
 import { writeFile as writeFile6 } from "fs/promises";
 import { existsSync as existsSync13 } from "fs";
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir10,
+  loadMemoriesFromDir as loadMemoriesFromDir11,
   serializeMemory as serializeMemory5
 } from "@hiveai/core";
 import { z as z13 } from "zod";
@@ -753,7 +782,7 @@ async function memApprove(input, ctx) {
   if (!existsSync13(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir10(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir11(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;
@@ -770,10 +799,60 @@ async function memApprove(input, ctx) {
   };
 }
 
-// src/tools/get-briefing.ts
-import { readFile as readFile3, readdir as readdir3 } from "fs/promises";
+// src/tools/mem-tried.ts
+import { mkdir as mkdir3, writeFile as writeFile7 } from "fs/promises";
 import { existsSync as existsSync14 } from "fs";
 import path5 from "path";
+import {
+  buildFrontmatter as buildFrontmatter2,
+  memoryFilePath as memoryFilePath2,
+  serializeMemory as serializeMemory6
+} from "@hiveai/core";
+import { z as z14 } from "zod";
+var MemTriedInputSchema = {
+  what: z14.string().min(1).describe("Brief description of the approach that was tried"),
+  why_failed: z14.string().min(1).describe("Why it failed or why it should NOT be used"),
+  instead: z14.string().optional().describe("What to use or do instead (recommended alternative)"),
+  scope: z14.enum(["personal", "team", "module"]).default("personal").describe("Visibility scope"),
+  module: z14.string().optional().describe("Module name (required when scope=module)"),
+  tags: z14.array(z14.string()).default([]).describe("Tags for filtering"),
+  paths: z14.array(z14.string()).default([]).describe("Anchor file paths this applies to"),
+  author: z14.string().optional().describe("Author handle or email")
+};
+async function memTried(input, ctx) {
+  if (!existsSync14(ctx.paths.haiveDir)) {
+    throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`);
+  }
+  const slug = input.what.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().split(/\s+/).slice(0, 5).join("-");
+  const baseFm = buildFrontmatter2({
+    type: "attempt",
+    slug,
+    scope: input.scope,
+    module: input.module,
+    tags: input.tags,
+    paths: input.paths,
+    author: input.author
+  });
+  const frontmatter = { ...baseFm, status: "validated" };
+  const lines = [`# ${input.what}`, ""];
+  lines.push(`**Why it failed / do NOT use:** ${input.why_failed}`);
+  if (input.instead) {
+    lines.push("", `**Instead, use:** ${input.instead}`);
+  }
+  const body = lines.join("\n") + "\n";
+  const file = memoryFilePath2(ctx.paths, frontmatter.scope, frontmatter.id, frontmatter.module);
+  await mkdir3(path5.dirname(file), { recursive: true });
+  if (existsSync14(file)) {
+    throw new Error(`Memory already exists at ${file}`);
+  }
+  await writeFile7(file, serializeMemory6({ frontmatter, body }), "utf8");
+  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";
+import { existsSync as existsSync15 } from "fs";
+import path6 from "path";
 import {
   allocateBudget,
   deriveConfidence as deriveConfidence4,
@@ -781,36 +860,43 @@ import {
   getUsage as getUsage5,
   inferModulesFromPaths as inferModulesFromPaths2,
   literalMatchesAllTokens as literalMatchesAllTokens2,
-  loadMemoriesFromDir as loadMemoriesFromDir11,
+  loadMemoriesFromDir as loadMemoriesFromDir12,
   loadUsageIndex as loadUsageIndex7,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
   tokenizeQuery as tokenizeQuery2,
   trackReads as trackReads3,
   truncateToTokens
 } from "@hiveai/core";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var GetBriefingInputSchema = {
-  task: z14.string().optional().describe(
+  task: z15.string().optional().describe(
     "What you are about to do, in 1\u20132 sentences. Used to rank relevant memories semantically."
   ),
-  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(
+  files: z15.array(z15.string()).default([]).describe("Project-relative file paths the agent is currently looking at or about to edit"),
+  max_tokens: z15.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: 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(
+  max_memories: z15.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
+  include_project_context: z15.boolean().default(true),
+  include_module_contexts: z15.boolean().default(true),
+  semantic: z15.boolean().default(true).describe(
     "Use semantic ranking when a task is provided (requires `haive embeddings index`)."
   ),
-  track: z14.boolean().default(true).describe("Increment read_count on returned memories")
+  include_stale: z15.boolean().default(false).describe("Include stale memories (excluded by default \u2014 they may be outdated)"),
+  track: z15.boolean().default(true).describe("Increment read_count on returned memories")
 };
 async function getBriefing(input, ctx) {
   const inferred = inferModulesFromPaths2(input.files);
   const memories = [];
   let searchMode = "literal";
-  if (existsSync14(ctx.paths.memoriesDir)) {
-    const allMemories = await loadMemoriesFromDir11(ctx.paths.memoriesDir);
+  if (existsSync15(ctx.paths.memoriesDir)) {
+    const allLoaded = await loadMemoriesFromDir12(ctx.paths.memoriesDir);
+    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;
+      return true;
+    });
     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) {
@@ -881,10 +967,13 @@ async function getBriefing(input, ctx) {
       await trackReads3(ctx.paths, memories.map((m) => m.id));
     }
   }
-  const projectContext = input.include_project_context && existsSync14(ctx.paths.projectContext) ? await readFile3(ctx.paths.projectContext, "utf8") : "";
+  const projectContext = input.include_project_context && existsSync15(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");
+  const memoriesText = memories.map((m) => {
+    const unverified = m.status === "proposed" ? " [UNVERIFIED \u2014 not yet validated]" : "";
+    return `### ${m.id} (${m.scope}/${m.type}, ${m.confidence})${unverified}
+${m.body.trim()}`;
+  }).join("\n\n---\n\n");
   const slices = allocateBudget(
     [
       { key: "project", text: projectContext, weight: 3, mode: "head" },
@@ -952,15 +1041,15 @@ async function trySemanticHits(ctx, task, limit) {
 }
 async function loadModuleContexts2(ctx, modules) {
   if (modules.length === 0) return [];
-  if (!existsSync14(ctx.paths.modulesContextDir)) return [];
+  if (!existsSync15(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 = path5.join(ctx.paths.modulesContextDir, m, "context.md");
-    if (existsSync14(file)) {
+    const file = path6.join(ctx.paths.modulesContextDir, m, "context.md");
+    if (existsSync15(file)) {
       out.push({ name: m, content: await readFile3(file, "utf8") });
     }
   }
@@ -969,11 +1058,11 @@ async function loadModuleContexts2(ctx, modules) {
 
 // src/tools/code-map.ts
 import { loadCodeMap, queryCodeMap } from "@hiveai/core";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var CodeMapInputSchema = {
-  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")
+  file: z16.string().optional().describe("Filter to files whose path contains this substring"),
+  symbol: z16.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
+  max_files: z16.number().int().positive().default(40).describe("Cap on returned files")
 };
 async function codeMapTool(input, ctx) {
   const map = await loadCodeMap(ctx.paths);
@@ -999,12 +1088,12 @@ async function codeMapTool(input, ctx) {
 }
 
 // src/prompts/bootstrap-project.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var BootstrapProjectArgsSchema = {
-  module: z16.string().optional().describe(
+  module: z17.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z16.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z17.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -1087,7 +1176,7 @@ ${template}\`\`\`
 
 // src/server.ts
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.2.3";
+var SERVER_VERSION = "0.2.6";
 function jsonResult(data) {
   return {
     content: [
@@ -1194,6 +1283,12 @@ function createHaiveServer(options = {}) {
     MemApproveInputSchema,
     async (input) => jsonResult(await memApprove(input, context))
   );
+  server.tool(
+    "mem_tried",
+    "Record a failed approach as negative knowledge (type=attempt, auto-validated). Use this whenever you tried something and it didn't work \u2014 saves future agents from repeating the mistake.",
+    MemTriedInputSchema,
+    async (input) => jsonResult(await memTried(input, context))
+  );
   server.prompt(
     "bootstrap_project",
     "Instructions for the AI client to analyze the project and save the context.",