@bryan-thompson/inspector-assessment-client 1.25.1 → 1.25.4

package/lib/services/assessment/orchestratorHelpers.js

@@ -0,0 +1,212 @@
+/**
+ * Assessment Orchestrator Helpers
+ *
+ * Pure functions extracted from AssessmentOrchestrator for testability.
+ * These functions handle:
+ * - AUP violation enrichment for JSONL events
+ * - Module progress/started event emission
+ * - Overall status determination
+ * - Summary and recommendations generation
+ */
+// Import score calculation helpers from shared module
+import { calculateModuleScore, normalizeModuleKey, INSPECTOR_VERSION, } from "../../lib/moduleScoring.js";
+// Track module start times for duration calculation
+export const moduleStartTimes = new Map();
+/**
+ * Emit module_started event and track start time for duration calculation.
+ * Emits JSONL to stderr with version field for consistent event structure.
+ */
+export function emitModuleStartedEvent(moduleName, estimatedTests, toolCount) {
+    const moduleKey = normalizeModuleKey(moduleName);
+    moduleStartTimes.set(moduleKey, Date.now());
+    // Emit JSONL to stderr with version field
+    console.error(JSON.stringify({
+        event: "module_started",
+        module: moduleKey,
+        estimatedTests,
+        toolCount,
+        version: INSPECTOR_VERSION,
+    }));
+}
+/**
+ * Emit module_complete event with score and duration.
+ * Uses shared score calculator for consistent scoring logic.
+ * For AUP module, includes enriched violation data for Claude analysis.
+ */
+export function emitModuleProgress(moduleName, status, result, testsRun = 0) {
+    // Calculate score using shared helper
+    const score = calculateModuleScore(result);
+    // Don't emit events for skipped modules (null score means module wasn't run)
+    if (score === null)
+        return;
+    const moduleKey = normalizeModuleKey(moduleName);
+    // Calculate duration from module start time
+    const startTime = moduleStartTimes.get(moduleKey);
+    const duration = startTime ? Date.now() - startTime : 0;
+    moduleStartTimes.delete(moduleKey);
+    // Build base event
+    const event = {
+        event: "module_complete",
+        module: moduleKey,
+        status,
+        score,
+        testsRun,
+        duration,
+        version: INSPECTOR_VERSION,
+    };
+    // Add AUP enrichment when module is AUP
+    if (moduleKey === "aup" && result) {
+        const aupEnrichment = buildAUPEnrichment(result);
+        Object.assign(event, aupEnrichment);
+    }
+    // Emit JSONL to stderr with version field
+    console.error(JSON.stringify(event));
+}
+/**
+ * Build AUP enrichment data from an AUP compliance assessment result.
+ * Samples violations prioritizing by severity (CRITICAL > HIGH > MEDIUM).
+ */
+export function buildAUPEnrichment(aupResult, maxSamples = 10) {
+    const violations = aupResult.violations || [];
+    // Calculate metrics
+    const metrics = {
+        total: violations.length,
+        critical: violations.filter((v) => v.severity === "CRITICAL").length,
+        high: violations.filter((v) => v.severity === "HIGH").length,
+        medium: violations.filter((v) => v.severity === "MEDIUM").length,
+        byCategory: {},
+    };
+    // Count by category
+    for (const v of violations) {
+        metrics.byCategory[v.category] = (metrics.byCategory[v.category] || 0) + 1;
+    }
+    // Sample violations prioritizing by severity
+    const sampled = [];
+    const severityOrder = ["CRITICAL", "HIGH", "MEDIUM"];
+    for (const severity of severityOrder) {
+        if (sampled.length >= maxSamples)
+            break;
+        const bySeverity = violations.filter((v) => v.severity === severity);
+        for (const v of bySeverity) {
+            if (sampled.length >= maxSamples)
+                break;
+            sampled.push({
+                category: v.category,
+                categoryName: v.categoryName || "",
+                severity: v.severity,
+                matchedText: v.matchedText || "",
+                location: v.location || "",
+                confidence: v.confidence || "",
+            });
+        }
+    }
+    // Build sampling note
+    let samplingNote = "";
+    if (violations.length === 0) {
+        samplingNote = "No violations detected.";
+    }
+    else if (violations.length <= maxSamples) {
+        samplingNote = `All ${violations.length} violation(s) included.`;
+    }
+    else {
+        samplingNote = `Sampled ${sampled.length} of ${violations.length} violations, prioritized by severity (CRITICAL > HIGH > MEDIUM).`;
+    }
+    return {
+        violationsSample: sampled,
+        samplingNote,
+        violationMetrics: metrics,
+        scannedLocations: aupResult.scannedLocations || {
+            toolNames: false,
+            toolDescriptions: false,
+            readme: false,
+            sourceCode: false,
+        },
+        highRiskDomains: (aupResult.highRiskDomains || []).slice(0, 10),
+    };
+}
+/**
+ * Determine overall status from assessment results.
+ * Priority: FAIL > NEED_MORE_INFO > PASS
+ */
+export function determineOverallStatus(results) {
+    const statuses = [];
+    // Collect all statuses from assessment results
+    Object.values(results).forEach((assessment) => {
+        if (assessment &&
+            typeof assessment === "object" &&
+            "status" in assessment) {
+            statuses.push(assessment.status);
+        }
+    });
+    // If any critical category fails, overall fails
+    if (statuses.includes("FAIL"))
+        return "FAIL";
+    // If any category needs more info, overall needs more info
+    if (statuses.includes("NEED_MORE_INFO"))
+        return "NEED_MORE_INFO";
+    // All must pass for overall pass
+    return "PASS";
+}
+/**
+ * Generate summary text from assessment results.
+ */
+export function generateSummary(results) {
+    const parts = [];
+    const totalCategories = Object.keys(results).length;
+    const passedCategories = Object.values(results).filter((r) => r && typeof r === "object" && "status" in r && r.status === "PASS").length;
+    parts.push(`Assessment complete: ${passedCategories}/${totalCategories} categories passed.`);
+    // Add key findings - use type assertions for optional properties
+    const security = results.security;
+    if (security?.vulnerabilities?.length) {
+        parts.push(`Found ${security.vulnerabilities.length} security vulnerabilities.`);
+    }
+    const functionality = results.functionality;
+    if (functionality?.brokenTools?.length) {
+        parts.push(`${functionality.brokenTools.length} tools are not functioning correctly.`);
+    }
+    // New assessor findings
+    const aupCompliance = results.aupCompliance;
+    if (aupCompliance?.violations?.length) {
+        const criticalCount = aupCompliance.violations.filter((v) => v.severity === "CRITICAL").length;
+        if (criticalCount > 0) {
+            parts.push(`CRITICAL: ${criticalCount} AUP violation(s) detected.`);
+        }
+        else {
+            parts.push(`${aupCompliance.violations.length} AUP item(s) flagged for review.`);
+        }
+    }
+    const toolAnnotations = results.toolAnnotations;
+    if (toolAnnotations?.missingAnnotationsCount) {
+        parts.push(`${toolAnnotations.missingAnnotationsCount} tools missing annotations.`);
+    }
+    const prohibitedLibraries = results.prohibitedLibraries;
+    if (prohibitedLibraries?.matches?.length) {
+        const blockingCount = prohibitedLibraries.matches.filter((m) => m.severity === "BLOCKING").length;
+        if (blockingCount > 0) {
+            parts.push(`BLOCKING: ${blockingCount} prohibited library/libraries detected.`);
+        }
+    }
+    const portability = results.portability;
+    if (portability?.usesBundleRoot) {
+        parts.push("Uses ${BUNDLE_ROOT} anti-pattern.");
+    }
+    return parts.join(" ");
+}
+/**
+ * Generate recommendations from assessment results.
+ * Aggregates, deduplicates, and limits to 10 recommendations.
+ */
+export function generateRecommendations(results) {
+    const recommendations = [];
+    // Aggregate recommendations from all assessments
+    Object.values(results).forEach((assessment) => {
+        if (assessment &&
+            typeof assessment === "object" &&
+            "recommendations" in assessment &&
+            Array.isArray(assessment.recommendations)) {
+            recommendations.push(...assessment.recommendations);
+        }
+    });
+    // De-duplicate and prioritize
+    return [...new Set(recommendations)].slice(0, 10);
+}

