superkit-mcp-server 1.2.6 → 1.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superkit-mcp-server",
-  "version": "1.2.6",
+  "version": "1.2.7",
   "type": "module",
   "description": "An MCP server for exploring and loading Super-Kit AI agent resources.",
   "main": "build/index.js",
@@ -8,6 +8,8 @@
     "superkit-mcp-server": "./build/index.js"
   },
   "scripts": {
+    "clean": "rimraf build",
+    "prebuild": "rimraf build",
     "build": "tsc",
     "start": "node build/index.js",
     "dev": "tsc --watch"
@@ -21,6 +23,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.19.13",
+    "rimraf": "^6.1.3",
     "typescript": "^5.7.2",
     "vitest": "^4.0.18"
   },

package/build/__tests__/test_apply_prompt_args.js

@@ -1,104 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { apply_prompt_args } from '../index.js';
-describe('apply_prompt_args', () => {
-    describe('{{args}} substitution', () => {
-        it('should replace {{args}} with the provided user args', () => {
-            const result = apply_prompt_args('Task: {{args}}', 'Add user authentication');
-            expect(result).toBe('Task: Add user authentication');
-        });
-        it('should replace all occurrences of {{args}}', () => {
-            const result = apply_prompt_args('{{args}} and also {{args}}', 'hello');
-            expect(result).toBe('hello and also hello');
-        });
-        it('should replace {{args}} with an empty string when no args are provided', () => {
-            const result = apply_prompt_args('Task: {{args}}', '');
-            expect(result).toBe('Task: ');
-        });
-        it('should replace {{args}} with an empty string when args is only whitespace', () => {
-            const result = apply_prompt_args('Task: {{args}}', '   ');
-            expect(result).toBe('Task:    ');
-        });
-    });
-    describe('{{#if args}} ... {{/if}} block (no else branch)', () => {
-        it('should include the block content when args is provided', () => {
-            const template = '{{#if args}}Task: {{args}}{{/if}}';
-            const result = apply_prompt_args(template, 'Fix bug');
-            expect(result).toBe('Task: Fix bug');
-        });
-        it('should remove the block entirely when args is empty', () => {
-            const template = 'Before\n{{#if args}}Task: {{args}}{{/if}}\nAfter';
-            const result = apply_prompt_args(template, '');
-            expect(result).toBe('Before\n\nAfter');
-        });
-        it('should remove the block entirely when args is only whitespace', () => {
-            const template = '{{#if args}}Task: {{args}}{{/if}}';
-            const result = apply_prompt_args(template, '   ');
-            expect(result).toBe('');
-        });
-        it('should handle multiline block content', () => {
-            const template = '{{#if args}}\n# Task\n**Input:** {{args}}\n{{/if}}';
-            const result = apply_prompt_args(template, 'Do something');
-            expect(result).toBe('\n# Task\n**Input:** Do something\n');
-        });
-    });
-    describe('{{#if args}} ... {{else}} ... {{/if}} block', () => {
-        it('should render the if-block when args is provided', () => {
-            const template = '{{#if args}}Task: {{args}}{{else}}No task provided.{{/if}}';
-            const result = apply_prompt_args(template, 'Add login');
-            expect(result).toBe('Task: Add login');
-        });
-        it('should render the else-block when args is empty', () => {
-            const template = '{{#if args}}Task: {{args}}{{else}}No task provided.{{/if}}';
-            const result = apply_prompt_args(template, '');
-            expect(result).toBe('No task provided.');
-        });
-        it('should render the else-block when args is only whitespace', () => {
-            const template = '{{#if args}}Task: {{args}}{{else}}No task provided.{{/if}}';
-            const result = apply_prompt_args(template, '   ');
-            expect(result).toBe('No task provided.');
-        });
-        it('should handle multiline if and else blocks', () => {
-            const template = [
-                '{{#if args}}',
-                '# Running: {{args}}',
-                'Execute the task above.',
-                '{{else}}',
-                '# Usage',
-                'Provide a task to run.',
-                '{{/if}}',
-            ].join('\n');
-            const with_args = apply_prompt_args(template, 'Build the feature');
-            expect(with_args).toContain('# Running: Build the feature');
-            expect(with_args).not.toContain('# Usage');
-            const without_args = apply_prompt_args(template, '');
-            expect(without_args).toContain('# Usage');
-            expect(without_args).not.toContain('# Running:');
-        });
-    });
-    describe('edge cases', () => {
-        it('should return the template unchanged when it has no placeholders', () => {
-            const template = '# Plan\nThis is a static template.';
-            const result = apply_prompt_args(template, 'some args');
-            expect(result).toBe(template);
-        });
-        it('should handle a template with both {{args}} and {{#if args}} blocks', () => {
-            const template = [
-                '{{#if args}}',
-                '**Task:** {{args}}',
-                '{{else}}',
-                '**Task:** (none)',
-                '{{/if}}',
-                '',
-                'Details: {{args}}',
-            ].join('\n');
-            const result = apply_prompt_args(template, 'Refactor auth');
-            expect(result).toContain('**Task:** Refactor auth');
-            expect(result).toContain('Details: Refactor auth');
-            expect(result).not.toContain('(none)');
-        });
-        it('should handle empty template string', () => {
-            const result = apply_prompt_args('', 'some args');
-            expect(result).toBe('');
-        });
-    });
-});

