@syrin/cli 1.3.1 → 1.4.0

package/dist/runtime/analysis/rules/warnings/w010-output-not-reusable.js

@@ -1,81 +0,0 @@
-/**
- * W010: Tool Output Not Reusable
- *
- * Condition:
- * - Output tailored only for natural language
- * - Not structured for reuse
- *
- * Why:
- * - Limits composability
- */
-import { BaseRule } from '../base.js';
-/**
- * Check if output appears to be only for natural language display.
- */
-function isNaturalLanguageOnly(output) {
-    const name = output.name.toLowerCase();
-    const desc = (output.description || '').toLowerCase();
-    const combined = `${name} ${desc}`;
-    // Indicators that output is only for display
-    const displayOnlyIndicators = [
-        'message',
-        'response',
-        'reply',
-        'answer',
-        'text',
-        'description',
-        'summary',
-        'note',
-        'comment',
-        'info',
-    ];
-    // If it's a string type and name suggests display-only
-    if (output.type === 'string') {
-        return displayOnlyIndicators.some(indicator => combined.includes(indicator));
-    }
-    return false;
-}
-/**
- * Check if output is structured (object or array).
- */
-function isStructured(output) {
-    if (output.type === 'object' || output.type === 'array') {
-        return true;
-    }
-    if (output.properties && typeof output.properties === 'object') {
-        if (Array.isArray(output.properties) && output.properties.length > 0) {
-            return true;
-        }
-        // Also check if it's a Record with keys
-        if (!Array.isArray(output.properties) &&
-            Object.keys(output.properties).length > 0) {
-            return true;
-        }
-    }
-    return false;
-}
-class W010OutputNotReusableRule extends BaseRule {
-    id = 'W010';
-    severity = 'warning';
-    ruleName = 'Tool Output Not Reusable';
-    description = 'Output of tool is not designed for reuse. Limits composability.';
-    check(ctx) {
-        const diagnostics = [];
-        for (const tool of ctx.tools) {
-            // Only check tools that have outputs
-            if (tool.outputs.length === 0) {
-                continue;
-            }
-            // Check if all outputs are natural language only
-            const allNaturalLanguage = tool.outputs.every(output => isNaturalLanguageOnly(output));
-            const hasStructured = tool.outputs.some(output => isStructured(output));
-            // If all outputs are natural language and none are structured
-            if (allNaturalLanguage && !hasStructured) {
-                diagnostics.push(this.createDiagnostic(`Output of "${tool.name}" is not designed for reuse (only natural language output).`, tool.name, undefined, `Add structured output fields (objects/arrays) to "${tool.name}" to improve composability with other tools.`));
-            }
-        }
-        return diagnostics;
-    }
-}
-export const W010OutputNotReusable = new W010OutputNotReusableRule();
-//# sourceMappingURL=w010-output-not-reusable.js.map

package/dist/runtime/analysis/rules/warnings/w021-weak-schema.d.ts

@@ -1,40 +0,0 @@
-/**
- * W021: Weak Schema
- *
- * Condition: Contract schema is too loose or doesn't match MCP tool schema structure
- *
- * Why this is a warning:
- * - Loose schemas make validation less effective
- * - Mismatch between contract and actual tool schema indicates contract needs update
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for weak schema detection.
- */
-export interface WeakSchemaContext {
-    /** Tool name */
-    toolName: string;
-    /** Contract input schema name */
-    contractInputSchema: string;
-    /** Contract output schema name */
-    contractOutputSchema: string;
-    /** Whether schemas match actual MCP tool schemas */
-    schemasMatch: boolean;
-    /** Details about mismatch (if any) */
-    mismatchDetails?: string;
-}
-declare class W021WeakSchemaRule extends BaseRule {
-    readonly id = "W021";
-    readonly severity: "warning";
-    readonly ruleName = "Weak Schema";
-    readonly description = "Contract schema is too loose or does not match MCP tool schema structure.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: WeakSchemaContext): Diagnostic[];
-}
-export declare const W021WeakSchema: W021WeakSchemaRule;
-export {};
-//# sourceMappingURL=w021-weak-schema.d.ts.map

