superkit-mcp-server 1.0.1 → 1.0.2

package/build/tools/validators/testRunner.js

@@ -0,0 +1,111 @@
+import { exec } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export async function detectTestFramework(projectPath) {
+    const result = {
+        type: 'unknown',
+        framework: null,
+        cmd: null,
+        coverageCmd: null
+    };
+    try {
+        const pkgPath = path.join(projectPath, 'package.json');
+        const pkgData = await fs.readFile(pkgPath, 'utf-8');
+        const pkg = JSON.parse(pkgData);
+        result.type = 'node';
+        const scripts = pkg.scripts || {};
+        const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+        if (scripts.test) {
+            result.framework = 'npm test';
+            result.cmd = ['npm', 'test'];
+            if (deps.vitest) {
+                result.framework = 'vitest';
+                result.coverageCmd = ['npx', 'vitest', 'run', '--coverage'];
+            }
+            else if (deps.jest) {
+                result.framework = 'jest';
+                result.coverageCmd = ['npx', 'jest', '--coverage'];
+            }
+        }
+        else if (deps.vitest) {
+            result.framework = 'vitest';
+            result.cmd = ['npx', 'vitest', 'run'];
+            result.coverageCmd = ['npx', 'vitest', 'run', '--coverage'];
+        }
+        else if (deps.jest) {
+            result.framework = 'jest';
+            result.cmd = ['npx', 'jest'];
+            result.coverageCmd = ['npx', 'jest', '--coverage'];
+        }
+    }
+    catch { }
+    // Check python
+    try {
+        const pyproject = await fs.stat(path.join(projectPath, 'pyproject.toml')).catch(() => null);
+        const reqs = await fs.stat(path.join(projectPath, 'requirements.txt')).catch(() => null);
+        if (pyproject || reqs) {
+            result.type = 'python';
+            result.framework = 'pytest';
+            result.cmd = ['python', '-m', 'pytest', '-v'];
+            result.coverageCmd = ['python', '-m', 'pytest', '--cov', '--cov-report=term-missing'];
+        }
+    }
+    catch { }
+    return result;
+}
+export async function runTestRunner(projectPath = ".", withCoverage = false) {
+    const root = path.resolve(projectPath);
+    let report = `============================================================\n`;
+    report += `[TEST RUNNER] Unified Test Execution\n`;
+    report += `============================================================\n`;
+    const info = await detectTestFramework(root);
+    report += `Type: ${info.type}\nFramework: ${info.framework}\n------------------------------------------------------------\n`;
+    if (!info.cmd) {
+        report += `No test framework found for this project.\n`;
+        return { passed: true, report };
+    }
+    const cmdArr = (withCoverage && info.coverageCmd) ? info.coverageCmd : info.cmd;
+    const cmdStr = cmdArr.join(' ');
+    report += `Running: ${cmdStr}\n------------------------------------------------------------\n`;
+    let passed = false;
+    let testsRun = 0, testsPassed = 0, testsFailed = 0;
+    let output = '';
+    try {
+        // Child process maxbuffer 5MB since test output can be huge
+        const result = await execAsync(cmdStr, { cwd: root, maxBuffer: 5 * 1024 * 1024 });
+        passed = true;
+        output = result.stdout;
+    }
+    catch (e) {
+        passed = false;
+        output = e.stdout || e.stderr || e.message;
+    }
+    // Parse stats
+    const passedMatch = output.match(/(\d+)\s+passed/i);
+    if (passedMatch)
+        testsPassed = parseInt(passedMatch[1]);
+    const failedMatch = output.match(/(\d+)\s+failed/i);
+    if (failedMatch)
+        testsFailed = parseInt(failedMatch[1]);
+    testsRun = testsPassed + testsFailed;
+    const lines = output.split('\n');
+    for (const line of lines.slice(0, 30)) {
+        report += `${line}\n`;
+    }
+    if (lines.length > 30) {
+        report += `... (${lines.length - 30} more lines)\n`;
+    }
+    report += `\n============================================================\nSUMMARY\n============================================================\n`;
+    if (passed) {
+        report += `[PASS] All tests passed\n`;
+    }
+    else {
+        report += `[FAIL] Some tests failed\n`;
+    }
+    if (testsRun > 0) {
+        report += `Tests: ${testsRun} total, ${testsPassed} passed, ${testsFailed} failed\n`;
+    }
+    return { passed, report };
+}