package/build/tools/__tests__/archTools.test.js

@@ -1,42 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { completePlan, validateArchitecture } from '../archTools.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-describe('Arch Tools', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'arch-test-'));
-    });
-    afterEach(async () => {
-        await fs.rm(tempDir, { recursive: true, force: true });
-    });
-    it('should complete a plan successfully', async () => {
-        const planPath = path.join(tempDir, 'plan1.md');
-        await fs.writeFile(planPath, '> Status: Draft\n\n- [x] Done item');
-        const res = await completePlan('plan1.md', false, tempDir);
-        expect(res).toContain('Plan marked as Implemented');
-        const content = await fs.readFile(planPath, 'utf8');
-        expect(content).toContain('> Status: Implemented');
-    });
-    it('should fail to complete a plan if unchecked items exist', async () => {
-        const planPath = path.join(tempDir, 'plan2.md');
-        await fs.writeFile(planPath, '> Status: Draft\n\n- [ ] Pending item');
-        const res = await completePlan('plan2.md', false, tempDir);
-        expect(res).toContain('unchecked acceptance criteria found');
-    });
-    it('should force complete a plan with unchecked items', async () => {
-        const planPath = path.join(tempDir, 'plan3.md');
-        await fs.writeFile(planPath, '> Status: Draft\n\n- [ ] Pending item');
-        const res = await completePlan('plan3.md', true, tempDir);
-        expect(res).toContain('Plan marked as Implemented');
-    });
-    it('should validate architecture counts', async () => {
-        const archDir = path.join(tempDir, 'docs', 'architecture');
-        await fs.mkdir(archDir, { recursive: true });
-        await fs.writeFile(path.join(archDir, 'compound-system.md'), '---\nskills: 1\nworkflows: 0\nscripts: 0\npatterns: 0\n---');
-        const res = await validateArchitecture(tempDir);
-        expect(res).toContain('Architecture Document is stale!');
-        expect(res).toContain('Skills mismatch');
-    });
-});

package/build/tools/__tests__/compoundTools.test.js

@@ -1,60 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { compoundSearch, updateSolutionRef, validateCompound, auditStateDrift } from '../compoundTools.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-describe('Compound Tools', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'compound-test-'));
-    });
-    afterEach(async () => {
-        await fs.rm(tempDir, { recursive: true, force: true });
-    });
-    it('should search for solutions', async () => {
-        const solDir = path.join(tempDir, 'docs', 'solutions');
-        await fs.mkdir(solDir, { recursive: true });
-        await fs.writeFile(path.join(solDir, 'test.md'), '# Test Solution\n\nThis mentions React and Next.js.');
-        await fs.writeFile(path.join(solDir, 'test2.md'), '# Other Solution\n\nThis mentions Vue.');
-        const res = await compoundSearch(['React'], tempDir);
-        expect(res).toContain('test.md');
-        expect(res).toContain('Test Solution');
-        expect(res).not.toContain('test2.md');
-    });
-    it('should update solution ref', async () => {
-        const solDir = path.join(tempDir, 'docs', 'solutions');
-        await fs.mkdir(solDir, { recursive: true });
-        const filePath = path.join(solDir, 'test.md');
-        await fs.writeFile(filePath, '---\ntags: [test]\n---\n# Test Solution');
-        const res = await updateSolutionRef([path.relative(tempDir, filePath)], tempDir);
-        expect(res).toContain('Updated 1 files');
-        const content = await fs.readFile(filePath, 'utf-8');
-        expect(content).toContain('last_referenced:');
-    });
-    it('should validate compound health', async () => {
-        const planPath = path.join(tempDir, 'implementation_plan.md');
-        await fs.writeFile(planPath, '- [ ] todo 1\n- [ ] todo 2\n');
-        const res = await validateCompound(tempDir);
-        expect(res).toContain('⚠️  Found 2 unchecked items in implementation_plan.md');
-        expect(res).toContain('❌ Validation failed.');
-    });
-    it('should audit state drift and report drift', async () => {
-        const todosDir = path.join(tempDir, 'todos');
-        await fs.mkdir(todosDir, { recursive: true });
-        const todoPath = path.join(todosDir, '001-pending-p1-test.md');
-        await fs.writeFile(todoPath, 'status: pending\n\n- [x] tick 1\n- [x] tick 2');
-        const res = await auditStateDrift(tempDir, false);
-        expect(res).toContain('DRIFT: 001-pending-p1-test.md');
-        expect(res).toContain('Checked: 2/2');
-    });
-    it('should audit state drift and fix drift', async () => {
-        const todosDir = path.join(tempDir, 'todos');
-        await fs.mkdir(todosDir, { recursive: true });
-        const todoPath = path.join(todosDir, '001-pending-p1-test.md');
-        await fs.writeFile(todoPath, 'status: pending\n\n- [x] tick 1\n- [x] tick 2');
-        const res = await auditStateDrift(tempDir, true);
-        expect(res).toContain('FIXED: 001-pending-p1-test.md');
-        const content = await fs.readFile(todoPath, 'utf8');
-        expect(content).toContain('status: done');
-    });
-});

