npm - superkit-mcp-server - Versions diffs - 1.0.1 → 1.0.2 - Mend

superkit-mcp-server 1.0.1 → 1.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (67) hide show

package/ARCHITECTURE.md +2 -3
package/README.md +1 -0
package/build/index.js +75 -0
package/build/tools/autoPreview.js +99 -0
package/build/tools/checklist.js +120 -0
package/build/tools/sessionManager.js +107 -0
package/build/tools/validators/__tests__/apiSchema.test.js +77 -0
package/build/tools/validators/__tests__/convertRules.test.js +38 -0
package/build/tools/validators/__tests__/frontendDesign.test.js +55 -0
package/build/tools/validators/__tests__/geoChecker.test.js +45 -0
package/build/tools/validators/__tests__/i18nChecker.test.js +32 -0
package/build/tools/validators/__tests__/lintRunner.test.js +65 -0
package/build/tools/validators/__tests__/mobileAudit.test.js +40 -0
package/build/tools/validators/__tests__/playwrightRunner.test.js +55 -0
package/build/tools/validators/__tests__/reactPerformanceChecker.test.js +49 -0
package/build/tools/validators/__tests__/securityScan.test.js +42 -0
package/build/tools/validators/__tests__/seoChecker.test.js +44 -0
package/build/tools/validators/__tests__/testRunner.test.js +49 -0
package/build/tools/validators/__tests__/typeCoverage.test.js +62 -0
package/build/tools/validators/accessibilityChecker.js +124 -0
package/build/tools/validators/apiValidator.js +140 -0
package/build/tools/validators/convertRules.js +170 -0
package/build/tools/validators/geoChecker.js +176 -0
package/build/tools/validators/i18nChecker.js +205 -0
package/build/tools/validators/lighthouseAudit.js +50 -0
package/build/tools/validators/lintRunner.js +106 -0
package/build/tools/validators/mobileAudit.js +190 -0
package/build/tools/validators/playwrightRunner.js +101 -0
package/build/tools/validators/reactPerformanceChecker.js +199 -0
package/build/tools/validators/schemaValidator.js +105 -0
package/build/tools/validators/securityScan.js +215 -0
package/build/tools/validators/seoChecker.js +122 -0
package/build/tools/validators/testRunner.js +111 -0
package/build/tools/validators/typeCoverage.js +150 -0
package/build/tools/validators/uxAudit.js +222 -0
package/build/tools/verifyAll.js +159 -0
package/package.json +5 -3
package/skills/tech/api-patterns/SKILL.md +1 -1
package/skills/tech/clean-code/SKILL.md +14 -14
package/skills/tech/doc.md +3 -3
package/skills/tech/frontend-design/SKILL.md +1 -1
package/skills/tech/geo-fundamentals/SKILL.md +1 -1
package/skills/tech/i18n-localization/SKILL.md +1 -1
package/skills/tech/lint-and-validate/SKILL.md +2 -2
package/skills/tech/mobile-design/SKILL.md +1 -1
package/skills/tech/nextjs-react-expert/SKILL.md +1 -1
package/skills/tech/parallel-agents/SKILL.md +3 -3
package/skills/tech/performance-profiling/SKILL.md +1 -1
package/skills/tech/vulnerability-scanner/SKILL.md +1 -1
package/skills/tech/webapp-testing/SKILL.md +3 -3
package/workflows/review-compound.md +1 -1
package/skills/tech/api-patterns/scripts/api_validator.py +0 -211
package/skills/tech/database-design/scripts/schema_validator.py +0 -172
package/skills/tech/frontend-design/scripts/accessibility_checker.py +0 -183
package/skills/tech/frontend-design/scripts/ux_audit.py +0 -722
package/skills/tech/geo-fundamentals/scripts/geo_checker.py +0 -289
package/skills/tech/i18n-localization/scripts/i18n_checker.py +0 -241
package/skills/tech/lint-and-validate/scripts/lint_runner.py +0 -184
package/skills/tech/lint-and-validate/scripts/type_coverage.py +0 -173
package/skills/tech/mobile-design/scripts/mobile_audit.py +0 -670
package/skills/tech/nextjs-react-expert/scripts/convert_rules.py +0 -222
package/skills/tech/nextjs-react-expert/scripts/react_performance_checker.py +0 -252
package/skills/tech/performance-profiling/scripts/lighthouse_audit.py +0 -76
package/skills/tech/seo-fundamentals/scripts/seo_checker.py +0 -219
package/skills/tech/testing-patterns/scripts/test_runner.py +0 -219
package/skills/tech/vulnerability-scanner/scripts/security_scan.py +0 -458
package/skills/tech/webapp-testing/scripts/playwright_runner.py +0 -173

