@syrin/cli 1.3.2 → 1.4.0

package/dist/runtime/analysis/rules/errors/e012-side-effect-detected.js

@@ -1,40 +0,0 @@
-/**
- * E012: Side Effect Detected
- *
- * Condition: Tool attempts filesystem writes to project files (not temp directory)
- *
- * Why this is fatal:
- * - Tools should not mutate project state
- * - Breaks isolation and testability
- * - Makes behavior unpredictable
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E012SideEffectDetectedRule extends BaseRule {
-    id = ERROR_CODES.E012;
-    severity = 'error';
-    ruleName = 'Side Effect Detected';
-    description = 'Tool attempted filesystem write to project files. Tools should not mutate project state.';
-    check(_ctx) {
-        const diagnostics = [];
-        // This rule requires behavioral context (from runtime testing)
-        // It will be called with behavioral data from the test orchestrator
-        // For now, return empty - actual checking happens in test orchestrator
-        return diagnostics;
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        if (behavioralCtx.sideEffects.length > 0) {
-            const sideEffectList = behavioralCtx.sideEffects
-                .map(se => `  - ${se.operation}: ${se.path}`)
-                .join('\n');
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" attempted filesystem operations on project files:\n${sideEffectList}`, behavioralCtx.toolName, undefined, 'Remove filesystem writes or write only to temp directory. Tools should not mutate project state.'));
-        }
-        return diagnostics;
-    }
-}
-export const E012SideEffectDetected = new E012SideEffectDetectedRule();
-//# sourceMappingURL=e012-side-effect-detected.js.map

package/dist/runtime/analysis/rules/errors/e013-non-deterministic-output.d.ts

@@ -1,37 +0,0 @@
-/**
- * E013: Non-Deterministic Output
- *
- * Condition: Tool produces different outputs for the same input across multiple runs
- *
- * Why this is fatal:
- * - Breaks agent reliability
- * - Makes testing impossible
- * - LLM cannot reason about tool behavior
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for non-determinism detection.
- */
-export interface NonDeterminismContext {
-    /** Tool name */
-    toolName: string;
-    /** Number of runs that produced different outputs */
-    differentRuns: number;
-    /** Total number of runs */
-    totalRuns: number;
-}
-declare class E013NonDeterministicOutputRule extends BaseRule {
-    readonly id: any;
-    readonly severity: "error";
-    readonly ruleName = "Non-Deterministic Output";
-    readonly description = "Tool produces different outputs for the same input across multiple runs. This breaks agent reliability.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: NonDeterminismContext): Diagnostic[];
-}
-export declare const E013NonDeterministicOutput: E013NonDeterministicOutputRule;
-export {};
-//# sourceMappingURL=e013-non-deterministic-output.d.ts.map

package/dist/runtime/analysis/rules/errors/e013-non-deterministic-output.js

