superkit-mcp-server 1.0.1 → 1.0.2

package/ARCHITECTURE.md

@@ -22,7 +22,6 @@ super-kit/
 ├── SUPERKIT.md              # Global rules and activation protocol
 ├── .core/                   # Core engine-independent logic
 │   ├── rules/               # Universal mandates (e.g., clean-code, security-first)
-│   └── scripts/             # Master validation (checklist.py, auto_preview.py)
 ├── agents/                  # The T-Shaped AI Team Personas
 ├── skills/                  # The Knowledge Modules
 │   ├── meta/                # Session-resume, compound-docs, file-todos (from gemini-kit)
@@ -84,7 +83,7 @@ The primary operating directive for building sustainable software:
 1. **Explore**: Investigate the codebase and gather requirements.
 2. **Plan**: Write the task boundaries and solution architecture.
 3. **Work**: The Core Team executes code generation.
-4. **Review**: Automated auditing via `.core/scripts/checklist.py`.
+4. **Review**: Automated auditing via `src/tools/checklist.ts`.
 5. **Compound**: Output reusable solutions to `docs/solutions/`.
 
 ## ⚙️ Usage & Agnosticism
@@ -94,7 +93,7 @@ The entry point is reading `SUPERKIT.md` to establish global rules.
 
 ### How to Point Changing Agents to the Entrypoint:
 
-- **Antigravity**: Reference `@SUPERKIT.md` in your prompt, or set its content as your persistent user rules for the project.
+- **Standard Agents**: Reference `@SUPERKIT.md` in your prompt, or set its content as your persistent user rules for the project.
 - **Cursor/Windsurf**: Reference `@SUPERKIT.md` in your Composer/Chat, or set the content of `SUPERKIT.md` as your project's `.cursorrules` / `.windsurfrules`.
 - **Cline (VS Code)**: Set the content of `SUPERKIT.md` as your custom instructions in the Cline settings, or add an `@SUPERKIT.md` command in your prompt.
 - **Gemini / Google AI Studio**: Supply `SUPERKIT.md` as your System Prompt instructions.

package/README.md

@@ -26,6 +26,7 @@ npx -y superkit-mcp-server
 - **`load_superkit_agent`**: Loads the system instructions and guidelines for a specific specialist agent (e.g., `data-engineer`).
 - **`load_superkit_skill`**: Loads the skill instructions (`SKILL.md`) for a specific category and skill (e.g., category: `tech`, name: `react-best-practices`).
 - **`load_superkit_workflow`**: Loads the instructions for a specific slash-command workflow (e.g., `work`, `explore`).
+- **`call_tool_checklist`**: Executes the native TypeScript validation suite (security, web accessibility, react performance, testing, API structure) on a target project location via the MCP environment instead of generic bash loops.
 
 ## Manual Installation and Configuration
 

package/build/index.js

@@ -5,6 +5,10 @@ import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextpro
 import * as path from "path";
 import * as fs from "fs/promises";
 import { fileURLToPath } from "url";