package/build/tools/validators/__tests__/geoChecker.test.js ADDED Viewed

@@ -0,0 +1,45 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { checkGeoPage } from '../geoChecker.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+describe('geoChecker', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('checkGeoPage', () => {
+        it('should detect structured schema and H1s', async () => {
+            vi.mocked(fs.readFile).mockResolvedValue(`
+                <html lang="en">
+                <head>
+                <script type="application/ld+json">
+                {
+                  "@type": "Article",
+                  "author": "Test Author"
+                }
+                </script>
+                </head>
+                <body>
+                    <h1>Main Title</h1>
+                    <p>Some content with numbers like 50% and $100.</p>
+                </body>
+                </html>
+            `);
+            const result = await checkGeoPage('/mock/page.html');
+            expect(result.passed.some(m => m.includes('JSON-LD structured data'))).toBe(true);
+            expect(result.passed.some(m => m.includes('Single H1'))).toBe(true);
+            expect(result.passed.some(m => m.includes('Original statistics'))).toBe(true);
+            expect(result.score).toBeGreaterThan(0);
+        });
+        it('should flag missing structural tags', async () => {
+            vi.mocked(fs.readFile).mockResolvedValue(`
+                <body>
+                    <p>No headings, no structure, no stats.</p>
+                </body>
+            `);
+            const result = await checkGeoPage('/mock/bad.html');
+            expect(result.issues.some(m => m.includes('No JSON-LD'))).toBe(true);
+            expect(result.issues.some(m => m.includes('No H1 heading'))).toBe(true);
+            expect(result.score).toBeLessThan(50);
+        });
+    });
+});

package/build/tools/validators/__tests__/i18nChecker.test.js ADDED Viewed

@@ -0,0 +1,32 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { checkLocaleCompleteness } from '../i18nChecker.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+describe('i18nChecker', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('checkLocaleCompleteness', () => {
+        it('should detect missing translation keys in other locales', async () => {
+            // Mock translation files
+            vi.mocked(fs.readFile).mockImplementation(async (file) => {
+                if (file.includes('en'))
+                    return JSON.stringify({ hello: 'World', nested: { a: 1, b: 2 } });
+                if (file.includes('fr'))
+                    return JSON.stringify({ hello: 'Monde', nested: { a: 1 } });
+                return "{}";
+            });
+            const result = await checkLocaleCompleteness(['/locales/en/common.json', '/locales/fr/common.json']);
+            expect(result.issues.some(i => i.includes('Missing 1 keys'))).toBe(true);
+            expect(result.passed.some(p => p.includes('Found 2 language'))).toBe(true);
+        });
+        it('should pass matching keys', async () => {
+            vi.mocked(fs.readFile).mockImplementation(async (file) => {
+                return JSON.stringify({ a: 1, b: 2 });
+            });
+            const result = await checkLocaleCompleteness(['/en/app.json', '/es/app.json']);
+            expect(result.issues.length).toBe(0);
+            expect(result.passed.some(p => p.includes('matching keys'))).toBe(true);
+        });
+    });
+});

package/build/tools/validators/__tests__/lintRunner.test.js ADDED Viewed

