@syrin/cli 1.3.0

package/dist/runtime/analysis/rules/errors/e101-missing-tool-description.js

@@ -0,0 +1,33 @@
+/**
+ * E101: Missing Tool Description
+ *
+ * Condition:
+ * - Tool has no description OR
+ * - Tool description is empty or only whitespace
+ *
+ * Why:
+ * - LLM cannot understand what the tool does
+ * - Tool selection becomes ambiguous
+ * - Critical for tool discovery and usage
+ */
+import { BaseRule } from '../base.js';
+import { ERROR_CODES } from '../error-codes.js';
+class E101MissingToolDescriptionRule extends BaseRule {
+    id = ERROR_CODES.E101;
+    severity = 'error';
+    ruleName = 'Missing Tool Description';
+    description = 'Tool is missing a description. LLM cannot understand what the tool does.';
+    check(ctx) {
+        const diagnostics = [];
+        for (const tool of ctx.tools) {
+            // Check if description is missing or empty/whitespace only
+            const hasDescription = Boolean(tool.description && tool.description.trim().length > 0);
+            if (!hasDescription) {
+                diagnostics.push(this.createDiagnostic(`Tool "${tool.name}" is missing a description.`, tool.name, undefined, `Add a clear description to "${tool.name}" explaining what it does, what inputs it expects, and what it returns.`));
+            }
+        }
+        return diagnostics;
+    }
+}
+export const E101MissingToolDescription = new E101MissingToolDescriptionRule();
+//# sourceMappingURL=e101-missing-tool-description.js.map

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

