@syrin/cli 1.3.2 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syrin/cli",
-  "version": "1.3.2",
+  "version": "1.4.1",
   "description": "Syrin is a runtime intelligence system that makes MCP servers debuggable, testable, and safe to run in production.",
   "type": "module",
   "main": "dist/index.js",
@@ -23,7 +23,7 @@
     "LICENSE"
   ],
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.12.0"
   },
   "keywords": [
     "mcp",
@@ -55,52 +55,52 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/syrin-labs/cli.git"
+    "url": "git+https://github.com/Syrin-Labs/cli.git"
   },
   "author": "Syrin Labs Team",
   "license": "ISC",
   "bugs": {
-    "url": "https://github.com/syrin-labs/cli/issues"
+    "url": "https://github.com/Syrin-Labs/cli/issues"
   },
-  "homepage": "https://github.com/syrin-labs/cli#readme",
+  "homepage": "https://github.com/Syrin-Labs/cli#readme",
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.9",
     "@types/js-yaml": "^4.0.9",
-    "@types/node": "^25.0.3",
-    "@types/react": "^19.2.7",
+    "@types/node": "^25.2.0",
+    "@types/react": "^19.2.10",
     "@types/uuid": "^10.0.0",
-    "@typescript-eslint/eslint-plugin": "^8.52.0",
-    "@typescript-eslint/parser": "^8.52.0",
-    "@vitest/coverage-v8": "^3.2.4",
-    "@vitest/ui": "^3.2.4",
+    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "@typescript-eslint/parser": "^8.54.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/ui": "^4.0.18",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-prettier": "^5.5.4",
-    "globals": "^17.0.0",
-    "prettier": "^3.7.4",
+    "eslint-plugin-prettier": "^5.5.5",
+    "globals": "^17.3.0",
+    "prettier": "^3.8.1",
     "tsc-alias": "^1.8.16",
     "tsconfig-paths": "^4.2.0",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "vitest": "^4.0.18"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.71.2",
-    "@apidevtools/json-schema-ref-parser": "^15.1.3",
-    "@modelcontextprotocol/sdk": "^1.25.1",
-    "commander": "^14.0.2",
+    "@anthropic-ai/sdk": "^0.72.1",
+    "@apidevtools/json-schema-ref-parser": "^15.2.2",
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "commander": "^14.0.3",
     "ink": "^6.6.0",
     "ink-text-input": "^6.0.0",
-    "inquirer": "^13.1.0",
+    "inquirer": "^13.2.2",
     "js-yaml": "^4.1.1",
     "ollama": "^0.6.3",
-    "openai": "^6.15.0",
-    "react": "^19.2.3",
+    "openai": "^6.17.0",
+    "react": "^19.2.4",
     "uuid": "^13.0.0",
-    "zod": "^4.3.5"
+    "zod": "^4.3.6"
   }
 }

package/dist/runtime/analysis/rules/errors/e001-missing-output-schema.d.ts