@@ -0,0 +1,65 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { detectProjectType, runLinter } from '../lintRunner.js';
+import * as fs from 'fs/promises';
+import { existsSync } from 'fs';
+import * as cp from 'child_process';
+// Mock fs and child_process modules
+vi.mock('fs/promises');
+vi.mock('fs', () => ({ existsSync: vi.fn() }));
+vi.mock('child_process');
+describe('lintRunner', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('detectProjectType', () => {
+        it('should detect a node project with lint script', async () => {
+            existsSync.mockImplementation((p) => p.endsWith('package.json'));
+            vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({
+                scripts: { lint: 'eslint .' }
+            }));
+            const info = await detectProjectType('/mock/path');
+            expect(info.type).toBe('node');
+            expect(info.linters).toEqual([{ name: 'npm lint', cmd: ['npm', 'run', 'lint'] }]);
+        });
+        it('should detect a python project with ruff', async () => {
+            existsSync.mockImplementation((p) => p.endsWith('pyproject.toml') || p.endsWith('mypy.ini'));
+            const info = await detectProjectType('/mock/python');
+            expect(info.type).toBe('python');
+            expect(info.linters).toContainEqual({ name: 'ruff', cmd: ['ruff', 'check', '.'] });
+            expect(info.linters).toContainEqual({ name: 'mypy', cmd: ['mypy', '.'] });
+        });
+    });
+    describe('runLinter', () => {
+        it('should return passed on success code', async () => {
+            // Mock spawn
+            const mockChild = {
+                stdout: { on: vi.fn((event, cb) => cb('success out')) },
+                stderr: { on: vi.fn() },
+                on: vi.fn((event, cb) => {
+                    if (event === 'close')
+                        cb(0);
+                }),
+                kill: vi.fn()
+            };
+            vi.mocked(cp.spawn).mockReturnValue(mockChild);
+            const result = await runLinter({ name: 'test', cmd: ['npm', 'test'] }, '/mock');
+            expect(result.passed).toBe(true);
+            expect(result.output).toContain('success out');
+        });
+        it('should return failed on error code', async () => {
+            const mockChild = {
+                stdout: { on: vi.fn() },
+                stderr: { on: vi.fn((event, cb) => cb('error out')) },
+                on: vi.fn((event, cb) => {
+                    if (event === 'close')
+                        cb(1);
+                }),
+                kill: vi.fn()
+            };
+            vi.mocked(cp.spawn).mockReturnValue(mockChild);
+            const result = await runLinter({ name: 'failtest', cmd: ['npm', 'fail'] }, '/mock');
+            expect(result.passed).toBe(false);
+            expect(result.error).toContain('error out');
+        });
+    });
+});

package/build/tools/validators/__tests__/mobileAudit.test.js ADDED Viewed

@@ -0,0 +1,40 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { runMobileAudit } from '../mobileAudit.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+describe('mobileAudit', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should report warnings for generic rn file issues', async () => {
+        vi.mocked(fs.readdir).mockResolvedValue([{
+                name: 'Screen.tsx',
+                isDirectory: () => false
+            }]);
+        vi.mocked(fs.readFile).mockResolvedValue(`
+            import React from 'react';
+            import { View, ScrollView } from 'react-native';
+            export const Screen = () => {
+                return (
+                    <ScrollView>
+                       {data.map(d => <View key={index} />)}
+                    </ScrollView>
+                )
+            }
+        `);
+        const res = await runMobileAudit('.');
+        expect(res.passed).toBe(false);
+        expect(res.report).toContain('ScrollView with .map()'); // critical performance
+    });
+    it('should ignore non react native / flutter files', async () => {
+        vi.mocked(fs.readdir).mockResolvedValue([{
+                name: 'regular.tsx',
+                isDirectory: () => false
+            }]);
+        vi.mocked(fs.readFile).mockResolvedValue(`
+            export const App = () => <div>Hello Web</div>
+        `);
+        const res = await runMobileAudit('.');
+        expect(res.passed).toBe(true);
+    });
+});