@@ -1,34 +0,0 @@
-/**
- * E013: Non-Deterministic Output
- *
- * Condition: Tool produces different outputs for the same input across multiple runs
- *
- * Why this is fatal:
- * - Breaks agent reliability
- * - Makes testing impossible
- * - LLM cannot reason about tool behavior
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E013NonDeterministicOutputRule extends BaseRule {
-    id = ERROR_CODES.E013;
-    severity = 'error';
-    ruleName = 'Non-Deterministic Output';
-    description = 'Tool produces different outputs for the same input across multiple runs. This breaks agent reliability.';
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        if (behavioralCtx.differentRuns > 0) {
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" produced different outputs across ${behavioralCtx.totalRuns} runs. ${behavioralCtx.differentRuns} run(s) produced different results.`, behavioralCtx.toolName, undefined, 'Ensure tool produces consistent outputs for the same input. Remove sources of non-determinism (random values, timestamps, etc.).'));
-        }
-        return diagnostics;
-    }
-}
-export const E013NonDeterministicOutput = new E013NonDeterministicOutputRule();
-//# sourceMappingURL=e013-non-deterministic-output.js.map

package/dist/runtime/analysis/rules/errors/e013-output-explosion.d.ts

@@ -1,39 +0,0 @@
-/**
- * E013: Output Explosion
- *
- * Condition: Tool output exceeds declared size limit
- *
- * Why this is fatal:
- * - Large outputs overwhelm LLM context
- * - Breaks agent reasoning
- * - Indicates design issue (pagination, filtering needed)
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for output size validation.
- */
-export interface OutputSizeContext {
-    /** Tool name */
-    toolName: string;
-    /** Actual output size in bytes */
-    actualSize: number;
-    /** Maximum allowed size in bytes */
-    maxSize: number;
-    /** Size limit string from contract (e.g., "50kb") */
-    limitString: string;
-}
-declare class E013OutputExplosionRule extends BaseRule {
-    readonly id: "E013";
-    readonly severity: "error";
-    readonly ruleName = "Output Explosion";
-    readonly description = "Tool output exceeds declared size limit. Large outputs overwhelm LLM context and break agent reasoning.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: OutputSizeContext): Diagnostic[];
-}
-export declare const E013OutputExplosion: E013OutputExplosionRule;
-export {};
-//# sourceMappingURL=e013-output-explosion.d.ts.map

package/dist/runtime/analysis/rules/errors/e013-output-explosion.js

@@ -1,36 +0,0 @@
-/**
- * E013: Output Explosion
- *
- * Condition: Tool output exceeds declared size limit
- *
- * Why this is fatal:
- * - Large outputs overwhelm LLM context
- * - Breaks agent reasoning
- * - Indicates design issue (pagination, filtering needed)
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E013OutputExplosionRule extends BaseRule {
-    id = ERROR_CODES.E013;
-    severity = 'error';
-    ruleName = 'Output Explosion';
-    description = 'Tool output exceeds declared size limit. Large outputs overwhelm LLM context and break agent reasoning.';
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        if (behavioralCtx.actualSize > behavioralCtx.maxSize) {
-            const actualSizeKB = (behavioralCtx.actualSize / 1024).toFixed(2);
-            const maxSizeKB = (behavioralCtx.maxSize / 1024).toFixed(2);
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" returned ${actualSizeKB}KB, exceeding declared limit of ${behavioralCtx.limitString} (${maxSizeKB}KB).`, behavioralCtx.toolName, undefined, `Reduce output size by: paginating results, adding filters, or updating contract limit if legitimate (max_output_size: ${Math.ceil(behavioralCtx.actualSize / 1024)}kb).`));
-        }
-        return diagnostics;
-    }
-}
-export const E013OutputExplosion = new E013OutputExplosionRule();
-//# sourceMappingURL=e013-output-explosion.js.map

package/dist/runtime/analysis/rules/errors/e014-hidden-dependency.d.ts

@@ -1,42 +0,0 @@
-/**
- * E014: Hidden Dependency
- *
- * Condition: Tool calls other tools during execution without declaring them in contract
- *
- * Why this is fatal:
- * - Breaks isolation assumption
- * - Creates hidden coupling
- * - Makes tool behavior unpredictable
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for hidden dependency detection.
- */
-export interface HiddenDependencyContext {
-    /** Tool name */
-    toolName: string;
-    /** List of tool calls that are not declared */
-    hiddenDependencies: Array<{
-        toolName: string;
-        timestamp: number;
-    }>;
-    /** List of declared dependencies that don't exist in the MCP server */
-    missingDependencies?: string[];
-    /** Declared dependencies from contract — reserved for future validation/consumer use */
-    declaredDependencies: string[];
-}
-declare class E014HiddenDependencyRule extends BaseRule {
-    readonly id: "E014";
-    readonly severity: "error";
-    readonly ruleName = "Hidden Dependency";
-    readonly description = "Tool calls other tools during execution without declaring them in contract. This breaks isolation.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: HiddenDependencyContext): Diagnostic[];
-}
-export declare const E014HiddenDependency: E014HiddenDependencyRule;
-export {};
-//# sourceMappingURL=e014-hidden-dependency.d.ts.map

