@syrin/cli 1.3.2 → 1.4.1

package/dist/runtime/analysis/rules/errors/e020-unexpected-test-result.js

@@ -1,109 +0,0 @@
-/**
- * E020: Unexpected Test Result
- *
- * Condition: Test's actual outcome doesn't match its expectation
- *
- * Why this is fatal:
- * - Test contract is inaccurate
- * - Tool behavior doesn't match declared guarantees
- * - Can cause false positives/negatives in validation
- * - Indicates mismatch between expectations and reality
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E020UnexpectedTestResultRule extends BaseRule {
-    id = ERROR_CODES.E020;
-    severity = 'error';
-    ruleName = 'Unexpected Test Result';
-    description = "Test's actual outcome doesn't match its expectation. Tool behavior doesn't match declared guarantees.";
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Determine if a diagnostic should be created based on behavioral context.
-     */
-    shouldCreateDiagnostic(behavioralCtx) {
-        // If outcomes don't match, create diagnostic
-        if (behavioralCtx.expectedOutcome !== behavioralCtx.actualOutcome) {
-            return true;
-        }
-        // Outcomes match - check if error details also match (for error cases)
-        if (behavioralCtx.expectedOutcome === 'error') {
-            const expectedType = behavioralCtx.expectedErrorType?.toLowerCase();
-            const actualType = behavioralCtx.actualErrorType?.toLowerCase();
-            if (expectedType && actualType && expectedType !== actualType) {
-                return true; // Type mismatch
-            }
-            if (expectedType && !actualType) {
-                return true; // Expected type but no actual type
-            }
-            const expectedCode = behavioralCtx.expectedErrorCode;
-            const actualCode = behavioralCtx.actualErrorCode;
-            if (expectedCode && actualCode && expectedCode !== actualCode) {
-                return true; // Code mismatch
-            }
-        }
-        return false; // Everything matches
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        if (!this.shouldCreateDiagnostic(behavioralCtx)) {
-            return diagnostics;
-        }
-        // If we reach here, there's a mismatch - create diagnostic
-        let message = `Test "${behavioralCtx.testName}" in tool "${behavioralCtx.toolName}" expected `;
-        // Build expected description
-        if (behavioralCtx.expectedOutcome === 'success') {
-            message += 'success but got ';
-            if (behavioralCtx.actualOutcome === 'error') {
-                message += `error (${behavioralCtx.actualErrorCode || behavioralCtx.actualErrorType || 'unknown error'})`;
-            }
-            else if (behavioralCtx.actualOutcome === 'timeout') {
-                message += 'timeout';
-            }
-            else {
-                message += behavioralCtx.actualOutcome;
-            }
-        }
-        else if (behavioralCtx.expectedOutcome === 'error') {
-            message += `error`;
-            if (behavioralCtx.expectedErrorType) {
-                message += ` of type "${behavioralCtx.expectedErrorType}"`;
-            }
-            if (behavioralCtx.expectedErrorCode) {
-                message += ` (code: ${behavioralCtx.expectedErrorCode})`;
-            }
-            message += ' but got ';
-            if (behavioralCtx.actualOutcome === 'success') {
-                message += 'success';
-            }
-            else {
-                message += `${behavioralCtx.actualOutcome} (${behavioralCtx.actualErrorCode || behavioralCtx.actualErrorType || 'unknown error'})`;
-            }
-            if (behavioralCtx.actualErrorType &&
-                behavioralCtx.expectedErrorType &&
-                behavioralCtx.actualErrorType.toLowerCase() !==
-                    behavioralCtx.expectedErrorType.toLowerCase()) {
-                message += ' with different type';
-            }
-        }
-        else {
-            message += `${behavioralCtx.expectedOutcome} but got ${behavioralCtx.actualOutcome}`;
-        }
-        diagnostics.push(this.createDiagnostic(message, behavioralCtx.toolName, undefined, 'Update test expectation to match actual tool behavior, or fix tool implementation to match declared guarantees. Ensure test expectations accurately reflect tool behavior.', {
-            testName: behavioralCtx.testName,
-            testInput: behavioralCtx.testInput,
-            expectedOutcome: behavioralCtx.expectedOutcome,
-            actualOutcome: behavioralCtx.actualOutcome,
-            expectedError: behavioralCtx.expectedError,
-            actualError: behavioralCtx.actualError,
-        }));
-        return diagnostics;
-    }
-}
-export const E020UnexpectedTestResult = new E020UnexpectedTestResultRule();
-//# sourceMappingURL=e020-unexpected-test-result.js.map