+import { manageAutoPreview } from "./tools/autoPreview.js";
+import { manageSession } from "./tools/sessionManager.js";
+import { runChecklist } from "./tools/checklist.js";
+import { runVerifyAll } from "./tools/verifyAll.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const superKitRoot = path.resolve(__dirname, "../");
@@ -37,6 +41,57 @@ function getSafePath(basePath, relativePath) {
     return resolvedPath;
 }
 const TOOLS = [
+    {
+        name: "call_tool_auto_preview",
+        description: "Manages (start/stop/status) the local development server for previewing the application.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: { type: "string", enum: ["start", "stop", "status"] },
+                port: { type: "number", default: 3000 }
+            },
+            required: ["action"],
+        }
+    },
+    {
+        name: "call_tool_session_manager",
+        description: "Analyzes project state, detects tech stack, tracks file statistics, and provides a summary.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                command: { type: "string", enum: ["status", "info"] },
+                path: { type: "string", default: "." }
+            },
+            required: ["command"],
+        }
+    },
+    {
+        name: "call_tool_checklist",
+        description: "Orchestrates validation scripts in priority order for incremental validation during development.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                projectPath: { type: "string", default: "." },
+                url: { type: "string" },
+                skipPerformance: { type: "boolean", default: false }
+            },
+            required: ["projectPath"]
+        }
+    },
+    {
+        name: "call_tool_verify_all",
+        description: "Runs COMPLETE validation including all checks + performance + E2E for deployment.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                projectPath: { type: "string", default: "." },
+                url: { type: "string" },
+                skipE2E: { type: "boolean", default: false },
+                stopOnFail: { type: "boolean", default: false }
+            },
+            required: ["projectPath", "url"]
+        }
+    },
     {
         name: "list_superkit_assets",
         description: "Lists all available agents, skills, and workflows in the Super-Kit repository.",
@@ -98,6 +153,26 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 });
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
+        if (request.params.name === "call_tool_auto_preview") {
+            const args = request.params.arguments;
+            const res = await manageAutoPreview(args.action, args.port);
+            return { content: [{ type: "text", text: res }] };
+        }
+        if (request.params.name === "call_tool_session_manager") {
+            const args = request.params.arguments;
+            const res = await manageSession(args.command, args.path);
+            return { content: [{ type: "text", text: res }] };
+        }
+        if (request.params.name === "call_tool_checklist") {
+            const args = request.params.arguments;
+            const res = await runChecklist(args.projectPath, args.url, args.skipPerformance);
+            return { content: [{ type: "text", text: res }] };
+        }
+        if (request.params.name === "call_tool_verify_all") {
+            const args = request.params.arguments;
+            const res = await runVerifyAll(args.projectPath, args.url, args.skipE2E, args.stopOnFail);
+            return { content: [{ type: "text", text: res }] };
+        }
         if (request.params.name === "list_superkit_assets") {
             const agentsPath = path.join(superKitRoot, "agents");
             const skillsTechPath = path.join(superKitRoot, "skills", "tech");

package/build/tools/autoPreview.js

@@ -0,0 +1,99 @@
+import * as fs from 'fs/promises';
+import { existsSync } from 'fs';
+import * as path from 'path';
+import { spawn, execSync } from 'child_process';
+const AGENT_DIR = path.resolve('.agent');
+const PID_FILE = path.join(AGENT_DIR, 'preview.pid');
+const LOG_FILE = path.join(AGENT_DIR, 'preview.log');
+export async function manageAutoPreview(action, port = 3000) {
+    const root = path.resolve('.');
+    // Ensure .agent dir exists
+    if (!existsSync(AGENT_DIR)) {
+        await fs.mkdir(AGENT_DIR, { recursive: true });
+    }
+    const isRunning = (pid) => {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    };
+    if (action === 'start') {
+        if (existsSync(PID_FILE)) {
+            const pid = parseInt(await fs.readFile(PID_FILE, 'utf-8'));
+            if (isRunning(pid)) {
+                return `⚠️ Preview already running (PID: ${pid})`;
+            }
+        }
+        const pkgPath = path.join(root, 'package.json');
+        if (!existsSync(pkgPath)) {
+            return "❌ No package.json found";
+        }
+        const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
+        const scripts = pkg.scripts || {};
+        // npm sometimes behaves differently on Windows, using shell helps
+        let cmd = '';
+        let args = [];
+        if (scripts['dev']) {
+            cmd = 'npm';
+            args = ['run', 'dev'];
+        }
+        else if (scripts['start']) {
+            cmd = 'npm';
+            args = ['start'];
+        }
+        else {
+            return "❌ No 'dev' or 'start' script found in package.json";
+        }
+        const logStream = (await import('fs')).createWriteStream(LOG_FILE, { flags: 'w' });
+        const child = spawn(cmd, args, {
+            cwd: root,
+            env: { ...process.env, PORT: port.toString() },
+            shell: true,
+            detached: true,
+            stdio: ['ignore', logStream, logStream]
+        });
+        child.unref();
+        await fs.writeFile(PID_FILE, child.pid.toString());
+        return `✅ Preview started! (PID: ${child.pid})\n   Logs: ${LOG_FILE}\n   URL: http://localhost:${port}`;
+    }
+    if (action === 'stop') {
+        if (!existsSync(PID_FILE)) {
+            return "ℹ️ No preview server found.";
+        }
+        const pid = parseInt(await fs.readFile(PID_FILE, 'utf-8'));
+        if (isRunning(pid)) {
+            try {
+                process.kill(pid, process.platform === 'win32' ? 'SIGINT' : 'SIGTERM');
+                await fs.unlink(PID_FILE).catch(() => { });
+                return `🛑 Preview stopped (PID: ${pid})`;
+            }
+            catch (e) {
+                if (process.platform === 'win32') {
+                    execSync(`taskkill /F /T /PID ${pid}`);
+                    await fs.unlink(PID_FILE).catch(() => { });
+                    return `🛑 Preview stopped via taskkill (PID: ${pid})`;
+                }
+                return `❌ Error stopping server: ${e.message}`;
+            }
+        }
+        await fs.unlink(PID_FILE).catch(() => { });
+        return "ℹ️ Process was not running, removed stale PID file.";
+    }
+    if (action === 'status') {
+        let running = false;
+        let pid = null;
+        if (existsSync(PID_FILE)) {
+            pid = parseInt(await fs.readFile(PID_FILE, 'utf-8'));
+            if (isRunning(pid))
+                running = true;
+        }
+        if (running) {
+            return `✅ Status: Running\n🔢 PID: ${pid}\n🌐 URL: http://localhost:${port}\n📝 Logs: ${LOG_FILE}`;
+        }
+        return "⚪ Status: Stopped";
+    }
+    return "❌ Invalid action.";
+}

package/build/tools/checklist.js

@@ -0,0 +1,120 @@
+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 { runSchemaValidator } from './validators/schemaValidator.js';
+import { runApiValidator } from './validators/apiValidator.js';
+import { runUxAudit } from './validators/uxAudit.js';
+import { runAccessibilityChecker } from './validators/accessibilityChecker.js';
+import { runGeoChecker } from './validators/geoChecker.js';
+import { runI18nChecker } from './validators/i18nChecker.js';
+import { runMobileAudit } from './validators/mobileAudit.js';
+import { runReactPerformanceChecker } from './validators/reactPerformanceChecker.js';
+import { runSeoChecker } from './validators/seoChecker.js';
+import { runLighthouseAudit } from './validators/lighthouseAudit.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) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, { cwd: projectPath, shell: true });
+        let out = '';
+        let err = '';
+        child.stdout.on('data', data => out += data.toString());
+        child.stderr.on('data', data => err += data.toString());
+        child.on('close', code => {
+            const passed = code === 0;
+            const report = passed ? `✅ ${name}: PASSED\n${out}` : `❌ ${name}: FAILED\n${err || out}`;
+            resolve({ passed, report });
+        });
+        setTimeout(() => {
+            child.kill();
+            resolve({ passed: false, report: `❌ ${name}: TIMED OUT\n${out}\n${err}` });
+        }, 5 * 60 * 1000);
+    });
+}
+export async function runChecklist(projectPath, url, skipPerformance = false) {
+    const root = path.resolve(projectPath);
+    let masterOutput = `🚀 SUPER KIT - MASTER CHECKLIST\nProject: ${root}\nURL: ${url || 'None'}\n\n📋 CORE CHECKS\n`;
+    let passedCount = 0;
+    let failedCount = 0;
+    let skippedCount = 0;
+    let hasCriticalFailure = false;
+    const runAndFormat = async (name, required, fn) => {
+        if (hasCriticalFailure)
+            return;
+        try {
+            const result = await fn();
+            if (result.skipped) {
+                skippedCount++;
+                masterOutput += `\n--- [${name}] ---\n⏭️  Skipped: ${result.report}\n`;
+                return;
+            }
+            masterOutput += `\n--- [${name}] ---\n${result.report}\n`;
+            if (result.passed) {
+                passedCount++;
+            }
+            else {
+                failedCount++;
+                if (required) {
+                    hasCriticalFailure = true;
+                    masterOutput += `CRITICAL: ${name} failed. Stopping checklist.\n`;
+                }
+            }
+        }
+        catch (e) {
+            masterOutput += `\n--- [${name}] ---\n❌ Error executing check: ${e.message}\n`;
+            failedCount++;
+            if (required)
+                hasCriticalFailure = true;
+        }
+    };
+    // Replace CLI calls using exact TS equivalents
+    await runAndFormat("Security Scan", false, () => runSecurityScan(root));
+    await runAndFormat("Lint Check", true, () => runLintRunner(root));
+    await runAndFormat("Type Coverage", false, () => runTypeCoverage(root));
+    await runAndFormat("Test Runner", false, () => runTestRunner(root, false));
+    await runAndFormat("Schema Validator", false, () => runSchemaValidator(root));
+    await runAndFormat("API Validator", false, () => runApiValidator(root));
+    await runAndFormat("UX Audit", false, () => runUxAudit(root));
+    await runAndFormat("Accessibility Checker", false, () => runAccessibilityChecker(root));
+    await runAndFormat("GEO Checker", false, () => runGeoChecker(root));
+    await runAndFormat("i18n Checker", false, () => runI18nChecker(root));
+    await runAndFormat("Mobile Audit", false, () => runMobileAudit(root));
+    await runAndFormat("React Performance", false, () => runReactPerformanceChecker(root));
+    await runAndFormat("SEO Checker", false, () => runSeoChecker(root));
+    // Build check (still executes package.json script)
+    await runAndFormat("Build Validation", false, async () => {
+        if (await hasScript(root, 'build'))
+            return runCommand("Build Validation", 'npm', ['run', 'build'], root);
+        return { passed: true, skipped: true, report: `Script 'build' not found in package.json` };
+    });
+    if (url && !skipPerformance && !hasCriticalFailure) {
+        masterOutput += `\n⚡ PERFORMANCE & E2E CHECKS\n`;
+        await runAndFormat("Lighthouse / Performance", true, () => runLighthouseAudit(url));
+        await runAndFormat("E2E Tests", false, () => runPlaywrightTest(url).then(res => ({
+            passed: res.status === 'success',
+            report: JSON.stringify(res, null, 2)
+        })));
+    }
+    else if (!url && !hasCriticalFailure) {
+        masterOutput += `\n⏭️ Skipping Performance & E2E checks (No URL provided)\n`;
+    }
+    masterOutput += `\n📊 SUMMARY\nPassed: ${passedCount}\nFailed: ${failedCount}\nSkipped: ${skippedCount}\n\n`;
+    masterOutput += failedCount > 0 ? `❌ Checks FAILED - Attention required.` : `✅ All checks PASSED!`;
+    return masterOutput;
+}

