@bryan-thompson/inspector-assessment 1.35.3 → 1.36.1

package/client/lib/services/assessment/modules/ErrorHandlingAssessor.js

@@ -6,13 +6,16 @@ import { BaseAssessor } from "./BaseAssessor.js";
 import { createConcurrencyLimit } from "../lib/concurrencyLimit.js";
 import { ExecutionArtifactDetector } from "./securityTests/ExecutionArtifactDetector.js";
 import { SafeResponseDetector } from "./securityTests/SafeResponseDetector.js";
+import { ErrorClassifier } from "./securityTests/ErrorClassifier.js";
 export class ErrorHandlingAssessor extends BaseAssessor {
     executionDetector;
     safeResponseDetector;
+    errorClassifier;
     constructor(config) {
         super(config);
         this.executionDetector = new ExecutionArtifactDetector();
         this.safeResponseDetector = new SafeResponseDetector();
+        this.errorClassifier = new ErrorClassifier();
     }
     async assess(context) {
         this.logger.info("Starting error handling assessment");
@@ -56,6 +59,15 @@ export class ErrorHandlingAssessor extends BaseAssessor {
             passedTests += toolTests.filter((t) => t.passed).length;
         }
         this.testCount = testDetails.length;
+        // Issue #153: Calculate test execution metadata for score validation
+        // Count connection errors from test results (tests with isConnectionError flag)
+        const connectionErrorTests = testDetails.filter((t) => t.isConnectionError);
+        const connectionErrorCount = connectionErrorTests.length;
+        const validTestsCompleted = testDetails.length - connectionErrorCount;
+        const totalTestsAttempted = testDetails.length;
+        const testCoveragePercent = totalTestsAttempted > 0
+            ? Math.round((validTestsCompleted / totalTestsAttempted) * 100)
+            : 0;
         const metrics = this.calculateMetrics(testDetails, passedTests);
         const status = this.determineErrorHandlingStatus(metrics, testDetails.length);
         const explanation = this.generateExplanation(metrics, testDetails);
@@ -68,6 +80,13 @@ export class ErrorHandlingAssessor extends BaseAssessor {
             score: Math.round(metrics.mcpComplianceScore),
             explanation,
             recommendations,
+            // Issue #153: Test execution metadata for score validation
+            testExecutionMetadata: {
+                totalTestsAttempted,
+                validTestsCompleted,
+                connectionErrorCount,
+                testCoveragePercent,
+            },
         };
     }
     selectToolsForTesting(tools) {
@@ -175,6 +194,25 @@ export class ErrorHandlingAssessor extends BaseAssessor {
             };
         }
         catch (error) {
+            // Issue #153: Check for connection errors first - these should NOT count as passed
+            if (this.errorClassifier.isConnectionErrorFromException(error)) {
+                const errorInfo = this.extractErrorInfo(error);
+                return {
+                    toolName: tool.name,
+                    testType: "missing_required",
+                    testInput,
+                    expectedError: "Missing required parameters",
+                    actualResponse: {
+                        isError: true,
+                        errorCode: errorInfo.code,
+                        errorMessage: errorInfo.message,
+                        rawResponse: error,
+                    },
+                    passed: false,
+                    reason: "Connection error - unable to test",
+                    isConnectionError: true,
+                };
+            }
             // Check if the error message is meaningful (not just a generic crash)
             const errorInfo = this.extractErrorInfo(error);
             const messageLower = errorInfo.message?.toLowerCase() ?? "";
@@ -183,8 +221,8 @@ export class ErrorHandlingAssessor extends BaseAssessor {
                 messageLower.includes("parameter") ||
                 messageLower.includes("must") ||
                 messageLower.includes("invalid") ||
-                messageLower.includes("validation") ||
-                (errorInfo.message?.length ?? 0) > 20; // Longer messages are likely intentional
+                messageLower.includes("validation");
+            // Removed: (errorInfo.message?.length ?? 0) > 20 - this was causing false positives
             return {
                 toolName: tool.name,
                 testType: "missing_required",
@@ -242,6 +280,25 @@ export class ErrorHandlingAssessor extends BaseAssessor {
             };
         }
         catch (error) {
+            // Issue #153: Check for connection errors first - these should NOT count as passed
+            if (this.errorClassifier.isConnectionErrorFromException(error)) {
+                const errorInfo = this.extractErrorInfo(error);
+                return {
+                    toolName: tool.name,
+                    testType: "wrong_type",
+                    testInput,
+                    expectedError: "Type validation error",
+                    actualResponse: {
+                        isError: true,
+                        errorCode: errorInfo.code,
+                        errorMessage: errorInfo.message,
+                        rawResponse: error,
+                    },
+                    passed: false,
+                    reason: "Connection error - unable to test",
+                    isConnectionError: true,
+                };
+            }
             // Check if the error message is meaningful (not just a generic crash)
             const errorInfo = this.extractErrorInfo(error);
             const messageLower = errorInfo.message?.toLowerCase() ?? "";
@@ -251,8 +308,8 @@ export class ErrorHandlingAssessor extends BaseAssessor {
                 messageLower.includes("must be") ||
                 messageLower.includes("validation") ||
                 messageLower.includes("string") ||
-                messageLower.includes("number") ||
-                (errorInfo.message?.length ?? 0) > 20; // Longer messages are likely intentional
+                messageLower.includes("number");
+            // Removed: (errorInfo.message?.length ?? 0) > 20 - this was causing false positives
             return {
                 toolName: tool.name,
                 testType: "wrong_type",
@@ -294,6 +351,25 @@ export class ErrorHandlingAssessor extends BaseAssessor {
             };
         }
         catch (error) {
+            // Issue #153: Check for connection errors first - these should NOT count as passed
+            if (this.errorClassifier.isConnectionErrorFromException(error)) {
+                const errorInfo = this.extractErrorInfo(error);
+                return {
+                    toolName: tool.name,
+                    testType: "invalid_values",
+                    testInput,
+                    expectedError: "Invalid parameter values",
+                    actualResponse: {
+                        isError: true,
+                        errorCode: errorInfo.code,
+                        errorMessage: errorInfo.message,
+                        rawResponse: error,
+                    },
+                    passed: false,
+                    reason: "Connection error - unable to test",
+                    isConnectionError: true,
+                };
+            }
             // Check if the error message is meaningful (not just a generic crash)
             const errorInfo = this.extractErrorInfo(error);
             const messageLower = errorInfo.message?.toLowerCase() ?? "";
@@ -302,8 +378,8 @@ export class ErrorHandlingAssessor extends BaseAssessor {
                 messageLower.includes("must") ||
                 messageLower.includes("cannot") ||
                 messageLower.includes("validation") ||
-                messageLower.includes("error") ||
-                (errorInfo.message?.length ?? 0) > 15; // Even shorter messages OK for invalid values
+                messageLower.includes("error");
+            // Removed: (errorInfo.message?.length ?? 0) > 15 - this was causing false positives
             return {
                 toolName: tool.name,
                 testType: "invalid_values",
@@ -343,6 +419,25 @@ export class ErrorHandlingAssessor extends BaseAssessor {
             };
         }
         catch (error) {
+            // Issue #153: Check for connection errors first - these should NOT count as passed
+            if (this.errorClassifier.isConnectionErrorFromException(error)) {
+                const errorInfo = this.extractErrorInfo(error);
+                return {
+                    toolName: tool.name,
+                    testType: "excessive_input",
+                    testInput: { value: "[100KB string]" },
+                    expectedError: "Input size limit exceeded",
+                    actualResponse: {
+                        isError: true,
+                        errorCode: errorInfo.code,
+                        errorMessage: errorInfo.message,
+                        rawResponse: "[error details omitted]",
+                    },
+                    passed: false,
+                    reason: "Connection error - unable to test",
+                    isConnectionError: true,
+                };
+            }
             // Check if the error message is meaningful (not just a generic crash)
             const errorInfo = this.extractErrorInfo(error);
             const messageLower = errorInfo.message?.toLowerCase() ?? "";
@@ -351,8 +446,8 @@ export class ErrorHandlingAssessor extends BaseAssessor {
                 messageLower.includes("limit") ||
                 messageLower.includes("exceed") ||
                 messageLower.includes("too") ||
-                messageLower.includes("maximum") ||
-                (errorInfo.message?.length ?? 0) > 10; // Short messages OK for size limits
+                messageLower.includes("maximum");
+            // Removed: (errorInfo.message?.length ?? 0) > 10 - this was causing false positives
             return {
                 toolName: tool.name,
                 testType: "excessive_input",

package/client/lib/services/assessment/modules/ProhibitedLibrariesAssessor.d.ts

@@ -17,6 +17,11 @@ export declare class ProhibitedLibrariesAssessor extends BaseAssessor {
      * Run prohibited libraries assessment
      */
     assess(context: AssessmentContext): Promise<ProhibitedLibrariesAssessment>;
+    /**
+     * Create result when no files are available to scan (Issue #154)
+     * Follows the pattern established by ConformanceAssessor
+     */
+    private createSkippedResult;
     /**
      * Check if file is a source file worth scanning
      */

package/client/lib/services/assessment/modules/ProhibitedLibrariesAssessor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProhibitedLibrariesAssessor.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/modules/ProhibitedLibrariesAssessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EACV,6BAA6B,EAI9B,MAAM,uBAAuB,CAAC;AAS/B,qBAAa,2BAA4B,SAAQ,YAAY;IAC3D;;OAEG;IACG,MAAM,CACV,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,6BAA6B,CAAC;IAiKzC;;OAEG;IACH,OAAO,CAAC,YAAY;IA0BpB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAqB1B;;;;;;;OAOG;IACH,OAAO,CAAC,0BAA0B;IAiClC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAoD3B;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;CA2EhC"}
+{"version":3,"file":"ProhibitedLibrariesAssessor.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/modules/ProhibitedLibrariesAssessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EACV,6BAA6B,EAI9B,MAAM,uBAAuB,CAAC;AAS/B,qBAAa,2BAA4B,SAAQ,YAAY;IAC3D;;OAEG;IACG,MAAM,CACV,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,6BAA6B,CAAC;IAkLzC;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAiB3B;;OAEG;IACH,OAAO,CAAC,YAAY;IA0BpB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAqB1B;;;;;;;OAOG;IACH,OAAO,CAAC,0BAA0B;IAiClC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAoD3B;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;CA2EhC"}

package/client/lib/services/assessment/modules/ProhibitedLibrariesAssessor.js

@@ -18,6 +18,15 @@ export class ProhibitedLibrariesAssessor extends BaseAssessor {
     async assess(context) {
         this.logger.info("Starting prohibited libraries assessment");
         this.testCount = 0;
+        // Issue #154: Check if there are any files to scan
+        const hasPackageJson = Boolean(context.packageJson);
+        const hasSourceFiles = Boolean(context.sourceCodeFiles &&
+            context.config.enableSourceCodeAnalysis &&
+            context.sourceCodeFiles.size > 0);
+        if (!hasPackageJson && !hasSourceFiles) {
+            this.logger.info("No package.json or source files available, skipping assessment");
+            return this.createSkippedResult("No package.json or source files provided. Enable source code analysis with --source flag.");
+        }
         const matches = [];
         const scannedFiles = [];
         let hasFinancialLibraries = false;
@@ -137,6 +146,26 @@ export class ProhibitedLibrariesAssessor extends BaseAssessor {
             recommendations,
         };
     }
+    /**
+     * Create result when no files are available to scan (Issue #154)
+     * Follows the pattern established by ConformanceAssessor
+     */
+    createSkippedResult(reason) {
+        return {
+            matches: [],
+            scannedFiles: [],
+            hasFinancialLibraries: false,
+            hasMediaLibraries: false,
+            status: "NEED_MORE_INFO",
+            explanation: `Prohibited libraries assessment skipped: ${reason}`,
+            recommendations: [
+                "Provide --source <path> to enable package.json and source file scanning",
+                "Ensure the source path exists and contains package.json or source files",
+            ],
+            skipped: true,
+            skipReason: reason,
+        };
+    }
     /**
      * Check if file is a source file worth scanning
      */

package/client/lib/services/assessment/modules/SecurityAssessor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SecurityAssessor.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/modules/SecurityAssessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EACL,kBAAkB,EAInB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAiB9D,OAAO,EACL,gBAAgB,EAGjB,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,OAAO,CAAC,aAAa,CAAwB;IAC7C,OAAO,CAAC,gBAAgB,CAA2B;IACnD,OAAO,CAAC,oBAAoB,CAAuB;IACnD,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,YAAY,CAAiC;IAErD;;;OAGG;IACH,eAAe,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,GAAG,IAAI;IAStD;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAOjC;;;OAGG;YACW,0BAA0B;gBAwBtC,MAAM,EAAE,OAAO,8BAA8B,EAAE,uBAAuB;IAwClE,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA+OrE;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAoC7B;;OAEG;YACW,+BAA+B;IAiC7C;;;OAGG;YACW,yBAAyB;IA0CvC;;;;;;;OAOG;YACW,yBAAyB;IAmFvC;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAYjC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IA0B/B;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAkEnC;;;OAGG;IACH,OAAO,CAAC,0BAA0B;CAgDnC"}
+{"version":3,"file":"SecurityAssessor.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/modules/SecurityAssessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EACL,kBAAkB,EAInB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAiB9D,OAAO,EACL,gBAAgB,EAGjB,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,OAAO,CAAC,aAAa,CAAwB;IAC7C,OAAO,CAAC,gBAAgB,CAA2B;IACnD,OAAO,CAAC,oBAAoB,CAAuB;IACnD,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,YAAY,CAAiC;IAErD;;;OAGG;IACH,eAAe,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,GAAG,IAAI;IAStD;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAOjC;;;OAGG;YACW,0BAA0B;gBAwBtC,MAAM,EAAE,OAAO,8BAA8B,EAAE,uBAAuB;IAwClE,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA8PrE;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAoC7B;;OAEG;YACW,+BAA+B;IAiC7C;;;OAGG;YACW,yBAAyB;IA0CvC;;;;;;;OAOG;YACW,yBAAyB;IAmFvC;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAYjC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IA0B/B;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAkEnC;;;OAGG;IACH,OAAO,CAAC,0BAA0B;CAgDnC"}

package/client/lib/services/assessment/modules/SecurityAssessor.js

@@ -253,6 +253,12 @@ export class SecurityAssessor extends BaseAssessor {
         }
         // Issue #75: Aggregate auth bypass detection results
         const authBypassSummary = this.aggregateAuthBypassResults(allTests);
+        // Issue #152: Calculate test execution metadata for score validation
+        const totalTestsAttempted = allTests.length;
+        const validTestsCompleted = validTests.length;
+        const testCoveragePercent = totalTestsAttempted > 0
+            ? Math.round((validTestsCompleted / totalTestsAttempted) * 100)
+            : 0;
         return {
             promptInjectionTests: allTests,
             vulnerabilities,
@@ -263,6 +269,13 @@ export class SecurityAssessor extends BaseAssessor {
             // Issue #134: Test validity warning for response uniformity detection
             testValidityWarning: validityResult.warning,
             overallConfidence,
+            // Issue #152: Test execution metadata for score validation
+            testExecutionMetadata: {
+                totalTestsAttempted,
+                validTestsCompleted,
+                connectionErrorCount: connectionErrors.length,
+                testCoveragePercent,
+            },
         };
     }
     /**

package/client/lib/services/assessment/modules/annotations/AlignmentChecker.d.ts

@@ -38,9 +38,14 @@ export interface AlignmentMetricsResult {
     };
 }
 /**
- * Extract annotations from a tool
- * Checks multiple sources in priority order: annotations object, direct properties, metadata
+ * Enable or disable annotation debug logging (Issue #155)
+ * Called by CLI when --debug-annotations flag is provided
  */
+export declare function setAnnotationDebugMode(enabled: boolean): void;
+/**
+ * Check if annotation debug mode is enabled
+ */
+export declare function isAnnotationDebugEnabled(): boolean;
 export declare function extractAnnotations(tool: Tool): ExtractedAnnotations;
 /**
  * Extract extended metadata from tool (Issue #54)

package/client/lib/services/assessment/modules/annotations/AlignmentChecker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AlignmentChecker.d.ts","sourceRoot":"","sources":["../../../../../src/services/assessment/modules/annotations/AlignmentChecker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAC/D,OAAO,KAAK,EACV,oBAAoB,EACpB,gBAAgB,EAEhB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EACV,gBAAgB,EAChB,wBAAwB,EACzB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,gCAAgC,CAAC;AAoExC;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,MAAM,EAAE,gBAAgB,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE;QACP,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,kBAAkB,EAAE;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,oBAAoB,CA8DnE;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,IAAI,GACT,oBAAoB,CAAC,kBAAkB,CAAC,CA6D1C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,GAAG,iBAAiB,EAAE,CAqBtE;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,IAAI,GAAG,mBAAmB,CAmD3E;AAqCD;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,IAAI,EACV,gBAAgB,EAAE,gBAAgB,EAClC,kBAAkB,CAAC,EAAE,wBAAwB,GAC5C,oBAAoB,CA0JtB;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,oBAAoB,EAAE,EAC/B,UAAU,EAAE,MAAM,GACjB,gBAAgB,CA8BlB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,oBAAoB,EAAE,EAC/B,UAAU,EAAE,MAAM,GACjB,sBAAsB,CA2BxB"}
+{"version":3,"file":"AlignmentChecker.d.ts","sourceRoot":"","sources":["../../../../../src/services/assessment/modules/annotations/AlignmentChecker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAC/D,OAAO,KAAK,EACV,oBAAoB,EACpB,gBAAgB,EAEhB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EACV,gBAAgB,EAChB,wBAAwB,EACzB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,gCAAgC,CAAC;AAuFxC;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,MAAM,EAAE,gBAAgB,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE;QACP,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,kBAAkB,EAAE;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AA0CD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAE7D;AAED;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,OAAO,CAElD;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,oBAAoB,CAiNnE;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,IAAI,GACT,oBAAoB,CAAC,kBAAkB,CAAC,CA6D1C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,GAAG,iBAAiB,EAAE,CAqBtE;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,IAAI,GAAG,mBAAmB,CAmD3E;AAqCD;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,IAAI,EACV,gBAAgB,EAAE,gBAAgB,EAClC,kBAAkB,CAAC,EAAE,wBAAwB,GAC5C,oBAAoB,CA0JtB;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,oBAAoB,EAAE,EAC/B,UAAU,EAAE,MAAM,GACjB,gBAAgB,CA8BlB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,oBAAoB,EAAE,EAC/B,UAAU,EAAE,MAAM,GACjB,sBAAsB,CA2BxB"}

package/client/lib/services/assessment/modules/annotations/AlignmentChecker.js

@@ -7,57 +7,155 @@
 import { scanDescriptionForPoisoning, } from "./DescriptionPoisoningDetector.js";
 import { detectAnnotationDeception, isActionableConfidence, } from "./AnnotationDeceptionDetector.js";
 import { inferBehavior } from "./BehaviorInference.js";
+/**
+ * Helper to resolve annotation value with fallback (Issue #150)
+ * Checks *Hint suffix first (MCP spec), then non-suffixed version as fallback
+ * This handles servers that use 'readOnly' instead of 'readOnlyHint'
+ *
+ * @param obj - The object to search for annotation properties
+ * @param hintKey - The MCP spec compliant key (e.g., 'readOnlyHint')
+ * @param fallbackKey - The non-suffixed fallback key (e.g., 'readOnly')
+ * @returns The boolean annotation value, or undefined if not found or not a boolean
+ */
+function resolveAnnotationValue(obj, hintKey, fallbackKey) {
+    if (!obj)
+        return undefined;
+    // Priority: *Hint version (MCP spec)
+    if (obj[hintKey] !== undefined) {
+        const val = obj[hintKey];
+        if (typeof val === "boolean")
+            return val;
+    }
+    // Fallback: non-suffixed version (Issue #150)
+    if (obj[fallbackKey] !== undefined) {
+        const val = obj[fallbackKey];
+        if (typeof val === "boolean")
+            return val;
+    }
+    return undefined;
+}
 /**
  * Extract annotations from a tool
  * Checks multiple sources in priority order: annotations object, direct properties, metadata
+ * Issue #150: Also checks non-suffixed property names (readOnly, destructive) as fallback
+ */
+/**
+ * Global debug flag for annotation extraction (Issue #155)
+ * Set via setAnnotationDebugMode() when --debug-annotations flag is used
+ */
+let annotationDebugMode = false;
+/**
+ * Enable or disable annotation debug logging (Issue #155)
+ * Called by CLI when --debug-annotations flag is provided
+ */
+export function setAnnotationDebugMode(enabled) {
+    annotationDebugMode = enabled;
+}
+/**
+ * Check if annotation debug mode is enabled
  */
+export function isAnnotationDebugEnabled() {
+    return annotationDebugMode;
+}
 export function extractAnnotations(tool) {
     const extendedTool = tool;
+    // Issue #155: Debug logging when --debug-annotations flag is enabled
+    if (annotationDebugMode) {
+        console.log("[DEBUG-ANNOTATIONS]", tool.name, "| keys:", Object.keys(tool), "| annotations:", JSON.stringify(extendedTool.annotations), "| direct.readOnlyHint:", extendedTool.readOnlyHint);
+    }
     // Priority 1: Check annotations object (MCP 2024-11 spec)
+    // Issue #150: Use resolveAnnotationValue to check both *Hint and non-suffixed versions
     if (extendedTool.annotations) {
-        const hasAnnotations = extendedTool.annotations.readOnlyHint !== undefined ||
-            extendedTool.annotations.destructiveHint !== undefined;
+        const annotationsObj = extendedTool.annotations;
+        const readOnlyValue = resolveAnnotationValue(annotationsObj, "readOnlyHint", "readOnly");
+        const destructiveValue = resolveAnnotationValue(annotationsObj, "destructiveHint", "destructive");
+        const hasAnnotations = readOnlyValue !== undefined || destructiveValue !== undefined;
         if (hasAnnotations) {
             return {
-                readOnlyHint: extendedTool.annotations.readOnlyHint,
-                destructiveHint: extendedTool.annotations.destructiveHint,
+                readOnlyHint: readOnlyValue,
+                destructiveHint: destructiveValue,
                 title: extendedTool.annotations.title || extendedTool.title,
                 description: tool.description,
-                idempotentHint: extendedTool.annotations.idempotentHint,
-                openWorldHint: extendedTool.annotations.openWorldHint,
+                idempotentHint: resolveAnnotationValue(annotationsObj, "idempotentHint", "idempotent"),
+                openWorldHint: resolveAnnotationValue(annotationsObj, "openWorldHint", "openWorld"),
                 source: "mcp",
             };
         }
     }
     // Priority 2: Check direct properties
-    if (extendedTool.readOnlyHint !== undefined ||
-        extendedTool.destructiveHint !== undefined) {
+    // Issue #150: Use resolveAnnotationValue to check both *Hint and non-suffixed versions
+    const directObj = extendedTool;
+    const directReadOnly = resolveAnnotationValue(directObj, "readOnlyHint", "readOnly");
+    const directDestructive = resolveAnnotationValue(directObj, "destructiveHint", "destructive");
+    if (directReadOnly !== undefined || directDestructive !== undefined) {
         return {
-            readOnlyHint: extendedTool.readOnlyHint,
-            destructiveHint: extendedTool.destructiveHint,
+            readOnlyHint: directReadOnly,
+            destructiveHint: directDestructive,
             title: extendedTool.title,
             description: tool.description,
-            idempotentHint: extendedTool.idempotentHint,
-            openWorldHint: extendedTool.openWorldHint,
+            idempotentHint: resolveAnnotationValue(directObj, "idempotentHint", "idempotent"),
+            openWorldHint: resolveAnnotationValue(directObj, "openWorldHint", "openWorld"),
             source: "mcp",
         };
     }
     // Priority 3: Check metadata
+    // Issue #150: Use resolveAnnotationValue to check both *Hint and non-suffixed versions
     if (extendedTool.metadata) {
-        const hasMetadataAnnotations = extendedTool.metadata.readOnlyHint !== undefined ||
-            extendedTool.metadata.destructiveHint !== undefined;
+        const metadataObj = extendedTool.metadata;
+        const metaReadOnly = resolveAnnotationValue(metadataObj, "readOnlyHint", "readOnly");
+        const metaDestructive = resolveAnnotationValue(metadataObj, "destructiveHint", "destructive");
+        const hasMetadataAnnotations = metaReadOnly !== undefined || metaDestructive !== undefined;
         if (hasMetadataAnnotations) {
             return {
-                readOnlyHint: extendedTool.metadata.readOnlyHint,
-                destructiveHint: extendedTool.metadata.destructiveHint,
+                readOnlyHint: metaReadOnly,
+                destructiveHint: metaDestructive,
                 title: extendedTool.metadata.title || extendedTool.title,
                 description: tool.description,
-                idempotentHint: extendedTool.metadata.idempotentHint,
-                openWorldHint: extendedTool.metadata.openWorldHint,
+                idempotentHint: resolveAnnotationValue(metadataObj, "idempotentHint", "idempotent"),
+                openWorldHint: resolveAnnotationValue(metadataObj, "openWorldHint", "openWorld"),
+                source: "mcp",
+            };
+        }
+    }
+    // Priority 4: Check _meta object (MCP spec allows arbitrary data here)
+    // Issue #155: Some servers may store annotations in _meta
+    if (extendedTool._meta) {
+        const metaObj = extendedTool._meta;
+        const metaReadOnly = resolveAnnotationValue(metaObj, "readOnlyHint", "readOnly");
+        const metaDestructive = resolveAnnotationValue(metaObj, "destructiveHint", "destructive");
+        if (metaReadOnly !== undefined || metaDestructive !== undefined) {
+            return {
+                readOnlyHint: metaReadOnly,
+                destructiveHint: metaDestructive,
+                title: metaObj.title,
+                description: tool.description,
+                idempotentHint: resolveAnnotationValue(metaObj, "idempotentHint", "idempotent"),
+                openWorldHint: resolveAnnotationValue(metaObj, "openWorldHint", "openWorld"),
                 source: "mcp",
             };
         }
     }
+    // Priority 5: Check annotations.hints (nested structure some servers use)
+    // Issue #155: Handle servers that nest hints inside annotations object
+    if (extendedTool.annotations) {
+        const hintsObj = extendedTool.annotations
+            .hints;
+        if (hintsObj) {
+            const hintsReadOnly = resolveAnnotationValue(hintsObj, "readOnlyHint", "readOnly");
+            const hintsDestructive = resolveAnnotationValue(hintsObj, "destructiveHint", "destructive");
+            if (hintsReadOnly !== undefined || hintsDestructive !== undefined) {
+                return {
+                    readOnlyHint: hintsReadOnly,
+                    destructiveHint: hintsDestructive,
+                    title: extendedTool.annotations.title,
+                    description: tool.description,
+                    idempotentHint: resolveAnnotationValue(hintsObj, "idempotentHint", "idempotent"),
+                    openWorldHint: resolveAnnotationValue(hintsObj, "openWorldHint", "openWorld"),
+                    source: "mcp",
+                };
+            }
+        }
+    }
     return {
         title: extendedTool.title,
         description: tool.description,

package/client/lib/services/assessment/modules/annotations/index.d.ts

@@ -16,7 +16,7 @@ export { analyzeDescription, hasReadOnlyIndicators, hasDestructiveIndicators, ha
 export { analyzeInputSchema, analyzeOutputSchema, hasBulkOperationIndicators, hasPaginationParameters, hasForceFlags, INPUT_READONLY_PATTERNS, INPUT_DESTRUCTIVE_PATTERNS, INPUT_WRITE_PATTERNS, OUTPUT_READONLY_PATTERNS, OUTPUT_DESTRUCTIVE_PATTERNS, OUTPUT_WRITE_PATTERNS, type JSONSchema, } from "./SchemaAnalyzer.js";
 export { detectArchitecture, hasDatabaseToolPatterns, extractDatabasesFromDependencies, type Tool as ArchitectureTool, type ArchitectureContext, } from "./ArchitectureDetector.js";
 export { type ClaudeInference, type EnhancedToolAnnotationResult, } from "./types.js";
-export { extractAnnotations, extractExtendedMetadata, extractToolParams, scanInputSchemaDescriptions, assessSingleTool, determineAnnotationStatus, calculateMetrics, type ExtractedAnnotations, type AlignmentMetricsResult, } from "./AlignmentChecker.js";
+export { extractAnnotations, extractExtendedMetadata, extractToolParams, scanInputSchemaDescriptions, assessSingleTool, determineAnnotationStatus, calculateMetrics, setAnnotationDebugMode, isAnnotationDebugEnabled, type ExtractedAnnotations, type AlignmentMetricsResult, } from "./AlignmentChecker.js";
 export { generateExplanation, generateEnhancedExplanation, generateRecommendations, generateEnhancedRecommendations, } from "./ExplanationGenerator.js";
 export { emitAnnotationEvents, emitMismatchEvent } from "./EventEmitter.js";
 export { enhanceWithClaudeInference, createPatternBasedInference, } from "./ClaudeIntegration.js";

package/client/lib/services/assessment/modules/annotations/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/assessment/modules/annotations/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,8BAA8B,EAC9B,2BAA2B,EAC3B,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,GACzB,MAAM,gCAAgC,CAAC;AAExC,OAAO,EACL,+BAA+B,EAC/B,4BAA4B,EAC5B,kCAAkC,EAClC,eAAe,EACf,kBAAkB,EAClB,sBAAsB,EACtB,yBAAyB,EACzB,KAAK,eAAe,GACrB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EACL,aAAa,EACb,qBAAqB,EACrB,KAAK,uBAAuB,GAC7B,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,wBAAwB,EACxB,kBAAkB,EAClB,6BAA6B,GAC9B,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,0BAA0B,EAC1B,uBAAuB,EACvB,aAAa,EACb,uBAAuB,EACvB,0BAA0B,EAC1B,oBAAoB,EACpB,wBAAwB,EACxB,2BAA2B,EAC3B,qBAAqB,EACrB,KAAK,UAAU,GAChB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,gCAAgC,EAChC,KAAK,IAAI,IAAI,gBAAgB,EAC7B,KAAK,mBAAmB,GACzB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,4BAA4B,GAClC,MAAM,SAAS,CAAC;AAIjB,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,iBAAiB,EACjB,2BAA2B,EAC3B,gBAAgB,EAChB,yBAAyB,EACzB,gBAAgB,EAChB,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,GAC5B,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,mBAAmB,EACnB,2BAA2B,EAC3B,uBAAuB,EACvB,+BAA+B,GAChC,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGzE,OAAO,EACL,0BAA0B,EAC1B,2BAA2B,GAC5B,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/assessment/modules/annotations/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,8BAA8B,EAC9B,2BAA2B,EAC3B,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,GACzB,MAAM,gCAAgC,CAAC;AAExC,OAAO,EACL,+BAA+B,EAC/B,4BAA4B,EAC5B,kCAAkC,EAClC,eAAe,EACf,kBAAkB,EAClB,sBAAsB,EACtB,yBAAyB,EACzB,KAAK,eAAe,GACrB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EACL,aAAa,EACb,qBAAqB,EACrB,KAAK,uBAAuB,GAC7B,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,wBAAwB,EACxB,kBAAkB,EAClB,6BAA6B,GAC9B,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,0BAA0B,EAC1B,uBAAuB,EACvB,aAAa,EACb,uBAAuB,EACvB,0BAA0B,EAC1B,oBAAoB,EACpB,wBAAwB,EACxB,2BAA2B,EAC3B,qBAAqB,EACrB,KAAK,UAAU,GAChB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,gCAAgC,EAChC,KAAK,IAAI,IAAI,gBAAgB,EAC7B,KAAK,mBAAmB,GACzB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,4BAA4B,GAClC,MAAM,SAAS,CAAC;AAKjB,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,iBAAiB,EACjB,2BAA2B,EAC3B,gBAAgB,EAChB,yBAAyB,EACzB,gBAAgB,EAChB,sBAAsB,EACtB,wBAAwB,EACxB,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,GAC5B,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,mBAAmB,EACnB,2BAA2B,EAC3B,uBAAuB,EACvB,+BAA+B,GAChC,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGzE,OAAO,EACL,0BAA0B,EAC1B,2BAA2B,GAC5B,MAAM,qBAAqB,CAAC"}

package/client/lib/services/assessment/modules/annotations/index.js

@@ -20,7 +20,8 @@ export { analyzeInputSchema, analyzeOutputSchema, hasBulkOperationIndicators, ha
 export { detectArchitecture, hasDatabaseToolPatterns, extractDatabasesFromDependencies, } from "./ArchitectureDetector.js";
 // Issue #105: Alignment Checker
 // Issue #119: Added scanInputSchemaDescriptions for Challenge #15
-export { extractAnnotations, extractExtendedMetadata, extractToolParams, scanInputSchemaDescriptions, assessSingleTool, determineAnnotationStatus, calculateMetrics, } from "./AlignmentChecker.js";
+// Issue #155: Added setAnnotationDebugMode for debug logging
+export { extractAnnotations, extractExtendedMetadata, extractToolParams, scanInputSchemaDescriptions, assessSingleTool, determineAnnotationStatus, calculateMetrics, setAnnotationDebugMode, isAnnotationDebugEnabled, } from "./AlignmentChecker.js";
 // Issue #105: Explanation Generator
 export { generateExplanation, generateEnhancedExplanation, generateRecommendations, generateEnhancedRecommendations, } from "./ExplanationGenerator.js";
 // Issue #105: Event Emitter

package/client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bryan-thompson/inspector-assessment-client",
-  "version": "1.35.3",
+  "version": "1.36.1",
   "description": "Client-side application for the Enhanced MCP Inspector with assessment capabilities",
   "license": "MIT",
   "author": "Bryan Thompson <bryan@triepod.ai>",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bryan-thompson/inspector-assessment",
-  "version": "1.35.3",
+  "version": "1.36.1",
   "description": "Enhanced MCP Inspector with comprehensive assessment capabilities for server validation",
   "license": "MIT",
   "author": "Bryan Thompson <bryan@triepod.ai>",

package/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bryan-thompson/inspector-assessment-server",
-  "version": "1.35.3",
+  "version": "1.36.1",
   "description": "Server-side application for the Enhanced MCP Inspector with assessment capabilities",
   "license": "MIT",
   "author": "Bryan Thompson <bryan@triepod.ai>",