package/dist/runtime/analysis/rules/warnings/w001-implicit-dependency.d.ts

@@ -1,22 +0,0 @@
-/**
- * W001: Implicit Tool Dependency
- *
- * Condition:
- * - High confidence dependency inferred
- * - Not stated explicitly in description
- *
- * Why:
- * - LLM may not chain tools reliably
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class W001ImplicitDependencyRule extends BaseRule {
-    readonly id = "W001";
-    readonly severity: "warning";
-    readonly ruleName = "Implicit Tool Dependency";
-    readonly description = "Tool appears to depend on another tool, but the dependency is implicit.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const W001ImplicitDependency: W001ImplicitDependencyRule;
-export {};
-//# sourceMappingURL=w001-implicit-dependency.d.ts.map

package/dist/runtime/analysis/rules/warnings/w001-implicit-dependency.js

@@ -1,39 +0,0 @@
-/**
- * W001: Implicit Tool Dependency
- *
- * Condition:
- * - High confidence dependency inferred
- * - Not stated explicitly in description
- *
- * Why:
- * - LLM may not chain tools reliably
- */
-import { BaseRule } from '../base.js';
-class W001ImplicitDependencyRule extends BaseRule {
-    id = 'W001';
-    severity = 'warning';
-    ruleName = 'Implicit Tool Dependency';
-    description = 'Tool appears to depend on another tool, but the dependency is implicit.';
-    check(ctx) {
-        const diagnostics = [];
-        // Check medium to high confidence dependencies (0.6-0.8)
-        const implicitDeps = ctx.dependencies.filter(d => d.confidence >= 0.6 && d.confidence < 0.8);
-        for (const dep of implicitDeps) {
-            // Find the toTool to check its description
-            const toTool = ctx.indexes.toolIndex.get(dep.toTool.toLowerCase());
-            if (!toTool) {
-                continue;
-            }
-            const description = toTool.description || '';
-            // Check if fromTool is mentioned in description
-            const fromToolNameLower = dep.fromTool.toLowerCase();
-            const descLower = description.toLowerCase();
-            if (!descLower.includes(fromToolNameLower)) {
-                diagnostics.push(this.createDiagnostic(`Tool "${dep.toTool}" appears to depend on "${dep.fromTool}", but the dependency is implicit.`, dep.toTool, dep.toField, `Mention "${dep.fromTool}" in the description of "${dep.toTool}" to make the dependency explicit.`));
-            }
-        }
-        return diagnostics;
-    }
-}
-export const W001ImplicitDependency = new W001ImplicitDependencyRule();
-//# sourceMappingURL=w001-implicit-dependency.js.map

package/dist/runtime/analysis/rules/warnings/w002-free-text-without-normalization.d.ts

