@bryan-thompson/inspector-assessment-client 1.27.0 → 1.29.0

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

@@ -0,0 +1,475 @@
+/**
+ * File Modularization Assessor (Issue #104)
+ * Detects large monolithic tool files and recommends modularization
+ *
+ * Checks:
+ * - Single file >1,000 lines (WARNING, MEDIUM severity)
+ * - Single file >2,000 lines (ERROR, HIGH severity)
+ * - Tool file with >10 tools (WARNING, MEDIUM severity)
+ * - Tool file with >20 tools (ERROR, HIGH severity)
+ * - No modular structure (INFO, LOW severity)
+ *
+ * Scoring:
+ * - Starts at 100 points
+ * - -15 per file >2,000 lines
+ * - -8 per file 1,000-2,000 lines
+ * - -12 per file with >20 tools
+ * - -6 per file with 10-20 tools
+ * - -10 for no modular structure
+ * - +5 for tools/ subdirectory
+ * - +3 for multiple tool files (>3)
+ */
+import { BaseAssessor } from "./BaseAssessor.js";
+/**
+ * Tool detection patterns by language
+ */
+const TOOL_PATTERNS = {
+    python: [
+        /@mcp\.tool/g, // FastMCP decorator
+        /(?<!async\s)def\s+\w+_tool\s*\(/g, // Convention: *_tool functions (not async)
+        /async\s+def\s+\w+_tool\s*\(/g, // Async tool functions
+        /@server\.tool/g, // MCP server decorator
+        /@app\.tool/g, // Alternative app-based decorator
+    ],
+    typescript: [
+        /server\.tool\s*\(/g, // MCP SDK tool registration
+        /\.setRequestHandler\s*\(/g, // Request handler pattern
+        /tools\.push\s*\(/g, // Array-based registration
+        /registerTool\s*\(/g, // Common pattern
+        /\.addTool\s*\(/g, // Add tool pattern
+    ],
+    javascript: [
+        /server\.tool\s*\(/g,
+        /\.setRequestHandler\s*\(/g,
+        /tools\.push\s*\(/g,
+        /registerTool\s*\(/g,
+        /\.addTool\s*\(/g,
+    ],
+    go: [
+        /func\s+\w*Tool\s*\(/g, // Go tool functions
+        /mcp\.NewTool\s*\(/g, // MCP Go SDK
+        /tools\.Register\s*\(/g, // Tool registration
+    ],
+    rust: [
+        /fn\s+\w+_tool\s*\(/g, // Rust tool functions
+        /#\[tool\]/g, // Attribute macro
+        /\.register_tool\s*\(/g, // Registration pattern
+    ],
+};
+/**
+ * File extension to language mapping
+ */
+const EXTENSION_TO_LANGUAGE = {
+    ".py": "python",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".go": "go",
+    ".rs": "rust",
+};
+/**
+ * Thresholds for modularization checks
+ */
+const THRESHOLDS = {
+    LINE_WARNING: 1000,
+    LINE_ERROR: 2000,
+    TOOL_COUNT_WARNING: 10,
+    TOOL_COUNT_ERROR: 20,
+};
+export class FileModularizationAssessor extends BaseAssessor {
+    /**
+     * Run file modularization assessment
+     */
+    async assess(context) {
+        this.logger.info("Starting file modularization assessment");
+        this.testCount = 0;
+        // Check if source code analysis is enabled
+        if (!context.sourceCodeFiles || !context.config.enableSourceCodeAnalysis) {
+            this.logger.info("Source code analysis not enabled, returning NEED_MORE_INFO");
+            return this.createSkippedResult();
+        }
+        // Analyze each source file
+        const fileAnalyses = this.analyzeFiles(context.sourceCodeFiles);
+        // Calculate metrics
+        const metrics = this.calculateMetrics(fileAnalyses);
+        // Run checks against thresholds
+        const checks = this.runChecks(metrics, fileAnalyses);
+        // Determine status based on checks
+        const status = this.determineStatusFromChecks(checks);
+        // Generate explanation and recommendations
+        const explanation = this.generateExplanation(metrics, checks);
+        const recommendations = this.generateRecommendations(metrics, fileAnalyses);
+        this.logger.info(`Assessment complete: score=${metrics.modularizationScore}, status=${status}`);
+        return {
+            metrics,
+            checks,
+            status,
+            explanation,
+            recommendations,
+        };
+    }
+    /**
+     * Create result when source code is not available
+     */
+    createSkippedResult() {
+        return {
+            metrics: {
+                totalSourceFiles: 0,
+                totalLines: 0,
+                largestFiles: [],
+                filesOver1000Lines: 0,
+                filesOver2000Lines: 0,
+                filesWithOver10Tools: 0,
+                filesWithOver20Tools: 0,
+                hasModularStructure: false,
+                modularizationScore: 0,
+            },
+            checks: [],
+            status: "NEED_MORE_INFO",
+            explanation: "Source code analysis not enabled. Enable enableSourceCodeAnalysis in config to run file modularization checks.",
+            recommendations: [
+                "Enable source code analysis by setting enableSourceCodeAnalysis: true in assessment config",
+                "Provide sourceCodePath in assessment context to analyze file structure",
+            ],
+        };
+    }
+    /**
+     * Analyze all source files
+     */
+    analyzeFiles(sourceCodeFiles) {
+        const analyses = new Map();
+        for (const [filePath, content] of sourceCodeFiles) {
+            if (!this.isSourceFile(filePath)) {
+                continue;
+            }
+            this.testCount++;
+            const lines = content.split("\n").length;
+            const language = this.detectLanguage(filePath);
+            const toolCount = this.countToolsInFile(content, language);
+            analyses.set(filePath, { lines, toolCount, language });
+        }
+        return analyses;
+    }
+    /**
+     * Check if file is a source file worth scanning
+     */
+    isSourceFile(filePath) {
+        const sourceExtensions = Object.keys(EXTENSION_TO_LANGUAGE);
+        // Skip test files, node_modules, and build artifacts
+        // Check for paths containing these directories or starting with them
+        if (filePath.includes("node_modules") ||
+            filePath.includes(".test.") ||
+            filePath.includes(".spec.") ||
+            filePath.includes("__tests__") ||
+            filePath.includes("__pycache__") ||
+            filePath.includes("/dist/") ||
+            filePath.includes("/build/") ||
+            filePath.includes("/.venv/") ||
+            filePath.includes("/venv/") ||
+            filePath.startsWith("dist/") ||
+            filePath.startsWith("build/") ||
+            filePath.startsWith(".venv/") ||
+            filePath.startsWith("venv/")) {
+            return false;
+        }
+        return sourceExtensions.some((ext) => filePath.endsWith(ext));
+    }
+    /**
+     * Detect language from file extension
+     */
+    detectLanguage(filePath) {
+        for (const [ext, lang] of Object.entries(EXTENSION_TO_LANGUAGE)) {
+            if (filePath.endsWith(ext)) {
+                return lang;
+            }
+        }
+        return null;
+    }
+    /**
+     * Count tool definitions in a file
+     */
+    countToolsInFile(content, language) {
+        if (!language)
+            return 0;
+        const patterns = TOOL_PATTERNS[language] || [];
+        let count = 0;
+        for (const pattern of patterns) {
+            // Reset lastIndex since we're using global flags
+            pattern.lastIndex = 0;
+            const matches = content.match(pattern);
+            if (matches) {
+                count += matches.length;
+            }
+        }
+        return count;
+    }
+    /**
+     * Calculate aggregated metrics
+     */
+    calculateMetrics(fileAnalyses) {
+        const largestFiles = [];
+        let totalLines = 0;
+        let filesOver1000Lines = 0;
+        let filesOver2000Lines = 0;
+        let filesWithOver10Tools = 0;
+        let filesWithOver20Tools = 0;
+        for (const [filePath, analysis] of fileAnalyses) {
+            totalLines += analysis.lines;
+            // Check line count thresholds
+            if (analysis.lines > THRESHOLDS.LINE_ERROR) {
+                filesOver2000Lines++;
+                filesOver1000Lines++; // Also counts for 1000+ threshold
+            }
+            else if (analysis.lines > THRESHOLDS.LINE_WARNING) {
+                filesOver1000Lines++;
+            }
+            // Check tool count thresholds
+            if (analysis.toolCount > THRESHOLDS.TOOL_COUNT_ERROR) {
+                filesWithOver20Tools++;
+                filesWithOver10Tools++; // Also counts for 10+ threshold
+            }
+            else if (analysis.toolCount > THRESHOLDS.TOOL_COUNT_WARNING) {
+                filesWithOver10Tools++;
+            }
+            // Track large files for reporting
+            if (analysis.lines > THRESHOLDS.LINE_WARNING ||
+                analysis.toolCount > THRESHOLDS.TOOL_COUNT_WARNING) {
+                const severity = this.determineSeverity(analysis.lines, analysis.toolCount);
+                const recommendation = this.generateFileRecommendation(filePath, analysis.lines, analysis.toolCount);
+                largestFiles.push({
+                    path: filePath,
+                    lines: analysis.lines,
+                    toolCount: analysis.toolCount,
+                    severity,
+                    recommendation,
+                });
+            }
+        }
+        // Sort by lines descending
+        largestFiles.sort((a, b) => b.lines - a.lines);
+        // Check for modular structure
+        const hasModularStructure = this.checkModularStructure(fileAnalyses);
+        // Calculate modularization score
+        const modularizationScore = this.calculateScore(filesOver1000Lines, filesOver2000Lines, filesWithOver10Tools, filesWithOver20Tools, hasModularStructure, fileAnalyses);
+        return {
+            totalSourceFiles: fileAnalyses.size,
+            totalLines,
+            largestFiles,
+            filesOver1000Lines,
+            filesOver2000Lines,
+            filesWithOver10Tools,
+            filesWithOver20Tools,
+            hasModularStructure,
+            modularizationScore,
+        };
+    }
+    /**
+     * Determine severity for a file
+     */
+    determineSeverity(lines, toolCount) {
+        // HIGH if either threshold is exceeded at error level
+        if (lines > THRESHOLDS.LINE_ERROR ||
+            toolCount > THRESHOLDS.TOOL_COUNT_ERROR) {
+            return "HIGH";
+        }
+        // MEDIUM if warning thresholds are exceeded
+        if (lines > THRESHOLDS.LINE_WARNING ||
+            toolCount > THRESHOLDS.TOOL_COUNT_WARNING) {
+            return "MEDIUM";
+        }
+        return "LOW";
+    }
+    /**
+     * Generate recommendation for a specific file
+     */
+    generateFileRecommendation(filePath, lines, toolCount) {
+        const fileName = filePath.split("/").pop() || filePath;
+        const parts = [];
+        if (lines > THRESHOLDS.LINE_ERROR) {
+            parts.push(`Split ${fileName} (${lines} lines) into smaller modules of <500 lines each`);
+        }
+        else if (lines > THRESHOLDS.LINE_WARNING) {
+            parts.push(`Consider splitting ${fileName} (${lines} lines) to improve maintainability`);
+        }
+        if (toolCount > THRESHOLDS.TOOL_COUNT_ERROR) {
+            parts.push(`Separate ${toolCount} tools into category-based modules (e.g., tools/auth/, tools/data/)`);
+        }
+        else if (toolCount > THRESHOLDS.TOOL_COUNT_WARNING) {
+            parts.push(`Consider grouping ${toolCount} tools into logical categories`);
+        }
+        return parts.join(". ");
+    }
+    /**
+     * Check if codebase has modular structure
+     */
+    checkModularStructure(fileAnalyses) {
+        const filePaths = Array.from(fileAnalyses.keys());
+        // Check for tools/ subdirectory pattern
+        const hasToolsDir = filePaths.some((f) => f.includes("/tools/") || f.includes("\\tools\\"));
+        // Check for multiple tool files (not all tools in one file)
+        const toolFiles = Array.from(fileAnalyses.entries()).filter(([, analysis]) => analysis.toolCount > 0);
+        // Has modular structure if: has tools/ dir OR has 3+ tool files
+        return hasToolsDir || toolFiles.length >= 3;
+    }
+    /**
+     * Calculate modularization score (0-100)
+     */
+    calculateScore(filesOver1000Lines, filesOver2000Lines, filesWithOver10Tools, filesWithOver20Tools, hasModularStructure, fileAnalyses) {
+        let score = 100;
+        // Deductions
+        score -= filesOver2000Lines * 15; // -15 per file >2000 lines
+        score -= (filesOver1000Lines - filesOver2000Lines) * 8; // -8 per file 1000-2000 lines
+        score -= filesWithOver20Tools * 12; // -12 per file with >20 tools
+        score -= (filesWithOver10Tools - filesWithOver20Tools) * 6; // -6 per file 10-20 tools
+        if (!hasModularStructure) {
+            score -= 10; // -10 for no modular structure
+        }
+        // Positive signals (bonuses)
+        const filePaths = Array.from(fileAnalyses.keys());
+        const hasToolsDir = filePaths.some((f) => f.includes("/tools/") || f.includes("\\tools\\"));
+        const hasSharedUtils = filePaths.some((f) => f.includes("_common.") ||
+            f.includes("shared.") ||
+            f.includes("utils.") ||
+            f.includes("helpers."));
+        const toolFilesCount = Array.from(fileAnalyses.values()).filter((a) => a.toolCount > 0).length;
+        if (hasToolsDir)
+            score += 5; // +5 for tools/ subdirectory
+        if (toolFilesCount > 3)
+            score += 3; // +3 for multiple tool files
+        if (hasSharedUtils)
+            score += 2; // +2 for shared utilities
+        // Clamp to 0-100
+        return Math.max(0, Math.min(100, score));
+    }
+    /**
+     * Run threshold checks
+     */
+    runChecks(metrics, _fileAnalyses) {
+        const checks = [];
+        // Check 1: Files over 2000 lines (HIGH severity)
+        checks.push({
+            checkName: "file_line_count_error",
+            passed: metrics.filesOver2000Lines === 0,
+            severity: "HIGH",
+            evidence: metrics.filesOver2000Lines > 0
+                ? `${metrics.filesOver2000Lines} file(s) exceed 2000 lines`
+                : "No files exceed 2000 lines",
+            threshold: THRESHOLDS.LINE_ERROR,
+            actualValue: metrics.filesOver2000Lines,
+        });
+        // Check 2: Files over 1000 lines (MEDIUM severity)
+        const filesOnlyOver1000 = metrics.filesOver1000Lines - metrics.filesOver2000Lines;
+        checks.push({
+            checkName: "file_line_count_warning",
+            passed: filesOnlyOver1000 === 0,
+            severity: "MEDIUM",
+            evidence: filesOnlyOver1000 > 0
+                ? `${filesOnlyOver1000} file(s) exceed 1000 lines`
+                : "No additional files exceed 1000 lines",
+            threshold: THRESHOLDS.LINE_WARNING,
+            actualValue: filesOnlyOver1000,
+        });
+        // Check 3: Files with >20 tools (HIGH severity)
+        checks.push({
+            checkName: "tool_count_error",
+            passed: metrics.filesWithOver20Tools === 0,
+            severity: "HIGH",
+            evidence: metrics.filesWithOver20Tools > 0
+                ? `${metrics.filesWithOver20Tools} file(s) contain more than 20 tools`
+                : "No files contain more than 20 tools",
+            threshold: THRESHOLDS.TOOL_COUNT_ERROR,
+            actualValue: metrics.filesWithOver20Tools,
+        });
+        // Check 4: Files with >10 tools (MEDIUM severity)
+        const filesOnlyOver10Tools = metrics.filesWithOver10Tools - metrics.filesWithOver20Tools;
+        checks.push({
+            checkName: "tool_count_warning",
+            passed: filesOnlyOver10Tools === 0,
+            severity: "MEDIUM",
+            evidence: filesOnlyOver10Tools > 0
+                ? `${filesOnlyOver10Tools} file(s) contain more than 10 tools`
+                : "No additional files contain more than 10 tools",
+            threshold: THRESHOLDS.TOOL_COUNT_WARNING,
+            actualValue: filesOnlyOver10Tools,
+        });
+        // Check 5: Modular structure (LOW severity, info)
+        checks.push({
+            checkName: "modular_structure",
+            passed: metrics.hasModularStructure,
+            severity: "LOW",
+            evidence: metrics.hasModularStructure
+                ? "Codebase has modular structure (tools/ directory or multiple tool files)"
+                : "No modular structure detected - all tools appear to be in single file",
+        });
+        return checks;
+    }
+    /**
+     * Determine status from checks
+     */
+    determineStatusFromChecks(checks) {
+        // FAIL if any HIGH severity check fails
+        const highSeverityFailed = checks.some((c) => !c.passed && c.severity === "HIGH");
+        if (highSeverityFailed) {
+            return "FAIL";
+        }
+        // NEED_MORE_INFO if any MEDIUM severity check fails
+        const mediumSeverityFailed = checks.some((c) => !c.passed && c.severity === "MEDIUM");
+        if (mediumSeverityFailed) {
+            return "NEED_MORE_INFO";
+        }
+        return "PASS";
+    }
+    /**
+     * Generate explanation
+     */
+    generateExplanation(metrics, checks) {
+        const parts = [];
+        parts.push(`Analyzed ${metrics.totalSourceFiles} source files (${metrics.totalLines} total lines).`);
+        parts.push(`Modularization score: ${metrics.modularizationScore}/100.`);
+        const failedChecks = checks.filter((c) => !c.passed);
+        if (failedChecks.length === 0) {
+            parts.push("All modularization checks passed. Code structure appears well-organized.");
+        }
+        else {
+            const highFailed = failedChecks.filter((c) => c.severity === "HIGH");
+            const mediumFailed = failedChecks.filter((c) => c.severity === "MEDIUM");
+            if (highFailed.length > 0) {
+                parts.push(`ERROR: ${highFailed.length} high-severity issue(s) - files are too large or contain too many tools.`);
+            }
+            if (mediumFailed.length > 0) {
+                parts.push(`WARNING: ${mediumFailed.length} medium-severity issue(s) - consider refactoring for better maintainability.`);
+            }
+        }
+        return parts.join(" ");
+    }
+    /**
+     * Generate recommendations
+     */
+    generateRecommendations(metrics, _fileAnalyses) {
+        const recommendations = [];
+        // Add specific file recommendations
+        for (const file of metrics.largestFiles) {
+            if (file.severity === "HIGH") {
+                recommendations.push(`HIGH: ${file.recommendation}`);
+            }
+        }
+        // Add general recommendations based on checks
+        if (metrics.filesOver2000Lines > 0) {
+            recommendations.push("Split large files (>2000 lines) into smaller modules to improve maintainability and IDE performance.");
+        }
+        if (metrics.filesWithOver20Tools > 0) {
+            recommendations.push("Group tools by category (e.g., auth tools, data tools, utility tools) into separate modules.");
+        }
+        if (!metrics.hasModularStructure) {
+            recommendations.push("Create a tools/ subdirectory to organize tool implementations by category.");
+            recommendations.push("Extract shared utilities into a common module (e.g., _common.py, shared.ts).");
+        }
+        if (recommendations.length === 0) {
+            recommendations.push("Code structure is well-modularized. Continue following current patterns.");
+        }
+        return recommendations;
+    }
+}

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

@@ -5,151 +5,27 @@
  *
  * This addresses a critical gap: standard assessments call tools with many different
  * payloads but never call the same tool repeatedly with identical payloads.
+ *
+ * Refactored in Issue #106 to extract MutationDetector and VarianceClassifier
+ * into focused helper modules for maintainability.
  */
 import { AssessmentConfiguration, TemporalAssessment } from "../../../lib/assessmentTypes.js";
 import { AssessmentContext } from "../AssessmentOrchestrator.js";
 import { BaseAssessor } from "./BaseAssessor.js";
 export declare class TemporalAssessor extends BaseAssessor {
     private invocationsPerTool;
-    private readonly DESTRUCTIVE_PATTERNS;
+    private mutationDetector;
+    private varianceClassifier;
     private readonly PER_INVOCATION_TIMEOUT;
-    /**
-     * Tool name patterns that are expected to have state-dependent responses.
-     * These tools legitimately return different results based on data state,
-     * which is NOT a rug pull vulnerability.
-     *
-     * Includes both:
-     * - READ operations: search, list, query return more results after data stored
-     * - ACCUMULATION operations: add, append, store return accumulated state (counts, IDs)
-     *
-     * NOTE: Does NOT include patterns already in DESTRUCTIVE_PATTERNS (create, write,
-     * insert, etc.) - those need strict comparison to detect real rug pulls.
-     *
-     * Uses word-boundary matching to prevent false matches.
-     * "add_observations" matches "add" but "address_validator" does not.
-     */
-    private readonly STATEFUL_TOOL_PATTERNS;
-    /**
-     * Issue #69: Patterns for resource-creating operations that legitimately return
-     * different IDs/resources each invocation.
-     *
-     * These tools CREATE new resources, so they should use schema comparison + variance
-     * classification rather than exact comparison. Unlike STATEFUL_TOOL_PATTERNS, these
-     * may overlap with DESTRUCTIVE_PATTERNS (e.g., "create", "insert") but should still
-     * use intelligent variance classification to avoid false positives.
-     *
-     * Examples:
-     * - create_billing_product → new product_id each time (LEGITIMATE variance)
-     * - generate_report → new report_id each time (LEGITIMATE variance)
-     * - insert_record → new record_id each time (LEGITIMATE variance)
-     */
-    private readonly RESOURCE_CREATING_PATTERNS;
     constructor(config: AssessmentConfiguration);
     assess(context: AssessmentContext): Promise<TemporalAssessment>;
     private assessTool;
-    /**
-     * Detect mutations in tool definition across invocation snapshots.
-     * DVMCP Challenge 4: Tool descriptions that mutate after N calls.
-     */
-    private detectDefinitionMutation;
     private analyzeResponses;
     /**
      * Generate a safe/neutral payload for a tool based on its input schema.
      * Only populates required parameters with minimal test values.
      */
     private generateSafePayload;
-    /**
-     * Normalize response for comparison by removing naturally varying data.
-     * Prevents false positives from timestamps, UUIDs, request IDs, counters, etc.
-     * Handles both direct JSON and nested JSON strings (e.g., content[].text).
-     */
-    private normalizeResponse;
-    /**
-     * Detect if a tool may have side effects based on naming patterns.
-     */
-    private isDestructiveTool;
-    /**
-     * Check if a tool is expected to have state-dependent behavior.
-     * Stateful tools (search, list, add, store, etc.) legitimately return different
-     * results as underlying data changes - this is NOT a rug pull.
-     *
-     * Uses word-boundary matching to prevent false positives:
-     * - "add_observations" matches "add" ✓
-     * - "address_validator" does NOT match "add" ✓
-     */
-    private isStatefulTool;
-    /**
-     * Issue #69: Check if a tool creates new resources that legitimately vary per invocation.
-     * Resource-creating tools return different IDs, creation timestamps, etc.
-     * for each new resource - this is expected behavior, NOT a rug pull.
-     *
-     * Unlike isStatefulTool(), this DOES include patterns that overlap with DESTRUCTIVE_PATTERNS
-     * because resource-creating tools need intelligent variance classification, not exact comparison.
-     *
-     * Uses word-boundary matching like isStatefulTool() to prevent false matches.
-     * - "create_billing_product" matches "create" ✓
-     * - "recreate_view" does NOT match "create" ✓ (must be at word boundary)
-     */
-    private isResourceCreatingTool;
-    /**
-     * Issue #69: Classify variance between two responses to reduce false positives.
-     * Returns LEGITIMATE for expected variance (IDs, timestamps), SUSPICIOUS for
-     * schema changes, and BEHAVIORAL for semantic changes (promotional keywords, errors).
-     */
-    private classifyVariance;
-    /**
-     * Issue #69: Check if a field name represents legitimate variance.
-     * Fields containing IDs, timestamps, tokens, etc. are expected to vary.
-     */
-    private isLegitimateFieldVariance;
-    /**
-     * Issue #69: Find which fields differ between two responses.
-     * Returns field paths that have different values.
-     */
-    private findVariedFields;
-    /**
-     * Compare response schemas (field names) rather than full content.
-     * Stateful tools may have different values but should have consistent fields.
-     *
-     * For stateful tools, allows schema growth (empty arrays → populated arrays)
-     * but flags when baseline fields disappear (suspicious behavior).
-     */
-    private compareSchemas;
-    /**
-     * Extract all field names from an object recursively.
-     * Handles arrays by sampling multiple elements to detect heterogeneous schemas.
-     */
-    private extractFieldNames;
-    /**
-     * Secondary detection for stateful tools that pass schema comparison.
-     * Catches rug pulls that change content semantically while keeping schema intact.
-     *
-     * Examples detected:
-     * - Weather data → "Rate limit exceeded, upgrade to premium"
-     * - Stock prices → "Subscribe for $9.99/month to continue"
-     * - Search results → "Error: Service unavailable"
-     */
-    private detectStatefulContentChange;
-    /**
-     * Extract text content from a response for semantic analysis.
-     */
-    private extractTextContent;
-    /**
-     * Check for error-related keywords that indicate service degradation.
-     */
-    private hasErrorKeywords;
-    /**
-     * Check for promotional/monetization keywords that indicate a monetization rug pull.
-     * Enhanced to catch CH4-style rug pulls with limited-time offers, referral codes, etc.
-     *
-     * Combined into single regex for O(text_length) performance instead of O(18 * text_length).
-     */
-    private hasPromotionalKeywords;
-    /**
-     * Check for suspicious URL/link injection that wasn't present initially.
-     * Rug pulls often inject links to external malicious or monetization pages.
-     */
-    private hasSuspiciousLinks;
     private determineTemporalStatus;
     private generateExplanation;
     private generateRecommendations;

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

@@ -1 +1 @@
-{"version":3,"file":"TemporalAssessor.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/modules/TemporalAssessor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACL,uBAAuB,EAEvB,kBAAkB,EAGnB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AA+B9C,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,OAAO,CAAC,kBAAkB,CAAS;IAGnC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAoBnC;IAGF,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAU;IAEjD;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAqBrC;IAEF;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAYzC;gBAEU,MAAM,EAAE,uBAAuB;IAKrC,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;YAqEvD,UAAU;IAuHxB;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IAkChC,OAAO,CAAC,gBAAgB;IAwJxB;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAsC3B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAiFzB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAKzB;;;;;;;;OAQG;IACH,OAAO,CAAC,cAAc;IAetB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,sBAAsB;IAQ9B;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAmExB;;;OAGG;IACH,OAAO,CAAC,yBAAyB;IAgEjC;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IA2DxB;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAuBtB;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAiCzB;;;;;;;;OAQG;IACH,OAAO,CAAC,2BAA2B;IAmDnC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAM1B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAcxB;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAU9B;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAgB1B,OAAO,CAAC,uBAAuB;IAa/B,OAAO,CAAC,mBAAmB;IA+C3B,OAAO,CAAC,uBAAuB;CA+DhC"}
+{"version":3,"file":"TemporalAssessor.d.ts","sourceRoot":"","sources":["../../../../src/services/assessment/modules/TemporalAssessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,uBAAuB,EAEvB,kBAAkB,EAGnB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAiB9C,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,kBAAkB,CAAqB;IAG/C,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAU;gBAErC,MAAM,EAAE,uBAAuB;IAOrC,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;YAqEvD,UAAU;IAuHxB,OAAO,CAAC,gBAAgB;IA6JxB;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAsC3B,OAAO,CAAC,uBAAuB;IAa/B,OAAO,CAAC,mBAAmB;IA+C3B,OAAO,CAAC,uBAAuB;CA+DhC"}