superkit-mcp-server 1.1.1 → 1.1.3

package/README.md

@@ -32,6 +32,10 @@ npx -y superkit-mcp-server
 - **`load_superkit_workflow`**: Loads the instructions for a specific slash-command workflow (e.g., `work`, `explore`).
 - **`call_tool_checklist`**: Executes the native TypeScript validation suite (security, web accessibility, react performance, testing, API structure) on a target project location via the MCP environment instead of generic bash loops.
 
+## Available Prompts
+
+The Super-Kit MCP server exposes all workflows inside the `workflows/` directory dynamically as **MCP Prompts**. AI agents can invoke `GetPromptRequestSchema` to instantly load complex workflows (e.g., `plan-compound`, `review-compound`) along with their security and validation tooling straight into their context.
+
 ## Manual Installation and Configuration
 
 If you cloned this repository locally, you can build and use the MCP server directly:

package/build/index.js

@@ -9,6 +9,12 @@ import { manageAutoPreview } from "./tools/autoPreview.js";
 import { manageSession } from "./tools/sessionManager.js";
 import { runChecklist } from "./tools/checklist.js";
 import { runVerifyAll } from "./tools/verifyAll.js";
+import { logSkill, logWorkflow, rotateLogs } from "./tools/loggerTools.js";
+import { getNextTodoId, createTodo, startTodo, doneTodo, completeTodo } from "./tools/todoTools.js";
+import { compoundSearch, updateSolutionRef, validateCompound, auditStateDrift, suggestSkills, compoundHealth, compoundDashboard, compoundMetrics } from "./tools/compoundTools.js";
+import { bootstrapFolderDocs, checkDocsFreshness, discoverUndocumentedFolders, validateFolderDocs } from "./tools/docsTools.js";
+import { generateChangelog, validateChangelog, archiveCompleted, prePushHousekeeping } from "./tools/gitTools.js";
+import { validateSpecConsistency, completePlan, validateArchitecture, syncSpec, updateSpecPhase } from "./tools/archTools.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const superKitRoot = path.resolve(__dirname, "../");
@@ -93,6 +99,100 @@ const TOOLS = [
             required: ["projectPath", "url"]
         }
     },
+    {
+        name: "call_tool_logger_manager",
+        description: "Manages tool logging operations (skills, workflows, log rotation)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: { type: "string", enum: ["logSkill", "logWorkflow", "rotateLogs"] },
+                name: { type: "string" },
+                outcome: { type: "string" },
+                projectPath: { type: "string", default: "." }
+            },
+            required: ["action", "projectPath"]
+        }
+    },
+    {
+        name: "call_tool_todo_manager",
+        description: "Manages todos (nextId, create, start, done, complete)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: { type: "string", enum: ["nextId", "create", "start", "done", "complete"] },
+                title: { type: "string" },
+                description: { type: "string" },
+                priority: { type: "number" },
+                todoId: { type: "string" },
+                force: { type: "boolean", default: false },
+                projectPath: { type: "string", default: "." }
+            },
+            required: ["action", "projectPath"]
+        }
+    },
+    {
+        name: "call_tool_compound_manager",
+        description: "Manages compound knowledge capabilities (search, updateRef, validate, auditDrift, suggestSkills, health, dashboard, metrics)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: { type: "string", enum: ["search", "updateRef", "validate", "auditDrift", "suggestSkills", "health", "dashboard", "metrics"] },
+                terms: { type: "array", items: { type: "string" } },
+                files: { type: "array", items: { type: "string" } },
+                fix: { type: "boolean", default: false },
+                force: { type: "boolean", default: false },
+                projectPath: { type: "string", default: "." }
+            },
+            required: ["action", "projectPath"]
+        }
+    },
+    {
+        name: "call_tool_docs_manager",
+        description: "Manages documentation (bootstrap, freshness, discover, validate)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: { type: "string", enum: ["bootstrap", "freshness", "discover", "validate"] },
+                folder: { type: "string" },
+                skipDocs: { type: "boolean", default: false },
+                strict: { type: "boolean", default: false },
+                targetFolders: { type: "array", items: { type: "string" } },
+                projectPath: { type: "string", default: "." }
+            },
+            required: ["action", "projectPath"]
+        }
+    },
+    {
+        name: "call_tool_git_manager",
+        description: "Manages git and housekeeping tasks (changelog, validateChangelog, archive, housekeeping)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: { type: "string", enum: ["changelog", "validateChangelog", "archive", "housekeeping"] },
+                applyFix: { type: "boolean", default: false },
+                projectPath: { type: "string", default: "." }
+            },
+            required: ["action", "projectPath"]
+        }
+    },
+    {
+        name: "call_tool_arch_manager",
+        description: "Manages architecture and specs tasks (validateSpecs, completePlan, validateArch, syncSpec, updatePhase)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: { type: "string", enum: ["validateSpecs", "completePlan", "validateArch", "syncSpec", "updatePhase"] },
+                planFile: { type: "string" },
+                force: { type: "boolean", default: false },
+                specDir: { type: "string" },
+                specName: { type: "string" },
+                phaseNum: { type: "string" },
+                status: { type: "string" },
+                projectPath: { type: "string", default: "." }
+            },
+            required: ["action", "projectPath"]
+        }
+    },
     {
         name: "list_superkit_assets",
         description: "Lists all available agents, skills, and workflows in the Super-Kit repository.",
@@ -225,6 +325,94 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const res = await runVerifyAll(args.projectPath, args.url, args.skipE2E, args.stopOnFail);
             return { content: [{ type: "text", text: res }] };
         }