@@ -1,24 +0,0 @@
-/**
- * W002: Free-Text Output Without Normalization
- *
- * Condition:
- * - Output is string
- * - Not constrained or normalized
- * - Even if not chained
- *
- * Why:
- * - Hard to reuse
- * - Hard to evolve
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class W002FreeTextWithoutNormalizationRule extends BaseRule {
-    readonly id = "W002";
-    readonly severity: "warning";
-    readonly ruleName = "Free-Text Output Without Normalization";
-    readonly description = "Tool returns unconstrained free text. Consider normalizing output.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const W002FreeTextWithoutNormalization: W002FreeTextWithoutNormalizationRule;
-export {};
-//# sourceMappingURL=w002-free-text-without-normalization.d.ts.map

package/dist/runtime/analysis/rules/warnings/w002-free-text-without-normalization.js

@@ -1,40 +0,0 @@
-/**
- * W002: Free-Text Output Without Normalization
- *
- * Condition:
- * - Output is string
- * - Not constrained or normalized
- * - Even if not chained
- *
- * Why:
- * - Hard to reuse
- * - Hard to evolve
- */
-import { BaseRule } from '../base.js';
-class W002FreeTextWithoutNormalizationRule extends BaseRule {
-    id = 'W002';
-    severity = 'warning';
-    ruleName = 'Free-Text Output Without Normalization';
-    description = 'Tool returns unconstrained free text. Consider normalizing output.';
-    check(ctx) {
-        const diagnostics = [];
-        for (const tool of ctx.tools) {
-            for (const output of tool.outputs) {
-                // Check if output is unconstrained string
-                if (output.type !== 'string') {
-                    continue;
-                }
-                const hasEnum = Boolean(output.enum && output.enum.length > 0);
-                const hasPattern = Boolean(output.pattern);
-                const hasDescription = Boolean(output.description && output.description.trim());
-                // If it's a string with no constraints, it's unconstrained free text
-                if (!hasEnum && !hasPattern && !hasDescription) {
-                    diagnostics.push(this.createDiagnostic(`Tool "${tool.name}" returns unconstrained free text (field: "${output.name}"). Consider normalizing output.`, tool.name, output.name, `Add constraints to the output: enum values, regex pattern, or a clear description of the expected format.`));
-                }
-            }
-        }
-        return diagnostics;
-    }
-}
-export const W002FreeTextWithoutNormalization = new W002FreeTextWithoutNormalizationRule();
-//# sourceMappingURL=w002-free-text-without-normalization.js.map

package/dist/runtime/analysis/rules/warnings/w003-missing-examples.d.ts

@@ -1,22 +0,0 @@
-/**
- * W003: Missing Examples for User-Facing Inputs
- *
- * Condition:
- * - Tool takes user-provided input
- * - No examples provided
- *
- * Why:
- * - LLM guessing increases error rate
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class W003MissingExamplesRule extends BaseRule {
-    readonly id = "W003";
-    readonly severity: "warning";
-    readonly ruleName = "Missing Examples for User-Facing Inputs";
-    readonly description = "Tool accepts user-provided input but has no examples. LLM accuracy may be reduced.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const W003MissingExamples: W003MissingExamplesRule;
-export {};
-//# sourceMappingURL=w003-missing-examples.d.ts.map

package/dist/runtime/analysis/rules/warnings/w003-missing-examples.js

@@ -1,84 +0,0 @@
-/**
- * W003: Missing Examples for User-Facing Inputs
- *
- * Condition:
- * - Tool takes user-provided input
- * - No examples provided
- *
- * Why:
- * - LLM guessing increases error rate
- */
-import { BaseRule } from '../base.js';
-import { escapeRegex } from '../../utils.js';
-/**
- * Check if an input field appears to be user-provided.
- * Indicators are treated as plain text (not regex patterns).
- */
-function isUserFacingInput(inputName, description) {
-    const name = inputName.toLowerCase();
-    const desc = (description || '').toLowerCase();
-    // Keywords that suggest user input (treated as plain text, not regex)
-    const userInputIndicators = [
-        'user',
-        'person',
-        'name',
-        'email',
-        'location',
-        'address',
-        'preference',
-        'query',
-        'question',
-        'input',
-        'text',
-        'message',
-    ];
-    // Split into tokens for whole-word matching
-    const nameTokens = name
-        .split(/[^\w]+|(?<=[a-z])(?=[A-Z])/)
-        .filter(t => t.length > 0);
-    const descTokens = desc
-        .split(/[^\w]+|(?<=[a-z])(?=[A-Z])/)
-        .filter(t => t.length > 0);
-    const allTokens = new Set([...nameTokens, ...descTokens]);
-    // Check for whole-word matches using word boundaries
-    // Escape indicators to prevent regex injection
-    return userInputIndicators.some(indicator => {
-        if (allTokens.has(indicator)) {
-            return true;
-        }
-        const escapedIndicator = escapeRegex(indicator);
-        const indicatorRegex = new RegExp(`\\b${escapedIndicator}\\b`, 'i');
-        return indicatorRegex.test(name) || indicatorRegex.test(desc);
-    });
-}
-class W003MissingExamplesRule extends BaseRule {
-    id = 'W003';
-    severity = 'warning';
-    ruleName = 'Missing Examples for User-Facing Inputs';
-    description = 'Tool accepts user-provided input but has no examples. LLM accuracy may be reduced.';
-    check(ctx) {
-        const diagnostics = [];
-        for (const tool of ctx.tools) {
-            for (const input of tool.inputs) {
-                // Only check user-facing inputs
-                if (!isUserFacingInput(input.name, input.description)) {
-                    continue;
-                }
-                // Check if it has an example (treat undefined, empty strings, whitespace-only, and empty arrays/objects as missing)
-                const example = input.example;
-                const isMissing = example === undefined ||
-                    (typeof example === 'string' && example.trim().length === 0) ||
-                    (Array.isArray(example) && example.length === 0) ||
-                    (typeof example === 'object' &&
-                        example !== null &&
-                        Object.keys(example).length === 0);
-                if (isMissing) {
-                    diagnostics.push(this.createDiagnostic(`Tool "${tool.name}" parameter "${input.name}" has no examples. LLM accuracy may be reduced.`, tool.name, input.name, `Add example values to "${input.name}" to help the LLM understand the expected format.`));
-                }
-            }
-        }
-        return diagnostics;
-    }
-}
-export const W003MissingExamples = new W003MissingExamplesRule();
-//# sourceMappingURL=w003-missing-examples.js.map