package/lib/services/assessment/tool-classifier-patterns.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Tool Classifier Pattern Configuration
+ *
+ * Pre-compiled regex patterns for MCP tool classification.
+ * Extracting patterns to this file provides:
+ * - Single source of truth for patterns, confidence values, and risk levels
+ * - Pre-compiled patterns (created once at module load, not per classify() call)
+ * - Easier maintenance without modifying core classification logic
+ *
+ * @see ToolClassifier.ts for classification logic
+ * @see ToolClassifier.test.ts for pattern behavior validation
+ */
+/**
+ * Security risk categories for MCP tools.
+ *
+ * Categories are organized by risk level:
+ * - **HIGH**: Tools that may execute code or access sensitive data
+ * - **MEDIUM**: Tools with potential bypass or supply chain risks
+ * - **LOW**: Safe tools for data retrieval and manipulation
+ */
+export declare enum ToolCategory {
+    CALCULATOR = "calculator",
+    SYSTEM_EXEC = "system_exec",
+    CODE_EXECUTOR = "code_executor",
+    DATA_ACCESS = "data_access",
+    TOOL_OVERRIDE = "tool_override",
+    CONFIG_MODIFIER = "config_modifier",
+    URL_FETCHER = "fetcher",
+    UNICODE_PROCESSOR = "unicode",
+    JSON_PARSER = "parser",
+    PACKAGE_INSTALLER = "installer",
+    RUG_PULL = "rug_pull",
+    SAFE_STORAGE = "safe_storage",
+    API_WRAPPER = "api_wrapper",
+    SEARCH_RETRIEVAL = "search_retrieval",
+    CRUD_CREATION = "crud_creation",
+    READ_ONLY_INFO = "read_only_info",
+    GENERIC = "generic"
+}
+/**
+ * Risk level for security categorization
+ */
+export type RiskLevel = "HIGH" | "MEDIUM" | "LOW";
+/**
+ * Configuration for a single tool category
+ */
+export interface CategoryConfig {
+    /** Pre-compiled regex patterns for this category */
+    readonly patterns: readonly RegExp[];
+    /** Confidence score (0-100) when this category matches */
+    readonly confidence: number;
+    /** Human-readable reasoning for classification */
+    readonly reasoning: string;
+    /** Risk level for security prioritization */
+    readonly risk: RiskLevel;
+}
+/**
+ * Complete pattern configuration for all tool categories.
+ * Patterns are pre-compiled as static constants for performance.
+ *
+ * ## Pattern Types
+ *
+ * 1. **Substring patterns** (`/keyword/i`): Match anywhere in text
+ *    - Used for HIGH-risk keywords that warrant scrutiny even when embedded
+ *
+ * 2. **Word boundary patterns** (`/\bword\b/i`): Match isolated words only
+ *    - Used for common words to prevent false positives
+ *    - Note: `\b` treats hyphens as boundaries but underscores as word chars
+ */
+export declare const CATEGORY_PATTERNS: Readonly<Record<Exclude<ToolCategory, ToolCategory.GENERIC>, CategoryConfig>>;
+/**
+ * Default configuration for GENERIC category (no pattern match)
+ */
+export declare const GENERIC_CONFIG: Readonly<{
+    confidence: number;
+    reasoning: string;
+    risk: RiskLevel;
+}>;
+/**
+ * Order in which categories are checked during classification.
+ * This order determines priority when a tool matches multiple categories.
+ */
+export declare const CATEGORY_CHECK_ORDER: readonly Exclude<ToolCategory, ToolCategory.GENERIC>[];
+//# sourceMappingURL=tool-classifier-patterns.d.ts.map

