@hiveai/mcp 0.1.1 → 0.2.1

package/dist/index.js

@@ -469,10 +469,11 @@ async function memForFiles(input, ctx) {
   }
   for (const loaded of all) {
     if (seen.has(loaded.memory.frontmatter.id)) continue;
-    const mod = loaded.memory.frontmatter.module;
-    if (mod && inferred.includes(mod)) {
+    const fm = loaded.memory.frontmatter;
+    const moduleHit = fm.module && inferred.includes(fm.module) || fm.tags.some((t) => inferred.includes(t));
+    if (moduleHit) {
       byModule.push(toMatch(loaded, "module", usage));
-      seen.add(loaded.memory.frontmatter.id);
+      seen.add(fm.id);
     }
   }
   for (const loaded of all) {
@@ -680,13 +681,236 @@ async function memApprove(input, ctx) {
   };
 }
 
-// src/prompts/bootstrap-project.ts
+// src/tools/get-briefing.ts
+import { readFile as readFile3, readdir as readdir3 } from "fs/promises";
+import { existsSync as existsSync13 } from "fs";
+import path5 from "path";
+import {
+  allocateBudget,
+  deriveConfidence as deriveConfidence4,
+  estimateTokens,
+  getUsage as getUsage5,
+  inferModulesFromPaths as inferModulesFromPaths2,
+  literalMatchesAllTokens as literalMatchesAllTokens2,
+  loadMemoriesFromDir as loadMemoriesFromDir10,
+  loadUsageIndex as loadUsageIndex7,
+  memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
+  tokenizeQuery as tokenizeQuery2,
+  trackReads as trackReads3,
+  truncateToTokens
+} from "@hiveai/core";
 import { z as z13 } from "zod";
+var GetBriefingInputSchema = {
+  task: z13.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(
+    "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(
+    "Use semantic ranking when a task is provided (requires `haive embeddings index`)."
+  ),
+  track: z13.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);
+    const usage = await loadUsageIndex7(ctx.paths);
+    const semanticHits = input.task && input.semantic ? await trySemanticHits(ctx, input.task, allMemories.length * 2) : null;
+    const seen = /* @__PURE__ */ new Map();
+    const addOrUpdate = (loaded, reason, score) => {
+      const fm = loaded.memory.frontmatter;
+      const existing = seen.get(fm.id);
+      if (existing) {
+        if (!existing.reasons.includes(reason)) existing.reasons.push(reason);
+        if (score !== void 0 && (existing.semantic_score ?? 0) < score) {
+          existing.semantic_score = score;
+        }
+        return;
+      }
+      const u = getUsage5(usage, fm.id);
+      seen.set(fm.id, {
+        id: fm.id,
+        scope: fm.scope,
+        type: fm.type,
+        ...fm.module ? { module: fm.module } : {},
+        tags: fm.tags,
+        status: fm.status,
+        confidence: deriveConfidence4(fm, u),
+        read_count: u.read_count,
+        reasons: [reason],
+        ...score !== void 0 ? { semantic_score: score } : {},
+        body: loaded.memory.body,
+        file_path: loaded.filePath
+      });
+    };
+    if (input.files.length > 0) {
+      for (const loaded of allMemories) {
+        if (memoryMatchesAnchorPaths2(loaded.memory, input.files)) addOrUpdate(loaded, "anchor");
+      }
+      for (const loaded of allMemories) {
+        const fm = loaded.memory.frontmatter;
+        if (fm.module && inferred.includes(fm.module)) addOrUpdate(loaded, "module");
+        if (fm.domain && inferred.includes(fm.domain)) addOrUpdate(loaded, "domain");
+        if (fm.tags.some((t) => inferred.includes(t))) addOrUpdate(loaded, "module");
+      }
+    }
+    if (input.task) {
+      const tokens = tokenizeQuery2(input.task);
+      for (const loaded of allMemories) {
+        if (literalMatchesAllTokens2(loaded.memory, tokens)) {
+          addOrUpdate(loaded, "semantic");
+        }
+      }
+      if (semanticHits) {
+        const byId = new Map(allMemories.map((m) => [m.memory.frontmatter.id, m]));
+        for (const hit of semanticHits) {
+          const loaded = byId.get(hit.id);
+          if (loaded) addOrUpdate(loaded, "semantic", hit.score);
+        }
+      }
+    }
+    const ranked = [...seen.values()].sort((a, b) => {
+      const reasonScore = (m) => (m.reasons.includes("anchor") ? 4 : 0) + (m.reasons.includes("module") ? 2 : 0) + (m.reasons.includes("semantic") ? 2 : 0) + (m.reasons.includes("domain") ? 1 : 0);
+      const confidenceScore = (m) => m.confidence === "authoritative" ? 4 : m.confidence === "trusted" ? 3 : m.confidence === "low" ? 1 : m.confidence === "stale" ? -2 : 0;
+      const sa = reasonScore(a) + confidenceScore(a) + (a.semantic_score ?? 0);
+      const sb = reasonScore(b) + confidenceScore(b) + (b.semantic_score ?? 0);
+      return sb - sa;
+    });
+    memories.push(...ranked.slice(0, input.max_memories));
+    if (input.track && memories.length > 0) {
+      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 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 slices = allocateBudget(
+    [
+      { key: "project", text: projectContext, weight: 3, mode: "head" },
+      {
+        key: "modules",
+        text: moduleContents.map((m) => `## ${m.name}
+${m.content}`).join("\n\n---\n\n"),
+        weight: 3,
+        mode: "head"
+      },
+      { key: "memories", text: memoriesText, weight: 4, mode: "head" }
+    ],
+    input.max_tokens
+  );
+  const projectSlice = slices.find((s) => s.key === "project");
+  const modulesSlice = slices.find((s) => s.key === "modules");
+  const memoriesSlice = slices.find((s) => s.key === "memories");
+  const trimmedModules = [];
+  if (modulesSlice.text.length > 0 && moduleContents.length > 0) {
+    const subSlices = allocateBudget(
+      moduleContents.map((m) => ({ key: m.name, text: m.content, weight: 1, mode: "head" })),
+      modulesSlice.allocatedTokens
+    );
+    for (const m of moduleContents) {
+      const sub = subSlices.find((s) => s.key === m.name);
+      trimmedModules.push({ name: m.name, content: sub.text, truncated: sub.truncated });
+    }
+  }
+  const trimmedMemoriesText = memoriesSlice.text;
+  const trimmedMemories = memories.map((m) => {
+    if (!memoriesSlice.truncated) return m;
+    const tokensPer = Math.floor(memoriesSlice.allocatedTokens / Math.max(1, memories.length));
+    const t = truncateToTokens(m.body, { maxTokens: tokensPer, mode: "head" });
+    return { ...m, body: t.text };
+  });
+  const totalTokens = projectSlice.estimatedTokens + modulesSlice.estimatedTokens + memoriesSlice.estimatedTokens;
+  return {
+    ...input.task ? { task: input.task } : {},
+    inferred_modules: inferred,
+    project_context: projectContext ? { content: projectSlice.text, truncated: projectSlice.truncated } : null,
+    module_contexts: trimmedModules,
+    memories: trimmedMemories,
+    estimated_tokens: totalTokens,
+    budget: {
+      max_tokens: input.max_tokens,
+      spent: {
+        project: projectSlice.estimatedTokens,
+        modules: modulesSlice.estimatedTokens,
+        memories: memoriesSlice.estimatedTokens
+      }
+    }
+  };
+}
+async function trySemanticHits(ctx, task, limit) {
+  let mod;
+  try {
+    mod = await import("@hiveai/embeddings");
+  } catch {
+    return null;
+  }
+  const result = await mod.semanticSearch(ctx.paths, task, { limit });
+  if (!result) return null;
+  return result.hits.map((h) => ({ id: h.id, score: h.score }));
+}
+async function loadModuleContexts2(ctx, modules) {
+  if (modules.length === 0) return [];
+  if (!existsSync13(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 (existsSync13(file)) {
+      out.push({ name: m, content: await readFile3(file, "utf8") });
+    }
+  }
+  return out;
+}
+
+// src/tools/code-map.ts
+import { loadCodeMap, queryCodeMap } from "@hiveai/core";
+import { z as z14 } 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")
+};
+async function codeMapTool(input, ctx) {
+  const map = await loadCodeMap(ctx.paths);
+  if (!map) {
+    return {
+      available: false,
+      files: [],
+      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 });
+  return {
+    available: true,
+    generated_at: map.generated_at,
+    total_files: Object.keys(map.files).length,
+    files: files.slice(0, input.max_files).map((f) => ({
+      path: f.path,
+      ...f.entry.summary ? { summary: f.entry.summary } : {},
+      loc: f.entry.loc,
+      exports: f.entry.exports
+    }))
+  };
+}
+
+// src/prompts/bootstrap-project.ts
+import { z as z15 } from "zod";
 var BootstrapProjectArgsSchema = {
-  module: z13.string().optional().describe(
+  module: z15.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z13.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z15.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -769,7 +993,7 @@ ${template}\`\`\`
 
 // src/server.ts
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.1.0";
+var SERVER_VERSION = "0.2.1";
 function jsonResult(data) {
   return {
     content: [
@@ -810,6 +1034,18 @@ function createHaiveServer(options = {}) {
     GetProjectContextInputSchema,
     async (input) => jsonResult(await getProjectContext(input, context))
   );
+  server.tool(
+    "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))
+  );
+  server.tool(
+    "code_map",
+    "Browse the project's pre-computed code map (file \u2192 exports + 1-line description) instead of grepping. Requires `haive index code`.",
+    CodeMapInputSchema,
+    async (input) => jsonResult(await codeMapTool(input, context))
+  );
   server.tool(
     "bootstrap_project_save",
     "Persist a project (or module) context document analyzed by the AI client.",