package/dist/runtime/analysis/rules/warnings/w004-overloaded-responsibility.d.ts

@@ -1,23 +0,0 @@
-/**
- * W004: Overloaded Tool Responsibility
- *
- * Condition:
- * - Tool does multiple conceptual things
- * - Description contains multiple verbs or intents
- *
- * Why:
- * - Tool selection becomes unstable
- * - Hard to compose
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class W004OverloadedResponsibilityRule extends BaseRule {
-    readonly id = "W004";
-    readonly severity: "warning";
-    readonly ruleName = "Overloaded Tool Responsibility";
-    readonly description = "Tool appears to handle multiple responsibilities. Tool selection becomes unstable.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const W004OverloadedResponsibility: W004OverloadedResponsibilityRule;
-export {};
-//# sourceMappingURL=w004-overloaded-responsibility.d.ts.map

package/dist/runtime/analysis/rules/warnings/w004-overloaded-responsibility.js

@@ -1,96 +0,0 @@
-/**
- * W004: Overloaded Tool Responsibility
- *
- * Condition:
- * - Tool does multiple conceptual things
- * - Description contains multiple verbs or intents
- *
- * Why:
- * - Tool selection becomes unstable
- * - Hard to compose
- */
-import { BaseRule } from '../base.js';
-/**
- * Count verbs in a description.
- */
-function countVerbs(description) {
-    const commonVerbs = [
-        'get',
-        'set',
-        'create',
-        'delete',
-        'update',
-        'find',
-        'search',
-        'fetch',
-        'send',
-        'receive',
-        'process',
-        'handle',
-        'execute',
-        'run',
-        'call',
-        'invoke',
-        'parse',
-        'format',
-        'validate',
-        'transform',
-        'convert',
-        'merge',
-        'split',
-        'filter',
-        'sort',
-        'save',
-        'load',
-        'read',
-        'write',
-    ];
-    const descLower = description.toLowerCase();
-    let verbCount = 0;
-    for (const verb of commonVerbs) {
-        // Check if verb appears as a word (not just as part of another word)
-        const regex = new RegExp(`\\b${verb}\\b`, 'i');
-        if (regex.test(descLower)) {
-            verbCount++;
-        }
-    }
-    return verbCount;
-}
-/**
- * Count distinct intents (action + object pairs).
- */
-function countIntents(description) {
-    // Simple heuristic: count "and" and "or" which often separate intents
-    const connectors = [' and ', ' or ', ', and ', ', or '];
-    let intentCount = 1; // Start with 1
-    const descLower = description.toLowerCase();
-    for (const connector of connectors) {
-        const matches = descLower.split(connector);
-        if (matches.length > 1) {
-            intentCount = Math.max(intentCount, matches.length);
-        }
-    }
-    return intentCount;
-}
-class W004OverloadedResponsibilityRule extends BaseRule {
-    id = 'W004';
-    severity = 'warning';
-    ruleName = 'Overloaded Tool Responsibility';
-    description = 'Tool appears to handle multiple responsibilities. Tool selection becomes unstable.';
-    check(ctx) {
-        const diagnostics = [];
-        for (const tool of ctx.tools) {
-            const description = tool.description || '';
-            // Count verbs and intents
-            const verbCount = countVerbs(description);
-            const intentCount = countIntents(description);
-            // If too many verbs (>3) or multiple intents (>2), it's overloaded
-            if (verbCount > 3 || intentCount > 2) {
-                diagnostics.push(this.createDiagnostic(`Tool "${tool.name}" appears to handle multiple responsibilities.`, tool.name, undefined, `Split "${tool.name}" into multiple focused tools, each handling a single responsibility.`));
-            }
-        }
-        return diagnostics;
-    }
-}
-export const W004OverloadedResponsibility = new W004OverloadedResponsibilityRule();
-//# sourceMappingURL=w004-overloaded-responsibility.js.map

