@syrin/cli 1.3.2 → 1.4.1

package/dist/runtime/analysis/rules/warnings/w006-optional-as-required.js

@@ -1,44 +0,0 @@
-/**
- * W006: Optional Input Used as Required Downstream
- *
- * Condition:
- * - Input marked optional
- * - Treated as required in chaining
- *
- * Why:
- * - Hidden contract violation
- */
-import { BaseRule } from '../base.js';
-class W006OptionalAsRequiredRule extends BaseRule {
-    id = 'W006';
-    severity = 'warning';
-    ruleName = 'Optional Input Used as Required Downstream';
-    description = 'Optional input is treated as required downstream. Hidden contract violation.';
-    check(ctx) {
-        const diagnostics = [];
-        // Check high-confidence dependencies (>= 0.8)
-        const highConfidenceDeps = ctx.dependencies.filter(d => d.confidence >= 0.8);
-        for (const dep of highConfidenceDeps) {
-            // Find the source output
-            const fromTool = ctx.indexes.toolIndex.get(dep.fromTool.toLowerCase());
-            const toTool = ctx.indexes.toolIndex.get(dep.toTool.toLowerCase());
-            if (!fromTool || !toTool) {
-                continue;
-            }
-            const fromField = fromTool.outputs.find(f => f.name === dep.fromField);
-            const toField = toTool.inputs.find(f => f.name === dep.toField);
-            if (!fromField || !toField) {
-                continue;
-            }
-            // Check if source is optional/nullable but target is required
-            const isSourceOptional = fromField.nullable === true;
-            const isTargetRequired = toField.required === true;
-            if (isSourceOptional && isTargetRequired) {
-                diagnostics.push(this.createDiagnostic(`Source field "${dep.fromTool}.${dep.fromField}" is nullable/optional but is being wired into required input "${dep.toTool}.${dep.toField}".`, dep.toTool, dep.toField, `Make "${dep.fromTool}.${dep.fromField}" non-nullable, or make "${dep.toTool}.${dep.toField}" optional.`));
-            }
-        }
-        return diagnostics;
-    }
-}
-export const W006OptionalAsRequired = new W006OptionalAsRequiredRule();
-//# sourceMappingURL=w006-optional-as-required.js.map

package/dist/runtime/analysis/rules/warnings/w007-broad-output-schema.d.ts

@@ -1,23 +0,0 @@
-/**
- * W007: Output Schema Too Broad
- *
- * Condition:
- * - Output type is object with no properties
- * - Or any
- *
- * Why:
- * - No contract enforcement
- * - Breaks evolution
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class W007BroadOutputSchemaRule extends BaseRule {
-    readonly id = "W007";
-    readonly severity: "warning";
-    readonly ruleName = "Output Schema Too Broad";
-    readonly description = "Output schema of tool is too broad. No contract enforcement.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const W007BroadOutputSchema: W007BroadOutputSchemaRule;
-export {};
-//# sourceMappingURL=w007-broad-output-schema.d.ts.map

package/dist/runtime/analysis/rules/warnings/w007-broad-output-schema.js

@@ -1,37 +0,0 @@
-/**
- * W007: Output Schema Too Broad
- *
- * Condition:
- * - Output type is object with no properties
- * - Or any
- *
- * Why:
- * - No contract enforcement
- * - Breaks evolution
- */
-import { BaseRule } from '../base.js';
-class W007BroadOutputSchemaRule extends BaseRule {
-    id = 'W007';
-    severity = 'warning';
-    ruleName = 'Output Schema Too Broad';
-    description = 'Output schema of tool is too broad. No contract enforcement.';
-    check(ctx) {
-        const diagnostics = [];
-        for (const tool of ctx.tools) {
-            for (const output of tool.outputs) {
-                // Check if output is "any" type
-                if (output.type === 'any') {
-                    diagnostics.push(this.createDiagnostic(`Output schema of "${tool.name}" (field: "${output.name}") is too broad (type: "any").`, tool.name, output.name, `Specify a concrete type for "${output.name}" instead of "any".`));
-                }
-                // Check if output is object with no properties
-                if (output.type === 'object' &&
-                    (!output.properties || output.properties.length === 0)) {
-                    diagnostics.push(this.createDiagnostic(`Output schema of "${tool.name}" (field: "${output.name}") is an object with no properties defined.`, tool.name, output.name, `Define the properties of the object schema for "${output.name}".`));
-                }
-            }
-        }
-        return diagnostics;
-    }
-}
-export const W007BroadOutputSchema = new W007BroadOutputSchemaRule();
-//# sourceMappingURL=w007-broad-output-schema.js.map