package/build/tools/validators/typeCoverage.js

@@ -0,0 +1,150 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+async function getFiles(dir, extensionRegex, excludeList) {
+    let files = [];
+    try {
+        const items = await fs.readdir(dir, { withFileTypes: true });
+        for (const item of items) {
+            const fullPath = path.join(dir, item.name);
+            if (excludeList.some(ex => fullPath.includes(ex)))
+                continue;
+            if (item.isDirectory()) {
+                files = files.concat(await getFiles(fullPath, extensionRegex, excludeList));
+            }
+            else if (extensionRegex.test(item.name)) {
+                files.push(fullPath);
+            }
+        }
+    }
+    catch { } // Ignore read errors
+    return files;
+}
+export async function checkTypescriptCoverage(projectPath) {
+    const passed = [];
+    const issues = [];
+    const stats = { any_count: 0, untyped_functions: 0, total_functions: 0 };
+    const exclude = ['node_modules', '.d.ts', 'dist', 'build', '.next'];
+    const tsFiles = await getFiles(projectPath, /\.(ts|tsx)$/, exclude);
+    if (tsFiles.length === 0) {
+        return { type: 'typescript', files: 0, passed, issues: ["[!] No TypeScript files found"], stats };
+    }
+    // Check first 30 files for performance
+    for (const filePath of tsFiles.slice(0, 30)) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            // any count
+            const anyMatches = content.match(/:\s*any\b/g);
+            if (anyMatches)
+                stats.any_count += anyMatches.length;
+            // untyped functions
+            const untypedFuncs = content.match(/function\s+\w+\s*\([^)]*\)\s*{/g);
+            if (untypedFuncs)
+                stats.untyped_functions += untypedFuncs.length;
+            const untypedArrows = content.match(/=\s*\([^:)]*\)\s*=>/g);
+            if (untypedArrows)
+                stats.untyped_functions += untypedArrows.length;
+            // typed functions
+            let typedCount = 0;
+            const typedFuncs = content.match(/function\s+\w+\s*\([^)]*\)\s*:\s*\w+/g);
+            if (typedFuncs)
+                typedCount += typedFuncs.length;
+            const typedArrows = content.match(/:\s*\([^)]*\)\s*=>\s*\w+/g);
+            if (typedArrows)
+                typedCount += typedArrows.length;
+            stats.total_functions += (typedCount + (untypedFuncs?.length || 0) + (untypedArrows?.length || 0));
+        }
+        catch { }
+    }
+    if (stats.any_count === 0)
+        passed.push("[OK] No 'any' types found");
+    else if (stats.any_count <= 5)
+        issues.push(`[!] ${stats.any_count} 'any' types found (acceptable)`);
+    else
+        issues.push(`[X] ${stats.any_count} 'any' types found (too many)`);
+    if (stats.total_functions > 0) {
+        const typedRatio = ((stats.total_functions - stats.untyped_functions) / stats.total_functions) * 100;
+        if (typedRatio >= 80)
+            passed.push(`[OK] Type coverage: ${typedRatio.toFixed(0)}%`);
+        else if (typedRatio >= 50)
+            issues.push(`[!] Type coverage: ${typedRatio.toFixed(0)}% (improve)`);
+        else
+            issues.push(`[X] Type coverage: ${typedRatio.toFixed(0)}% (too low)`);
+    }
+    passed.push(`[OK] Analyzed ${tsFiles.length} TypeScript files`);
+    return { type: 'typescript', files: tsFiles.length, passed, issues, stats };
+}
+export async function checkPythonCoverage(projectPath) {
+    const passed = [];
+    const issues = [];
+    const stats = { any_count: 0, untyped_functions: 0, total_functions: 0, typed_functions: 0 };
+    const exclude = ['venv', '__pycache__', '.git', 'node_modules'];
+    const pyFiles = await getFiles(projectPath, /\.py$/, exclude);
+    if (pyFiles.length === 0) {
+        return { type: 'python', files: 0, passed, issues: ["[!] No Python files found"], stats };
+    }
+    for (const filePath of pyFiles.slice(0, 30)) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const anyMatches = content.match(/:\s*Any\b/g);
+            if (anyMatches)
+                stats.any_count += anyMatches.length;
+            const allFuncs = content.match(/def\s+\w+\s*\([^)]*\)(?:\s*->[^:]+)?\s*:/g);
+            if (allFuncs) {
+                let localTyped = 0;
+                for (const f of allFuncs) {
+                    const argsPart = f.substring(f.indexOf('('), f.lastIndexOf(')'));
+                    const hasReturn = f.includes('->');
+                    const hasTypedArgs = argsPart.includes(':');
+                    if (hasTypedArgs || hasReturn) {
+                        localTyped++;
+                    }
+                }
+                stats.typed_functions += localTyped;
+                stats.untyped_functions += allFuncs.length - localTyped;
+            }
+        }
+        catch { }
+    }
+    stats.total_functions = stats.typed_functions + stats.untyped_functions;
+    if (stats.total_functions > 0) {
+        const typedRatio = (stats.typed_functions / stats.total_functions) * 100;
+        if (typedRatio >= 70)
+            passed.push(`[OK] Type hints coverage: ${typedRatio.toFixed(0)}%`);
+        else if (typedRatio >= 40)
+            issues.push(`[!] Type hints coverage: ${typedRatio.toFixed(0)}%`);
+        else
+            issues.push(`[X] Type hints coverage: ${typedRatio.toFixed(0)}% (add type hints)`);
+    }
+    if (stats.any_count === 0)
+        passed.push("[OK] No 'Any' types found");
+    else if (stats.any_count <= 3)
+        issues.push(`[!] ${stats.any_count} 'Any' types found`);
+    else
+        issues.push(`[X] ${stats.any_count} 'Any' types found`);
+    passed.push(`[OK] Analyzed ${pyFiles.length} Python files`);
+    return { type: 'python', files: pyFiles.length, passed, issues, stats };
+}
+export async function runTypeCoverage(projectPath = ".") {
+    const tsRes = await checkTypescriptCoverage(projectPath);
+    const pyRes = await checkPythonCoverage(projectPath);
+    const results = [tsRes, pyRes].filter(r => r.files > 0);
+    if (results.length === 0) {
+        return { passed: true, report: "[!] No TypeScript or Python files found." };
+    }
+    let report = "";
+    let criticalIssues = 0;
+    for (const res of results) {
+        report += `\n[${res.type.toUpperCase()}]\n----------------------------------------\n`;
+        for (const p of res.passed)
+            report += `  ${p}\n`;
+        for (const i of res.issues) {
+            report += `  ${i}\n`;
+            if (i.startsWith("[X]"))
+                criticalIssues++;
+        }
+    }
+    report += `\n============================================================\n`;
+    const passed = criticalIssues === 0;
+    report += passed ? `[OK] TYPE COVERAGE: ACCEPTABLE` : `[X] TYPE COVERAGE: ${criticalIssues} critical issues`;
+    return { passed, report };
+}

