@hiveai/mcp 0.9.0 → 0.9.3

package/README.md

@@ -8,11 +8,15 @@ Connect your AI coding tools to a shared, version-controlled knowledge base. Eve
 
 ## Install
 
+**Recommended:** install only `@hiveai/cli`. The MCP server is **bundled** inside `haive` — configure clients with `command: "haive"` and `args: ["mcp", "--stdio"]` (see `@hiveai/cli` README).
+
+Standalone package (legacy / advanced):
+
 ```bash
 npm install -g @hiveai/mcp
 ```
 
-Also install the CLI to manage memories:
+You usually still want the CLI for `haive init`, `haive sync`, etc.:
 
 ```bash
 npm install -g @hiveai/cli
@@ -50,8 +54,8 @@ Add to `~/.claude.json` (global) or `.claude/settings.json` (per-project):
 {
   "mcpServers": {
     "haive": {
-      "command": "haive-mcp",
-      "args": ["--root", "/absolute/path/to/your/project"]
+      "command": "haive",
+      "args": ["mcp", "--stdio", "--root", "/absolute/path/to/your/project"]
     }
   }
 }
@@ -65,8 +69,8 @@ Add to `~/.cursor/mcp.json`:
 {
   "mcpServers": {
     "haive": {
-      "command": "haive-mcp",
-      "args": ["--root", "/absolute/path/to/your/project"]
+      "command": "haive",
+      "args": ["mcp", "--stdio", "--root", "/absolute/path/to/your/project"]
     }
   }
 }
@@ -75,7 +79,7 @@ Add to `~/.cursor/mcp.json`:
 ### VS Code
 
 ```bash
-code --add-mcp '{"name":"haive","command":"haive-mcp","args":["--root","/absolute/path/to/project"]}'
+code --add-mcp '{"name":"haive","command":"haive","args":["mcp","--stdio","--root","/absolute/path/to/project"]}'
 ```
 
 ### Project-scoped (auto-detected)
@@ -86,8 +90,9 @@ Add a `.mcp.json` at the project root:
 {
   "mcpServers": {
     "haive": {
-      "command": "haive-mcp",
-      "args": ["--root", "."]
+      "command": "haive",
+      "args": ["mcp", "--stdio"],
+      "env": { "HAIVE_PROJECT_ROOT": "/absolute/path/to/your/project" }
     }
   }
 }

package/dist/index.js

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 
-// src/index.ts
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/context.ts
 import { findProjectRoot, resolveHaivePaths } from "@hiveai/core";
@@ -142,7 +140,9 @@ var MemSaveInputSchema = {
   ),
   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"),
+  scope: z4.enum(["personal", "team", "module"]).optional().describe(
+    "Visibility scope: personal | team | module. When omitted, falls back to defaultScope in haive.config.json (default: personal)."
+  ),
   module: z4.string().optional().describe("Module name (required when scope=module)"),
   tags: z4.array(z4.string()).default([]).describe("Tags for filtering"),
   domain: z4.string().optional().describe("Domain (e.g. transactions, billing)"),
@@ -157,6 +157,30 @@ var MemSaveInputSchema = {
 function bodyHash(body) {
   return createHash("sha256").update(body.trim()).digest("hex").slice(0, 12);
 }
+var WORD_RE = /\b[a-z0-9]{3,}\b/gi;
+function bodyTokenSet(body) {
+  const raw = body.toLowerCase().match(WORD_RE) ?? [];
+  return new Set(raw);
+}
+function maxBodySimilarity(incomingTokens, memories, scope, type, excludeIds) {
+  if (incomingTokens.size < 6) return null;
+  let best = null;
+  const skip = excludeIds ?? /* @__PURE__ */ new Set();
+  for (const { memory } of memories) {
+    const fm = memory.frontmatter;
+    if (skip.has(fm.id)) continue;
+    if (fm.scope !== scope || fm.type !== type) continue;
+    if (fm.status === "rejected" || fm.status === "deprecated") continue;
+    const other = bodyTokenSet(memory.body);
+    if (other.size === 0) continue;
+    let inter = 0;
+    for (const t of incomingTokens) if (other.has(t)) inter++;
+    const uni = incomingTokens.size + other.size - inter;
+    const j = uni === 0 ? 0 : inter / uni;
+    if (j >= 0.72 && (!best || j > best.score)) best = { score: j, id: fm.id };
+  }
+  return best;
+}
 async function memSave(input, ctx) {
   if (!existsSync4(ctx.paths.haiveDir)) {
     throw new Error(
@@ -164,24 +188,40 @@ async function memSave(input, ctx) {
     );
   }
   const existing = existsSync4(ctx.paths.memoriesDir) ? await loadMemoriesFromDir2(ctx.paths.memoriesDir) : [];
+  const haiveConfig = await loadConfig(ctx.paths);
+  const resolvedScope = input.scope ?? haiveConfig.defaultScope ?? "personal";
   const invalidPaths = input.paths.filter(
     (p) => !existsSync4(path3.resolve(ctx.paths.root, p))
   );
   const incomingHash = bodyHash(input.body);
   const hashDuplicate = existing.find(
-    ({ memory }) => bodyHash(memory.body) === incomingHash && memory.frontmatter.scope === input.scope
+    ({ memory }) => bodyHash(memory.body) === incomingHash && memory.frontmatter.scope === resolvedScope
   );
   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.`
     );
   }
