@dotsetlabs/bellwether 0.10.0

package/dist/baseline/incremental-checker.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Incremental checking for faster CI runs.
+ *
+ * Compares current tool schemas against a baseline to determine which tools
+ * need retesting. Tools with unchanged schemas can use cached results.
+ */
+import type { MCPTool } from '../transport/types.js';
+import type { BehavioralBaseline, ToolFingerprint } from './types.js';
+/**
+ * Result of incremental analysis.
+ */
+export interface IncrementalCheckResult {
+    /** Tools that need testing (new or changed schema) */
+    toolsToTest: string[];
+    /** Tools that can use cached results */
+    toolsToSkip: string[];
+    /** Tool fingerprints from baseline for skipped tools */
+    cachedFingerprints: ToolFingerprint[];
+    /** Summary of what changed */
+    changeSummary: IncrementalChangeSummary;
+}
+/**
+ * Summary of changes detected during incremental analysis.
+ */
+export interface IncrementalChangeSummary {
+    /** Number of new tools (not in baseline) */
+    newTools: number;
+    /** Number of tools with changed schemas */
+    changedTools: number;
+    /** Number of tools with unchanged schemas */
+    unchangedTools: number;
+    /** Number of removed tools (in baseline but not current) */
+    removedTools: number;
+    /** Names of new tools */
+    newToolNames: string[];
+    /** Names of changed tools */
+    changedToolNames: string[];
+    /** Names of removed tools */
+    removedToolNames: string[];
+}
+/**
+ * Options for incremental checking.
+ */
+export interface IncrementalCheckOptions {
+    /** Force retest even if schema unchanged */
+    forceRetest?: boolean;
+    /** Specific tools to always retest */
+    alwaysRetest?: string[];
+    /** Maximum age of cached results in hours (default: 168 = 1 week) */
+    maxCacheAgeHours?: number;
+}
+/**
+ * Determine which tools need testing based on schema changes.
+ *
+ * Algorithm:
+ * 1. Load previous baseline
+ * 2. Compare current tool schemas to baseline inputSchemaHash
+ * 3. Return list of tools that need testing (new or changed)
+ * 4. Return cached fingerprints for unchanged tools
+ *
+ * @param currentTools - Current tools from discovery
+ * @param baseline - Previous baseline to compare against
+ * @param options - Incremental check options
+ * @returns Analysis result with tools to test and cached data
+ */
+export declare function analyzeForIncremental(currentTools: MCPTool[], baseline: BehavioralBaseline | null, options?: IncrementalCheckOptions): IncrementalCheckResult;
+/**
+ * Merge new test results with cached fingerprints to create a complete baseline.
+ *
+ * @param newFingerprints - Fingerprints from newly tested tools
+ * @param cachedFingerprints - Fingerprints from skipped tools (cached)
+ * @returns Combined fingerprints in deterministic order
+ */
+export declare function mergeFingerprints(newFingerprints: ToolFingerprint[], cachedFingerprints: ToolFingerprint[]): ToolFingerprint[];
+/**
+ * Format incremental check summary for display.
+ *
+ * @param summary - The incremental change summary
+ * @returns Human-readable summary
+ */
+export declare function formatIncrementalSummary(summary: IncrementalChangeSummary): string;
+/**
+ * Check if incremental mode can provide meaningful speedup.
+ *
+ * @param result - Incremental check result
+ * @returns true if skipping tools provides >20% speedup
+ */
+export declare function isIncrementalWorthwhile(result: IncrementalCheckResult): boolean;
+/**
+ * Update tool fingerprints with incremental metadata.
+ *
+ * @param fingerprint - Tool fingerprint to update
+ * @param schemaHash - Current schema hash
+ * @returns Updated fingerprint with lastTestedAt and inputSchemaHashAtTest
+ */
+export declare function addIncrementalMetadata(fingerprint: ToolFingerprint, schemaHash: string): ToolFingerprint;
+//# sourceMappingURL=incremental-checker.d.ts.map

package/dist/baseline/incremental-checker.js