@@ -1,22 +0,0 @@
-/**
- * E001: Missing Output Schema
- *
- * Condition: Tool does not declare an output schema
- *
- * Why this is fatal:
- * - Downstream tools cannot reason about outputs
- * - LLM will invent structure
- * - Reproducibility is impossible
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class E001MissingOutputSchemaRule extends BaseRule {
-    readonly id: "E001";
-    readonly severity: "error";
-    readonly ruleName = "Missing Output Schema";
-    readonly description = "Tool does not declare an output schema. Downstream tools cannot safely consume its output.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const E001MissingOutputSchema: E001MissingOutputSchemaRule;
-export {};
-//# sourceMappingURL=e001-missing-output-schema.d.ts.map

package/dist/runtime/analysis/rules/errors/e001-missing-output-schema.js

@@ -1,30 +0,0 @@
-/**
- * E001: Missing Output Schema
- *
- * Condition: Tool does not declare an output schema
- *
- * Why this is fatal:
- * - Downstream tools cannot reason about outputs
- * - LLM will invent structure
- * - Reproducibility is impossible
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E001MissingOutputSchemaRule extends BaseRule {
-    id = ERROR_CODES.E001;
-    severity = 'error';
-    ruleName = 'Missing Output Schema';
-    description = 'Tool does not declare an output schema. Downstream tools cannot safely consume its output.';
-    check(ctx) {
-        const diagnostics = [];
-        for (const tool of ctx.tools) {
-            // Check if tool has no output fields
-            if (!tool.outputs || tool.outputs.length === 0) {
-                diagnostics.push(this.createDiagnostic(`Tool "${tool.name}" has no output schema. Downstream tools cannot safely consume its output.`, tool.name, undefined, 'Add an output schema to the tool definition to specify the structure of the output.'));
-            }
-        }
-        return diagnostics;
-    }
-}
-export const E001MissingOutputSchema = new E001MissingOutputSchemaRule();
-//# sourceMappingURL=e001-missing-output-schema.js.map

package/dist/runtime/analysis/rules/errors/e002-underspecified-input.d.ts

@@ -1,24 +0,0 @@
-/**
- * E002: Underspecified Required Input
- *
- * Condition:
- * - Input parameter is required AND
- * - Type is broad (string, any, object) AND
- * - No description, constraints, enum, regex, or example
- *
- * Why:
- * - LLM will hallucinate values
- * - Tool invocation becomes nondeterministic
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class E002UnderspecifiedRequiredInputRule extends BaseRule {
-    readonly id: "E002";
-    readonly severity: "error";
-    readonly ruleName = "Underspecified Required Input";
-    readonly description = "Required parameter is underspecified. LLM may pass invalid or ambiguous values.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const E002UnderspecifiedRequiredInput: E002UnderspecifiedRequiredInputRule;
-export {};
-//# sourceMappingURL=e002-underspecified-input.d.ts.map

package/dist/runtime/analysis/rules/errors/e002-underspecified-input.js

@@ -1,52 +0,0 @@
-/**
- * E002: Underspecified Required Input
- *
- * Condition:
- * - Input parameter is required AND
- * - Type is broad (string, any, object) AND
- * - No description, constraints, enum, regex, or example
- *
- * Why:
- * - LLM will hallucinate values
- * - Tool invocation becomes nondeterministic
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E002UnderspecifiedRequiredInputRule extends BaseRule {
-    id = ERROR_CODES.E002;
-    severity = 'error';
-    ruleName = 'Underspecified Required Input';
-    description = 'Required parameter is underspecified. LLM may pass invalid or ambiguous values.';
-    check(ctx) {
-        const diagnostics = [];
-        // Broad types that need constraints
-        const broadTypes = new Set(['string', 'any', 'object']);
-        for (const tool of ctx.tools) {
-            for (const input of tool.inputs) {
-                // Check if type is broad
-                if (!broadTypes.has(input.type)) {
-                    continue;
-                }
-                // Check if it has any constraints
-                const hasDescription = Boolean(input.description && input.description.trim());
-                const hasEnum = Boolean(input.enum && input.enum.length > 0);
-                const hasPattern = Boolean(input.pattern);
-                const hasExample = input.example !== undefined;
-                // If it's broad and has no constraints, it's underspecified
-                if (!hasDescription && !hasEnum && !hasPattern && !hasExample) {
-                    if (input.required) {
-                        // Required parameter without constraints - error
-                        diagnostics.push(this.createDiagnostic(`Required parameter "${input.name}" in tool "${tool.name}" is underspecified. LLM may pass invalid or ambiguous values.`, tool.name, input.name, `Add constraints to "${input.name}": provide a description, enum values, regex pattern, or example.`));
-                    }
-                    else {
-                        // Optional parameter without constraints - flag as warning since it's less critical
-                        diagnostics.push(this.createDiagnostic(`Optional parameter "${input.name}" in tool "${tool.name}" is underspecified. LLM may pass invalid or ambiguous values.`, tool.name, input.name, `Add constraints to "${input.name}": provide a description, enum values, regex pattern, or example.`, undefined, 'warning'));
-                    }
-                }
-            }
-        }
-        return diagnostics;
-    }
-}
-export const E002UnderspecifiedRequiredInput = new E002UnderspecifiedRequiredInputRule();
-//# sourceMappingURL=e002-underspecified-input.js.map

package/dist/runtime/analysis/rules/errors/e003-type-mismatch.d.ts

@@ -1,23 +0,0 @@
-/**
- * E003: Unsafe Tool Chaining (Type Mismatch)
- *
- * Condition:
- * - Tool A output flows into Tool B input AND
- * - Output type incompatible with input type
- *
- * Why:
- * - Tool chains silently break
- * - Bugs appear "random"
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class E003TypeMismatchRule extends BaseRule {
-    readonly id: "E003";
-    readonly severity: "error";
-    readonly ruleName = "Unsafe Tool Chaining (Type Mismatch)";
-    readonly description = "Output type incompatible with downstream input type. Tool chains will break.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const E003TypeMismatch: E003TypeMismatchRule;
-export {};
-//# sourceMappingURL=e003-type-mismatch.d.ts.map

package/dist/runtime/analysis/rules/errors/e003-type-mismatch.js

@@ -1,73 +0,0 @@
-/**
- * E003: Unsafe Tool Chaining (Type Mismatch)
- *
- * Condition:
- * - Tool A output flows into Tool B input AND
- * - Output type incompatible with input type
- *
- * Why:
- * - Tool chains silently break
- * - Bugs appear "random"
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-/**
- * Check if two types are incompatible.
- */
-function areTypesIncompatible(outputType, inputType) {
-    // Exact match is always compatible
-    if (outputType === inputType) {
-        return false;
-    }
-    // String can accept almost anything (it's broad)
-    if (inputType === 'string') {
-        return false;
-    }
-    // Incompatible type pairs
-    const incompatiblePairs = [
-        ['string', 'number'],
-        ['string', 'boolean'],
-        ['string', 'integer'],
-        ['number', 'boolean'],
-        ['boolean', 'number'],
-        ['array', 'object'],
-        ['object', 'array'],
-    ];
-    for (const [from, to] of incompatiblePairs) {
-        if (outputType === from && inputType === to) {
-            return true;
-        }
-    }
-    return false;
-}
-class E003TypeMismatchRule extends BaseRule {
-    id = ERROR_CODES.E003;
-    severity = 'error';
-    ruleName = 'Unsafe Tool Chaining (Type Mismatch)';
-    description = 'Output type incompatible with downstream input type. Tool chains will break.';
-    check(ctx) {
-        const diagnostics = [];
-        // Only check high-confidence dependencies (>= 0.8)
-        const highConfidenceDeps = ctx.dependencies.filter(d => d.confidence >= 0.8);
-        for (const dep of highConfidenceDeps) {
-            // Find the output and input fields
-            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 type compatibility
-            if (areTypesIncompatible(fromField.type, toField.type)) {
-                diagnostics.push(this.createDiagnostic(`Tool "${dep.toTool}" parameter "${dep.toField}" depends on output from "${dep.fromTool}", but types are incompatible (${fromField.type} → ${toField.type}).`, dep.toTool, dep.toField, `Ensure "${dep.fromTool}" outputs ${toField.type}, or modify "${dep.toTool}" to accept ${fromField.type}.`));
-            }
-        }
-        return diagnostics;
-    }
-}
-export const E003TypeMismatch = new E003TypeMismatchRule();
-//# sourceMappingURL=e003-type-mismatch.js.map

