superkit-mcp-server 1.2.5 → 1.2.7

package/build/tools/ProjectAssets.js

@@ -0,0 +1,177 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+// The conventional folder name for project-local Super-Kit assets
+export const PROJECT_ASSETS_DIR = '.agents';
+/**
+ * Resolves the effective project root path.
+ * - If an explicit projectPath is provided, it is resolved to an absolute path.
+ * - Otherwise, falls back to process.cwd().
+ */
+export function resolve_project_path(projectPath) {
+    if (projectPath) {
+        return path.resolve(projectPath);
+    }
+    return process.cwd();
+}
+/**
+ * Returns the absolute path to the .agents/ root for the given project.
+ */
+export function get_project_agents_root(projectPath) {
+    return path.join(resolve_project_path(projectPath), PROJECT_ASSETS_DIR);
+}
+/**
+ * Internal guard: ensures the resolved path stays strictly within the .agents/ root.
+ * Returns the resolved absolute path, or null if a traversal attempt is detected.
+ */
+function safe_project_path(agentsRoot, relative) {
+    // Normalize the root so the startsWith check is reliable on all platforms
+    const normalizedRoot = path.resolve(agentsRoot);
+    const resolved = path.resolve(agentsRoot, relative);
+    // On Windows path.resolve produces lower-cased drive letters consistently,
+    // so this comparison is safe cross-platform.
+    if (!resolved.startsWith(normalizedRoot + path.sep) && resolved !== normalizedRoot) {
+        return null; // traversal detected
+    }
+    return resolved;
+}
+/**
+ * Validates a user-supplied asset name (agentName, skillName, workflowName).
+ * Rejects absolute paths and anything containing path-separator characters.
+ */
+function validate_asset_name(name) {
+    if (!name || typeof name !== 'string') {
+        throw new Error('Asset name must be a non-empty string.');
+    }
+    if (path.isAbsolute(name)) {
+        throw new Error(`Asset name must not be an absolute path: "${name}"`);
+    }
+    // Reject any component that contains a path separator or navigates upward
+    const normalized = path.normalize(name);
+    if (normalized.includes('..') || normalized.startsWith('/') || normalized.startsWith('\\')) {
+        throw new Error(`Asset name contains invalid path components: "${name}"`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Listing helpers
+// ---------------------------------------------------------------------------
+/**
+ * Lists project-scoped agent names (without .md extension) from .agents/agents/.
+ * Returns an empty array if the directory does not exist.
+ */
+export async function list_project_agents(projectPath) {
+    const agentsRoot = get_project_agents_root(projectPath);
+    const agentsDir = path.join(agentsRoot, 'agents');
+    try {
+        const entries = await fs.readdir(agentsDir, { withFileTypes: true });
+        return entries
+            .filter((e) => e.isFile() && e.name.endsWith('.md'))
+            .map((e) => e.name.replace(/\.md$/, ''));
+    }
+    catch {
+        // Directory does not exist — graceful degradation
+        return [];
+    }
+}
+/**
+ * Lists project-scoped skill directory names from .agents/skills/tech/ and .agents/skills/meta/.
+ * Returns empty arrays for each category if the directories do not exist.
+ */
+export async function list_project_skills(projectPath) {
+    const agentsRoot = get_project_agents_root(projectPath);
+    const list_category_skills = async (category) => {
+        const categoryDir = path.join(agentsRoot, 'skills', category);
+        try {
+            const entries = await fs.readdir(categoryDir, { withFileTypes: true });
+            return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+        }
+        catch {
+            return [];
+        }
+    };
+    const [tech, meta] = await Promise.all([
+        list_category_skills('tech'),
+        list_category_skills('meta'),
+    ]);
+    return { tech, meta };
+}
+/**
+ * Lists project-scoped workflow names (without .md extension) from .agents/workflows/.
+ * Returns an empty array if the directory does not exist.
+ */
+export async function list_project_workflows(projectPath) {
+    const agentsRoot = get_project_agents_root(projectPath);
+    const workflowsDir = path.join(agentsRoot, 'workflows');
+    try {
+        const entries = await fs.readdir(workflowsDir, { withFileTypes: true });
+        return entries
+            .filter((e) => e.isFile() && e.name.endsWith('.md'))
+            .map((e) => e.name.replace(/\.md$/, ''));
+    }
+    catch {
+        return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// Loading helpers
+// ---------------------------------------------------------------------------
+/**
+ * Loads a project-scoped agent's markdown content from:
+ *   {projectPath}/.agents/agents/{agentName}.md
+ */
+export async function load_project_agent_file(agentName, projectPath) {
+    validate_asset_name(agentName);
+    const agentsRoot = get_project_agents_root(projectPath);
+    const relative = path.join('agents', `${agentName}.md`);
+    const safePath = safe_project_path(agentsRoot, relative);
+    if (!safePath) {
+        throw new Error(`Path traversal detected for agent name: "${agentName}"`);
+    }
+    try {
+        return await fs.readFile(safePath, 'utf-8');
+    }
+    catch {
+        throw new Error(`Project agent not found: "${agentName}". ` +
+            `Expected file at: ${safePath}`);
+    }
+}
+/**
+ * Loads a project-scoped skill's SKILL.md content from:
+ *   {projectPath}/.agents/skills/{category}/{skillName}/SKILL.md
+ */
+export async function load_project_skill_file(category, skillName, projectPath) {
+    validate_asset_name(category);
+    validate_asset_name(skillName);
+    const agentsRoot = get_project_agents_root(projectPath);
+    const relative = path.join('skills', category, skillName, 'SKILL.md');
+    const safePath = safe_project_path(agentsRoot, relative);
+    if (!safePath) {
+        throw new Error(`Path traversal detected for skill: category="${category}", skillName="${skillName}"`);
+    }
+    try {
+        return await fs.readFile(safePath, 'utf-8');
+    }
+    catch {
+        throw new Error(`Project skill not found: category="${category}", skillName="${skillName}". ` +
+            `Expected SKILL.md at: ${safePath}`);
+    }
+}
+/**
+ * Loads a project-scoped workflow's markdown content from:
+ *   {projectPath}/.agents/workflows/{workflowName}.md
+ */
+export async function load_project_workflow_file(workflowName, projectPath) {
+    validate_asset_name(workflowName);
+    const agentsRoot = get_project_agents_root(projectPath);
+    const relative = path.join('workflows', `${workflowName}.md`);
+    const safePath = safe_project_path(agentsRoot, relative);
+    if (!safePath) {
+        throw new Error(`Path traversal detected for workflow name: "${workflowName}"`);
+    }
+    try {
+        return await fs.readFile(safePath, 'utf-8');
+    }
+    catch {
+        throw new Error(`Project workflow not found: "${workflowName}". ` +
+            `Expected file at: ${safePath}`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superkit-mcp-server",
-  "version": "1.2.5",
+  "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/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.');
-    });
-});