@hivelore/mcp 0.43.2 → 0.46.0

package/dist/server.d.ts

@@ -365,6 +365,7 @@ interface AntiPatternsCheckInput {
     limit: number;
     semantic: boolean;
     min_semantic_score?: number;
+    track?: boolean;
 }
 interface AntiPatternsWarning {
     id: string;
@@ -694,6 +695,7 @@ declare const ScaffoldTestInputSchema: {
     memory_id: z.ZodString;
     framework: z.ZodOptional<z.ZodEnum<["vitest", "jest", "pytest", "gotest"]>>;
     out_path: z.ZodOptional<z.ZodString>;
+    red_ref: z.ZodOptional<z.ZodString>;
     write: z.ZodDefault<z.ZodBoolean>;
 };
 type ScaffoldTestInput = {
@@ -834,5 +836,6 @@ declare function printHaiveMcpVersion(): void;
 declare function runHaiveMcpStdio(options: {
     root?: string;
 }): Promise<void>;
+declare function writeMcpRuntimeMarker(context: HaiveContext): Promise<void>;
 
-export { type AnchorFrameworkGroup, type AntiPatternsCheckInput, type AntiPatternsCheckOutput, type AstMatch, type AstScanResult, type BriefingOutput, type CodeMapInput, type CodeMapToolOutput, type CodeSearchInput, type CodeSearchOutput, ENFORCEMENT_PROFILE_TOOLS, EXPERIMENTAL_PROFILE_TOOLS, type GetBriefingInput, type GetRecapInput, type GetRecapOutput, MAINTENANCE_PROFILE_TOOLS, type MemConflictCandidatesInput, type MemDistillInput, type MemDistillOutput, type MemRelevantToInput, type MemRelevantToOutput, type MemResolveProjectInput, type MemSuggestTopicInput, type MemTimelineInput, type MemTriedOutput, type PreCommitCheckInput, type PreCommitCheckOutput, type ProposeSensorOutput, SERVER_NAME, SERVER_VERSION, type ScaffoldTestOutput, TOOL_PROFILES, type ToolProfile, antiPatternsCheck, astEngineAvailable, astLangForPath, codeMapTool, codeSearch, createHaiveServer, detectTestFrameworkForPaths, detectTestFrameworksForAnchors, getAllowedToolsForProfile, getBriefing, getRecap, memConflictCandidates, memDistill, memRelevantTo, memResolveProject, memSuggestTopic, memTimeline, memTried, parseMcpCliArgs, preCommitCheck, printHaiveMcpVersion, proposeSensor, readPresumedCorrectTargets, runAstPattern, runAstSensorOnContent, runHaiveMcpStdio, scaffoldTest };
+export { type AnchorFrameworkGroup, type AntiPatternsCheckInput, type AntiPatternsCheckOutput, type AstMatch, type AstScanResult, type BriefingOutput, type CodeMapInput, type CodeMapToolOutput, type CodeSearchInput, type CodeSearchOutput, ENFORCEMENT_PROFILE_TOOLS, EXPERIMENTAL_PROFILE_TOOLS, type GetBriefingInput, type GetRecapInput, type GetRecapOutput, MAINTENANCE_PROFILE_TOOLS, type MemConflictCandidatesInput, type MemDistillInput, type MemDistillOutput, type MemRelevantToInput, type MemRelevantToOutput, type MemResolveProjectInput, type MemSuggestTopicInput, type MemTimelineInput, type MemTriedOutput, type PreCommitCheckInput, type PreCommitCheckOutput, type ProposeSensorOutput, SERVER_NAME, SERVER_VERSION, type ScaffoldTestOutput, TOOL_PROFILES, type ToolProfile, antiPatternsCheck, astEngineAvailable, astLangForPath, codeMapTool, codeSearch, createHaiveServer, detectTestFrameworkForPaths, detectTestFrameworksForAnchors, getAllowedToolsForProfile, getBriefing, getRecap, memConflictCandidates, memDistill, memRelevantTo, memResolveProject, memSuggestTopic, memTimeline, memTried, parseMcpCliArgs, preCommitCheck, printHaiveMcpVersion, proposeSensor, readPresumedCorrectTargets, runAstPattern, runAstSensorOnContent, runHaiveMcpStdio, scaffoldTest, writeMcpRuntimeMarker };

package/dist/server.js

@@ -1,6 +1,8 @@
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { mkdir as mkdir8, writeFile as writeFile15 } from "fs/promises";
+import path15 from "path";
 
 // src/context.ts
 import { findProjectRoot, resolveHaivePaths } from "@hivelore/core";
@@ -1791,15 +1793,24 @@ async function memTried(input, ctx) {
 import { existsSync as existsSync17, statSync } from "fs";
 import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile10 } from "fs/promises";
 import path8 from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
 import { z as z17 } from "zod";
 import {
   buildProposeCommand,
+  incidentHintsFromDiff,
   loadMemoriesFromDir as loadMemoriesFromDir14,
   normalizeFramework,
   parseLessonFields,
   pickTestFramework,
   scaffoldPostIncidentTest
 } from "@hivelore/core";
+var execFileAsync = promisify(execFile);
+async function gitDiffText(root, redRef, paths) {
+  const args = ["diff", redRef, "HEAD", "--", ...paths];
+  const { stdout } = await execFileAsync("git", args, { cwd: root, maxBuffer: 64 * 1024 * 1024 });
+  return stdout;
+}
 var PY_SIGNALS = ["pyproject.toml", "setup.py", "pytest.ini", "requirements.txt", "tox.ini"];
 async function detectForAnchor(root, rel) {
   let dir = path8.resolve(root, rel);
@@ -1854,6 +1865,9 @@ var ScaffoldTestInputSchema = {
   memory_id: z17.string().min(1).describe("Id of the attempt/gotcha lesson to scaffold a post-incident test from."),
   framework: z17.enum(["vitest", "jest", "pytest", "gotest"]).optional().describe("Test framework. Auto-detected from the package that owns the lesson's anchor paths when omitted."),
   out_path: z17.string().optional().describe("Override the generated test file path (repo-relative)."),
+  red_ref: z17.string().optional().describe(
+    "Pre-fix incident commit/ref. When set, the scaffold names the symbols the fix (<red_ref>..HEAD) touched within the lesson's anchor scope and pre-fills the example around them, so the assertion is a targeted edit rather than a blank page. A bad ref falls back to the generic template."
+  ),
   write: z17.boolean().default(true).describe("Write the file to disk (default). false = return the content for preview without writing.")
 };
 async function scaffoldTest(input, ctx) {
@@ -1867,13 +1881,23 @@ async function scaffoldTest(input, ctx) {
   const groups = input.out_path ? allGroups.slice(0, 1) : allGroups;
   const frameworkFor = (detected) => input.framework ? normalizeFramework(input.framework) ?? detected : detected;
   const fields = parseLessonFields(found.memory.body);
+  let incidentHints;
+  if (input.red_ref) {
+    try {
+      const diff = await gitDiffText(ctx.paths.root, input.red_ref, anchorPaths);
+      const hints = incidentHintsFromDiff(diff, { redRef: input.red_ref });
+      if (hints.changedSymbols.length > 0 || hints.changedFiles.length > 0) incidentHints = hints;
+    } catch {
+    }
+  }
   const lesson = {
     memoryId: input.memory_id,
     title: fields.title || input.memory_id,
     whyFailed: fields.whyFailed,
     instead: fields.instead,
     incident: found.memory.frontmatter.sensor?.incident,
-    paths: anchorPaths
+    paths: anchorPaths,
+    incidentHints
   };
   let scaffolds = groups.map(
     (g) => scaffoldPostIncidentTest(lesson, { framework: frameworkFor(g.framework), outPath: input.out_path, baseDir: g.baseDir })
@@ -3197,7 +3221,7 @@ function oneLine(value) {
   return value.replace(/\s+/g, " ").replace(/"/g, '\\"').trim().slice(0, 120);
 }
 function serverVersion() {
-  return true ? "0.43.2" : "dev";
+  return true ? "0.46.0" : "dev";
 }
 
 // src/tools/code-map.ts
@@ -3483,7 +3507,8 @@ var AntiPatternsCheckInputSchema = {
   ),
   min_semantic_score: z26.number().min(0).max(1).default(0.45).describe(
     "Minimum cosine score for semantic-only anti-pattern hits. Anchor/literal matches still surface. Default 0.45 keeps broad, weakly-related memories out of review noise."
-  )
+  ),
+  track: z26.boolean().default(true).describe("Record real prevention outcomes. Set false for eval/selftest probes so synthetic cases never inflate ROI.")
 };
 function tokenizeDiffForLiteral(diff) {
   const lines = diff.split("\n");
@@ -3511,6 +3536,7 @@ function isHaiveOwnedPath(p) {
   if (/^\.github\/workflows\/haive-.*\.ya?ml$/.test(p)) return true;
   return false;
 }
+var MAX_FUZZY_SCAN_LINES = 2e4;
 var TEST_PATH_RE = /(?:^|\/)(?:tests?|__tests__|__mocks__|e2e|fixtures)\/|\.(?:test|spec)\.[cm]?[jt]sx?$/i;
 function isTestPath(p) {
   return TEST_PATH_RE.test(p);
@@ -3521,7 +3547,7 @@ function stripTestHunks(diff) {
   let block = [];
   let keep = true;
   const flush = () => {
-    if (keep) out.push(...block);
+    if (keep) for (const l of block) out.push(l);
     block = [];
     keep = true;
   };
@@ -3542,7 +3568,7 @@ function stripAiDirHunks(diff) {
   let block = [];
   let keep = true;
   const flush = () => {
-    if (keep) out.push(...block);
+    if (keep) for (const l of block) out.push(l);
     block = [];
     keep = true;
   };
@@ -3613,7 +3639,10 @@ async function antiPatternsCheck(input, ctx) {
     }
   }
   const scanDiff = input.diff ? stripTestHunks(stripAiDirHunks(input.diff)) : input.diff;
-  if (scanDiff) {
+  const scanAddedLineCount = scanDiff ? addedLinesFromDiff(scanDiff).split("\n").length : 0;
+  const fuzzyScanTooLarge = scanAddedLineCount > MAX_FUZZY_SCAN_LINES;
+  const notice = fuzzyScanTooLarge ? `Diff is very large (${scanAddedLineCount.toLocaleString()} added lines) \u2014 literal/semantic corroboration skipped for performance; anchored lessons and deterministic sensors were still evaluated in full. If this staged node_modules or a build artifact, unstage it.` : void 0;
+  if (scanDiff && !fuzzyScanTooLarge) {
     const tokens = tokenizeDiffForLiteral(scanDiff);
     const added = addedLinesFromDiff(scanDiff);
     const addedText = added.trim().length > 0 ? added : scanDiff;
@@ -3648,7 +3677,7 @@ async function antiPatternsCheck(input, ctx) {
       }
     }
   }
-  if (input.semantic && scanDiff) {
+  if (input.semantic && scanDiff && !fuzzyScanTooLarge) {
     try {
       const mod = await import("@hivelore/embeddings");
       const added = addedLinesFromDiff(scanDiff);
@@ -3676,10 +3705,13 @@ async function antiPatternsCheck(input, ctx) {
   }).slice(0, input.limit);
   const isHardBlockCatch = (w) => w.reasons.includes("sensor");
   const strongCatches = warnings.filter(isHardBlockCatch);
-  await recordPreventionHits(ctx.paths, strongCatches.map((w) => w.id), "anti-pattern");
+  if (input.track !== false) {
+    await recordPreventionHits(ctx.paths, strongCatches.map((w) => w.id), "anti-pattern");
+  }
   return {
     scanned: negative.length,
-    warnings
+    warnings,
+    ...notice ? { notice } : {}
   };
 }
 
@@ -3907,6 +3939,7 @@ async function preCommitCheck(input, ctx) {
       relevant_memories: relevant_memories.length,
       stale_anchors: staleHits.length
     },
+    ...apResult.notice ? { notice: apResult.notice } : {},
     warnings: classifiedWarnings,
     relevant_memories,
     stale_anchors: staleHits.map((r) => {
@@ -4458,13 +4491,14 @@ Main code areas detected: ${areas}
 import { z as z35 } from "zod";
 var PostTaskArgsSchema = {
   task_summary: z35.string().optional().describe("One sentence describing what you just did"),
-  files_touched: z35.array(z35.string()).optional().describe("Files you created or modified during the task")
+  files_touched: z35.string().optional().describe("Files you created or modified during the task, as CSV or a JSON array string")
 };
 function postTaskPrompt(args, ctx) {
   const taskLine = args.task_summary ? `
 Task just completed: **${args.task_summary}**` : "";
-  const filesLine = args.files_touched && args.files_touched.length > 0 ? `
-Files touched: ${args.files_touched.map((f) => `\`${f}\``).join(", ")}` : "";
+  const filesTouched = parsePromptFilesTouched(args.files_touched);
+  const filesLine = filesTouched.length > 0 ? `
+Files touched: ${filesTouched.map((f) => `\`${f}\``).join(", ")}` : "";
   const text = `You have just finished a task. Before closing this session, take 60 seconds to capture what you learned.
 ${taskLine}${filesLine}
 
@@ -4553,6 +4587,20 @@ When done, respond with a brief summary: "Saved N memories: [list of IDs]. Sessi
     ]
   };
 }
+function parsePromptFilesTouched(input) {
+  const raw = input?.trim();
+  if (!raw) return [];
+  if (raw.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) {
+        return parsed.filter((value) => typeof value === "string").map((value) => value.trim()).filter(Boolean);
+      }
+    } catch {
+    }
+  }
+  return raw.split(",").map((value) => value.trim()).filter(Boolean);
+}
 
 // src/prompts/import-docs.ts
 import { z as z36 } from "zod";
@@ -4626,7 +4674,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
 // src/server.ts
 import { hasRecentBriefingMarker, loadConfigSync } from "@hivelore/core";
 var SERVER_NAME = "hivelore";
-var SERVER_VERSION = "0.43.2";
+var SERVER_VERSION = "0.46.0";
 function jsonResult(data) {
   return {
     content: [
@@ -5565,11 +5613,22 @@ function printHaiveMcpVersion() {
 }
 async function runHaiveMcpStdio(options) {
   const { server, context } = createHaiveServer({ root: options.root, env: process.env });
+  await writeMcpRuntimeMarker(context).catch(() => {
+  });
   console.error(
     `[haive-mcp] starting server v${SERVER_VERSION} (project root: ${context.paths.root})`
   );
   await server.connect(new StdioServerTransport());
 }
+async function writeMcpRuntimeMarker(context) {
+  await mkdir8(context.paths.runtimeDir, { recursive: true });
+  await writeFile15(path15.join(context.paths.runtimeDir, "mcp-server.json"), JSON.stringify({
+    version: SERVER_VERSION,
+    pid: process.pid,
+    started_at: (/* @__PURE__ */ new Date()).toISOString(),
+    command: "hivelore mcp --stdio"
+  }, null, 2), "utf8");
+}
 export {
   ENFORCEMENT_PROFILE_TOOLS,
   EXPERIMENTAL_PROFILE_TOOLS,
@@ -5603,6 +5662,7 @@ export {
   runAstPattern,
   runAstSensorOnContent,
   runHaiveMcpStdio,
-  scaffoldTest
+  scaffoldTest,
+  writeMcpRuntimeMarker
 };
 //# sourceMappingURL=server.js.map