package/build/tools/validators/uxAudit.js

@@ -0,0 +1,222 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+class UXAuditor {
+    issues = [];
+    warnings = [];
+    passed_count = 0;
+    files_checked = 0;
+    async auditFile(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            this.files_checked++;
+            const filename = path.basename(filePath);
+            const lowerC = content.toLowerCase();
+            const hasLongText = /<p|<div.*class=.*text|article|<span.*text/i.test(content);
+            const hasForm = /<form|<input|password|credit|card|payment/i.test(content);
+            const complexElements = (content.match(/<input|<select|<textarea|<option/gi) || []).length;
+            const navItems = (content.match(/<NavLink|<Link|<a\s+href|nav-item/gi) || []).length;
+            if (navItems > 7)
+                this.issues.push(`[Hick's Law] ${filename}: ${navItems} nav items (Max 7)`);
+            if (/height:\s*([0-3]\d)px/.test(content) || /h-[1-9]\b|h-10\b/.test(content))
+                this.warnings.push(`[Fitts' Law] ${filename}: Small targets (< 44px)`);
+            if (complexElements > 7 && !/step|wizard|stage/i.test(content))
+                this.warnings.push(`[Miller's Law] ${filename}: Complex form (${complexElements} fields)`);
+            if (lowerC.includes('button') && !/primary|bg-primary|Button.*primary|variant=["']primary/i.test(content))
+                this.warnings.push(`[Von Restorff] ${filename}: No primary CTA`);
+            if (navItems > 3) {
+                const navContent = [...content.matchAll(/<NavLink|<Link|<a\s+href[^>]*>([^<]+)<\/a>/gi)];
+                if (navContent.length > 2) {
+                    const last = navContent[navContent.length - 1][1].toLowerCase();
+                    if (!['contact', 'login', 'sign', 'get started', 'cta', 'button'].some(x => last.includes(x))) {
+                        this.warnings.push(`[Serial Position] ${filename}: Last nav item may not be important.`);
+                    }
+                }
+            }
+            const hasHero = /hero|<h1|banner/i.test(content);
+            if (hasHero) {
+                const hasVis = /gradient|linear-gradient|radial-gradient|@keyframes|transition:|animate-/.test(content);
+                if (!hasVis && !/background:|bg-/.test(content)) {
+                    this.warnings.push(`[Visceral] ${filename}: Hero section lacks visual appeal.`);
+                }
+            }
+            if (/onClick|@click|onclick/i.test(content)) {
+                if (!/transition|animate|hover:|focus:|disabled|loading|spinner|setState|useState/i.test(content)) {
+                    this.warnings.push(`[Behavioral] ${filename}: Interactive elements lack immediate feedback.`);
+                }
+            }
+            if (hasLongText && !/about|story|mission|values|why we|our journey|testimonials/i.test(content)) {
+                this.warnings.push(`[Reflective] ${filename}: Long-form content without brand story/values.`);
+            }
+            if (hasForm) {
+                if (!/ssl|secure|encrypt|lock|padlock|https/i.test(content) && !/checkout|payment/i.test(content)) {
+                    this.warnings.push(`[Trust] ${filename}: Form without security indicators.`);
+                }
+                if (!/<label|placeholder|aria-label/i.test(content)) {
+                    this.issues.push(`[Cognitive Load] ${filename}: Form inputs without labels.`);
+                }
+                const radioInputs = (content.match(/type=["']radio/gi) || []).length;
+                if (radioInputs > 0 && !/checked|selected|default|value=["'].*["']/i.test(content)) {
+                    this.warnings.push(`[Persuasion] ${filename}: Radio buttons without default selection.`);
+                }
+            }
+            const socialProof = content.match(/review|testimonial|rating|star|trust|trusted by|customer|logo/gi) || [];
+            if (socialProof.length > 0)
+                this.passed_count++;
+            else if (hasLongText)
+                this.warnings.push(`[Trust] ${filename}: No social proof detected.`);
+            if (/footer|<footer/i.test(content) && !/certif|award|media|press|featured|as seen in/i.test(content)) {
+                this.warnings.push(`[Trust] ${filename}: Footer lacks authority signals.`);
+            }
+            if (complexElements > 5 && !/step|wizard|stage|accordion|collapsible|tab|more\.\.\.|advanced|show more/i.test(content)) {
+                this.warnings.push(`[Cognitive Load] ${filename}: Many form elements without progressive disclosure.`);
+            }
+            const manyColors = (content.match(/#[0-9a-fA-F]{3,6}|rgb|hsl/g) || []).length > 15;
+            const manyBorders = (content.match(/border:|border-/g) || []).length > 10;
+            if (manyColors && manyBorders)
+                this.warnings.push(`[Cognitive Load] ${filename}: High visual noise detected.`);
+            if (/price|pricing|cost|\$\d+/i.test(content) && !/original|was|strike|del|save \d+%/i.test(content)) {
+                this.warnings.push(`[Persuasion] ${filename}: Prices without anchoring.`);
+            }
+            if (/join|subscriber|member|user/i.test(content) && !/\d+[+kmb]|\d+,\d+/.test(content)) {
+                this.warnings.push(`[Persuasion] ${filename}: Social proof without specific numbers.`);
+            }
+            if (hasForm && complexElements > 5 && !/progress|step \d+|complete|%|bar/i.test(content)) {
+                this.warnings.push(`[Persuasion] ${filename}: Long form without progress indicator.`);
+            }
+            // Typography
+            const googleFonts = [...content.matchAll(/fonts\.googleapis\.com[^"']*family=([^"&]+)/gi)];
+            if (googleFonts.length > 3)
+                this.issues.push(`[Typography] ${filename}: >3 font families detected.`);
+            if (hasLongText && !/max-w-(?:prose|[\[\\]?\d+ch[\]\\]?)|max-width:\s*\d+ch/.test(content)) {
+                this.warnings.push(`[Typography] ${filename}: No line length constraint (45-75ch).`);
+            }
+            if (/<h[1-6]|text-(?:xl|2xl|3xl|4xl|5xl|6xl)/i.test(content)) {
+                const lhMatches = [...content.matchAll(/(?:leading-|line-height:\s*)([\d.]+)/g)];
+                for (const m of lhMatches) {
+                    if (parseFloat(m[1]) > 1.5)
+                        this.warnings.push(`[Typography] ${filename}: Heading has line-height > 1.3.`);
+                }
+            }
+            if (/uppercase|text-transform:\s*uppercase/i.test(content) && !/tracking-|letter-spacing:/.test(content)) {
+                this.warnings.push(`[Typography] ${filename}: Uppercase text without tracking.`);
+            }
+            if (/text-(?:4xl|5xl|6xl|7xl|8xl|9xl)|font-size:\s*[3-9]\dpx/.test(content) && !/tracking-tight|letter-spacing:\s*-[0-9]/.test(content)) {
+                this.warnings.push(`[Typography] ${filename}: Large display text without tracking-tight.`);
+            }
+            if (/font-size:|text-(?:xs|sm|base|lg|xl|2xl)/.test(content) && !/clamp\(|responsive:/.test(content)) {
+                this.warnings.push(`[Typography] ${filename}: Fixed font sizes without clamp().`);
+            }
+            const headings = [...content.matchAll(/<h([1-6])/gi)];
+            if (headings.length > 0) {
+                for (let i = 0; i < headings.length - 1; i++) {
+                    if (parseInt(headings[i + 1][1]) > parseInt(headings[i][1]) + 1) {
+                        this.warnings.push(`[Typography] ${filename}: Skipped heading level.`);
+                    }
+                }
+                if (!headings.some(h => h[1] === '1') && hasLongText) {
+                    this.warnings.push(`[Typography] ${filename}: No h1 found.`);
+                }
+            }
+            // Visual Effects
+            if (/backdrop-filter|blur\(/.test(content) && !/background:\s*rgba|bg-opacity|bg-[a-z0-9]+\/\d+/.test(content)) {
+                this.warnings.push(`[Visual] ${filename}: Blur used without semi-transparent background`);
+            }
+            if (/@keyframes|transition:/.test(content) && /width|height|top|left|right|bottom|margin|padding/.test(content)) {
+                this.warnings.push(`[Performance] ${filename}: Animating expensive properties. Use transform/opacity.`);
+                if (!/prefers-reduced-motion/.test(content))
+                    this.warnings.push(`[Accessibility] ${filename}: Animations found without prefers-reduced-motion check`);
+            }
+            const neoShadows = [...content.matchAll(/box-shadow:\s*([^;]+)/g)];
+            for (const s of neoShadows) {
+                if (s[1].includes(',') && s[1].includes('-') && s[1].includes('inset')) {
+                    this.warnings.push(`[Visual] ${filename}: Neomorphism inset detected. Ensure adequate contrast.`);
+                }
+            }
+            const gradients = (content.match(/gradient/gi) || []).length;
+            if (gradients > 5)
+                this.warnings.push(`[Visual] ${filename}: Many gradients detected (${gradients}).`);
+            else if (hasHero && !/background:|bg-/.test(content))
+                this.warnings.push(`[Visual] ${filename}: Hero section without visual interest.`);
+            if ((content.match(/border:/g) || []).length > 8)
+                this.warnings.push(`[Visual] ${filename}: Many border declarations`);
+            // colors
+            const purples = ['#8B5CF6', '#A855F7', '#9333EA', '#7C3AED', '#6D28D9', 'purple', 'violet', 'fuchsia', 'magenta', 'lavender'];
+            for (const p of purples) {
+                if (lowerC.includes(p.toLowerCase())) {
+                    this.issues.push(`[Color] ${filename}: PURPLE DETECTED ('${p}'). Banned by Maestro rules.`);
+                    break;
+                }
+            }
+            if (/color:\s*#000000|#000\b/.test(content))
+                this.warnings.push(`[Color] ${filename}: Pure black (#000000) detected.`);
+            // animation & UX
+            const durations = [...content.matchAll(/(?:duration|animation-duration|transition-duration):\s*([\d.]+)(s|ms)/g)];
+            for (const d of durations) {
+                const ms = parseFloat(d[1]) * (d[2] === 's' ? 1000 : 1);
+                if (ms < 50)
+                    this.warnings.push(`[Animation] ${filename}: Very fast animation (${d[1]}${d[2]}).`);
+                else if (ms > 1000 && lowerC.includes('transition'))
+                    this.warnings.push(`[Animation] ${filename}: Long transition.`);
+            }
+            if (/ease-in\s+.*entry|fade-in.*ease-in/.test(content))
+                this.warnings.push(`[Animation] ${filename}: Entry animation with ease-in.`);
+            if (/ease-out\s+.*exit|fade-out.*ease-out/.test(content))
+                this.warnings.push(`[Animation] ${filename}: Exit animation with ease-out.`);
+            const interactiveCount = (content.match(/<button|<a\s+href|onClick|@click/g) || []).length;
+            if (interactiveCount > 2 && !/hover:|focus:|:hover|:focus/.test(content)) {
+                this.warnings.push(`[Animation] ${filename}: Interactive elements without hover/focus states.`);
+            }
+            // accessibility basics
+            if (/<img(?![^>]*alt=)[^>]*>/.test(content))
+                this.issues.push(`[Accessibility] ${filename}: Missing img alt text`);
+        }
+        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'].includes(item.name))
+                    continue;
+                const fullPath = path.join(dir, item.name);
+                if (item.isDirectory()) {
+                    await this.auditDirectory(fullPath);
+                }
+                else if (/\.(tsx|jsx|html|vue|svelte|css)$/.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 runUxAudit(projectPath = ".") {
+    const root = path.resolve(projectPath);
+    const auditor = new UXAuditor();
+    await auditor.auditDirectory(root);
+    const res = auditor.getReport();
+    let report = `\n[UX AUDIT] ${res.files_checked} 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/verifyAll.js

@@ -0,0 +1,159 @@
+import * as path from 'path';
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import * as fs from 'fs/promises';
+import { runSecurityScan } from './validators/securityScan.js';
+import { runLintRunner } from './validators/lintRunner.js';
+import { runTypeCoverage } from './validators/typeCoverage.js';
+import { runTestRunner } from './validators/testRunner.js';
+import { runPlaywrightTest } from './validators/playwrightRunner.js';
+async function hasScript(rootPath, scriptName) {
+    const pkgPath = path.join(rootPath, 'package.json');
+    if (!existsSync(pkgPath))
+        return false;
+    try {
+        const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+        return !!(pkg.scripts && pkg.scripts[scriptName]);
+    }
+    catch {
+        return false;
+    }
+}
+async function runCommand(name, command, args, projectPath) {
+    const start = Date.now();
+    return new Promise((resolve) => {
+        const child = spawn(command, args, { cwd: projectPath, shell: true });
+        let out = '';
+        child.stdout.on('data', data => out += data.toString());
+        child.stderr.on('data', data => out += data.toString());
+        child.on('close', code => {
+            const passed = code === 0;
+            const duration = (Date.now() - start) / 1000;
+            const report = passed ? `✅ ${name} (${duration}s): PASSED\n${out}` : `❌ ${name} (${duration}s): FAILED\n${out}`;
+            resolve({ passed, report, duration });
+        });
+        setTimeout(() => {
+            child.kill();
+            resolve({ passed: false, report: `❌ ${name}: TIMED OUT`, duration: (Date.now() - start) / 1000 });
+        }, 10 * 60 * 1000);
+    });
+}
+export async function runVerifyAll(projectPath, url, skipE2E = false, stopOnFail = false) {
+    const root = path.resolve(projectPath);
+    let report = `🚀 FULL VERIFICATION SUITE\nProject: ${root}\nURL: ${url}\n\n`;
+    let passedCount = 0;
+    let failedCount = 0;
+    let skippedCount = 0;
+    const VERIFICATION_SUITE = [
+        {
+            category: "Security",
+            checks: [
+                {
+                    name: "Security Scan", required: true, fn: async () => {
+                        const start = Date.now();
+                        const res = await runSecurityScan(root);
+                        return { passed: res.passed, report: res.report, duration: (Date.now() - start) / 1000 };
+                    }
+                }
+            ]
+        },
+        {
+            category: "Code Quality",
+            checks: [
+                {
+                    name: "Lint Check", required: true, fn: async () => {
+                        const start = Date.now();
+                        const res = await runLintRunner(root);
+                        return { passed: res.passed, report: res.report, duration: (Date.now() - start) / 1000 };
+                    }
+                },
+                {
+                    name: "Type Coverage", required: false, fn: async () => {
+                        const start = Date.now();
+                        const res = await runTypeCoverage(root);
+                        return { passed: res.passed, report: res.report, duration: (Date.now() - start) / 1000 };
+                    }
+                }
+            ]
+        },
+        {
+            category: "Testing",
+            checks: [
+                {
+                    name: "Test Suite", required: false, fn: async () => {
+                        const start = Date.now();
+                        const res = await runTestRunner(root, false);
+                        return { passed: res.passed, report: res.report, duration: (Date.now() - start) / 1000 };
+                    }
+                }
+            ]
+        },
+        {
+            category: "Build",
+            checks: [
+                {
+                    name: "Build App", required: false, fn: async () => {
+                        if (await hasScript(root, 'build'))
+                            return runCommand("Build App", 'npm', ['run', 'build'], root);
+                        return { passed: true, skipped: true, report: `Script 'build' not found in package.json` };
+                    }
+                }
+            ]
+        },
+        {
+            category: "E2E Testing",
+            requiresUrl: true,
+            checks: [
+                {
+                    name: "Playwright E2E", required: false, fn: async () => {
+                        const start = Date.now();
+                        const res = await runPlaywrightTest(url);
+                        return {
+                            passed: res.status === 'success',
+                            report: JSON.stringify(res, null, 2),
+                            duration: (Date.now() - start) / 1000
+                        };
+                    }
+                }
+            ]
+        }
+    ];
+    for (const suite of VERIFICATION_SUITE) {
+        if (suite.requiresUrl && !url)
+            continue;
+        if (skipE2E && suite.category === "E2E Testing")
+            continue;
+        report += `📋 ${suite.category.toUpperCase()}\n`;
+        for (const check of suite.checks) {
+            try {
+                const result = await check.fn();
+                if (result.skipped) {
+                    skippedCount++;
+                    report += `⏭️  ${check.name}: Skipped - ${result.report}\n`;
+                    continue;
+                }
+                report += `[${result.duration?.toFixed(2)}s] ${check.name}:\n${result.report}\n`;
+                if (result.passed) {
+                    passedCount++;
+                }
+                else {
+                    failedCount++;
+                    if (stopOnFail && check.required) {
+                        report += `CRITICAL FAILURE on ${check.name}\n`;
+                        return report + `\nTotal Passed: ${passedCount} | Failed: ${failedCount} | Skipped: ${skippedCount}\n\nFAILED❗`;
+                    }
+                }
+            }
+            catch (e) {
+                failedCount++;
+                report += `❌ Error executing check ${check.name}: ${e.message}\n`;
+                if (stopOnFail && check.required) {
+                    return report + `\nTotal Passed: ${passedCount} | Failed: ${failedCount} | Skipped: ${skippedCount}\n\nFAILED❗`;
+                }
+            }
+        }
+    }
+    report += `\n📊 FINAL REPORT\nPassed: ${passedCount}\nFailed: ${failedCount}\nSkipped: ${skippedCount}\n\n`;
+    report += failedCount > 0 ? `❌ VERIFICATION FAILED!` : `✅ ALL CHECKS PASSED - Ready for deployment! ✨`;
+    return report;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "superkit-mcp-server",
-    "version": "1.0.1",
+    "version": "1.0.2",
     "type": "module",
     "description": "An MCP server for exploring and loading Super-Kit AI agent resources.",
     "main": "build/index.js",
@@ -14,11 +14,13 @@
     },
     "dependencies": {
         "@modelcontextprotocol/sdk": "^1.4.1",
+        "playwright": "^1.58.2",
         "zod": "^3.23.8"
     },
     "devDependencies": {
-        "@types/node": "^22.10.1",
-        "typescript": "^5.7.2"
+        "@types/node": "^22.19.13",
+        "typescript": "^5.7.2",
+        "vitest": "^4.0.18"
     },
     "files": [
         "build/",

package/skills/tech/api-patterns/SKILL.md

@@ -77,5 +77,5 @@ Before designing an API:
 
 | Script | Purpose | Command |
 |--------|---------|---------|
-| `scripts/api_validator.py` | API endpoint validation | `python scripts/api_validator.py <project_path>` |
+| `api_validator` validator | API endpoint validation | `call_tool_checklist` |