codereview-aia 0.1.3 → 0.1.4

package/dist/utils/detection/frameworkDetector.js

@@ -0,0 +1,850 @@
+"use strict";
+/**
+ * @fileoverview Framework detection utility for cr-aia
+ *
+ * This module analyzes project files to determine which framework is being used,
+ * allowing for more specific prompts and improved review quality.
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFramework = detectFramework;
+exports.detectPrimaryLanguage = detectPrimaryLanguage;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const logger_1 = __importDefault(require("../logger"));
+/**
+ * Recursively count files with specific extensions in a directory
+ * @param dirPath Directory path to search
+ * @param extensions Array of file extensions to count (e.g., ['.ts', '.tsx'])
+ * @returns Promise resolving to the count of matching files
+ */
+async function countFilesByExtension(dirPath, extensions) {
+    let count = 0;
+    try {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                // Skip common directories that shouldn't be counted
+                if (!['node_modules', '.git', 'dist', 'build', '.next', 'coverage'].includes(entry.name)) {
+                    count += await countFilesByExtension(fullPath, extensions);
+                }
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name);
+                if (extensions.includes(ext)) {
+                    count++;
+                }
+            }
+        }
+    }
+    catch (error) {
+        logger_1.default.debug(`Error reading directory ${dirPath}: ${error}`);
+    }
+    return count;
+}
+/**
+ * Language-specific framework signatures
+ */
+const FRAMEWORK_SIGNATURES = {
+    typescript: [
+        {
+            name: 'react',
+            files: ['src/App.tsx', 'src/App.jsx', 'public/index.html'],
+            dependencies: ['react', 'react-dom'],
+            weight: 0.8,
+            type: 'ui',
+        },
+        {
+            name: 'nextjs',
+            files: ['next.config.js', 'pages/_app.tsx', 'pages/index.tsx'],
+            dependencies: ['next'],
+            weight: 0.9,
+            type: 'fullstack',
+        },
+        {
+            name: 'angular',
+            files: ['angular.json', 'src/app/app.module.ts'],
+            dependencies: ['@angular/core', '@angular/common'],
+            weight: 0.9,
+            type: 'ui',
+        },
+        {
+            name: 'vue',
+            files: ['src/App.vue', 'vue.config.js'],
+            dependencies: ['vue'],
+            weight: 0.8,
+            type: 'ui',
+        },
+        {
+            name: 'express',
+            files: ['app.js', 'server.js'],
+            dependencies: ['express'],
+            weight: 0.7,
+            type: 'backend',
+        },
+    ],
+    php: [
+        {
+            name: 'laravel',
+            files: ['artisan', 'composer.json'],
+            directories: ['app/Http/Controllers', 'resources/views'],
+            weight: 0.9,
+            type: 'fullstack',
+        },
+        {
+            name: 'symfony',
+            files: ['symfony.lock', 'composer.json', 'config/bundles.php'],
+            dependencies: ['symfony/symfony', 'symfony/framework-bundle'],
+            weight: 0.9,
+            type: 'fullstack',
+        },
+        {
+            name: 'wordpress',
+            files: ['wp-config.php', 'wp-content/themes'],
+            directories: ['wp-admin', 'wp-content'],
+            weight: 0.8,
+            type: 'fullstack',
+        },
+    ],
+    python: [
+        {
+            name: 'django',
+            files: ['manage.py', 'settings.py'],
+            directories: ['app/migrations'],
+            dependencies: ['django'],
+            weight: 0.9,
+            type: 'fullstack',
+        },
+        {
+            name: 'flask',
+            files: ['app.py', 'wsgi.py'],
+            dependencies: ['flask'],
+            weight: 0.8,
+            type: 'backend',
+        },
+        {
+            name: 'fastapi',
+            files: ['main.py'],
+            dependencies: ['fastapi'],
+            weight: 0.7,
+            type: 'backend',
+        },
+    ],
+    ruby: [
+        {
+            name: 'rails',
+            files: ['Gemfile', 'config/routes.rb', 'app/controllers/application_controller.rb'],
+            directories: ['app/models', 'app/controllers', 'app/views'],
+            weight: 0.9,
+            type: 'fullstack',
+        },
+        {
+            name: 'sinatra',
+            files: ['Gemfile', 'config.ru'],
+            dependencies: ['sinatra'],
+            weight: 0.8,
+            type: 'backend',
+        },
+    ],
+    dart: [
+        {
+            name: 'flutter',
+            files: [
+                'pubspec.yaml',
+                'lib/main.dart',
+                'android/app/build.gradle',
+                'ios/Runner.xcodeproj/project.pbxproj',
+            ],
+            directories: ['lib', 'android', 'ios'],
+            dependencies: ['flutter'],
+            weight: 0.9,
+            type: 'ui',
+        },
+    ],
+    css: [
+        {
+            name: 'tailwind',
+            files: ['tailwind.config.js', 'postcss.config.js'],
+            dependencies: ['tailwindcss'],
+            weight: 0.9,
+            type: 'css',
+        },
+        {
+            name: 'bootstrap',
+            files: ['bootstrap.min.css', 'bootstrap.bundle.min.js'],
+            dependencies: ['bootstrap'],
+            weight: 0.8,
+            type: 'css',
+        },
+        {
+            name: 'material-ui',
+            files: [],
+            dependencies: ['@mui/material', '@material-ui/core'],
+            weight: 0.8,
+            type: 'css',
+        },
+        {
+            name: 'styled-components',
+            files: [],
+            dependencies: ['styled-components'],
+            weight: 0.7,
+            type: 'css',
+        },
+        {
+            name: 'emotion',
+            files: [],
+            dependencies: ['@emotion/react', '@emotion/styled'],
+            weight: 0.7,
+            type: 'css',
+        },
+        {
+            name: 'chakra-ui',
+            files: [],
+            dependencies: ['@chakra-ui/react'],
+            weight: 0.8,
+            type: 'css',
+        },
+        {
+            name: 'bulma',
+            dependencies: ['bulma'],
+            files: ['bulma.min.css'],
+            weight: 0.7,
+            type: 'css',
+        },
+    ],
+};
+/**
+ * Detect frameworks used in a project
+ * @param projectPath Path to project root directory
+ * @returns Promise resolving to framework detection result
+ */
+async function detectFramework(projectPath) {
+    try {
+        logger_1.default.debug(`Detecting framework for project at ${projectPath}`);
+        // First, detect the primary language
+        const language = await detectPrimaryLanguage(projectPath);
+        if (!language) {
+            logger_1.default.debug('Could not detect primary language.');
+            return null;
+        }
+        logger_1.default.debug(`Detected primary language: ${language}`);
+        // Now detect the framework based on the language
+        if (FRAMEWORK_SIGNATURES[language]) {
+            const frameworkResult = await detectFrameworkForLanguage(projectPath, language);
+            if (frameworkResult) {
+                logger_1.default.debug(`Detected framework: ${frameworkResult.framework} with confidence ${frameworkResult.confidence.toFixed(2)}`);
+                if (frameworkResult.additionalFrameworks &&
+                    frameworkResult.additionalFrameworks.length > 0) {
+                    logger_1.default.debug(`Additional frameworks detected: ${frameworkResult.additionalFrameworks.join(', ')}`);
+                }
+                return frameworkResult;
+            }
+        }
+        // If we couldn't detect a specific framework, return just the language
+        logger_1.default.debug(`No specific framework detected for ${language}`);
+        return {
+            language,
+            framework: 'none',
+            confidence: 0.5,
+            detectionMethod: 'language-only',
+        };
+    }
+    catch (error) {
+        logger_1.default.error(`Error detecting framework: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Detect the primary programming language used in a project
+ * @param projectPath Path to project root directory
+ * @returns Promise resolving to language name
+ */
+async function detectPrimaryLanguage(projectPath) {
+    try {
+        // Check for language-specific files
+        const fileExtensionMap = {
+            typescript: ['.ts', '.tsx'],
+            javascript: ['.js', '.jsx'],
+            php: ['.php'],
+            python: ['.py'],
+            ruby: ['.rb'],
+            dart: ['.dart'],
+        };
+        // Count files by extension
+        const extensionCounts = {};
+        for (const [language, extensions] of Object.entries(fileExtensionMap)) {
+            try {
+                const count = await countFilesByExtension(projectPath, extensions);
+                extensionCounts[language] = count;
+            }
+            catch (error) {
+                logger_1.default.debug(`Error counting ${language} files: ${error}`);
+                extensionCounts[language] = 0;
+            }
+        }
+        // Find the language with the most files
+        let maxCount = 0;
+        let primaryLanguage = null;
+        for (const [language, count] of Object.entries(extensionCounts)) {
+            if (count > maxCount) {
+                maxCount = count;
+                primaryLanguage = language;
+            }
+        }
+        // If TypeScript and JavaScript are close, prefer TypeScript
+        if (primaryLanguage === 'javascript' &&
+            extensionCounts.typescript > 0 &&
+            extensionCounts.typescript >= extensionCounts.javascript * 0.5) {
+            primaryLanguage = 'typescript';
+        }
+        // Check for special cases: package.json (Node.js), composer.json (PHP), Gemfile (Ruby), requirements.txt (Python), pubspec.yaml (Dart/Flutter)
+        try {
+            const packageJsonExists = await fileExists(path.join(projectPath, 'package.json'));
+            const composerJsonExists = await fileExists(path.join(projectPath, 'composer.json'));
+            const gemfileExists = await fileExists(path.join(projectPath, 'Gemfile'));
+            const requirementsTxtExists = await fileExists(path.join(projectPath, 'requirements.txt'));
+            const pubspecYamlExists = await fileExists(path.join(projectPath, 'pubspec.yaml'));
+            // IMPORTANT: Language detection priority:
+            // 1. Strong file evidence for non-JS/TS languages (Python, PHP, Ruby) takes absolute priority
+            // 2. For JS/TS projects, config files can influence the decision
+            // 3. Package.json presence suggests Node.js ecosystem
+            // If we have strong evidence for Python, PHP, Ruby, or Dart, respect it absolutely
+            if (primaryLanguage === 'python' && extensionCounts.python > 3) {
+                // Keep Python if we have clear Python files
+                logger_1.default.debug(`Strong Python evidence (${extensionCounts.python} files), keeping Python despite package.json`);
+            }
+            else if (primaryLanguage === 'php' && extensionCounts.php > 3) {
+                // Keep PHP if we have clear PHP files
+                logger_1.default.debug(`Strong PHP evidence (${extensionCounts.php} files), keeping PHP`);
+            }
+            else if (primaryLanguage === 'ruby' && extensionCounts.ruby > 3) {
+                // Keep Ruby if we have clear Ruby files
+                logger_1.default.debug(`Strong Ruby evidence (${extensionCounts.ruby} files), keeping Ruby`);
+            }
+            else if (primaryLanguage === 'dart' && extensionCounts.dart > 0) {
+                // Keep Dart if we have any Dart files - Dart projects are usually pure Dart
+                logger_1.default.debug(`Strong Dart evidence (${extensionCounts.dart} files), keeping Dart`);
+            }
+            else if (packageJsonExists) {
+                // Handle Node.js projects (package.json present)
+                if (primaryLanguage === null ||
+                    primaryLanguage === 'javascript' ||
+                    primaryLanguage === 'typescript') {
+                    // Check if this is a TypeScript-oriented project
+                    const isTypescriptProject = await isTypeScriptProject(projectPath);
+                    if (isTypescriptProject || extensionCounts.typescript > 0) {
+                        primaryLanguage = 'typescript';
+                    }
+                    else if (extensionCounts.javascript > 0 || extensionCounts.typescript === 0) {
+                        // For backward compatibility with tests, default to TypeScript for Node.js projects
+                        // This maintains the existing behavior while fixing Python detection
+                        primaryLanguage = 'typescript';
+                    }
+                }
+                // If primaryLanguage is Python/PHP/Ruby with few files, package.json might be for tooling
+            }
+            else if (composerJsonExists && (primaryLanguage === null || extensionCounts.php > 0)) {
+                primaryLanguage = 'php';
+            }
+            else if (gemfileExists && (primaryLanguage === null || extensionCounts.ruby > 0)) {
+                primaryLanguage = 'ruby';
+            }
+            else if (requirementsTxtExists &&
+                (primaryLanguage === null || extensionCounts.python > 0)) {
+                primaryLanguage = 'python';
+            }
+            else if (pubspecYamlExists && (primaryLanguage === null || extensionCounts.dart > 0)) {
+                primaryLanguage = 'dart';
+            }
+            // Additional Python detection for projects with Python files but no requirements.txt
+            if (primaryLanguage === null && extensionCounts.python > 0) {
+                primaryLanguage = 'python';
+            }
+            // Additional Dart detection for projects with Dart files but no pubspec.yaml
+            if (primaryLanguage === null && extensionCounts.dart > 0) {
+                primaryLanguage = 'dart';
+            }
+        }
+        catch (error) {
+            logger_1.default.debug(`Error checking for special files: ${error}`);
+        }
+        return primaryLanguage;
+    }
+    catch (error) {
+        logger_1.default.error(`Error detecting primary language: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Detect frameworks for a specific language
+ * @param projectPath Path to project root directory
+ * @param language Language to detect frameworks for
+ * @returns Promise resolving to framework detection result
+ */
+async function detectFrameworkForLanguage(projectPath, language) {
+    try {
+        const signatures = FRAMEWORK_SIGNATURES[language] || [];
+        const scores = {};
+        const detectionMethods = {};
+        // Get all dependencies for this project
+        const dependencies = await getDependencies(projectPath, language);
+        // Detect CSS frameworks
+        const cssFrameworks = await detectCssFrameworks(projectPath, dependencies);
+        // Store framework versions
+        let frameworkVersion;
+        let frameworkType;
+        // Check for each framework signature
+        for (const signature of signatures) {
+            let score = 0;
+            const methods = [];
+            // Check for files
+            for (const file of signature.files) {
+                if (await fileExists(path.join(projectPath, file))) {
+                    score += signature.weight;
+                    methods.push(`found file: ${file}`);
+                }
+            }
+            // Check for directories
+            if (signature.directories) {
+                for (const dir of signature.directories) {
+                    if (await directoryExists(path.join(projectPath, dir))) {
+                        score += signature.weight * 0.8;
+                        methods.push(`found directory: ${dir}`);
+                    }
+                }
+            }
+            // Check for dependencies
+            if (signature.dependencies) {
+                for (const dep of signature.dependencies) {
+                    if (dependencies[dep]) {
+                        score += signature.weight * 0.9;
+                        methods.push(`found dependency: ${dep}`);
+                        // Store version of the main dependency
+                        if (!frameworkVersion) {
+                            frameworkVersion = dependencies[dep];
+                        }
+                    }
+                }
+            }
+            scores[signature.name] = score;
+            detectionMethods[signature.name] = methods;
+            // Store the framework type if this signature has a high score
+            if (score > 0.7 && signature.type) {
+                frameworkType = signature.type;
+            }
+        }
+        // Find the framework with the highest score
+        let maxScore = 0;
+        let detectedFramework = null;
+        for (const [framework, score] of Object.entries(scores)) {
+            if (score > maxScore) {
+                maxScore = score;
+                detectedFramework = framework;
+            }
+        }
+        // Calculate additional frameworks
+        const additionalFrameworks = [];
+        for (const [framework, score] of Object.entries(scores)) {
+            if (framework !== detectedFramework && score > 0.5) {
+                additionalFrameworks.push(framework);
+            }
+        }
+        // If a framework was detected, return it
+        if (detectedFramework) {
+            return {
+                language,
+                framework: detectedFramework,
+                confidence: Math.min(maxScore, 1),
+                detectionMethod: detectionMethods[detectedFramework].join(', '),
+                additionalFrameworks: additionalFrameworks.length > 0 ? additionalFrameworks : undefined,
+                cssFrameworks: cssFrameworks.length > 0 ? cssFrameworks : undefined,
+                frameworkVersion: frameworkVersion,
+                frameworkType: frameworkType,
+            };
+        }
+        // If no framework was detected but we have CSS frameworks, return language with CSS frameworks
+        if (cssFrameworks.length > 0) {
+            return {
+                language,
+                framework: 'none',
+                confidence: 0.5,
+                detectionMethod: 'css-frameworks-only',
+                cssFrameworks: cssFrameworks,
+            };
+        }
+        if (language === 'php') {
+            const wordpressMatch = await detectWordPressArtifacts(projectPath);
+            if (wordpressMatch) {
+                return {
+                    language,
+                    framework: 'wordpress',
+                    confidence: 0.75,
+                    detectionMethod: wordpressMatch.reason,
+                    frameworkType: 'fullstack',
+                };
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        logger_1.default.error(`Error detecting framework for ${language}: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Check if a file exists
+ * @param filePath Path to file
+ * @returns Promise resolving to boolean
+ */
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch (_error) {
+        return false;
+    }
+}
+/**
+ * Check if a directory exists
+ * @param dirPath Path to directory
+ * @returns Promise resolving to boolean
+ */
+async function directoryExists(dirPath) {
+    try {
+        const stats = await fs.stat(dirPath);
+        return stats.isDirectory();
+    }
+    catch (_error) {
+        return false;
+    }
+}
+/**
+ * Check if a Node.js project should be considered a TypeScript project
+ * @param projectPath Path to project root
+ * @returns Promise resolving to boolean
+ */
+async function isTypeScriptProject(projectPath) {
+    try {
+        // Check for TypeScript config files
+        const tsconfigExists = await fileExists(path.join(projectPath, 'tsconfig.json'));
+        if (tsconfigExists) {
+            return true;
+        }
+        // Check package.json for TypeScript dependencies
+        const packageJsonPath = path.join(projectPath, 'package.json');
+        if (await fileExists(packageJsonPath)) {
+            const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+            // Check for TypeScript in dependencies or devDependencies
+            const allDeps = {
+                ...packageJson.dependencies,
+                ...packageJson.devDependencies,
+            };
+            // Look for TypeScript-specific packages
+            const typescriptIndicators = [
+                'typescript',
+                '@types/node',
+                'ts-node',
+                '@typescript-eslint/parser',
+                '@typescript-eslint/eslint-plugin',
+            ];
+            return typescriptIndicators.some((indicator) => allDeps[indicator]);
+        }
+        return false;
+    }
+    catch (error) {
+        logger_1.default.debug(`Error checking if TypeScript project: ${error}`);
+        return false;
+    }
+}
+/**
+ * Get dependencies for a project
+ * @param projectPath Path to project
+ * @param language Language to get dependencies for
+ * @returns Promise resolving to dependency map with versions
+ */
+async function getDependencies(projectPath, language) {
+    const dependencies = {};
+    try {
+        if (language === 'typescript' || language === 'javascript') {
+            // Parse package.json
+            const packageJsonPath = path.join(projectPath, 'package.json');
+            if (await fileExists(packageJsonPath)) {
+                const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+                // Add both dependencies and devDependencies
+                if (packageJson.dependencies) {
+                    Object.assign(dependencies, packageJson.dependencies);
+                }
+                if (packageJson.devDependencies) {
+                    Object.assign(dependencies, packageJson.devDependencies);
+                }
+            }
+        }
+        else if (language === 'php') {
+            // Parse composer.json
+            const composerJsonPath = path.join(projectPath, 'composer.json');
+            if (await fileExists(composerJsonPath)) {
+                const composerJson = JSON.parse(await fs.readFile(composerJsonPath, 'utf-8'));
+                if (composerJson.require) {
+                    Object.assign(dependencies, composerJson.require);
+                }
+                if (composerJson['require-dev']) {
+                    Object.assign(dependencies, composerJson['require-dev']);
+                }
+            }
+        }
+        else if (language === 'ruby') {
+            // Parse Gemfile
+            const gemfilePath = path.join(projectPath, 'Gemfile');
+            if (await fileExists(gemfilePath)) {
+                const gemfile = await fs.readFile(gemfilePath, 'utf-8');
+                // Simple regex to extract gem names
+                const gemRegex = /gem\s+['"]([^'"]+)['"](?:,\s*['"]([^'"]+)['"])?/g;
+                let match;
+                while ((match = gemRegex.exec(gemfile)) !== null) {
+                    dependencies[match[1]] = match[2] || '*';
+                }
+            }
+        }
+        else if (language === 'python') {
+            // Parse requirements.txt
+            const requirementsPath = path.join(projectPath, 'requirements.txt');
+            if (await fileExists(requirementsPath)) {
+                const requirements = await fs.readFile(requirementsPath, 'utf-8');
+                // Parse each line
+                for (const line of requirements.split('\n')) {
+                    const trimmedLine = line.trim();
+                    if (trimmedLine && !trimmedLine.startsWith('#')) {
+                        // Extract package name and version
+                        const parts = trimmedLine.split(/([=<>!~]=?)/);
+                        if (parts.length >= 1) {
+                            const packageName = parts[0].trim().toLowerCase();
+                            const version = parts.length >= 3 ? parts[1] + parts[2] : '*';
+                            if (packageName) {
+                                dependencies[packageName] = version;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else if (language === 'dart') {
+            // Parse pubspec.yaml
+            const pubspecPath = path.join(projectPath, 'pubspec.yaml');
+            if (await fileExists(pubspecPath)) {
+                const pubspecContent = await fs.readFile(pubspecPath, 'utf-8');
+                // Simple YAML parsing for dependencies
+                const lines = pubspecContent.split('\n');
+                let inDependencies = false;
+                let inDevDependencies = false;
+                for (const line of lines) {
+                    const trimmedLine = line.trim();
+                    // Check for dependencies sections
+                    if (trimmedLine === 'dependencies:') {
+                        inDependencies = true;
+                        inDevDependencies = false;
+                        continue;
+                    }
+                    if (trimmedLine === 'dev_dependencies:') {
+                        inDependencies = false;
+                        inDevDependencies = true;
+                        continue;
+                    }
+                    if (trimmedLine.endsWith(':') && !trimmedLine.startsWith(' ')) {
+                        // New top-level section
+                        inDependencies = false;
+                        inDevDependencies = false;
+                        continue;
+                    }
+                    // Parse dependency lines
+                    if ((inDependencies || inDevDependencies) &&
+                        trimmedLine &&
+                        !trimmedLine.startsWith('#')) {
+                        // Handle different dependency formats:
+                        // package_name: ^1.0.0
+                        // package_name:
+                        //   sdk: flutter
+                        const colonIndex = trimmedLine.indexOf(':');
+                        if (colonIndex > 0) {
+                            const packageName = trimmedLine.substring(0, colonIndex).trim();
+                            const versionPart = trimmedLine.substring(colonIndex + 1).trim();
+                            // Skip SDK dependencies and empty values
+                            if (packageName && !versionPart.startsWith('sdk:') && packageName !== 'sdk') {
+                                const version = versionPart || '*';
+                                dependencies[packageName] = version;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        logger_1.default.warn(`Error getting dependencies: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return dependencies;
+}
+async function detectWordPressArtifacts(projectPath) {
+    try {
+        const wpContent = path.join(projectPath, 'wp-content');
+        if (await directoryExists(wpContent)) {
+            return { reason: 'wp-content directory detected' };
+        }
+        const styleCss = path.join(projectPath, 'style.css');
+        if (await fileExists(styleCss)) {
+            const head = await readFileHead(styleCss);
+            if (/Theme Name\s*:/i.test(head)) {
+                return { reason: 'style.css theme header' };
+            }
+        }
+        const rootEntries = await fs.readdir(projectPath, { withFileTypes: true });
+        for (const entry of rootEntries) {
+            if (!entry.isFile())
+                continue;
+            if (!entry.name.toLowerCase().endsWith('.php'))
+                continue;
+            const fullPath = path.join(projectPath, entry.name);
+            const head = await readFileHead(fullPath);
+            if (/(Plugin Name|Theme Name)\s*:/i.test(head)) {
+                return { reason: `WordPress plugin header detected in ${entry.name}` };
+            }
+            if (/Text Domain\s*:/i.test(head)) {
+                return { reason: `WordPress localization header detected in ${entry.name}` };
+            }
+        }
+    }
+    catch (error) {
+        logger_1.default.debug(`Error detecting WordPress artifacts: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return null;
+}
+async function readFileHead(filePath, length = 4096) {
+    try {
+        const data = await fs.readFile(filePath, 'utf-8');
+        return data.slice(0, length);
+    }
+    catch (_error) {
+        return '';
+    }
+}
+/**
+ * Detect CSS frameworks used in a project
+ * @param projectPath Path to project root directory
+ * @param dependencies Dependencies map
+ * @returns Promise resolving to CSS frameworks detection results
+ */
+async function detectCssFrameworks(projectPath, dependencies) {
+    const cssFrameworks = [];
+    try {
+        // Check for CSS frameworks based on FRAMEWORK_SIGNATURES
+        if (FRAMEWORK_SIGNATURES.css) {
+            for (const signature of FRAMEWORK_SIGNATURES.css) {
+                let score = 0;
+                let foundDependency = false;
+                let version;
+                // Check for dependencies
+                if (signature.dependencies) {
+                    for (const dep of signature.dependencies) {
+                        if (dependencies[dep]) {
+                            score += signature.weight * 0.9;
+                            foundDependency = true;
+                            version = dependencies[dep];
+                            break;
+                        }
+                    }
+                }
+                // Check for files
+                if (signature.files) {
+                    for (const file of signature.files) {
+                        if (await fileExists(path.join(projectPath, file))) {
+                            score += signature.weight * 0.8;
+                            break;
+                        }
+                    }
+                }
+                // If we have a score, add it to the list
+                if (score > 0.5) {
+                    cssFrameworks.push({
+                        name: signature.name,
+                        version: foundDependency ? version : undefined,
+                        confidence: Math.min(score, 1),
+                    });
+                }
+            }
+        }
+        // Look for specific CSS files in common locations
+        const cssDirs = ['src/styles', 'src/css', 'public/css', 'assets/css', 'styles', 'css'];
+        for (const dir of cssDirs) {
+            const fullPath = path.join(projectPath, dir);
+            if (await directoryExists(fullPath)) {
+                try {
+                    const files = await fs.readdir(fullPath);
+                    // Look for common CSS framework files
+                    for (const file of files) {
+                        const lowerFile = file.toLowerCase();
+                        if (lowerFile.includes('bootstrap') && lowerFile.endsWith('.css')) {
+                            if (!cssFrameworks.some((f) => f.name === 'bootstrap')) {
+                                cssFrameworks.push({ name: 'bootstrap', confidence: 0.7 });
+                            }
+                        }
+                        else if (lowerFile.includes('bulma') && lowerFile.endsWith('.css')) {
+                            if (!cssFrameworks.some((f) => f.name === 'bulma')) {
+                                cssFrameworks.push({ name: 'bulma', confidence: 0.7 });
+                            }
+                        }
+                        else if (lowerFile.includes('tailwind') && lowerFile.endsWith('.css')) {
+                            if (!cssFrameworks.some((f) => f.name === 'tailwind')) {
+                                cssFrameworks.push({ name: 'tailwind', confidence: 0.7 });
+                            }
+                        }
+                    }
+                }
+                catch (_error) {
+                    // Ignore directory read errors
+                }
+            }
+        }
+        return cssFrameworks;
+    }
+    catch (error) {
+        logger_1.default.warn(`Error detecting CSS frameworks: ${error instanceof Error ? error.message : String(error)}`);
+        return [];
+    }
+}
+//# sourceMappingURL=frameworkDetector.js.map