package/dist/runtime/analysis/rules/errors/e004-free-text-propagation.d.ts

@@ -1,23 +0,0 @@
-/**
- * E004: Unsafe Tool Chaining (Free Text Propagation)
- *
- * Condition:
- * - Output is unconstrained string
- * - Used as input to another tool
- *
- * Why:
- * - LLM passes sentences instead of data
- * - Most common real-world failure
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class E004FreeTextPropagationRule extends BaseRule {
-    readonly id: "E004";
-    readonly severity: "error";
-    readonly ruleName = "Unsafe Tool Chaining (Free Text Propagation)";
-    readonly description = "Free-text output is used by another tool. This is unsafe without constraints.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const E004FreeTextPropagation: E004FreeTextPropagationRule;
-export {};
-//# sourceMappingURL=e004-free-text-propagation.d.ts.map

package/dist/runtime/analysis/rules/errors/e004-free-text-propagation.js

@@ -1,47 +0,0 @@
-/**
- * E004: Unsafe Tool Chaining (Free Text Propagation)
- *
- * Condition:
- * - Output is unconstrained string
- * - Used as input to another tool
- *
- * Why:
- * - LLM passes sentences instead of data
- * - Most common real-world failure
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E004FreeTextPropagationRule extends BaseRule {
-    id = ERROR_CODES.E004;
-    severity = 'error';
-    ruleName = 'Unsafe Tool Chaining (Free Text Propagation)';
-    description = 'Free-text output is used by another tool. This is unsafe without constraints.';
-    check(ctx) {
-        const diagnostics = [];
-        // Only check high-confidence dependencies (>= 0.8)
-        const highConfidenceDeps = ctx.dependencies.filter(d => d.confidence >= 0.8);
-        for (const dep of highConfidenceDeps) {
-            // Find the output field
-            const fromTool = ctx.indexes.toolIndex.get(dep.fromTool.toLowerCase());
-            if (!fromTool) {
-                continue;
-            }
-            const fromField = fromTool.outputs.find(f => f.name === dep.fromField);
-            if (!fromField) {
-                continue;
-            }
-            // Check if output is unconstrained string
-            const isString = fromField.type === 'string';
-            const hasEnum = Boolean(fromField.enum && fromField.enum.length > 0);
-            const hasPattern = Boolean(fromField.pattern);
-            const hasDescription = Boolean(fromField.description && fromField.description.trim());
-            // If it's a string with no constraints, it's free text
-            if (isString && !hasEnum && !hasPattern && !hasDescription) {
-                diagnostics.push(this.createDiagnostic(`Free-text output from "${dep.fromTool}" (field: "${dep.fromField}") is used by "${dep.toTool}". This is unsafe without constraints.`, dep.toTool, dep.toField, `Constrain the output of "${dep.fromTool}" by adding enum values, regex pattern, or clear description of expected format.`));
-            }
-        }
-        return diagnostics;
-    }
-}
-export const E004FreeTextPropagation = new E004FreeTextPropagationRule();
-//# sourceMappingURL=e004-free-text-propagation.js.map

package/dist/runtime/analysis/rules/errors/e005-tool-ambiguity.d.ts

@@ -1,25 +0,0 @@
-/**
- * E005: Hard Tool Ambiguity
- *
- * Condition:
- * - Two or more tools:
- *   - Overlapping descriptions
- *   - Overlapping schemas
- *   - No clear differentiator
- *
- * Why:
- * - Tool selection becomes nondeterministic
- * - Agent behavior changes across runs/models
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class E005ToolAmbiguityRule extends BaseRule {
-    readonly id: "E005";
-    readonly severity: "error";
-    readonly ruleName = "Hard Tool Ambiguity";
-    readonly description = "Multiple tools match the same intent. LLM tool selection is ambiguous.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const E005ToolAmbiguity: E005ToolAmbiguityRule;
-export {};
-//# sourceMappingURL=e005-tool-ambiguity.d.ts.map

package/dist/runtime/analysis/rules/errors/e005-tool-ambiguity.js

@@ -1,73 +0,0 @@
-/**
- * E005: Hard Tool Ambiguity
- *
- * Condition:
- * - Two or more tools:
- *   - Overlapping descriptions
- *   - Overlapping schemas
- *   - No clear differentiator
- *
- * Why:
- * - Tool selection becomes nondeterministic
- * - Agent behavior changes across runs/models
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-/**
- * Calculate similarity between two sets of tokens.
- */
-function tokenSimilarity(tokens1, tokens2) {
-    if (tokens1.size === 0 || tokens2.size === 0) {
-        return 0.0;
-    }
-    const intersection = new Set([...tokens1].filter(t => tokens2.has(t)));
-    const union = new Set([...tokens1, ...tokens2]);
-    return intersection.size / union.size;
-}
-/**
- * Calculate schema overlap between two tools.
- */
-function schemaOverlap(inputs1, inputs2) {
-    const names1 = new Set(inputs1.map(i => i.name.toLowerCase()));
-    const names2 = new Set(inputs2.map(i => i.name.toLowerCase()));
-    const nameOverlapSet = new Set([...names1].filter(n => names2.has(n)));
-    const nameOverlap = nameOverlapSet.size;
-    const totalNames = new Set([...names1, ...names2]).size;
-    if (totalNames === 0) {
-        return 0.0;
-    }
-    return nameOverlap / totalNames;
-}
-class E005ToolAmbiguityRule extends BaseRule {
-    id = ERROR_CODES.E005;
-    severity = 'error';
-    ruleName = 'Hard Tool Ambiguity';
-    description = 'Multiple tools match the same intent. LLM tool selection is ambiguous.';
-    check(ctx) {
-        const diagnostics = [];
-        for (let i = 0; i < ctx.tools.length; i++) {
-            const tool1 = ctx.tools[i];
-            if (!tool1)
-                continue;
-            for (let j = i + 1; j < ctx.tools.length; j++) {
-                const tool2 = ctx.tools[j];
-                if (!tool2)
-                    continue;
-                // Calculate description similarity
-                const descSimilarity = tokenSimilarity(tool1.descriptionTokens, tool2.descriptionTokens);
-                // Calculate schema overlap
-                const inputOverlap = schemaOverlap(tool1.inputs, tool2.inputs);
-                const outputOverlap = schemaOverlap(tool1.outputs, tool2.outputs);
-                const schemaOverlapScore = (inputOverlap + outputOverlap) / 2;
-                // If both description and schema are very similar, it's ambiguous
-                // Threshold: >0.7 description similarity AND >0.5 schema overlap
-                if (descSimilarity > 0.7 && schemaOverlapScore > 0.5) {
-                    diagnostics.push(this.createDiagnostic(`Multiple tools match the same intent: "${tool1.name}", "${tool2.name}". LLM tool selection is ambiguous.`, undefined, undefined, `Differentiate "${tool1.name}" and "${tool2.name}" by making their descriptions and schemas more distinct.`));
-                }
-            }
-        }
-        return diagnostics;
-    }
-}
-export const E005ToolAmbiguity = new E005ToolAmbiguityRule();
-//# sourceMappingURL=e005-tool-ambiguity.js.map