+  const incomingTokens = bodyTokenSet(input.body);
+  function bodySimilarWarnings(excludeIds) {
+    const dup = maxBodySimilarity(incomingTokens, existing, resolvedScope, input.type, excludeIds);
+    if (!dup?.id) return {};
+    const body_similar = {
+      id: dup.id,
+      score: Math.round(dup.score * 100) / 100
+    };
+    return {
+      similarityWarning: `Body is ~${Math.round(dup.score * 100)}% similar (token overlap) to existing "${dup.id}" \u2014 consolidate if redundant.`,
+      body_similar
+    };
+  }
   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)
+      ({ memory }) => memory.frontmatter.topic === input.topic && memory.frontmatter.scope === resolvedScope && (!input.module || memory.frontmatter.module === input.module)
     );
     if (topicMatch) {
       const fm = topicMatch.memory.frontmatter;
+      const { similarityWarning: simW, body_similar: bs } = bodySimilarWarnings(/* @__PURE__ */ new Set([fm.id]));
       const newFrontmatter = {
         ...fm,
         body: input.body,
@@ -198,18 +238,22 @@ async function memSave(input, ctx) {
         serializeMemory({ frontmatter: newFrontmatter, body: input.body }),
         "utf8"
       );
+      const mergedTw = [
+        invalidPaths.length > 0 ? `Anchor path(s) not found in project: ${invalidPaths.join(", ")}. They will be marked stale by haive sync.` : null,
+        simW ?? null
+      ].filter(Boolean).join(" \u2014 ") || void 0;
       return {
         id: fm.id,
         scope: fm.scope,
         file_path: topicMatch.filePath,
         action: "updated",
         revision_count: newFrontmatter.revision_count,
-        ...invalidPaths.length > 0 ? { invalid_paths: invalidPaths, warning: `Anchor path(s) not found in project: ${invalidPaths.join(", ")}. They will be marked stale by haive sync.` } : {}
+        ...mergedTw ? { warning: mergedTw } : {},
+        ...bs ? { body_similar: bs } : {},
+        ...invalidPaths.length > 0 ? { invalid_paths: invalidPaths } : {}
       };
     }
   }
-  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,
@@ -248,9 +292,11 @@ async function memSave(input, ctx) {
     }
   }
   await writeFile2(file, serializeMemory({ frontmatter, body: input.body }), "utf8");