@@ -0,0 +1,174 @@
+/**
+ * Incremental checking for faster CI runs.
+ *
+ * Compares current tool schemas against a baseline to determine which tools
+ * need retesting. Tools with unchanged schemas can use cached results.
+ */
+import { computeSchemaHash } from './schema-compare.js';
+/**
+ * Determine which tools need testing based on schema changes.
+ *
+ * Algorithm:
+ * 1. Load previous baseline
+ * 2. Compare current tool schemas to baseline inputSchemaHash
+ * 3. Return list of tools that need testing (new or changed)
+ * 4. Return cached fingerprints for unchanged tools
+ *
+ * @param currentTools - Current tools from discovery
+ * @param baseline - Previous baseline to compare against
+ * @param options - Incremental check options
+ * @returns Analysis result with tools to test and cached data
+ */
+export function analyzeForIncremental(currentTools, baseline, options = {}) {
+    const { forceRetest = false, alwaysRetest = [], maxCacheAgeHours = 168, // 1 week
+     } = options;
+    // If no baseline or force retest, test everything
+    if (!baseline || forceRetest) {
+        return {
+            toolsToTest: currentTools.map(t => t.name),
+            toolsToSkip: [],
+            cachedFingerprints: [],
+            changeSummary: {
+                newTools: baseline ? 0 : currentTools.length,
+                changedTools: 0,
+                unchangedTools: 0,
+                removedTools: 0,
+                newToolNames: baseline ? [] : currentTools.map(t => t.name),
+                changedToolNames: [],
+                removedToolNames: [],
+            },
+        };
+    }
+    const toolsToTest = [];
+    const toolsToSkip = [];
+    const cachedFingerprints = [];
+    const newToolNames = [];
+    const changedToolNames = [];
+    const removedToolNames = [];
+    // Build maps for comparison
+    const baselineToolMap = new Map(baseline.tools.map(t => [t.name, t]));
+    const currentToolSet = new Set(currentTools.map(t => t.name));
+    // Check current tools against baseline
+    for (const tool of currentTools) {
+        const baselineTool = baselineToolMap.get(tool.name);
+        // Always retest if in the alwaysRetest list
+        if (alwaysRetest.includes(tool.name)) {
+            toolsToTest.push(tool.name);
+            continue;
+        }
+        if (!baselineTool) {
+            // New tool - needs testing
+            toolsToTest.push(tool.name);
+            newToolNames.push(tool.name);
+            continue;
+        }
+        // Check if schema changed
+        const currentSchemaHash = computeSchemaHash(tool.inputSchema);
+        const baselineSchemaHash = baselineTool.schemaHash;
+        if (currentSchemaHash !== baselineSchemaHash) {
+            // Schema changed - needs retesting
+            toolsToTest.push(tool.name);
+            changedToolNames.push(tool.name);
+            continue;
+        }
+        // Check cache age if lastTestedAt is available
+        if (baselineTool.lastTestedAt) {
+            const testedAt = new Date(baselineTool.lastTestedAt);
+            const ageHours = (Date.now() - testedAt.getTime()) / (1000 * 60 * 60);
+            if (ageHours > maxCacheAgeHours) {
+                // Cache too old - needs retesting
+                toolsToTest.push(tool.name);
+                continue;
+            }
+        }
+        // Schema unchanged and cache valid - can skip
+        toolsToSkip.push(tool.name);
+        cachedFingerprints.push(baselineTool);
+    }
+    // Find removed tools (in baseline but not current)
+    for (const [name] of baselineToolMap) {
+        if (!currentToolSet.has(name)) {
+            removedToolNames.push(name);
+        }
+    }
+    return {
+        toolsToTest,
+        toolsToSkip,
+        cachedFingerprints,
+        changeSummary: {
+            newTools: newToolNames.length,
+            changedTools: changedToolNames.length,
+            unchangedTools: toolsToSkip.length,
+            removedTools: removedToolNames.length,
+            newToolNames,
+            changedToolNames,
+            removedToolNames,
+        },
+    };
+}
+/**
+ * Merge new test results with cached fingerprints to create a complete baseline.
+ *
+ * @param newFingerprints - Fingerprints from newly tested tools
+ * @param cachedFingerprints - Fingerprints from skipped tools (cached)
+ * @returns Combined fingerprints in deterministic order
+ */
+export function mergeFingerprints(newFingerprints, cachedFingerprints) {
+    // Combine all fingerprints
+    const combined = [...newFingerprints, ...cachedFingerprints];
+    // Sort by name for deterministic ordering
+    return combined.sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Format incremental check summary for display.
+ *
+ * @param summary - The incremental change summary
+ * @returns Human-readable summary
+ */
+export function formatIncrementalSummary(summary) {
+    const parts = [];
+    if (summary.newTools > 0) {
+        parts.push(`${summary.newTools} new tool${summary.newTools > 1 ? 's' : ''}`);
+    }
+    if (summary.changedTools > 0) {
+        parts.push(`${summary.changedTools} changed`);
+    }
+    if (summary.unchangedTools > 0) {
+        parts.push(`${summary.unchangedTools} cached`);
+    }
+    if (summary.removedTools > 0) {
+        parts.push(`${summary.removedTools} removed`);
+    }
+    if (parts.length === 0) {
+        return 'No tools to check';
+    }
+    return parts.join(', ');
+}
+/**
+ * Check if incremental mode can provide meaningful speedup.
+ *
+ * @param result - Incremental check result
+ * @returns true if skipping tools provides >20% speedup
+ */
+export function isIncrementalWorthwhile(result) {
+    const total = result.toolsToTest.length + result.toolsToSkip.length;
+    if (total === 0)
+        return false;
+    const skipRatio = result.toolsToSkip.length / total;
+    return skipRatio > 0.2; // At least 20% can be skipped
+}
+/**
+ * Update tool fingerprints with incremental metadata.
+ *
+ * @param fingerprint - Tool fingerprint to update
+ * @param schemaHash - Current schema hash
+ * @returns Updated fingerprint with lastTestedAt and inputSchemaHashAtTest
+ */
+export function addIncrementalMetadata(fingerprint, schemaHash) {
+    return {
+        ...fingerprint,
+        lastTestedAt: new Date(),
+        inputSchemaHashAtTest: schemaHash,
+    };
+}
+//# sourceMappingURL=incremental-checker.js.map

package/dist/baseline/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Baseline module - structural drift detection.
+ */
+export type { ChangeSeverity, BehaviorAspect, BehavioralAssertion, BehaviorChange, ToolDiff, BehavioralDiff, ToolFingerprint, ServerFingerprint, BehavioralBaseline, WorkflowSignature, CompareOptions, BaselineMode, VersionCompatibilityInfo, DriftAcceptance, AcceptedDiff, SeverityConfig, SchemaEvolutionReport, SchemaEvolutionIssue, PerformanceRegressionReport, PerformanceRegression, PerformanceConfidence, PerformanceConfidenceChange, ConfidenceLevel, DocumentationScore, DocumentationScoreSummary, DocumentationScoreChange, DocumentationIssue, DocumentationGrade, DocumentationComponents, ToolDocumentationScore, } from './types.js';
+export { createBaseline, saveBaseline, loadBaseline, verifyIntegrity, baselineExists, recalculateIntegrityHash, acceptDrift, hasAcceptance, clearAcceptance, type LoadBaselineOptions, type AcceptDriftOptions, } from './saver.js';
+export { compareWithBaseline, compareBaselines, hasBreakingChanges, hasSecurityChanges, filterByMinimumSeverity, checkBaselineVersionCompatibility, compareSeverity, severityMeetsThreshold, applyAspectOverride, applySeverityConfig, shouldFailOnDiff, } from './comparator.js';
+export { formatDiffText, formatDiffJson, formatDiffCompact, formatDiffGitHubActions, formatDiffMarkdown, formatDiffJUnit, formatDiffSarif, formatSecurityReport, } from './diff.js';
+export { convertToCloudBaseline, createCloudBaseline, } from './converter.js';
+export { computeSchemaHash, compareSchemas, computeConsensusSchemaHash, type SchemaChangeType, type SchemaChange, type SchemaComparisonResult, } from './schema-compare.js';
+export { getBaselineVersion, parseVersion, areVersionsCompatible, compareVersions, getCompatibilityWarning, checkVersionCompatibility, assertVersionCompatibility, formatVersion, isCurrentVersion, isOlderVersion, isNewerVersion, requiresMigration, BaselineVersionError, type FormatVersion, type VersionCompatibility, } from './version.js';
+export { migrateBaseline, canMigrate, getMigrationsToApply, needsMigration, getMigrationInfo, } from './migrations.js';
+export { analyzeForIncremental, mergeFingerprints, formatIncrementalSummary, isIncrementalWorthwhile, addIncrementalMetadata, type IncrementalCheckResult, type IncrementalChangeSummary, type IncrementalCheckOptions, } from './incremental-checker.js';
+export { analyzeResponses, inferSchemaFromValue, compareFingerprints, compareErrorPatterns, computeInferredSchemaHash, type ResponseFingerprint, type ResponseContentType, type ResponseSize, type InferredSchema, type ErrorPattern, type ResponseAnalysis, type FingerprintDiff, type FingerprintChange, type ErrorPatternDiff, } from './response-fingerprint.js';
+export { compareInferredSchemas, buildSchemaEvolution, compareSchemaEvolution, formatSchemaEvolution, formatSchemaEvolutionDiff, hasSchemaEvolutionIssues, getSchemaStabilityGrade, type ResponseSchemaEvolution, type SchemaVersion as SchemaEvolutionVersion, type SchemaEvolutionDiff, type SchemaTypeChange, } from './response-schema-tracker.js';
+export { analyzeToolChangeImpact, analyzeDiffImpact, analyzeSchemaChanges, isBreakingChange, getBreakingChangeSummary, CHANGE_IMPACT, type SchemaChangeType as ImpactSchemaChangeType, type SchemaChangeDetail, type MigrationComplexity, type ChangeImpact, type DiffImpactAnalysis, type ActionItem, } from './change-impact-analyzer.js';
+export { calculateMetrics, createPerformanceBaseline, extractPerformanceBaselines, comparePerformance, generatePerformanceReport, formatMetrics, formatComparison, isPerformanceAcceptable, aggregateSamplesByTool, calculatePerformanceConfidence, calculateConfidenceFromMetrics, formatConfidenceLevel, hasReliableConfidence, PERFORMANCE, type LatencyTrend, type ToolPerformanceMetrics, type PerformanceBaseline, type PerformanceComparison, type PerformanceReport, type LatencySample, } from './performance-tracker.js';
+export { checkDeprecations, checkToolDeprecation, markAsDeprecated, clearDeprecation, getDeprecatedTools, getExpiredTools, getUpcomingRemovals, formatDeprecationWarning, formatDeprecationReport, shouldFailOnDeprecation, DEPRECATION, DEPRECATION_DEFAULTS, DEPRECATION_THRESHOLDS, type DeprecationStatus, type DeprecationWarning, type DeprecationReport, type DeprecationConfig, } from './deprecation-tracker.js';
+export { calculateHealthScore, formatHealthScore, meetsHealthThreshold, getHealthBadgeColor, createHealthHistoryEntry, HEALTH_SCORING, HEALTH_WEIGHTS, GRADE_THRESHOLDS, SEVERITY_THRESHOLDS, HEALTH_PENALTIES, type HealthTrend, type ActionPriority, type HealthActionItem, type HealthComponents, type HealthScore, type HealthHistory, type HealthInput, } from './health-scorer.js';
+export { buildServerTimeline, buildToolTimeline, formatTimeline, formatServerTimelineSummary, generateVisualTimeline, serializeTimeline, deserializeTimeline, serializeServerTimeline, deserializeServerTimeline, getMostActiveTools, getMostBreakingTools, getBreakingChanges, getVersionAtTime, getChangesBetween, hadBreakingChanges, type SchemaEventType, type SchemaVersion, type SchemaTimeline, type ServerTimeline, type DeprecationEvent, type TimelineStats, type TimelineBuildOptions, } from './schema-evolution.js';
+export { generateMigrationGuide, formatMigrationGuideMarkdown, formatMigrationGuideText, hasBreakingMigrationChanges, getBreakingTools, type MigrationEffort, type MigrationStepType, type CodeExample, type BreakingChange, type MigrationStep, type MigrationGuide, type MigrationStats, } from './migration-generator.js';
+export { generateToolScenarios, generateBaselineScenarios, formatScenariosAsYaml, formatScenariosReport, getScenariosByPriority, getScenariosByCategory, getCriticalScenarios, getSecurityScenarios, type ScenarioCategory, type ScenarioPriority, type TestScenario, type AutoGeneratedScenarios, type ScenarioGenerationSummary, type ScenarioGenerationResult, type ScenarioGenerationConfig, } from './scenario-generator.js';
+export { generatePRComment, generateCompactPRComment, generateCIStatusSummary, generateDiffTable, generateBadgeUrl, generateBadgeMarkdown, getBadgeColor, shouldBlockMerge, getSeverityEmoji, type BadgeColor, type CommentSection, type AffectedWorkflow, type PRComment, type PRCommentConfig, } from './pr-comment-generator.js';
+export type { SecurityCategory, RiskLevel, SecurityPayload, SecurityTestResult, SecurityFinding, SecurityFingerprint, SecurityDiff, SecurityTestOptions, SecurityTestContext, SecurityToolCallResult, SecurityReport, } from '../security/types.js';
+export { runSecurityTests, compareSecurityFingerprints, getRiskLevelFromScore, parseSecurityCategories, getPayloadsForCategory, getAllSecurityPayloads, getAllSecurityCategories, } from '../security/index.js';
+export type { HttpStatusCategory, ErrorSeverity, EnhancedErrorAnalysis, ErrorAnalysisSummary, ErrorTrend, ErrorTrendReport, } from './error-analyzer.js';
+export { analyzeError, analyzeErrorPatterns, generateErrorSummary, analyzeErrorTrends, extractHttpStatus, categorizeHttpStatus, inferRootCause, generateRemediation, extractRelatedParameters, isTransientError, assessErrorSeverity, mapStatusToErrorCategory, formatEnhancedError, formatErrorTrendReport, formatCategoryName, } from './error-analyzer.js';
+export { scoreDocumentation, scoreToolDocumentation, calculateDescriptionCoverage, calculateDescriptionQuality, calculateParameterDocumentation, calculateExampleCoverage, hasExamples, scoreToGrade, generateSuggestions, compareDocumentationScores, formatDocumentationScore, formatDocumentationScoreCompact, formatDocumentationScoreChange, toDocumentationScoreSummary, getGradeIndicator, getGradeBadgeColor, meetsDocumentationThreshold, meetsDocumentationGrade, type DocumentationIssueSeverity, type DocumentationIssueType, } from './documentation-scorer.js';
+export { calculateAICompatibilityScore, generateAICompatibilityMarkdown, type AICompatibilityScore, type ScoreComponent, type AICompatibilityRecommendation, type ToolAIScore, type AICompatibilityInput, } from './ai-compatibility-scorer.js';
+export { calculateRiskScore, generateRiskScoreMarkdown, type RegressionRiskScore, type RiskFactor, } from './risk-scorer.js';
+export { calculatePruningDecisions, calculateToolPruning, prioritizeTools, generatePruningSummary, generatePruningMarkdown, type TestCategory, type TestCategoryDecision, type ToolPruningDecision, type ToolCharacteristics, type PruningInput, type PruningSummary, } from './test-pruner.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/baseline/index.js

@@ -0,0 +1,42 @@
+/**
+ * Baseline module - structural drift detection.
+ */
+export { createBaseline, saveBaseline, loadBaseline, verifyIntegrity, baselineExists, recalculateIntegrityHash, acceptDrift, hasAcceptance, clearAcceptance, } from './saver.js';
+export { compareWithBaseline, compareBaselines, hasBreakingChanges, hasSecurityChanges, filterByMinimumSeverity, checkBaselineVersionCompatibility, compareSeverity, severityMeetsThreshold, applyAspectOverride, applySeverityConfig, shouldFailOnDiff, } from './comparator.js';
+export { formatDiffText, formatDiffJson, formatDiffCompact, formatDiffGitHubActions, formatDiffMarkdown, formatDiffJUnit, formatDiffSarif, formatSecurityReport, } from './diff.js';
+export { convertToCloudBaseline, createCloudBaseline, } from './converter.js';
+export { computeSchemaHash, compareSchemas, computeConsensusSchemaHash, } from './schema-compare.js';
+export { getBaselineVersion, parseVersion, areVersionsCompatible, compareVersions, getCompatibilityWarning, checkVersionCompatibility, assertVersionCompatibility, formatVersion, isCurrentVersion, isOlderVersion, isNewerVersion, requiresMigration, BaselineVersionError, } from './version.js';
+export { migrateBaseline, canMigrate, getMigrationsToApply, needsMigration, getMigrationInfo, } from './migrations.js';
+// Incremental checking
+export { analyzeForIncremental, mergeFingerprints, formatIncrementalSummary, isIncrementalWorthwhile, addIncrementalMetadata, } from './incremental-checker.js';
+export { analyzeResponses, inferSchemaFromValue, compareFingerprints, compareErrorPatterns, computeInferredSchemaHash, } from './response-fingerprint.js';
+// Response schema evolution tracking
+export { compareInferredSchemas, buildSchemaEvolution, compareSchemaEvolution, formatSchemaEvolution, formatSchemaEvolutionDiff, hasSchemaEvolutionIssues, getSchemaStabilityGrade, } from './response-schema-tracker.js';
+// Change impact analysis
+export { analyzeToolChangeImpact, analyzeDiffImpact, analyzeSchemaChanges, isBreakingChange, getBreakingChangeSummary, CHANGE_IMPACT, } from './change-impact-analyzer.js';
+// Performance tracking
+export { calculateMetrics, createPerformanceBaseline, extractPerformanceBaselines, comparePerformance, generatePerformanceReport, formatMetrics, formatComparison, isPerformanceAcceptable, aggregateSamplesByTool, calculatePerformanceConfidence, calculateConfidenceFromMetrics, formatConfidenceLevel, hasReliableConfidence, PERFORMANCE, } from './performance-tracker.js';
+// Deprecation tracking
+export { checkDeprecations, checkToolDeprecation, markAsDeprecated, clearDeprecation, getDeprecatedTools, getExpiredTools, getUpcomingRemovals, formatDeprecationWarning, formatDeprecationReport, shouldFailOnDeprecation, DEPRECATION, DEPRECATION_DEFAULTS, DEPRECATION_THRESHOLDS, } from './deprecation-tracker.js';
+// Health scoring
+export { calculateHealthScore, formatHealthScore, meetsHealthThreshold, getHealthBadgeColor, createHealthHistoryEntry, HEALTH_SCORING, HEALTH_WEIGHTS, GRADE_THRESHOLDS, SEVERITY_THRESHOLDS, HEALTH_PENALTIES, } from './health-scorer.js';
+// Schema evolution timeline
+export { buildServerTimeline, buildToolTimeline, formatTimeline, formatServerTimelineSummary, generateVisualTimeline, serializeTimeline, deserializeTimeline, serializeServerTimeline, deserializeServerTimeline, getMostActiveTools, getMostBreakingTools, getBreakingChanges, getVersionAtTime, getChangesBetween, hadBreakingChanges, } from './schema-evolution.js';
+// Migration guide generation
+export { generateMigrationGuide, formatMigrationGuideMarkdown, formatMigrationGuideText, hasBreakingMigrationChanges, getBreakingTools, } from './migration-generator.js';
+// Auto-generated test scenarios
+export { generateToolScenarios, generateBaselineScenarios, formatScenariosAsYaml, formatScenariosReport, getScenariosByPriority, getScenariosByCategory, getCriticalScenarios, getSecurityScenarios, } from './scenario-generator.js';
+// Enhanced PR comments
+export { generatePRComment, generateCompactPRComment, generateCIStatusSummary, generateDiffTable, generateBadgeUrl, generateBadgeMarkdown, getBadgeColor, shouldBlockMerge, getSeverityEmoji, } from './pr-comment-generator.js';
+export { runSecurityTests, compareSecurityFingerprints, getRiskLevelFromScore, parseSecurityCategories, getPayloadsForCategory, getAllSecurityPayloads, getAllSecurityCategories, } from '../security/index.js';
+export { analyzeError, analyzeErrorPatterns, generateErrorSummary, analyzeErrorTrends, extractHttpStatus, categorizeHttpStatus, inferRootCause, generateRemediation, extractRelatedParameters, isTransientError, assessErrorSeverity, mapStatusToErrorCategory, formatEnhancedError, formatErrorTrendReport, formatCategoryName, } from './error-analyzer.js';
+// Documentation quality scoring
+export { scoreDocumentation, scoreToolDocumentation, calculateDescriptionCoverage, calculateDescriptionQuality, calculateParameterDocumentation, calculateExampleCoverage, hasExamples, scoreToGrade, generateSuggestions, compareDocumentationScores, formatDocumentationScore, formatDocumentationScoreCompact, formatDocumentationScoreChange, toDocumentationScoreSummary, getGradeIndicator, getGradeBadgeColor, meetsDocumentationThreshold, meetsDocumentationGrade, } from './documentation-scorer.js';
+// AI Agent Compatibility Scoring
+export { calculateAICompatibilityScore, generateAICompatibilityMarkdown, } from './ai-compatibility-scorer.js';
+// Regression Risk Scoring
+export { calculateRiskScore, generateRiskScoreMarkdown, } from './risk-scorer.js';
+// Intelligent Test Pruning
+export { calculatePruningDecisions, calculateToolPruning, prioritizeTools, generatePruningSummary, generatePruningMarkdown, } from './test-pruner.js';
+//# sourceMappingURL=index.js.map

package/dist/baseline/migration-generator.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Migration Guide Generator
+ *
+ * Auto-generates migration guides for breaking changes between baselines.
+ * Provides step-by-step instructions, code examples, and effort estimates.
+ */
+import type { BehavioralBaseline, BehavioralDiff, ChangeSeverity } from './types.js';
+import { type SchemaChangeDetail, type SchemaChangeType } from './change-impact-analyzer.js';
+/**
+ * Estimated effort level for migration.
+ */
+export type MigrationEffort = 'trivial' | 'minor' | 'moderate' | 'major';
+/**
+ * Type of migration step.
+ */
+export type MigrationStepType = 'add_parameter' | 'remove_parameter' | 'change_type' | 'update_constraint' | 'update_enum' | 'update_default' | 'deprecation' | 'tool_removal' | 'tool_addition';
+/**
+ * A single step in the migration process.
+ */
+export interface MigrationStep {
+    /** Step number */
+    stepNumber: number;
+    /** Type of migration action */
+    type: MigrationStepType;
+    /** Tool affected */
+    toolName: string;
+    /** Parameter path (if applicable) */
+    parameterPath?: string;
+    /** Human-readable title */
+    title: string;
+    /** Detailed description of what to do */
+    description: string;
+    /** Whether this step is for a breaking change */
+    isBreaking: boolean;
+    /** Code examples */
+    codeExamples: CodeExample[];
+    /** Related schema change */
+    schemaChange?: SchemaChangeDetail;
+}
+/**
+ * Code example for a migration step.
+ */
+export interface CodeExample {
+    /** Language (typescript, javascript, etc.) */
+    language: string;
+    /** Title/description of the example */
+    title: string;
+    /** Code before migration */
+    before: string;
+    /** Code after migration */
+    after: string;
+}
+/**
+ * A single breaking change with context.
+ */
+export interface BreakingChange {
+    /** Tool name */
+    toolName: string;
+    /** Type of change */
+    changeType: SchemaChangeType;
+    /** Parameter affected */
+    parameterPath: string;
+    /** Value before */
+    before: unknown;
+    /** Value after */
+    after: unknown;
+    /** Human-readable description */
+    description: string;
+    /** Severity */
+    severity: ChangeSeverity;
+}
+/**
+ * Complete migration guide between two versions.
+ */
+export interface MigrationGuide {
+    /** Source version/identifier */
+    fromVersion: string;
+    /** Target version/identifier */
+    toVersion: string;
+    /** Date range of the migration */
+    dateRange: {
+        from: Date;
+        to: Date;
+    };
+    /** All breaking changes */
+    breakingChanges: BreakingChange[];
+    /** Step-by-step migration instructions */
+    steps: MigrationStep[];
+    /** Code examples for common patterns */
+    codeExamples: CodeExample[];
+    /** Estimated effort level */
+    estimatedEffort: MigrationEffort;
+    /** Summary statistics */
+    stats: MigrationStats;
+    /** Human-readable summary */
+    summary: string;
+    /** Tools that were removed */
+    removedTools: string[];
+    /** Tools that were added */
+    addedTools: string[];
+    /** Warnings or notes */
+    warnings: string[];
+}
+/**
+ * Statistics about the migration.
+ */
+export interface MigrationStats {
+    /** Total breaking changes */
+    breakingChangesCount: number;
+    /** Total tools affected */
+    toolsAffected: number;
+    /** Total migration steps */
+    stepsCount: number;
+    /** Breakdown by change type */
+    changesByType: Record<SchemaChangeType, number>;
+}
+/**
+ * Generate a migration guide from two baselines.
+ */
+export declare function generateMigrationGuide(oldBaseline: BehavioralBaseline, newBaseline: BehavioralBaseline, diff?: BehavioralDiff): MigrationGuide;
+/**
+ * Format migration guide as markdown.
+ */
+export declare function formatMigrationGuideMarkdown(guide: MigrationGuide): string;
+/**
+ * Format migration guide for console output.
+ */
+export declare function formatMigrationGuideText(guide: MigrationGuide): string;
+/**
+ * Check if a migration guide contains breaking changes that require action.
+ */
+export declare function hasBreakingMigrationChanges(guide: MigrationGuide): boolean;
+/**
+ * Get breaking tools from guide.
+ */
+export declare function getBreakingTools(guide: MigrationGuide): string[];
+//# sourceMappingURL=migration-generator.d.ts.map