@reftrixmcp/mcp-server 0.1.7 → 0.2.0

package/dist/services/project-context-analyzer.js

@@ -1,747 +0,0 @@
-"use strict";
-// SPDX-FileCopyrightText: 2026 TKMD and Reftrix Contributors
-// SPDX-License-Identifier: AGPL-3.0-only
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProjectContextAnalyzer = void 0;
-exports.getProjectContextAnalyzer = getProjectContextAnalyzer;
-exports.resetProjectContextAnalyzer = resetProjectContextAnalyzer;
-/**
- * ProjectContextAnalyzer Service
- *
- * Analyzes project patterns (design tokens, hooks, CSS classes)
- * and calculates adaptability scores for layout.search results.
- *
- * Purpose:
- * - Detect existing project patterns (STYLES, DESIGN_TOKENS constants)
- * - Identify custom hooks (useScrollAnimation, useGsap)
- * - Parse CSS framework patterns (TailwindCSS 4.1 @theme variables)
- * - Calculate adaptability scores for search results
- * - Generate integration hints for easier adoption
- *
- * Security (MCP-SEC-02):
- * - Path validation to prevent directory traversal attacks
- * - Allowed workspace restriction for local file access
- * - Blocked path patterns for sensitive directories
- * - Symlink escape detection
- *
- * @module services/project-context-analyzer
- */
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const logger_1 = require("../utils/logger");
-const path_security_1 = require("../utils/path-security");
-// =====================================================
-// Constants
-// =====================================================
-/** File extensions to scan */
-const SCANNABLE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".css"];
-/** Directories to skip */
-const SKIP_DIRECTORIES = ["node_modules", ".git", "dist", "build", ".next", "coverage"];
-/** Regex patterns */
-const PATTERNS = {
-    // Match const STYLES = { ... } or const DESIGN_TOKENS = { ... }
-    constStyles: /(?:export\s+)?const\s+(STYLES|DESIGN_TOKENS|THEME|COLORS|TOKENS)\s*=\s*\{/gi,
-    // Match color values (hex, rgb, rgba, oklch, hsl)
-    colorValue: /#[0-9a-fA-F]{3,8}|rgba?\([^)]+\)|oklch\([^)]+\)|hsla?\([^)]+\)/g,
-    // Match color properties in object
-    colorProperty: /['"]?([\w.-]+)['"]?\s*:\s*['"]?(#[0-9a-fA-F]{3,8}|rgba?\([^)]+\)|oklch\([^)]+\)|hsla?\([^)]+\))['"]?/g,
-    // Match hook exports
-    hookExport: /export\s+(?:function|const)\s+(use[A-Z]\w*)/g,
-    // Match @theme CSS variables
-    themeVariable: /--[\w-]+:\s*[^;]+;/g,
-    // Match @keyframes
-    keyframes: /@keyframes\s+([\w-]+)\s*\{/g,
-    // Match CSS class definitions
-    cssClass: /\.([\w-]+)\s*\{/g,
-    // Match TailwindCSS v4 import
-    tailwindImport: /@import\s+["']tailwindcss["']/,
-    // Match scroll animation patterns in HTML
-    scrollAnimation: /data-(?:scroll|animation)|animate-on-scroll|scroll-triggered|will-animate/i,
-    // Match 3D/complex animation patterns
-    complexAnimation: /perspective|rotateX|rotateY|rotateZ|transform3d|timeline|gsap/i,
-    // Match style attribute colors
-    styleColor: /(?:color|background(?:-color)?|border(?:-color)?)\s*:\s*([^;'"]+)/gi,
-};
-// =====================================================
-// ProjectContextAnalyzer
-// =====================================================
-/**
- * Service for analyzing project patterns and calculating adaptability scores
- */
-class ProjectContextAnalyzer {
-    patternCache = new Map();
-    /**
-     * Detect project patterns from the codebase
-     *
-     * Security (MCP-SEC-02):
-     * - Path validation before scanning
-     * - Allowed workspace restriction
-     * - Directory traversal prevention
-     *
-     * @param projectPath - Root path to scan
-     * @returns Detected project patterns
-     * @throws Error if path validation fails (security violation)
-     */
-    async detectProjectPatterns(projectPath) {
-        // Check cache first (use normalized path for cache key)
-        const cached = this.patternCache.get(projectPath);
-        if (cached) {
-            return cached;
-        }
-        const patterns = {
-            designTokens: { styles: [] },
-            hooks: [],
-            cssFramework: "unknown",
-            themeVariables: [],
-            animations: [],
-            utilityClasses: [],
-        };
-        // MCP-SEC-02: Validate project path before scanning
-        const validationResult = (0, path_security_1.validateProjectPath)(projectPath);
-        if (!validationResult.isValid) {
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.warn("[ProjectContextAnalyzer] Path validation failed", {
-                    projectPath,
-                    errorCode: validationResult.error?.code,
-                    errorMessage: validationResult.error?.message,
-                });
-            }
-            // Return empty patterns instead of scanning disallowed paths
-            // This is a security measure to prevent unauthorized filesystem access
-            return patterns;
-        }
-        // Use validated/normalized path for scanning
-        const normalizedPath = validationResult.normalizedPath;
-        if (!fs.existsSync(normalizedPath)) {
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.warn("[ProjectContextAnalyzer] Project path does not exist", {
-                    projectPath: normalizedPath,
-                });
-            }
-            return patterns;
-        }
-        try {
-            // Scan for patterns using validated path
-            await this.scanDirectory(normalizedPath, patterns, 0, normalizedPath);
-            // Cache results with original path as key
-            this.patternCache.set(projectPath, patterns);
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.info("[ProjectContextAnalyzer] Patterns detected", {
-                    styles: patterns.designTokens.styles.length,
-                    hooks: patterns.hooks.length,
-                    cssFramework: patterns.cssFramework,
-                    themeVariables: patterns.themeVariables.length,
-                    animations: patterns.animations.length,
-                    utilityClasses: patterns.utilityClasses.length,
-                });
-            }
-        }
-        catch (error) {
-            if ((0, logger_1.isDevelopment)()) {
-                logger_1.logger.error("[ProjectContextAnalyzer] Error detecting patterns", {
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-        return patterns;
-    }
-    /**
-     * Scan directory for patterns
-     *
-     * Security (MCP-SEC-02):
-     * - Validates each file path before reading
-     * - Blocks access to sensitive file patterns
-     * - Ensures paths stay within workspace boundary
-     *
-     * @param dirPath - Directory to scan
-     * @param patterns - Patterns object to populate
-     * @param depth - Current recursion depth (max: 5)
-     * @param workspacePath - Root workspace path for validation
-     */
-    async scanDirectory(dirPath, patterns, depth = 0, workspacePath) {
-        // Limit recursion depth
-        if (depth > 5)
-            return;
-        // MCP-SEC-02: Ensure workspace path is set
-        const validatedWorkspace = workspacePath ?? dirPath;
-        try {
-            const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-            for (const entry of entries) {
-                const entryName = typeof entry === "string" ? entry : (entry.name ?? "");
-                // Skip hidden and excluded directories
-                if (SKIP_DIRECTORIES.includes(entryName) || entryName.startsWith(".")) {
-                    continue;
-                }
-                const fullPath = path.join(dirPath, entryName);
-                // MCP-SEC-02: Validate file path is within workspace
-                if (!(0, path_security_1.validateFilePath)(fullPath, validatedWorkspace)) {
-                    if ((0, logger_1.isDevelopment)()) {
-                        logger_1.logger.warn("[ProjectContextAnalyzer] Skipping path outside workspace", {
-                            path: fullPath,
-                            workspace: validatedWorkspace,
-                        });
-                    }
-                    continue;
-                }
-                // MCP-SEC-02: Check for blocked file patterns
-                if ((0, path_security_1.matchesBlockedFilePattern)(entryName)) {
-                    if ((0, logger_1.isDevelopment)()) {
-                        logger_1.logger.debug("[ProjectContextAnalyzer] Skipping blocked file pattern", {
-                            filename: entryName,
-                        });
-                    }
-                    continue;
-                }
-                try {
-                    const stat = fs.statSync(fullPath);
-                    if (stat.isDirectory()) {
-                        await this.scanDirectory(fullPath, patterns, depth + 1, validatedWorkspace);
-                    }
-                    else if (stat.isFile()) {
-                        const ext = path.extname(entryName);
-                        if (SCANNABLE_EXTENSIONS.includes(ext)) {
-                            this.analyzeFile(fullPath, entryName, patterns);
-                        }
-                    }
-                }
-                catch {
-                    // Skip files we can't access
-                    continue;
-                }
-            }
-        }
-        catch {
-            // Skip directories we can't read
-        }
-    }
-    /**
-     * Analyze a single file for patterns
-     */
-    analyzeFile(filePath, fileName, patterns) {
-        try {
-            const content = fs.readFileSync(filePath, "utf-8");
-            const ext = path.extname(fileName);
-            if (ext === ".css") {
-                this.analyzeCssFile(content, patterns);
-            }
-            else {
-                this.analyzeJsFile(content, fileName, patterns);
-            }
-        }
-        catch {
-            // Skip files we can't read
-        }
-    }
-    /**
-     * Analyze JavaScript/TypeScript file
-     */
-    analyzeJsFile(content, fileName, patterns) {
-        // Detect style constants (STYLES, DESIGN_TOKENS, etc.)
-        let match;
-        PATTERNS.constStyles.lastIndex = 0;
-        while ((match = PATTERNS.constStyles.exec(content)) !== null) {
-            const constantName = match[1] ?? "";
-            const isExport = match[0].startsWith("export");
-            // Extract colors from the constant
-            const colors = this.extractColors(content, match.index);
-            patterns.designTokens.styles.push({
-                name: constantName,
-                type: isExport ? "export-const" : "const",
-                colors,
-                file: fileName,
-            });
-        }
-        // Detect hooks
-        PATTERNS.hookExport.lastIndex = 0;
-        while ((match = PATTERNS.hookExport.exec(content)) !== null) {
-            const hookName = match[1] ?? "";
-            if (!hookName)
-                continue;
-            // Check if this hook already exists
-            const existingHook = patterns.hooks.find((h) => h.name === hookName);
-            if (!existingHook) {
-                patterns.hooks.push({
-                    name: hookName,
-                    file: fileName,
-                    exports: [hookName],
-                });
-            }
-        }
-    }
-    /**
-     * Analyze CSS file
-     */
-    analyzeCssFile(content, patterns) {
-        // Detect TailwindCSS v4
-        if (PATTERNS.tailwindImport.test(content)) {
-            patterns.cssFramework = "tailwindcss-v4";
-        }
-        // Extract @theme variables
-        const themeMatch = content.match(/@theme\s*\{([^}]+)\}/s);
-        if (themeMatch && themeMatch[1]) {
-            const themeContent = themeMatch[1];
-            const varMatches = themeContent.match(/--[\w-]+:\s*[^;]+/g);
-            if (varMatches) {
-                for (const vm of varMatches) {
-                    const parts = vm.split(":");
-                    const name = parts[0];
-                    const value = parts.slice(1).join(":").trim();
-                    if (name) {
-                        patterns.themeVariables.push({ name: name.trim(), value });
-                    }
-                }
-            }
-        }
-        // Extract @keyframes
-        let keyframeMatch;
-        PATTERNS.keyframes.lastIndex = 0;
-        while ((keyframeMatch = PATTERNS.keyframes.exec(content)) !== null) {
-            const animName = keyframeMatch[1];
-            if (animName) {
-                patterns.animations.push({
-                    name: animName,
-                    type: "keyframes",
-                });
-            }
-        }
-        // Extract utility classes
-        let classMatch;
-        PATTERNS.cssClass.lastIndex = 0;
-        while ((classMatch = PATTERNS.cssClass.exec(content)) !== null) {
-            const className = classMatch[1];
-            // Only include meaningful utility classes
-            if (className && className.length > 2 && !className.startsWith("_")) {
-                patterns.utilityClasses.push(className);
-            }
-        }
-    }
-    /**
-     * Extract color values from content starting at a position
-     */
-    extractColors(content, startIndex) {
-        const colors = {};
-        // Find the object content (basic brace matching)
-        let braceCount = 0;
-        let objectStart = -1;
-        let objectEnd = -1;
-        for (let i = startIndex; i < content.length; i++) {
-            if (content[i] === "{") {
-                if (objectStart === -1)
-                    objectStart = i;
-                braceCount++;
-            }
-            else if (content[i] === "}") {
-                braceCount--;
-                if (braceCount === 0 && objectStart !== -1) {
-                    objectEnd = i;
-                    break;
-                }
-            }
-        }
-        if (objectStart === -1 || objectEnd === -1)
-            return colors;
-        const objectContent = content.slice(objectStart, objectEnd + 1);
-        // Extract color properties
-        let match;
-        PATTERNS.colorProperty.lastIndex = 0;
-        while ((match = PATTERNS.colorProperty.exec(objectContent)) !== null) {
-            const propertyPath = match[1];
-            const colorValue = match[2];
-            if (propertyPath && colorValue) {
-                colors[propertyPath] = colorValue;
-            }
-        }
-        return colors;
-    }
-    /**
-     * Calculate adaptability score for HTML against project patterns
-     *
-     * @param html - HTML snippet to analyze
-     * @param patterns - Detected project patterns
-     * @returns Adaptability result with score and hints
-     */
-    calculateAdaptabilityScore(html, patterns) {
-        if (!html || html.trim().length === 0) {
-            return {
-                score: 0,
-                integration_hints: {
-                    suggested_hooks: [],
-                    color_mapping: {},
-                    existing_animations: [],
-                },
-            };
-        }
-        let score = 0;
-        const maxScore = 100;
-        // 1. Color compatibility (40 points max)
-        const colorScore = this.calculateColorCompatibility(html, patterns);
-        score += colorScore * 0.4;
-        // 2. Animation compatibility (30 points max)
-        const animationScore = this.calculateAnimationCompatibility(html, patterns);
-        score += animationScore * 0.3;
-        // 3. Framework compatibility (20 points max)
-        const frameworkScore = this.calculateFrameworkCompatibility(html, patterns);
-        score += frameworkScore * 0.2;
-        // 4. Utility class compatibility (10 points max)
-        const utilityScore = this.calculateUtilityCompatibility(html, patterns);
-        score += utilityScore * 0.1;
-        // Generate integration hints
-        const integration_hints = this.generateIntegrationHints(html, patterns);
-        // Ensure score is within bounds
-        score = Math.max(0, Math.min(maxScore, Math.round(score)));
-        return {
-            score,
-            integration_hints,
-        };
-    }
-    /**
-     * Calculate color compatibility score
-     */
-    calculateColorCompatibility(html, patterns) {
-        const htmlColors = this.extractHtmlColors(html);
-        if (htmlColors.length === 0)
-            return 50; // Neutral if no colors
-        const projectColors = this.getAllProjectColors(patterns);
-        if (projectColors.length === 0)
-            return 50; // Neutral if no project colors
-        let matchCount = 0;
-        for (const htmlColor of htmlColors) {
-            if (this.findSimilarColor(htmlColor, projectColors)) {
-                matchCount++;
-            }
-        }
-        return (matchCount / htmlColors.length) * 100;
-    }
-    /**
-     * Extract colors from HTML
-     */
-    extractHtmlColors(html) {
-        const colors = [];
-        let match;
-        PATTERNS.styleColor.lastIndex = 0;
-        while ((match = PATTERNS.styleColor.exec(html)) !== null) {
-            const colorValue = match[1];
-            if (colorValue) {
-                // Extract actual color value (hex, rgb, etc.)
-                const colorMatch = colorValue.trim().match(PATTERNS.colorValue);
-                if (colorMatch && colorMatch[0]) {
-                    colors.push(colorMatch[0].toLowerCase());
-                }
-            }
-        }
-        // Also check for inline color values in class attributes might reference
-        const hexColors = html.match(/#[0-9a-fA-F]{3,8}/g);
-        if (hexColors) {
-            colors.push(...hexColors.map((c) => c.toLowerCase()));
-        }
-        return [...new Set(colors)];
-    }
-    /**
-     * Get all project colors
-     */
-    getAllProjectColors(patterns) {
-        const colors = [];
-        // From design tokens
-        for (const style of patterns.designTokens.styles) {
-            colors.push(...Object.values(style.colors).map((c) => c.toLowerCase()));
-        }
-        // From theme variables (extract color values)
-        for (const variable of patterns.themeVariables) {
-            if (variable.name.includes("color")) {
-                const match = variable.value.match(PATTERNS.colorValue);
-                if (match) {
-                    colors.push(match[0].toLowerCase());
-                }
-            }
-        }
-        return [...new Set(colors)];
-    }
-    /**
-     * Find similar color in project colors
-     */
-    findSimilarColor(color, projectColors) {
-        // Exact match
-        const normalized = color.toLowerCase();
-        if (projectColors.includes(normalized)) {
-            return normalized;
-        }
-        // Convert to RGB for comparison if hex
-        if (normalized.startsWith("#")) {
-            const rgb = this.hexToRgb(normalized);
-            if (rgb) {
-                for (const pc of projectColors) {
-                    if (pc.startsWith("#")) {
-                        const pcRgb = this.hexToRgb(pc);
-                        if (pcRgb && this.colorDistance(rgb, pcRgb) < 30) {
-                            return pc;
-                        }
-                    }
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * Convert hex to RGB
-     */
-    hexToRgb(hex) {
-        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-        if (!result || !result[1] || !result[2] || !result[3]) {
-            // Try 3-digit hex
-            const short = /^#?([a-f\d])([a-f\d])([a-f\d])$/i.exec(hex);
-            if (!short || !short[1] || !short[2] || !short[3])
-                return null;
-            return {
-                r: parseInt(short[1] + short[1], 16),
-                g: parseInt(short[2] + short[2], 16),
-                b: parseInt(short[3] + short[3], 16),
-            };
-        }
-        return {
-            r: parseInt(result[1], 16),
-            g: parseInt(result[2], 16),
-            b: parseInt(result[3], 16),
-        };
-    }
-    /**
-     * Calculate Euclidean distance between two colors
-     */
-    colorDistance(c1, c2) {
-        return Math.sqrt(Math.pow(c1.r - c2.r, 2) + Math.pow(c1.g - c2.g, 2) + Math.pow(c1.b - c2.b, 2));
-    }
-    /**
-     * Calculate animation compatibility score
-     */
-    calculateAnimationCompatibility(html, patterns) {
-        const hasScrollAnimation = PATTERNS.scrollAnimation.test(html);
-        const hasComplexAnimation = PATTERNS.complexAnimation.test(html);
-        // Check if project has corresponding hooks
-        const hasScrollHook = patterns.hooks.some((h) => h.name.toLowerCase().includes("scroll") || h.name.toLowerCase().includes("animation"));
-        const hasGsapHook = patterns.hooks.some((h) => h.name.toLowerCase().includes("gsap") || h.name.toLowerCase().includes("timeline"));
-        let score = 50; // Base score
-        if (hasScrollAnimation && hasScrollHook)
-            score += 25;
-        if (hasComplexAnimation && hasGsapHook)
-            score += 25;
-        if (!hasScrollAnimation && !hasComplexAnimation)
-            score += 10; // Simple HTML is more adaptable
-        return Math.min(100, score);
-    }
-    /**
-     * Calculate framework compatibility score
-     */
-    calculateFrameworkCompatibility(html, patterns) {
-        // Check for TailwindCSS classes in HTML
-        const hasTailwindClasses = /class="[^"]*\b(flex|grid|p-|m-|w-|h-|text-|bg-|border-)/i.test(html);
-        if (patterns.cssFramework === "tailwindcss-v4") {
-            return hasTailwindClasses ? 100 : 60;
-        }
-        // If no specific framework, inline styles are neutral
-        return 50;
-    }
-    /**
-     * Calculate utility class compatibility score
-     */
-    calculateUtilityCompatibility(html, patterns) {
-        if (patterns.utilityClasses.length === 0)
-            return 50;
-        const htmlClasses = html.match(/class="([^"]*)"/g);
-        if (!htmlClasses)
-            return 50;
-        let matchCount = 0;
-        let totalClasses = 0;
-        for (const classAttr of htmlClasses) {
-            const classes = classAttr.match(/class="([^"]*)"/)?.[1]?.split(/\s+/) || [];
-            for (const cls of classes) {
-                if (cls) {
-                    totalClasses++;
-                    if (patterns.utilityClasses.includes(cls)) {
-                        matchCount++;
-                    }
-                }
-            }
-        }
-        if (totalClasses === 0)
-            return 50;
-        return (matchCount / totalClasses) * 100;
-    }
-    /**
-     * Generate integration hints for HTML against project patterns
-     */
-    generateIntegrationHints(html, patterns) {
-        const hints = {
-            suggested_hooks: [],
-            color_mapping: {},
-            existing_animations: [],
-        };
-        // Suggest hooks based on HTML patterns
-        if (PATTERNS.scrollAnimation.test(html)) {
-            const scrollHook = patterns.hooks.find((h) => h.name.toLowerCase().includes("scroll") || h.name === "useScrollAnimation");
-            if (scrollHook) {
-                hints.suggested_hooks.push(scrollHook.name);
-            }
-        }
-        if (PATTERNS.complexAnimation.test(html)) {
-            const gsapHook = patterns.hooks.find((h) => h.name.toLowerCase().includes("gsap") || h.name === "useGsap");
-            if (gsapHook) {
-                hints.suggested_hooks.push(gsapHook.name);
-            }
-        }
-        // Map colors
-        const htmlColors = this.extractHtmlColors(html);
-        for (const color of htmlColors) {
-            const mappedToken = this.mapColorToToken(color, patterns);
-            if (mappedToken) {
-                hints.color_mapping[color] = mappedToken;
-            }
-        }
-        // Find existing animations that could be reused
-        const htmlAnimations = this.extractAnimationNames(html);
-        for (const anim of htmlAnimations) {
-            const existing = patterns.animations.find((a) => a.name.toLowerCase().includes(anim.toLowerCase()) ||
-                anim.toLowerCase().includes(a.name.toLowerCase()));
-            if (existing) {
-                hints.existing_animations.push(existing.name);
-            }
-        }
-        // Deduplicate
-        hints.suggested_hooks = [...new Set(hints.suggested_hooks)];
-        hints.existing_animations = [...new Set(hints.existing_animations)];
-        return hints;
-    }
-    /**
-     * Map a color to project token
-     */
-    mapColorToToken(color, patterns) {
-        const normalized = color.toLowerCase();
-        // Check design tokens
-        for (const style of patterns.designTokens.styles) {
-            for (const [path, value] of Object.entries(style.colors)) {
-                if (value.toLowerCase() === normalized) {
-                    return `${style.name}.${path}`;
-                }
-                // Check similar colors
-                if (normalized.startsWith("#") && value.startsWith("#")) {
-                    const rgb1 = this.hexToRgb(normalized);
-                    const rgb2 = this.hexToRgb(value);
-                    if (rgb1 && rgb2 && this.colorDistance(rgb1, rgb2) < 20) {
-                        return `${style.name}.${path}`;
-                    }
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * Extract animation names from HTML
-     */
-    extractAnimationNames(html) {
-        const names = [];
-        // From animation property
-        const animMatch = html.match(/animation:\s*([\w-]+)/gi);
-        if (animMatch) {
-            for (const m of animMatch) {
-                const name = m.replace(/animation:\s*/i, "").split(/\s/)[0];
-                if (name)
-                    names.push(name);
-            }
-        }
-        // From class names containing animation keywords
-        const classMatch = html.match(/class="[^"]*animate[^"]*"/gi);
-        if (classMatch) {
-            for (const m of classMatch) {
-                const classes = m.match(/animate[-\w]+/gi);
-                if (classes) {
-                    names.push(...classes.map((c) => c.replace(/^animate-?/i, "")));
-                }
-            }
-        }
-        return [...new Set(names.filter((n) => n.length > 0))];
-    }
-    /**
-     * Analyze with options (convenience method)
-     */
-    async analyzeWithOptions(projectPath, html, options) {
-        if (!options.enabled) {
-            return null;
-        }
-        const scanPath = options.projectPath || projectPath;
-        // If custom designTokensPath, scan that first
-        let patterns = await this.detectProjectPatterns(scanPath);
-        if (options.designTokensPath && fs.existsSync(options.designTokensPath)) {
-            const tokenPatterns = await this.detectProjectPatterns(options.designTokensPath);
-            // Merge token patterns
-            patterns = {
-                ...patterns,
-                designTokens: {
-                    styles: [...patterns.designTokens.styles, ...tokenPatterns.designTokens.styles],
-                },
-            };
-        }
-        return this.calculateAdaptabilityScore(html, patterns);
-    }
-    /**
-     * Clear pattern cache
-     */
-    clearCache() {
-        this.patternCache.clear();
-    }
-}
-exports.ProjectContextAnalyzer = ProjectContextAnalyzer;
-// =====================================================
-// Singleton Instance
-// =====================================================
-let instance = null;
-/**
- * Get ProjectContextAnalyzer instance (singleton)
- */
-function getProjectContextAnalyzer() {
-    if (!instance) {
-        instance = new ProjectContextAnalyzer();
-    }
-    return instance;
-}
-/**
- * Reset ProjectContextAnalyzer instance
- */
-function resetProjectContextAnalyzer() {
-    if (instance) {
-        instance.clearCache();
-    }
-    instance = null;
-}
-exports.default = ProjectContextAnalyzer;
-//# sourceMappingURL=project-context-analyzer.js.map