@syrin/cli 1.3.2 → 1.4.1

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

@@ -1,42 +0,0 @@
-/**
- * E017: 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 E017OutputValidationFailedRule extends BaseRule {
-    id = ERROR_CODES.E017;
-    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 E017OutputValidationFailed = new E017OutputValidationFailedRule();
-//# sourceMappingURL=e017-output-validation-failed.js.map

package/dist/runtime/analysis/rules/errors/e018-input-validation-failed.d.ts

@@ -1,57 +0,0 @@
-/**
- * E018: Input Validation Failed
- *
- * Condition: Tool input doesn't match declared input schema
- *
- * Why this is fatal:
- * - Tool contract is inaccurate
- * - Tool doesn't handle invalid inputs gracefully
- * - Can cause runtime errors in production
- * - Indicates missing input validation or schema mismatch
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for input validation failure detection.
- */
-export interface InputValidationContext {
-    /** Tool name */
-    toolName: string;
-    /** Test name (if applicable) */
-    testName?: string;
-    /** Test input that caused the failure */
-    testInput?: Record<string, unknown>;
-    /** Validation error details */
-    error?: string;
-    /** Parsed error details (field, message, etc.) */
-    parsedError?: {
-        field?: string;
-        message?: string;
-        inputValue?: string;
-        inputType?: string;
-        errorType?: string;
-    };
-    /** Additional validation details */
-    details?: Record<string, unknown>;
-}
-declare class E018InputValidationFailedRule extends BaseRule {
-    readonly id: "E018";
-    readonly severity: "error";
-    readonly ruleName = "Input Validation Failed";
-    readonly description = "Tool input doesn't match declared input schema. Tool doesn't handle invalid inputs gracefully.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Build parsed error message fragment for a field.
-     * @param parsed - Parsed error details
-     * @param baseError - Base error message as fallback
-     * @returns Error message fragment describing the field validation issue
-     */
-    private buildParsedErrorMessage;
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: InputValidationContext): Diagnostic[];
-}
-export declare const E018InputValidationFailed: E018InputValidationFailedRule;
-export {};
-//# sourceMappingURL=e018-input-validation-failed.d.ts.map

package/dist/runtime/analysis/rules/errors/e018-input-validation-failed.js

@@ -1,80 +0,0 @@
-/**
- * E018: Input Validation Failed
- *
- * Condition: Tool input doesn't match declared input schema
- *
- * Why this is fatal:
- * - Tool contract is inaccurate
- * - Tool doesn't handle invalid inputs gracefully
- * - Can cause runtime errors in production
- * - Indicates missing input validation or schema mismatch
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E018InputValidationFailedRule extends BaseRule {
-    id = ERROR_CODES.E018;
-    severity = 'error';
-    ruleName = 'Input Validation Failed';
-    description = "Tool input doesn't match declared input schema. Tool doesn't handle invalid inputs gracefully.";
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Build parsed error message fragment for a field.
-     * @param parsed - Parsed error details
-     * @param baseError - Base error message as fallback
-     * @returns Error message fragment describing the field validation issue
-     */
-    buildParsedErrorMessage(parsed, baseError) {
-        if (!parsed?.field) {
-            return baseError;
-        }
-        if (parsed.message && parsed.inputType) {
-            return `Field "${parsed.field}" - ${parsed.message} (received invalid type ${parsed.inputType})`;
-        }
-        else if (parsed.message) {
-            return `Field "${parsed.field}" - ${parsed.message}`;
-        }
-        else if (parsed.inputType) {
-            return `Field "${parsed.field}" received invalid type ${parsed.inputType}`;
-        }
-        else {
-            return baseError;
-        }
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        // Build a clear error message
-        const baseError = behavioralCtx.error || 'Invalid input';
-        const parsedMessage = this.buildParsedErrorMessage(behavioralCtx.parsedError, baseError);
-        let message;
-        if (behavioralCtx.testName) {
-            // Test-specific error message
-            if (behavioralCtx.parsedError?.field) {
-                message = `Test "${behavioralCtx.testName}" in tool "${behavioralCtx.toolName}" input validation failed: ${parsedMessage}`;
-            }
-            else {
-                message = `Test "${behavioralCtx.testName}" in tool "${behavioralCtx.toolName}" input validation failed: ${baseError}`;
-            }
-        }
-        else if (behavioralCtx.parsedError?.field) {
-            message = `Tool "${behavioralCtx.toolName}" input validation failed: ${parsedMessage}`;
-        }
-        else {
-            message = `Tool "${behavioralCtx.toolName}" input validation failed: ${baseError}`;
-        }
-        diagnostics.push(this.createDiagnostic(message, behavioralCtx.toolName, undefined, 'Fix input validation to handle edge cases gracefully, update input schema to match actual validation, or add proper error handling for invalid inputs.', {
-            testName: behavioralCtx.testName,
-            testInput: behavioralCtx.testInput,
-            parsedError: behavioralCtx.parsedError,
-            ...behavioralCtx.details,
-        }));
-        return diagnostics;
-    }
-}
-export const E018InputValidationFailed = new E018InputValidationFailedRule();
-//# sourceMappingURL=e018-input-validation-failed.js.map

