@hivelore/cli 0.43.2 → 0.46.0

package/README.md

@@ -233,6 +233,7 @@ Run the repeatable quality gate for Hivelore itself or for a project using Hivel
 ```bash
 hivelore eval
 hivelore eval --semantic-only
+hivelore eval --semantic-ranking  # require and exercise the real embeddings-backed ranker
 hivelore eval --spec .ai/eval/spec.json --fail-under 80
 ```
 
@@ -533,14 +534,14 @@ hivelore install-hooks --dir /path/to/project
 
 ---
 
-### `hivelore embeddings`
+### `hivelore index`
 
 Manage the local semantic search index (requires `@hivelore/embeddings` to be installed).
 
 ```bash
-hivelore embeddings index          # Build or refresh the embeddings index
-hivelore embeddings status         # Show index stats (count, last updated, model)
-hivelore embeddings query "how do we handle retries on payment failures"
+hivelore index memories            # Build or refresh the embeddings index
+hivelore index status              # Show index stats (count, last updated, model)
+hivelore index query "how do we handle retries on payment failures"
 ```
 
 The model (`bge-small-en-v1.5`, ~110MB) is downloaded on first use and cached locally. **No data leaves your machine.**
@@ -655,8 +656,8 @@ Install `@hivelore/embeddings` for similarity-based memory retrieval:
 
 ```bash
 npm install -g @hivelore/embeddings
-hivelore embeddings index          # First run downloads the model (~110MB)
-hivelore embeddings query "payment retry logic"
+hivelore index memories            # First run downloads the model (~110MB)
+hivelore index query "payment retry logic"
 ```
 
 From MCP: set `semantic: true` on `mem_search` or `get_briefing`.

package/dist/{chunk-FXDGOBPT.js → chunk-W7EPRKOZ.js}

@@ -3,6 +3,8 @@
 // ../mcp/dist/server.js
 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";
 import { findProjectRoot, resolveHaivePaths } from "@hivelore/core";
 import { mkdir, writeFile } from "fs/promises";
 import { existsSync } from "fs";
@@ -153,9 +155,12 @@ import path5 from "path";
 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,
@@ -1914,6 +1919,12 @@ async function memTried(input, ctx) {
     hint
   };
 }
+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);
@@ -1968,6 +1979,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) {
@@ -1981,13 +1995,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 })
@@ -3211,7 +3235,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";
 }
 var CodeMapInputSchema = {
   file: z21.string().optional().describe("Filter to files whose path contains this substring"),
@@ -3454,7 +3478,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");
@@ -3482,6 +3507,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);
@@ -3492,7 +3518,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;
   };
@@ -3513,7 +3539,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;
   };
@@ -3584,7 +3610,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;
@@ -3619,7 +3648,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);
@@ -3647,10 +3676,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 } : {}
   };
 }
 var MemDistillInputSchema = {
@@ -3866,6 +3898,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) => {
@@ -4376,13 +4409,14 @@ Main code areas detected: ${areas}
 }
 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}
 
@@ -4471,6 +4505,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);
+}
 var ImportDocsArgsSchema = {
   content: z36.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
   source: z36.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
@@ -4538,7 +4586,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "hivelore";
-var SERVER_VERSION = "0.43.2";
+var SERVER_VERSION = "0.46.0";
 function jsonResult(data) {
   return {
     content: [
@@ -5477,11 +5525,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 {
   astEngineAvailable,
@@ -5516,6 +5575,7 @@ export {
   createHaiveServer,
   parseMcpCliArgs,
   printHaiveMcpVersion,
-  runHaiveMcpStdio
+  runHaiveMcpStdio,
+  writeMcpRuntimeMarker
 };
-//# sourceMappingURL=chunk-FXDGOBPT.js.map
+//# sourceMappingURL=chunk-W7EPRKOZ.js.map