@bryan-thompson/inspector-assessment-client 1.24.2 → 1.25.0

package/lib/services/assessment/modules/DeveloperExperienceAssessor.js

@@ -0,0 +1,586 @@
+/**
+ * Developer Experience Assessor Module
+ *
+ * Unified module for evaluating developer experience aspects of MCP servers.
+ * Merges DocumentationAssessor and UsabilityAssessor functionality.
+ *
+ * Assessment Areas:
+ * 1. Documentation Quality - README completeness, examples, guides
+ * 2. Usability - Tool naming, parameter clarity, best practices
+ *
+ * This module is part of Tier 4 (Extended) and is optional for security-focused audits.
+ *
+ * @module assessment/modules/DeveloperExperienceAssessor
+ */
+import { BaseAssessor } from "./BaseAssessor.js";
+export class DeveloperExperienceAssessor extends BaseAssessor {
+    async assess(context) {
+        this.log("Starting developer experience assessment");
+        // Assess documentation
+        const documentationMetrics = this.analyzeDocumentation(context.readmeContent || "", context.tools, "verbose");
+        const documentationScore = this.calculateDocumentationScore(documentationMetrics);
+        // Assess usability
+        const usabilityMetrics = this.analyzeUsability(context.tools);
+        const usabilityScore = this.calculateUsabilityScore(usabilityMetrics);
+        // Calculate overall score (weighted average)
+        const overallScore = Math.round(documentationScore * 0.6 + usabilityScore * 0.4);
+        // Determine status
+        const status = this.determineOverallStatus(overallScore);
+        // Generate explanation and recommendations
+        const explanation = this.generateExplanation(documentationMetrics, usabilityMetrics, context.tools);
+        const recommendations = this.generateRecommendations(documentationMetrics, usabilityMetrics);
+        this.testCount = 9; // Documentation (5) + Usability (4) checks
+        return {
+            documentation: documentationMetrics,
+            usability: usabilityMetrics,
+            status,
+            explanation,
+            recommendations,
+            scores: {
+                documentation: documentationScore,
+                usability: usabilityScore,
+                overall: overallScore,
+            },
+        };
+    }
+    // ============================================================================
+    // Documentation Analysis (from DocumentationAssessor)
+    // ============================================================================
+    analyzeDocumentation(content, tools, verbosity = "standard") {
+        const hasReadme = content.length > 0;
+        const functionalExamples = this.extractFunctionalExamples(content);
+        const allCodeExamples = this.extractCodeExamples(content);
+        const hasInstallInstructions = this.checkInstallInstructions(content);
+        const hasUsageGuide = this.checkUsageGuide(content);
+        const hasAPIReference = this.checkAPIReference(content);
+        const missingExamples = [];
+        let documentedToolsCount = 0;
+        const toolDocumentation = [];
+        const ADEQUATE_DESCRIPTION_LENGTH = 50;
+        let toolsWithDescriptions = 0;
+        const toolDocGaps = [];
+        if (tools && tools.length > 0) {
+            for (const tool of tools) {
+                const toolName = tool.name;
+                const description = tool.description?.trim() || "";
+                const descriptionLength = description.length;
+                const hasDescription = descriptionLength > 0;
+                const hasAdequateDescription = descriptionLength >= ADEQUATE_DESCRIPTION_LENGTH;
+                const headingRegex = new RegExp(`^#{1,6}\\s+${toolName}`, "mi");
+                const mentionRegex = new RegExp(`\\b${toolName}\\b`, "i");
+                const hasHeading = headingRegex.test(content);
+                const hasMention = mentionRegex.test(content);
+                const documentedInReadme = hasHeading || hasMention;
+                if (documentedInReadme) {
+                    documentedToolsCount++;
+                }
+                if (!hasDescription && !documentedInReadme) {
+                    missingExamples.push(toolName);
+                }
+                if (hasAdequateDescription) {
+                    toolsWithDescriptions++;
+                }
+                else {
+                    toolDocGaps.push({
+                        toolName,
+                        issue: descriptionLength === 0 ? "missing" : "too_short",
+                        descriptionLength,
+                        documentedInReadme,
+                    });
+                }
+                if (verbosity !== "minimal") {
+                    toolDocumentation.push({
+                        name: toolName,
+                        hasDescription,
+                        descriptionLength,
+                        documentedInReadme,
+                        description: hasDescription ? description.slice(0, 200) : undefined,
+                    });
+                }
+            }
+        }
+        else {
+            if (functionalExamples.length < 1)
+                missingExamples.push("Basic usage example");
+        }
+        const requiredExamples = 3;
+        const functionalExampleCount = functionalExamples.length +
+            (tools && tools.length > 0 ? documentedToolsCount : 0);
+        const sectionHeadings = verbosity !== "minimal" ? this.extractSectionHeadings(content) : [];
+        const baseMetrics = {
+            hasReadme,
+            exampleCount: functionalExampleCount,
+            requiredExamples,
+            missingExamples,
+            hasInstallInstructions,
+            hasUsageGuide,
+            hasAPIReference,
+            extractedExamples: allCodeExamples,
+            installInstructions: hasInstallInstructions
+                ? this.extractSection(content, "install")
+                : undefined,
+            usageInstructions: hasUsageGuide
+                ? this.extractSection(content, "usage")
+                : undefined,
+            toolsWithDescriptions,
+            toolsTotal: tools?.length || 0,
+            toolDocGaps,
+        };
+        if (verbosity !== "minimal") {
+            baseMetrics.readmeLength = content.length;
+            baseMetrics.readmeWordCount = content
+                .split(/\s+/)
+                .filter((w) => w.length > 0).length;
+            baseMetrics.sectionHeadings = sectionHeadings;
+            if (toolDocumentation.length > 0) {
+                baseMetrics.toolDocumentation = toolDocumentation;
+            }
+        }
+        if (verbosity === "verbose" && content.length > 0) {
+            baseMetrics.readmeContent = content.substring(0, 5000);
+        }
+        return baseMetrics;
+    }
+    extractFunctionalExamples(content) {
+        const functionalExamples = [];
+        const standalonePromptRegex = /^[ \t]*([A-Z][^\n]{10,300}?(?:use (?:context7|library|@?[\w-]+\/[\w-]+)|with \S+)[^\n]*?)[ \t]*$/gim;
+        let standaloneMatch;
+        while ((standaloneMatch = standalonePromptRegex.exec(content)) !== null) {
+            const prompt = standaloneMatch[1].trim();
+            if (!this.isNonFunctionalCodeBlock(prompt) &&
+                this.scoreFunctionalExample(prompt)) {
+                functionalExamples.push({
+                    code: prompt,
+                    language: "prompt",
+                    description: "Functional example prompt",
+                    lineNumber: this.getLineNumber(content, standaloneMatch.index),
+                });
+            }
+        }
+        const bulletedExampleRegex = /^[ \t]*[-*][ \t]+([A-Z][^\n]{10,300}?)[ \t]*$/gim;
+        let bulletMatch;
+        while ((bulletMatch = bulletedExampleRegex.exec(content)) !== null) {
+            const prompt = bulletMatch[1].trim();
+            if (!this.isNonFunctionalCodeBlock(prompt) &&
+                this.scoreFunctionalExample(prompt)) {
+                functionalExamples.push({
+                    code: prompt,
+                    language: "prompt",
+                    description: "Bulleted example",
+                    lineNumber: this.getLineNumber(content, bulletMatch.index),
+                });
+            }
+        }
+        return this.deduplicateExamples(functionalExamples);
+    }
+    isNonFunctionalCodeBlock(text) {
+        const excludePatterns = [
+            /^\s*{\s*["']mcpServers["']/i,
+            /^\s*{\s*["']command["']/i,
+            /^\s*(npx|npm|yarn|pnpm|docker|git)\s+/i,
+            /^\s*FROM\s+\w+:/i,
+            /^\s*import\s+.*\s+from/i,
+            /^\s*\[.*\]\s*=\s*["']/i,
+            /^\s*<\w+>/i,
+            /^\s*(export|const|let|var|function)\s+/i,
+            /^\s*\/\//i,
+            /^\s*#\s*\w+/i,
+        ];
+        return excludePatterns.some((pattern) => pattern.test(text));
+    }
+    scoreFunctionalExample(text) {
+        let score = 0;
+        if (/\b(create|configure|implement|show|generate|build|write|add|get|set|use|run|start)\b/i.test(text)) {
+            score += 2;
+        }
+        if (/\b(?:use|with)\s+(?:context7|library|@?\w+\/\w+)\b/i.test(text)) {
+            score += 2;
+        }
+        if (/^[A-Z].{10,}/.test(text)) {
+            score += 1;
+        }
+        if (/\b(Next\.js|React|Vue|Angular|PostgreSQL|MySQL|MongoDB|Redis|AWS|Cloudflare|API|HTTP|REST|GraphQL|TypeScript|JavaScript|Python|Docker|Kubernetes|Supabase|Firebase|Auth|JWT|OAuth)\b/i.test(text)) {
+            score += 1;
+        }
+        return score >= 4;
+    }
+    getLineNumber(content, position) {
+        const beforeMatch = content.substring(0, position);
+        return beforeMatch.split("\n").length;
+    }
+    deduplicateExamples(examples) {
+        const seen = new Set();
+        const unique = [];
+        for (const example of examples) {
+            const normalized = example.code
+                .toLowerCase()
+                .replace(/[^\w\s]/g, "")
+                .replace(/\s+/g, " ")
+                .trim();
+            if (!seen.has(normalized)) {
+                seen.add(normalized);
+                unique.push(example);
+            }
+        }
+        return unique;
+    }
+    extractCodeExamples(content) {
+        const examples = [];
+        const codeBlockRegex = /```(\w+)?\n([\s\S]*?)```/g;
+        let match;
+        const lines = content.split("\n");
+        while ((match = codeBlockRegex.exec(content)) !== null) {
+            const language = match[1] || "plaintext";
+            const code = match[2].trim();
+            const position = match.index;
+            const beforeMatch = content.substring(0, position);
+            const lineNumber = beforeMatch.split("\n").length;
+            let description = "";
+            const lineIndex = lines.findIndex((_, i) => lines.slice(0, i + 1).join("\n").length >= position);
+            if (lineIndex > 0) {
+                const prevLine = lines[lineIndex - 1].trim();
+                if (prevLine && !prevLine.startsWith("#")) {
+                    description = prevLine;
+                }
+            }
+            examples.push({
+                code,
+                language,
+                description,
+                lineNumber,
+                lineCount: code.split("\n").length,
+                exampleType: this.classifyCodeExample(code, language),
+            });
+        }
+        return examples;
+    }
+    checkInstallInstructions(content) {
+        const installKeywords = [
+            "install",
+            "npm install",
+            "yarn add",
+            "pip install",
+            "setup",
+            "getting started",
+        ];
+        const contentLower = content.toLowerCase();
+        return installKeywords.some((keyword) => contentLower.includes(keyword));
+    }
+    checkUsageGuide(content) {
+        const usageKeywords = [
+            "usage",
+            "how to use",
+            "example",
+            "quick start",
+            "tutorial",
+        ];
+        const contentLower = content.toLowerCase();
+        return usageKeywords.some((keyword) => contentLower.includes(keyword));
+    }
+    checkAPIReference(content) {
+        const apiKeywords = [
+            "api",
+            "reference",
+            "methods",
+            "functions",
+            "parameters",
+            "returns",
+            "endpoints",
+        ];
+        const contentLower = content.toLowerCase();
+        return apiKeywords.some((keyword) => contentLower.includes(keyword));
+    }
+    extractSection(content, section) {
+        const sectionRegex = new RegExp(`#+\\s*${section}[\\s\\S]*?(?=\\n#|$)`, "gi");
+        const match = content.match(sectionRegex);
+        return match ? match[0].trim() : "";
+    }
+    extractSectionHeadings(content) {
+        const headingRegex = /^(#{1,6})\s+(.+)$/gm;
+        const headings = [];
+        let match;
+        while ((match = headingRegex.exec(content)) !== null) {
+            headings.push(match[2].trim());
+        }
+        return headings;
+    }
+    classifyCodeExample(code, language) {
+        if (/^\s*(npx|npm|yarn|pnpm|pip|docker|git)\s+/i.test(code)) {
+            return "install";
+        }
+        if (/^\s*{\s*["']mcpServers["']/i.test(code) ||
+            /^\s*{\s*["']command["']/i.test(code) ||
+            language === "json" ||
+            language === "toml" ||
+            language === "yaml") {
+            return "config";
+        }
+        if (/^\s*(import|export|const|let|var|function|class)\s+/i.test(code) ||
+            /^\s*from\s+/i.test(code)) {
+            return "implementation";
+        }
+        return "functional";
+    }
+    calculateDocumentationScore(metrics) {
+        let score = 0;
+        const maxScore = 5;
+        if (metrics.hasReadme)
+            score++;
+        if (metrics.hasInstallInstructions)
+            score++;
+        if (metrics.hasUsageGuide)
+            score++;
+        if (metrics.hasAPIReference)
+            score++;
+        if (metrics.exampleCount >= metrics.requiredExamples)
+            score++;
+        return Math.round((score / maxScore) * 100);
+    }
+    // ============================================================================
+    // Usability Analysis (from UsabilityAssessor)
+    // ============================================================================
+    analyzeUsability(tools) {
+        const toolNamingConvention = this.analyzeNamingConvention(tools);
+        const parameterClarity = this.analyzeParameterClarity(tools);
+        const hasHelpfulDescriptions = this.checkDescriptions(tools);
+        const followsBestPractices = this.checkBestPractices(tools);
+        return {
+            toolNamingConvention,
+            parameterClarity,
+            hasHelpfulDescriptions,
+            followsBestPractices,
+        };
+    }
+    analyzeNamingConvention(tools) {
+        if (tools.length === 0)
+            return "consistent";
+        const namingPatterns = {
+            camelCase: 0,
+            snake_case: 0,
+            kebab_case: 0,
+            PascalCase: 0,
+        };
+        for (const tool of tools) {
+            const name = tool.name;
+            if (/^[a-z][a-zA-Z0-9]*$/.test(name)) {
+                namingPatterns.camelCase++;
+            }
+            else if (/^[a-z]+(_[a-z]+)*$/.test(name)) {
+                namingPatterns.snake_case++;
+            }
+            else if (/^[a-z]+(-[a-z]+)*$/.test(name)) {
+                namingPatterns.kebab_case++;
+            }
+            else if (/^[A-Z][a-zA-Z0-9]*$/.test(name)) {
+                namingPatterns.PascalCase++;
+            }
+        }
+        const total = tools.length;
+        const threshold = total * 0.7;
+        for (const count of Object.values(namingPatterns)) {
+            if (count >= threshold) {
+                return "consistent";
+            }
+        }
+        return "inconsistent";
+    }
+    analyzeParameterClarity(tools) {
+        if (tools.length === 0)
+            return "clear";
+        let clearCount = 0;
+        let unclearCount = 0;
+        for (const tool of tools) {
+            const schema = this.getToolSchema(tool);
+            if (!schema?.properties)
+                continue;
+            for (const [paramName, paramDef] of Object.entries(schema.properties)) {
+                if (this.isDescriptiveName(paramName)) {
+                    clearCount++;
+                }
+                else {
+                    unclearCount++;
+                }
+                if (paramDef.description) {
+                    clearCount++;
+                }
+                else {
+                    unclearCount++;
+                }
+            }
+        }
+        const total = clearCount + unclearCount;
+        if (total === 0)
+            return "clear";
+        const clarityRatio = clearCount / total;
+        if (clarityRatio >= 0.8)
+            return "clear";
+        if (clarityRatio <= 0.3)
+            return "unclear";
+        return "mixed";
+    }
+    checkDescriptions(tools) {
+        if (tools.length === 0)
+            return false;
+        let toolsWithDescriptions = 0;
+        for (const tool of tools) {
+            if (tool.description && tool.description.length > 10) {
+                toolsWithDescriptions++;
+            }
+        }
+        return toolsWithDescriptions / tools.length >= 0.7;
+    }
+    checkBestPractices(tools) {
+        const practices = {
+            hasVersioning: false,
+            hasErrorHandling: false,
+            hasValidation: false,
+            hasDocumentation: false,
+        };
+        for (const tool of tools) {
+            const schema = this.getToolSchema(tool);
+            if (schema?.required && schema.required.length > 0) {
+                practices.hasValidation = true;
+            }
+            if (schema?.properties) {
+                for (const prop of Object.values(schema.properties)) {
+                    if (prop.enum ||
+                        prop.minimum !== undefined ||
+                        prop.maximum !== undefined) {
+                        practices.hasValidation = true;
+                    }
+                }
+            }
+            if (tool.description) {
+                practices.hasDocumentation = true;
+            }
+        }
+        const followedPractices = Object.values(practices).filter((v) => v).length;
+        return followedPractices >= 2;
+    }
+    isDescriptiveName(name) {
+        const goodNames = [
+            "query",
+            "search",
+            "input",
+            "output",
+            "data",
+            "content",
+            "message",
+            "text",
+            "file",
+            "path",
+            "url",
+            "name",
+            "id",
+            "value",
+            "result",
+            "response",
+            "request",
+            "params",
+        ];
+        const nameLower = name.toLowerCase();
+        for (const goodName of goodNames) {
+            if (nameLower.includes(goodName)) {
+                return true;
+            }
+        }
+        return name.length > 3 && !/^[a-z]$/.test(name);
+    }
+    getToolSchema(tool) {
+        if (!tool.inputSchema)
+            return null;
+        return typeof tool.inputSchema === "string"
+            ? this.safeJsonParse(tool.inputSchema)
+            : tool.inputSchema;
+    }
+    calculateUsabilityScore(metrics) {
+        let score = 0;
+        const maxScore = 4;
+        if (metrics.toolNamingConvention === "consistent")
+            score++;
+        if (metrics.parameterClarity === "clear")
+            score++;
+        if (metrics.hasHelpfulDescriptions)
+            score++;
+        if (metrics.followsBestPractices)
+            score++;
+        return Math.round((score / maxScore) * 100);
+    }
+    // ============================================================================
+    // Combined Status, Explanation, and Recommendations
+    // ============================================================================
+    determineOverallStatus(overallScore) {
+        if (overallScore >= 80)
+            return "PASS";
+        if (overallScore >= 50)
+            return "NEED_MORE_INFO";
+        return "FAIL";
+    }
+    generateExplanation(docMetrics, usabilityMetrics, tools) {
+        const parts = [];
+        // Documentation summary
+        if (!docMetrics.hasReadme) {
+            parts.push("No README documentation found.");
+        }
+        else {
+            parts.push(`README contains ${docMetrics.exampleCount} code examples.`);
+            const features = [];
+            if (docMetrics.hasInstallInstructions)
+                features.push("installation");
+            if (docMetrics.hasUsageGuide)
+                features.push("usage guide");
+            if (docMetrics.hasAPIReference)
+                features.push("API reference");
+            if (features.length > 0) {
+                parts.push(`Documentation includes: ${features.join(", ")}.`);
+            }
+        }
+        // Usability summary
+        parts.push(`Analyzed ${tools.length} tools for usability.`);
+        parts.push(`Naming convention: ${usabilityMetrics.toolNamingConvention}.`);
+        parts.push(`Parameter clarity: ${usabilityMetrics.parameterClarity}.`);
+        const usabilityFeatures = [];
+        if (usabilityMetrics.hasHelpfulDescriptions)
+            usabilityFeatures.push("helpful descriptions");
+        if (usabilityMetrics.followsBestPractices)
+            usabilityFeatures.push("follows best practices");
+        if (usabilityFeatures.length > 0) {
+            parts.push(`Usability: ${usabilityFeatures.join(", ")}.`);
+        }
+        return parts.join(" ");
+    }
+    generateRecommendations(docMetrics, usabilityMetrics) {
+        const recommendations = [];
+        // Documentation recommendations
+        if (!docMetrics.hasReadme) {
+            recommendations.push("Create a comprehensive README.md file");
+        }
+        if (!docMetrics.hasInstallInstructions) {
+            recommendations.push("Add clear installation instructions");
+        }
+        if (!docMetrics.hasUsageGuide) {
+            recommendations.push("Include a usage guide with examples");
+        }
+        if (!docMetrics.hasAPIReference) {
+            recommendations.push("Document all available tools and parameters");
+        }
+        if (docMetrics.exampleCount < docMetrics.requiredExamples) {
+            recommendations.push(`Add ${docMetrics.requiredExamples - docMetrics.exampleCount} more code examples`);
+        }
+        // Usability recommendations
+        if (usabilityMetrics.toolNamingConvention === "inconsistent") {
+            recommendations.push("Adopt a consistent naming convention for all tools");
+        }
+        if (usabilityMetrics.parameterClarity !== "clear") {
+            recommendations.push("Use descriptive parameter names");
+            recommendations.push("Add descriptions for all parameters");
+        }
+        if (!usabilityMetrics.hasHelpfulDescriptions) {
+            recommendations.push("Provide detailed descriptions for each tool");
+        }
+        if (!usabilityMetrics.followsBestPractices) {
+            recommendations.push("Implement input validation with constraints");
+        }
+        return recommendations;
+    }
+}

package/lib/services/assessment/modules/ProtocolComplianceAssessor.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Protocol Compliance Assessor Module
+ *
+ * Unified module for MCP protocol compliance validation.
+ * Merges MCPSpecComplianceAssessor and ProtocolConformanceAssessor functionality.
+ *
+ * Protocol Checks:
+ * 1. JSON-RPC 2.0 Compliance - Validates request/response structure
+ * 2. Server Info Validity - Validates initialization handshake
+ * 3. Schema Compliance - Validates tool input schemas
+ * 4. Error Response Format - Validates isError flag, content array structure
+ * 5. Content Type Support - Validates valid content types (text, image, audio, resource)
+ * 6. Structured Output Support - Checks for outputSchema usage
+ * 7. Capabilities Compliance - Validates declared vs actual capabilities
+ *
+ * @module assessment/modules/ProtocolComplianceAssessor
+ */
+import { MCPSpecComplianceAssessment, AssessmentConfiguration } from "../../../lib/assessmentTypes.js";
+import type { ProtocolCheck } from "../../../lib/assessment/extendedTypes.js";
+import { BaseAssessor } from "./BaseAssessor.js";
+import { AssessmentContext } from "../AssessmentOrchestrator.js";
+/**
+ * Protocol Compliance Assessment Result
+ * Unified output type for protocol compliance checks
+ */
+export interface ProtocolComplianceAssessment extends MCPSpecComplianceAssessment {
+    /** Additional conformance-style checks from ProtocolConformanceAssessor */
+    conformanceChecks?: {
+        errorResponseFormat: ProtocolCheck;
+        contentTypeSupport: ProtocolCheck;
+        initializationHandshake: ProtocolCheck;
+    };
+}
+export declare class ProtocolComplianceAssessor extends BaseAssessor<ProtocolComplianceAssessment> {
+    private ajv;
+    constructor(config: AssessmentConfiguration);
+    /**
+     * Get MCP spec version from config or use default
+     */
+    private getSpecVersion;
+    /**
+     * Get base URL for MCP specification
+     */
+    private getSpecBaseUrl;
+    /**
+     * Assess MCP Protocol Compliance - Unified Approach
+     * Combines MCPSpecComplianceAssessor and ProtocolConformanceAssessor functionality
+     */
+    assess(context: AssessmentContext): Promise<ProtocolComplianceAssessment>;
+    /**
+     * Extract protocol version from context
+     */
+    private extractProtocolVersion;
+    /**
+     * Check JSON-RPC 2.0 compliance
+     */
+    private checkJsonRpcCompliance;
+    /**
+     * Check if server info is valid and properly formatted
+     */
+    private checkServerInfoValidity;
+    /**
+     * Check schema compliance for all tools
+     */
+    private checkSchemaCompliance;
+    /**
+     * Check error response compliance (basic check from MCPSpec)
+     */
+    private checkErrorResponses;
+    /**
+     * Check structured output support (2025-06-18 feature)
+     */
+    private checkStructuredOutputSupport;
+    /**
+     * Check capabilities compliance
+     */
+    private checkCapabilitiesCompliance;
+    /**
+     * Select representative tools for testing (first, middle, last for diversity)
+     */
+    private selectToolsForTesting;
+    /**
+     * Check Error Response Format (conformance-style with multi-tool testing)
+     */
+    private checkErrorResponseFormat;
+    /**
+     * Check Content Type Support
+     */
+    private checkContentTypeSupport;
+    /**
+     * Check Initialization Handshake
+     */
+    private checkInitializationHandshake;
+    private assessTransportCompliance;
+    private assessAnnotationSupport;
+    private assessStreamingSupport;
+    private assessOAuthCompliance;
+    private extractMetadataHints;
+    /**
+     * Generate explanation based on all protocol checks
+     */
+    private generateExplanation;
+    /**
+     * Generate recommendations based on all checks
+     */
+    private generateRecommendations;
+}
+//# sourceMappingURL=ProtocolComplianceAssessor.d.ts.map

package/lib/services/assessment/modules/ProtocolComplianceAssessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolComplianceAssessor.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/modules/ProtocolComplianceAssessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACL,2BAA2B,EAM3B,uBAAuB,EAGxB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAOpE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAmB9D;;;GAGG;AACH,MAAM,WAAW,4BAA6B,SAAQ,2BAA2B;IAC/E,2EAA2E;IAC3E,iBAAiB,CAAC,EAAE;QAClB,mBAAmB,EAAE,aAAa,CAAC;QACnC,kBAAkB,EAAE,aAAa,CAAC;QAClC,uBAAuB,EAAE,aAAa,CAAC;KACxC,CAAC;CACH;AAED,qBAAa,0BAA2B,SAAQ,YAAY,CAAC,4BAA4B,CAAC;IACxF,OAAO,CAAC,GAAG,CAAc;gBAEb,MAAM,EAAE,uBAAuB;IAK3C;;OAEG;IACH,OAAO,CAAC,cAAc;IAItB;;OAEG;IACH,OAAO,CAAC,cAAc;IAItB;;;OAGG;IACG,MAAM,CACV,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,4BAA4B,CAAC;IAmIxC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAqB9B;;OAEG;YACW,sBAAsB;IAuBpC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAsB/B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAuC7B;;OAEG;YACW,mBAAmB;IAiCjC;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAYpC;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAkEnC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAS7B;;OAEG;YACW,wBAAwB;IA4GtC;;OAEG;YACW,uBAAuB;IA2FrC;;OAEG;YACW,4BAA4B;IAoD1C,OAAO,CAAC,yBAAyB;IAkEjC,OAAO,CAAC,uBAAuB;IAqB/B,OAAO,CAAC,sBAAsB;IA0B9B,OAAO,CAAC,qBAAqB;IAgC7B,OAAO,CAAC,oBAAoB;IA8E5B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAoC3B;;OAEG;IACH,OAAO,CAAC,uBAAuB;CAqEhC"}