package/dist/runtime/analysis/rules/warnings/w021-weak-schema.js

@@ -1,32 +0,0 @@
-/**
- * W021: Weak Schema
- *
- * Condition: Contract schema is too loose or doesn't match MCP tool schema structure
- *
- * Why this is a warning:
- * - Loose schemas make validation less effective
- * - Mismatch between contract and actual tool schema indicates contract needs update
- */
-import { BaseRule } from '../base.js';
-class W021WeakSchemaRule extends BaseRule {
-    id = 'W021';
-    severity = 'warning';
-    ruleName = 'Weak Schema';
-    description = 'Contract schema is too loose or does not match MCP tool schema structure.';
-    check(_ctx) {
-        // This rule requires behavioral context (schema comparison)
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        if (!behavioralCtx.schemasMatch) {
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" contract schemas do not match actual MCP tool schemas.${behavioralCtx.mismatchDetails ? ` ${behavioralCtx.mismatchDetails}` : ''}`, behavioralCtx.toolName, undefined, 'Update contract to match actual tool schema structure. Ensure input_schema and output_schema names reference correct schemas.'));
-        }
-        return diagnostics;
-    }
-}
-export const W021WeakSchema = new W021WeakSchemaRule();
-//# sourceMappingURL=w021-weak-schema.js.map

package/dist/runtime/analysis/rules/warnings/w022-high-entropy-output.d.ts

@@ -1,39 +0,0 @@
-/**
- * W022: High Entropy Output
- *
- * Condition: Tool output has high entropy (random, unpredictable structure)
- *
- * Why this is a warning:
- * - High entropy makes it hard for LLM to reason about output
- * - Indicates potential design issues
- * - May indicate non-determinism
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for high entropy detection.
- */
-export interface HighEntropyContext {
-    /** Tool name */
-    toolName: string;
-    /** Entropy score (0-1, higher = more entropy) */
-    entropyScore: number;
-    /** Reason for high entropy */
-    reason?: string;
-    /** Optional custom entropy threshold (defaults to 0.7 if not provided) */
-    entropyThreshold?: number;
-}
-declare class W022HighEntropyOutputRule extends BaseRule {
-    readonly id = "W022";
-    readonly severity: "warning";
-    readonly ruleName = "High Entropy Output";
-    readonly description = "Tool output has high entropy, making it difficult for LLM to reason about.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: HighEntropyContext): Diagnostic[];
-}
-export declare const W022HighEntropyOutput: W022HighEntropyOutputRule;
-export {};
-//# sourceMappingURL=w022-high-entropy-output.d.ts.map

package/dist/runtime/analysis/rules/warnings/w022-high-entropy-output.js

@@ -1,36 +0,0 @@
-/**
- * W022: High Entropy Output
- *
- * Condition: Tool output has high entropy (random, unpredictable structure)
- *
- * Why this is a warning:
- * - High entropy makes it hard for LLM to reason about output
- * - Indicates potential design issues
- * - May indicate non-determinism
- */
-import { BaseRule } from '../base.js';
-class W022HighEntropyOutputRule extends BaseRule {
-    id = 'W022';
-    severity = 'warning';
-    ruleName = 'High Entropy Output';
-    description = 'Tool output has high entropy, making it difficult for LLM to reason about.';
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        // Use configured threshold or fall back to default 0.7
-        const threshold = behavioralCtx.entropyThreshold ?? 0.7;
-        // Threshold: entropy above configured value is considered high
-        if (behavioralCtx.entropyScore > threshold) {
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" produces high entropy output (score: ${behavioralCtx.entropyScore.toFixed(2)}, threshold: ${threshold.toFixed(2)}).${behavioralCtx.reason ? ` ${behavioralCtx.reason}` : ''}`, behavioralCtx.toolName, undefined, 'Consider normalizing output structure, reducing randomness, or providing more predictable output format.'));
-        }
-        return diagnostics;
-    }
-}
-export const W022HighEntropyOutput = new W022HighEntropyOutputRule();
-//# sourceMappingURL=w022-high-entropy-output.js.map