package/build/tools/__tests__/docsTools.test.js

@@ -1,44 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { bootstrapFolderDocs, checkDocsFreshness, discoverUndocumentedFolders, validateFolderDocs } from '../docsTools.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-describe('Docs Tools', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'docs-test-'));
-    });
-    afterEach(async () => {
-        await fs.rm(tempDir, { recursive: true, force: true });
-    });
-    it('should bootstrap folder docs', async () => {
-        const targetDir = path.join(tempDir, 'src');
-        await fs.mkdir(targetDir, { recursive: true });
-        await fs.writeFile(path.join(targetDir, 'utils.ts'), 'content');
-        const result = await bootstrapFolderDocs('src', tempDir);
-        expect(result).toContain('Bootstrapped');
-        const readme = await fs.readFile(path.join(targetDir, 'README.md'), 'utf8');
-        expect(readme).toContain('# src');
-        expect(readme).toContain('`utils.ts`');
-    });
-    it('should discover undocumented folders', async () => {
-        const srcDir = path.join(tempDir, 'src');
-        await fs.mkdir(srcDir, { recursive: true });
-        await fs.writeFile(path.join(srcDir, 'logic.ts'), 'content');
-        // no readme -> should be discovered
-        const result = await discoverUndocumentedFolders(tempDir);
-        expect(result).toContain('src');
-    });
-    it('should validate folder docs', async () => {
-        const targetDir = path.join(tempDir, 'src');
-        await fs.mkdir(targetDir, { recursive: true });
-        await fs.writeFile(path.join(targetDir, 'README.md'), '# src\n');
-        const result = await validateFolderDocs(false, ['src'], tempDir);
-        expect(result).toContain('missing sections: Purpose, Components, Component Details, Changelog');
-    });
-    it('should check docs freshness without failing', async () => {
-        // Just tests the skip-docs flag since git repo isn't present
-        const result = await checkDocsFreshness(true, tempDir);
-        expect(result).toContain('Skipping documentation freshness check');
-    });
-});

package/build/tools/__tests__/gitTools.test.js

@@ -1,45 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { validateChangelog, archiveCompleted, prePushHousekeeping } from '../gitTools.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-describe('Git Tools', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'git-test-'));
-    });
-    afterEach(async () => {
-        await fs.rm(tempDir, { recursive: true, force: true });
-    });
-    it('should validate changelog', async () => {
-        const changelogPath = path.join(tempDir, 'CHANGELOG.md');
-        await fs.writeFile(changelogPath, '## [Unreleased]\n## [Unreleased]\n<<<<<<< HEAD');
-        const result = await validateChangelog(tempDir);
-        expect(result).toContain('Multiple [Unreleased] sections found');
-        expect(result).toContain('Merge conflict markers found');
-    });
-    it('should archive completed items in dry-run mode', async () => {
-        await fs.mkdir(path.join(tempDir, 'todos'), { recursive: true });
-        const todoPath = path.join(tempDir, 'todos', '001-done-test.md');
-        await fs.writeFile(todoPath, 'content');
-        const res = await archiveCompleted(tempDir, false);
-        expect(res).toContain('DRY-RUN');
-        expect(res).toContain('[ARCHIVED] 001-done-test.md');
-        // Still exists
-        await fs.access(todoPath);
-    });
-    it('should archive completed items and move them', async () => {
-        await fs.mkdir(path.join(tempDir, 'todos'), { recursive: true });
-        const todoPath = path.join(tempDir, 'todos', '001-done-test.md');
-        await fs.writeFile(todoPath, 'content');
-        const res = await archiveCompleted(tempDir, true);
-        expect(res).toContain('APPLYING CHANGES');
-        const archivedPath = path.join(tempDir, 'todos', 'archive', '001-done-test.md');
-        await fs.access(archivedPath); // Should not throw
-    });
-    it('should run pre-push housekeeping', async () => {
-        const res = await prePushHousekeeping(tempDir, false);
-        expect(res).toContain('Pre-Push Housekeeping Check');
-        expect(res).toContain('All checks passed');
-    });
-});

