superkit-mcp-server 1.0.1 → 1.0.2

package/build/tools/validators/reactPerformanceChecker.js

@@ -0,0 +1,199 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export class PerformanceChecker {
+    projectPath;
+    issues = [];
+    warnings = [];
+    constructor(projectPath) {
+        this.projectPath = path.resolve(projectPath);
+    }
+    async getFiles(extensions) {
+        let files = [];
+        const self = this;
+        async function search(dir) {
+            try {
+                const items = await fs.readdir(dir, { withFileTypes: true });
+                for (const item of items) {
+                    if (['node_modules', '.git', 'dist', 'build', '.next'].includes(item.name))
+                        continue;
+                    const fullPath = path.join(dir, item.name);
+                    if (item.isDirectory())
+                        await search(fullPath);
+                    else if (extensions.includes(path.extname(item.name).toLowerCase())) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+            catch { }
+        }
+        await search(this.projectPath);
+        return files;
+    }
+    async checkWaterfalls(files) {
+        for (const file of files) {
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                const lines = content.split('\n');
+                let consecutiveAwaits = 0;
+                for (let i = 0; i < lines.length; i++) {
+                    const line = lines[i];
+                    if (/await\s+/.test(line)) {
+                        consecutiveAwaits++;
+                        if (consecutiveAwaits > 1) {
+                            this.issues.push({
+                                file: path.relative(this.projectPath, file),
+                                type: 'CRITICAL',
+                                issue: 'Sequential awaits detected (waterfall)',
+                                fix: 'Use Promise.all() for parallel fetching',
+                                section: '1-async-eliminating-waterfalls.md'
+                            });
+                            break; // report once per file is enough for test
+                        }
+                    }
+                    else if (line.trim().length > 0 && !line.trim().startsWith('//')) {
+                        consecutiveAwaits = 0;
+                    }
+                }
+            }
+            catch { }
+        }
+    }
+    async checkBarrelImports(files) {
+        for (const file of files) {
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                if (/import.*from\s+['"](@\/.*?)\/index['"]/.test(content) || /import.*from\s+['"]\.\.?\/.*?['"](?!\.tsx?)/.test(content)) {
+                    this.warnings.push({
+                        file: path.relative(this.projectPath, file),
+                        type: 'CRITICAL',
+                        issue: 'Potential barrel imports detected',
+                        fix: 'Import directly from specific files',
+                        section: '2-bundle-bundle-size-optimization.md'
+                    });
+                }
+            }
+            catch { }
+        }
+    }
+    async checkDynamicImports(files) {
+        for (const file of files) {
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                if (content.length > 10000) {
+                    const filename = path.parse(file).name;
+                    for (const checkFile of files) {
+                        if (checkFile === file)
+                            continue;
+                        const checkContent = await fs.readFile(checkFile, 'utf-8');
+                        if ((checkContent.includes(`import ${filename}`) || checkContent.includes(`import { ${filename}`)) && !checkContent.includes('dynamic(')) {
+                            this.warnings.push({
+                                file: path.relative(this.projectPath, checkFile),
+                                type: 'CRITICAL',
+                                issue: `Large component ${filename} imported statically`,
+                                fix: 'Use dynamic() for code splitting',
+                                section: '2-bundle-bundle-size-optimization.md'
+                            });
+                            break;
+                        }
+                    }
+                }
+            }
+            catch { }
+        }
+    }
+    async checkUseEffectFetching(files) {
+        for (const file of files) {
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                if (content.includes('useEffect') && /useEffect.*?fetch\(/s.test(content)) {
+                    this.warnings.push({
+                        file: path.relative(this.projectPath, file),
+                        type: 'MEDIUM', // Mapped from MEDIUM-HIGH to fit interface
+                        issue: 'Data fetching in useEffect',
+                        fix: 'Consider using SWR or React Query for deduplication',
+                        section: '4-client-client-side-data-fetching.md'
+                    });
+                }
+            }
+            catch { }
+        }
+    }
+    async checkMissingMemoization(files) {
+        for (const file of files.filter(f => f.endsWith('.tsx'))) {
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                const components = content.match(/(?:export\s+)?(?:const|function)\s+([A-Z]\w+)/g);
+                if (components && !content.includes('React.memo') && !content.includes('memo(')) {
+                    if (content.includes('props:') || content.includes('Props>')) {
+                        this.warnings.push({
+                            file: path.relative(this.projectPath, file),
+                            type: 'MEDIUM',
+                            issue: 'Component with props not memoized',
+                            fix: 'Consider using React.memo if props are stable',
+                            section: '5-rerender-re-render-optimization.md'
+                        });
+                    }
+                }
+            }
+            catch { }
+        }
+    }
+    async checkImageOptimization(files) {
+        for (const file of files) {
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                if (content.includes('<img') && !content.includes('next/image')) {
+                    this.warnings.push({
+                        file: path.relative(this.projectPath, file),
+                        type: 'MEDIUM',
+                        issue: 'Using <img> instead of next/image',
+                        fix: 'Use next/image for automatic optimization',
+                        section: '6-rendering-rendering-performance.md'
+                    });
+                }
+            }
+            catch { }
+        }
+    }
+    async runAll() {
+        const tsJsFiles = await this.getFiles(['.ts', '.tsx', '.js', '.jsx']);
+        const tsxFiles = tsJsFiles.filter(f => f.endsWith('.tsx') || f.endsWith('.ts')); // for dynamic/effects
+        await this.checkWaterfalls(tsJsFiles);
+        await this.checkBarrelImports(tsJsFiles);
+        await this.checkDynamicImports(tsxFiles); // Usually larger components are in ts/tsx
+        await this.checkUseEffectFetching(tsxFiles);
+        await this.checkMissingMemoization(tsxFiles);
+        await this.checkImageOptimization(tsJsFiles);
+        return {
+            issues: this.issues,
+            warnings: this.warnings,
+            passed: this.issues.length === 0 && this.warnings.filter(w => w.type === 'CRITICAL').length === 0
+        };
+    }
+}
+export async function runReactPerformanceChecker(projectPath = ".") {
+    const checker = new PerformanceChecker(projectPath);
+    const result = await checker.runAll();
+    let report = `============================================================\n`;
+    report += `REACT PERFORMANCE AUDIT REPORT\n`;
+    report += `============================================================\n`;
+    const crits = result.issues.filter(i => i.type === 'CRITICAL');
+    report += `\n[CRITICAL ISSUES] (${crits.length})\n`;
+    for (const issue of crits) {
+        report += `  - ${issue.file}\n    Issue: ${issue.issue}\n    Fix: ${issue.fix}\n    Reference: ${issue.section}\n\n`;
+    }
+    report += `\n[WARNINGS] (${result.warnings.length})\n`;
+    for (const warning of result.warnings.slice(0, 10)) {
+        report += `  - ${warning.file}\n    Issue: ${warning.issue}\n    Fix: ${warning.fix}\n    Reference: ${warning.section}\n\n`;
+    }
+    if (result.warnings.length > 10)
+        report += `  ... and ${result.warnings.length - 10} more warnings\n`;
+    report += `\n============================================================\nSUMMARY:\n`;
+    report += `  Critical Issues: ${crits.length}\n  Warnings: ${result.warnings.length}\n`;
+    report += `============================================================\n`;
+    if (result.issues.length === 0 && result.warnings.length === 0)
+        report += `\n[SUCCESS] No major performance issues detected!\n`;
+    else
+        report += `\n[ACTION REQUIRED] Review and fix issues above\nPriority: CRITICAL > HIGH > MEDIUM > LOW\n`;
+    return { passed: result.passed, report };
+}

