swarm-orchestrator 7.0.0-alpha.0

package/dist/src/quality-gates/file-utils.js

@@ -0,0 +1,152 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse_gitignore_dirs = parse_gitignore_dirs;
+exports.list_project_files = list_project_files;
+exports.maybe_read_text = maybe_read_text;
+exports.compile_regexes = compile_regexes;
+exports.is_excluded_by_regex = is_excluded_by_regex;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function to_posix(relPath) {
+    return relPath.split(path.sep).join('/');
+}
+/**
+ * Parse a .gitignore file into directory names and path-prefix patterns.
+ * Only handles the patterns quality gates care about: bare directory names
+ * (e.g. "venv", "__pycache__") and directory prefixes ("venv/", "lib/").
+ * Does not implement full gitignore globbing; the goal is to catch the
+ * obvious third-party trees that should never be scanned.
+ */
+function parse_gitignore_dirs(projectRoot) {
+    const dirs = new Set();
+    const gitignorePath = path.join(projectRoot, '.gitignore');
+    if (!fs.existsSync(gitignorePath)) {
+        return dirs;
+    }
+    let content;
+    try {
+        content = fs.readFileSync(gitignorePath, 'utf8');
+    }
+    catch {
+        return dirs;
+    }
+    for (const raw of content.split('\n')) {
+        const line = raw.trim();
+        if (!line || line.startsWith('#')) {
+            continue;
+        }
+        // Negation patterns (e.g. "!important/") are intentionally skipped;
+        // they would need full gitignore semantics to handle correctly
+        if (line.startsWith('!')) {
+            continue;
+        }
+        // Strip trailing slash if present: "venv/" -> "venv"
+        const cleaned = line.endsWith('/') ? line.slice(0, -1) : line;
+        // Only treat simple names (no globs, no path separators) as directory excludes.
+        // Patterns like "*.pyc" or "build/output" are too complex for this fast path.
+        if (cleaned && !cleaned.includes('*') && !cleaned.includes('?') && !cleaned.includes('/')) {
+            dirs.add(cleaned);
+        }
+    }
+    return dirs;
+}
+function list_project_files(projectRoot, excludeDirNames) {
+    const files = [];
+    const exclude = new Set(excludeDirNames);
+    // Merge directory names from .gitignore so project-specific exclusions
+    // (like "venv", "lib", ".eggs") are honored without hardcoding every variant
+    const gitignoreDirs = parse_gitignore_dirs(projectRoot);
+    for (const dir of gitignoreDirs) {
+        exclude.add(dir);
+    }
+    function walk(absDir) {
+        const entries = fs.readdirSync(absDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === '.DS_Store') {
+                continue;
+            }
+            const absPath = path.join(absDir, entry.name);
+            const relPath = to_posix(path.relative(projectRoot, absPath));
+            if (entry.isDirectory()) {
+                if (exclude.has(entry.name)) {
+                    continue;
+                }
+                walk(absPath);
+                continue;
+            }
+            if (!entry.isFile()) {
+                continue;
+            }
+            let sizeBytes;
+            try {
+                sizeBytes = fs.statSync(absPath).size;
+            }
+            catch {
+                // ignore unreadable
+                continue;
+            }
+            files.push({
+                path: absPath,
+                relativePath: relPath,
+                sizeBytes
+            });
+        }
+    }
+    walk(projectRoot);
+    return files;
+}
+function maybe_read_text(file, maxBytes) {
+    if (file.sizeBytes > maxBytes) {
+        return undefined;
+    }
+    try {
+        const buf = fs.readFileSync(file.path);
+        // crude binary sniff
+        if (buf.includes(0)) {
+            return undefined;
+        }
+        return buf.toString('utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function compile_regexes(regexes) {
+    return regexes.map(r => new RegExp(r, 'i'));
+}
+function is_excluded_by_regex(relPath, regexes) {
+    return regexes.some(r => r.test(relPath));
+}

package/dist/src/quality-gates/gate-runner.js

@@ -0,0 +1,171 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run_quality_gates = run_quality_gates;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const file_utils_1 = require("./file-utils");
+const registry_1 = require("./registry");
+function format_issue(issue) {
+    const loc = issue.filePath
+        ? issue.line
+            ? `${issue.filePath}:${issue.line}`
+            : issue.filePath
+        : 'unknown';
+    return `- ${loc}: ${issue.message}`;
+}
+async function run_quality_gates(projectRoot, config, outDir, baselineFiles, baseCommit, skippedRequirementIds, skippedGateKeys) {
+    const start = Date.now();
+    if (!config.enabled) {
+        return {
+            passed: true,
+            advisory: true,
+            results: [{
+                    id: 'quality-gates',
+                    title: 'Quality gates disabled',
+                    status: 'skip',
+                    durationMs: 0,
+                    issues: []
+                }],
+            totalDurationMs: 0
+        };
+    }
+    const files = (0, file_utils_1.list_project_files)(projectRoot, config.excludeDirNames);
+    // attach text for small-ish files once (so multiple gates can reuse)
+    const ctx = {
+        projectRoot,
+        files: files.map(f => {
+            const text = (0, file_utils_1.maybe_read_text)(f, config.maxFileSizeBytes);
+            return text === undefined ? { ...f } : { ...f, text };
+        }),
+        baselineFiles,
+        skippedRequirementIds,
+        baseCommit,
+    };
+    const gateResults = [];
+    for (const gate of (0, registry_1.getRegisteredGates)()) {
+        const gateConfig = config.gates[gate.key];
+        if (!gateConfig?.enabled)
+            continue;
+        // Target-mode skip: self-improvement gates the caller has opted out of
+        // for this run (orchestrator passes SELF_IMPROVEMENT_GATE_KEYS when
+        // targetMode === true — running against an external repo whose
+        // conventions aren't ours to enforce). Universal gates (hardcodedConfig,
+        // testFileProtection) are never in this set. See registry.ts.
+        if (skippedGateKeys?.has(gate.key)) {
+            // Match the kebab-case id convention that the fired gates emit
+            // (e.g. 'duplicateBlocks' registry key → 'duplicate-blocks' id).
+            // Downstream consumers look gates up by id, so skipped entries need
+            // the same id shape as run entries for the same gate.
+            const id = gate.key.replace(/[A-Z]/g, m => '-' + m.toLowerCase());
+            gateResults.push({
+                id,
+                title: gate.title,
+                status: 'skip',
+                durationMs: 0,
+                issues: [],
+            });
+            continue;
+        }
+        gateResults.push(await gate.run(ctx, gateConfig, config.maxFileSizeBytes));
+    }
+    // Downgrade gate failures when the entire gate covers requirements that are
+    // in the skip tier for the current task type. This prevents API projects from
+    // failing on accessibility checks, or CLI projects from failing on security headers.
+    if (ctx.skippedRequirementIds && ctx.skippedRequirementIds.size > 0) {
+        const GATE_TO_REQUIREMENT_IDS = {
+            'accessibility': ['aria-attributes', 'aria-interactive', 'responsive-layout', 'skip-link', 'dark-mode', 'focus-visible', 'semantic-html', 'keyboard-navigation', 'responsive-breakpoint'],
+        };
+        for (const result of gateResults) {
+            if (result.status !== 'fail')
+                continue;
+            const mappedIds = GATE_TO_REQUIREMENT_IDS[result.id];
+            if (!mappedIds)
+                continue;
+            const allSkipped = mappedIds.every(id => ctx.skippedRequirementIds.has(id));
+            if (allSkipped) {
+                result.status = 'skip';
+                result.issues = [];
+            }
+        }
+    }
+    const hardPassed = true;
+    const totalDurationMs = Date.now() - start;
+    if (outDir) {
+        fs.mkdirSync(outDir, { recursive: true });
+        const jsonPath = path.join(outDir, 'quality-gates.json');
+        fs.writeFileSync(jsonPath, JSON.stringify({
+            projectRoot,
+            passed: hardPassed,
+            advisory: true,
+            totalDurationMs,
+            results: gateResults
+        }, null, 2), 'utf8');
+        const mdPath = path.join(outDir, 'quality-gates.md');
+        const mdLines = [];
+        mdLines.push('# Quality Gates Report');
+        mdLines.push('');
+        mdLines.push(`Root: ${projectRoot}`);
+        mdLines.push('Status: ✅ PASSED (advisory findings only)');
+        mdLines.push(`Duration: ${totalDurationMs}ms`);
+        mdLines.push('');
+        for (const gr of gateResults) {
+            const icon = gr.status === 'pass' ? '✅' : gr.status === 'skip' ? '⏭️' : '❌';
+            mdLines.push(`## ${icon} ${gr.title} (${gr.id})`);
+            mdLines.push('');
+            if (gr.issues.length === 0) {
+                mdLines.push('No issues found.');
+                mdLines.push('');
+                continue;
+            }
+            for (const issue of gr.issues) {
+                mdLines.push(format_issue(issue));
+                if (issue.excerpt) {
+                    mdLines.push('');
+                    mdLines.push('```');
+                    mdLines.push(issue.excerpt);
+                    mdLines.push('```');
+                }
+                if (issue.hint) {
+                    mdLines.push('');
+                    mdLines.push(`hint: ${issue.hint}`);
+                }
+                mdLines.push('');
+            }
+        }
+        fs.writeFileSync(mdPath, mdLines.join('\n'), 'utf8');
+    }
+    return { passed: hardPassed, advisory: true, results: gateResults, totalDurationMs };
+}

package/dist/src/quality-gates/gates/accessibility.js

@@ -0,0 +1,355 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run_accessibility_gate = run_accessibility_gate;
+const file_utils_1 = require("../file-utils");
+// Matches <h1> through <h6> tags in HTML content
+const HEADING_REGEX = /<h([1-6])\b/gi;
+async function run_accessibility_gate(ctx, config, maxFileSizeBytes) {
+    const start = Date.now();
+    const issues = [];
+    // Only check files created by agents; pre-existing project files are the owner's concern
+    const baseline = ctx.baselineFiles;
+    const isAgentFile = (f) => !baseline || !baseline.has(f.relativePath);
+    const htmlFiles = ctx.files.filter(f => /\.html?$/i.test(f.relativePath) && isAgentFile(f));
+    const jsxFiles = ctx.files.filter(f => /\.(jsx|tsx)$/i.test(f.relativePath) && isAgentFile(f));
+    const cssFiles = ctx.files.filter(f => /\.css$/i.test(f.relativePath) && isAgentFile(f));
+    // 1. Check lang attribute on <html> in all .html files
+    for (const file of htmlFiles) {
+        const text = file.text ?? (0, file_utils_1.maybe_read_text)(file, maxFileSizeBytes);
+        if (!text)
+            continue;
+        if (/<html\b/i.test(text) && !/<html[^>]+lang\s*=/i.test(text)) {
+            issues.push({
+                message: `<html> element missing lang attribute`,
+                filePath: file.relativePath,
+                hint: 'add lang="en" (or appropriate language code) to the <html> tag'
+            });
+        }
+    }
+    // 2. Check for skip-to-content link
+    if (config.requireSkipLink && htmlFiles.length > 0) {
+        const hasSkipLink = htmlFiles.some(f => {
+            const text = f.text ?? (0, file_utils_1.maybe_read_text)(f, maxFileSizeBytes);
+            if (!text)
+                return false;
+            return /skip-link|skip.to.content|#main-content/i.test(text);
+        });
+        // Also check JSX/TSX components for skip links
+        const hasSkipLinkInJsx = jsxFiles.some(f => {
+            const text = f.text ?? (0, file_utils_1.maybe_read_text)(f, maxFileSizeBytes);
+            if (!text)
+                return false;
+            return /skip-link|skip.to.content|#main-content/i.test(text);
+        });
+        if (!hasSkipLink && !hasSkipLinkInJsx) {
+            issues.push({
+                message: 'no skip-to-content link found in HTML or JSX files',
+                hint: 'add <a href="#main-content" class="skip-link">Skip to content</a> as the first focusable element'
+            });
+        }
+    }
+    // 3. Check heading hierarchy
+    if (config.requireHeadingHierarchy) {
+        const allSourceFiles = [...htmlFiles, ...jsxFiles];
+        for (const file of allSourceFiles) {
+            const text = file.text ?? (0, file_utils_1.maybe_read_text)(file, maxFileSizeBytes);
+            if (!text)
+                continue;
+            const headings = [];
+            let match;
+            const headingRegex = new RegExp(HEADING_REGEX.source, 'gi');
+            while ((match = headingRegex.exec(text)) !== null) {
+                headings.push(parseInt(match[1], 10));
+            }
+            if (headings.length === 0)
+                continue;
+            // First heading should be h1
+            if (headings[0] !== 1) {
+                issues.push({
+                    message: `first heading is <h${headings[0]}>, expected <h1>`,
+                    filePath: file.relativePath,
+                    hint: 'page should start with an <h1> element'
+                });
+            }
+            // No skipped levels: h1 -> h3 without h2 in between
+            for (let i = 1; i < headings.length; i++) {
+                if (headings[i] > headings[i - 1] + 1) {
+                    issues.push({
+                        message: `heading level skips from <h${headings[i - 1]}> to <h${headings[i]}>`,
+                        filePath: file.relativePath,
+                        hint: `add an intermediate <h${headings[i - 1] + 1}> heading before <h${headings[i]}>`
+                    });
+                    break; // one issue per file is enough
+                }
+            }
+        }
+    }
+    // 4. Check aria-label on interactive/landmark elements
+    if (config.requireAriaLabels) {
+        for (const file of jsxFiles) {
+            const text = file.text ?? (0, file_utils_1.maybe_read_text)(file, maxFileSizeBytes);
+            if (!text)
+                continue;
+            // <nav> without aria-label
+            if (/<nav\b/i.test(text) && !/<nav[^>]+aria-label/i.test(text)) {
+                issues.push({
+                    message: '<nav> element missing aria-label',
+                    filePath: file.relativePath,
+                    hint: 'add aria-label="Main navigation" or similar'
+                });
+            }
+            // <button> without aria-label and without visible text children
+            // Only flag buttons that look like icon-only buttons (contain emoji or svg but no plain text)
+            const buttonRegex = /<button\b([^>]*)>([\s\S]*?)<\/button>/gi;
+            let btnMatch;
+            while ((btnMatch = buttonRegex.exec(text)) !== null) {
+                const attrs = btnMatch[1];
+                const content = btnMatch[2];
+                const hasAriaLabel = /aria-label/i.test(attrs);
+                // Button has meaningful text if it contains word characters outside tags
+                const strippedContent = content.replace(/<[^>]+>/g, '').trim();
+                const hasTextContent = /\w{2,}/.test(strippedContent);
+                if (!hasAriaLabel && !hasTextContent) {
+                    issues.push({
+                        message: 'icon-only <button> missing aria-label',
+                        filePath: file.relativePath,
+                        excerpt: content.slice(0, 40),
+                        hint: 'add aria-label describing the button action'
+                    });
+                    break; // one per file
+                }
+            }
+        }
+    }
+    // 5. Check for :focus-visible in CSS
+    if (config.requireFocusStyles) {
+        const hasFocusVisible = cssFiles.some(f => {
+            const text = f.text ?? (0, file_utils_1.maybe_read_text)(f, maxFileSizeBytes);
+            if (!text)
+                return false;
+            return /:focus-visible/.test(text);
+        });
+        // Also check inline styles in JSX for focus handling
+        const hasFocusInJsx = jsxFiles.some(f => {
+            const text = f.text ?? (0, file_utils_1.maybe_read_text)(f, maxFileSizeBytes);
+            if (!text)
+                return false;
+            return /focus-visible|onFocus|:focus/.test(text);
+        });
+        if (!hasFocusVisible && !hasFocusInJsx && cssFiles.length > 0) {
+            issues.push({
+                message: 'no :focus-visible styles found in any CSS file',
+                hint: 'add :focus-visible { outline: 2px solid <color>; outline-offset: 2px; } for interactive elements'
+            });
+        }
+        // Check for outline: none/0 without replacement focus style.
+        // "0" must be standalone (followed by ; or whitespace-then-;), not a decimal prefix like 0.1875rem.
+        const outlineDisabledRe = /outline\s*:\s*(none|0(?!\.\d))\s*(;|!|$)/m;
+        const outlineReplacementRe = /outline\s*:\s*\d+(\.\d+)?\s*(px|rem|em)\b/;
+        for (const file of cssFiles) {
+            const text = file.text ?? (0, file_utils_1.maybe_read_text)(file, maxFileSizeBytes);
+            if (!text)
+                continue;
+            if (outlineDisabledRe.test(text) && !outlineReplacementRe.test(text.replace(outlineDisabledRe, ''))) {
+                issues.push({
+                    message: 'outline: none found without replacement focus style',
+                    filePath: file.relativePath,
+                    hint: 'removing outline disables keyboard focus visibility; add an alternative focus indicator'
+                });
+            }
+        }
+    }
+    // 6. Check prefers-reduced-motion when animations are present
+    if (config.requireReducedMotion) {
+        const animationSources = [...cssFiles, ...htmlFiles];
+        for (const file of animationSources) {
+            const text = file.text ?? (0, file_utils_1.maybe_read_text)(file, maxFileSizeBytes);
+            if (!text)
+                continue;
+            const hasAnimations = /@keyframes\b/.test(text) || /animation\s*:/.test(text) || /transition\s*:/.test(text);
+            const hasReducedMotionQuery = /prefers-reduced-motion/.test(text);
+            if (hasAnimations && !hasReducedMotionQuery) {
+                issues.push({
+                    message: 'CSS includes animations but no prefers-reduced-motion media query',
+                    filePath: file.relativePath,
+                    hint: 'add @media (prefers-reduced-motion: reduce) { /* disable or simplify animations */ }'
+                });
+            }
+        }
+    }
+    // 7. Check for phantom asset references (src/href pointing to nonexistent local files)
+    if (config.requireNoPhantomAssets) {
+        const knownFiles = new Set(ctx.files.map(f => f.relativePath));
+        for (const file of htmlFiles) {
+            const text = file.text ?? (0, file_utils_1.maybe_read_text)(file, maxFileSizeBytes);
+            if (!text)
+                continue;
+            // Match src="..." and href="..." that look like local paths (not URLs, not anchors, not data URIs)
+            const refRegex = /(?:src|href)\s*=\s*["']([^"']+)["']/gi;
+            // Resolve references against the HTML file's own directory so a nested
+            // page (e.g. web/index.html) correctly points at web/src/styles.css.
+            const slashIdx = file.relativePath.lastIndexOf('/');
+            const htmlDir = slashIdx >= 0 ? file.relativePath.substring(0, slashIdx) : '';
+            let refMatch;
+            while ((refMatch = refRegex.exec(text)) !== null) {
+                const ref = refMatch[1];
+                // Skip external URLs, anchors, data URIs, template expressions
+                if (/^(https?:|mailto:|#|data:|javascript:|\{|%|\/)/.test(ref))
+                    continue;
+                // Resolve ./ and ../ segments against the HTML file's directory.
+                let remaining = ref.replace(/^\.\//g, '');
+                let dir = htmlDir;
+                while (remaining.startsWith('../')) {
+                    remaining = remaining.substring(3);
+                    const parent = dir.lastIndexOf('/');
+                    dir = parent >= 0 ? dir.substring(0, parent) : '';
+                }
+                const resolved = dir ? `${dir}/${remaining}` : remaining;
+                // Fall back to the bare reference for flat projects where HTML sits
+                // alongside its assets without a shared parent directory.
+                if (!knownFiles.has(resolved) && !knownFiles.has(remaining)) {
+                    issues.push({
+                        message: `references "${ref}" which does not exist in the project`,
+                        filePath: file.relativePath,
+                        hint: 'remove the reference or create the missing file'
+                    });
+                }
+            }
+        }
+    }
+    // 8. Check for required meta tags in HTML head
+    if (config.requireMetaTags) {
+        for (const file of htmlFiles) {
+            const text = file.text ?? (0, file_utils_1.maybe_read_text)(file, maxFileSizeBytes);
+            if (!text)
+                continue;
+            if (!/<html\b/i.test(text))
+                continue;
+            if (!/<meta[^>]+name\s*=\s*["']description["'][^>]*>/i.test(text)) {
+                issues.push({
+                    message: 'missing <meta name="description"> in HTML head',
+                    filePath: file.relativePath,
+                    hint: 'add <meta name="description" content="..."> with a real project description'
+                });
+            }
+            if (!/<meta[^>]+name\s*=\s*["']theme-color["'][^>]*>/i.test(text)) {
+                issues.push({
+                    message: 'missing <meta name="theme-color"> in HTML head',
+                    filePath: file.relativePath,
+                    hint: 'add <meta name="theme-color" content="#..."> matching the primary brand color'
+                });
+            }
+        }
+    }
+    // 9. Check for responsive CSS (viewport meta tag and responsive units or media queries)
+    if (config.requireResponsiveCSS && htmlFiles.length > 0) {
+        const hasViewportMeta = htmlFiles.some(f => {
+            const text = f.text ?? (0, file_utils_1.maybe_read_text)(f, maxFileSizeBytes);
+            return text ? /<meta[^>]+name\s*=\s*["']viewport["'][^>]*>/i.test(text) : false;
+        });
+        if (!hasViewportMeta) {
+            issues.push({
+                message: 'no <meta name="viewport"> found in any HTML file',
+                hint: 'add <meta name="viewport" content="width=device-width, initial-scale=1.0"> for responsive layout'
+            });
+        }
+        // At least one CSS file should use a responsive technique
+        if (cssFiles.length > 0) {
+            const hasResponsive = cssFiles.some(f => {
+                const text = f.text ?? (0, file_utils_1.maybe_read_text)(f, maxFileSizeBytes);
+                if (!text)
+                    return false;
+                return /@media\b/.test(text) || /\bclamp\(/.test(text) || /\b(vw|vh|vmin|vmax|rem|%)\b/.test(text);
+            });
+            if (!hasResponsive) {
+                issues.push({
+                    message: 'CSS uses no responsive techniques (media queries, clamp(), relative units)',
+                    hint: 'use relative units (rem, %), clamp(), or @media queries for responsive layout'
+                });
+            }
+        }
+    }
+    // 10. Check for color scheme support (CSS custom properties + dark mode query)
+    if (config.requireColorScheme && cssFiles.length > 0) {
+        const hasCustomProperties = cssFiles.some(f => {
+            const text = f.text ?? (0, file_utils_1.maybe_read_text)(f, maxFileSizeBytes);
+            return text ? /--[\w-]+\s*:/.test(text) : false;
+        });
+        const hasDarkModeQuery = cssFiles.some(f => {
+            const text = f.text ?? (0, file_utils_1.maybe_read_text)(f, maxFileSizeBytes);
+            return text ? /prefers-color-scheme\s*:\s*dark/.test(text) : false;
+        });
+        if (!hasCustomProperties) {
+            issues.push({
+                message: 'no CSS custom properties defined; colors should use --var references for theming',
+                hint: 'define colors, spacing, and font sizes as custom properties on :root'
+            });
+        }
+        if (!hasDarkModeQuery) {
+            issues.push({
+                message: 'no @media (prefers-color-scheme: dark) found for dark mode support',
+                hint: 'add a dark mode media query that overrides :root custom properties'
+            });
+        }
+    }
+    // 11. Check semantic HTML: flag div-heavy markup without semantic elements
+    if (config.requireSemanticHTML) {
+        for (const file of htmlFiles) {
+            const text = file.text ?? (0, file_utils_1.maybe_read_text)(file, maxFileSizeBytes);
+            if (!text)
+                continue;
+            if (!/<html\b/i.test(text))
+                continue;
+            const hasMain = /<main\b/i.test(text);
+            const hasNav = /<nav\b/i.test(text);
+            const hasHeader = /<header\b/i.test(text);
+            const hasSemanticElement = hasMain || hasNav || hasHeader;
+            const divCount = (text.match(/<div\b/gi) || []).length;
+            // Flag pages that use divs but no semantic landmarks at all
+            if (divCount > 3 && !hasSemanticElement) {
+                issues.push({
+                    message: `${divCount} <div> elements but no semantic landmarks (main, nav, header)`,
+                    filePath: file.relativePath,
+                    hint: 'replace wrapper divs with semantic elements: <main>, <nav>, <header>, <footer>'
+                });
+            }
+        }
+    }
+    // 12. Check that <img> tags have alt attributes
+    if (config.requireImgAlt) {
+        const allSourceFiles = [...htmlFiles, ...jsxFiles];
+        for (const file of allSourceFiles) {
+            const text = file.text ?? (0, file_utils_1.maybe_read_text)(file, maxFileSizeBytes);
+            if (!text)
+                continue;
+            const imgRegex = /<img\b([^>]*)>/gi;
+            let imgMatch;
+            while ((imgMatch = imgRegex.exec(text)) !== null) {
+                const attrs = imgMatch[1];
+                if (!/\balt\s*=/i.test(attrs)) {
+                    issues.push({
+                        message: '<img> element missing alt attribute',
+                        filePath: file.relativePath,
+                        hint: 'add alt="descriptive text" or alt="" for decorative images'
+                    });
+                    break; // one per file
+                }
+            }
+        }
+    }
+    const durationMs = Date.now() - start;
+    const status = issues.length > 0 ? 'fail' : 'pass';
+    return {
+        id: 'accessibility',
+        title: 'Accessibility checks',
+        status,
+        durationMs,
+        issues,
+        stats: {
+            htmlFiles: htmlFiles.length,
+            jsxFiles: jsxFiles.length,
+            cssFiles: cssFiles.length,
+            issues: issues.length
+        }
+    };
+}