+        if (request.params.name === "call_tool_logger_manager") {
+            const args = request.params.arguments;
+            let res = "";
+            if (args.action === "logSkill")
+                res = await logSkill(args.name, args.outcome, args.projectPath);
+            else if (args.action === "logWorkflow")
+                res = await logWorkflow(args.name, args.outcome, args.projectPath);
+            else if (args.action === "rotateLogs")
+                res = await rotateLogs(args.projectPath);
+            return { content: [{ type: "text", text: res }] };
+        }
+        if (request.params.name === "call_tool_todo_manager") {
+            const args = request.params.arguments;
+            let res = "";
+            if (args.action === "nextId")
+                res = String(await getNextTodoId(args.projectPath));
+            else if (args.action === "create")
+                res = await createTodo(args.title, args.description, args.priority, args.projectPath);
+            else if (args.action === "start")
+                res = await startTodo(args.todoId, args.force, args.projectPath);
+            else if (args.action === "done")
+                res = await doneTodo(args.todoId, args.force, args.projectPath);
+            else if (args.action === "complete")
+                res = await completeTodo(args.todoId, args.force, args.projectPath);
+            return { content: [{ type: "text", text: res }] };
+        }
+        if (request.params.name === "call_tool_compound_manager") {
+            const args = request.params.arguments;
+            let res = "";
+            if (args.action === "search")
+                res = await compoundSearch(args.terms || [], args.projectPath);
+            else if (args.action === "updateRef")
+                res = await updateSolutionRef(args.files || [], args.projectPath);
+            else if (args.action === "validate")
+                res = await validateCompound(args.projectPath);
+            else if (args.action === "auditDrift")
+                res = await auditStateDrift(args.projectPath, args.fix);
+            else if (args.action === "suggestSkills")
+                res = await suggestSkills(args.projectPath);
+            else if (args.action === "health")
+                res = await compoundHealth(args.projectPath);
+            else if (args.action === "dashboard")
+                res = await compoundDashboard(args.projectPath);
+            else if (args.action === "metrics")
+                res = await compoundMetrics(args.projectPath, args.force);
+            return { content: [{ type: "text", text: res }] };
+        }
+        if (request.params.name === "call_tool_docs_manager") {
+            const args = request.params.arguments;
+            let res = "";
+            if (args.action === "bootstrap")
+                res = await bootstrapFolderDocs(args.folder, args.projectPath);
+            else if (args.action === "freshness")
+                res = await checkDocsFreshness(args.skipDocs, args.projectPath);
+            else if (args.action === "discover")
+                res = await discoverUndocumentedFolders(args.projectPath);
+            else if (args.action === "validate")
+                res = await validateFolderDocs(args.strict, args.targetFolders || [], args.projectPath);
+            return { content: [{ type: "text", text: res }] };
+        }
+        if (request.params.name === "call_tool_git_manager") {
+            const args = request.params.arguments;
+            let res = "";
+            if (args.action === "changelog")
+                res = await generateChangelog(args.projectPath);
+            else if (args.action === "validateChangelog")
+                res = await validateChangelog(args.projectPath);
+            else if (args.action === "archive")
+                res = await archiveCompleted(args.projectPath, args.applyFix);
+            else if (args.action === "housekeeping")
+                res = await prePushHousekeeping(args.projectPath, args.applyFix);
+            return { content: [{ type: "text", text: res }] };
+        }
+        if (request.params.name === "call_tool_arch_manager") {
+            const args = request.params.arguments;
+            let res = "";
+            if (args.action === "validateSpecs")
+                res = await validateSpecConsistency(args.projectPath);
+            else if (args.action === "completePlan")
+                res = await completePlan(args.planFile, args.force, args.projectPath);
+            else if (args.action === "validateArch")
+                res = await validateArchitecture(args.projectPath);
+            else if (args.action === "syncSpec")
+                res = await syncSpec(args.specDir, args.projectPath);
+            else if (args.action === "updatePhase")
+                res = await updateSpecPhase(args.specName, String(args.phaseNum), args.status, args.projectPath);
+            return { content: [{ type: "text", text: res }] };
+        }
         if (request.params.name === "list_superkit_assets") {
             const agentsPath = path.join(superKitRoot, "agents");
             const skillsTechPath = path.join(superKitRoot, "skills", "tech");

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

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

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

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

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

@@ -0,0 +1,74 @@
+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, '.agent', '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, '.agent', '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, '.agent', '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, '.agent', '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, '.agent', '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

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