@syrin/cli 1.3.0

package/dist/presentation/test-ui.js

@@ -0,0 +1,358 @@
+/**
+ * Test Results UI for MCP Connection Testing and Tool Validation.
+ * Provides a minimalistic, easy-to-read display of connection test results
+ * and tool validation results.
+ */
+import { getVersionDisplayString } from '../utils/version-display.js';
+import { log } from '../utils/logger.js';
+/**
+ * Get human-readable explanation for capability properties.
+ */
+function explainCapabilityProperty(capabilityName, propertyName) {
+    const explanations = {
+        tools: {
+            listChanged: 'Server sends notifications when the list of available tools changes',
+        },
+        prompts: {
+            listChanged: 'Server sends notifications when the list of available prompts changes',
+        },
+        resources: {
+            listChanged: 'Server sends notifications when the list of available resources changes',
+            subscribe: 'Server supports subscribing to resource updates',
+        },
+        tasks: {
+            list: 'Server supports listing tasks',
+            cancel: 'Server supports cancelling tasks',
+            'requests.tools.call': 'Server supports task-augmented tool calls (long-running operations)',
+        },
+        completions: {
+            '*': 'Server supports LLM completion requests',
+        },
+        logging: {
+            '*': 'Server supports logging messages',
+        },
+        experimental: {
+            '*': 'Server supports experimental features',
+        },
+    };
+    return (explanations[capabilityName]?.[propertyName] ||
+        explanations[capabilityName]?.['*'] ||
+        '');
+}
+/**
+ * Display test results using plain console output.
+ * This avoids Ink taking control of stdin, which disables terminal history.
+ */
+export async function displayTestResults(options) {
+    const { result, transport } = options;
+    // Get version info for display
+    const versionDisplayString = await getVersionDisplayString();
+    const details = result.details;
+    const success = result.success;
+    // Version display
+    log.blank();
+    log.label(`Syrin ${versionDisplayString}`);
+    log.blank();
+    // Header
+    if (success) {
+        log.checkmark('Connection successful');
+    }
+    else {
+        log.xmark('Connection failed');
+    }
+    // Error message if failed
+    if (result.error) {
+        log.error(`  Error: ${result.error}`);
+    }
+    // Connection details
+    if (details) {
+        log.blank();
+        log.heading('  Connection Details:');
+        if (transport === 'http' && details.mcpUrl) {
+            const status = success ? ` ${log.tick()}` : '';
+            log.labelValue('    MCP URL:', `${details.mcpUrl}${status}`);
+        }
+        else if (transport === 'stdio' && details.command) {
+            const status = success ? ` ${log.tick()}` : '';
+            log.labelValue('    Command:', `${details.command}${status}`);
+        }
+        if (details.protocolVersion) {
+            log.labelValue('    Protocol Version:', details.protocolVersion);
+        }
+        if (details.sessionId) {
+            log.labelValue('    Session ID:', details.sessionId);
+        }
+    }
+    // Initialize Handshake details (only for HTTP transport and successful connections)
+    if (details?.initializeRequest && success && transport === 'http') {
+        log.blank();
+        log.heading('  Initialize Handshake:');
+        log.label('    Note: MCP uses Server-Sent Events (SSE) transport. Messages are sent via HTTP POST');
+        log.label('    and responses are received via HTTP GET with text/event-stream.');
+        log.blank();
+        // Request details
+        log.plain(`    ${log.styleText('Request:', 'bold')}`);
+        if (details.initializeRequest.method) {
+            log.labelValue('      HTTP Method:', details.initializeRequest.method);
+        }
+        if (details.initializeRequest.url) {
+            log.labelValue('      URL:', details.initializeRequest.url);
+        }
+        if (details.initializeRequest.headers &&
+            Object.keys(details.initializeRequest.headers).length > 0) {
+            log.label('      Headers:');
+            for (const [key, val] of Object.entries(details.initializeRequest.headers)) {
+                log.labelValue(`        ${key}:`, String(val));
+            }
+        }
+        if (details.initializeRequest.body) {
+            const body = details.initializeRequest.body;
+            if (body.method) {
+                log.labelValue('      JSON-RPC Method:', body.method);
+            }
+            if (body.params?.protocolVersion) {
+                log.labelValue('      Protocol Version:', body.params.protocolVersion);
+            }
+            if (body.params?.clientInfo) {
+                log.labelValue('      Client Info:', `${body.params.clientInfo.name || ''} v${body.params.clientInfo.version || ''}`);
+            }
+        }
+        // Response details
+        if (details.initializeResponse) {
+            log.blank();
+            log.plain(`    ${log.styleText('Response:', 'bold')}`);
+            if (details.initializeResponse.statusCode) {
+                log.labelValue('      Status:', String(details.initializeResponse.statusCode));
+            }
+            if (details.initializeResponse.headers &&
+                Object.keys(details.initializeResponse.headers).length > 0) {
+                log.label('      Response Headers:');
+                for (const [key, val] of Object.entries(details.initializeResponse.headers)) {
+                    log.labelValue(`        ${key}:`, String(val));
+                }
+            }
+            log.label('      Note: Server capabilities are returned in the initialize response');
+        }
+    }
+    // Capabilities
+    const getValidCapabilityKeys = (caps) => {
+        if (!caps)
+            return [];
+        return Object.keys(caps).filter(key => {
+            const val = caps[key];
+            return val !== undefined && val !== null && val !== false;
+        });
+    };
+    const validCapabilityKeys = getValidCapabilityKeys(details?.capabilities);
+    if (details?.capabilities && validCapabilityKeys.length > 0) {
+        const capabilityCount = validCapabilityKeys.length;
+        log.blank();
+        log.heading(`  Server Capabilities (${capabilityCount}):`);
+        log.label('    Note: Capabilities are obtained from the initialize response');
+        const capabilities = details.capabilities;
+        const capabilityNames = validCapabilityKeys;
+        for (const capabilityName of capabilityNames) {
+            const capability = capabilities[capabilityName];
+            if (capability &&
+                typeof capability === 'object' &&
+                !Array.isArray(capability)) {
+                const capabilityObj = capability;
+                const props = Object.keys(capabilityObj).filter(prop => capabilityObj[prop] !== undefined &&
+                    capabilityObj[prop] !== null &&
+                    capabilityObj[prop] !== false);
+                if (props.length > 0) {
+                    log.plain(`  ${log.styleText(capabilityName + ':', 'bold', 'cyan')}`);
+                    for (const prop of props) {
+                        const explanation = explainCapabilityProperty(capabilityName, prop);
+                        if (explanation) {
+                            log.plain(`    ${log.styleText('•', 'dim')} ${log.styleText(prop, 'cyan')} ${log.styleText(`- ${explanation}`, 'dim')}`);
+                        }
+                        else {
+                            log.plain(`    ${log.styleText('•', 'dim')} ${log.styleText(prop, 'cyan')}`);
+                        }
+                    }
+                }
+                else {
+                    log.plain(`  ${log.styleText('•', 'dim')} ${log.styleText(capabilityName, 'cyan')}`);
+                }
+            }
+            else {
+                const explanation = explainCapabilityProperty(capabilityName, '*');
+                if (explanation) {
+                    log.plain(`  ${log.styleText('•', 'dim')} ${log.styleText(capabilityName, 'cyan')} ${log.styleText(`- ${explanation}`, 'dim')}`);
+                }
+                else {
+                    log.plain(`  ${log.styleText('•', 'dim')} ${log.styleText(capabilityName, 'cyan')}`);
+                }
+            }
+        }
+    }
+    log.blank();
+}
+/**
+ * Format test results for CI output (minimal).
+ */
+export function formatCIResults(result) {
+    const errors = result.diagnostics.filter(d => d.severity === 'error');
+    const warnings = result.diagnostics.filter(d => d.severity === 'warning');
+    // CI mode: minimal output, exit codes handled by caller
+    if (result.verdict === 'fail') {
+        console.log(`✗ Test failed: ${result.toolsFailed} tool(s) failed, ${errors.length} error(s), ${warnings.length} warning(s)`);
+        // Print errors only (no warnings in CI)
+        for (const error of errors) {
+            console.log(`${error.code}: ${error.message}`);
+        }
+    }
+    else {
+        console.log(`✓ Test passed: ${result.toolsTested} tool(s) tested, ${result.toolsPassed} passed`);
+        if (warnings.length > 0) {
+            console.log(`  ${warnings.length} warning(s) (non-blocking)`);
+        }
+    }
+}
+/**
+ * Format test results for CLI output.
+ */
+export function formatCLIResults(result) {
+    log.blank();
+    log.heading('Tool Validation Results');
+    log.blank();
+    // Overall verdict
+    if (result.verdict === 'pass') {
+        log.checkmark('All tools passed validation');
+    }
+    else if (result.verdict === 'pass-with-warnings') {
+        log.warn('Tools passed with warnings');
+    }
+    else {
+        log.xmark('Tool validation failed');
+    }
+    log.blank();
+    // Summary
+    log.heading('Summary:');
+    log.labelValue('  Tools tested:', String(result.toolsTested));
+    log.labelValue('  Tools passed:', String(result.toolsPassed));
+    log.labelValue('  Tools failed:', String(result.toolsFailed));
+    const errors = result.diagnostics.filter(d => d.severity === 'error');
+    const warnings = result.diagnostics.filter(d => d.severity === 'warning');
+    if (errors.length > 0) {
+        log.labelValue('  Errors:', String(errors.length));
+    }
+    if (warnings.length > 0) {
+        log.labelValue('  Warnings:', String(warnings.length));
+    }
+    log.blank();
+    // Tool results
+    if (result.toolResults.length > 0) {
+        log.heading('Tool Results:');
+        for (const toolResult of result.toolResults) {
+            log.blank();
+            const status = toolResult.passed ? log.tick() : log.cross();
+            log.plain(`  ${status} ${log.styleText(toolResult.toolName, 'bold')}`);
+            // Summary
+            log.labelValue('    Executions:', `${toolResult.summary.successfulExecutions}/${toolResult.summary.totalExecutions} successful`);
+            if (toolResult.summary.testsPassed !== undefined &&
+                toolResult.summary.testsFailed !== undefined) {
+                const totalTests = toolResult.summary.testsPassed + toolResult.summary.testsFailed;
+                log.labelValue('    Tests:', `${toolResult.summary.testsPassed}/${totalTests} passed (expectations matched)`);
+            }
+            if (toolResult.summary.failedExecutions > 0) {
+                log.labelValue('    Failed:', String(toolResult.summary.failedExecutions));
+            }
+            if (toolResult.summary.timedOutExecutions > 0) {
+                log.labelValue('    Timed out:', String(toolResult.summary.timedOutExecutions));
+            }
+            // Diagnostics
+            if (toolResult.diagnostics.length > 0) {
+                const toolErrors = toolResult.diagnostics.filter(d => d.severity === 'error');
+                const toolWarnings = toolResult.diagnostics.filter(d => d.severity === 'warning');
+                if (toolErrors.length > 0) {
+                    log.plain('    Errors:');
+                    for (const error of toolErrors) {
+                        log.error(`      ${error.code}: ${error.message}`);
+                        // Show test context if available
+                        const context = error.context;
+                        if (context?.testName) {
+                            log.plain(`        Test: ${context.testName}`);
+                        }
+                        if (context?.testInput &&
+                            Object.keys(context.testInput).length > 0) {
+                            const inputStr = JSON.stringify(context.testInput, null, 2)
+                                .split('\n')
+                                .map((line, idx) => (idx === 0 ? line : `        ${line}`))
+                                .join('\n');
+                            log.plain(`        Input: ${inputStr}`);
+                        }
+                        if (context?.expectedOutputSchema) {
+                            log.plain(`        Expected output schema: ${context.expectedOutputSchema}`);
+                        }
+                        // Show parsed error details if available
+                        if (context?.parsedError) {
+                            const parsed = context.parsedError;
+                            if (parsed.field) {
+                                if (parsed.errorType === 'missing_argument') {
+                                    log.plain(`        Field "${parsed.field}" is required but was not provided`);
+                                }
+                                else if (parsed.inputType) {
+                                    log.plain(`        Field "${parsed.field}" received ${parsed.inputType}${parsed.inputValue && parsed.inputValue !== '{}' ? ` (${parsed.inputValue})` : ''}`);
+                                }
+                            }
+                        }
+                        if (error.suggestion) {
+                            log.plain(`        Suggestion: ${error.suggestion}`);
+                        }
+                        log.blank();
+                    }
+                }
+                if (toolWarnings.length > 0) {
+                    log.plain('    Warnings:');
+                    for (const warning of toolWarnings) {
+                        log.warn(`      ${warning.code}: ${warning.message}`);
+                        if (warning.suggestion) {
+                            log.plain(`        Suggestion: ${warning.suggestion}`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    log.blank();
+}
+/**
+ * Format test results as JSON.
+ */
+export function formatJSONResults(result) {
+    const json = {
+        verdict: result.verdict,
+        summary: {
+            toolsTested: result.toolsTested,
+            toolsPassed: result.toolsPassed,
+            toolsFailed: result.toolsFailed,
+            errors: result.diagnostics.filter(d => d.severity === 'error').length,
+            warnings: result.diagnostics.filter(d => d.severity === 'warning').length,
+        },
+        diagnostics: result.diagnostics.map(d => ({
+            code: d.code,
+            severity: d.severity,
+            message: d.message,
+            tool: d.tool,
+            field: d.field,
+            suggestion: d.suggestion,
+            context: d.context,
+        })),
+        tools: result.toolResults.map(tr => ({
+            toolName: tr.toolName,
+            passed: tr.passed,
+            summary: tr.summary,
+            diagnostics: tr.diagnostics.map(d => ({
+                code: d.code,
+                severity: d.severity,
+                message: d.message,
+                suggestion: d.suggestion,
+                context: d.context,
+            })),
+        })),
+    };
+    return JSON.stringify(json, null, 2);
+}
+//# sourceMappingURL=test-ui.js.map

package/dist/runtime/analysis/analyser.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Analysis orchestrator.
+ * Main entry point for static analysis of MCP tools.
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { AnalysisResult } from './types.js';
+/**
+ * Perform static analysis on MCP tools.
+ *
+ * @param client - Connected MCP client
+ * @returns Analysis result
+ */
+export declare function analyseTools(client: Client): Promise<AnalysisResult>;
+//# sourceMappingURL=analyser.d.ts.map

package/dist/runtime/analysis/analyser.js

@@ -0,0 +1,88 @@
+/**
+ * Analysis orchestrator.
+ * Main entry point for static analysis of MCP tools.
+ */
+import { loadMCPTools } from './loader.js';
+import { normalizeTools } from './normalizer.js';
+import { buildIndexes } from './indexer.js';
+import { inferDependencies } from './dependencies.js';
+import { ALL_RULES } from './rules/index.js';
+import { logger } from '../../utils/logger.js';
+/**
+ * Analyze MCP tools and return diagnostics.
+ * Executes all registered rules.
+ *
+ * @param tools - Normalized tool specifications
+ * @param dependencies - Inferred dependencies
+ * @param indexes - Built indexes
+ * @returns Array of diagnostics
+ */
+function runRules(tools, dependencies, indexes) {
+    const diagnostics = [];
+    const context = {
+        tools,
+        dependencies,
+        indexes,
+    };
+    // Run all registered rules
+    for (const rule of ALL_RULES) {
+        try {
+            const ruleDiagnostics = rule.check(context);
+            diagnostics.push(...ruleDiagnostics);
+        }
+        catch (error) {
+            // If a rule fails, log error but don't crash the analysis
+            logger.error(`Rule ${rule.id} failed`, error instanceof Error ? error : new Error(String(error)), {
+                ruleId: rule.id,
+                ruleName: rule.ruleName,
+            });
+        }
+    }
+    return diagnostics;
+}
+/**
+ * Compute verdict from diagnostics.
+ */
+function computeVerdict(diagnostics) {
+    const errors = diagnostics.filter(d => d.severity === 'error');
+    const warnings = diagnostics.filter(d => d.severity === 'warning');
+    if (errors.length > 0) {
+        return 'fail';
+    }
+    if (warnings.length > 0) {
+        return 'pass-with-warnings';
+    }
+    return 'pass';
+}
+/**
+ * Perform static analysis on MCP tools.
+ *
+ * @param client - Connected MCP client
+ * @returns Analysis result
+ */
+export async function analyseTools(client) {
+    // Step 1: Load raw tools
+    const rawTools = await loadMCPTools(client);
+    // Step 2: Normalize tools
+    const tools = await normalizeTools(rawTools);
+    // Step 3: Build indexes
+    const indexes = buildIndexes(tools);
+    // Step 4: Infer dependencies
+    const dependencies = inferDependencies(tools);
+    // Step 5: Run rules
+    const diagnostics = runRules(tools, dependencies, indexes);
+    // Step 6: Compute verdict
+    const verdict = computeVerdict(diagnostics);
+    // Separate errors and warnings
+    const errors = diagnostics.filter(d => d.severity === 'error');
+    const warnings = diagnostics.filter(d => d.severity === 'warning');
+    return {
+        verdict,
+        diagnostics,
+        errors,
+        warnings,
+        dependencies,
+        toolCount: tools.length,
+    };
+}
+//# sourceMappingURL=analyser.js.map

package/dist/runtime/analysis/dependencies.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Dependency inference.
+ * Infers tool dependencies using deterministic heuristics.
+ */
+import type { ToolSpec, Dependency } from './types.js';
+/**
+ * Infer dependencies between tools.
+ */
+export declare function inferDependencies(tools: ToolSpec[]): Dependency[];
+//# sourceMappingURL=dependencies.d.ts.map

package/dist/runtime/analysis/dependencies.js

@@ -0,0 +1,140 @@
+/**
+ * Dependency inference.
+ * Infers tool dependencies using deterministic heuristics.
+ */
+/**
+ * Confidence threshold for dependencies.
+ */
+const DEPENDENCY_THRESHOLD = 0.6;
+/**
+ * Calculate name similarity between two strings.
+ * Returns a score between 0.0 and 1.0.
+ */
+function nameSimilarity(name1, name2) {
+    const n1 = name1.toLowerCase().trim();
+    const n2 = name2.toLowerCase().trim();
+    // Exact match
+    if (n1 === n2) {
+        return 1.0;
+    }
+    // Partial match (common substring) - check length first to apply substring rule
+    const longer = n1.length > n2.length ? n1 : n2;
+    const shorter = n1.length > n2.length ? n2 : n1;
+    // Check if shorter is a significant substring of longer (>=3 chars = higher confidence)
+    if (shorter.length >= 3 && longer.includes(shorter)) {
+        return 0.8;
+    }
+    // One contains the other (but shorter is less than 3 chars, so lower confidence)
+    if (n1.includes(n2) || n2.includes(n1)) {
+        return 0.7;
+    }
+    // Word overlap
+    const words1 = new Set(n1.split(/\W+/).filter(w => w.length > 2));
+    const words2 = new Set(n2.split(/\W+/).filter(w => w.length > 2));
+    if (words1.size === 0 || words2.size === 0) {
+        return 0.0;
+    }
+    const intersection = new Set([...words1].filter(w => words2.has(w)));
+    const union = new Set([...words1, ...words2]);
+    if (union.size === 0) {
+        return 0.0;
+    }
+    return intersection.size / union.size;
+}
+/**
+ * Check if two types are compatible.
+ */
+function typeCompatible(fromType, toType) {
+    // Exact match
+    if (fromType === toType) {
+        return 0.3;
+    }
+    // Compatible types
+    const compatiblePairs = [
+        ['string', 'string'],
+        ['number', 'string'],
+        ['integer', 'string'],
+        ['string', 'enum'],
+        ['array', 'string'],
+        ['object', 'string'],
+    ];
+    for (const [from, to] of compatiblePairs) {
+        if (fromType === from && (toType === to || toType === 'string')) {
+            return 0.2;
+        }
+    }
+    // Incompatible
+    if ((fromType === 'string' && toType === 'number') ||
+        (fromType === 'number' && toType === 'boolean')) {
+        return -0.5;
+    }
+    return 0.0;
+}
+/**
+ * Calculate description token overlap.
+ */
+function descriptionOverlap(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]);
+    if (union.size === 0) {
+        return 0.0;
+    }
+    return (intersection.size / union.size) * 0.3;
+}
+/**
+ * Infer dependencies between tools.
+ */
+export function inferDependencies(tools) {
+    const dependencies = [];
+    for (const toTool of tools) {
+        for (const toField of toTool.inputs) {
+            // Check all output fields from all tools
+            for (const fromTool of tools) {
+                if (fromTool.name === toTool.name) {
+                    continue; // Skip same tool
+                }
+                for (const fromField of fromTool.outputs) {
+                    // Calculate confidence score
+                    let confidence = 0.0;
+                    // Name similarity (weight: 0.4)
+                    const nameSim = nameSimilarity(fromField.name, toField.name);
+                    confidence += nameSim * 0.4;
+                    // Type compatibility (weight: 0.3)
+                    const typeCompat = typeCompatible(fromField.type, toField.type);
+                    const weightedType = typeCompat * 0.3;
+                    confidence += weightedType;
+                    // Description token overlap (weight: 0.3)
+                    const descOverlap = descriptionOverlap(fromTool.descriptionTokens, toTool.descriptionTokens);
+                    confidence += descOverlap;
+                    // Bonus for exact field name match + compatible types
+                    // This allows confidence to reach >= 0.8 for high-confidence rules
+                    // Exact name match (1.0) + exact type (0.3) = 0.4 + 0.09 = 0.49
+                    // With description overlap of 0.2, we get 0.49 + 0.2 = 0.69
+                    // Bonus derived from type compatibility brings it to 0.8+
+                    if (nameSim === 1.0 && typeCompat >= 0.2) {
+                        // Bonus scales with type compatibility (not description overlap, which is already counted)
+                        const bonus = Math.min(0.15, typeCompat * 0.1 + 0.05);
+                        confidence += bonus;
+                    }
+                    // Clamp confidence to [0.0, 1.0]
+                    confidence = Math.max(0.0, Math.min(1.0, confidence));
+                    // Only include if above threshold
+                    if (confidence >= DEPENDENCY_THRESHOLD) {
+                        dependencies.push({
+                            fromTool: fromTool.name,
+                            fromField: fromField.name,
+                            toTool: toTool.name,
+                            toField: toField.name,
+                            confidence,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return dependencies;
+}
+//# sourceMappingURL=dependencies.js.map

package/dist/runtime/analysis/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Analysis engine exports.
+ */
+export * from './types.js';
+export * from './loader.js';
+export * from './normalizer.js';
+export * from './indexer.js';
+export * from './dependencies.js';
+export * from './analyser.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/analysis/index.js

@@ -0,0 +1,10 @@
+/**
+ * Analysis engine exports.
+ */
+export * from './types.js';
+export * from './loader.js';
+export * from './normalizer.js';
+export * from './indexer.js';
+export * from './dependencies.js';
+export * from './analyser.js';
+//# sourceMappingURL=index.js.map

package/dist/runtime/analysis/indexer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Index builder.
+ * Builds fast lookup indexes for analysis rules.
+ */
+import type { ToolSpec, Indexes } from './types.js';
+/**
+ * Build indexes from normalized tools.
+ */
+export declare function buildIndexes(tools: ToolSpec[]): Indexes;
+//# sourceMappingURL=indexer.d.ts.map