package/build/tools/sessionManager.js

@@ -0,0 +1,107 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export async function manageSession(command, rootPath = '.') {
+    const root = path.resolve(rootPath);
+    const pkgPath = path.join(root, 'package.json');
+    const getPackageInfo = async () => {
+        try {
+            const data = await fs.readFile(pkgPath, 'utf8');
+            const pkg = JSON.parse(data);
+            const allDeps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+            const stack = [];
+            if (allDeps['next'])
+                stack.push("Next.js");
+            else if (allDeps['react'])
+                stack.push("React");
+            else if (allDeps['vue'])
+                stack.push("Vue");
+            else if (allDeps['svelte'])
+                stack.push("Svelte");
+            else if (allDeps['express'])
+                stack.push("Express");
+            else if (allDeps['nestjs'] || allDeps['@nestjs/core'])
+                stack.push("NestJS");
+            if (allDeps['tailwindcss'])
+                stack.push("Tailwind CSS");
+            if (allDeps['prisma'])
+                stack.push("Prisma");
+            if (allDeps['typescript'])
+                stack.push("TypeScript");
+            return {
+                name: pkg.name || 'unnamed',
+                version: pkg.version || '0.0.0',
+                stack,
+                scripts: Object.keys(pkg.scripts || {})
+            };
+        }
+        catch (e) {
+            return { name: root.split(path.sep).pop() || 'unnamed', version: '0.0.0', stack: ['Generic'], scripts: [] };
+        }
+    };
+    const countFiles = async (dir) => {
+        let count = 0;
+        const exclude = new Set(['.git', 'node_modules', '.next', 'dist', 'build', '.agent', '.gemini', '__pycache__']);
+        try {
+            const items = await fs.readdir(dir, { withFileTypes: true });
+            for (const item of items) {
+                if (exclude.has(item.name))
+                    continue;
+                if (item.isDirectory()) {
+                    count += await countFiles(path.join(dir, item.name));
+                }
+                else {
+                    count++;
+                }
+            }
+        }
+        catch { }
+        return count;
+    };
+    const detectFeatures = async () => {
+        const features = [];
+        const srcPath = path.join(root, 'src');
+        const possibleDirs = ["components", "modules", "features", "app", "pages", "services"];
+        try {
+            const srcExists = await fs.stat(srcPath).then(s => s.isDirectory()).catch(() => false);
+            if (srcExists) {
+                for (const d of possibleDirs) {
+                    const p = path.join(srcPath, d);
+                    const pExists = await fs.stat(p).then(s => s.isDirectory()).catch(() => false);
+                    if (pExists) {
+                        const children = await fs.readdir(p, { withFileTypes: true });
+                        for (const child of children) {
+                            if (child.isDirectory())
+                                features.push(child.name);
+                        }
+                    }
+                }
+            }
+        }
+        catch { }
+        return features.slice(0, 10);
+    };
+    const info = await getPackageInfo();
+    if (command === 'info') {
+        return JSON.stringify(info, null, 2);
+    }
+    if (command === 'status') {
+        const fileCount = await countFiles(root);
+        const features = await detectFeatures();
+        let output = `=== Project Status ===\n\n`;
+        output += `📁 Project: ${info.name}\n`;
+        output += `📂 Path: ${root}\n`;
+        output += `🏷️  Type: ${info.stack.join(', ')}\n`;
+        output += `📊 Status: Active\n\n`;
+        output += `🔧 Tech Stack:\n`;
+        for (const tech of info.stack)
+            output += `   • ${tech}\n`;
+        output += `\n✅ Detected Modules/Features (${features.length}):\n`;
+        if (features.length === 0)
+            output += `   (No distinct feature modules detected)\n`;
+        for (const feat of features)
+            output += `   • ${feat}\n`;
+        output += `\n📄 Files: ${fileCount} total files tracked\n`;
+        return output;
+    }
+    return "❌ Invalid command";
+}