+  const { similarityWarning: simWarnNew, body_similar: bsNew } = bodySimilarWarnings();
   const finalWarning = [
     invalidPaths.length > 0 ? `Anchor path(s) not found in project: ${invalidPaths.join(", ")}. They will be marked stale by \`haive sync\`.` : null,
-    warning ?? null
+    warning ?? null,
+    simWarnNew ?? null
   ].filter(Boolean).join(" \u2014 ") || void 0;
   return {
     id: frontmatter.id,
@@ -259,6 +305,7 @@ async function memSave(input, ctx) {
     action: "created",
     ...finalWarning ? { warning: finalWarning } : {},
     ...similar_found ? { similar_found } : {},
+    ...bsNew ? { body_similar: bsNew } : {},
     ...invalidPaths.length > 0 ? { invalid_paths: invalidPaths } : {}
   };
 }
@@ -1294,6 +1341,7 @@ import {
   DEFAULT_AUTO_PROMOTE_RULE,
   deriveConfidence as deriveConfidence4,
   estimateTokens,
+  extractActionsBriefBody,
   getUsage as getUsage5,
   inferModulesFromPaths as inferModulesFromPaths2,
   isAutoPromoteEligible,
@@ -1306,6 +1354,7 @@ import {
   loadUsageIndex as loadUsageIndex7,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
   queryCodeMap,
+  resolveBriefingBudget,
   serializeMemory as serializeMemory9,
   tokenizeQuery as tokenizeQuery2,
   trackReads as trackReads3,
@@ -1328,17 +1377,29 @@ var GetBriefingInputSchema = {
   ),
   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)."
+  format: z17.enum(["full", "compact", "actions"]).default("full").describe(
+    "Output format: 'full' returns memory bodies (honors token budget via truncation); 'compact' returns a 1-line summary per memory (call mem_get for detail); 'actions' squeezes bodies to actionable bullet lines \u2014 fewer tokens vs full."
   ),
   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."
   ),
   min_semantic_score: z17.number().min(0).max(1).default(0).describe(
     "Drop semantic-only memory hits whose cosine score is below this threshold. Useful to avoid weakly-related noise when the task is short or the corpus is broad. Has no effect on memories matched via anchor/module/literal \u2014 those are always kept. Try 0.25\u20130.4 for stricter matching."
+  ),
+  budget_preset: z17.enum(["quick", "balanced", "deep"]).optional().describe(
+    "Shortcut token budget: 'quick' minimizes tokens/skip module CONTEXT slices; 'balanced' mirrors historical defaults; 'deep' uses a larger briefing. When set, overrides max_tokens, max_memories, and include_module_contexts."
   )
 };
+var GetBriefingZod = z17.object(GetBriefingInputSchema);
 async function getBriefing(input, ctx) {
+  const resolvedBudget = resolveBriefingBudget(input.budget_preset, {
+    max_tokens: input.max_tokens,
+    max_memories: input.max_memories,
+    include_module_contexts: input.include_module_contexts
+  });
+  const briefingMaxTokens = resolvedBudget.max_tokens;
+  const briefingMaxMemories = resolvedBudget.max_memories;
+  const briefingIncludeModules = resolvedBudget.include_module_contexts;
   const inferred = inferModulesFromPaths2(input.files);
   const memories = [];
   let searchMode = "literal";
@@ -1450,8 +1511,8 @@ async function getBriefing(input, ctx) {
       const sb = reasonScore(b) + confidenceScore(b) + (b.semantic_score ?? 0);
       return sb - sa;
     });