package/dist/runtime/analysis/rules/warnings/w023-unstable-defaults.d.ts

@@ -1,38 +0,0 @@
-/**
- * W023: Unstable Defaults
- *
- * Condition: Tool behavior changes significantly with default values
- *
- * Why this is a warning:
- * - Defaults should be stable and predictable
- * - Changing defaults breaks agent expectations
- * - Indicates design inconsistency
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for unstable defaults detection.
- */
-export interface UnstableDefaultsContext {
-    /** Tool name */
-    toolName: string;
-    /** Fields with unstable defaults */
-    unstableFields: Array<{
-        fieldName: string;
-        reason: string;
-    }>;
-}
-declare class W023UnstableDefaultsRule extends BaseRule {
-    readonly id = "W023";
-    readonly severity: "warning";
-    readonly ruleName = "Unstable Defaults";
-    readonly description = "Tool behavior changes significantly with default values, breaking agent expectations.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: UnstableDefaultsContext): Diagnostic[];
-}
-export declare const W023UnstableDefaults: W023UnstableDefaultsRule;
-export {};
-//# sourceMappingURL=w023-unstable-defaults.d.ts.map

package/dist/runtime/analysis/rules/warnings/w023-unstable-defaults.js

@@ -1,36 +0,0 @@
-/**
- * W023: Unstable Defaults
- *
- * Condition: Tool behavior changes significantly with default values
- *
- * Why this is a warning:
- * - Defaults should be stable and predictable
- * - Changing defaults breaks agent expectations
- * - Indicates design inconsistency
- */
-import { BaseRule } from '../base.js';
-class W023UnstableDefaultsRule extends BaseRule {
-    id = 'W023';
-    severity = 'warning';
-    ruleName = 'Unstable Defaults';
-    description = 'Tool behavior changes significantly with default values, breaking agent expectations.';
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        if (behavioralCtx.unstableFields.length > 0) {
-            const fieldList = behavioralCtx.unstableFields
-                .map(f => `  - ${f.fieldName}: ${f.reason}`)
-                .join('\n');
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" has unstable default values:\n${fieldList}`, behavioralCtx.toolName, undefined, 'Ensure default values are stable and predictable. Avoid defaults that change behavior significantly.'));
-        }
-        return diagnostics;
-    }
-}
-export const W023UnstableDefaults = new W023UnstableDefaultsRule();
-//# sourceMappingURL=w023-unstable-defaults.js.map

package/dist/runtime/test/dependency-tracker.d.ts

@@ -1,66 +0,0 @@
-/**
- * Hidden dependency tracker.
- * Tracks tool calls during execution to detect hidden dependencies.
- */
-/**
- * Tool call record during execution.
- */
-export interface ToolCallRecord {
-    /** Tool name that was called */
-    toolName: string;
-    /** Timestamp */
-    timestamp: number;
-    /** Arguments passed */
-    arguments?: Record<string, unknown>;
-}
-/**
- * Dependency tracking result.
- */
-export interface DependencyTrackingResult {
-    /** Whether hidden dependencies were detected */
-    detected: boolean;
-    /** List of tool calls that are not declared in contract */
-    hiddenDependencies: ToolCallRecord[];
-    /** List of declared dependencies that don't exist in the MCP server */
-    missingDependencies: string[];
-    /** Declared dependencies from contract */
-    declaredDependencies: string[];
-}
-/**
- * Dependency tracker for monitoring tool calls.
- * Note: This requires integration with MCP client to intercept tool calls.
- * For v1.3.0, we'll track via a wrapper or client extension.
- */
-export declare class DependencyTracker {
-    private toolCalls;
-    private readonly declaredDependencies;
-    constructor(declaredDependencies?: string[]);
-    /**
-     * Record a tool call.
-     */
-    recordToolCall(toolName: string, arguments_?: Record<string, unknown>): void;
-    /**
-     * Get all tool calls.
-     */
-    getToolCalls(): readonly ToolCallRecord[];
-    /**
-     * Detect hidden dependencies (tool calls not declared in contract).
-     * Also validates that declared dependencies actually exist.
-     * @param availableTools - Set of available tool names from MCP server (optional, for validation)
-     */
-    detectHiddenDependencies(availableTools?: Set<string> | string[]): DependencyTrackingResult;
-    /**
-     * Clear all recorded tool calls.
-     */
-    clear(): void;
-    /**
-     * Get summary of dependencies.
-     */
-    getSummary(availableTools?: Set<string> | string[]): {
-        totalCalls: number;
-        uniqueTools: number;
-        hiddenDependencies: number;
-        missingDependencies: number;
-    };
-}
-//# sourceMappingURL=dependency-tracker.d.ts.map

