@hiveai/core 0.14.0 → 0.15.0

package/dist/index.js

@@ -2943,10 +2943,10 @@ function isRetiredMemory(fm, body = "", now = /* @__PURE__ */ new Date()) {
 function normalizeProjectPath(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^[ab]\//, "").replace(/\/+$/g, "");
 }
-function sensorAppliesToPath(sensor, anchorPaths, path17) {
+function sensorAppliesToPath(sensor, anchorPaths, path18) {
   const scopes = sensor.paths.length > 0 ? sensor.paths : anchorPaths;
   if (scopes.length === 0) return true;
-  const target = normalizeProjectPath(path17);
+  const target = normalizeProjectPath(path18);
   return scopes.some((rawScope) => {
     const scope = normalizeProjectPath(rawScope);
     if (!scope) return false;
@@ -2994,6 +2994,28 @@ function runSensors(memories, targets) {
   }
   return hits;
 }
+function selectCommandSensors(memories, changedPaths) {
+  const specs = [];
+  for (const memory of memories) {
+    const sensor = memory.frontmatter.sensor;
+    if (!sensor) continue;
+    if (sensor.kind !== "shell" && sensor.kind !== "test") continue;
+    const command = sensor.command?.trim();
+    if (!command) continue;
+    const anchorPaths = memory.frontmatter.anchor.paths;
+    const applies = changedPaths.length === 0 ? true : changedPaths.some((p) => sensorAppliesToPath(sensor, anchorPaths, p));
+    if (!applies) continue;
+    specs.push({
+      memory_id: memory.frontmatter.id,
+      command,
+      kind: sensor.kind,
+      severity: sensor.severity,
+      message: sensor.message,
+      paths: sensor.paths.length > 0 ? sensor.paths : anchorPaths
+    });
+  }
+  return specs;
+}
 function sensorTargetsFromDiff(diff) {
   const targets = [];
   let currentPath = null;
@@ -3220,8 +3242,8 @@ function normalizeFindingSeverity(raw) {
       return "info";
   }
 }
-function findingKey(tool, ruleId, path17) {
-  return `${tool}:${ruleId}:${path17}`;
+function findingKey(tool, ruleId, path18) {
+  return `${tool}:${ruleId}:${path18}`;
 }
 function coerceJson(input) {
   if (typeof input === "string") {
@@ -3255,8 +3277,8 @@ function parseSarif(input) {
       const physical = asRecord(location.physicalLocation);
       const artifact = asRecord(physical.artifactLocation);
       const region = asRecord(physical.region);
-      const path17 = typeof artifact.uri === "string" ? normalizeUri(artifact.uri) : "";
-      if (!path17) continue;
+      const path18 = typeof artifact.uri === "string" ? normalizeUri(artifact.uri) : "";
+      if (!path18) continue;
       const line = typeof region.startLine === "number" ? region.startLine : void 0;
       const snippet = typeof asRecord(region.snippet).text === "string" ? asRecord(region.snippet).text.trim() : void 0;
       findings.push({
@@ -3264,10 +3286,10 @@ function parseSarif(input) {
         ruleId,
         message: message.trim(),
         severity,
-        path: path17,
+        path: path18,
         ...line !== void 0 ? { line } : {},
         ...snippet ? { snippet } : {},
-        key: findingKey(tool, ruleId, path17)
+        key: findingKey(tool, ruleId, path18)
       });
     }
   }
@@ -3286,17 +3308,17 @@ function parseSonar(input) {
       (typeof issue.severity === "string" ? issue.severity : void 0) ?? impactSeverity
     );
     const component = typeof issue.component === "string" ? issue.component : "";
-    const path17 = componentToPath(component);
-    if (!path17) continue;
+    const path18 = componentToPath(component);
+    if (!path18) continue;
     const line = typeof issue.line === "number" ? issue.line : void 0;
     findings.push({
       tool: "sonar",
       ruleId,
       message,
       severity,
-      path: path17,
+      path: path18,
       ...line !== void 0 ? { line } : {},
-      key: findingKey("sonar", ruleId, path17)
+      key: findingKey("sonar", ruleId, path18)
     });
   }
   return findings;
@@ -3373,6 +3395,52 @@ function filterNewDrafts(drafts, existingTopics) {
   return drafts.filter((d) => !existing.has(d.topic));
 }
 
+// src/gate-precision.ts
+function round33(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+function computeGatePrecision(events, usage, currentGate = "anchored") {
+  let sensorCatches = 0;
+  let antiPatternCatches = 0;
+  for (const e of events) {
+    if (e.source === "sensor") sensorCatches += 1;
+    else if (e.source === "anti-pattern") antiPatternCatches += 1;
+  }
+  let applied = 0;
+  let rejections = 0;
+  for (const mem of Object.values(usage.by_id ?? {})) {
+    applied += mem.applied_count ?? 0;
+    rejections += mem.rejected_count ?? 0;
+  }
+  const useful = sensorCatches + antiPatternCatches + applied;
+  const denom = useful + rejections;
+  const precision = denom === 0 ? null : round33(useful / denom);
+  return {
+    sensor_catches: sensorCatches,
+    anti_pattern_catches: antiPatternCatches,
+    useful,
+    rejections,
+    precision,
+    suggestion: suggestGate(precision, rejections, currentGate)
+  };
+}
+function suggestGate(precision, rejections, currentGate) {
+  if (precision === null || rejections < 3) return null;
+  if (precision < 0.5 && (currentGate === "anchored" || currentGate === "strict")) {
+    return {
+      recommended: "review",
+      reason: `Gate precision ${precision} with ${rejections} rejection(s) \u2014 the gate is crying wolf. Loosen to "review" (surface, don't hard-block) until the corpus is cleaner.`
+    };
+  }
+  if (precision >= 0.85 && currentGate === "review") {
+    return {
+      recommended: "anchored",
+      reason: `Gate precision ${precision} \u2014 catches are reliably real. Tighten to "anchored" so corroborated anti-patterns hard-block.`
+    };
+  }
+  return null;
+}
+
 // src/dashboard.ts
 var MS_PER_DAY4 = 24 * 60 * 60 * 1e3;
 function isAnchorless(fm) {
@@ -3514,6 +3582,11 @@ function buildDashboard(memories, usage, options = {}) {
         top: computeRecurrence(options.preventionEvents ?? []).top.slice(0, top)
       }
     },
+    gate_precision: computeGatePrecision(
+      options.preventionEvents ?? [],
+      usage,
+      options.antiPatternGate ?? "anchored"
+    ),
     corpus: {
       memory_files: inventory.total,
       body_chars: bodyChars,
@@ -3521,6 +3594,235 @@ function buildDashboard(memories, usage, options = {}) {
     }
   };
 }
+
+// src/failure-coverage.ts
+var MS_PER_HOUR = 36e5;
+function normalizeSummary(summary) {
+  return summary.toLowerCase().replace(/\s+/g, " ").trim().slice(0, 160);
+}
+function findUncapturedFailures(failures, captureTimes, options = {}) {
+  const now = (options.now ?? /* @__PURE__ */ new Date()).getTime();
+  const windowMs = (options.windowHours ?? 24) * MS_PER_HOUR;
+  const dedupe = options.dedupe ?? true;
+  let latestCapture = 0;
+  for (const iso of captureTimes) {
+    const t = Date.parse(iso);
+    if (Number.isFinite(t) && now - t <= windowMs && t > latestCapture) latestCapture = t;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const f of failures) {
+    const t = Date.parse(f.ts);
+    if (!Number.isFinite(t)) continue;
+    if (now - t > windowMs) continue;
+    if (t <= latestCapture) continue;
+    if (dedupe) {
+      const key = normalizeSummary(f.summary);
+      if (seen.has(key)) continue;
+      seen.add(key);
+    }
+    out.push({ ts: f.ts, tool: f.tool, summary: f.summary });
+  }
+  out.sort((a, b) => a.ts.localeCompare(b.ts));
+  return out;
+}
+
+// src/coverage.ts
+var DEFAULT_COVERING_TYPES = ["decision", "convention", "gotcha", "architecture"];
+function normalizePath(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/g, "");
+}
+function buildCoverageIndex(memories, coveringTypes = DEFAULT_COVERING_TYPES) {
+  const types = new Set(coveringTypes);
+  const covered = /* @__PURE__ */ new Set();
+  for (const { memory } of memories) {
+    const fm = memory.frontmatter;
+    if (!types.has(fm.type)) continue;
+    if (fm.status === "stale" || fm.status === "deprecated" || fm.status === "rejected") continue;
+    for (const p of fm.anchor.paths) {
+      const norm = normalizePath(p);
+      if (norm) covered.add(norm);
+    }
+  }
+  return covered;
+}
+function isCovered(file, coverage) {
+  const target = normalizePath(file);
+  if (coverage.has(target)) return true;
+  for (const scope of coverage) {
+    if (target === scope || target.startsWith(`${scope}/`)) return true;
+  }
+  return false;
+}
+function findCoverageGaps(hotFiles, memories, options = {}) {
+  const minChanges = options.minChanges ?? 3;
+  const limit = options.limit ?? 20;
+  const coverage = buildCoverageIndex(memories, options.coveringTypes);
+  const gaps = [];
+  for (const hot of hotFiles) {
+    if (hot.changes < minChanges) continue;
+    if (isCovered(hot.path, coverage)) continue;
+    gaps.push({ path: normalizePath(hot.path), changes: hot.changes });
+  }
+  gaps.sort((a, b) => b.changes - a.changes);
+  return gaps.slice(0, limit);
+}
+
+// src/eval-history.ts
+import { appendFile as appendFile4, mkdir as mkdir11, readFile as readFile14 } from "fs/promises";
+import { existsSync as existsSync15 } from "fs";
+import path17 from "path";
+function evalHistoryPath(paths) {
+  return path17.join(paths.haiveDir, ".cache", "eval-history.jsonl");
+}
+async function appendEvalHistory(paths, entry) {
+  const file = evalHistoryPath(paths);
+  await mkdir11(path17.dirname(file), { recursive: true });
+  await appendFile4(file, JSON.stringify(entry) + "\n", "utf8");
+}
+async function loadEvalHistory(paths) {
+  const file = evalHistoryPath(paths);
+  if (!existsSync15(file)) return [];
+  const raw = await readFile14(file, "utf8").catch(() => "");
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const e = JSON.parse(trimmed);
+      if (e && typeof e.at === "string" && typeof e.score === "number") out.push(e);
+    } catch {
+    }
+  }
+  return out;
+}
+function computeEvalTrend(entries, recentN = 10) {
+  const sorted = [...entries].sort((a, b) => a.at.localeCompare(b.at));
+  const scores = sorted.map((e) => e.score);
+  const latest = scores.length > 0 ? scores[scores.length - 1] : null;
+  const previous = scores.length > 1 ? scores[scores.length - 2] : null;
+  const delta = latest !== null && previous !== null ? Math.round((latest - previous) * 1e3) / 1e3 : null;
+  const best = scores.length > 0 ? Math.max(...scores) : null;
+  return {
+    latest,
+    previous,
+    delta,
+    best,
+    runs: scores.length,
+    recent: scores.slice(-recentN),
+    regressed: delta !== null && delta < 0
+  };
+}
+
+// src/conflict-resolve.ts
+var STATUS_RANK = {
+  validated: 4,
+  proposed: 3,
+  draft: 2,
+  stale: 1,
+  deprecated: 0,
+  rejected: 0
+};
+function statusRank(fm) {
+  return STATUS_RANK[fm.status] ?? 2;
+}
+function planConflictResolution(a, b) {
+  const fa = a.memory.frontmatter;
+  const fb = b.memory.frontmatter;
+  const ra = statusRank(fa);
+  const rb = statusRank(fb);
+  let winner;
+  let loser;
+  let reason;
+  if (ra !== rb) {
+    [winner, loser] = ra > rb ? [a, b] : [b, a];
+    reason = `status (${winner.memory.frontmatter.status} beats ${loser.memory.frontmatter.status})`;
+  } else if (fa.revision_count !== fb.revision_count) {
+    [winner, loser] = fa.revision_count > fb.revision_count ? [a, b] : [b, a];
+    reason = `revision_count (${winner.memory.frontmatter.revision_count} > ${loser.memory.frontmatter.revision_count})`;
+  } else {
+    const cmp = fa.created_at.localeCompare(fb.created_at);
+    [winner, loser] = cmp >= 0 ? [a, b] : [b, a];
+    reason = `recency (${winner.memory.frontmatter.created_at} is newer)`;
+  }
+  const keepId = winner.memory.frontmatter.id;
+  const supersedeId = loser.memory.frontmatter.id;
+  return {
+    keep_id: keepId,
+    supersede_id: supersedeId,
+    reason,
+    stale_reason: `Superseded by ${keepId} (conflict resolved on ${reason}).`
+  };
+}
+
+// src/seed-git.ts
+var REVERT_RE = /^Revert\s+"(.+)"\s*$/i;
+var FIXUP_RE = /^(?:fixup!|hotfix[:!]|fix[:!]\s*revert|revert\s+revert)/i;
+var URGENT_FIX_RE = /\b(hotfix|urgent fix|emergency fix|critical fix|broke production|broken build)\b/i;
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "reverted-change";
+}
+function proposeSeedsFromCommits(commits, limit = 20) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const commit of commits) {
+    const subject = commit.subject.trim();
+    let what = null;
+    let kind = null;
+    const revert = subject.match(REVERT_RE);
+    if (revert) {
+      what = revert[1].trim();
+      kind = "revert";
+    } else if (FIXUP_RE.test(subject) || URGENT_FIX_RE.test(subject)) {
+      what = subject.replace(FIXUP_RE, "").trim() || subject;
+      kind = "fixup";
+    }
+    if (!what || !kind) continue;
+    const slug = slugify(what);
+    if (seen.has(slug)) continue;
+    seen.add(slug);
+    out.push({
+      slug,
+      what,
+      why_failed: kind === "revert" ? `This change was reverted in commit ${commit.sha} \u2014 it caused a regression and was backed out. Verify the root cause before re-attempting.` : `This area required an urgent fix (commit ${commit.sha}: "${subject}") \u2014 it shipped broken once. Treat changes here with extra care.`,
+      paths: (commit.files ?? []).slice(0, 8),
+      source_sha: commit.sha,
+      kind
+    });
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+
+// src/merge-memory.ts
+function safeParse(raw) {
+  try {
+    return parseMemory(raw);
+  } catch {
+    return null;
+  }
+}
+function mergeMemoryVersions(ours, theirs) {
+  if (ours === theirs) {
+    return { content: ours, winner: "ours", reason: "identical" };
+  }
+  const a = safeParse(ours);
+  const b = safeParse(theirs);
+  if (!a || !b) {
+    return { content: ours, winner: "ours", reason: "unparseable side \u2014 kept ours" };
+  }
+  const ra = a.frontmatter.revision_count ?? 0;
+  const rb = b.frontmatter.revision_count ?? 0;
+  if (ra !== rb) {
+    return rb > ra ? { content: theirs, winner: "theirs", reason: `higher revision_count (${rb} > ${ra})` } : { content: ours, winner: "ours", reason: `higher revision_count (${ra} > ${rb})` };
+  }
+  const ca = a.frontmatter.created_at ?? "";
+  const cb = b.frontmatter.created_at ?? "";
+  const cmp = cb.localeCompare(ca);
+  if (cmp > 0) return { content: theirs, winner: "theirs", reason: `newer created_at (${cb})` };
+  if (cmp < 0) return { content: ours, winner: "ours", reason: `newer created_at (${ca})` };
+  return { content: ours, winner: "ours", reason: "tie \u2014 kept ours" };
+}
 export {
   AUTOPILOT_DEFAULTS,
   ActivationSchema,
@@ -3561,12 +3863,14 @@ export {
   aggregateUsage,
   allocateBudget,
   antiPatternGateParams,
+  appendEvalHistory,
   appendPreventionEvent,
   appendRuntimeJournalEntry,
   appendUsageEvent,
   briefingMarkerPath,
   briefingMarkersDir,
   buildCodeMap,
+  buildCoverageIndex,
   buildDashboard,
   buildDocFrequency,
   buildFrontmatter,
@@ -3577,6 +3881,8 @@ export {
   compareEvalReports,
   compareImpact,
   compileRegexSensor,
+  computeEvalTrend,
+  computeGatePrecision,
   computeImpact,
   computePreventionTrend,
   computeRecurrence,
@@ -3591,13 +3897,16 @@ export {
   emptyUsageIndex,
   enforcementDir,
   estimateTokens,
+  evalHistoryPath,
   evaluateSkillActivation,
   extractActionsBriefBody,
   extractSnippet,
   filterNewDrafts,
+  findCoverageGaps,
   findLexicalConflictPairs,
   findProjectRoot,
   findTopicStatusConflictPairs,
+  findUncapturedFailures,
   findingBody,
   findingToDraft,
   firstMemoryOneLine,
@@ -3607,6 +3916,7 @@ export {
   hashProjectContext,
   inferModulesFromPaths,
   isAutoPromoteEligible,
+  isCovered,
   isDecaying,
   isDistinctiveToken,
   isFreshIsoDate,
@@ -3622,12 +3932,14 @@ export {
   loadCodeMap,
   loadConfig,
   loadConfigSync,
+  loadEvalHistory,
   loadMemoriesFromDir,
   loadMemory,
   loadPreventionEvents,
   loadUsageIndex,
   memoryFilePath,
   memoryMatchesAnchorPaths,
+  mergeMemoryVersions,
   newMemoryId,
   normalizeFindingSeverity,
   normalizeSessionId,
@@ -3639,8 +3951,10 @@ export {
   parseSonar,
   pathsOverlap,
   pickSnippetNeedle,
+  planConflictResolution,
   preventionLogPath,
   projectContextRecentlyEmitted,
+  proposeSeedsFromCommits,
   pullCrossRepoSources,
   queryCodeMap,
   rankMemoriesLexical,
@@ -3665,12 +3979,14 @@ export {
   saveUsageIndex,
   scoreRetrievalCase,
   scoreSensorCase,
+  selectCommandSensors,
   sensorAppliesToPath,
   sensorTargetsFromDiff,
   serializeMemory,
   snapshotContract,
   specificityScore,
   stripPrivate,
+  suggestGate,
   suggestSensorFromMemory,
   suggestTopicKey,
   summarizeImpact,