package/build/tools/validators/__tests__/apiSchema.test.js

@@ -0,0 +1,77 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { validatePrismaSchema } from '../schemaValidator.js';
+import { checkApiCode, checkOpenApiSpec } from '../apiValidator.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+describe('schemaValidator', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('validatePrismaSchema', () => {
+        it('should detect bad model names and missing fields', async () => {
+            vi.mocked(fs.readFile).mockResolvedValue(`
+                 model user {
+                     name String
+                 }
+                 model Post {
+                     id String @id
+                     userId String
+                     createdAt DateTime
+                 }
+                 enum role { ADMIN, USER }
+             `);
+            const issues = await validatePrismaSchema('/mock.prisma');
+            expect(issues.some(i => i.includes("Model 'user' should be PascalCase"))).toBe(true);
+            expect(issues.some(i => i.includes("Enum 'role' should be PascalCase"))).toBe(true);
+            expect(issues.some(i => i.includes("missing createdAt"))).toBe(true); // for user
+            expect(issues.some(i => i.includes("adding @@index([userId])"))).toBe(true); // for Post
+        });
+    });
+});
+describe('apiValidator', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('checkOpenApiSpec', () => {
+        it('should validate openapi json', async () => {
+            vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({
+                openapi: "3.0.0",
+                info: { title: "Test", version: "1", description: "Test API" },
+                paths: {
+                    "/test": { get: { responses: { 200: {} }, description: "desc" } }
+                }
+            }));
+            const res = await checkOpenApiSpec('api.json');
+            expect(res.issues.length).toBe(0);
+        });
+    });
+    describe('checkApiCode', () => {
+        it('should detect missing api practices', async () => {
+            vi.mocked(fs.readFile).mockResolvedValue(`
+                 function handler() {
+                     // no try, no status, no security check
+                     return "hello";
+                 }
+             `);
+            const res = await checkApiCode('route.ts');
+            expect(res.issues.some(i => i.includes('No error handling'))).toBe(true);
+            expect(res.issues.some(i => i.includes('No explicit HTTP status'))).toBe(true);
+            expect(res.passed.length).toBe(0);
+        });
+        it('should pass good practices', async () => {
+            vi.mocked(fs.readFile).mockResolvedValue(`
+                 import { z } from 'zod';
+                 function handler(req, res) {
+                     try {
+                         const jwtToken = "123";
+                         return res.status(200).send("hello");
+                     } catch(e) {}
+                 }
+             `);
+            const res = await checkApiCode('route.ts');
+            expect(res.passed.some(i => i.includes('Error handling'))).toBe(true);
+            expect(res.passed.some(i => i.includes('validation present'))).toBe(true);
+            expect(res.passed.some(i => i.includes('status codes used'))).toBe(true);
+        });
+    });
+});