@@ -0,0 +1,24 @@
+/**
+ * E102: 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 E102UnderspecifiedRequiredInputRule extends BaseRule {
+    readonly id: "E102";
+    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 E102UnderspecifiedRequiredInput: E102UnderspecifiedRequiredInputRule;
+export {};
+//# sourceMappingURL=e102-underspecified-input.d.ts.map

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

@@ -0,0 +1,52 @@
+/**
+ * E102: 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 E102UnderspecifiedRequiredInputRule extends BaseRule {
+    id = ERROR_CODES.E102;
+    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 E102UnderspecifiedRequiredInput = new E102UnderspecifiedRequiredInputRule();
+//# sourceMappingURL=e102-underspecified-input.js.map

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

@@ -0,0 +1,23 @@
+/**
+ * E103: 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 E103TypeMismatchRule extends BaseRule {
+    readonly id: "E103";
+    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 E103TypeMismatch: E103TypeMismatchRule;
+export {};
+//# sourceMappingURL=e103-type-mismatch.d.ts.map

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

@@ -0,0 +1,72 @@
+/**
+ * E103: 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';
+/**
+ * Type compatibility matrix.
+ * Maps each output type to the list of input types it can be safely converted to.
+ */
+const COMPATIBILITY_MATRIX = {
+    string: ['string'], // Only string outputs to string inputs
+    number: ['number', 'string'],
+    integer: ['integer', 'number', 'string'],
+    boolean: ['boolean', 'string'],
+    array: ['array', 'string'],
+    object: ['object', 'string'],
+};
+/**
+ * Check if two types are incompatible.
+ */
+function areTypesIncompatible(outputType, inputType) {
+    // Exact match is always compatible
+    if (outputType === inputType) {
+        return false;
+    }
+    // Define which types can be safely converted to which inputs
+    const compatibleInputs = COMPATIBILITY_MATRIX[outputType];
+    if (!compatibleInputs) {
+        // Unknown output type - consider incompatible by default
+        return true;
+    }
+    return !compatibleInputs.includes(inputType);
+}
+class E103TypeMismatchRule extends BaseRule {
+    id = ERROR_CODES.E103;
+    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 E103TypeMismatch = new E103TypeMismatchRule();
+//# sourceMappingURL=e103-type-mismatch.js.map

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

@@ -0,0 +1,22 @@
+/**
+ * E104: 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 E104ParamNotInDescriptionRule extends BaseRule {
+    readonly id: "E104";
+    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 E104ParamNotInDescription: E104ParamNotInDescriptionRule;
+export {};
+//# sourceMappingURL=e104-param-not-in-description.d.ts.map

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

@@ -0,0 +1,57 @@
+/**
+ * E104: 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 E104ParamNotInDescriptionRule extends BaseRule {
+    id = ERROR_CODES.E104;
+    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 E104ParamNotInDescription = new E104ParamNotInDescriptionRule();
+//# sourceMappingURL=e104-param-not-in-description.js.map

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

@@ -0,0 +1,23 @@
+/**
+ * E105: 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 E105FreeTextPropagationRule extends BaseRule {
+    readonly id: "E105";
+    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 E105FreeTextPropagation: E105FreeTextPropagationRule;
+export {};
+//# sourceMappingURL=e105-free-text-propagation.d.ts.map

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

@@ -0,0 +1,47 @@
+/**
+ * E105: 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 E105FreeTextPropagationRule extends BaseRule {
+    id = ERROR_CODES.E105;
+    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);
+            // If it's a string with no constraints (enum/pattern), it's free text
+            // Note: hasDescription is NOT a constraint, only documentation
+            if (isString && !hasEnum && !hasPattern) {
+                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 or regex pattern.`));
+            }
+        }
+        return diagnostics;
+    }
+}
+export const E105FreeTextPropagation = new E105FreeTextPropagationRule();
+//# sourceMappingURL=e105-free-text-propagation.js.map

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

@@ -0,0 +1,23 @@
+/**
+ * E106: 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 E106OutputNotGuaranteedRule extends BaseRule {
+    readonly id: "E106";
+    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 E106OutputNotGuaranteed: E106OutputNotGuaranteedRule;
+export {};
+//# sourceMappingURL=e106-output-not-guaranteed.d.ts.map

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

@@ -0,0 +1,58 @@
+/**
+ * E106: 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 E106OutputNotGuaranteedRule extends BaseRule {
+    id = ERROR_CODES.E106;
+    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
+            // (1) Optional upstream always triggers when downstream requires it
+            if (!fromField.required && toField.required === true) {
+                diagnostics.push(this.createDiagnostic(`Output of "${dep.fromTool}" (field: "${dep.fromField}") is optional/may be missing but is required by "${dep.toTool}".`, dep.toTool, dep.toField, `Make the output of "${dep.fromTool}" required, or add fallback/handling in "${dep.toTool}" for when the field is missing.`));
+            }
+            // (2) Nullable upstream only triggers when downstream is required AND not nullable (can't handle null)
+            if (fromField.nullable === true &&
+                toField.required === true &&
+                toField.nullable !== true) {
+                diagnostics.push(this.createDiagnostic(`Output of "${dep.fromTool}" (field: "${dep.fromField}") is nullable but "${dep.toTool}" cannot accept null.`, dep.toTool, dep.toField, `Make the output of "${dep.fromTool}" non-nullable, or ensure "${dep.toTool}" handles null values.`));
+            }
+        }
+        return diagnostics;
+    }
+}
+export const E106OutputNotGuaranteed = new E106OutputNotGuaranteedRule();
+//# sourceMappingURL=e106-output-not-guaranteed.js.map

package/dist/runtime/analysis/rules/errors/e107-circular-dependency.d.ts

@@ -0,0 +1,22 @@
+/**
+ * E107: Circular Tool Dependency
+ *
+ * Condition:
+ * - Tool dependency graph contains a cycle
+ *
+ * Why:
+ * - LLMs cannot reason about cycles
+ * - Execution becomes undefined
+ */
+import { BaseRule } from '../base.js';
+import type { AnalysisContext, Diagnostic } from '../../types.js';
+declare class E107CircularDependencyRule extends BaseRule {
+    readonly id: "E107";
+    readonly severity: "error";
+    readonly ruleName = "Circular Tool Dependency";
+    readonly description = "Circular dependency detected between tools. Execution becomes undefined.";
+    check(ctx: AnalysisContext): Diagnostic[];
+}
+export declare const E107CircularDependency: E107CircularDependencyRule;
+export {};
+//# sourceMappingURL=e107-circular-dependency.d.ts.map

package/dist/runtime/analysis/rules/errors/e107-circular-dependency.js

@@ -0,0 +1,84 @@
+/**
+ * E107: Circular Tool Dependency
+ *
+ * Condition:
+ * - Tool dependency graph contains a cycle
+ *
+ * Why:
+ * - LLMs cannot reason about cycles
+ * - Execution becomes undefined
+ */
+import { BaseRule } from '../base.js';
+import { ERROR_CODES } from '../error-codes.js';
+/**
+ * Detect cycles in the dependency graph using DFS.
+ */
+function detectCycles(dependencies) {
+    // Build adjacency list
+    const graph = new Map();
+    for (const dep of dependencies) {
+        if (!graph.has(dep.fromTool)) {
+            graph.set(dep.fromTool, []);
+        }
+        graph.get(dep.fromTool).push(dep.toTool);
+    }
+    const cycles = [];
+    const visited = new Set();
+    const recStack = new Set();
+    function dfs(tool, path) {
+        visited.add(tool);
+        recStack.add(tool);
+        path.push(tool);
+        const neighbors = graph.get(tool) || [];
+        for (const neighbor of neighbors) {
+            if (!visited.has(neighbor)) {
+                dfs(neighbor, [...path]);
+            }
+            else if (recStack.has(neighbor)) {
+                // Found a cycle
+                const cycleStart = path.indexOf(neighbor);
+                if (cycleStart !== -1) {
+                    cycles.push([...path.slice(cycleStart), neighbor]);
+                }
+            }
+        }
+        recStack.delete(tool);
+    }
+    // Check all tools
+    for (const dep of dependencies) {
+        if (!visited.has(dep.fromTool)) {
+            dfs(dep.fromTool, []);
+        }
+    }
+    return cycles;
+}
+class E107CircularDependencyRule extends BaseRule {
+    id = ERROR_CODES.E107;
+    severity = 'error';
+    ruleName = 'Circular Tool Dependency';
+    description = 'Circular dependency detected between tools. Execution becomes undefined.';
+    check(ctx) {
+        const diagnostics = [];
+        // Only check high-confidence dependencies (>= 0.8) for cycles
+        const highConfidenceDeps = ctx.dependencies.filter(d => d.confidence >= 0.8);
+        if (highConfidenceDeps.length === 0) {
+            return diagnostics;
+        }
+        const cycles = detectCycles(highConfidenceDeps);
+        // Report each cycle
+        const reportedCycles = new Set();
+        for (const cycle of cycles) {
+            // Create a canonical representation of the cycle (sort a copy to avoid mutating original)
+            const cycleKey = [...cycle].sort().join(' → ');
+            if (reportedCycles.has(cycleKey)) {
+                continue;
+            }
+            reportedCycles.add(cycleKey);
+            const cycleStr = cycle.join(' → ');
+            diagnostics.push(this.createDiagnostic(`Circular dependency detected between tools: ${cycleStr}.`, undefined, undefined, `Break the cycle by removing or restructuring dependencies between: ${cycle.join(', ')}.`));
+        }
+        return diagnostics;
+    }
+}
+export const E107CircularDependency = new E107CircularDependencyRule();
+//# sourceMappingURL=e107-circular-dependency.js.map

package/dist/runtime/analysis/rules/errors/e108-implicit-user-input.d.ts

@@ -0,0 +1,23 @@
+/**
+ * E108: Tool Depends on User Input Indirectly
+ *
+ * Condition:
+ * - Tool expects data
+ * - Only source is implicit user memory / conversation
+ * - No explicit tool provides it
+ *
+ * Why:
+ * - Relies on hallucinated context
+ */
+import { BaseRule } from '../base.js';
+import type { AnalysisContext, Diagnostic } from '../../types.js';
+declare class E108ImplicitUserInputRule extends BaseRule {
+    readonly id: "E108";
+    readonly severity: "error";
+    readonly ruleName = "Tool Depends on User Input Indirectly";
+    readonly description = "Tool depends on implicit user context with no explicit source.";
+    check(ctx: AnalysisContext): Diagnostic[];
+}
+export declare const E108ImplicitUserInput: E108ImplicitUserInputRule;
+export {};
+//# sourceMappingURL=e108-implicit-user-input.d.ts.map

package/dist/runtime/analysis/rules/errors/e108-implicit-user-input.js

@@ -0,0 +1,94 @@
+/**
+ * E108: Tool Depends on User Input Indirectly
+ *
+ * Condition:
+ * - Tool expects data
+ * - Only source is implicit user memory / conversation
+ * - No explicit tool provides it
+ *
+ * Why:
+ * - Relies on hallucinated context
+ */
+import { BaseRule } from '../base.js';
+import { ERROR_CODES } from '../error-codes.js';
+/**
+ * Keywords that suggest user-provided input.
+ */
+const USER_DATA_INDICATORS = [
+    'user',
+    'person',
+    'name',
+    'email',
+    'location',
+    'address',
+    'preference',
+];
+class E108ImplicitUserInputRule extends BaseRule {
+    id = ERROR_CODES.E108;
+    severity = 'error';
+    ruleName = 'Tool Depends on User Input Indirectly';
+    description = 'Tool depends on implicit user context with no explicit source.';
+    check(ctx) {
+        const diagnostics = [];
+        for (const tool of ctx.tools) {
+            for (const input of tool.inputs) {
+                if (!input.required) {
+                    continue;
+                }
+                // Check if there's any tool that provides this input
+                // Look for output fields with similar names
+                const fieldName = input.name.toLowerCase();
+                let hasExplicitSource = false;
+                // Token-based matching: split on non-alphanumeric and camelCase boundaries
+                // Compute fieldTokens once per field since it only depends on fieldName
+                const fieldTokens = new Set(fieldName
+                    .split(/[^\w]+|(?<=[a-z])(?=[A-Z])/)
+                    .filter(t => t.length > 0));
+                for (const otherTool of ctx.tools) {
+                    if (otherTool.name === tool.name) {
+                        continue;
+                    }
+                    for (const output of otherTool.outputs) {
+                        const outputName = output.name.toLowerCase();
+                        // Check for exact match or token-based match
+                        if (outputName === fieldName) {
+                            hasExplicitSource = true;
+                            break;
+                        }
+                        // Token-based matching: compute outputTokens per output
+                        const outputTokens = new Set(outputName
+                            .split(/[^\w]+|(?<=[a-z])(?=[A-Z])/)
+                            .filter(t => t.length > 0));
+                        // Check for token intersection
+                        const hasTokenMatch = Array.from(fieldTokens).some(token => outputTokens.has(token) && token.length >= 3) ||
+                            Array.from(outputTokens).some(token => fieldTokens.has(token) && token.length >= 3);
+                        if (hasTokenMatch) {
+                            hasExplicitSource = true;
+                            break;
+                        }
+                    }
+                    if (hasExplicitSource) {
+                        break;
+                    }
+                }
+                // Also check dependencies
+                if (!hasExplicitSource) {
+                    const hasDependency = ctx.dependencies.some(d => d.toTool === tool.name &&
+                        d.toField === input.name &&
+                        d.confidence >= 0.6);
+                    if (hasDependency) {
+                        hasExplicitSource = true;
+                    }
+                }
+                // If no explicit source found and input name suggests user data
+                const looksLikeUserData = USER_DATA_INDICATORS.some(indicator => fieldName.includes(indicator));
+                if (!hasExplicitSource && looksLikeUserData) {
+                    diagnostics.push(this.createDiagnostic(`Tool "${tool.name}" depends on implicit user context (parameter: "${input.name}") with no explicit source.`, tool.name, input.name, `Create an explicit tool to provide "${input.name}", or ensure it's clearly documented as user input.`));
+                }
+            }
+        }
+        return diagnostics;
+    }
+}
+export const E108ImplicitUserInput = new E108ImplicitUserInputRule();
+//# sourceMappingURL=e108-implicit-user-input.js.map