package/lib/services/assessment/tool-classifier-patterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-classifier-patterns.d.ts","sourceRoot":"","sources":["../../../src/services/assessment/tool-classifier-patterns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;;GAOG;AACH,oBAAY,YAAY;IAEtB,UAAU,eAAe;IACzB,WAAW,gBAAgB;IAC3B,aAAa,kBAAkB;IAC/B,WAAW,gBAAgB;IAC3B,aAAa,kBAAkB;IAC/B,eAAe,oBAAoB;IACnC,WAAW,YAAY;IAGvB,iBAAiB,YAAY;IAC7B,WAAW,WAAW;IACtB,iBAAiB,cAAc;IAC/B,QAAQ,aAAa;IAGrB,YAAY,iBAAiB;IAC7B,WAAW,gBAAgB;IAC3B,gBAAgB,qBAAqB;IACrC,aAAa,kBAAkB;IAC/B,cAAc,mBAAmB;IAGjC,OAAO,YAAY;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;AAElD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,0DAA0D;IAC1D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,kDAAkD;IAClD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,6CAA6C;IAC7C,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;CAC1B;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CACtC,MAAM,CAAC,OAAO,CAAC,YAAY,EAAE,YAAY,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC,CAyR3D,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,SAAS,CAAC;CACjB,CAIS,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS,OAAO,CACjD,YAAY,EACZ,YAAY,CAAC,OAAO,CACrB,EAoBS,CAAC"}