package/dist/runtime/analysis/rules/errors/e018-tool-execution-failed.d.ts

@@ -1,38 +0,0 @@
-/**
- * E018: Tool Execution Failed
- *
- * Condition: Tool raises an exception during execution
- *
- * Why this is fatal:
- * - Tool crashes instead of handling errors gracefully
- * - Breaks agent reliability
- * - Indicates missing error handling or input validation
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for execution error detection.
- */
-export interface ExecutionErrorContext {
-    /** Tool name */
-    toolName: string;
-    /** Execution errors */
-    errors: Array<{
-        message: string;
-        code?: string;
-    }>;
-}
-declare class E018ToolExecutionFailedRule extends BaseRule {
-    readonly id: "E018";
-    readonly severity: "error";
-    readonly ruleName = "Tool Execution Failed";
-    readonly description = "Tool raises an exception during execution. Tool should handle errors gracefully instead of crashing.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: ExecutionErrorContext): Diagnostic[];
-}
-export declare const E018ToolExecutionFailed: E018ToolExecutionFailedRule;
-export {};
-//# sourceMappingURL=e018-tool-execution-failed.d.ts.map

package/dist/runtime/analysis/rules/errors/e018-tool-execution-failed.js

@@ -1,37 +0,0 @@
-/**
- * E018: Tool Execution Failed
- *
- * Condition: Tool raises an exception during execution
- *
- * Why this is fatal:
- * - Tool crashes instead of handling errors gracefully
- * - Breaks agent reliability
- * - Indicates missing error handling or input validation
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E018ToolExecutionFailedRule extends BaseRule {
-    id = ERROR_CODES.E018;
-    severity = 'error';
-    ruleName = 'Tool Execution Failed';
-    description = 'Tool raises an exception during execution. Tool should handle errors gracefully instead of crashing.';
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        if (behavioralCtx.errors.length > 0) {
-            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 and validates inputs before processing.'));
-        }
-        return diagnostics;
-    }
-}
-export const E018ToolExecutionFailed = new E018ToolExecutionFailedRule();
-//# sourceMappingURL=e018-tool-execution-failed.js.map

package/dist/runtime/analysis/rules/errors/e019-tool-execution-failed.d.ts

@@ -1,38 +0,0 @@
-/**
- * E019: Tool Execution Failed
- *
- * Condition: Tool raises an exception during execution
- *
- * Why this is fatal:
- * - Tool crashes instead of handling errors gracefully
- * - Breaks agent reliability
- * - Indicates missing error handling or input validation
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for execution error detection.
- */
-export interface ExecutionErrorContext {
-    /** Tool name */
-    toolName: string;
-    /** Execution errors */
-    errors: Array<{
-        message: string;
-        code?: string;
-    }>;
-}
-declare class E019ToolExecutionFailedRule extends BaseRule {
-    readonly id: "E019";
-    readonly severity: "error";
-    readonly ruleName = "Tool Execution Failed";
-    readonly description = "Tool raises an exception during execution. Tool should handle errors gracefully instead of crashing.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: ExecutionErrorContext): Diagnostic[];
-}
-export declare const E019ToolExecutionFailed: E019ToolExecutionFailedRule;
-export {};
-//# sourceMappingURL=e019-tool-execution-failed.d.ts.map

package/dist/runtime/analysis/rules/errors/e019-tool-execution-failed.js

