@hiveai/mcp 0.4.3 → 0.5.0

package/dist/server.d.ts

@@ -1,5 +1,6 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { HaivePaths } from '@hiveai/core';
+import { HaivePaths, ConfidenceLevel } from '@hiveai/core';
+import { z } from 'zod';
 
 interface HaiveContext {
     paths: HaivePaths;
@@ -22,6 +23,308 @@ declare class SessionTracker {
     private registerShutdownHandler;
 }
 
+declare const GetBriefingInputSchema: {
+    task: z.ZodOptional<z.ZodString>;
+    files: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    max_tokens: z.ZodDefault<z.ZodNumber>;
+    max_memories: z.ZodDefault<z.ZodNumber>;
+    include_project_context: z.ZodDefault<z.ZodBoolean>;
+    include_module_contexts: z.ZodDefault<z.ZodBoolean>;
+    semantic: z.ZodDefault<z.ZodBoolean>;
+    include_stale: z.ZodDefault<z.ZodBoolean>;
+    track: z.ZodDefault<z.ZodBoolean>;
+    format: z.ZodDefault<z.ZodEnum<["full", "compact"]>>;
+    symbols: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    min_semantic_score: z.ZodDefault<z.ZodNumber>;
+};
+type GetBriefingInput = {
+    [K in keyof typeof GetBriefingInputSchema]: z.infer<(typeof GetBriefingInputSchema)[K]>;
+};
+interface BriefingMemory {
+    id: string;
+    scope: string;
+    type: string;
+    module?: string;
+    tags: string[];
+    status: string;
+    confidence: ConfidenceLevel;
+    /** Present when confidence is 'low' or 'unverified' — AI should weight this memory cautiously. */
+    unverified?: true;
+    read_count: number;
+    reasons: Array<"anchor" | "module" | "domain" | "semantic">;
+    match_quality: "exact" | "partial" | "semantic";
+    semantic_score?: number;
+    body: string;
+    file_path: string;
+}
+interface CodeMapSymbolHit {
+    symbol: string;
+    /** files that export this symbol */
+    locations: Array<{
+        file: string;
+        kind: string;
+        line: number;
+        description?: string;
+    }>;
+}
+interface ActionRequiredItem {
+    /** Memory id containing the alert */
+    id: string;
+    /** Short human-readable summary of the issue */
+    summary: string;
+    /**
+     * The exact message to show the developer before doing anything.
+     * Copy-paste this verbatim — do NOT paraphrase or act before confirmation.
+     */
+    developer_message: string;
+}
+interface BriefingOutput {
+    task?: string;
+    search_mode: "semantic" | "literal_fallback" | "literal";
+    match_quality_note?: string;
+    inferred_modules: string[];
+    last_session?: {
+        id: string;
+        scope: string;
+        revision_count: number;
+        body: string;
+    };
+    project_context: {
+        content: string;
+        truncated: boolean;
+        is_template?: boolean;
+        auto_generated?: boolean;
+    } | null;
+    module_contexts: Array<{
+        name: string;
+        content: string;
+        truncated: boolean;
+    }>;
+    memories: BriefingMemory[];
+    symbol_locations?: CodeMapSymbolHit[];
+    /**
+     * Memories that require explicit human confirmation before any code action.
+     * IMPORTANT: for each item, show developer_message to the developer and
+     * wait for explicit approval before modifying any code.
+     * These are surfaced separately from memories to make them impossible to miss.
+     */
+    action_required: ActionRequiredItem[];
+    decay_warnings: string[];
+    setup_warnings: string[];
+    /**
+     * True when this briefing carries little actionable signal:
+     * - project-context.md is still the default template
+     * - no memories matched the task (or none exist at all)
+     * - no previous session recap
+     * Clients can use this flag to skip surfacing a near-empty briefing to the model.
+     */
+    low_value?: true;
+    /**
+     * Short, action-oriented hints surfaced to the agent based on the briefing payload.
+     * Examples: "haive is uninitialized — use Read/Grep directly", "gotcha memories present — read first".
+     * Always non-empty when low_value=true.
+     */
+    hints?: string[];
+    estimated_tokens: number;
+    budget: {
+        max_tokens: number;
+        spent: {
+            project: number;
+            modules: number;
+            memories: number;
+        };
+    };
+}
+declare function getBriefing(input: GetBriefingInput, ctx: HaiveContext): Promise<BriefingOutput>;
+
+declare const CodeMapInputSchema: {
+    file: z.ZodOptional<z.ZodString>;
+    symbol: z.ZodOptional<z.ZodString>;
+    paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    max_files: z.ZodDefault<z.ZodNumber>;
+    max_tokens: z.ZodOptional<z.ZodNumber>;
+};
+type CodeMapInput = {
+    [K in keyof typeof CodeMapInputSchema]: z.infer<(typeof CodeMapInputSchema)[K]>;
+};
+interface CodeMapToolOutput {
+    available: boolean;
+    generated_at?: string;
+    total_files?: number;
+    files: Array<{
+        path: string;
+        summary?: string;
+        loc: number;
+        exports: Array<{
+            name: string;
+            kind: string;
+            description?: string;
+            line: number;
+        }>;
+    }>;
+    /** Number of matched files dropped due to max_files / max_tokens. */
+    truncated?: number;
+    /** True when at least one file was dropped to fit the token budget. */
+    budget_clipped?: true;
+    notice?: string;
+}
+declare function codeMapTool(input: CodeMapInput, ctx: HaiveContext): Promise<CodeMapToolOutput>;
+
+declare const GetRecapInputSchema: {
+    scope: z.ZodDefault<z.ZodEnum<["personal", "team", "any"]>>;
+};
+type GetRecapInput = {
+    [K in keyof typeof GetRecapInputSchema]: z.infer<(typeof GetRecapInputSchema)[K]>;
+};
+interface GetRecapOutput {
+    recap: {
+        id: string;
+        scope: string;
+        revision_count: number;
+        created_at: string;
+        body: string;
+    } | null;
+    notice?: string;
+}
+/**
+ * Lightweight alternative to get_briefing when you ONLY need the previous
+ * session recap (e.g. resuming a long task between sessions). Skips project
+ * context, modules, and memory ranking — pays only the recap's token cost.
+ */
+declare function getRecap(input: GetRecapInput, ctx: HaiveContext): Promise<GetRecapOutput>;
+
+declare const MemRelevantToInputSchema: {
+    task: z.ZodString;
+    files: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    min_semantic_score: z.ZodDefault<z.ZodNumber>;
+    format: z.ZodDefault<z.ZodEnum<["full", "compact"]>>;
+};
+type MemRelevantToInput = {
+    [K in keyof typeof MemRelevantToInputSchema]: z.infer<(typeof MemRelevantToInputSchema)[K]>;
+};
+interface MemRelevantToOutput {
+    task: string;
+    search_mode: "semantic" | "literal_fallback" | "literal";
+    memories: BriefingMemory[];
+    hints?: string[];
+    /**
+     * True when the search returned zero memories — clients can skip surfacing
+     * an empty payload to the model.
+     */
+    empty?: true;
+}
+/**
+ * One-shot ranked memories for a task. Use instead of get_briefing when you
+ * already have project context loaded and only want the relevant memory layer.
+ *
+ * Runs the same ranking (anchor / module / literal / semantic) as get_briefing
+ * but skips project_context, module_contexts, action_required, etc. — paying
+ * only the cost of the memory bodies you actually get back.
+ */
+declare function memRelevantTo(input: MemRelevantToInput, ctx: HaiveContext): Promise<MemRelevantToOutput>;
+
+declare const CodeSearchInputSchema: {
+    query: z.ZodString;
+    k: z.ZodDefault<z.ZodNumber>;
+    min_score: z.ZodDefault<z.ZodNumber>;
+};
+type CodeSearchInput = {
+    [K in keyof typeof CodeSearchInputSchema]: z.infer<(typeof CodeSearchInputSchema)[K]>;
+};
+interface CodeSearchHit {
+    file: string;
+    name: string;
+    kind: string;
+    line: number;
+    description?: string;
+    score: number;
+}
+interface CodeSearchOutput {
+    available: boolean;
+    hits: CodeSearchHit[];
+    notice?: string;
+}
+declare function codeSearch(input: CodeSearchInput, ctx: HaiveContext): Promise<CodeSearchOutput>;
+
+declare const WhyThisFileInputSchema: {
+    path: z.ZodString;
+    git_log_limit: z.ZodDefault<z.ZodNumber>;
+    memory_limit: z.ZodDefault<z.ZodNumber>;
+};
+type WhyThisFileInput = {
+    [K in keyof typeof WhyThisFileInputSchema]: z.infer<(typeof WhyThisFileInputSchema)[K]>;
+};
+interface WhyThisFileOutput {
+    file: string;
+    exists: boolean;
+    recent_commits: Array<{
+        sha: string;
+        author: string;
+        relative_date: string;
+        subject: string;
+    }>;
+    memories: Array<{
+        id: string;
+        type: string;
+        scope: string;
+        confidence: string;
+        body_preview: string;
+    }>;
+    code_map_entry: {
+        summary?: string;
+        loc: number;
+        exports: Array<{
+            name: string;
+            kind: string;
+            line: number;
+            description?: string;
+        }>;
+    } | null;
+    hints?: string[];
+}
+/**
+ * One-shot file-context lookup: combines recent git history, memories anchored
+ * to the path, and the code-map entry. Designed to answer "why is this file
+ * the way it is?" in a single call instead of 3-4 manual ones.
+ */
+declare function whyThisFile(input: WhyThisFileInput, ctx: HaiveContext): Promise<WhyThisFileOutput>;
+
+declare const AntiPatternsCheckInputSchema: {
+    diff: z.ZodOptional<z.ZodString>;
+    paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    semantic: z.ZodDefault<z.ZodBoolean>;
+};
+type AntiPatternsCheckInput = {
+    [K in keyof typeof AntiPatternsCheckInputSchema]: z.infer<(typeof AntiPatternsCheckInputSchema)[K]>;
+};
+interface AntiPatternsWarning {
+    id: string;
+    type: "attempt" | "gotcha";
+    scope: string;
+    confidence: string;
+    body_preview: string;
+    reasons: Array<"anchor" | "literal" | "semantic">;
+    semantic_score?: number;
+}
+interface AntiPatternsCheckOutput {
+    /** Total number of attempt+gotcha memories that exist in this project. */
+    scanned: number;
+    warnings: AntiPatternsWarning[];
+    notice?: string;
+}
+/**
+ * Scan a diff (or set of paths) against documented attempt/gotcha memories.
+ * Surfaces "you are about to repeat a known mistake" warnings BEFORE you commit.
+ *
+ * Matching strategy:
+ *   1. Anchor — memories anchored to any of the changed paths
+ *   2. Literal — tokens from the diff overlap with memory body
+ *   3. Semantic — cosine similarity (when enabled and index available)
+ */
+declare function antiPatternsCheck(input: AntiPatternsCheckInput, ctx: HaiveContext): Promise<AntiPatternsCheckOutput>;
+
 declare const SERVER_NAME = "haive";
 declare const SERVER_VERSION: string;
 declare function createHaiveServer(options?: CreateContextOptions): {
@@ -30,4 +333,4 @@ declare function createHaiveServer(options?: CreateContextOptions): {
     tracker: SessionTracker;
 };
 
-export { SERVER_NAME, SERVER_VERSION, createHaiveServer };
+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 };