package/dist/runtime/analysis/rules/warnings/w005-generic-description.d.ts

@@ -1,53 +0,0 @@
-/**
- * W005: Tool Description Too Generic
- *
- * Condition:
- * - Description uses vague verbs:
- *   - "get"
- *   - "handle"
- *   - "process"
- * - No concrete nouns
- *
- * Why:
- * - LLM cannot discriminate tools
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Default list of concrete nouns that make a description specific.
- * This list can be extended or overridden when creating a custom rule instance.
- *
- * @example
- * ```ts
- * import { createW005Rule, DEFAULT_CONCRETE_NOUNS } from './w005-generic-description.js';
- * const customNouns = [...DEFAULT_CONCRETE_NOUNS, 'invoice', 'report'];
- * const customRule = createW005Rule(customNouns);
- * ```
- */
-export declare const DEFAULT_CONCRETE_NOUNS: readonly ["weather", "location", "user", "file", "data", "email", "message", "order", "payment", "product", "customer", "account", "transaction", "request", "response"];
-declare class W005GenericDescriptionRule extends BaseRule {
-    private readonly concreteNouns;
-    readonly id = "W005";
-    readonly severity: "warning";
-    readonly ruleName = "Tool Description Too Generic";
-    readonly description = "Description of tool is too generic. LLM cannot discriminate tools.";
-    constructor(concreteNouns?: readonly string[]);
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-/**
- * Create a W005 rule instance with custom concrete nouns.
- *
- * @param concreteNouns - Optional list of concrete nouns (defaults to DEFAULT_CONCRETE_NOUNS)
- * @returns A new W005GenericDescriptionRule instance
- *
- * @example
- * ```ts
- * import { createW005Rule, DEFAULT_CONCRETE_NOUNS } from './w005-generic-description.js';
- * const customNouns = [...DEFAULT_CONCRETE_NOUNS, 'invoice', 'report'];
- * const customRule = createW005Rule(customNouns);
- * ```
- */
-export declare function createW005Rule(concreteNouns?: readonly string[]): W005GenericDescriptionRule;
-export declare const W005GenericDescription: W005GenericDescriptionRule;
-export {};
-//# sourceMappingURL=w005-generic-description.d.ts.map

package/dist/runtime/analysis/rules/warnings/w005-generic-description.js

@@ -1,108 +0,0 @@
-/**
- * W005: Tool Description Too Generic
- *
- * Condition:
- * - Description uses vague verbs:
- *   - "get"
- *   - "handle"
- *   - "process"
- * - No concrete nouns
- *
- * Why:
- * - LLM cannot discriminate tools
- */
-import { BaseRule } from '../base.js';
-/**
- * Default list of concrete nouns that make a description specific.
- * This list can be extended or overridden when creating a custom rule instance.
- *
- * @example
- * ```ts
- * import { createW005Rule, DEFAULT_CONCRETE_NOUNS } from './w005-generic-description.js';
- * const customNouns = [...DEFAULT_CONCRETE_NOUNS, 'invoice', 'report'];
- * const customRule = createW005Rule(customNouns);
- * ```
- */
-export const DEFAULT_CONCRETE_NOUNS = [
-    'weather',
-    'location',
-    'user',
-    'file',
-    'data',
-    'email',
-    'message',
-    'order',
-    'payment',
-    'product',
-    'customer',
-    'account',
-    'transaction',
-    'request',
-    'response',
-];
-/**
- * Check if description is too generic.
- *
- * @param description - Tool description to check
- * @param concreteNouns - Optional list of concrete nouns (defaults to DEFAULT_CONCRETE_NOUNS)
- */
-function isGenericDescription(description, concreteNouns = DEFAULT_CONCRETE_NOUNS) {
-    const descLower = description.toLowerCase();
-    // Vague verbs
-    const vagueVerbs = ['get', 'handle', 'process', 'do', 'make', 'use', 'call'];
-    // Check for vague verbs without concrete nouns
-    let hasVagueVerb = false;
-    for (const verb of vagueVerbs) {
-        const regex = new RegExp(`\\b${verb}\\b`, 'i');
-        if (regex.test(descLower)) {
-            hasVagueVerb = true;
-            break;
-        }
-    }
-    if (!hasVagueVerb) {
-        return false;
-    }
-    // Check if description has concrete nouns
-    const hasConcreteNoun = concreteNouns.some(noun => descLower.includes(noun));
-    // If has vague verb but no concrete noun, it's generic
-    return !hasConcreteNoun;
-}
-class W005GenericDescriptionRule extends BaseRule {
-    concreteNouns;
-    id = 'W005';
-    severity = 'warning';
-    ruleName = 'Tool Description Too Generic';
-    description = 'Description of tool is too generic. LLM cannot discriminate tools.';
-    constructor(concreteNouns = DEFAULT_CONCRETE_NOUNS) {
-        super();
-        this.concreteNouns = concreteNouns;
-    }
-    check(ctx) {
-        const diagnostics = [];
-        for (const tool of ctx.tools) {
-            const description = tool.description || '';
-            if (isGenericDescription(description, this.concreteNouns)) {
-                diagnostics.push(this.createDiagnostic(`Description of "${tool.name}" is too generic.`, tool.name, undefined, `Make the description more specific by including concrete nouns and specific actions (e.g., "Get weather data for a location" instead of "Get data").`));
-            }
-        }
-        return diagnostics;
-    }
-}
-/**
- * Create a W005 rule instance with custom concrete nouns.
- *
- * @param concreteNouns - Optional list of concrete nouns (defaults to DEFAULT_CONCRETE_NOUNS)
- * @returns A new W005GenericDescriptionRule instance
- *
- * @example
- * ```ts
- * import { createW005Rule, DEFAULT_CONCRETE_NOUNS } from './w005-generic-description.js';
- * const customNouns = [...DEFAULT_CONCRETE_NOUNS, 'invoice', 'report'];
- * const customRule = createW005Rule(customNouns);
- * ```
- */
-export function createW005Rule(concreteNouns) {
-    return new W005GenericDescriptionRule(concreteNouns);
-}
-export const W005GenericDescription = new W005GenericDescriptionRule();
-//# sourceMappingURL=w005-generic-description.js.map

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

@@ -1,22 +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';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class W006OptionalAsRequiredRule extends BaseRule {
-    readonly id = "W006";
-    readonly severity: "warning";
-    readonly ruleName = "Optional Input Used as Required Downstream";
-    readonly description = "Optional input is treated as required downstream. Hidden contract violation.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const W006OptionalAsRequired: W006OptionalAsRequiredRule;
-export {};
-//# sourceMappingURL=w006-optional-as-required.d.ts.map