package/build/tools/validators/__tests__/convertRules.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { runConvertRules } from '../convertRules.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+describe('convertRules', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should fail if the rules directory does not exist', async () => {
+        vi.mocked(fs.stat).mockRejectedValue(new Error('ENOENT'));
+        const res = await runConvertRules('.');
+        expect(res.passed).toBe(false);
+        expect(res.report).toContain('[ERROR] Rules directory not found');
+    });
+    it('should correctly parse frontmatter and generate rules', async () => {
+        vi.mocked(fs.stat).mockResolvedValue({ isDirectory: () => true });
+        vi.mocked(fs.readdir).mockResolvedValue(['async-waterfall.md']);
+        vi.mocked(fs.readFile).mockResolvedValue(`---
+title: Waterfall check
+impact: HIGH
+tags: perf
+---
+Content body of the rule here.`);
+        vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+        vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+        const res = await runConvertRules('.');
+        console.log("ACTUAL REPORT:", res.report);
+        expect(res.passed).toBe(true);
+        expect(res.report).toContain('Generated 8 section files from 1 rules');
+        // ensure valid output creation
+        expect(fs.writeFile).toHaveBeenCalled();
+        const callArgs = vi.mocked(fs.writeFile).mock.calls[0];
+        const writtenContent = callArgs[1];
+        expect(writtenContent).toContain('## Rule 1.1: Waterfall check');
+        expect(writtenContent).toContain('**Impact:** HIGH');
+        expect(writtenContent).toContain('Content body of the rule here.');
+    });
+});