package/dist/runtime/analysis/rules/errors/e014-hidden-dependency.js

@@ -1,46 +0,0 @@
-/**
- * E014: Hidden Dependency
- *
- * Condition: Tool calls other tools during execution without declaring them in contract
- *
- * Why this is fatal:
- * - Breaks isolation assumption
- * - Creates hidden coupling
- * - Makes tool behavior unpredictable
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E014HiddenDependencyRule extends BaseRule {
-    id = ERROR_CODES.E014;
-    severity = 'error';
-    ruleName = 'Hidden Dependency';
-    description = 'Tool calls other tools during execution without declaring them in contract. This breaks isolation.';
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        // Check for hidden dependencies (tools called but not declared)
-        if (behavioralCtx.hiddenDependencies.length > 0) {
-            const dependencyList = behavioralCtx.hiddenDependencies
-                .map(dep => `  - ${dep.toolName}`)
-                .join('\n');
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" called other tools without declaring them:\n${dependencyList}`, behavioralCtx.toolName, undefined, `Declare dependencies in contract (guarantees.dependencies: [${behavioralCtx.hiddenDependencies.map(d => `"${d.toolName}"`).join(', ')}]) or remove the tool calls.`));
-        }
-        // Check for missing dependencies (declared but don't exist in MCP server)
-        if (behavioralCtx.missingDependencies &&
-            behavioralCtx.missingDependencies.length > 0) {
-            const missingList = behavioralCtx.missingDependencies
-                .map(dep => `  - ${dep}`)
-                .join('\n');
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" declares dependencies that don't exist in the MCP server:\n${missingList}`, behavioralCtx.toolName, undefined, `Remove non-existent dependencies from contract (guarantees.dependencies) or ensure these tools are implemented: [${behavioralCtx.missingDependencies.map(d => `"${d}"`).join(', ')}]`));
-        }
-        return diagnostics;
-    }
-}
-export const E014HiddenDependency = new E014HiddenDependencyRule();
-//# sourceMappingURL=e014-hidden-dependency.js.map

package/dist/runtime/analysis/rules/errors/e014-output-explosion.d.ts

@@ -1,39 +0,0 @@
-/**
- * E014: Output Explosion
- *
- * Condition: Tool output exceeds declared size limit
- *
- * Why this is fatal:
- * - Large outputs overwhelm LLM context
- * - Breaks agent reasoning
- * - Indicates design issue (pagination, filtering needed)
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for output size validation.
- */
-export interface OutputSizeContext {
-    /** Tool name */
-    toolName: string;
-    /** Actual output size in bytes */
-    actualSize: number;
-    /** Maximum allowed size in bytes */
-    maxSize: number;
-    /** Size limit string from contract (e.g., "50kb") */
-    limitString: string;
-}
-declare class E014OutputExplosionRule extends BaseRule {
-    readonly id: "E014";
-    readonly severity: "error";
-    readonly ruleName = "Output Explosion";
-    readonly description = "Tool output exceeds declared size limit. Large outputs overwhelm LLM context and break agent reasoning.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: OutputSizeContext): Diagnostic[];
-}
-export declare const E014OutputExplosion: E014OutputExplosionRule;
-export {};
-//# sourceMappingURL=e014-output-explosion.d.ts.map

package/dist/runtime/analysis/rules/errors/e014-output-explosion.js

