superkit-mcp-server 1.0.1 → 1.0.2

package/build/tools/validators/i18nChecker.js

@@ -0,0 +1,205 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+const HARDCODED_PATTERNS = {
+    'jsx': [
+        // Text directly in JSX: <div>Hello World</div>
+        '>\\s*[A-Z][a-zA-Z\\s]{3,30}\\s*</',
+        // JSX attribute strings: title="Welcome"
+        '(title|placeholder|label|alt|aria-label)="[A-Z][a-zA-Z\\s]{2,}"',
+        // Button/heading text
+        '<(button|h[1-6]|p|span|label)[^>]*>\\s*[A-Z][a-zA-Z\\s!?.,]{3,}\\s*</',
+    ],
+    'vue': [
+        '>\\s*[A-Z][a-zA-Z\\s]{3,30}\\s*</',
+        '(placeholder|label|title)="[A-Z][a-zA-Z\\s]{2,}"',
+    ],
+    'python': [
+        '(print|raise\\s+\\w+)\\s*\\(\\s*["\'][A-Z][^"\']{5,}["\']',
+        'flash\\s*\\(\\s*["\'][A-Z][^"\']{5,}["\']',
+    ]
+};
+const I18N_PATTERNS = [
+    't\\(["\']',
+    'useTranslation',
+    '\\$t\\(',
+    '_\\(["\']',
+    'gettext\\(',
+    'useTranslations',
+    'FormattedMessage',
+    'i18n\\.'
+];
+export async function findLocaleFiles(projectPath) {
+    let files = [];
+    async function search(dir) {
+        try {
+            const items = await fs.readdir(dir, { withFileTypes: true });
+            for (const item of items) {
+                if (item.name === 'node_modules' || item.name === '.git')
+                    continue;
+                const fullPath = path.join(dir, item.name);
+                if (item.isDirectory())
+                    await search(fullPath);
+                else {
+                    const lpath = fullPath.toLowerCase();
+                    if ((lpath.includes('locales') || lpath.includes('translations') || lpath.includes('lang') ||
+                        lpath.includes('i18n') || lpath.includes('messages')) && lpath.endsWith('.json')) {
+                        files.push(fullPath);
+                    }
+                    else if (lpath.endsWith('.po')) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    await search(projectPath);
+    return files;
+}
+function flattenKeys(d, prefix = '') {
+    let keys = new Set();
+    for (const [k, v] of Object.entries(d)) {
+        const newKey = prefix ? `${prefix}.${k}` : k;
+        if (v && typeof v === 'object' && !Array.isArray(v)) {
+            for (const childKey of flattenKeys(v, newKey))
+                keys.add(childKey);
+        }
+        else {
+            keys.add(newKey);
+        }
+    }
+    return keys;
+}
+export async function checkLocaleCompleteness(localeFiles) {
+    const passed = [];
+    const issues = [];
+    if (localeFiles.length === 0)
+        return { passed, issues: ["[!] No locale files found"] };
+    const locales = {};
+    for (const file of localeFiles) {
+        if (file.endsWith('.json')) {
+            try {
+                const lang = path.basename(path.dirname(file));
+                const content = JSON.parse(await fs.readFile(file, 'utf-8'));
+                if (!locales[lang])
+                    locales[lang] = {};
+                locales[lang][path.parse(file).name] = flattenKeys(content);
+            }
+            catch { }
+        }
+    }
+    const allLangs = Object.keys(locales);
+    if (allLangs.length < 2) {
+        passed.push(`[OK] Found ${localeFiles.length} locale file(s)`);
+        return { passed, issues };
+    }
+    passed.push(`[OK] Found ${allLangs.length} language(s): ${allLangs.join(', ')}`);
+    const baseLang = allLangs[0];
+    for (const [namespace, baseKeys] of Object.entries(locales[baseLang] || {})) {
+        for (let i = 1; i < allLangs.length; i++) {
+            const lang = allLangs[i];
+            const otherKeys = (locales[lang] || {})[namespace] || new Set();
+            let missing = 0;
+            for (const k of baseKeys)
+                if (!otherKeys.has(k))
+                    missing++;
+            if (missing > 0)
+                issues.push(`[X] ${lang}/${namespace}: Missing ${missing} keys`);
+            let extra = 0;
+            for (const k of otherKeys)
+                if (!baseKeys.has(k))
+                    extra++;
+            if (extra > 0)
+                issues.push(`[!] ${lang}/${namespace}: ${extra} extra keys`);
+        }
+    }
+    if (issues.length === 0)
+        passed.push("[OK] All locales have matching keys");
+    return { passed, issues };
+}
+export async function checkHardcodedStrings(projectPath) {
+    const passed = [];
+    const issues = [];
+    const exts = { '.tsx': 'jsx', '.jsx': 'jsx', '.ts': 'jsx', '.js': 'jsx', '.vue': 'vue', '.py': 'python' };
+    let codeFiles = [];
+    async function search(dir) {
+        try {
+            const items = await fs.readdir(dir, { withFileTypes: true });
+            for (const item of items) {
+                if (['node_modules', '.git', 'dist', 'build', '__pycache__', 'venv', 'test', 'spec'].includes(item.name))
+                    continue;
+                const fullPath = path.join(dir, item.name);
+                if (item.isDirectory())
+                    await search(fullPath);
+                else if (exts[path.extname(item.name)])
+                    codeFiles.push(fullPath);
+            }
+        }
+        catch { }
+    }
+    await search(projectPath);
+    if (codeFiles.length === 0)
+        return { passed: ["[!] No code files found"], issues };
+    let filesWithI18n = 0;
+    let filesWithHardcoded = 0;
+    const examples = [];
+    for (const file of codeFiles.slice(0, 50)) {
+        try {
+            const content = await fs.readFile(file, 'utf-8');
+            const type = exts[path.extname(file)] || 'jsx';
+            const hasI18n = I18N_PATTERNS.some(p => new RegExp(p).test(content));
+            if (hasI18n)
+                filesWithI18n++;
+            let hardcodedFound = false;
+            for (const pattern of HARDCODED_PATTERNS[type] || []) {
+                const match = content.match(new RegExp(pattern));
+                if (match && !hasI18n) {
+                    hardcodedFound = true;
+                    if (examples.length < 5)
+                        examples.push(`${path.basename(file)}: ${match[0].substring(0, 40)}...`);
+                }
+            }
+            if (hardcodedFound)
+                filesWithHardcoded++;
+        }
+        catch { }
+    }
+    passed.push(`[OK] Analyzed ${codeFiles.length} code files`);
+    if (filesWithI18n > 0)
+        passed.push(`[OK] ${filesWithI18n} files use i18n`);
+    if (filesWithHardcoded > 0) {
+        issues.push(`[X] ${filesWithHardcoded} files may have hardcoded strings`);
+        for (const ex of examples)
+            issues.push(`   -> ${ex}`);
+    }
+    else {
+        passed.push("[OK] No obvious hardcoded strings detected");
+    }
+    return { passed, issues };
+}
+export async function runI18nChecker(projectPath = ".") {
+    const root = path.resolve(projectPath);
+    let report = `============================================================\n`;
+    report += `  i18n CHECKER - Internationalization Audit\n`;
+    report += `============================================================\n\n`;
+    const localeFiles = await findLocaleFiles(root);
+    const localeRes = await checkLocaleCompleteness(localeFiles);
+    const codeRes = await checkHardcodedStrings(root);
+    report += `[LOCALE FILES]\n----------------------------------------\n`;
+    for (const p of localeRes.passed)
+        report += `  ${p}\n`;
+    for (const i of localeRes.issues)
+        report += `  ${i}\n`;
+    report += `\n[CODE ANALYSIS]\n----------------------------------------\n`;
+    for (const p of codeRes.passed)
+        report += `  ${p}\n`;
+    for (const i of codeRes.issues)
+        report += `  ${i}\n`;
+    const criticals = [...localeRes.issues, ...codeRes.issues].filter(i => i.startsWith("[X]")).length;
+    report += `\n============================================================\n`;
+    if (criticals === 0)
+        report += `[OK] i18n CHECK: PASSED\n`;
+    else
+        report += `[X] i18n CHECK: ${criticals} issues found\n`;
+    return { passed: criticals === 0, report };
+}

package/build/tools/validators/lighthouseAudit.js

@@ -0,0 +1,50 @@
+import { exec } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { promisify } from 'util';
+import * as os from 'os';
+const execAsync = promisify(exec);
+export async function runLighthouseAudit(url) {
+    const tempFilePath = path.join(os.tmpdir(), `lighthouse-${Date.now()}.json`);
+    let report = `============================================================\n`;
+    report += `LIGHTHOUSE AUDIT REPORT for ${url}\n`;
+    report += `============================================================\n`;
+    try {
+        await execAsync(`lighthouse "${url}" --output=json --output-path="${tempFilePath}" --chrome-flags="--headless" --only-categories=performance,accessibility,best-practices,seo`);
+    }
+    catch (error) {
+        // Lighthouse sometimes exits with code 1 even when the report is valid generated
+        // We will proceed to check if the file was created
+    }
+    try {
+        const fileContent = await fs.readFile(tempFilePath, 'utf-8');
+        const data = JSON.parse(fileContent);
+        await fs.unlink(tempFilePath).catch(() => { }); // cleanup
+        const categories = data.categories || {};
+        const performance = Math.round((categories.performance?.score || 0) * 100);
+        const accessibility = Math.round((categories.accessibility?.score || 0) * 100);
+        const bestPractices = Math.round((categories['best-practices']?.score || 0) * 100);
+        const seo = Math.round((categories.seo?.score || 0) * 100);
+        report += `Performance: ${performance}/100\n`;
+        report += `Accessibility: ${accessibility}/100\n`;
+        report += `Best Practices: ${bestPractices}/100\n`;
+        report += `SEO: ${seo}/100\n\n`;
+        // Using average for pass/fail logic
+        const avg = (performance + accessibility + bestPractices + seo) / 4;
+        if (performance >= 90) {
+            report += `[OK] Excellent performance\n`;
+        }
+        else if (performance >= 50) {
+            report += `[!] Needs improvement\n`;
+        }
+        else {
+            report += `[X] Poor performance\n`;
+        }
+        return { passed: avg >= 80, report };
+    }
+    catch (e) {
+        report += `[ERROR] Failed to read or parse Lighthouse report: ${e.message}\n`;
+        report += `Ensure Lighthouse CLI is installed globally (npm install -g lighthouse).\n`;
+        return { passed: false, report };
+    }
+}

package/build/tools/validators/lintRunner.js

@@ -0,0 +1,106 @@
+import * as fs from 'fs/promises';
+import { existsSync } from 'fs';
+import * as path from 'path';
+import { spawn } from 'child_process';
+export async function detectProjectType(projectPath) {
+    const result = { type: 'unknown', linters: [] };
+    const root = path.resolve(projectPath);
+    const pkgPath = path.join(root, 'package.json');
+    if (existsSync(pkgPath)) {
+        result.type = 'node';
+        try {
+            const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+            const scripts = pkg.scripts || {};
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (scripts['lint']) {
+                result.linters.push({ name: 'npm lint', cmd: ['npm', 'run', 'lint'] });
+            }
+            else if (deps['eslint']) {
+                result.linters.push({ name: 'eslint', cmd: ['npx', 'eslint', '.'] });
+            }
+            if (deps['typescript'] || existsSync(path.join(root, 'tsconfig.json'))) {
+                result.linters.push({ name: 'tsc', cmd: ['npx', 'tsc', '--noEmit'] });
+            }
+        }
+        catch { }
+    }
+    if (existsSync(path.join(root, 'pyproject.toml')) || existsSync(path.join(root, 'requirements.txt'))) {
+        result.type = 'python';
+        result.linters.push({ name: 'ruff', cmd: ['ruff', 'check', '.'] });
+        if (existsSync(path.join(root, 'mypy.ini')) || existsSync(path.join(root, 'pyproject.toml'))) {
+            result.linters.push({ name: 'mypy', cmd: ['mypy', '.'] });
+        }
+    }
+    return result;
+}
+export async function runLinter(linter, cwd) {
+    return new Promise((resolve) => {
+        let cmd = linter.cmd[0];
+        const args = linter.cmd.slice(1);
+        // Handle npx/npm on windows
+        if (process.platform === 'win32' && (cmd === 'npm' || cmd === 'npx')) {
+            cmd += '.cmd';
+        }
+        const child = spawn(cmd, args, { cwd, shell: true });
+        let out = '';
+        let err = '';
+        child.stdout.on('data', d => out += d.toString());
+        child.stderr.on('data', d => err += d.toString());
+        child.on('close', code => {
+            resolve({
+                name: linter.name,
+                passed: code === 0,
+                output: out.substring(0, 2000),
+                error: err.substring(0, 500)
+            });
+        });
+        child.on('error', e => {
+            resolve({
+                name: linter.name,
+                passed: false,
+                output: '',
+                error: e.message
+            });
+        });
+        setTimeout(() => {
+            child.kill();
+            resolve({
+                name: linter.name,
+                passed: false,
+                output: '',
+                error: 'Timeout after 120s'
+            });
+        }, 120000);
+    });
+}
+export async function runLintRunner(projectPath = ".") {
+    const root = path.resolve(projectPath);
+    let report = `============================================================\n`;
+    report += `[LINT RUNNER] Unified Linting\n`;
+    report += `============================================================\n`;
+    report += `Project: ${root}\n`;
+    const info = await detectProjectType(root);
+    report += `Type: ${info.type}\n`;
+    report += `Linters: ${info.linters.length}\n------------------------------------------------------------\n`;
+    if (info.linters.length === 0) {
+        report += "No linters found for this project type.\n";
+        return { passed: true, report };
+    }
+    let allPassed = true;
+    for (const linter of info.linters) {
+        report += `\nRunning: ${linter.name}...\n`;
+        const result = await runLinter(linter, root);
+        if (result.passed) {
+            report += `  [PASS] ${linter.name}\n`;
+        }
+        else {
+            report += `  [FAIL] ${linter.name}\n`;
+            if (result.error)
+                report += `  Error: ${result.error.substring(0, 200)}\n`;
+            allPassed = false;
+        }
+    }
+    report += `\n============================================================\nSUMMARY\n============================================================\n`;
+    report += allPassed ? "[OK] LINT CHECKS PASSED\n" : "[X] LINT CHECKS FAILED\n";
+    return { passed: allPassed, report };
+}

package/build/tools/validators/mobileAudit.js

@@ -0,0 +1,190 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+class MobileAuditor {
+    issues = [];
+    warnings = [];
+    passed_count = 0;
+    files_checked = 0;
+    async auditFile(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const isReactNative = /react-native|@react-navigation|React\.Native/.test(content);
+            const isFlutter = /import 'package:flutter|MaterialApp|Widget\.build/.test(content);
+            if (!isReactNative && !isFlutter)
+                return;
+            this.files_checked++;
+            const filename = path.basename(filePath);
+            // Touch Psychology
+            const smallSizes = [...content.matchAll(/(?:width|height|size):\s*([0-3]\d)/g)];
+            for (const match of smallSizes) {
+                if (parseInt(match[1]) < 44)
+                    this.issues.push(`[Touch Target] ${filename}: size ${match[1]}px < 44px`);
+            }
+            const smallGaps = [...content.matchAll(/(?:margin|gap):\s*([0-7])\s*(?:px|dp)/g)];
+            for (const match of smallGaps) {
+                if (parseInt(match[1]) < 8)
+                    this.warnings.push(`[Touch Spacing] ${filename}: gap ${match[1]}px < 8px`);
+            }
+            const hasPrimaryBtn = /(?:testID|id):\s*["'](?:.*(?:primary|cta|submit|confirm)[^"']*)["']/i.test(content);
+            const hasBottomObj = /position:\s*["']?absolute["']?|bottom:\s*\d+|style.*bottom|justifyContent:\s*["']?flex-end/.test(content);
+            if (hasPrimaryBtn && !hasBottomObj)
+                this.warnings.push(`[Thumb Zone] ${filename}: Primary CTA may not be at bottom`);
+            if (/Swipeable|onSwipe|PanGestureHandler|swipe/.test(content) && !/Button.*(?:delete|archive|more)|TouchableOpacity|Pressable/.test(content)) {
+                this.warnings.push(`[Gestures] ${filename}: Swipe without visible button alternative`);
+            }
+            if (/(?:onPress|onSubmit|delete|remove|confirm|purchase)/.test(content) && !/Haptics|Vibration|react-native-haptic-feedback|FeedbackManager/.test(content)) {
+                this.warnings.push(`[Haptics] ${filename}: Important action without haptics`);
+            }
+            if (isReactNative && /Pressable|TouchableOpacity/.test(content) && !/pressed|style.*opacity|underlay/.test(content)) {
+                this.warnings.push(`[Touch Feedback] ${filename}: Pressable without visual feedback state`);
+            }
+            // Performance
+            if (/<ScrollView|ScrollView\./.test(content) && /ScrollView.*\.map\(|ScrollView.*\{.*\.map/s.test(content)) {
+                this.issues.push(`[Performance CRITICAL] ${filename}: ScrollView with .map() detected. Use FlatList.`);
+            }
+            if (isReactNative && /FlatList|FlashList|SectionList/.test(content) && !/React\.memo|memo\(/.test(content)) {
+                this.warnings.push(`[Performance] ${filename}: List without React.memo`);
+            }
+            if (isReactNative && /FlatList|FlashList/.test(content) && !/useCallback/.test(content)) {
+                this.warnings.push(`[Performance] ${filename}: FlatList renderItem without useCallback`);
+            }
+            if (isReactNative && /FlatList/.test(content)) {
+                if (!/keyExtractor/.test(content))
+                    this.issues.push(`[Performance CRITICAL] ${filename}: FlatList without keyExtractor`);
+                if (/key=\{.*index.*?\}|key:\s*index/.test(content))
+                    this.issues.push(`[Performance CRITICAL] ${filename}: Using index as key`);
+            }
+            if (isReactNative && /Animated\./.test(content)) {
+                if (/useNativeDriver:\s*false/.test(content))
+                    this.warnings.push(`[Performance] ${filename}: Animation.useNativeDriver is false`);
+                if (!/useNativeDriver/.test(content))
+                    this.warnings.push(`[Performance] ${filename}: Animated without useNativeDriver`);
+            }
+            if (isReactNative && /useEffect/.test(content) && /addEventListener|subscribe|\.focus\(\)|\.off\(/.test(content) && !/return\s*\(\)\s*=>|return\s+function/.test(content)) {
+                this.issues.push(`[Memory Leak] ${filename}: useEffect subscription without cleanup`);
+            }
+            const consoleCount = (content.match(/console\.(log|warn|error|debug)/g) || []).length;
+            if (consoleCount > 5)
+                this.warnings.push(`[Performance] ${filename}: ${consoleCount} console statements logs`);
+            if (isReactNative) {
+                const inlines = (content.match(/(?:onPress|onPressIn|onPressOut|renderItem):\s*\([^)]*\)\s*=>/g) || []).length;
+                if (inlines > 3)
+                    this.warnings.push(`[Performance] ${filename}: ${inlines} inline functions in props`);
+            }
+            if (/Animated\.timing.*(?:width|height|margin|padding)/.test(content)) {
+                this.issues.push(`[Performance] ${filename}: Animating layout properties instead of transform/opacity`);
+            }
+            // Navigation
+            const tabs = (content.match(/Tab\.Screen|createBottomTabNavigator|BottomTab/g) || []).length;
+            if (tabs > 5)
+                this.warnings.push(`[Navigation] ${filename}: ${tabs} tab items (max 5)`);
+            if (/createBottomTabNavigator|Tab\.Navigator/.test(content) && !/lazy:\s*false/.test(content)) {
+                this.warnings.push(`[Navigation] ${filename}: Tab bar without lazy: false`);
+            }
+            if (/(onBackPress|handleBackPress)/.test(content) && !/(BackHandler|useFocusEffect|navigation\.addListener)/.test(content)) {
+                this.warnings.push(`[Navigation] ${filename}: Custom back handling without BackHandler listnener`);
+            }
+            const hasLinkConfig = /apollo-link|react-native-screens|navigation\.link/.test(content);
+            if (/Linking\.|Linking\.openURL|deepLink|universalLink/.test(content) && !hasLinkConfig) {
+                this.warnings.push(`[Navigation] ${filename}: Deep linking detected but lacks configuration.`);
+            }
+            else if (!hasLinkConfig) {
+                this.passed_count++;
+            }
+            // Typography
+            if (isReactNative) {
+                if (/fontFamily:\s*["'][^"']+/.test(content) && !/fontFamily:\s*["']?(?:System|San Francisco|Roboto|-apple-system)/.test(content)) {
+                    this.warnings.push(`[Typography] ${filename}: Custom font detected instead of system fonts`);
+                }
+                if (/fontSize:/.test(content) && !/allowFontScaling:\s*true|responsiveFontSize|useWindowDimensions/.test(content)) {
+                    this.warnings.push(`[Typography] ${filename}: Fixed font sizes without scaling support`);
+                }
+            }
+            const lineHeights = [...content.matchAll(/lineHeight:\s*([\d.]+)/g)];
+            for (const lh of lineHeights) {
+                if (parseFloat(lh[1]) > 1.8)
+                    this.warnings.push(`[Typography] ${filename}: lineHeight > 1.8`);
+            }
+            const fontSizes = [...content.matchAll(/fontSize:\s*([\d.]+)/g)];
+            for (const fs of fontSizes) {
+                const size = parseFloat(fs[1]);
+                if (size < 12)
+                    this.warnings.push(`[Typography] ${filename}: fontSize < 12px`);
+                else if (size > 32)
+                    this.warnings.push(`[Typography] ${filename}: fontSize > 32px`);
+            }
+            // Colors
+            if (/#000000|color:\s*black|backgroundColor:\s*["']?black/.test(content)) {
+                this.warnings.push(`[Color] ${filename}: Pure black #000000 detected`);
+            }
+            if (!/useColorScheme|colorScheme|appearance:\s*["']?dark/.test(content) && !/\\\?.*dark|style:\s*.*dark|isDark/.test(content)) {
+                this.warnings.push(`[Color] ${filename}: No dark mode support detected`);
+            }
+            // Backend rules
+            if (/(token|jwt|auth.*storage)/i.test(content) && /AsyncStorage|@react-native-async-storage/.test(content) && !/SecureStore|Keychain|EncryptedSharedPreferences/.test(content)) {
+                this.issues.push(`[Security] ${filename}: Storing auth token in AsyncStorage`);
+            }
+            if (/fetch|axios|netinfo|@react-native-community\/netinfo/.test(content) && !/offline|isConnected|netInfo|cache.*offline/.test(content)) {
+                this.warnings.push(`[Offline] ${filename}: Network request without offline handling`);
+            }
+            if (/Notifications|pushNotification|Firebase\.messaging|PushNotificationIOS/.test(content) && !/onNotification|addNotificationListener|notification\.open/.test(content)) {
+                this.warnings.push(`[Push] ${filename}: Push notifications without handler`);
+            }
+            // OLED & visibility
+            if (/backgroundColor:\s*["']?#[0-9A-Fa-f]{6}/.test(content) && !/#121212|#1A1A1A|#0D0D0D|#000000/.test(content)) {
+                this.warnings.push(`[Mobile Color] ${filename}: Consider OLED-optimized dark backgrounds`);
+            }
+            if (/(dark:\s*|isDark|useColorScheme|colorScheme:\s*["']?dark)/.test(content) && /(color:\s*["']?#ffffff|#fff["']?\}|textColor:\s*["']?white)/.test(content)) {
+                this.warnings.push(`[Mobile Color] ${filename}: Pure white text in dark mode`);
+            }
+        }
+        catch { }
+    }
+    async auditDirectory(dir) {
+        try {
+            const items = await fs.readdir(dir, { withFileTypes: true });
+            for (const item of items) {
+                if (['node_modules', '.git', 'dist', 'build', '.next', 'ios', 'android', '.idea'].includes(item.name))
+                    continue;
+                const fullPath = path.join(dir, item.name);
+                if (item.isDirectory()) {
+                    await this.auditDirectory(fullPath);
+                }
+                else if (/\.(tsx|ts|jsx|js|dart)$/.test(item.name)) {
+                    await this.auditFile(fullPath);
+                }
+            }
+        }
+        catch { }
+    }
+    getReport() {
+        return {
+            files_checked: this.files_checked,
+            issues: this.issues,
+            warnings: this.warnings,
+            passed_checks: this.passed_count,
+            compliant: this.issues.length === 0
+        };
+    }
+}
+export async function runMobileAudit(projectPath = ".") {
+    const root = path.resolve(projectPath);
+    const auditor = new MobileAuditor();
+    await auditor.auditDirectory(root);
+    const res = auditor.getReport();
+    let report = `\n[MOBILE AUDIT] ${res.files_checked} mobile files checked\n`;
+    report += `--------------------------------------------------\n`;
+    if (res.issues.length > 0) {
+        report += `[!] ISSUES (${res.issues.length}):\n`;
+        for (const i of res.issues.slice(0, 10))
+            report += `  - ${i}\n`;
+    }
+    if (res.warnings.length > 0) {
+        report += `[*] WARNINGS (${res.warnings.length}):\n`;
+        for (const w of res.warnings.slice(0, 15))
+            report += `  - ${w}\n`;
+    }
+    report += `[+] PASSED CHECKS: ${res.passed_checks}\n`;
+    report += `STATUS: ${res.compliant ? 'PASS' : 'FAIL'}\n`;
+    return { passed: res.compliant, report };
+}

package/build/tools/validators/playwrightRunner.js

@@ -0,0 +1,101 @@
+import { chromium } from 'playwright';
+import * as os from 'os';
+import * as path from 'path';
+export async function runPlaywrightTest(url, takeScreenshot = false) {
+    const result = {
+        url,
+        timestamp: new Date().toISOString(),
+        status: 'pending'
+    };
+    let browser;
+    try {
+        browser = await chromium.launch({ headless: true });
+        const context = await browser.newContext({
+            viewport: { width: 1280, height: 720 },
+            userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        });
+        const page = await context.newPage();
+        const consoleErrors = [];
+        page.on('console', msg => {
+            if (msg.type() === 'error')
+                consoleErrors.push(msg.text());
+        });
+        const response = await page.goto(url, { waitUntil: 'networkidle', timeout: 30000 }).catch(() => null);
+        result.page = {
+            title: await page.title().catch(() => ''),
+            url: page.url(),
+            status_code: response ? response.status() : null
+        };
+        result.health = {
+            loaded: response ? response.ok() : false,
+            has_title: !!result.page.title,
+            has_h1: (await page.locator('h1').count()) > 0,
+            has_links: (await page.locator('a').count()) > 0,
+            has_images: (await page.locator('img').count()) > 0
+        };
+        const timingStr = await page.evaluate(() => JSON.stringify({
+            dom_content_loaded: window.performance.timing.domContentLoadedEventEnd - window.performance.timing.navigationStart,
+            load_complete: window.performance.timing.loadEventEnd - window.performance.timing.navigationStart
+        }));
+        result.performance = JSON.parse(timingStr);
+        if (takeScreenshot) {
+            const screenshotDir = path.join(os.tmpdir(), "maestro_screenshots");
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const screenshotPath = path.join(screenshotDir, `screenshot_${timestamp}.png`);
+            // Note: mkdirs internally handled by playwright or Node requires `fs.mkdir`
+            await page.screenshot({ path: screenshotPath, fullPage: true });
+            result.screenshot = screenshotPath;
+            result.screenshot_note = "Saved to temp directory (auto-cleaned by OS)";
+        }
+        result.elements = {
+            links: await page.locator('a').count(),
+            buttons: await page.locator('button').count(),
+            inputs: await page.locator('input').count(),
+            images: await page.locator('img').count(),
+            forms: await page.locator('form').count()
+        };
+        result.status = result.health.loaded ? 'success' : 'failed';
+        result.summary = result.status === 'success' ? '[OK] Page loaded successfully' : '[X] Page failed to load';
+    }
+    catch (e) {
+        result.status = 'error';
+        result.error = e.message;
+        result.summary = `[X] Error: ${e.message.substring(0, 100)}`;
+    }
+    finally {
+        if (browser)
+            await browser.close().catch(() => { });
+    }
+    return result;
+}
+export async function runPlaywrightA11y(url) {
+    const result = { url, accessibility: {} };
+    let browser;
+    try {
+        browser = await chromium.launch({ headless: true });
+        const page = await browser.newPage();
+        await page.goto(url, { waitUntil: 'networkidle', timeout: 30000 });
+        result.accessibility = {
+            images_with_alt: await page.locator('img[alt]').count(),
+            images_without_alt: await page.locator('img:not([alt])').count(),
+            buttons_with_label: (await page.locator('button[aria-label]').count()) + (await page.locator('button:has-text("")').count()),
+            links_with_text: await page.locator('a:has-text("")').count(),
+            form_labels: await page.locator('label').count(),
+            headings: {
+                h1: await page.locator('h1').count(),
+                h2: await page.locator('h2').count(),
+                h3: await page.locator('h3').count()
+            }
+        };
+        result.status = 'success';
+    }
+    catch (e) {
+        result.status = 'error';
+        result.error = e.message;
+    }
+    finally {
+        if (browser)
+            await browser.close().catch(() => { });
+    }
+    return result;
+}