@projitive/mcp 2.0.3 → 2.1.0

package/output/source/tools/roadmap.test.js

@@ -1,75 +1,270 @@
-import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
-import fs from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-import { isValidRoadmapId, collectRoadmapLintSuggestions, loadRoadmapDocument, renderRoadmapMarkdown, registerRoadmapTools } from "./roadmap.js";
-describe("roadmap module", () => {
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { replaceRoadmapsInStore } from '../common/store.js';
+import { isValidRoadmapId, collectRoadmapLintSuggestions, loadRoadmapDocument, renderRoadmapMarkdown, registerRoadmapTools } from './roadmap.js';
+async function createGovernanceWorkspace() {
+    const projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'projitive-mcp-roadmap-workspace-'));
+    const governanceDir = path.join(projectRoot, '.projitive');
+    const dbPath = path.join(governanceDir, '.projitive');
+    await fs.mkdir(governanceDir, { recursive: true });
+    await fs.writeFile(dbPath, '', 'utf-8');
+    return { projectRoot, governanceDir, dbPath };
+}
+function getRoadmapToolHandler(mockServer, toolName) {
+    const call = mockServer.registerTool.mock.calls.find((entry) => entry[0] === toolName);
+    expect(call).toBeTruthy();
+    return call?.[2];
+}
+describe('roadmap module', () => {
     let tempDir;
     beforeAll(async () => {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "projitive-roadmap-test-"));
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'projitive-roadmap-test-'));
     });
     afterAll(async () => {
         await fs.rm(tempDir, { recursive: true, force: true });
     });