@@ -1,36 +0,0 @@
-/**
- * E014: Output Explosion
- *
- * Condition: Tool output exceeds declared size limit
- *
- * Why this is fatal:
- * - Large outputs overwhelm LLM context
- * - Breaks agent reasoning
- * - Indicates design issue (pagination, filtering needed)
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E014OutputExplosionRule extends BaseRule {
-    id = ERROR_CODES.E014;
-    severity = 'error';
-    ruleName = 'Output Explosion';
-    description = 'Tool output exceeds declared size limit. Large outputs overwhelm LLM context and break agent reasoning.';
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        if (behavioralCtx.actualSize > behavioralCtx.maxSize) {
-            const actualSizeKB = (behavioralCtx.actualSize / 1024).toFixed(2);
-            const maxSizeKB = (behavioralCtx.maxSize / 1024).toFixed(2);
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" returned ${actualSizeKB}KB, exceeding declared limit of ${behavioralCtx.limitString} (${maxSizeKB}KB).`, behavioralCtx.toolName, undefined, `Reduce output size by: paginating results, adding filters, or updating contract limit if legitimate (max_output_size: ${Math.ceil(behavioralCtx.actualSize / 1024)}kb).`));
-        }
-        return diagnostics;
-    }
-}
-export const E014OutputExplosion = new E014OutputExplosionRule();
-//# sourceMappingURL=e014-output-explosion.js.map

package/dist/runtime/analysis/rules/errors/e015-hidden-dependency.d.ts

@@ -1,42 +0,0 @@
-/**
- * E015: Hidden Dependency
- *
- * Condition: Tool calls other tools during execution without declaring them in contract
- *
- * Why this is fatal:
- * - Breaks isolation assumption
- * - Creates hidden coupling
- * - Makes tool behavior unpredictable
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for hidden dependency detection.
- */
-export interface HiddenDependencyContext {
-    /** Tool name */
-    toolName: string;
-    /** List of tool calls that are not declared */
-    hiddenDependencies: Array<{
-        toolName: string;
-        timestamp: number;
-    }>;
-    /** List of declared dependencies that don't exist in the MCP server */
-    missingDependencies?: string[];
-    /** Declared dependencies from contract — reserved for future validation/consumer use */
-    declaredDependencies: string[];
-}
-declare class E015HiddenDependencyRule extends BaseRule {
-    readonly id: "E015";
-    readonly severity: "error";
-    readonly ruleName = "Hidden Dependency";
-    readonly description = "Tool calls other tools during execution without declaring them in contract. This breaks isolation.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: HiddenDependencyContext): Diagnostic[];
-}
-export declare const E015HiddenDependency: E015HiddenDependencyRule;
-export {};
-//# sourceMappingURL=e015-hidden-dependency.d.ts.map

package/dist/runtime/analysis/rules/errors/e015-hidden-dependency.js