package/build/tools/validators/schemaValidator.js

@@ -0,0 +1,105 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export async function findSchemaFiles(projectPath) {
+    const schemas = [];
+    async function search(dir) {
+        try {
+            const items = await fs.readdir(dir, { withFileTypes: true });
+            for (const item of items) {
+                if (['node_modules', '.git', 'dist'].includes(item.name))
+                    continue;
+                const fullPath = path.join(dir, item.name);
+                if (item.isDirectory()) {
+                    await search(fullPath);
+                }
+                else {
+                    if (item.name === 'schema.prisma') {
+                        schemas.push(fullPath);
+                    }
+                    else if (fullPath.includes('drizzle') || fullPath.includes('schema') || fullPath.includes('table')) {
+                        if (item.name.endsWith('.ts'))
+                            schemas.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    await search(projectPath);
+    return schemas.slice(0, 10);
+}
+export async function validatePrismaSchema(filePath) {
+    const issues = [];
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        // Match models roughly: model Name { body }
+        const modelMatches = [...content.matchAll(/model\s+(\w+)\s*{([^}]+)}/g)];
+        for (const match of modelMatches) {
+            const modelName = match[1];
+            const modelBody = match[2];
+            if (modelName[0] !== modelName[0].toUpperCase()) {
+                issues.push(`Model '${modelName}' should be PascalCase`);
+            }
+            if (!modelBody.includes('@id') && !modelBody.toLowerCase().includes('id')) {
+                issues.push(`Model '${modelName}' might be missing @id field`);
+            }
+            if (!modelBody.includes('createdAt') && !modelBody.includes('created_at')) {
+                issues.push(`Model '${modelName}' missing createdAt field (recommended)`);
+            }
+            // Check for index suggestions
+            const fks = [...modelBody.matchAll(/(\w+Id)\s+\w+/g)].map(m => m[1]);
+            for (const fk of fks) {
+                if (!content.includes(`@@index([${fk}])`) && !content.includes(`@@index(["${fk}"])`)) {
+                    issues.push(`Consider adding @@index([${fk}]) for better query in ${modelName}`);
+                }
+            }
+        }
+        const enumMatches = [...content.matchAll(/enum\s+(\w+)\s*{/g)];
+        for (const match of enumMatches) {
+            if (match[1][0] !== match[1][0].toUpperCase()) {
+                issues.push(`Enum '${match[1]}' should be PascalCase`);
+            }
+        }
+    }
+    catch (e) {
+        issues.push(`Error reading schema: ${e.message.substring(0, 50)}`);
+    }
+    return issues;
+}
+export async function runSchemaValidator(projectPath = ".") {
+    const root = path.resolve(projectPath);
+    let report = `============================================================\n`;
+    report += `[SCHEMA VALIDATOR] Database Schema Validation\n`;
+    report += `============================================================\n`;
+    report += `Project: ${root}\n------------------------------------------------------------\n`;
+    const schemas = await findSchemaFiles(root);
+    report += `Found ${schemas.length} schema files\n`;
+    if (schemas.length === 0) {
+        report += "No schema files found\n";
+        return { passed: true, report };
+    }
+    const allIssues = [];
+    for (const file of schemas) {
+        const type = file.endsWith('.prisma') ? 'prisma' : 'drizzle';
+        report += `\nValidating: ${path.basename(file)} (${type})\n`;
+        const issues = type === 'prisma' ? await validatePrismaSchema(file) : [];
+        if (issues.length > 0) {
+            allIssues.push({ file: path.basename(file), type, issues });
+        }
+    }
+    report += `\n============================================================\nSCHEMA ISSUES\n============================================================\n`;
+    if (allIssues.length > 0) {
+        for (const item of allIssues) {
+            report += `\n${item.file} (${item.type}):\n`;
+            for (const issue of item.issues.slice(0, 5)) {
+                report += `  - ${issue}\n`;
+            }
+            if (item.issues.length > 5)
+                report += `  ... and ${item.issues.length - 5} more issues\n`;
+        }
+    }
+    else {
+        report += "No schema issues found!\n";
+    }
+    return { passed: true, report }; // Schema is usually just warnings
+}

package/build/tools/validators/securityScan.js

@@ -0,0 +1,215 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+// Patterns to mimic security_scan.py
+const SECRET_PATTERNS = [
+    { regex: /api[_-]?key\s*[=:]\s*["'][^"']{10,}["']/i, type: "API Key", severity: "high" },
+    { regex: /token\s*[=:]\s*["'][^"']{10,}["']/i, type: "Token", severity: "high" },
+    { regex: /bearer\s+[a-zA-Z0-9\-_.]+/i, type: "Bearer Token", severity: "critical" },
+    { regex: /AKIA[0-9A-Z]{16}/, type: "AWS Access Key", severity: "critical" },
+    { regex: /password\s*[=:]\s*["'][^"']{4,}["']/i, type: "Password", severity: "high" },
+    { regex: /(mongodb|postgres|mysql|redis):\/\/[^\s"']+/, type: "Database Connection", severity: "critical" },
+    { regex: /-----BEGIN\s+(RSA|PRIVATE|EC)\s+KEY-----/, type: "Private Key", severity: "critical" },
+];
+const DANGEROUS_PATTERNS = [
+    { regex: /eval\s*\(/i, name: "eval() usage", severity: "critical", category: "Code Injection risk" },
+    { regex: /child_process\.exec\s*\(/i, name: "child_process.exec", severity: "high", category: "Command Injection risk" },
+    { regex: /\.innerHTML\s*=/i, name: "innerHTML assignment", severity: "medium", category: "XSS risk" },
+    { regex: /dangerouslySetInnerHTML/i, name: "dangerouslySetInnerHTML", severity: "high", category: "XSS risk" },
+    { regex: /verify\s*=\s*False/i, name: "SSL Verify Disabled", severity: "high", category: "MITM risk" },
+    { regex: /disable[_-]?ssl/i, name: "SSL Disabled", severity: "high", category: "MITM risk" }
+];
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '__pycache__', '.venv', 'venv', '.next']);
+const CODE_EXTENSIONS = new Set(['.js', '.ts', '.jsx', '.tsx', '.py', '.go', '.java', '.rb', '.php']);
+const CONFIG_EXTENSIONS = new Set(['.json', '.yaml', '.yml', '.toml', '.env', '.env.local', '.env.development']);
+async function getFilesByExtensions(dir, extensions) {
+    let files = [];
+    try {
+        const items = await fs.readdir(dir, { withFileTypes: true });
+        for (const item of items) {
+            if (SKIP_DIRS.has(item.name))
+                continue;
+            const fullPath = path.join(dir, item.name);
+            if (item.isDirectory()) {
+                files = files.concat(await getFilesByExtensions(fullPath, extensions));
+            }
+            else if (extensions.has(path.extname(item.name).toLowerCase())) {
+                files.push(fullPath);
+            }
+        }
+    }
+    catch { } // Ignore read errors
+    return files;
+}
+export async function scanDependencies(projectPath) {
+    const results = { tool: "dependency_scanner", findings: [], status: "[OK] Secure" };
+    const lockFiles = {
+        "npm": ["package-lock.json", "npm-shrinkwrap.json"],
+        "yarn": ["yarn.lock"],
+        "pnpm": ["pnpm-lock.yaml"],
+        "pip": ["requirements.txt", "Pipfile.lock", "poetry.lock"],
+    };
+    for (const [manager, files] of Object.entries(lockFiles)) {
+        const pkgFile = manager === 'pip' ? 'requirements.txt' : 'package.json';
+        if (existsSync(path.join(projectPath, pkgFile))) {
+            const hasLock = files.some(f => existsSync(path.join(projectPath, f)));
+            if (!hasLock) {
+                results.findings.push({
+                    type: "Missing Lock File",
+                    severity: "high",
+                    message: `${manager}: No lock file found. Supply chain integrity at risk.`
+                });
+            }
+        }
+    }
+    if (existsSync(path.join(projectPath, "package.json"))) {
+        await new Promise((resolve) => {
+            const cmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+            const child = spawn(cmd, ['audit', '--json'], { cwd: projectPath });
+            let out = '';
+            child.stdout.on('data', d => out += d.toString());
+            child.on('close', () => {
+                try {
+                    const auditData = JSON.parse(out);
+                    const vulns = auditData.vulnerabilities || {};
+                    let crit = 0, high = 0;
+                    for (const v of Object.values(vulns)) {
+                        const sev = v.severity || 'low';
+                        if (sev === 'critical')
+                            crit++;
+                        if (sev === 'high')
+                            high++;
+                    }
+                    if (crit > 0) {
+                        results.status = "[!!] Critical vulnerabilities";
+                        results.findings.push({ type: "npm audit", severity: "critical", message: `${crit} critical vulnerabilities` });
+                    }
+                    else if (high > 0) {
+                        results.status = "[!] High vulnerabilities";
+                        results.findings.push({ type: "npm audit", severity: "high", message: `${high} high vulnerabilities` });
+                    }
+                }
+                catch { }
+                resolve();
+            });
+            child.on('error', () => resolve());
+        });
+    }
+    if (results.findings.length === 0)
+        results.status = "[OK] Supply chain checks passed";
+    return results;
+}
+export async function scanSecrets(projectPath) {
+    const results = {
+        tool: "secret_scanner",
+        findings: [],
+        status: "[OK] No secrets detected",
+        scanned_files: 0,
+        by_severity: { critical: 0, high: 0, medium: 0 }
+    };
+    // Merge Sets for secret scanning
+    const exts = new Set([...CODE_EXTENSIONS, ...CONFIG_EXTENSIONS]);
+    const files = await getFilesByExtensions(projectPath, exts);
+    results.scanned_files = files.length;
+    for (const file of files) {
+        try {
+            const content = await fs.readFile(file, 'utf-8');
+            for (const pattern of SECRET_PATTERNS) {
+                const matches = content.match(new RegExp(pattern.regex, 'g'));
+                if (matches) {
+                    results.findings.push({
+                        file: path.relative(projectPath, file),
+                        type: pattern.type,
+                        severity: pattern.severity,
+                        count: matches.length
+                    });
+                    results.by_severity[pattern.severity] += matches.length;
+                }
+            }
+        }
+        catch { }
+    }
+    if (results.by_severity.critical > 0)
+        results.status = "[!!] CRITICAL: Secrets exposed!";
+    else if (results.by_severity.high > 0)
+        results.status = "[!] HIGH: Secrets found";
+    else if (results.by_severity.high > 0 || results.by_severity.medium > 0)
+        results.status = "[?] Potential secrets detected";
+    results.findings = results.findings.slice(0, 15);
+    return results;
+}
+export async function scanCodePatterns(projectPath) {
+    const results = {
+        tool: "pattern_scanner",
+        findings: [],
+        status: "[OK] No dangerous patterns",
+        scanned_files: 0,
+        by_category: {}
+    };
+    const files = await getFilesByExtensions(projectPath, CODE_EXTENSIONS);
+    results.scanned_files = files.length;
+    for (const file of files) {
+        try {
+            const content = await fs.readFile(file, 'utf-8');
+            const lines = content.split('\n');
+            lines.forEach((line, index) => {
+                for (const pattern of DANGEROUS_PATTERNS) {
+                    if (pattern.regex.test(line)) {
+                        results.findings.push({
+                            file: path.relative(projectPath, file),
+                            line: index + 1,
+                            pattern: pattern.name,
+                            severity: pattern.severity,
+                            category: pattern.category,
+                            snippet: line.trim().substring(0, 80)
+                        });
+                        results.by_category[pattern.category] = (results.by_category[pattern.category] || 0) + 1;
+                    }
+                }
+            });
+        }
+        catch { }
+    }
+    const critCount = results.findings.filter(f => f.severity === 'critical').length;
+    const highCount = results.findings.filter(f => f.severity === 'high').length;
+    if (critCount > 0)
+        results.status = `[!!] CRITICAL: ${critCount} dangerous patterns`;
+    else if (highCount > 0)
+        results.status = `[!] HIGH: ${highCount} risky patterns`;
+    else if (results.findings.length > 0)
+        results.status = "[?] Some patterns need review";
+    results.findings = results.findings.slice(0, 20);
+    return results;
+}
+export async function runSecurityScan(projectPath = ".", scanType = "all") {
+    const report = {
+        project: path.resolve(projectPath),
+        timestamp: new Date().toISOString(),
+        scan_type: scanType,
+        scans: {},
+        summary: { total_findings: 0, critical: 0, high: 0, overall_status: "[OK] SECURE" }
+    };
+    if (scanType === "all" || scanType === "deps")
+        report.scans.dependencies = await scanDependencies(projectPath);
+    if (scanType === "all" || scanType === "secrets")
+        report.scans.secrets = await scanSecrets(projectPath);
+    if (scanType === "all" || scanType === "patterns")
+        report.scans.code_patterns = await scanCodePatterns(projectPath);
+    for (const scan of Object.values(report.scans)) {
+        report.summary.total_findings += scan.findings.length;
+        for (const finding of scan.findings) {
+            if (finding.severity === 'critical')
+                report.summary.critical++;
+            if (finding.severity === 'high')
+                report.summary.high++;
+        }
+    }
+    if (report.summary.critical > 0)
+        report.summary.overall_status = "[!!] CRITICAL ISSUES FOUND";
+    else if (report.summary.high > 0)
+        report.summary.overall_status = "[!] HIGH RISK ISSUES";
+    else if (report.summary.total_findings > 0)
+        report.summary.overall_status = "[?] REVIEW RECOMMENDED";
+    return report;
+}

package/build/tools/validators/seoChecker.js

@@ -0,0 +1,122 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+const SKIP_DIRS = ['node_modules', '.next', 'dist', 'build', '.git', '.github', '.vscode', '.idea', 'coverage', 'test', 'tests', '__tests__', 'spec', 'docs', 'documentation', 'examples'];
+const SKIP_PATTERNS = ['config', 'setup', 'util', 'helper', 'hook', 'context', 'store', 'service', 'api', 'lib', 'constant', 'type', 'interface', 'mock', '.test.', '.spec.', '_test.', '_spec.'];
+function isPageFile(filePath) {
+    const name = path.basename(filePath).toLowerCase();
+    const stem = path.parse(filePath).name.toLowerCase();
+    if (SKIP_PATTERNS.some(skip => name.includes(skip)))
+        return false;
+    const parts = filePath.toLowerCase().split(path.sep);
+    const pageDirs = ['pages', 'app', 'routes', 'views', 'screens'];
+    if (pageDirs.some(d => parts.includes(d)))
+        return true;
+    const pageNames = ['page', 'index', 'home', 'about', 'contact', 'blog', 'post', 'article', 'product', 'landing', 'layout'];
+    if (pageNames.some(p => stem.includes(p)))
+        return true;
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === '.html' || ext === '.htm')
+        return true;
+    return false;
+}
+export async function checkSeoPage(filePath) {
+    const issues = [];
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const isLayout = content.includes('Head>') || content.toLowerCase().includes('<head');
+        if (isLayout && !content.toLowerCase().includes('<title') && !content.includes('title=')) {
+            issues.push("Missing <title> tag");
+        }
+        if (isLayout && !content.toLowerCase().includes('name="description"') && !content.toLowerCase().includes("name='description'")) {
+            issues.push("Missing meta description");
+        }
+        if (isLayout && !content.includes('og:') && !content.toLowerCase().includes('property="og:')) {
+            issues.push("Missing Open Graph tags");
+        }
+        const h1Matches = content.match(/<h1[^>]*>/gi) || [];
+        if (h1Matches.length > 1) {
+            issues.push(`Multiple H1 tags (${h1Matches.length})`);
+        }
+        const imgMatches = content.match(/<img[^>]+>/gi) || [];
+        for (const img of imgMatches) {
+            const imgLower = img.toLowerCase();
+            if (!imgLower.includes('alt=')) {
+                issues.push("Image missing alt attribute");
+                break;
+            }
+            if (img.includes('alt=""') || img.includes("alt=''")) {
+                issues.push("Image has empty alt attribute");
+                break;
+            }
+        }
+        return { file: path.basename(filePath), issues };
+    }
+    catch (e) {
+        return { file: path.basename(filePath), issues: [`Error: ${e.message}`] };
+    }
+}
+export async function runSeoChecker(projectPath = ".") {
+    const pages = [];
+    const root = path.resolve(projectPath);
+    async function search(dir) {
+        if (pages.length >= 50)
+            return;
+        try {
+            const items = await fs.readdir(dir, { withFileTypes: true });
+            for (const item of items) {
+                if (SKIP_DIRS.includes(item.name))
+                    continue;
+                const fullPath = path.join(dir, item.name);
+                if (item.isDirectory()) {
+                    await search(fullPath);
+                }
+                else if (/\.(html|htm|jsx|tsx)$/i.test(item.name)) {
+                    if (isPageFile(fullPath)) {
+                        pages.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    await search(root);
+    let report = `============================================================\n`;
+    report += `SEO CHECKER - Search Engine Optimization Audit\n`;
+    report += `============================================================\n`;
+    if (pages.length === 0) {
+        report += `\n[!] No page files found.\n`;
+        return { passed: true, report };
+    }
+    report += `Found ${pages.length} page files to analyze\n\n`;
+    report += `============================================================\n`;
+    report += `SEO ANALYSIS RESULTS\n`;
+    report += `============================================================\n`;
+    const allIssues = [];
+    for (const page of pages) {
+        const result = await checkSeoPage(page);
+        if (result.issues.length > 0) {
+            allIssues.push(result);
+        }
+    }
+    if (allIssues.length > 0) {
+        const counts = {};
+        allIssues.forEach(item => {
+            item.issues.forEach(issue => counts[issue] = (counts[issue] || 0) + 1);
+        });
+        report += `\nIssue Summary:\n`;
+        Object.entries(counts).sort((a, b) => b[1] - a[1]).forEach(([issue, count]) => {
+            report += `  [${count}] ${issue}\n`;
+        });
+        report += `\nAffected files (${allIssues.length}):\n`;
+        for (const item of allIssues.slice(0, 5)) {
+            report += `  - ${item.file}\n`;
+        }
+        if (allIssues.length > 5)
+            report += `  ... and ${allIssues.length - 5} more\n`;
+    }
+    else {
+        report += `\n[OK] No SEO issues found!\n`;
+    }
+    const totalIssues = allIssues.reduce((sum, item) => sum + item.issues.length, 0);
+    return { passed: totalIssues === 0, report };
+}