-    for (const mem of ranked.slice(0, input.max_memories)) {
-      if (seen.size >= input.max_memories * 2) break;
+    for (const mem of ranked.slice(0, briefingMaxMemories)) {
+      if (seen.size >= briefingMaxMemories * 2) break;
       const loaded = byId.get(mem.id);
       if (!loaded) continue;
       for (const relId of loaded.memory.frontmatter.related_ids ?? []) {
@@ -1460,12 +1521,13 @@ async function getBriefing(input, ctx) {
         if (related) addOrUpdate(related, "anchor", void 0, "partial");
       }
     }
-    memories.push(...ranked.slice(0, input.max_memories));
+    memories.push(...ranked.slice(0, briefingMaxMemories));
     if (input.track && memories.length > 0) {
       await trackReads3(ctx.paths, memories.map((m) => m.id));
       const freshUsage = await loadUsageIndex7(ctx.paths);
+      const cfg = await loadConfig3(ctx.paths);
       const rule = {
-        minReads: DEFAULT_AUTO_PROMOTE_RULE.minReads,
+        minReads: cfg.autoPromoteMinReads ?? DEFAULT_AUTO_PROMOTE_RULE.minReads,
         maxRejections: DEFAULT_AUTO_PROMOTE_RULE.maxRejections
       };
       for (const m of memories) {
@@ -1539,7 +1601,7 @@ async function getBriefing(input, ctx) {
       }
     }
   }
-  const moduleContents = input.include_module_contexts ? await loadModuleContexts2(ctx, inferred) : [];
+  const moduleContents = briefingIncludeModules ? await loadModuleContexts2(ctx, inferred) : [];
   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}
@@ -1557,7 +1619,7 @@ ${m.content}`).join("\n\n---\n\n"),
       },
       { key: "memories", text: memoriesText, weight: 4, mode: "head" }
     ],
-    input.max_tokens
+    briefingMaxTokens
   );
   const projectSlice = slices.find((s) => s.key === "project");
   const modulesSlice = slices.find((s) => s.key === "modules");
@@ -1599,7 +1661,10 @@ ${m.content}`).join("\n\n---\n\n"),
     const createdAt = loaded?.memory.frontmatter.created_at ?? (/* @__PURE__ */ new Date()).toISOString();
     if (isDecaying(u, createdAt)) decayWarnings.push(m.id);
   }
-  const outputMemories = input.format === "compact" ? trimmedMemories.map((m) => ({ ...m, body: compactSummary(m.body) })) : trimmedMemories;
+  const outputMemories = input.format === "compact" ? trimmedMemories.map((m) => ({ ...m, body: compactSummary(m.body) })) : input.format === "actions" ? trimmedMemories.map((m) => ({
+    ...m,
+    body: extractActionsBriefBody(m.body)
+  })) : trimmedMemories;
   let symbolLocations;
   const symbolsToLookup = new Set(input.symbols);
   for (const m of outputMemories) {
@@ -1721,6 +1786,11 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
         "After completing the task: capture new gotchas with mem_observe, failed approaches with mem_tried, validated patterns with mem_save."
       );
     }