package/dist/runtime/test/dependency-tracker.js

@@ -1,80 +0,0 @@
-/**
- * Hidden dependency tracker.
- * Tracks tool calls during execution to detect hidden dependencies.
- */
-/**
- * Dependency tracker for monitoring tool calls.
- * Note: This requires integration with MCP client to intercept tool calls.
- * For v1.3.0, we'll track via a wrapper or client extension.
- */
-export class DependencyTracker {
-    toolCalls = [];
-    declaredDependencies;
-    constructor(declaredDependencies = []) {
-        this.declaredDependencies = declaredDependencies;
-    }
-    /**
-     * Record a tool call.
-     */
-    recordToolCall(toolName, arguments_) {
-        this.toolCalls.push({
-            toolName,
-            timestamp: Date.now(),
-            arguments: arguments_,
-        });
-    }
-    /**
-     * Get all tool calls.
-     */
-    getToolCalls() {
-        return this.toolCalls;
-    }
-    /**
-     * Detect hidden dependencies (tool calls not declared in contract).
-     * Also validates that declared dependencies actually exist.
-     * @param availableTools - Set of available tool names from MCP server (optional, for validation)
-     */
-    detectHiddenDependencies(availableTools) {
-        // Check for hidden dependencies (tools called but not declared)
-        const hiddenDependencies = this.toolCalls.filter(call => !this.declaredDependencies.includes(call.toolName));
-        // Check for missing dependencies (declared but don't exist in MCP server)
-        const missingDependencies = [];
-        if (availableTools) {
-            const availableSet = Array.isArray(availableTools)
-                ? new Set(availableTools)
-                : availableTools;
-            for (const declaredDep of this.declaredDependencies) {
-                if (!availableSet.has(declaredDep)) {
-                    missingDependencies.push(declaredDep);
-                }
-            }
-        }
-        const detected = hiddenDependencies.length > 0 || missingDependencies.length > 0;
-        return {
-            detected,
-            hiddenDependencies,
-            missingDependencies,
-            declaredDependencies: this.declaredDependencies,
-        };
-    }
-    /**
-     * Clear all recorded tool calls.
-     */
-    clear() {
-        this.toolCalls = [];
-    }
-    /**
-     * Get summary of dependencies.
-     */
-    getSummary(availableTools) {
-        const uniqueTools = new Set(this.toolCalls.map(c => c.toolName));
-        const result = this.detectHiddenDependencies(availableTools);
-        return {
-            totalCalls: this.toolCalls.length,
-            uniqueTools: uniqueTools.size,
-            hiddenDependencies: result.hiddenDependencies.length,
-            missingDependencies: result.missingDependencies.length,
-        };
-    }
-}
-//# sourceMappingURL=dependency-tracker.js.map

package/dist/runtime/test/formatters.d.ts

@@ -1,18 +0,0 @@
-/**
- * Test result formatters.
- * Formats test results for CLI and JSON output.
- */
-import type { TestOrchestratorResult } from './orchestrator.js';
-/**
- * Format test results for CI output (minimal).
- */
-export declare function formatCIResults(result: TestOrchestratorResult): void;
-/**
- * Format test results for CLI output.
- */
-export declare function formatCLIResults(result: TestOrchestratorResult): void;
-/**
- * Format test results as JSON.
- */
-export declare function formatJSONResults(result: TestOrchestratorResult): string;
-//# sourceMappingURL=formatters.d.ts.map