package/dist/runtime/analysis/rules/warnings/w008-multiple-entry-points.d.ts

@@ -1,22 +0,0 @@
-/**
- * W008: Multiple Entry Points for Same Concept
- *
- * Condition:
- * - Multiple tools ask user for same conceptual data
- *   (e.g. location, user_id)
- *
- * Why:
- * - Conflicting sources of truth
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class W008MultipleEntryPointsRule extends BaseRule {
-    readonly id = "W008";
-    readonly severity: "warning";
-    readonly ruleName = "Multiple Entry Points for Same Concept";
-    readonly description = "Multiple tools capture the same concept. Conflicting sources of truth.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const W008MultipleEntryPoints: W008MultipleEntryPointsRule;
-export {};
-//# sourceMappingURL=w008-multiple-entry-points.d.ts.map

package/dist/runtime/analysis/rules/warnings/w008-multiple-entry-points.js

@@ -1,97 +0,0 @@
-/**
- * W008: Multiple Entry Points for Same Concept
- *
- * Condition:
- * - Multiple tools ask user for same conceptual data
- *   (e.g. location, user_id)
- *
- * Why:
- * - Conflicting sources of truth
- */
-import { BaseRule } from '../base.js';
-import { escapeRegex } from '../../utils.js';
-/**
- * Extract the concept from an input field name.
- */
-function extractConcept(fieldName) {
-    // Split field name into tokens (on non-word characters and camelCase boundaries)
-    // Preserve case for camelCase detection, then lowercase tokens individually
-    const tokens = fieldName
-        .split(/[^\w]+|(?<=[a-z])(?=[A-Z])/)
-        .filter(t => t.length > 0)
-        .map(t => t.toLowerCase());
-    const name = fieldName.toLowerCase();
-    // Common concepts
-    const concepts = [
-        [['location', 'loc', 'place', 'address', 'city', 'country'], 'location'],
-        [['user', 'user_id', 'userid', 'username', 'person'], 'user'],
-        [['email', 'e-mail', 'mail'], 'email'],
-        [['phone', 'telephone', 'mobile'], 'phone'],
-        [['name', 'fullname', 'full_name'], 'name'],
-        [['id', 'identifier'], 'id'],
-    ];
-    for (const [keywords, concept] of concepts) {
-        for (const keyword of keywords) {
-            // Check for exact token match or word-boundary match
-            // Escape keyword to prevent regex injection
-            const escapedKeyword = escapeRegex(keyword);
-            const keywordRegex = new RegExp(`\\b${escapedKeyword}\\b`, 'i');
-            if (tokens.includes(keyword) || keywordRegex.test(name)) {
-                return concept;
-            }
-        }
-    }
-    return null;
-}
-class W008MultipleEntryPointsRule extends BaseRule {
-    id = 'W008';
-    severity = 'warning';
-    ruleName = 'Multiple Entry Points for Same Concept';
-    description = 'Multiple tools capture the same concept. Conflicting sources of truth.';
-    check(ctx) {
-        const diagnostics = [];
-        // Map concept to tools that have it
-        const conceptToTools = new Map();
-        for (const tool of ctx.tools) {
-            for (const input of tool.inputs) {
-                // Only check user-facing inputs
-                if (!input.required) {
-                    continue;
-                }
-                const concept = extractConcept(input.name);
-                if (!concept) {
-                    continue;
-                }
-                if (!conceptToTools.has(concept)) {
-                    conceptToTools.set(concept, []);
-                }
-                conceptToTools.get(concept).push({
-                    tool: tool.name,
-                    field: input.name,
-                });
-            }
-        }
-        // Check for concepts that appear in multiple tools
-        for (const [concept, tools] of conceptToTools.entries()) {
-            if (tools.length > 1) {
-                const toolNames = tools.map(t => `"${t.tool}"`).join(', ');
-                // Group by tool name in case same tool appears multiple times
-                const toolFieldsMap = new Map();
-                for (const toolEntry of tools) {
-                    if (!toolFieldsMap.has(toolEntry.tool)) {
-                        toolFieldsMap.set(toolEntry.tool, []);
-                    }
-                    toolFieldsMap.get(toolEntry.tool).push(toolEntry.field);
-                }
-                const context = {};
-                for (const [tool, fields] of toolFieldsMap.entries()) {
-                    context[tool] = fields.join(', ');
-                }
-                diagnostics.push(this.createDiagnostic(`Multiple tools capture the same concept: "${concept}" (${toolNames}).`, undefined, undefined, `Consolidate "${concept}" collection into a single tool to avoid conflicting sources of truth.`, context));
-            }
-        }
-        return diagnostics;
-    }
-}
-export const W008MultipleEntryPoints = new W008MultipleEntryPointsRule();
-//# sourceMappingURL=w008-multiple-entry-points.js.map