package/build/tools/__tests__/loggerTools.test.js

@@ -1,74 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { logSkill, logWorkflow, rotateLogs } from '../loggerTools.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-describe('Logger Tools', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'logger-test-'));
-    });
-    afterEach(async () => {
-        await fs.rm(tempDir, { recursive: true, force: true });
-        vi.restoreAllMocks();
-    });
-    it('should log skill usage', async () => {
-        vi.useFakeTimers();
-        vi.setSystemTime(new Date('2026-03-04T00:00:00Z'));
-        const result = await logSkill('test-skill', 'manual', 'context', tempDir);
-        expect(result).toBe('Successfully logged skill usage for test-skill');
-        const logFile = path.join(tempDir, 'docs', 'agents', 'logs', 'skill_usage.log');
-        const content = await fs.readFile(logFile, 'utf-8');
-        expect(content).toContain('2026-03-04T00:00:00Z|test-skill|manual|context\n');
-        vi.useRealTimers();
-    });
-    it('should log workflow usage', async () => {
-        vi.useFakeTimers();
-        vi.setSystemTime(new Date('2026-03-04T00:00:00Z'));
-        const result = await logWorkflow('test-workflow', 'session-123', tempDir);
-        expect(result).toBe('Successfully logged workflow usage for test-workflow');
-        const logFile = path.join(tempDir, 'docs', 'agents', 'logs', 'workflow_usage.log');
-        const content = await fs.readFile(logFile, 'utf-8');
-        expect(content).toContain('2026-03-04T00:00:00Z|test-workflow|session-123\n');
-        vi.useRealTimers();
-    });
-    it('should generate a default session id if not provided', async () => {
-        vi.useFakeTimers();
-        vi.setSystemTime(new Date('2026-03-04T00:00:00Z')); // 1772582400 in seconds
-        await logWorkflow('test-workflow', '', tempDir);
-        const logFile = path.join(tempDir, 'docs', 'agents', 'logs', 'workflow_usage.log');
-        const content = await fs.readFile(logFile, 'utf-8');
-        expect(content).toContain('2026-03-04T00:00:00Z|test-workflow|1772582400\n');
-        vi.useRealTimers();
-    });
-    it('should rotate logs older than retention days', async () => {
-        const logDir = path.join(tempDir, 'docs', 'agents', 'logs');
-        await fs.mkdir(logDir, { recursive: true });
-        // Old log line (e.g. 100 days old)
-        const oldTimestamp = new Date();
-        oldTimestamp.setDate(oldTimestamp.getDate() - 100);
-        const oldStr = oldTimestamp.toISOString().replace(/\.[0-9]{3}Z$/, 'Z');
-        // New log line (10 days old)
-        const newTimestamp = new Date();
-        newTimestamp.setDate(newTimestamp.getDate() - 10);
-        const newStr = newTimestamp.toISOString().replace(/\.[0-9]{3}Z$/, 'Z');
-        const logContent = `${oldStr}|test|manual|context1\n${newStr}|test|manual|context2\n`;
-        await fs.writeFile(path.join(logDir, 'skill_usage.log'), logContent);
-        const output = await rotateLogs(tempDir, 90);
-        expect(output).toContain('Pruned 1 lines');
-        const finalContent = await fs.readFile(path.join(logDir, 'skill_usage.log'), 'utf-8');
-        expect(finalContent).not.toContain('context1');
-        expect(finalContent).toContain('context2');
-    });
-    it('should report if no logs need rotation', async () => {
-        const logDir = path.join(tempDir, 'docs', 'agents', 'logs');
-        await fs.mkdir(logDir, { recursive: true });
-        const newTimestamp = new Date();
-        newTimestamp.setDate(newTimestamp.getDate() - 10);
-        const newStr = newTimestamp.toISOString().replace(/\.[0-9]{3}Z$/, 'Z');
-        const logContent = `${newStr}|test|manual|context2\n`;
-        await fs.writeFile(path.join(logDir, 'skill_usage.log'), logContent);
-        const output = await rotateLogs(tempDir, 90);
-        expect(output).toContain('(No logs needed rotation)');
-    });
-});