package/lib/services/assessment/tool-classifier-patterns.js

@@ -0,0 +1,348 @@
+/**
+ * Tool Classifier Pattern Configuration
+ *
+ * Pre-compiled regex patterns for MCP tool classification.
+ * Extracting patterns to this file provides:
+ * - Single source of truth for patterns, confidence values, and risk levels
+ * - Pre-compiled patterns (created once at module load, not per classify() call)
+ * - Easier maintenance without modifying core classification logic
+ *
+ * @see ToolClassifier.ts for classification logic
+ * @see ToolClassifier.test.ts for pattern behavior validation
+ */
+/**
+ * Security risk categories for MCP tools.
+ *
+ * Categories are organized by risk level:
+ * - **HIGH**: Tools that may execute code or access sensitive data
+ * - **MEDIUM**: Tools with potential bypass or supply chain risks
+ * - **LOW**: Safe tools for data retrieval and manipulation
+ */
+export var ToolCategory;
+(function (ToolCategory) {
+    // HIGH RISK
+    ToolCategory["CALCULATOR"] = "calculator";
+    ToolCategory["SYSTEM_EXEC"] = "system_exec";
+    ToolCategory["CODE_EXECUTOR"] = "code_executor";
+    ToolCategory["DATA_ACCESS"] = "data_access";
+    ToolCategory["TOOL_OVERRIDE"] = "tool_override";
+    ToolCategory["CONFIG_MODIFIER"] = "config_modifier";
+    ToolCategory["URL_FETCHER"] = "fetcher";
+    // MEDIUM RISK
+    ToolCategory["UNICODE_PROCESSOR"] = "unicode";
+    ToolCategory["JSON_PARSER"] = "parser";
+    ToolCategory["PACKAGE_INSTALLER"] = "installer";
+    ToolCategory["RUG_PULL"] = "rug_pull";
+    // LOW RISK (SAFE)
+    ToolCategory["SAFE_STORAGE"] = "safe_storage";
+    ToolCategory["API_WRAPPER"] = "api_wrapper";
+    ToolCategory["SEARCH_RETRIEVAL"] = "search_retrieval";
+    ToolCategory["CRUD_CREATION"] = "crud_creation";
+    ToolCategory["READ_ONLY_INFO"] = "read_only_info";
+    // DEFAULT
+    ToolCategory["GENERIC"] = "generic";
+})(ToolCategory || (ToolCategory = {}));
+/**
+ * Complete pattern configuration for all tool categories.
+ * Patterns are pre-compiled as static constants for performance.
+ *
+ * ## Pattern Types
+ *
+ * 1. **Substring patterns** (`/keyword/i`): Match anywhere in text
+ *    - Used for HIGH-risk keywords that warrant scrutiny even when embedded
+ *
+ * 2. **Word boundary patterns** (`/\bword\b/i`): Match isolated words only
+ *    - Used for common words to prevent false positives
+ *    - Note: `\b` treats hyphens as boundaries but underscores as word chars
+ */
+export const CATEGORY_PATTERNS = {
+    // ============================================================================
+    // HIGH RISK CATEGORIES
+    // ============================================================================
+    [ToolCategory.CALCULATOR]: {
+        patterns: [
+            /calculator/i,
+            /compute/i,
+            /math/i,
+            /calc/i,
+            /eval/i,
+            /arithmetic/i,
+            /expression/i,
+        ],
+        confidence: 90,
+        reasoning: "Calculator pattern detected (arithmetic execution risk)",
+        risk: "HIGH",
+    },
+    [ToolCategory.SYSTEM_EXEC]: {
+        patterns: [
+            /system.*exec/i,
+            /exec.*tool/i,
+            /command/i,
+            /shell/i,
+            /\brun\b/i,
+            /execute/i,
+            /process/i,
+        ],
+        confidence: 95,
+        reasoning: "System execution pattern detected (command injection risk)",
+        risk: "HIGH",
+    },
+    [ToolCategory.CODE_EXECUTOR]: {
+        patterns: [
+            /execute.*code/i,
+            /run.*code/i,
+            /code.*execut/i,
+            /run.*script/i,
+            /exec.*script/i,
+            /\bpython.*code\b/i,
+            /\bjavascript.*code\b/i,
+            /\bjs.*code\b/i,
+            /\beval.*code\b/i,
+            /code.*runner/i,
+            /script.*runner/i,
+            /\bexec\b.*\b(python|js|javascript)\b/i,
+            /\b(python|js|javascript)\b.*\bexec\b/i,
+            /interpret/i,
+            /\brepl\b/i,
+        ],
+        confidence: 95,
+        reasoning: "Code executor pattern detected (arbitrary code execution risk)",
+        risk: "HIGH",
+    },
+    [ToolCategory.DATA_ACCESS]: {
+        patterns: [
+            /leak/i,
+            /\bdata\b/i,
+            /show/i,
+            /\bget\b/i,
+            /\blist\b/i,
+            /display/i,
+            /\benv/i,
+            /secret/i,
+            /\bkey\b/i,
+            /credential/i,
+            /exfiltrat/i,
+        ],
+        confidence: 85,
+        reasoning: "Data access pattern detected (data exfiltration risk)",
+        risk: "HIGH",
+    },
+    [ToolCategory.TOOL_OVERRIDE]: {
+        patterns: [
+            /override/i,
+            /shadow/i,
+            /poison/i,
+            /create.*tool/i,
+            /register.*tool/i,
+            /define.*tool/i,
+            /tool.*creator/i,
+            /add.*tool/i,
+        ],
+        confidence: 92,
+        reasoning: "Tool override pattern detected (shadowing/poisoning risk)",
+        risk: "HIGH",
+    },
+    [ToolCategory.CONFIG_MODIFIER]: {
+        patterns: [
+            /config/i,
+            /setting/i,
+            /modifier/i,
+            /\badmin\b/i,
+            /privilege/i,
+            /permission/i,
+            /configure/i,
+            /drift/i,
+        ],
+        confidence: 88,
+        reasoning: "Config modification pattern detected (configuration drift risk)",
+        risk: "HIGH",
+    },
+    [ToolCategory.URL_FETCHER]: {
+        patterns: [
+            /fetch/i,
+            /\burl\b/i,
+            /http/i,
+            /download/i,
+            /load/i,
+            /retrieve/i,
+            /\bget\b.*url/i,
+            /external/i,
+        ],
+        confidence: 87,
+        reasoning: "URL fetcher pattern detected (indirect prompt injection risk)",
+        risk: "HIGH",
+    },
+    // ============================================================================
+    // MEDIUM RISK CATEGORIES
+    // ============================================================================
+    [ToolCategory.UNICODE_PROCESSOR]: {
+        patterns: [
+            /unicode/i,
+            /encode/i,
+            /decode/i,
+            /charset/i,
+            /utf/i,
+            /hex/i,
+            /escape/i,
+        ],
+        confidence: 75,
+        reasoning: "Unicode processor pattern detected (bypass encoding risk)",
+        risk: "MEDIUM",
+    },
+    [ToolCategory.JSON_PARSER]: {
+        patterns: [
+            /parser/i,
+            /parse/i,
+            /json/i,
+            /xml/i,
+            /yaml/i,
+            /nested/i,
+            /deserialize/i,
+            /unmarshal/i,
+        ],
+        confidence: 78,
+        reasoning: "JSON/nested parser pattern detected (nested injection risk)",
+        risk: "MEDIUM",
+    },
+    [ToolCategory.PACKAGE_INSTALLER]: {
+        patterns: [
+            /install/i,
+            /package/i,
+            /\bnpm\b/i,
+            /\bpip\b/i,
+            /dependency/i,
+            /module/i,
+            /library/i,
+            /\bgem\b/i,
+        ],
+        confidence: 70,
+        reasoning: "Package installer pattern detected (typosquatting risk)",
+        risk: "MEDIUM",
+    },
+    [ToolCategory.RUG_PULL]: {
+        patterns: [
+            /rug.*pull/i,
+            /trust/i,
+            /behavior.*change/i,
+            /malicious.*after/i,
+            /invocation.*count/i,
+        ],
+        confidence: 80,
+        reasoning: "Rug pull pattern detected (behavioral change risk)",
+        risk: "MEDIUM",
+    },
+    // ============================================================================
+    // LOW RISK (SAFE) CATEGORIES
+    // ============================================================================
+    [ToolCategory.API_WRAPPER]: {
+        patterns: [
+            /firecrawl/i,
+            /\bscrape\b/i,
+            /\bcrawl\b/i,
+            /web.*scraping/i,
+            /api.*wrapper/i,
+            /http.*client/i,
+            /web.*client/i,
+            /rest.*client/i,
+            /graphql.*client/i,
+            /fetch.*web.*content/i,
+        ],
+        confidence: 95,
+        reasoning: "API wrapper pattern detected (safe data passing, not code execution)",
+        risk: "LOW",
+    },
+    [ToolCategory.SEARCH_RETRIEVAL]: {
+        patterns: [
+            /\bsearch\b/i,
+            /\bfind\b/i,
+            /\blookup\b/i,
+            /\bquery\b/i,
+            /retrieve/i,
+            /\blist\b/i,
+            /get.*users/i,
+            /get.*pages/i,
+            /get.*database/i,
+        ],
+        confidence: 93,
+        reasoning: "Search/retrieval pattern detected (returns data, not code execution)",
+        risk: "LOW",
+    },
+    [ToolCategory.CRUD_CREATION]: {
+        patterns: [
+            /\bcreate\b/i,
+            /\badd\b/i,
+            /\binsert\b/i,
+            /\bupdate\b/i,
+            /\bmodify\b/i,
+            /\bdelete\b/i,
+            /\bduplicate\b/i,
+            /\bmove\b/i,
+            /\bappend\b/i,
+        ],
+        confidence: 92,
+        reasoning: "CRUD operation pattern detected (data manipulation, not code execution)",
+        risk: "LOW",
+    },
+    [ToolCategory.READ_ONLY_INFO]: {
+        patterns: [
+            /get.*self/i,
+            /get.*teams/i,
+            /get.*info/i,
+            /get.*status/i,
+            /\bwhoami\b/i,
+            /get.*workspace/i,
+            /get.*user/i,
+            /current.*user/i,
+        ],
+        confidence: 94,
+        reasoning: "Read-only info pattern detected (intended data exposure, not vulnerability)",
+        risk: "LOW",
+    },
+    [ToolCategory.SAFE_STORAGE]: {
+        patterns: [
+            /safe.*storage/i,
+            /safe.*search/i,
+            /safe.*list/i,
+            /safe.*info/i,
+            /safe.*echo/i,
+            /safe.*validate/i,
+            /safe.*tool/i,
+        ],
+        confidence: 99,
+        reasoning: "Safe tool pattern detected (control group - should be safe)",
+        risk: "LOW",
+    },
+};
+/**
+ * Default configuration for GENERIC category (no pattern match)
+ */
+export const GENERIC_CONFIG = {
+    confidence: 50,
+    reasoning: "No specific pattern match, using generic tests",
+    risk: "LOW",
+};
+/**
+ * Order in which categories are checked during classification.
+ * This order determines priority when a tool matches multiple categories.
+ */
+export const CATEGORY_CHECK_ORDER = [
+    // HIGH risk first
+    ToolCategory.CALCULATOR,
+    ToolCategory.SYSTEM_EXEC,
+    ToolCategory.CODE_EXECUTOR,
+    ToolCategory.DATA_ACCESS,
+    ToolCategory.TOOL_OVERRIDE,
+    ToolCategory.CONFIG_MODIFIER,
+    ToolCategory.URL_FETCHER,
+    // MEDIUM risk
+    ToolCategory.UNICODE_PROCESSOR,
+    ToolCategory.JSON_PARSER,
+    ToolCategory.PACKAGE_INSTALLER,
+    ToolCategory.RUG_PULL,
+    // LOW risk (SAFE)
+    ToolCategory.API_WRAPPER,
+    ToolCategory.SEARCH_RETRIEVAL,
+    ToolCategory.CRUD_CREATION,
+    ToolCategory.READ_ONLY_INFO,
+    ToolCategory.SAFE_STORAGE,
+];

package/package.json

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