package/build/tools/validators/__tests__/playwrightRunner.test.js ADDED Viewed

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { runPlaywrightTest, runPlaywrightA11y } from '../playwrightRunner.js';
+vi.mock('playwright', () => {
+    return {
+        chromium: {
+            launch: vi.fn().mockResolvedValue({
+                newContext: vi.fn().mockResolvedValue({
+                    newPage: vi.fn().mockResolvedValue({
+                        goto: vi.fn().mockResolvedValue({
+                            status: () => 200,
+                            ok: () => true
+                        }),
+                        title: vi.fn().mockResolvedValue('Mock Title'),
+                        url: () => 'https://example.com',
+                        locator: vi.fn().mockReturnValue({ count: vi.fn().mockResolvedValue(5) }),
+                        on: vi.fn(),
+                        evaluate: vi.fn().mockResolvedValue('{"dom_content_loaded":100,"load_complete":200}'),
+                        screenshot: vi.fn().mockResolvedValue(true)
+                    })
+                }),
+                newPage: vi.fn().mockResolvedValue({
+                    goto: vi.fn().mockResolvedValue({
+                        status: () => 200,
+                        ok: () => true
+                    }),
+                    locator: vi.fn().mockReturnValue({ count: vi.fn().mockResolvedValue(3) })
+                }),
+                close: vi.fn().mockResolvedValue(undefined)
+            })
+        }
+    };
+});
+describe('playwrightRunner', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should successfully run a basic browser test', async () => {
+        const res = await runPlaywrightTest('https://example.com');
+        console.log("PLAYWRIGHT TEST:", res);
+        expect(res.error).toBeUndefined();
+        expect(res.status).toBe('success');
+        expect(res.health.loaded).toBe(true);
+        expect(res.performance.dom_content_loaded).toBe(100);
+        expect(res.elements.links).toBe(5);
+        expect(res.summary).toContain('[OK] Page loaded');
+    });
+    it('should calculate accessibility counts properly', async () => {
+        const res = await runPlaywrightA11y('https://example.com');
+        console.log("PLAYWRIGHT A11y:", res);
+        expect(res.error).toBeUndefined();
+        expect(res.status).toBe('success');
+        expect(res.accessibility.images_with_alt).toBe(3);
+        expect(res.accessibility.headings.h1).toBe(3);
+    });
+});

package/build/tools/validators/__tests__/reactPerformanceChecker.test.js ADDED Viewed

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { runReactPerformanceChecker } from '../reactPerformanceChecker.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+describe('reactPerformanceChecker', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should detect waterfalls and barrel imports', async () => {
+        vi.mocked(fs.readdir).mockResolvedValue([{
+                name: 'Home.tsx',
+                isDirectory: () => false
+            }]);
+        vi.mocked(fs.readFile).mockResolvedValue(`
+            import { something } from '@/components/index';
+            async function loadData() {
+                const a = await fetchA();
+                const b = await fetchB();
+                return { a, b };
+            }
+        `);
+        const res = await runReactPerformanceChecker('.');
+        console.log("RPC BAD REPORT:", res.report);
+        expect(res.passed).toBe(false); // CRITICAL issue makes it fail
+        expect(res.report).toContain('Sequential awaits detected (waterfall)');
+        expect(res.report).toContain('Potential barrel imports detected');
+    });
+    it('should pass cleanly configured react app', async () => {
+        vi.mocked(fs.readdir).mockResolvedValue([{
+                name: 'App.tsx',
+                isDirectory: () => false
+            }]);
+        vi.mocked(fs.readFile).mockResolvedValue(`
+            import { useQuery } from '@tanstack/react-query';
+            import Image from 'next/image';
+            const App = React.memo((props: Props) => {
+                const q = useQuery('data', fetchParallel);
+                return <Image src="foo" alt="bar" />
+            });
+            export default App;
+        `);
+        const res = await runReactPerformanceChecker('.');
+        console.log("RPC GOOD REPORT:", res.report);
+        expect(res.passed).toBe(true);
+        expect(res.report).toContain('[SUCCESS]');
+    });
+});

package/build/tools/validators/__tests__/securityScan.test.js ADDED Viewed