@@ -1,46 +0,0 @@
-/**
- * E015: Hidden Dependency
- *
- * Condition: Tool calls other tools during execution without declaring them in contract
- *
- * Why this is fatal:
- * - Breaks isolation assumption
- * - Creates hidden coupling
- * - Makes tool behavior unpredictable
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E015HiddenDependencyRule extends BaseRule {
-    id = ERROR_CODES.E015;
-    severity = 'error';
-    ruleName = 'Hidden Dependency';
-    description = 'Tool calls other tools during execution without declaring them in contract. This breaks isolation.';
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        // Check for hidden dependencies (tools called but not declared)
-        if (behavioralCtx.hiddenDependencies.length > 0) {
-            const dependencyList = behavioralCtx.hiddenDependencies
-                .map(dep => `  - ${dep.toolName}`)
-                .join('\n');
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" called other tools without declaring them:\n${dependencyList}`, behavioralCtx.toolName, undefined, `Declare dependencies in contract (guarantees.dependencies: [${behavioralCtx.hiddenDependencies.map(d => `"${d.toolName}"`).join(', ')}]) or remove the tool calls.`));
-        }
-        // Check for missing dependencies (declared but don't exist in MCP server)
-        if (behavioralCtx.missingDependencies &&
-            behavioralCtx.missingDependencies.length > 0) {
-            const missingList = behavioralCtx.missingDependencies
-                .map(dep => `  - ${dep}`)
-                .join('\n');
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" declares dependencies that don't exist in the MCP server:\n${missingList}`, behavioralCtx.toolName, undefined, `Remove non-existent dependencies from contract (guarantees.dependencies) or ensure these tools are implemented: [${behavioralCtx.missingDependencies.map(d => `"${d}"`).join(', ')}]`));
-        }
-        return diagnostics;
-    }
-}
-export const E015HiddenDependency = new E015HiddenDependencyRule();
-//# sourceMappingURL=e015-hidden-dependency.js.map

package/dist/runtime/analysis/rules/errors/e015-unbounded-execution.d.ts

@@ -1,44 +0,0 @@
-/**
- * E015: Unbounded Execution
- *
- * Condition: Tool execution timed out or failed to terminate
- *
- * Why this is fatal:
- * - Tool may hang indefinitely
- * - Breaks agent reliability
- * - Indicates design issue (missing timeouts, infinite loops)
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for unbounded execution detection.
- */
-export interface UnboundedExecutionContext {
-    /** Tool name */
-    toolName: string;
-    /** Whether execution timed out */
-    timedOut: boolean;
-    /** Declared max execution time (e.g., "5m", "2h") or undefined if using default */
-    declaredTimeout?: string;
-    /** Actual timeout used in milliseconds */
-    actualTimeoutMs?: number;
-    /** Execution errors */
-    errors: Array<{
-        message: string;
-        code?: string;
-    }>;
-}
-declare class E015UnboundedExecutionRule extends BaseRule {
-    readonly id: "E015";
-    readonly severity: "error";
-    readonly ruleName = "Unbounded Execution";
-    readonly description = "Tool execution timed out or failed to terminate. Tool may hang indefinitely, breaking agent reliability.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: UnboundedExecutionContext): Diagnostic[];
-}
-export declare const E015UnboundedExecution: E015UnboundedExecutionRule;
-export {};
-//# sourceMappingURL=e015-unbounded-execution.d.ts.map

package/dist/runtime/analysis/rules/errors/e015-unbounded-execution.js

@@ -1,66 +0,0 @@
-/**
- * E015: Unbounded Execution
- *
- * Condition: Tool execution timed out or failed to terminate
- *
- * Why this is fatal:
- * - Tool may hang indefinitely
- * - Breaks agent reliability
- * - Indicates design issue (missing timeouts, infinite loops)
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-/**
- * Format timeout in milliseconds to human-readable string.
- */
-function formatTimeout(ms) {
-    if (ms < 1000) {
-        return `${ms}ms`;
-    }
-    const s = Math.floor(ms / 1000);
-    if (s < 60) {
-        return `${s}s`;
-    }
-    const m = Math.floor(s / 60);
-    if (m < 60) {
-        return `${m}m`;
-    }
-    const h = Math.floor(m / 60);
-    return `${h}h`;
-}
-class E015UnboundedExecutionRule extends BaseRule {
-    id = ERROR_CODES.E015;
-    severity = 'error';
-    ruleName = 'Unbounded Execution';
-    description = 'Tool execution timed out or failed to terminate. Tool may hang indefinitely, breaking agent reliability.';
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        if (behavioralCtx.timedOut) {
-            const timeoutInfo = behavioralCtx.declaredTimeout
-                ? ` (exceeded declared timeout: ${behavioralCtx.declaredTimeout})`
-                : behavioralCtx.actualTimeoutMs
-                    ? ` (exceeded default timeout: ${formatTimeout(behavioralCtx.actualTimeoutMs)})`
-                    : '';
-            const suggestion = behavioralCtx.declaredTimeout
-                ? `Tool exceeded its declared max_execution_time (${behavioralCtx.declaredTimeout}). Either fix the tool to complete within this time, or update the contract if a longer timeout is legitimate.`
-                : 'Add timeouts, fix infinite loops, or optimize slow operations. If tool legitimately takes longer, declare max_execution_time in contract (e.g., "5m", "2h").';
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" execution timed out${timeoutInfo}. Tool may hang indefinitely.`, behavioralCtx.toolName, undefined, suggestion));
-        }
-        if (behavioralCtx.errors.length > 0 && !behavioralCtx.timedOut) {
-            const errorMessages = behavioralCtx.errors
-                .map(e => `  - ${e.message}`)
-                .join('\n');
-            diagnostics.push(this.createDiagnostic(`Tool "${behavioralCtx.toolName}" execution failed:\n${errorMessages}`, behavioralCtx.toolName, undefined, 'Fix tool implementation errors. Ensure tool handles all input cases gracefully.'));
-        }
-        return diagnostics;
-    }
-}
-export const E015UnboundedExecution = new E015UnboundedExecutionRule();
-//# sourceMappingURL=e015-unbounded-execution.js.map