package/dist/runtime/analysis/rules/errors/e006-param-not-in-description.d.ts

@@ -1,22 +0,0 @@
-/**
- * E006: Required Input Not Mentioned in Description
- *
- * Condition:
- * - Required input exists
- * - Tool description does not reference it directly or indirectly
- *
- * Why:
- * - LLM does not know parameter exists or matters
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class E006ParamNotInDescriptionRule extends BaseRule {
-    readonly id: "E006";
-    readonly severity: "error";
-    readonly ruleName = "Required Input Not Mentioned in Description";
-    readonly description = "Required parameter is not referenced in tool description. LLM may not know parameter exists.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const E006ParamNotInDescription: E006ParamNotInDescriptionRule;
-export {};
-//# sourceMappingURL=e006-param-not-in-description.d.ts.map

package/dist/runtime/analysis/rules/errors/e006-param-not-in-description.js

@@ -1,57 +0,0 @@
-/**
- * E006: Required Input Not Mentioned in Description
- *
- * Condition:
- * - Required input exists
- * - Tool description does not reference it directly or indirectly
- *
- * Why:
- * - LLM does not know parameter exists or matters
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-/**
- * Check if a parameter name appears in the description (case-insensitive).
- */
-function isParameterMentioned(description, paramName) {
-    const descLower = description.toLowerCase();
-    const paramLower = paramName.toLowerCase();
-    // Exact match
-    if (descLower.includes(paramLower)) {
-        return true;
-    }
-    // Check if words from param name appear in description
-    const paramWords = paramLower.split(/\W+/).filter(w => w.length > 2);
-    const descWords = descLower.split(/\W+/);
-    for (const word of paramWords) {
-        if (descWords.includes(word)) {
-            return true;
-        }
-    }
-    return false;
-}
-class E006ParamNotInDescriptionRule extends BaseRule {
-    id = ERROR_CODES.E006;
-    severity = 'error';
-    ruleName = 'Required Input Not Mentioned in Description';
-    description = 'Required parameter is not referenced in tool description. LLM may not know parameter exists.';
-    check(ctx) {
-        const diagnostics = [];
-        for (const tool of ctx.tools) {
-            const description = tool.description || '';
-            for (const input of tool.inputs) {
-                // Only check required inputs
-                if (!input.required) {
-                    continue;
-                }
-                // Check if parameter is mentioned in description
-                if (!isParameterMentioned(description, input.name)) {
-                    diagnostics.push(this.createDiagnostic(`Required parameter "${input.name}" is not referenced in "${tool.name}" description.`, tool.name, input.name, `Mention "${input.name}" in the tool description so the LLM knows it exists and is required.`));
-                }
-            }
-        }
-        return diagnostics;
-    }
-}
-export const E006ParamNotInDescription = new E006ParamNotInDescriptionRule();
-//# sourceMappingURL=e006-param-not-in-description.js.map