+    if (outputMemories.length > 2 && !input.budget_preset && input.task && !hints.some((h) => h.includes("budget_preset"))) {
+      hints.push(
+        "For tighter token budgets on small tasks pass budget_preset:'quick'; for refactor-sized work use budget_preset:'deep'."
+      );
+    }
   }
   return {
     ...input.task ? { task: input.task } : {},
@@ -1743,7 +1813,8 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
     ...hints.length > 0 ? { hints } : {},
     estimated_tokens: totalTokens,
     budget: {
-      max_tokens: input.max_tokens,
+      max_tokens: briefingMaxTokens,
+      ...input.budget_preset ? { preset_applied: input.budget_preset } : {},
       spent: {
         project: projectSlice.estimatedTokens,
         modules: modulesSlice.estimatedTokens,
@@ -1956,7 +2027,7 @@ var MemRelevantToInputSchema = {
   files: z21.array(z21.string()).default([]).describe("Optional: files you are about to edit \u2014 surfaces anchored memories."),
   limit: z21.number().int().positive().max(30).default(8).describe("Cap on returned memories."),
   min_semantic_score: z21.number().min(0).max(1).default(0.25).describe("Drop weakly-related semantic hits below this cosine threshold."),
-  format: z21.enum(["full", "compact"]).default("full").describe("'compact' = id + 1-line summary; 'full' = complete bodies.")
+  format: z21.enum(["full", "compact", "actions"]).default("full").describe("'compact' = id + 1-line summary; 'full' = complete bodies; 'actions' = bullet-first excerpts.")
 };
 async function memRelevantTo(input, ctx) {
   const briefingInput = {
@@ -2813,7 +2884,9 @@ async function patternDetect(input, ctx) {
     for (const file of configFiles.slice(0, 5)) {
       const diff = gitFileDiff(ctx.paths.root, file, input.since_days);
       if (!diff) continue;
-      const slug = path11.basename(file).replace(/\.[^.]+$/, "").replace(/[^a-z0-9]/gi, "-").toLowerCase().slice(0, 40);
+      const parentDir = path11.basename(path11.dirname(file));
+      const baseName = path11.basename(file).replace(/\.[^.]+$/, "");
+      const slug = `${parentDir}-${baseName}`.replace(/[^a-z0-9]/gi, "-").toLowerCase().slice(0, 40);
       matches.push({
         kind: "config_change",
         signal: `Config file modified: ${file}`,
@@ -3212,7 +3285,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.9.0";
+var SERVER_VERSION = "0.9.3";
 function jsonResult(data) {
   return {
     content: [
@@ -3378,7 +3451,8 @@ function createHaiveServer(options = {}) {
       "  task    \u2014 what you are about to do (1\u20132 sentences) \u2014 ALWAYS provide this",
       "  files   \u2014 files you are about to edit \u2014 surfaces anchored memories",
       "  symbols \u2014 symbol names to look up in the code-map (e.g. ['PaymentService'])",
-      "  format  \u2014 'full' (default) | 'compact' (1-line summaries, use when token budget is tight)",
+      "  format  \u2014 'full' (default) | 'compact' (1-line) | 'actions' (bullet-first excerpts)",
+      "  budget_preset \u2014 'quick' | 'balanced' | 'deep' \u2014 scales max_tokens/memories/module contexts",
       "",
       "EXAMPLE USAGE:",
       "  get_briefing({ task: 'add a Stripe payment integration', files: ['src/payments/'], symbols: ['PaymentService'] })",
@@ -3684,6 +3758,7 @@ function createHaiveServer(options = {}) {
       "  files   \u2014 files you'll edit (surfaces anchored memories)",
       "  limit   \u2014 cap on returned memories (default 8)",
       "  min_semantic_score \u2014 drop weak semantic hits below this cosine (default 0.25)",
+      "  format \u2014 'full' | 'compact' | 'actions' (inherits get_briefing memory framing)",
       "",
       "RETURNS: { task, search_mode, memories: [...], hints?: [...], empty?: true }"
     ].join("\n"),
@@ -3941,9 +4016,13 @@ function createHaiveServer(options = {}) {
   );
   return { server, context, tracker };
 }
-
-// src/index.ts
-function parseArgs(argv) {
+function parseMcpCliArgs(argv) {
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--version" || arg === "-V") {
+      return { versionOnly: true };
+    }
+  }
   const out = {};
   for (let i = 2; i < argv.length; i++) {
     const arg = argv[i];
@@ -3953,18 +4032,26 @@ function parseArgs(argv) {
       out.root = arg.slice("--root=".length);
     }
   }
-  return out;
+  return { root: out.root, versionOnly: false };
 }
-async function main() {
-  const { root } = parseArgs(process.argv);
-  const { server, context } = createHaiveServer({ root });
+function printHaiveMcpVersion() {
+  console.log(SERVER_VERSION);
+}
+async function runHaiveMcpStdio(options) {
+  const { server, context } = createHaiveServer({ root: options.root });
   console.error(
     `[haive-mcp] starting server v${SERVER_VERSION} (project root: ${context.paths.root})`
   );
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
+  await server.connect(new StdioServerTransport());
+}
+
+// src/index.ts
+var parsed = parseMcpCliArgs(process.argv);
+if (parsed.versionOnly) {
+  printHaiveMcpVersion();
+  process.exit(0);
 }
-main().catch((err) => {
+runHaiveMcpStdio({ root: parsed.root }).catch((err) => {
   console.error("[haive-mcp] fatal:", err instanceof Error ? err.message : err);
   process.exit(1);
 });