package/build/tools/validators/__tests__/frontendDesign.test.js

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { checkAccessibility } from '../accessibilityChecker.js';
+import { runUxAudit } from '../uxAudit.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+describe('accessibilityChecker', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('checkAccessibility', () => {
+        it('should detect input without label and img without alt', async () => {
+            vi.mocked(fs.readFile).mockResolvedValue(`
+                 <input type="text" name="bad" />
+                 <button>Click me</button>
+             `);
+            const issues = await checkAccessibility('test.html');
+            expect(issues.some(i => i.includes('Input without label'))).toBe(true);
+            expect(issues.some(i => i.includes('Missing lang'))).toBe(false); // only checks if <html> exists
+        });
+        it('should pass good inputs', async () => {
+            vi.mocked(fs.readFile).mockResolvedValue(`
+                 <html lang="en">
+                   <input type="text" aria-label="Good" />
+                   <button aria-label="Close">X</button>
+                 </html>
+             `);
+            const issues = await checkAccessibility('test.html');
+            expect(issues).toEqual([]); // Skip link is only requested if <main> or <body> is present
+        });
+    });
+});
+describe('uxAudit', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('runUxAudit', () => {
+        it('should detect UX violations', async () => {
+            vi.mocked(fs.readdir).mockResolvedValue([{
+                    name: 'test.tsx',
+                    isDirectory: () => false
+                }]);
+            vi.mocked(fs.readFile).mockResolvedValue(`
+                 <button onClick={() => {}}>Submit</button>
+                 <img src="foo.jpg">
+                 <p style="color: #000000; font-family: purple;">Hello</p>
+             `);
+            const res = await runUxAudit('.');
+            expect(res.passed).toBe(false);
+            expect(res.report.includes('PURPLE DETECTED')).toBe(true);
+            expect(res.report.includes('Missing img alt text')).toBe(true);
+            expect(res.report.includes('Pure black')).toBe(true);
+            expect(res.report.includes('Interactive elements lack immediate feedback')).toBe(true);
+        });
+    });
+});