-    describe("isValidRoadmapId", () => {
-        it("should validate correct roadmap IDs", () => {
-            expect(isValidRoadmapId("ROADMAP-0001")).toBe(true);
-            expect(isValidRoadmapId("ROADMAP-1234")).toBe(true);
+    describe('isValidRoadmapId', () => {
+        it('should validate correct roadmap IDs', () => {
+            expect(isValidRoadmapId('ROADMAP-0001')).toBe(true);
+            expect(isValidRoadmapId('ROADMAP-1')).toBe(true);
+            expect(isValidRoadmapId('ROADMAP-1234')).toBe(true);
+            expect(isValidRoadmapId('ROADMAP-12345')).toBe(true);
         });
-        it("should reject invalid roadmap IDs", () => {
-            expect(isValidRoadmapId("roadmap-0001")).toBe(false);
-            expect(isValidRoadmapId("TASK-0001")).toBe(false);
-            expect(isValidRoadmapId("invalid")).toBe(false);
+        it('should reject invalid roadmap IDs', () => {
+            expect(isValidRoadmapId('roadmap-0001')).toBe(false);
+            expect(isValidRoadmapId('TASK-0001')).toBe(false);
+            expect(isValidRoadmapId('invalid')).toBe(false);
         });
     });
-    describe("collectRoadmapLintSuggestions", () => {
-        it("should return lint suggestion for empty roadmap IDs", () => {
+    describe('collectRoadmapLintSuggestions', () => {
+        it('should return lint suggestion for empty roadmap IDs', () => {
             const suggestions = collectRoadmapLintSuggestions([], []);
-            expect(suggestions.some(s => s.includes("IDS_EMPTY"))).toBe(true);
+            expect(suggestions.some(s => s.includes('IDS_EMPTY'))).toBe(true);
         });
-        it("should return lint suggestion for empty tasks", () => {
-            const suggestions = collectRoadmapLintSuggestions(["ROADMAP-0001"], []);
-            expect(suggestions.some(s => s.includes("TASKS_EMPTY"))).toBe(true);
+        it('should return lint suggestion for empty tasks', () => {
+            const suggestions = collectRoadmapLintSuggestions(['ROADMAP-0001'], []);
+            expect(suggestions.some(s => s.includes('TASKS_EMPTY'))).toBe(true);
         });
-        it("should return lint suggestion for tasks without roadmap refs", () => {
+        it('should return lint suggestion for tasks without roadmap refs', () => {
             const tasks = [{
-                    id: "TASK-0001",
-                    title: "Test Task",
-                    status: "TODO",
-                    owner: "ai-copilot",
-                    summary: "Test",
-                    updatedAt: "2026-01-01T00:00:00.000Z",
+                    id: 'TASK-0001',
+                    title: 'Test Task',
+                    status: 'TODO',
+                    owner: 'ai-copilot',
+                    summary: 'Test',
+                    updatedAt: '2026-01-01T00:00:00.000Z',
                     links: [],
                     roadmapRefs: [],
                 }];
-            const suggestions = collectRoadmapLintSuggestions(["ROADMAP-0001"], tasks);
-            expect(suggestions.some(s => s.includes("TASK_REFS_EMPTY"))).toBe(true);
+            const suggestions = collectRoadmapLintSuggestions(['ROADMAP-0001'], tasks);
+            expect(suggestions.some(s => s.includes('TASK_REFS_EMPTY'))).toBe(true);
         });
-        it("loads from governance store and rewrites roadmap markdown view", async () => {
-            const governanceDir = path.join(tempDir, ".projitive-db");
+        it('collects lint suggestion for tasks with unknown roadmap refs', () => {
+            const tasks = [{
+                    id: 'TASK-0001',
+                    title: 'Orphaned Task',
+                    status: 'TODO',
+                    owner: 'ai-copilot',
+                    summary: '',
+                    updatedAt: '2026-01-01T00:00:00.000Z',
+                    links: [],
+                    roadmapRefs: ['ROADMAP-9999'],
+                }];
+            const suggestions = collectRoadmapLintSuggestions(['ROADMAP-0001'], tasks);
+            expect(suggestions.some(s => s.includes('UNKNOWN_REFS'))).toBe(true);
+        });
+        it('loads from governance store and rewrites roadmap markdown view', async () => {
+            const governanceDir = path.join(tempDir, '.projitive-db');
             await fs.mkdir(governanceDir, { recursive: true });
-            await fs.writeFile(path.join(governanceDir, ".projitive"), "", "utf-8");
+            await fs.writeFile(path.join(governanceDir, '.projitive'), '', 'utf-8');
             const doc = await loadRoadmapDocument(governanceDir);
-            expect(doc.roadmapPath.endsWith(".projitive")).toBe(true);
-            expect(doc.markdownPath.endsWith("roadmap.md")).toBe(true);
-            const markdown = await fs.readFile(path.join(governanceDir, "roadmap.md"), "utf-8");
-            expect(markdown).toContain("generated from .projitive governance store");
+            expect(doc.roadmapPath.endsWith('.projitive')).toBe(true);
+            expect(doc.markdownPath.endsWith('roadmap.md')).toBe(true);
+            const markdown = await fs.readFile(path.join(governanceDir, 'roadmap.md'), 'utf-8');
+            expect(markdown).toContain('generated from .projitive governance store');
+            expect(markdown).toContain('Author: yinxulai');
+            expect(markdown).toContain('Repository: https://github.com/yinxulai/projitive');
+            expect(markdown).toContain('Do not edit this file manually.');
         });
-        it("renders milestones in newest-first order", () => {
+        it('renders milestones in newest-first order', () => {
             const markdown = renderRoadmapMarkdown([
-                { id: "ROADMAP-0001", title: "Older", status: "active", updatedAt: "2026-01-01T00:00:00.000Z" },
-                { id: "ROADMAP-0002", title: "Newer", status: "done", updatedAt: "2026-02-01T00:00:00.000Z" },
+                { id: 'ROADMAP-0001', title: 'Older', status: 'active', updatedAt: '2026-01-01T00:00:00.000Z' },
+                { id: 'ROADMAP-0002', title: 'Newer', status: 'done', updatedAt: '2026-02-01T00:00:00.000Z' },
             ]);
-            expect(markdown.indexOf("ROADMAP-0002")).toBeLessThan(markdown.indexOf("ROADMAP-0001"));
-            expect(markdown).toContain("[x] ROADMAP-0002");
+            expect(markdown.indexOf('ROADMAP-0002')).toBeLessThan(markdown.indexOf('ROADMAP-0001'));
+            expect(markdown).toContain('[x] ROADMAP-0002');
         });
-        it("registers roadmapCreate tool", () => {
+        it('registers roadmapCreate tool', () => {
             const mockServer = {
-                registerTool: (..._args) => undefined,
+                registerTool: (...args) => {
+                    void args;
+                    return undefined;
+                },
             };
-            const spy = vi.spyOn(mockServer, "registerTool");
+            const spy = vi.spyOn(mockServer, 'registerTool');
+            registerRoadmapTools(mockServer);
+            expect(spy.mock.calls.some((call) => call[0] === 'roadmapCreate')).toBe(true);
+        });
+        it('sorts milestones with same timestamp by ID descending', () => {
+            const markdown = renderRoadmapMarkdown([
+                { id: 'ROADMAP-0001', title: 'First', status: 'active', updatedAt: '2026-01-01T00:00:00.000Z' },
+                { id: 'ROADMAP-0003', title: 'Third', status: 'active', updatedAt: '2026-01-01T00:00:00.000Z' },
+                { id: 'ROADMAP-0002', title: 'Second', status: 'active', updatedAt: '2026-01-01T00:00:00.000Z' },
+            ]);
+            expect(markdown.indexOf('ROADMAP-0003')).toBeLessThan(markdown.indexOf('ROADMAP-0002'));
+            expect(markdown.indexOf('ROADMAP-0002')).toBeLessThan(markdown.indexOf('ROADMAP-0001'));
+        });
+        it('skips view write on second load with no changes', async () => {
+            const { projectRoot, governanceDir } = await createGovernanceWorkspace();
+            await loadRoadmapDocument(governanceDir);
+            const doc = await loadRoadmapDocument(governanceDir);
+            expect(doc.milestones).toHaveLength(0);
+            await fs.rm(projectRoot, { recursive: true, force: true });
+        });
+    });
+    describe('roadmapList tool handler', () => {
+        it('lists roadmap IDs and linked task count', async () => {
+            const { projectRoot, dbPath } = await createGovernanceWorkspace();
+            await replaceRoadmapsInStore(dbPath, [
+                { id: 'ROADMAP-0001', title: 'First', status: 'active', updatedAt: '2026-01-01T00:00:00.000Z' },
+                { id: 'ROADMAP-0002', title: 'Second', status: 'done', updatedAt: '2026-02-01T00:00:00.000Z' },
+            ]);
+            const mockServer = { registerTool: vi.fn() };
+            registerRoadmapTools(mockServer);
+            const roadmapList = getRoadmapToolHandler(mockServer, 'roadmapList');
+            const result = await roadmapList({ projectPath: projectRoot });
+            expect(result.isError).toBeUndefined();
+            expect(result.content[0].text).toContain('roadmapCount: 2');
+            expect(result.content[0].text).toContain('ROADMAP-0001');
+            await fs.rm(projectRoot, { recursive: true, force: true });
+        });
+        it('returns no nextCall when roadmap store is empty', async () => {
+            const { projectRoot } = await createGovernanceWorkspace();
+            const mockServer = { registerTool: vi.fn() };
+            registerRoadmapTools(mockServer);
+            const roadmapList = getRoadmapToolHandler(mockServer, 'roadmapList');
+            const result = await roadmapList({ projectPath: projectRoot });
+            expect(result.isError).toBeUndefined();
+            expect(result.content[0].text).toContain('roadmapCount: 0');
+            await fs.rm(projectRoot, { recursive: true, force: true });
+        });
+    });
+    describe('roadmapContext tool handler', () => {
+        it('returns error for invalid roadmap ID format', async () => {
+            const { projectRoot } = await createGovernanceWorkspace();
+            const mockServer = { registerTool: vi.fn() };
+            registerRoadmapTools(mockServer);
+            const roadmapContext = getRoadmapToolHandler(mockServer, 'roadmapContext');
+            const result = await roadmapContext({ projectPath: projectRoot, roadmapId: 'INVALID-ID' });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain('Invalid roadmap ID format');
+            await fs.rm(projectRoot, { recursive: true, force: true });
+        });
+        it('returns context with related tasks and reference locations', async () => {
+            const { projectRoot, dbPath } = await createGovernanceWorkspace();
+            await replaceRoadmapsInStore(dbPath, [
+                { id: 'ROADMAP-0001', title: 'Bootstrap', status: 'active', updatedAt: '2026-01-01T00:00:00.000Z' },
+            ]);
+            const mockServer = { registerTool: vi.fn() };
+            registerRoadmapTools(mockServer);
+            const roadmapContext = getRoadmapToolHandler(mockServer, 'roadmapContext');
+            const result = await roadmapContext({ projectPath: projectRoot, roadmapId: 'ROADMAP-0001' });
+            expect(result.isError).toBeUndefined();
+            expect(result.content[0].text).toContain('ROADMAP-0001');
+            expect(result.content[0].text).toContain('relatedTasks: 0');
+            expect(result.content[0].text).toContain('roadmapView:');
+            await fs.rm(projectRoot, { recursive: true, force: true });
+        });
+    });
+    describe('roadmapCreate tool handler', () => {
+        it('returns error for invalid roadmap ID format', async () => {
+            const { projectRoot } = await createGovernanceWorkspace();
+            const mockServer = { registerTool: vi.fn() };
+            registerRoadmapTools(mockServer);
+            const roadmapCreate = getRoadmapToolHandler(mockServer, 'roadmapCreate');
+            const result = await roadmapCreate({ projectPath: projectRoot, roadmapId: 'BAD-FORMAT', title: 'Test' });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain('Invalid roadmap ID format');
+            await fs.rm(projectRoot, { recursive: true, force: true });
+        });
+        it('returns error when roadmap ID already exists', async () => {
+            const { projectRoot, dbPath } = await createGovernanceWorkspace();
+            await replaceRoadmapsInStore(dbPath, [
+                { id: 'ROADMAP-0001', title: 'Existing', status: 'active', updatedAt: '2026-01-01T00:00:00.000Z' },
+            ]);
+            const mockServer = { registerTool: vi.fn() };
+            registerRoadmapTools(mockServer);
+            const roadmapCreate = getRoadmapToolHandler(mockServer, 'roadmapCreate');
+            const result = await roadmapCreate({ projectPath: projectRoot, roadmapId: 'ROADMAP-0001', title: 'Duplicate' });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain('already exists');
+            await fs.rm(projectRoot, { recursive: true, force: true });
+        });
+        it('auto-generates next roadmap ID', async () => {
+            const { projectRoot, dbPath } = await createGovernanceWorkspace();
+            await replaceRoadmapsInStore(dbPath, [
+                { id: 'ROADMAP-0005', title: 'Existing', status: 'active', updatedAt: '2026-01-01T00:00:00.000Z' },
+            ]);
+            const mockServer = { registerTool: vi.fn() };
+            registerRoadmapTools(mockServer);
+            const roadmapCreate = getRoadmapToolHandler(mockServer, 'roadmapCreate');
+            const result = await roadmapCreate({ projectPath: projectRoot, title: 'New Milestone' });
+            expect(result.isError).toBeUndefined();
+            expect(result.content[0].text).toContain('ROADMAP-0006');
+            await fs.rm(projectRoot, { recursive: true, force: true });
+        });
+        it('creates milestone with explicit ID, status done, and time', async () => {
+            const { projectRoot } = await createGovernanceWorkspace();
+            const mockServer = { registerTool: vi.fn() };
+            registerRoadmapTools(mockServer);
+            const roadmapCreate = getRoadmapToolHandler(mockServer, 'roadmapCreate');
+            const result = await roadmapCreate({ projectPath: projectRoot, roadmapId: 'ROADMAP-0001', title: 'Planned', status: 'done', time: '2026-Q2' });
+            expect(result.isError).toBeUndefined();
+            expect(result.content[0].text).toContain('ROADMAP-0001');
+            expect(result.content[0].text).toContain('done');
+            await fs.rm(projectRoot, { recursive: true, force: true });
+        });
+    });
+    describe('roadmapUpdate tool handler', () => {
+        it('returns error for invalid roadmap ID format', async () => {
+            const { projectRoot } = await createGovernanceWorkspace();
+            const mockServer = { registerTool: vi.fn() };
+            registerRoadmapTools(mockServer);
+            const roadmapUpdate = getRoadmapToolHandler(mockServer, 'roadmapUpdate');
+            const result = await roadmapUpdate({ projectPath: projectRoot, roadmapId: 'NOT-VALID', updates: { title: 'New' } });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain('Invalid roadmap ID format');
+            await fs.rm(projectRoot, { recursive: true, force: true });
+        });
+        it('returns error when roadmap milestone not found', async () => {
+            const { projectRoot } = await createGovernanceWorkspace();
+            const mockServer = { registerTool: vi.fn() };
+            registerRoadmapTools(mockServer);
+            const roadmapUpdate = getRoadmapToolHandler(mockServer, 'roadmapUpdate');
+            const result = await roadmapUpdate({ projectPath: projectRoot, roadmapId: 'ROADMAP-0099', updates: { title: 'Does not exist' } });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain('not found');
+            await fs.rm(projectRoot, { recursive: true, force: true });
+        });
+        it('updates milestone title, status, and time', async () => {
+            const { projectRoot, dbPath } = await createGovernanceWorkspace();
+            await replaceRoadmapsInStore(dbPath, [
+                { id: 'ROADMAP-0001', title: 'Original', status: 'active', updatedAt: '2026-01-01T00:00:00.000Z' },
+            ]);
+            const mockServer = { registerTool: vi.fn() };
             registerRoadmapTools(mockServer);
-            expect(spy.mock.calls.some((call) => call[0] === "roadmapCreate")).toBe(true);
+            const roadmapUpdate = getRoadmapToolHandler(mockServer, 'roadmapUpdate');
+            const result = await roadmapUpdate({
+                projectPath: projectRoot,
+                roadmapId: 'ROADMAP-0001',
+                updates: { title: 'Updated', status: 'done', time: '2026-Q3' },
+            });
+            expect(result.isError).toBeUndefined();
+            expect(result.content[0].text).toContain('ROADMAP-0001');
+            expect(result.content[0].text).toContain('done');
+            await fs.rm(projectRoot, { recursive: true, force: true });
         });
     });
 });