package/build/tools/__tests__/todoTools.test.js

@@ -1,73 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { createTodo, startTodo, doneTodo, getNextTodoId } from '../todoTools.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-describe('Todo Tools', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'todo-test-'));
-    });
-    afterEach(async () => {
-        await fs.rm(tempDir, { recursive: true, force: true });
-    });
-    it('should calculate next todo ID correctly', async () => {
-        const id1 = await getNextTodoId(tempDir);
-        expect(id1).toBe('001');
-        await fs.mkdir(path.join(tempDir, 'todos'), { recursive: true });
-        await fs.writeFile(path.join(tempDir, 'todos', '005-pending-p2-test.md'), 'test');
-        const id2 = await getNextTodoId(tempDir);
-        expect(id2).toBe('006');
-    });
-    it('should create a new todo file', async () => {
-        const result = await createTodo('p2', 'Fix Bug', 'The bug is terrible', ['Check 1', 'Check 2'], tempDir);
-        expect(result).toContain('001-pending-p2-fix-bug');
-        const files = await fs.readdir(path.join(tempDir, 'todos'));
-        expect(files).toContain('001-pending-p2-fix-bug.md');
-        const content = await fs.readFile(path.join(tempDir, 'todos', '001-pending-p2-fix-bug.md'), 'utf-8');
-        expect(content).toContain('status: pending');
-        expect(content).toContain('priority: p2');
-        expect(content).toContain('- [ ] Check 1');
-    });
-    it('should start a todo file', async () => {
-        await createTodo('p2', 'Fix Bug', 'The bug is terrible', ['Check 1'], tempDir);
-        const todoFile = path.join('todos', '001-pending-p2-fix-bug.md');
-        const result = await startTodo(todoFile, false, tempDir);
-        expect(result).toContain('001-in-progress-p2-fix-bug.md');
-        const newPath = path.join(tempDir, 'todos', '001-in-progress-p2-fix-bug.md');
-        const content = await fs.readFile(newPath, 'utf-8');
-        expect(content).toContain('status: in-progress');
-    });
-    it('should fail to done a todo if unchecked items exist', async () => {
-        await createTodo('p2', 'Fix Bug', 'The bug is terrible', ['Check 1'], tempDir);
-        // It's still pending so its name has pending
-        const todoFile = path.join('todos', '001-pending-p2-fix-bug.md');
-        await expect(doneTodo(todoFile, false, tempDir)).rejects.toThrow(/Unchecked items found/);
-    });
-    it('should done a todo if force is true with unchecked items', async () => {
-        await createTodo('p2', 'Fix Bug', 'The bug is terrible', ['Check 1'], tempDir);
-        const todoFile = path.join('todos', '001-pending-p2-fix-bug.md');
-        const result = await doneTodo(todoFile, true, tempDir);
-        expect(result).toContain('001-done-p2-fix-bug.md');
-    });
-    it('should done a todo if all items are checked', async () => {
-        await createTodo('p2', 'Fix Bug', '', ['Check 1'], tempDir);
-        const todoFile = path.normalize(path.join(tempDir, 'todos', '001-pending-p2-fix-bug.md'));
-        let content = await fs.readFile(todoFile, 'utf-8');
-        content = content.replace('- [ ] Check 1', '- [x] Check 1');
-        await fs.writeFile(todoFile, content);
-        const result = await doneTodo(path.join('todos', '001-pending-p2-fix-bug.md'), false, tempDir);
-        expect(result).toContain('001-done-p2-fix-bug.md');
-        const newPath = path.join(tempDir, 'todos', '001-done-p2-fix-bug.md');
-        const newContent = await fs.readFile(newPath, 'utf-8');
-        expect(newContent).toContain('status: done');
-    });
-    it('should reject startTodo if in terminal state without force', async () => {
-        await createTodo('p2', 'Fix Bug', '', [], tempDir);
-        const todoFile = path.normalize(path.join(tempDir, 'todos', '001-pending-p2-fix-bug.md'));
-        let content = await fs.readFile(todoFile, 'utf-8');
-        content = content.replace('status: pending', 'status: done');
-        await fs.writeFile(todoFile, content);
-        await expect(startTodo(path.join('todos', '001-pending-p2-fix-bug.md'), false, tempDir)).rejects.toThrow(/terminal state/);
-    });
-});

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

@@ -1,77 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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);
-        });
-    });
-});