@hiveai/mcp 0.5.0 → 0.6.0

package/dist/server.d.ts

@@ -325,6 +325,189 @@ interface AntiPatternsCheckOutput {
  */
 declare function antiPatternsCheck(input: AntiPatternsCheckInput, ctx: HaiveContext): Promise<AntiPatternsCheckOutput>;
 
+declare const MemDistillInputSchema: {
+    since_days: z.ZodDefault<z.ZodNumber>;
+    min_cluster: z.ZodDefault<z.ZodNumber>;
+    type_filter: z.ZodDefault<z.ZodEnum<["gotcha", "attempt", "all"]>>;
+    scope: z.ZodDefault<z.ZodEnum<["personal", "team", "module", "any"]>>;
+};
+type MemDistillInput = {
+    [K in keyof typeof MemDistillInputSchema]: z.infer<(typeof MemDistillInputSchema)[K]>;
+};
+interface DistillCluster {
+    suggested_topic: string;
+    suggested_type: "convention" | "gotcha";
+    member_ids: string[];
+    overlapping_paths: string[];
+    common_keywords: string[];
+    sample_titles: string[];
+    /** ISO date of the latest member */
+    latest_at: string;
+}
+interface MemDistillOutput {
+    scanned: number;
+    /** Memories that didn't fit any cluster (kept here so callers can inspect singletons). */
+    singletons: number;
+    clusters: DistillCluster[];
+    notice?: string;
+}
+/**
+ * Cluster recurring observations / attempts so a human can collapse N similar
+ * memories into one richer convention/gotcha. Uses cheap heuristics (anchor
+ * path overlap + body keyword overlap) — no embeddings needed.
+ *
+ * Output is *advisory*: nothing is written to disk. The caller (CLI / human)
+ * decides whether to mem_save the consolidated form.
+ */
+declare function memDistill(input: MemDistillInput, ctx: HaiveContext): Promise<MemDistillOutput>;
+
+declare const WhyThisDecisionInputSchema: {
+    id: z.ZodString;
+    git_log_limit: z.ZodDefault<z.ZodNumber>;
+};
+type WhyThisDecisionInput = {
+    [K in keyof typeof WhyThisDecisionInputSchema]: z.infer<(typeof WhyThisDecisionInputSchema)[K]>;
+};
+interface WhyThisDecisionOutput {
+    found: boolean;
+    decision?: {
+        id: string;
+        type: string;
+        scope: string;
+        status: string;
+        confidence: string;
+        body: string;
+        created_at: string;
+    };
+    /** Memories explicitly linked via related_ids on the decision (or vice versa). */
+    related: Array<{
+        id: string;
+        type: string;
+        scope: string;
+        confidence: string;
+        body_preview: string;
+        relation: "explicit" | "back-link";
+    }>;
+    /** Other memories anchored to overlapping paths — implicit context. */
+    path_neighbors: Array<{
+        id: string;
+        type: string;
+        scope: string;
+        confidence: string;
+        overlap: string[];
+        body_preview: string;
+    }>;
+    /** Recent git commits touching any of the decision's anchored paths. */
+    recent_commits: Array<{
+        path: string;
+        sha: string;
+        author: string;
+        relative_date: string;
+        subject: string;
+    }>;
+    hints?: string[];
+    notice?: string;
+}
+/**
+ * Trace the genealogy of a `decision` memory: the decision itself + memories
+ * explicitly linked to it + memories anchored to overlapping paths + recent
+ * commits touching those paths. One call instead of 4-5 manual lookups.
+ *
+ * Works on any memory type, but is optimized for `decision` and `architecture`.
+ */
+declare function whyThisDecision(input: WhyThisDecisionInput, ctx: HaiveContext): Promise<WhyThisDecisionOutput>;
+
+declare const MemConflictsInputSchema: {
+    id: z.ZodString;
+    min_score: z.ZodDefault<z.ZodNumber>;
+    semantic: z.ZodDefault<z.ZodBoolean>;
+};
+type MemConflictsInput = {
+    [K in keyof typeof MemConflictsInputSchema]: z.infer<(typeof MemConflictsInputSchema)[K]>;
+};
+type ConflictReason = "opposite-status" | "attempt-vs-convention-same-paths" | "polarity-keywords" | "explicit-contradiction-tag";
+interface ConflictHit {
+    id: string;
+    type: string;
+    scope: string;
+    status: string;
+    confidence: string;
+    body_preview: string;
+    similarity: number | null;
+    reasons: ConflictReason[];
+    shared_paths: string[];
+}
+interface MemConflictsOutput {
+    found: boolean;
+    target?: {
+        id: string;
+        type: string;
+        status: string;
+    };
+    scanned: number;
+    conflicts: ConflictHit[];
+    notice?: string;
+}
+/**
+ * Find memories that potentially CONTRADICT the given memory. Useful before
+ * relying on a memory's advice — surfaces "another memory says the opposite".
+ *
+ * Detection layers (any of these triggers a hit):
+ *   - Opposite status: target is validated, neighbor is rejected — for the same topic
+ *   - Type mismatch on overlapping paths: an `attempt` (don't do X) coexists with
+ *     a `convention` (do X) anchored to overlapping paths
+ *   - Polarity keywords: target says "use X" while a semantic neighbor says "don't use X"
+ *   - Explicit contradiction tag (#contradicts:<id>) in either body
+ */
+declare function memConflicts(input: MemConflictsInput, ctx: HaiveContext): Promise<MemConflictsOutput>;
+
+declare const PreCommitCheckInputSchema: {
+    diff: z.ZodOptional<z.ZodString>;
+    paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    block_on: z.ZodDefault<z.ZodEnum<["any", "high-confidence", "never"]>>;
+    semantic: z.ZodDefault<z.ZodBoolean>;
+};
+type PreCommitCheckInput = {
+    [K in keyof typeof PreCommitCheckInputSchema]: z.infer<(typeof PreCommitCheckInputSchema)[K]>;
+};
+interface PreCommitCheckOutput {
+    /** True when at least one finding meets the configured block_on threshold. */
+    should_block: boolean;
+    /** Per-section summary; clients should surface the warnings + reasons to the user. */
+    summary: {
+        anti_patterns: number;
+        relevant_memories: number;
+        stale_anchors: number;
+    };
+    warnings: AntiPatternsWarning[];
+    /** Memories anchored to the touched files — convention reminders for the change author. */
+    relevant_memories: Array<{
+        id: string;
+        type: string;
+        confidence: string;
+        body_preview: string;
+    }>;
+    /** Memories whose anchored paths overlap with the diff AND are now stale — likely outdated knowledge. */
+    stale_anchors: Array<{
+        id: string;
+        paths: string[];
+        body_preview: string;
+    }>;
+    notice?: string;
+}
+/**
+ * One-shot "should I block this commit?" check.
+ *
+ * Combines three signals into a single call agents and git hooks can consume:
+ *   1. anti_patterns_check — known gotchas/attempts that match the diff
+ *   2. mem_for_files — conventions/decisions anchored to touched files
+ *   3. mem_verify — memories whose anchors are stale (knowledge may be wrong)
+ *
+ * Returns should_block per the configured threshold, plus the raw findings so
+ * the caller can render them. CLI wrapper: `haive precommit`.
+ */
+declare function preCommitCheck(input: PreCommitCheckInput, ctx: HaiveContext): Promise<PreCommitCheckOutput>;
+
 declare const SERVER_NAME = "haive";
 declare const SERVER_VERSION: string;
 declare function createHaiveServer(options?: CreateContextOptions): {
@@ -333,4 +516,4 @@ declare function createHaiveServer(options?: CreateContextOptions): {
     tracker: SessionTracker;
 };
 
-export { type AntiPatternsCheckInput, type AntiPatternsCheckOutput, type BriefingOutput, type CodeMapInput, type CodeMapToolOutput, type CodeSearchInput, type CodeSearchOutput, type GetBriefingInput, type GetRecapInput, type GetRecapOutput, type MemRelevantToInput, type MemRelevantToOutput, SERVER_NAME, SERVER_VERSION, type WhyThisFileInput, type WhyThisFileOutput, antiPatternsCheck, codeMapTool, codeSearch, createHaiveServer, getBriefing, getRecap, memRelevantTo, whyThisFile };
+export { type AntiPatternsCheckInput, type AntiPatternsCheckOutput, type BriefingOutput, type CodeMapInput, type CodeMapToolOutput, type CodeSearchInput, type CodeSearchOutput, type GetBriefingInput, type GetRecapInput, type GetRecapOutput, type MemConflictsInput, type MemConflictsOutput, type MemDistillInput, type MemDistillOutput, type MemRelevantToInput, type MemRelevantToOutput, type PreCommitCheckInput, type PreCommitCheckOutput, SERVER_NAME, SERVER_VERSION, type WhyThisDecisionInput, type WhyThisDecisionOutput, type WhyThisFileInput, type WhyThisFileOutput, antiPatternsCheck, codeMapTool, codeSearch, createHaiveServer, getBriefing, getRecap, memConflicts, memDistill, memRelevantTo, preCommitCheck, whyThisDecision, whyThisFile };