@dotsetlabs/bellwether 0.10.0

package/dist/cost/tracker.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Cost tracking and estimation for LLM API usage.
+ */
+/**
+ * Token usage information.
+ */
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+}
+/**
+ * Cost estimation result.
+ */
+export interface CostEstimate {
+    usage: TokenUsage;
+    costUSD: number;
+    model: string;
+    breakdown: {
+        inputCost: number;
+        outputCost: number;
+    };
+}
+/**
+ * Cumulative cost tracker for a session.
+ */
+export declare class CostTracker {
+    private model;
+    private totalInputTokens;
+    private totalOutputTokens;
+    private callCount;
+    constructor(model: string);
+    /**
+     * Add token usage from an API call.
+     */
+    addUsage(inputTokens: number, outputTokens: number): void;
+    /**
+     * Get total usage so far.
+     */
+    getUsage(): TokenUsage;
+    /**
+     * Get total cost estimate.
+     */
+    getCost(): CostEstimate;
+    /**
+     * Get call count.
+     */
+    getCallCount(): number;
+    /**
+     * Format cost summary for display.
+     */
+    formatSummary(): string;
+}
+/**
+ * Estimate cost for an interview before running.
+ */
+export declare function estimateInterviewCost(model: string, toolCount: number, questionsPerTool: number, personas?: number): CostEstimate;
+/**
+ * Format a pre-interview cost estimate.
+ */
+export declare function formatCostEstimate(estimate: CostEstimate): string;
+/**
+ * Get pricing info for a model.
+ */
+export declare function getModelPricing(model: string): {
+    input: number;
+    output: number;
+} | null;
+/**
+ * Time estimation result for an interview.
+ */
+export interface InterviewTimeEstimate {
+    /** Estimated duration in seconds */
+    durationSeconds: number;
+    /** Estimated duration in minutes (rounded) */
+    durationMinutes: number;
+    /** Whether estimate assumes parallel execution */
+    isParallel: boolean;
+    /** Whether using a local model (slower) */
+    isLocalModel: boolean;
+}
+/**
+ * Check if a provider uses local inference (slower than cloud APIs).
+ */
+export declare function isLocalProvider(provider: string): boolean;
+/**
+ * Estimate interview time based on tool count and configuration.
+ */
+export declare function estimateInterviewTime(toolCount: number, questionsPerTool: number, personas: number, parallelPersonas?: boolean, provider?: string, promptCount?: number, resourceCount?: number, checkMode?: boolean): InterviewTimeEstimate;
+/**
+ * Format a combined cost and time estimate for display.
+ */
+export declare function formatCostAndTimeEstimate(cost: CostEstimate, time: InterviewTimeEstimate): string;
+/**
+ * Optimization suggestion for reducing cost or time.
+ */
+export interface OptimizationSuggestion {
+    /** Flag to use (e.g., "--ci") */
+    flag: string;
+    /** Human-readable description */
+    description: string;
+    /** Estimated savings (e.g., "~80% cheaper") */
+    estimatedSavings: string;
+    /** Priority for sorting suggestions */
+    priority: 'high' | 'medium' | 'low';
+}
+/**
+ * Context for generating optimization suggestions.
+ */
+export interface OptimizationContext {
+    /** Estimated cost in USD */
+    estimatedCost: number;
+    /** Number of tools discovered */
+    toolCount: number;
+    /** Number of personas being used */
+    personaCount: number;
+    /** Whether using parallel personas */
+    isParallelPersonas: boolean;
+    /** Whether using a premium model (--quality flag) */
+    isPremiumModel: boolean;
+    /** Whether using CI preset */
+    isUsingCiPreset: boolean;
+    /** Whether scenarios file exists */
+    hasScenariosFile: boolean;
+}
+/**
+ * Generate optimization suggestions based on the interview context.
+ */
+export declare function suggestOptimizations(context: OptimizationContext): OptimizationSuggestion[];
+/**
+ * Format optimization suggestions for CLI display.
+ */
+export declare function formatOptimizationSuggestions(suggestions: OptimizationSuggestion[], maxSuggestions?: number): string;
+//# sourceMappingURL=tracker.d.ts.map