@@ -0,0 +1,42 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { scanSecrets, scanCodePatterns } from '../securityScan.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+describe('securityScan', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('scanSecrets', () => {
+        it('should detect AWS keys', async () => {
+            // Mock file system
+            vi.mocked(fs.readdir).mockResolvedValue([{
+                    name: 'config.json',
+                    isDirectory: () => false
+                }]);
+            vi.mocked(fs.readFile).mockResolvedValue(`
+                 { "aws_key": "AKIA1234567890123456" }
+             `);
+            const result = await scanSecrets('/mock');
+            expect(result.findings).toBeDefined();
+            expect(result.findings.some((f) => f.type === 'AWS Access Key')).toBe(true);
+            expect(result.by_severity.critical).toBeGreaterThan(0);
+        });
+    });
+    describe('scanCodePatterns', () => {
+        it('should detect eval() and child_process.exec()', async () => {
+            vi.mocked(fs.readdir).mockResolvedValue([{
+                    name: 'bad_code.js',
+                    isDirectory: () => false
+                }]);
+            vi.mocked(fs.readFile).mockResolvedValue(`
+                 eval('2 + 2');
+                 import { exec } from 'child_process';
+                 child_process.exec('rm -rf /');
+             `);
+            const result = await scanCodePatterns('/mock');
+            expect(result.findings.length).toBeGreaterThan(1);
+            expect(result.findings.some((f) => f.pattern === 'eval() usage')).toBe(true);
+            expect(result.findings.some((f) => f.pattern === 'child_process.exec')).toBe(true);
+        });
+    });
+});

package/build/tools/validators/__tests__/seoChecker.test.js ADDED Viewed

@@ -0,0 +1,44 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { runSeoChecker } from '../seoChecker.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+describe('seoChecker', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should report SEO issues on a page', async () => {
+        vi.mocked(fs.readdir).mockResolvedValue([{
+                name: 'index.tsx', // valid page layout file
+                isDirectory: () => false
+            }]);
+        vi.mocked(fs.readFile).mockResolvedValue(`
+            export default function Index() {
+                return (
+                    <html>
+                        <head>
+                            <title>Oops missing description and og</title>
+                        </head>
+                        <body>
+                            <h1>Title</h1>
+                            <h1>Duplicate Title</h1>
+                            <img src="foo" />
+                            <img src="bar" alt="" />
+                        </body>
+                    </html>
+                )
+            }
+        `);
+        const res = await runSeoChecker('.');
+        expect(res.passed).toBe(false);
+        expect(res.report).toContain('Image missing alt attribute');
+    });
+    it('should ignore non-pages files like utilities', async () => {
+        vi.mocked(fs.readdir).mockResolvedValue([{
+                name: 'api.util.ts',
+                isDirectory: () => false
+            }]);
+        const res = await runSeoChecker('.');
+        expect(res.passed).toBe(true);
+        expect(res.report).toContain('[!] No page files found.');
+    });
+});

package/build/tools/validators/__tests__/testRunner.test.js ADDED Viewed

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { runTestRunner, detectTestFramework } from '../testRunner.js';
+import * as fs from 'fs/promises';
+import * as child_process from 'child_process';
+vi.mock('fs/promises');
+vi.mock('child_process', () => ({
+    exec: vi.fn((cmd, options, callback) => {
+        callback(null, { stdout: '1 passed', stderr: '' });
+    })
+}));
+describe('testRunner', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should detect node test frameworks via package.json', async () => {
+        vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({
+            scripts: { test: "something" },
+            devDependencies: { vitest: "^1.0.0" }
+        }));
+        vi.mocked(fs.stat).mockRejectedValue(new Error('ENOENT')); // no python
+        const info = await detectTestFramework('.');
+        expect(info.type).toBe('node');
+        expect(info.framework).toBe('vitest');
+        expect(info.cmd).toEqual(['npm', 'test']);
+        expect(info.coverageCmd).toEqual(['npx', 'vitest', 'run', '--coverage']);
+    });
+    it('should detect python tests via pyproject.toml', async () => {
+        vi.mocked(fs.readFile).mockRejectedValue(new Error('ENOENT')); // no package.json
+        vi.mocked(fs.stat).mockResolvedValue({});
+        const info = await detectTestFramework('.');
+        expect(info.type).toBe('python');
+        expect(info.framework).toBe('pytest');
+        expect(info.cmd).toEqual(['python', '-m', 'pytest', '-v']);
+    });
+    it('should run tests and report success', async () => {
+        vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({
+            scripts: { test: "jest" }
+        }));
+        // Mock child_process.exec to simulate passing tests
+        vi.mocked(child_process.exec).mockImplementation((...args) => {
+            const cb = args[args.length - 1];
+            cb(null, { stdout: 'Tests: 1 passed, 1 total', stderr: '' });
+            return {};
+        });
+        const res = await runTestRunner('.');
+        expect(res.passed).toBe(true);
+        expect(res.report).toContain('Tests: 1 total, 1 passed, 0 failed');
+    });
+});