package/dist/runtime/analysis/rules/errors/e016-output-validation-failed.d.ts

@@ -1,43 +0,0 @@
-/**
- * E016: Output Structure Validation Failed
- *
- * Condition: Tool output doesn't match declared output schema
- *
- * Why this is fatal:
- * - Tool contract is inaccurate
- * - Breaks agent's ability to reason about tool outputs
- * - Can cause downstream errors in tool chains
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for output validation failure detection.
- */
-export interface OutputValidationContext {
-    /** Tool name */
-    toolName: string;
-    /** Test name (if applicable) */
-    testName?: string;
-    /** Test input that caused the failure */
-    testInput?: Record<string, unknown>;
-    /** Expected output schema name */
-    expectedOutputSchema?: string;
-    /** Validation error details */
-    error?: string;
-    /** Additional validation details */
-    details?: Record<string, unknown>;
-}
-declare class E016OutputValidationFailedRule extends BaseRule {
-    readonly id: "E016";
-    readonly severity: "error";
-    readonly ruleName = "Output Structure Validation Failed";
-    readonly description = "Tool output doesn't match declared output schema. This breaks agent's ability to reason about tool outputs.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: OutputValidationContext): Diagnostic[];
-}
-export declare const E016OutputValidationFailed: E016OutputValidationFailedRule;
-export {};
-//# sourceMappingURL=e016-output-validation-failed.d.ts.map

package/dist/runtime/analysis/rules/errors/e016-output-validation-failed.js

@@ -1,42 +0,0 @@
-/**
- * E016: Output Structure Validation Failed
- *
- * Condition: Tool output doesn't match declared output schema
- *
- * Why this is fatal:
- * - Tool contract is inaccurate
- * - Breaks agent's ability to reason about tool outputs
- * - Can cause downstream errors in tool chains
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E016OutputValidationFailedRule extends BaseRule {
-    id = ERROR_CODES.E016;
-    severity = 'error';
-    ruleName = 'Output Structure Validation Failed';
-    description = "Tool output doesn't match declared output schema. This breaks agent's ability to reason about tool outputs.";
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        const errorMessage = behavioralCtx.error || 'Output structure does not match schema';
-        let message = `Tool "${behavioralCtx.toolName}" output validation failed: ${errorMessage}`;
-        if (behavioralCtx.testName) {
-            message = `Test "${behavioralCtx.testName}" in tool "${behavioralCtx.toolName}" output validation failed: ${errorMessage}`;
-        }
-        diagnostics.push(this.createDiagnostic(message, behavioralCtx.toolName, undefined, 'Fix output structure to match declared schema or update schema to match actual output. Ensure output schema accurately reflects tool behavior.', {
-            testName: behavioralCtx.testName,
-            testInput: behavioralCtx.testInput,
-            expectedOutputSchema: behavioralCtx.expectedOutputSchema,
-            ...behavioralCtx.details,
-        }));
-        return diagnostics;
-    }
-}
-export const E016OutputValidationFailed = new E016OutputValidationFailedRule();
-//# sourceMappingURL=e016-output-validation-failed.js.map