package/dist/cost/tracker.js

@@ -0,0 +1,313 @@
+/**
+ * Cost tracking and estimation for LLM API usage.
+ */
+import { FORMATTING, COST_THRESHOLDS, TIME_ESTIMATION, } from '../constants.js';
+/**
+ * Pricing per 1M tokens (input/output) for various models.
+ * Prices as of January 2026.
+ */
+const MODEL_PRICING = {
+    // OpenAI models - GPT-5 series (latest)
+    'gpt-5.2': { input: 1.75, output: 14.00 },
+    'gpt-5.1': { input: 1.25, output: 10.00 },
+    'gpt-5': { input: 1.25, output: 10.00 },
+    'gpt-5-mini': { input: 0.25, output: 2.00 },
+    'gpt-5-nano': { input: 0.05, output: 0.40 },
+    // OpenAI models - GPT-4.1 series (legacy)
+    'gpt-4.1': { input: 2.00, output: 8.00 },
+    'gpt-4.1-mini': { input: 0.40, output: 1.60 },
+    'gpt-4.1-nano': { input: 0.10, output: 0.40 },
+    // OpenAI models - GPT-4o series (legacy)
+    'gpt-4o': { input: 2.50, output: 10.00 },
+    'gpt-4o-mini': { input: 0.15, output: 0.60 },
+    'gpt-4-turbo': { input: 10.00, output: 30.00 },
+    'gpt-4': { input: 30.00, output: 60.00 },
+    'gpt-3.5-turbo': { input: 0.50, output: 1.50 },
+    // Anthropic models - Claude 4.5 series (latest)
+    'claude-opus-4-5': { input: 5.00, output: 25.00 },
+    'claude-opus-4-5-20251101': { input: 5.00, output: 25.00 },
+    'claude-sonnet-4-5': { input: 3.00, output: 15.00 },
+    'claude-sonnet-4-5-20250929': { input: 3.00, output: 15.00 },
+    'claude-haiku-4-5': { input: 1.00, output: 5.00 },
+    'claude-haiku-4-5-20251001': { input: 1.00, output: 5.00 },
+    // Anthropic models - Claude 4 series (legacy)
+    'claude-opus-4-20250514': { input: 15.00, output: 75.00 },
+    'claude-sonnet-4-20250514': { input: 3.00, output: 15.00 },
+    // Anthropic models - Claude 3.x series (legacy)
+    'claude-3-5-sonnet-20241022': { input: 3.00, output: 15.00 },
+    'claude-3-5-haiku-20241022': { input: 0.80, output: 4.00 },
+    'claude-3-opus-20240229': { input: 15.00, output: 75.00 },
+    'claude-3-sonnet-20240229': { input: 3.00, output: 15.00 },
+    'claude-3-haiku-20240307': { input: 0.25, output: 1.25 },
+    // Ollama (local, no cost)
+    'llama3.2': { input: 0, output: 0 },
+    'llama3.1': { input: 0, output: 0 },
+    'mixtral': { input: 0, output: 0 },
+    'codellama': { input: 0, output: 0 },
+    'gemma3': { input: 0, output: 0 },
+    'gemma2': { input: 0, output: 0 },
+    'qwen3': { input: 0, output: 0 },
+    'qwen3:8b': { input: 0, output: 0 },
+    'qwen3:4b': { input: 0, output: 0 },
+    'qwen2.5': { input: 0, output: 0 },
+    'phi3': { input: 0, output: 0 },
+    'mistral': { input: 0, output: 0 },
+};
+/**
+ * Cumulative cost tracker for a session.
+ */
+export class CostTracker {
+    model;
+    totalInputTokens = 0;
+    totalOutputTokens = 0;
+    callCount = 0;
+    constructor(model) {
+        this.model = model;
+    }
+    /**
+     * Add token usage from an API call.
+     */
+    addUsage(inputTokens, outputTokens) {
+        this.totalInputTokens += inputTokens;
+        this.totalOutputTokens += outputTokens;
+        this.callCount++;
+    }
+    /**
+     * Get total usage so far.
+     */
+    getUsage() {
+        return {
+            inputTokens: this.totalInputTokens,
+            outputTokens: this.totalOutputTokens,
+            totalTokens: this.totalInputTokens + this.totalOutputTokens,
+        };
+    }
+    /**
+     * Get total cost estimate.
+     */
+    getCost() {
+        const usage = this.getUsage();
+        const pricing = MODEL_PRICING[this.model] ?? { input: 0, output: 0 };
+        const inputCost = (usage.inputTokens / 1_000_000) * pricing.input;
+        const outputCost = (usage.outputTokens / 1_000_000) * pricing.output;
+        return {
+            usage,
+            costUSD: inputCost + outputCost,
+            model: this.model,
+            breakdown: {
+                inputCost,
+                outputCost,
+            },
+        };
+    }
+    /**
+     * Get call count.
+     */
+    getCallCount() {
+        return this.callCount;
+    }
+    /**
+     * Format cost summary for display.
+     */
+    formatSummary() {
+        const cost = this.getCost();
+        const usage = cost.usage;
+        const lines = [
+            `LLM Usage Summary:`,
+            `  Model: ${cost.model}`,
+            `  API Calls: ${this.callCount}`,
+            `  Tokens: ${usage.totalTokens.toLocaleString()} (${usage.inputTokens.toLocaleString()} in, ${usage.outputTokens.toLocaleString()} out)`,
+        ];
+        if (cost.costUSD > 0) {
+            lines.push(`  Estimated Cost: $${cost.costUSD.toFixed(FORMATTING.PRICE_PRECISION)}`);
+        }
+        else {
+            lines.push(`  Estimated Cost: Free (local model)`);
+        }
+        return lines.join('\n');
+    }
+}
+/**
+ * Estimate cost for an interview before running.
+ */
+export function estimateInterviewCost(model, toolCount, questionsPerTool, personas = 3) {
+    // Average estimates based on typical interview patterns
+    const avgInputPerQuestion = 500; // tokens
+    const avgOutputPerQuestion = 300; // tokens
+    const totalQuestions = toolCount * questionsPerTool * personas;
+    // Add overhead for system prompts and tool schemas
+    const schemaOverhead = toolCount * 200; // tokens per tool schema
+    const inputTokens = (totalQuestions * avgInputPerQuestion) + schemaOverhead;
+    const outputTokens = totalQuestions * avgOutputPerQuestion;
+    const pricing = MODEL_PRICING[model] ?? { input: 0, output: 0 };
+    const inputCost = (inputTokens / 1_000_000) * pricing.input;
+    const outputCost = (outputTokens / 1_000_000) * pricing.output;
+    return {
+        usage: {
+            inputTokens,
+            outputTokens,
+            totalTokens: inputTokens + outputTokens,
+        },
+        costUSD: inputCost + outputCost,
+        model,
+        breakdown: {
+            inputCost,
+            outputCost,
+        },
+    };
+}
+/**
+ * Format a pre-interview cost estimate.
+ */
+export function formatCostEstimate(estimate) {
+    const lines = [
+        `Cost Estimate for Interview:`,
+        `  Model: ${estimate.model}`,
+        `  Estimated Tokens: ~${estimate.usage.totalTokens.toLocaleString()}`,
+    ];
+    if (estimate.costUSD > 0) {
+        lines.push(`  Estimated Cost: ~$${estimate.costUSD.toFixed(FORMATTING.PRICE_PRECISION)}`);
+    }
+    else {
+        lines.push(`  Estimated Cost: Free (local model)`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Get pricing info for a model.
+ */
+export function getModelPricing(model) {
+    return MODEL_PRICING[model] ?? null;
+}
+/**
+ * Check if a provider uses local inference (slower than cloud APIs).
+ */
+export function isLocalProvider(provider) {
+    return provider === 'ollama';
+}
+/**
+ * Estimate interview time based on tool count and configuration.
+ */
+export function estimateInterviewTime(toolCount, questionsPerTool, personas, parallelPersonas = false, provider = 'openai', promptCount = 0, resourceCount = 0, checkMode = false) {
+    const isLocal = isLocalProvider(provider);
+    // Fast CI mode: skips all LLM calls, only executes tool calls
+    if (checkMode) {
+        // Just tool execution + network overhead
+        const totalItems = toolCount + promptCount + resourceCount;
+        const executionTime = totalItems * 0.5; // ~0.5s per item for direct calls
+        const fixedOverhead = TIME_ESTIMATION.DISCOVERY_OVERHEAD_SECONDS + 5; // Discovery + minimal synthesis
+        const totalSeconds = executionTime + fixedOverhead;
+        return {
+            durationSeconds: Math.round(totalSeconds),
+            durationMinutes: Math.max(1, Math.round(totalSeconds / 60)),
+            isParallel: parallelPersonas,
+            isLocalModel: isLocal,
+        };
+    }
+    const totalQuestions = toolCount * questionsPerTool * personas;
+    // Base time: seconds per question + overhead per tool
+    const questionTime = totalQuestions * TIME_ESTIMATION.SECONDS_PER_QUESTION;
+    const toolOverhead = toolCount * TIME_ESTIMATION.SECONDS_PER_TOOL_OVERHEAD;
+    // Add time for prompts and resources
+    const promptTime = promptCount * TIME_ESTIMATION.SECONDS_PER_PROMPT;
+    const resourceTime = resourceCount * TIME_ESTIMATION.SECONDS_PER_RESOURCE;
+    // Fixed overhead for discovery and synthesis
+    const fixedOverhead = TIME_ESTIMATION.DISCOVERY_OVERHEAD_SECONDS +
+        TIME_ESTIMATION.SYNTHESIS_OVERHEAD_SECONDS;
+    let totalSeconds = questionTime + toolOverhead + promptTime + resourceTime + fixedOverhead;
+    // Apply parallel efficiency if running personas in parallel
+    if (parallelPersonas && personas > 1) {
+        // Parallel execution reduces the question time portion
+        const parallelFactor = 1 - (1 - 1 / personas) * TIME_ESTIMATION.PARALLEL_EFFICIENCY;
+        totalSeconds =
+            questionTime * parallelFactor + toolOverhead + promptTime + resourceTime + fixedOverhead;
+    }
+    // Local models (Ollama) are significantly slower than cloud APIs
+    if (isLocal) {
+        totalSeconds *= TIME_ESTIMATION.LOCAL_MODEL_MULTIPLIER;
+    }
+    return {
+        durationSeconds: Math.round(totalSeconds),
+        durationMinutes: Math.max(1, Math.round(totalSeconds / 60)),
+        isParallel: parallelPersonas,
+        isLocalModel: isLocal,
+    };
+}
+/**
+ * Format a combined cost and time estimate for display.
+ */
+export function formatCostAndTimeEstimate(cost, time) {
+    const costStr = cost.costUSD > 0
+        ? `~$${cost.costUSD.toFixed(2)}`
+        : 'Free (local)';
+    const timeStr = `~${time.durationMinutes} min`;
+    // Add note for local models being slower
+    const localNote = time.isLocalModel ? ' (local models are slower)' : '';
+    return `Estimated: ${costStr} | ${timeStr}${localNote}`;
+}
+/**
+ * Generate optimization suggestions based on the interview context.
+ */
+export function suggestOptimizations(context) {
+    const suggestions = [];
+    // Suggest --ci if cost > threshold and not already using ci preset
+    if (context.estimatedCost > COST_THRESHOLDS.SUGGEST_CI_THRESHOLD &&
+        !context.isUsingCiPreset) {
+        suggestions.push({
+            flag: '--ci',
+            description: 'Use CI mode for fast, cheap runs',
+            estimatedSavings: '~80% cheaper',
+            priority: 'high',
+        });
+    }
+    // Suggest --scenarios-only if cost > threshold and has scenarios file
+    if (context.estimatedCost > COST_THRESHOLDS.SUGGEST_SCENARIOS_ONLY_THRESHOLD &&
+        context.hasScenariosFile) {
+        suggestions.push({
+            flag: '--scenarios-only',
+            description: 'Run only custom scenarios (no LLM)',
+            estimatedSavings: 'Free',
+            priority: 'high',
+        });
+    }
+    // Suggest --parallel-personas if many tools and multiple personas
+    if (context.toolCount >= COST_THRESHOLDS.PARALLEL_PERSONAS_TOOL_THRESHOLD &&
+        context.personaCount > 1 &&
+        !context.isParallelPersonas) {
+        suggestions.push({
+            flag: '--parallel-personas',
+            description: 'Run personas in parallel',
+            estimatedSavings: '~50% faster',
+            priority: 'medium',
+        });
+    }
+    // Suggest removing --quality if premium model + many tools
+    if (context.isPremiumModel &&
+        context.toolCount >= COST_THRESHOLDS.QUALITY_TOOL_THRESHOLD) {
+        suggestions.push({
+            flag: 'remove --quality',
+            description: 'Use budget model for large codebases',
+            estimatedSavings: '~60% cheaper',
+            priority: 'medium',
+        });
+    }
+    // Sort by priority
+    const priorityOrder = { high: 0, medium: 1, low: 2 };
+    suggestions.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+    return suggestions;
+}
+/**
+ * Format optimization suggestions for CLI display.
+ */
+export function formatOptimizationSuggestions(suggestions, maxSuggestions = 3) {
+    if (suggestions.length === 0) {
+        return '';
+    }
+    const lines = ['Optimization suggestions:'];
+    const toShow = suggestions.slice(0, maxSuggestions);
+    for (const suggestion of toShow) {
+        lines.push(`  ${suggestion.flag} - ${suggestion.description} (${suggestion.estimatedSavings})`);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=tracker.js.map

package/dist/discovery/discovery.d.ts

@@ -0,0 +1,16 @@
+import type { MCPClient } from '../transport/mcp-client.js';
+import type { DiscoveryResult, ToolDetail } from './types.js';
+import type { MCPTool } from '../transport/types.js';
+/**
+ * Discover an MCP server's capabilities by connecting and querying it.
+ */
+export declare function discover(client: MCPClient, command: string, args: string[]): Promise<DiscoveryResult>;
+/**
+ * Parse tool information into a more detailed structure.
+ */
+export declare function parseToolDetail(tool: MCPTool): ToolDetail;
+/**
+ * Generate a summary of discovered capabilities.
+ */
+export declare function summarizeDiscovery(result: DiscoveryResult): string;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/discovery/discovery.js

@@ -0,0 +1,173 @@
+import { getLogger } from '../logging/logger.js';
+import { DISPLAY_LIMITS } from '../constants.js';
+const logger = getLogger('discovery');
+/**
+ * Discover an MCP server's capabilities by connecting and querying it.
+ */
+export async function discover(client, command, args) {
+    // Initialize connection
+    const initResult = await client.initialize();
+    // Discover tools
+    let tools = [];
+    if (initResult.capabilities.tools) {
+        try {
+            tools = await client.listTools();
+        }
+        catch (error) {
+            logger.error({ error }, 'Failed to list tools');
+        }
+    }
+    // Discover prompts
+    let prompts = [];
+    if (initResult.capabilities.prompts) {
+        try {
+            prompts = await client.listPrompts();
+        }
+        catch (error) {
+            logger.error({ error }, 'Failed to list prompts');
+        }
+    }
+    // Discover resources
+    let resources = [];
+    if (initResult.capabilities.resources) {
+        try {
+            resources = await client.listResources();
+        }
+        catch (error) {
+            logger.error({ error }, 'Failed to list resources');
+        }
+    }
+    return {
+        serverInfo: initResult.serverInfo,
+        protocolVersion: initResult.protocolVersion,
+        capabilities: initResult.capabilities,
+        tools,
+        prompts,
+        resources,
+        timestamp: new Date(),
+        serverCommand: command,
+        serverArgs: args,
+    };
+}
+/**
+ * Parse tool information into a more detailed structure.
+ */
+export function parseToolDetail(tool) {
+    const schema = tool.inputSchema;
+    const requiredParams = schema?.required ?? [];
+    const optionalParams = [];
+    if (schema?.properties) {
+        for (const param of Object.keys(schema.properties)) {
+            if (!requiredParams.includes(param)) {
+                optionalParams.push(param);
+            }
+        }
+    }
+    return {
+        name: tool.name,
+        description: tool.description ?? 'No description provided',
+        inputSchema: schema ?? null,
+        requiredParams,
+        optionalParams,
+    };
+}
+/**
+ * Generate a summary of discovered capabilities.
+ */
+export function summarizeDiscovery(result) {
+    const lines = [];
+    // Header with box drawing
+    lines.push('┌─────────────────────────────────────────────────────────────────┐');
+    lines.push(`│  ${result.serverInfo.name} v${result.serverInfo.version}`.padEnd(66) + '│');
+    lines.push('└─────────────────────────────────────────────────────────────────┘');
+    lines.push('');
+    // Server info
+    lines.push(`Protocol Version: ${result.protocolVersion}`);
+    lines.push(`Server Command: ${result.serverCommand} ${result.serverArgs.join(' ')}`);
+    lines.push('');
+    // Capabilities overview
+    lines.push('CAPABILITIES');
+    lines.push('────────────');
+    const caps = [];
+    if (result.capabilities.tools)
+        caps.push(`${result.tools.length} Tools`);
+    if (result.capabilities.prompts)
+        caps.push(`${result.prompts.length} Prompts`);
+    if (result.capabilities.resources)
+        caps.push(`${(result.resources ?? []).length} Resources`);
+    if (result.capabilities.logging)
+        caps.push('Logging');
+    lines.push(caps.join(' • ') || 'None discovered');
+    lines.push('');
+    // Tools section
+    if (result.tools.length > 0) {
+        lines.push('TOOLS');
+        lines.push('─────');
+        for (const tool of result.tools) {
+            const detail = parseToolDetail(tool);
+            const requiredStr = detail.requiredParams.length > 0
+                ? detail.requiredParams.join(', ')
+                : '';
+            const optionalStr = detail.optionalParams.length > 0
+                ? detail.optionalParams.map(p => `${p}?`).join(', ')
+                : '';
+            const allParams = [requiredStr, optionalStr].filter(Boolean).join(', ');
+            lines.push(`  ${tool.name}(${allParams})`);
+            if (tool.description) {
+                // Truncate long descriptions
+                const desc = tool.description.length > DISPLAY_LIMITS.DESCRIPTION_MAX_LENGTH
+                    ? tool.description.substring(0, DISPLAY_LIMITS.DESCRIPTION_TRUNCATE_AT) + '...'
+                    : tool.description;
+                lines.push(`    └─ ${desc}`);
+            }
+        }
+        lines.push('');
+    }
+    // Prompts section
+    if (result.prompts.length > 0) {
+        lines.push('PROMPTS');
+        lines.push('───────');
+        for (const prompt of result.prompts) {
+            const args = prompt.arguments?.map(a => {
+                return a.required ? a.name : `${a.name}?`;
+            }).join(', ') ?? '';
+            lines.push(`  ${prompt.name}(${args})`);
+            if (prompt.description) {
+                const desc = prompt.description.length > DISPLAY_LIMITS.DESCRIPTION_MAX_LENGTH
+                    ? prompt.description.substring(0, DISPLAY_LIMITS.DESCRIPTION_TRUNCATE_AT) + '...'
+                    : prompt.description;
+                lines.push(`    └─ ${desc}`);
+            }
+        }
+        lines.push('');
+    }
+    // Resources section
+    const resources = result.resources ?? [];
+    if (resources.length > 0) {
+        lines.push('RESOURCES');
+        lines.push('─────────');
+        for (const resource of resources) {
+            const mimeType = resource.mimeType ? ` [${resource.mimeType}]` : '';
+            lines.push(`  ${resource.name}${mimeType}`);
+            lines.push(`    URI: ${resource.uri}`);
+            if (resource.description) {
+                const desc = resource.description.length > DISPLAY_LIMITS.DESCRIPTION_MAX_LENGTH
+                    ? resource.description.substring(0, DISPLAY_LIMITS.DESCRIPTION_TRUNCATE_AT) + '...'
+                    : resource.description;
+                lines.push(`    └─ ${desc}`);
+            }
+        }
+        lines.push('');
+    }
+    // Quick start hint
+    lines.push('QUICK START');
+    lines.push('───────────');
+    lines.push(`  bellwether check ${result.serverCommand} ${result.serverArgs.join(' ')}`);
+    lines.push(`  bellwether explore ${result.serverCommand} ${result.serverArgs.join(' ')}`);
+    lines.push('');
+    lines.push('  Commands:');
+    lines.push('    check    Schema validation and drift detection (free, fast)');
+    lines.push('    explore  LLM-powered behavioral exploration');
+    return lines.join('\n');
+}
+//# sourceMappingURL=discovery.js.map

package/dist/discovery/types.d.ts

@@ -0,0 +1,51 @@
+import type { MCPTool, MCPPrompt, MCPResource, MCPServerInfo, MCPServerCapabilities } from '../transport/types.js';
+/**
+ * Result of discovering an MCP server's capabilities.
+ */
+export interface DiscoveryResult {
+    /** Server identification info */
+    serverInfo: MCPServerInfo;
+    /** Protocol version negotiated */
+    protocolVersion: string;
+    /** Server capabilities */
+    capabilities: MCPServerCapabilities;
+    /** List of available tools */
+    tools: MCPTool[];
+    /** List of available prompts */
+    prompts: MCPPrompt[];
+    /** List of available resources */
+    resources: MCPResource[];
+    /** Timestamp of discovery */
+    timestamp: Date;
+    /** Command used to start the server */
+    serverCommand: string;
+    /** Arguments passed to the server */
+    serverArgs: string[];
+}
+/**
+ * Detailed tool information with parsed schema.
+ */
+export interface ToolDetail {
+    name: string;
+    description: string;
+    inputSchema: ToolInputSchema | null;
+    requiredParams: string[];
+    optionalParams: string[];
+}
+/**
+ * Parsed JSON Schema for tool inputs.
+ */
+export interface ToolInputSchema {
+    type: string;
+    properties?: Record<string, PropertySchema>;
+    required?: string[];
+    additionalProperties?: boolean;
+}
+export interface PropertySchema {
+    type: string;
+    description?: string;
+    enum?: string[];
+    default?: unknown;
+    items?: PropertySchema;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/discovery/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/docs/agents.d.ts

@@ -0,0 +1,3 @@
+import type { InterviewResult } from '../interview/types.js';
+export declare function generateAgentsMd(result: InterviewResult): string;
+//# sourceMappingURL=agents.d.ts.map