package/build/tools/validators/__tests__/typeCoverage.test.js ADDED Viewed

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { checkTypescriptCoverage, checkPythonCoverage } from '../typeCoverage.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+describe('typeCoverage', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('checkTypescriptCoverage', () => {
+        it('should analyze a typescript file and find any types', async () => {
+            // Mock readdir to return 1 TS file
+            vi.mocked(fs.readdir).mockResolvedValue([{
+                    name: 'index.ts',
+                    isDirectory: () => false
+                }]);
+            // Mock readFile to return a snippet with an untyped function and an "any"
+            vi.mocked(fs.readFile).mockResolvedValue(`
+                function test(): any { return 1; }
+                const test2 = (x) => console.log(x);
+            `);
+            const result = await checkTypescriptCoverage('/mock/folder');
+            expect(result.type).toBe('typescript');
+            expect(result.files).toBe(1);
+            expect(result.stats.any_count).toBeGreaterThan(0);
+            expect(result.stats.untyped_functions).toBeGreaterThan(0);
+        });
+        it('should handle perfectly typed code without any', async () => {
+            vi.mocked(fs.readdir).mockResolvedValue([{
+                    name: 'good.ts',
+                    isDirectory: () => false
+                }]);
+            vi.mocked(fs.readFile).mockResolvedValue(`
+                function typedFunc(val: string): number { return val.length; }
+            `);
+            const result = await checkTypescriptCoverage('/mock/good');
+            expect(result.stats.any_count).toBe(0);
+            expect(result.stats.untyped_functions).toBe(0);
+            expect(result.passed.some(p => p.includes('100%'))).toBe(true);
+        });
+    });
+    describe('checkPythonCoverage', () => {
+        it('should detect Python type hint issues', async () => {
+            vi.mocked(fs.readdir).mockResolvedValue([{
+                    name: 'script.py',
+                    isDirectory: () => false
+                }]);
+            vi.mocked(fs.readFile).mockResolvedValue(`
+def bad_func(arg):
+    pass
+def good_func(arg: str) -> bool:
+    return True
+def any_func(arg: Any) -> Any:
+    pass
+             `);
+            const result = await checkPythonCoverage('/mock/py');
+            expect(result.stats.any_count).toBeGreaterThan(0);
+            expect(result.stats.untyped_functions).toBe(1);
+        });
+    });
+});

package/build/tools/validators/accessibilityChecker.js ADDED Viewed