package/dist/runtime/analysis/rules/errors/e007-output-not-guaranteed.d.ts

@@ -1,23 +0,0 @@
-/**
- * E007: Output Used Downstream but Not Guaranteed
- *
- * Condition:
- * - Tool output is optional / nullable
- * - Used downstream without fallback
- *
- * Why:
- * - Silent null propagation
- * - Hard-to-debug failures
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class E007OutputNotGuaranteedRule extends BaseRule {
-    readonly id: "E007";
-    readonly severity: "error";
-    readonly ruleName = "Output Used Downstream but Not Guaranteed";
-    readonly description = "Output of tool is not guaranteed, but is used by downstream tools without fallback.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const E007OutputNotGuaranteed: E007OutputNotGuaranteedRule;
-export {};
-//# sourceMappingURL=e007-output-not-guaranteed.d.ts.map

package/dist/runtime/analysis/rules/errors/e007-output-not-guaranteed.js

@@ -1,56 +0,0 @@
-/**
- * E007: Output Used Downstream but Not Guaranteed
- *
- * Condition:
- * - Tool output is optional / nullable
- * - Used downstream without fallback
- *
- * Why:
- * - Silent null propagation
- * - Hard-to-debug failures
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E007OutputNotGuaranteedRule extends BaseRule {
-    id = ERROR_CODES.E007;
-    severity = 'error';
-    ruleName = 'Output Used Downstream but Not Guaranteed';
-    description = 'Output of tool is not guaranteed, but is used by downstream tools without fallback.';
-    check(ctx) {
-        const diagnostics = [];
-        // Only check high-confidence dependencies (>= 0.8)
-        const highConfidenceDeps = ctx.dependencies.filter(d => d.confidence >= 0.8);
-        for (const dep of highConfidenceDeps) {
-            // Find the output field
-            const fromTool = ctx.indexes.toolIndex.get(dep.fromTool.toLowerCase());
-            if (!fromTool) {
-                continue;
-            }
-            const fromField = fromTool.outputs.find(f => f.name === dep.fromField);
-            if (!fromField) {
-                continue;
-            }
-            // Find the downstream input field
-            const toTool = ctx.indexes.toolIndex.get(dep.toTool.toLowerCase());
-            if (!toTool) {
-                continue;
-            }
-            const toField = toTool.inputs.find(f => f.name === dep.toField);
-            if (!toField) {
-                continue;
-            }
-            // Check if output is not guaranteed and downstream requires it without fallback
-            // Optional upstream always triggers when downstream requires it
-            // Nullable upstream only triggers when downstream is required AND not nullable (can't handle null)
-            if ((!fromField.required && toField.required === true) ||
-                (fromField.nullable === true &&
-                    toField.required === true &&
-                    toField.nullable !== true)) {
-                diagnostics.push(this.createDiagnostic(`Output of "${dep.fromTool}" (field: "${dep.fromField}") is nullable but is used by "${dep.toTool}" without fallback.`, dep.fromTool, dep.fromField, `Make the output of "${dep.fromTool}" non-nullable, or ensure "${dep.toTool}" handles null values.`));
-            }
-        }
-        return diagnostics;
-    }
-}
-export const E007OutputNotGuaranteed = new E007OutputNotGuaranteedRule();
-//# sourceMappingURL=e007-output-not-guaranteed.js.map