@@ -1,37 +0,0 @@
-/**
- * E019: Tool Execution Failed
- *
- * Condition: Tool raises an exception during execution
- *
- * Why this is fatal:
- * - Tool crashes instead of handling errors gracefully
- * - Breaks agent reliability
- * - Indicates missing error handling or input validation
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E019ToolExecutionFailedRule extends BaseRule {
-    id = ERROR_CODES.E019;
-    severity = 'error';
-    ruleName = 'Tool Execution Failed';
-    description = 'Tool raises an exception during execution. Tool should handle errors gracefully instead of crashing.';
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        if (behavioralCtx.errors.length > 0) {
-            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 and validates inputs before processing.'));
-        }
-        return diagnostics;
-    }
-}
-export const E019ToolExecutionFailed = new E019ToolExecutionFailedRule();
-//# sourceMappingURL=e019-tool-execution-failed.js.map

package/dist/runtime/analysis/rules/errors/e019-unexpected-test-result.d.ts

@@ -1,65 +0,0 @@
-/**
- * E019: 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 type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for unexpected test result detection.
- */
-export interface UnexpectedTestResultContext {
-    /** Tool name */
-    toolName: string;
-    /** Test name */
-    testName: string;
-    /** Test input */
-    testInput?: Record<string, unknown>;
-    /** Expected outcome (success/error/timeout) */
-    expectedOutcome: 'success' | 'error' | 'timeout';
-    /** Actual outcome (success/error/timeout) */
-    actualOutcome: 'success' | 'error' | 'timeout';
-    /** Expected error code (if expecting error) */
-    expectedErrorCode?: string;
-    /** Expected error type (if expecting error) */
-    expectedErrorType?: string;
-    /** Actual error code (if actual outcome is error) */
-    actualErrorCode?: string;
-    /** Actual error type (if actual outcome is error) */
-    actualErrorType?: string;
-    /** Expected error details (if expecting specific error) */
-    expectedError?: {
-        type?: string;
-        details?: Record<string, unknown>;
-    };
-    /** Actual error details (if actual outcome is error) */
-    actualError?: {
-        code?: string;
-        type?: string;
-        message?: string;
-    };
-}
-declare class E019UnexpectedTestResultRule extends BaseRule {
-    readonly id: "E019";
-    readonly severity: "error";
-    readonly ruleName = "Unexpected Test Result";
-    readonly description = "Test's actual outcome doesn't match its expectation. Tool behavior doesn't match declared guarantees.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Determine if a diagnostic should be created based on behavioral context.
-     */
-    private shouldCreateDiagnostic;
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: UnexpectedTestResultContext): Diagnostic[];
-}
-export declare const E019UnexpectedTestResult: E019UnexpectedTestResultRule;
-export {};
-//# sourceMappingURL=e019-unexpected-test-result.d.ts.map

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

@@ -1,109 +0,0 @@
-/**
- * E019: 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 E019UnexpectedTestResultRule extends BaseRule {
-    id = ERROR_CODES.E019;
-    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 E019UnexpectedTestResult = new E019UnexpectedTestResultRule();
-//# sourceMappingURL=e019-unexpected-test-result.js.map

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

@@ -1,65 +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 type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for unexpected test result detection.
- */
-export interface UnexpectedTestResultContext {
-    /** Tool name */
-    toolName: string;
-    /** Test name */
-    testName: string;
-    /** Test input */
-    testInput?: Record<string, unknown>;
-    /** Expected outcome (success/error/timeout) */
-    expectedOutcome: 'success' | 'error' | 'timeout';
-    /** Actual outcome (success/error/timeout) */
-    actualOutcome: 'success' | 'error' | 'timeout';
-    /** Expected error code (if expecting error) */
-    expectedErrorCode?: string;
-    /** Expected error type (if expecting error) */
-    expectedErrorType?: string;
-    /** Actual error code (if actual outcome is error) */
-    actualErrorCode?: string;
-    /** Actual error type (if actual outcome is error) */
-    actualErrorType?: string;
-    /** Expected error details (if expecting specific error) */
-    expectedError?: {
-        type?: string;
-        details?: Record<string, unknown>;
-    };
-    /** Actual error details (if actual outcome is error) */
-    actualError?: {
-        code?: string;
-        type?: string;
-        message?: string;
-    };
-}
-declare class E020UnexpectedTestResultRule extends BaseRule {
-    readonly id: "E020";
-    readonly severity: "error";
-    readonly ruleName = "Unexpected Test Result";
-    readonly description = "Test's actual outcome doesn't match its expectation. Tool behavior doesn't match declared guarantees.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Determine if a diagnostic should be created based on behavioral context.
-     */
-    private shouldCreateDiagnostic;
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: UnexpectedTestResultContext): Diagnostic[];
-}
-export declare const E020UnexpectedTestResult: E020UnexpectedTestResultRule;
-export {};
-//# sourceMappingURL=e020-unexpected-test-result.d.ts.map