@@ -0,0 +1,124 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export async function findHtmlFiles(projectPath) {
+    let files = [];
+    const skipDirs = new Set(['node_modules', '.next', 'dist', 'build', '.git']);
+    async function search(dir) {
+        try {
+            const items = await fs.readdir(dir, { withFileTypes: true });
+            for (const item of items) {
+                if (skipDirs.has(item.name))
+                    continue;
+                const fullPath = path.join(dir, item.name);
+                if (item.isDirectory())
+                    await search(fullPath);
+                else {
+                    const ext = path.extname(item.name).toLowerCase();
+                    if (['.html', '.jsx', '.tsx'].includes(ext)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    await search(projectPath);
+    return files.slice(0, 50);
+}
+export async function checkAccessibility(filePath) {
+    const issues = [];
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const lowerContent = content.toLowerCase();
+        const inputs = content.match(/<input[^>]*>/gi) || [];
+        for (const inp of inputs) {
+            if (!inp.toLowerCase().includes('type="hidden"')) {
+                if (!inp.toLowerCase().includes('aria-label') && !inp.toLowerCase().includes('id=')) {
+                    issues.push("Input without label or aria-label");
+                    break;
+                }
+            }
+        }
+        const buttons = content.match(/<button[^>]*>[^<]*<\/button>/gi) || [];
+        for (const btn of buttons) {
+            if (!btn.toLowerCase().includes('aria-label')) {
+                const text = btn.replace(/<[^>]+>/g, '').trim();
+                if (!text) {
+                    issues.push("Button without accessible text");
+                    break;
+                }
+            }
+        }
+        if (lowerContent.includes('<html') && !lowerContent.includes('lang=')) {
+            issues.push("Missing lang attribute on <html>");
+        }
+        if (lowerContent.includes('<main') || lowerContent.includes('<body')) {
+            if (!lowerContent.includes('skip') && !lowerContent.includes('#main')) {
+                issues.push("Consider adding skip-to-main-content link");
+            }
+        }
+        const onClickCount = (lowerContent.match(/onclick=/g) || []).length;
+        const keyCount = (lowerContent.match(/onkeydown=|onkeyup=/g) || []).length;
+        if (onClickCount > 0 && keyCount === 0) {
+            issues.push("onClick without keyboard handler (onKeyDown)");
+        }
+        if (lowerContent.includes('tabindex=')) {
+            if (!lowerContent.includes('tabindex="-1"') && !lowerContent.includes('tabindex="0"')) {
+                const positive = lowerContent.match(/tabindex="([1-9]\d*)"/);
+                if (positive)
+                    issues.push("Avoid positive tabIndex values");
+            }
+        }
+        if (lowerContent.includes('autoplay') && !lowerContent.includes('muted')) {
+            issues.push("Autoplay media should be muted");
+        }
+        if (lowerContent.includes('role="button"')) {
+            const divButtons = content.match(/<div[^>]*role="button"[^>]*>/gi) || [];
+            for (const div of divButtons) {
+                if (!div.toLowerCase().includes('tabindex')) {
+                    issues.push("role='button' without tabindex");
+                    break;
+                }
+            }
+        }
+    }
+    catch (e) {
+        issues.push(`Error reading file: ${e.message.substring(0, 50)}`);
+    }
+    return issues;
+}
+export async function runAccessibilityChecker(projectPath = ".") {
+    const root = path.resolve(projectPath);
+    let report = `============================================================\n`;
+    report += `[ACCESSIBILITY CHECKER] WCAG Compliance Audit\n`;
+    report += `============================================================\n`;
+    report += `Project: ${root}\n------------------------------------------------------------\n`;
+    const files = await findHtmlFiles(root);
+    report += `Found ${files.length} HTML/JSX/TSX files\n`;
+    if (files.length === 0) {
+        return { passed: true, report: report + "No HTML files found\n" };
+    }
+    const allIssues = [];
+    for (const file of files) {
+        const issues = await checkAccessibility(file);
+        if (issues.length > 0) {
+            allIssues.push({ file: path.basename(file), issues });
+        }
+    }
+    report += `\n============================================================\nACCESSIBILITY ISSUES\n============================================================\n`;
+    if (allIssues.length > 0) {
+        for (const item of allIssues.slice(0, 10)) {
+            report += `\n${item.file}:\n`;
+            for (const issue of item.issues)
+                report += `  - ${issue}\n`;
+        }
+        if (allIssues.length > 10)
+            report += `\n... and ${allIssues.length - 10} more files with issues\n`;
+    }
+    else {
+        report += "No accessibility issues found!\n";
+    }
+    const totalIssues = allIssues.reduce((sum, item) => sum + item.issues.length, 0);
+    const passed = totalIssues < 5;
+    return { passed, report };
+}