package/dist/runtime/test/formatters.js

@@ -1,172 +0,0 @@
-/**
- * Test result formatters.
- * Formats test results for CLI and JSON output.
- */
-import { log } from '../../utils/logger.js';
-/**
- * Format test results for CI output (minimal).
- */
-export function formatCIResults(result) {
-    const errors = result.diagnostics.filter(d => d.severity === 'error');
-    const warnings = result.diagnostics.filter(d => d.severity === 'warning');
-    // CI mode: minimal output, exit codes handled by caller
-    if (result.verdict === 'fail') {
-        console.log(`✗ Test failed: ${result.toolsFailed} tool(s) failed, ${errors.length} error(s), ${warnings.length} warning(s)`);
-        // Print errors only (no warnings in CI)
-        for (const error of errors) {
-            console.log(`${error.code}: ${error.message}`);
-        }
-    }
-    else {
-        console.log(`✓ Test passed: ${result.toolsTested} tool(s) tested, ${result.toolsPassed} passed`);
-        if (warnings.length > 0) {
-            console.log(`  ${warnings.length} warning(s) (non-blocking)`);
-        }
-    }
-}
-/**
- * Format test results for CLI output.
- */
-export function formatCLIResults(result) {
-    log.blank();
-    log.heading('Tool Validation Results');
-    log.blank();
-    // Overall verdict
-    if (result.verdict === 'pass') {
-        log.checkmark('All tools passed validation');
-    }
-    else if (result.verdict === 'pass-with-warnings') {
-        log.warn('Tools passed with warnings');
-    }
-    else {
-        log.xmark('Tool validation failed');
-    }
-    log.blank();
-    // Summary
-    log.heading('Summary:');
-    log.labelValue('  Tools tested:', String(result.toolsTested));
-    log.labelValue('  Tools passed:', String(result.toolsPassed));
-    log.labelValue('  Tools failed:', String(result.toolsFailed));
-    const errors = result.diagnostics.filter(d => d.severity === 'error');
-    const warnings = result.diagnostics.filter(d => d.severity === 'warning');
-    if (errors.length > 0) {
-        log.labelValue('  Errors:', String(errors.length));
-    }
-    if (warnings.length > 0) {
-        log.labelValue('  Warnings:', String(warnings.length));
-    }
-    log.blank();
-    // Tool results
-    if (result.toolResults.length > 0) {
-        log.heading('Tool Results:');
-        for (const toolResult of result.toolResults) {
-            log.blank();
-            const status = toolResult.passed ? log.tick() : log.cross();
-            log.plain(`  ${status} ${log.styleText(toolResult.toolName, 'bold')}`);
-            // Summary
-            log.labelValue('    Executions:', `${toolResult.summary.successfulExecutions}/${toolResult.summary.totalExecutions} successful`);
-            if (toolResult.summary.testsPassed !== undefined &&
-                toolResult.summary.testsFailed !== undefined) {
-                const totalTests = toolResult.summary.testsPassed + toolResult.summary.testsFailed;
-                log.labelValue('    Tests:', `${toolResult.summary.testsPassed}/${totalTests} passed (expectations matched)`);
-            }
-            if (toolResult.summary.failedExecutions > 0) {
-                log.labelValue('    Failed:', String(toolResult.summary.failedExecutions));
-            }
-            if (toolResult.summary.timedOutExecutions > 0) {
-                log.labelValue('    Timed out:', String(toolResult.summary.timedOutExecutions));
-            }
-            // Diagnostics
-            if (toolResult.diagnostics.length > 0) {
-                const toolErrors = toolResult.diagnostics.filter(d => d.severity === 'error');
-                const toolWarnings = toolResult.diagnostics.filter(d => d.severity === 'warning');
-                if (toolErrors.length > 0) {
-                    log.plain('    Errors:');
-                    for (const error of toolErrors) {
-                        log.error(`      ${error.code}: ${error.message}`);
-                        // Show test context if available
-                        const context = error.context;
-                        if (context?.testName) {
-                            log.plain(`        Test: ${context.testName}`);
-                        }
-                        if (context?.testInput &&
-                            Object.keys(context.testInput).length > 0) {
-                            const inputStr = JSON.stringify(context.testInput, null, 2)
-                                .split('\n')
-                                .map((line, idx) => (idx === 0 ? line : `        ${line}`))
-                                .join('\n');
-                            log.plain(`        Input: ${inputStr}`);
-                        }
-                        if (context?.expectedOutputSchema) {
-                            log.plain(`        Expected output schema: ${context.expectedOutputSchema}`);
-                        }
-                        // Show parsed error details if available
-                        if (context?.parsedError) {
-                            const parsed = context.parsedError;
-                            if (parsed.field) {
-                                if (parsed.errorType === 'missing_argument') {
-                                    log.plain(`        Field "${parsed.field}" is required but was not provided`);
-                                }
-                                else if (parsed.inputType) {
-                                    log.plain(`        Field "${parsed.field}" received ${parsed.inputType}${parsed.inputValue && parsed.inputValue !== '{}' ? ` (${parsed.inputValue})` : ''}`);
-                                }
-                            }
-                        }
-                        if (error.suggestion) {
-                            log.plain(`        Suggestion: ${error.suggestion}`);
-                        }
-                        log.blank();
-                    }
-                }
-                if (toolWarnings.length > 0) {
-                    log.plain('    Warnings:');
-                    for (const warning of toolWarnings) {
-                        log.warn(`      ${warning.code}: ${warning.message}`);
-                        if (warning.suggestion) {
-                            log.plain(`        Suggestion: ${warning.suggestion}`);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    log.blank();
-}
-/**
- * Format test results as JSON.
- */
-export function formatJSONResults(result) {
-    const json = {
-        verdict: result.verdict,
-        summary: {
-            toolsTested: result.toolsTested,
-            toolsPassed: result.toolsPassed,
-            toolsFailed: result.toolsFailed,
-            errors: result.diagnostics.filter(d => d.severity === 'error').length,
-            warnings: result.diagnostics.filter(d => d.severity === 'warning').length,
-        },
-        diagnostics: result.diagnostics.map(d => ({
-            code: d.code,
-            severity: d.severity,
-            message: d.message,
-            tool: d.tool,
-            field: d.field,
-            suggestion: d.suggestion,
-            context: d.context,
-        })),
-        tools: result.toolResults.map(tr => ({
-            toolName: tr.toolName,
-            passed: tr.passed,
-            summary: tr.summary,
-            diagnostics: tr.diagnostics.map(d => ({
-                code: d.code,
-                severity: d.severity,
-                message: d.message,
-                suggestion: d.suggestion,
-                context: d.context,
-            })),
-        })),
-    };
-    return JSON.stringify(json, null, 2);
-}
-//# sourceMappingURL=formatters.js.map

package/dist/runtime/test/input-generator.d.ts

@@ -1,33 +0,0 @@
-/**
- * Synthetic input generator.
- * Generates test inputs from JSON Schema definitions.
- */
-/**
- * JSON Schema field interface.
- */
-interface JSONSchemaField {
-    type?: string | string[];
-    description?: string;
-    required?: string[];
-    properties?: Record<string, JSONSchemaField>;
-    items?: JSONSchemaField | JSONSchemaField[];
-    $ref?: string;
-    enum?: unknown[];
-    pattern?: string;
-    example?: unknown;
-    examples?: unknown[];
-    nullable?: boolean;
-    default?: unknown;
-    minimum?: number;
-    maximum?: number;
-}
-type JSONSchema = JSONSchemaField | Record<string, unknown> | unknown;
-/**
- * Generate test inputs from a JSON Schema.
- * Includes both predictable patterns and agent-like unpredictable variations.
- * @param schema - JSON Schema definition
- * @returns Array of generated input objects
- */
-export declare function generateInputsFromSchema(schema: JSONSchema): Array<Record<string, unknown>>;
-export {};
-//# sourceMappingURL=input-generator.d.ts.map