@hiveai/mcp 0.1.0

package/dist/server.js

@@ -0,0 +1,869 @@
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/context.ts
+import { findProjectRoot, resolveHaivePaths } from "@hiveai/core";
+function createContext(options = {}) {
+  const env = options.env ?? process.env;
+  const cwd = options.cwd ?? process.cwd();
+  const root = options.root ?? env.HAIVE_PROJECT_ROOT ?? findProjectRoot(cwd);
+  return { paths: resolveHaivePaths(root) };
+}
+
+// src/tools/bootstrap-project-save.ts
+import { mkdir, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import path from "path";
+import { z } from "zod";
+var BootstrapProjectSaveInputSchema = {
+  content: z.string().min(1).describe("Full Markdown content for the project (or module) context file"),
+  module: z.string().optional().describe(
+    "If provided, save under .ai/modules/<module>/context.md instead of .ai/project-context.md"
+  ),
+  overwrite: z.boolean().default(false).describe("Overwrite an existing file instead of failing")
+};
+async function bootstrapProjectSave(input, ctx) {
+  const target = input.module ? path.join(ctx.paths.modulesContextDir, input.module, "context.md") : ctx.paths.projectContext;
+  const exists = existsSync(target);
+  if (exists && !input.overwrite) {
+    throw new Error(
+      `${target} already exists. Pass overwrite=true to replace it.`
+    );
+  }
+  await mkdir(path.dirname(target), { recursive: true });
+  await writeFile(target, input.content, "utf8");
+  return {
+    file_path: target,
+    action: exists ? "overwritten" : "created"
+  };
+}
+
+// src/tools/get-project-context.ts
+import { readFile, readdir } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import path2 from "path";
+import { z as z2 } from "zod";
+var GetProjectContextInputSchema = {
+  module: z2.string().optional().describe("If provided, also include the matching module's context file"),
+  list_modules: z2.boolean().default(false).describe("Return the list of available module context files")
+};
+async function getProjectContext(input, ctx) {
+  const out = { root_context: null };
+  if (existsSync2(ctx.paths.projectContext)) {
+    out.root_context = await readFile(ctx.paths.projectContext, "utf8");
+  }
+  if (input.module) {
+    const modFile = path2.join(ctx.paths.modulesContextDir, input.module, "context.md");
+    if (existsSync2(modFile)) {
+      out.module_context = {
+        name: input.module,
+        content: await readFile(modFile, "utf8")
+      };
+    }
+  }
+  if (input.list_modules) {
+    out.available_modules = await listModules(ctx.paths.modulesContextDir);
+  }
+  return out;
+}
+async function listModules(modulesDir) {
+  if (!existsSync2(modulesDir)) return [];
+  const entries = await readdir(modulesDir, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+}
+
+// src/tools/mem-list.ts
+import { existsSync as existsSync3 } from "fs";
+import { loadMemoriesFromDir } from "@hiveai/core";
+import { z as z3 } from "zod";
+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()
+};
+async function memList(input, ctx) {
+  if (!existsSync3(ctx.paths.memoriesDir)) {
+    return { memories: [] };
+  }
+  const all = await loadMemoriesFromDir(ctx.paths.memoriesDir);
+  const filtered = all.filter(({ memory }) => {
+    const fm = memory.frontmatter;
+    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.tag && !fm.tags.includes(input.tag)) return false;
+    return true;
+  });
+  const memories = filtered.map(({ memory, filePath }) => {
+    const fm = memory.frontmatter;
+    return {
+      id: fm.id,
+      scope: fm.scope,
+      type: fm.type,
+      ...fm.module ? { module: fm.module } : {},
+      status: fm.status,
+      tags: fm.tags,
+      file_path: filePath
+    };
+  });
+  return { memories };
+}
+
+// src/tools/mem-save.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import path3 from "path";
+import {
+  buildFrontmatter,
+  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"),
+  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"),
+  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)"),
+  author: z4.string().optional().describe("Author handle or email"),
+  paths: z4.array(z4.string()).default([]).describe("Anchor paths (file paths this memory references)"),
+  symbols: z4.array(z4.string()).default([]).describe("Anchor symbols (function/class names this memory references)"),
+  commit: z4.string().optional().describe("Anchor commit SHA (for staleness detection later)")
+};
+async function memSave(input, ctx) {
+  if (!existsSync4(ctx.paths.haiveDir)) {
+    throw new Error(
+      `No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`
+    );
+  }
+  const frontmatter = buildFrontmatter({
+    type: input.type,
+    slug: input.slug,
+    scope: input.scope,
+    module: input.module,
+    tags: input.tags,
+    domain: input.domain,
+    author: input.author,
+    paths: input.paths,
+    symbols: input.symbols,
+    commit: input.commit
+  });
+  const file = memoryFilePath(
+    ctx.paths,
+    frontmatter.scope,
+    frontmatter.id,
+    frontmatter.module
+  );
+  await mkdir2(path3.dirname(file), { recursive: true });
+  if (existsSync4(file)) {
+    throw new Error(`Memory already exists at ${file}`);
+  }
+  await writeFile2(file, serializeMemory({ frontmatter, body: input.body }), "utf8");
+  return {
+    id: frontmatter.id,
+    scope: frontmatter.scope,
+    file_path: file
+  };
+}
+
+// src/tools/mem-search.ts
+import { existsSync as existsSync5 } from "fs";
+import {
+  deriveConfidence,
+  extractSnippet,
+  getUsage,
+  literalMatchesAllTokens,
+  loadMemoriesFromDir as loadMemoriesFromDir2,
+  loadUsageIndex,
+  pickSnippetNeedle,
+  tokenizeQuery,
+  trackReads
+} from "@hiveai/core";
+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"),
+  module: z5.string().optional().describe("Restrict results to a module"),
+  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`)."
+  ),
+  min_score: z5.number().min(0).max(1).default(0).describe("Minimum cosine similarity (semantic mode only)"),
+  track: z5.boolean().default(true).describe("Increment read_count on returned memories (used for passive validation)")
+};
+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 filtered = all.filter(({ memory }) => passesFilters(memory.frontmatter, input));
+  const usage = await loadUsageIndex(ctx.paths);
+  let result;
+  if (input.semantic) {
+    const semantic = await trySemanticSearch(ctx, input, filtered, usage);
+    if (semantic) {
+      result = semantic;
+    } else {
+      result = {
+        ...buildLiteralResult(input, filtered, usage),
+        mode: "literal_fallback",
+        notice: "Semantic search unavailable (embeddings index missing or @hiveai/embeddings not installed). Falling back to literal search."
+      };
+    }
+  } else {
+    result = buildLiteralResult(input, filtered, usage);
+  }
+  if (input.track && result.matches.length > 0) {
+    await trackReads(
+      ctx.paths,
+      result.matches.map((m) => m.id)
+    );
+  }
+  return result;
+}
+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;
+  return true;
+}
+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);
+  return {
+    matches: top.map((loaded) => toHit(loaded, snippetNeedle, usage)),
+    total: matched.length,
+    mode: "literal"
+  };
+}
+async function trySemanticSearch(ctx, input, filtered, usage) {
+  let mod;
+  try {
+    mod = await import("@hiveai/embeddings");
+  } catch {
+    return null;
+  }
+  const result = await mod.semanticSearch(ctx.paths, input.query, {
+    limit: Math.min(input.limit * 3, 100),
+    minScore: input.min_score
+  });
+  if (!result) return null;
+  const allowedIds = new Set(filtered.map((m) => m.memory.frontmatter.id));
+  const byId = new Map(filtered.map((m) => [m.memory.frontmatter.id, m]));
+  const ranked = result.hits.filter((h) => allowedIds.has(h.id)).slice(0, input.limit);
+  const matches = ranked.map((hit) => {
+    const loaded = byId.get(hit.id);
+    if (!loaded) {
+      return {
+        id: hit.id,
+        scope: "unknown",
+        type: "unknown",
+        tags: [],
+        status: "unknown",
+        confidence: "unverified",
+        read_count: 0,
+        snippet: "",
+        file_path: hit.file_path,
+        score: hit.score
+      };
+    }
+    const base = toHit(loaded, input.query.toLowerCase(), usage);
+    return { ...base, score: hit.score };
+  });
+  return {
+    matches,
+    total: ranked.length,
+    mode: "semantic"
+  };
+}
+function toHit(loaded, needle, usage) {
+  const fm = loaded.memory.frontmatter;
+  const u = getUsage(usage, fm.id);
+  return {
+    id: fm.id,
+    scope: fm.scope,
+    type: fm.type,
+    ...fm.module ? { module: fm.module } : {},
+    tags: fm.tags,
+    status: fm.status,
+    confidence: deriveConfidence(fm, u),
+    read_count: u.read_count,
+    snippet: extractSnippet(loaded.memory.body, needle),
+    file_path: loaded.filePath
+  };
+}
+
+// src/tools/mem-verify.ts
+import { writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import {
+  loadMemoriesFromDir as loadMemoriesFromDir3,
+  serializeMemory as serializeMemory2,
+  verifyAnchor
+} from "@hiveai/core";
+import { z as z6 } from "zod";
+var MemVerifyInputSchema = {
+  id: z6.string().optional().describe("If set, verify only this memory id"),
+  update: z6.boolean().default(false).describe("Write the resulting status back to disk (status=stale or validated)")
+};
+async function memVerify(input, ctx) {
+  if (!existsSync6(ctx.paths.memoriesDir)) {
+    return {
+      results: [],
+      summary: { checked: 0, fresh: 0, stale: 0, anchorless_skipped: 0, updated: 0 }
+    };
+  }
+  const all = await loadMemoriesFromDir3(ctx.paths.memoriesDir);
+  const targets = input.id ? all.filter((m) => m.memory.frontmatter.id === input.id) : all;
+  const results = [];
+  let fresh = 0;
+  let stale = 0;
+  let anchorless = 0;
+  let updated = 0;
+  for (const { memory, filePath } of targets) {
+    const isAnchored = memory.frontmatter.anchor.paths.length > 0 || memory.frontmatter.anchor.symbols.length > 0;
+    if (!isAnchored) {
+      anchorless++;
+      continue;
+    }
+    const result = await verifyAnchor(memory, { projectRoot: ctx.paths.root });
+    if (result.stale) stale++;
+    else fresh++;
+    let statusAfter = memory.frontmatter.status;
+    if (input.update) {
+      const next = applyVerification(memory, result);
+      await writeFile3(filePath, serializeMemory2(next), "utf8");
+      statusAfter = next.frontmatter.status;
+      updated++;
+    }
+    results.push({
+      id: memory.frontmatter.id,
+      file_path: filePath,
+      stale: result.stale,
+      reason: result.reason,
+      status_after: statusAfter
+    });
+  }
+  return {
+    results,
+    summary: {
+      checked: results.length + anchorless,
+      fresh,
+      stale,
+      anchorless_skipped: anchorless,
+      updated
+    }
+  };
+}
+function applyVerification(mem, result) {
+  const verifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (result.stale) {
+    return {
+      frontmatter: {
+        ...mem.frontmatter,
+        status: "stale",
+        verified_at: verifiedAt,
+        stale_reason: result.reason
+      },
+      body: mem.body
+    };
+  }
+  const nextStatus = mem.frontmatter.status === "stale" || mem.frontmatter.status === "draft" ? "validated" : mem.frontmatter.status;
+  return {
+    frontmatter: {
+      ...mem.frontmatter,
+      status: nextStatus,
+      verified_at: verifiedAt,
+      stale_reason: null
+    },
+    body: mem.body
+  };
+}
+
+// src/tools/mem-reject.ts
+import { existsSync as existsSync7 } from "fs";
+import {
+  loadMemoriesFromDir as loadMemoriesFromDir4,
+  loadUsageIndex as loadUsageIndex2,
+  recordRejection,
+  saveUsageIndex
+} from "@hiveai/core";
+import { z as z7 } from "zod";
+var MemRejectInputSchema = {
+  id: z7.string().min(1).describe("Memory id being rejected"),
+  reason: z7.string().optional().describe("Why this memory is being rejected (recorded for review)")
+};
+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 exists = memories.some((m) => m.memory.frontmatter.id === input.id);
+  if (!exists) {
+    throw new Error(`No memory with id "${input.id}".`);
+  }
+  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,
+    rejected_count: u?.rejected_count ?? 0,
+    last_rejected_at: u?.last_rejected_at ?? null,
+    rejection_reason: u?.rejection_reason ?? null
+  };
+}
+
+// src/tools/mem-for-files.ts
+import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import path4 from "path";
+import {
+  deriveConfidence as deriveConfidence2,
+  getUsage as getUsage2,
+  inferModulesFromPaths,
+  loadMemoriesFromDir as loadMemoriesFromDir5,
+  loadUsageIndex as loadUsageIndex3,
+  memoryMatchesAnchorPaths,
+  trackReads as trackReads2
+} from "@hiveai/core";
+import { z as z8 } from "zod";
+var MemForFilesInputSchema = {
+  files: z8.array(z8.string()).min(1).describe("Project-relative file paths the agent is currently working on"),
+  include_module_contexts: z8.boolean().default(true).describe("Inline the matching .ai/modules/<name>/context.md contents"),
+  track: z8.boolean().default(true).describe("Increment read_count on returned memories")
+};
+async function memForFiles(input, ctx) {
+  const inferred = inferModulesFromPaths(input.files);
+  if (!existsSync8(ctx.paths.memoriesDir)) {
+    return {
+      inferred_modules: inferred,
+      by_anchor: [],
+      by_module: [],
+      by_domain: [],
+      module_contexts: await loadModuleContexts(ctx, inferred, input.include_module_contexts)
+    };
+  }
+  const all = await loadMemoriesFromDir5(ctx.paths.memoriesDir);
+  const usage = await loadUsageIndex3(ctx.paths);
+  const seen = /* @__PURE__ */ new Set();
+  const byAnchor = [];
+  const byModule = [];
+  const byDomain = [];
+  for (const loaded of all) {
+    if (memoryMatchesAnchorPaths(loaded.memory, input.files)) {
+      byAnchor.push(toMatch(loaded, "anchor_overlap", usage));
+      seen.add(loaded.memory.frontmatter.id);
+    }
+  }
+  for (const loaded of all) {
+    if (seen.has(loaded.memory.frontmatter.id)) continue;
+    const mod = loaded.memory.frontmatter.module;
+    if (mod && inferred.includes(mod)) {
+      byModule.push(toMatch(loaded, "module", usage));
+      seen.add(loaded.memory.frontmatter.id);
+    }
+  }
+  for (const loaded of all) {
+    if (seen.has(loaded.memory.frontmatter.id)) continue;
+    const domain = loaded.memory.frontmatter.domain;
+    if (domain && inferred.includes(domain)) {
+      byDomain.push(toMatch(loaded, "domain", usage));
+      seen.add(loaded.memory.frontmatter.id);
+    }
+  }
+  if (input.track) {
+    await trackReads2(ctx.paths, [...seen]);
+  }
+  return {
+    inferred_modules: inferred,
+    by_anchor: byAnchor,
+    by_module: byModule,
+    by_domain: byDomain,
+    module_contexts: await loadModuleContexts(ctx, inferred, input.include_module_contexts)
+  };
+}
+function toMatch(loaded, reason, usage) {
+  const fm = loaded.memory.frontmatter;
+  const u = getUsage2(usage, fm.id);
+  return {
+    id: fm.id,
+    scope: fm.scope,
+    type: fm.type,
+    ...fm.module ? { module: fm.module } : {},
+    tags: fm.tags,
+    status: fm.status,
+    confidence: deriveConfidence2(fm, u),
+    read_count: u.read_count,
+    reason,
+    file_path: loaded.filePath,
+    body: loaded.memory.body
+  };
+}
+async function loadModuleContexts(ctx, modules, enabled) {
+  if (!enabled || modules.length === 0) return [];
+  if (!existsSync8(ctx.paths.modulesContextDir)) return [];
+  const available = new Set(
+    (await readdir2(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 = path4.join(ctx.paths.modulesContextDir, m, "context.md");
+    if (existsSync8(file)) {
+      out.push({ name: m, content: await readFile2(file, "utf8") });
+    }
+  }
+  return out;
+}
+
+// src/tools/mem-get.ts
+import { existsSync as existsSync9 } from "fs";
+import {
+  deriveConfidence as deriveConfidence3,
+  getUsage as getUsage3,
+  loadMemoriesFromDir as loadMemoriesFromDir6,
+  loadUsageIndex as loadUsageIndex4
+} from "@hiveai/core";
+import { z as z9 } from "zod";
+var MemGetInputSchema = {
+  id: z9.string().min(1).describe("Memory id to fetch")
+};
+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 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;
+  const u = getUsage3(await loadUsageIndex4(ctx.paths), fm.id);
+  return {
+    id: fm.id,
+    scope: fm.scope,
+    type: fm.type,
+    ...fm.module ? { module: fm.module } : {},
+    tags: fm.tags,
+    status: fm.status,
+    confidence: deriveConfidence3(fm, u),
+    read_count: u.read_count,
+    rejected_count: u.rejected_count,
+    created_at: fm.created_at,
+    verified_at: fm.verified_at,
+    stale_reason: fm.stale_reason,
+    anchor: {
+      ...fm.anchor.commit ? { commit: fm.anchor.commit } : {},
+      paths: fm.anchor.paths,
+      symbols: fm.anchor.symbols
+    },
+    body: found.memory.body,
+    file_path: found.filePath
+  };
+}
+
+// src/tools/mem-delete.ts
+import { existsSync as existsSync10 } from "fs";
+import { unlink } from "fs/promises";
+import {
+  loadMemoriesFromDir as loadMemoriesFromDir7,
+  loadUsageIndex as loadUsageIndex5,
+  saveUsageIndex as saveUsageIndex2
+} from "@hiveai/core";
+import { z as z10 } from "zod";
+var MemDeleteInputSchema = {
+  id: z10.string().min(1).describe("Memory id to delete"),
+  keep_usage: z10.boolean().default(false).describe("Keep the usage.json entry instead of removing it alongside the file")
+};
+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 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);
+  let usageRemoved = false;
+  if (!input.keep_usage) {
+    const idx = await loadUsageIndex5(ctx.paths);
+    if (idx.by_id[input.id]) {
+      delete idx.by_id[input.id];
+      await saveUsageIndex2(ctx.paths, idx);
+      usageRemoved = true;
+    }
+  }
+  return { id: input.id, deleted_file: found.filePath, usage_removed: usageRemoved };
+}
+
+// src/tools/mem-pending.ts
+import { existsSync as existsSync11 } from "fs";
+import {
+  getUsage as getUsage4,
+  loadMemoriesFromDir as loadMemoriesFromDir8,
+  loadUsageIndex as loadUsageIndex6
+} from "@hiveai/core";
+import { z as z11 } from "zod";
+var MemPendingInputSchema = {
+  scope: z11.enum(["personal", "team", "module"]).optional()
+};
+async function memPending(input, ctx) {
+  if (!existsSync11(ctx.paths.memoriesDir)) return { pending: [] };
+  const all = await loadMemoriesFromDir8(ctx.paths.memoriesDir);
+  const usage = await loadUsageIndex6(ctx.paths);
+  const now = Date.now();
+  const proposed = all.filter(({ memory }) => {
+    if (memory.frontmatter.status !== "proposed") return false;
+    if (input.scope && memory.frontmatter.scope !== input.scope) return false;
+    return true;
+  });
+  proposed.sort(
+    (a, b) => getUsage4(usage, b.memory.frontmatter.id).read_count - getUsage4(usage, a.memory.frontmatter.id).read_count
+  );
+  return {
+    pending: proposed.map(({ memory, filePath }) => {
+      const fm = memory.frontmatter;
+      const u = getUsage4(usage, fm.id);
+      return {
+        id: fm.id,
+        scope: fm.scope,
+        type: fm.type,
+        ...fm.module ? { module: fm.module } : {},
+        tags: fm.tags,
+        age_days: Math.floor((now - new Date(fm.created_at).getTime()) / 864e5),
+        read_count: u.read_count,
+        rejected_count: u.rejected_count,
+        file_path: filePath
+      };
+    })
+  };
+}
+
+// src/tools/mem-approve.ts
+import { writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync12 } from "fs";
+import {
+  loadMemoriesFromDir as loadMemoriesFromDir9,
+  serializeMemory as serializeMemory3
+} from "@hiveai/core";
+import { z as z12 } from "zod";
+var MemApproveInputSchema = {
+  id: z12.string().min(1).describe("Memory id to approve (sets status=validated immediately)")
+};
+async function memApprove(input, ctx) {
+  if (!existsSync12(ctx.paths.memoriesDir)) {
+    throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
+  }
+  const all = await loadMemoriesFromDir9(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;
+  const next = {
+    frontmatter: { ...found.memory.frontmatter, status: "validated" },
+    body: found.memory.body
+  };
+  await writeFile4(found.filePath, serializeMemory3(next), "utf8");
+  return {
+    id: input.id,
+    previous_status: previous,
+    status: "validated",
+    file_path: found.filePath
+  };
+}
+
+// src/prompts/bootstrap-project.ts
+import { z as z13 } from "zod";
+var BootstrapProjectArgsSchema = {
+  module: z13.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')")
+};
+var ROOT_TEMPLATE = `# Project context
+
+## Architecture
+<one or two paragraphs on the high-level architecture>
+
+## Key modules
+- <module-name>: <one line on its purpose>
+- ...
+
+## Conventions
+- <convention>: <why it matters here>
+- ...
+
+## Glossary
+- <term>: <definition in this codebase>
+- ...
+
+## Gotchas
+- <surprising behavior, hidden coupling, or known traps>
+- ...
+`;
+var MODULE_TEMPLATE = `# Module context \u2014 {module}
+
+## Purpose
+<what this module is for>
+
+## Public surface
+- <exported symbol>: <one line>
+- ...
+
+## Internals
+<key files / classes / functions and how they connect>
+
+## Conventions specific to this module
+- ...
+
+## Gotchas
+- ...
+`;
+function bootstrapProjectPrompt(args, ctx) {
+  const target = args.module ? `\`.ai/modules/${args.module}/context.md\`` : "`.ai/project-context.md`";
+  const template = args.module ? MODULE_TEMPLATE.replace("{module}", args.module) : ROOT_TEMPLATE;
+  const focusLine = args.focus ? `
+Emphasis area for this analysis: **${args.focus}**.
+` : "";
+  const text = `You are bootstrapping a hAIve shared project context for the team.
+
+Project root: \`${ctx.paths.root}\`
+Target file: ${target}
+${focusLine}
+## What to do
+
+1. Explore the codebase: read the package manifests, top-level directories, build configs, and a representative sample of source files. Do not read every file \u2014 pick what gives you the highest signal per file (entry points, config, README if present, main domain models).
+2. Synthesize a concise, high-signal context document. Prefer load-bearing facts over exhaustive enumeration. A new teammate (human or AI) should be able to read it in 5 minutes and feel oriented.
+3. Match the structure of the template below. Keep each section short \u2014 link to files instead of repeating large code chunks.
+4. When you are done, call the \`bootstrap_project_save\` tool with the full Markdown content. Use \`overwrite=true\` only if the file already exists and you intend to replace it.
+
+## Template to fill
+
+\`\`\`markdown
+${template}\`\`\`
+
+## Tips
+
+- Anchor claims to file paths so future readers can verify them.
+- Write what is true *now*, not aspirational. Note open questions explicitly.
+- Skip sections that have nothing meaningful to say rather than padding them.
+`;
+  return {
+    description: args.module ? `Bootstrap context for module "${args.module}"` : "Bootstrap the root project context",
+    messages: [
+      {
+        role: "user",
+        content: { type: "text", text }
+      }
+    ]
+  };
+}
+
+// src/server.ts
+var SERVER_NAME = "haive";
+var SERVER_VERSION = "0.1.0";
+function jsonResult(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(data, null, 2)
+      }
+    ]
+  };
+}
+function createHaiveServer(options = {}) {
+  const context = createContext(options);
+  const server = new McpServer(
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    { capabilities: { tools: {}, prompts: {} } }
+  );
+  server.tool(
+    "mem_save",
+    "Save a new memory (default scope=personal). Use scope=team for shared memories.",
+    MemSaveInputSchema,
+    async (input) => jsonResult(await memSave(input, context))
+  );
+  server.tool(
+    "mem_search",
+    "Search memories by substring across id, tags, and body. Optional filters by scope/type/module.",
+    MemSearchInputSchema,
+    async (input) => jsonResult(await memSearch(input, context))
+  );
+  server.tool(
+    "mem_list",
+    "List memories with optional filters by scope/type/module/tag.",
+    MemListInputSchema,
+    async (input) => jsonResult(await memList(input, context))
+  );
+  server.tool(
+    "get_project_context",
+    "Read the shared .ai/project-context.md (and optionally a module context).",
+    GetProjectContextInputSchema,
+    async (input) => jsonResult(await getProjectContext(input, context))
+  );
+  server.tool(
+    "bootstrap_project_save",
+    "Persist a project (or module) context document analyzed by the AI client.",
+    BootstrapProjectSaveInputSchema,
+    async (input) => jsonResult(await bootstrapProjectSave(input, context))
+  );
+  server.tool(
+    "mem_verify",
+    "Check anchor freshness for one or every memory; optionally write status updates back to disk.",
+    MemVerifyInputSchema,
+    async (input) => jsonResult(await memVerify(input, context))
+  );
+  server.tool(
+    "mem_reject",
+    "Record a rejection for a memory (blocks auto-promotion and lowers its trust signal).",
+    MemRejectInputSchema,
+    async (input) => jsonResult(await memReject(input, context))
+  );
+  server.tool(
+    "mem_for_files",
+    "Given the file paths the agent is currently working on, return relevant memories grouped by reason (anchor overlap, module, domain) plus any matching .ai/modules/<name>/context.md contents.",
+    MemForFilesInputSchema,
+    async (input) => jsonResult(await memForFiles(input, context))
+  );
+  server.tool(
+    "mem_get",
+    "Fetch a single memory by id, including its body, anchor, usage, and confidence.",
+    MemGetInputSchema,
+    async (input) => jsonResult(await memGet(input, context))
+  );
+  server.tool(
+    "mem_delete",
+    "Delete a memory by id (and its usage entry by default).",
+    MemDeleteInputSchema,
+    async (input) => jsonResult(await memDelete(input, context))
+  );
+  server.tool(
+    "mem_pending",
+    "List 'proposed' memories awaiting review, sorted by reads (most-read first).",
+    MemPendingInputSchema,
+    async (input) => jsonResult(await memPending(input, context))
+  );
+  server.tool(
+    "mem_approve",
+    "Mark a memory as validated immediately (explicit team review).",
+    MemApproveInputSchema,
+    async (input) => jsonResult(await memApprove(input, context))
+  );
+  server.prompt(
+    "bootstrap_project",
+    "Instructions for the AI client to analyze the project and save the context.",
+    BootstrapProjectArgsSchema,
+    (args) => bootstrapProjectPrompt(args, context)
+  );
+  return { server, context };
+}
+export {
+  SERVER_NAME,
+  SERVER_VERSION,
+  createHaiveServer
+};
+//# sourceMappingURL=server.js.map