package/dist/runtime/analysis/rules/warnings/w009-hidden-side-effects.d.ts

@@ -1,23 +0,0 @@
-/**
- * W009: Hidden Side Effects
- *
- * Condition:
- * - Tool name/description suggests mutation
- * - But schema does not reflect it
- *
- * Why:
- * - Execution surprises
- * - Hard to reason
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class W009HiddenSideEffectsRule extends BaseRule {
-    readonly id = "W009";
-    readonly severity: "warning";
-    readonly ruleName = "Hidden Side Effects";
-    readonly description = "Tool appears to have side effects not reflected in schema. Execution surprises.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const W009HiddenSideEffects: W009HiddenSideEffectsRule;
-export {};
-//# sourceMappingURL=w009-hidden-side-effects.d.ts.map

package/dist/runtime/analysis/rules/warnings/w009-hidden-side-effects.js

@@ -1,88 +0,0 @@
-/**
- * W009: Hidden Side Effects
- *
- * Condition:
- * - Tool name/description suggests mutation
- * - But schema does not reflect it
- *
- * Why:
- * - Execution surprises
- * - Hard to reason
- */
-import { BaseRule } from '../base.js';
-/**
- * Check if a tool name/description suggests mutation.
- */
-function suggestsMutation(toolName, description) {
-    const combined = `${toolName} ${description}`.toLowerCase();
-    // Mutation verbs
-    const mutationVerbs = [
-        'create',
-        'delete',
-        'remove',
-        'update',
-        'modify',
-        'change',
-        'set',
-        'save',
-        'write',
-        'add',
-        'insert',
-        'destroy',
-        'drop',
-        'clear',
-        'reset',
-    ];
-    return mutationVerbs.some(verb => {
-        const regex = new RegExp(`\\b${verb}\\b`, 'i');
-        return regex.test(combined);
-    });
-}
-/**
- * Check if schema reflects mutation (has outputs that suggest state change).
- */
-function schemaReflectsMutation(tool) {
-    // If no outputs, it might be a mutation (void operation)
-    if (tool.outputs.length === 0) {
-        return true;
-    }
-    // Check if outputs suggest mutation confirmation
-    const mutationOutputs = [
-        'success',
-        'id',
-        'result',
-        'status',
-        'created',
-        'updated',
-        'deleted',
-    ];
-    for (const output of tool.outputs) {
-        const name = output.name.toLowerCase();
-        const desc = (output.description || '').toLowerCase();
-        if (mutationOutputs.some(mo => name.includes(mo) || desc.includes(mo))) {
-            return true;
-        }
-    }
-    return false;
-}
-class W009HiddenSideEffectsRule extends BaseRule {
-    id = 'W009';
-    severity = 'warning';
-    ruleName = 'Hidden Side Effects';
-    description = 'Tool appears to have side effects not reflected in schema. Execution surprises.';
-    check(ctx) {
-        const diagnostics = [];
-        for (const tool of ctx.tools) {
-            const description = tool.description || '';
-            const suggestsMut = suggestsMutation(tool.name, description);
-            const reflectsMut = schemaReflectsMutation(tool);
-            // If it suggests mutation but schema doesn't reflect it
-            if (suggestsMut && !reflectsMut) {
-                diagnostics.push(this.createDiagnostic(`Tool "${tool.name}" appears to have side effects not reflected in schema.`, tool.name, undefined, `Update the output schema of "${tool.name}" to reflect state changes (e.g., add success status, created ID, etc.).`));
-            }
-        }
-        return diagnostics;
-    }
-}
-export const W009HiddenSideEffects = new W009HiddenSideEffectsRule();
-//# sourceMappingURL=w009-hidden-side-effects.js.map

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

@@ -1,22 +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';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class W010OutputNotReusableRule extends BaseRule {
-    readonly id = "W010";
-    readonly severity: "warning";
-    readonly ruleName = "Tool Output Not Reusable";
-    readonly description = "Output of tool is not designed for reuse. Limits composability.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const W010OutputNotReusable: W010OutputNotReusableRule;
-export {};
-//# sourceMappingURL=w010-output-not-reusable.d.ts.map

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