@projitive/mcp 2.0.3 → 2.1.0

package/output/source/resources/readme.test.js

@@ -1,165 +1,165 @@
-import { describe, expect, it } from "vitest";
-import { parseRequiredReading, } from "./readme.js";
-describe("readme module", () => {
-    describe("parseRequiredReading", () => {
-        it("parses local and external required reading items", () => {
+import { describe, expect, it } from 'vitest';
+import { parseRequiredReading, } from './readme.js';
+describe('readme module', () => {
+    describe('parseRequiredReading', () => {
+        it('parses local and external required reading items', () => {
             const markdown = [
-                "# Project README",
-                "",
-                "Some intro content",
-                "",
-                "## Required Reading for Agents",
-                "",
-                "- Local: ./designs/README.md",
-                "- Local: .projitive/tasks.md",
-                "- External: https://example.com/docs",
-                "",
-                "## Other Section",
-                "",
-                "More content here",
-            ].join("\n");
+                '# Project README',
+                '',
+                'Some intro content',
+                '',
+                '## Required Reading for Agents',
+                '',
+                '- Local: ./designs/README.md',
+                '- Local: .projitive/tasks.md',
+                '- External: https://example.com/docs',
+                '',
+                '## Other Section',
+                '',
+                'More content here',
+            ].join('\n');
             const result = parseRequiredReading(markdown);
             expect(result.length).toBe(3);
             expect(result[0]).toEqual({
-                source: "Local",
-                value: "./designs/README.md",
+                source: 'Local',
+                value: './designs/README.md',
             });
             expect(result[1]).toEqual({
-                source: "Local",
-                value: ".projitive/tasks.md",
+                source: 'Local',
+                value: '.projitive/tasks.md',
             });
             expect(result[2]).toEqual({
-                source: "External",
-                value: "https://example.com/docs",
+                source: 'External',
+                value: 'https://example.com/docs',
             });
         });
-        it("parses Chinese section header", () => {
+        it('parses Chinese section header', () => {
             const markdown = [
-                "# 项目 README",
-                "",
-                "## Agent 必读",
-                "",
-                "- Local: ./docs/guide.md",
-                "",
-                "## 其他部分",
-            ].join("\n");
+                '# 项目 README',
+                '',
+                '## Agent 必读',
+                '',
+                '- Local: ./docs/guide.md',
+                '',
+                '## 其他部分',
+            ].join('\n');
             const result = parseRequiredReading(markdown);
             expect(result.length).toBe(1);
-            expect(result[0].source).toBe("Local");
-            expect(result[0].value).toBe("./docs/guide.md");
+            expect(result[0].source).toBe('Local');
+            expect(result[0].value).toBe('./docs/guide.md');
         });
-        it("returns empty array when no required reading section", () => {
+        it('returns empty array when no required reading section', () => {
             const markdown = [
-                "# Simple README",
-                "",
-                "No required reading here",
-                "",
-                "## Other Section",
-            ].join("\n");
+                '# Simple README',
+                '',
+                'No required reading here',
+                '',
+                '## Other Section',
+            ].join('\n');
             const result = parseRequiredReading(markdown);
             expect(result).toEqual([]);
         });
-        it("returns empty array for empty string", () => {
-            const result = parseRequiredReading("");
+        it('returns empty array for empty string', () => {
+            const result = parseRequiredReading('');
             expect(result).toEqual([]);
         });
-        it("ignores non-list items in required reading section", () => {
+        it('ignores non-list items in required reading section', () => {
             const markdown = [
-                "## Required Reading for Agents",
-                "",
-                "Some paragraph text here",
-                "- Local: valid-item.md",
-                "Another paragraph",
-                "- External: https://valid.com",
-                "",
-                "## Next Section",
-            ].join("\n");
+                '## Required Reading for Agents',
+                '',
+                'Some paragraph text here',
+                '- Local: valid-item.md',
+                'Another paragraph',
+                '- External: https://valid.com',
+                '',
+                '## Next Section',
+            ].join('\n');
             const result = parseRequiredReading(markdown);
             expect(result.length).toBe(2);
-            expect(result[0].value).toBe("valid-item.md");
-            expect(result[1].value).toBe("https://valid.com");
+            expect(result[0].value).toBe('valid-item.md');
+            expect(result[1].value).toBe('https://valid.com');
         });
-        it("handles items with whitespace variations", () => {
+        it('handles items with whitespace variations', () => {
             const markdown = [
-                "## Required Reading for Agents",
-                "",
-                "- Local:  ./path/with/spaces.md  ",
-                "-  External:   https://example.com  ",
-            ].join("\n");
+                '## Required Reading for Agents',
+                '',
+                '- Local:  ./path/with/spaces.md  ',
+                '-  External:   https://example.com  ',
+            ].join('\n');
             const result = parseRequiredReading(markdown);
             expect(result.length).toBe(2);
-            expect(result[0].value).toBe("./path/with/spaces.md");
-            expect(result[1].value).toBe("https://example.com");
+            expect(result[0].value).toBe('./path/with/spaces.md');
+            expect(result[1].value).toBe('https://example.com');
         });
-        it("ignores items without Local: or External: prefix", () => {
+        it('ignores items without Local: or External: prefix', () => {
             const markdown = [
-                "## Required Reading for Agents",
-                "",
-                "- Local: valid.md",
-                "- Invalid: this is ignored",
-                "- Just a plain list item",
-                "- External: https://valid.com",
-            ].join("\n");
+                '## Required Reading for Agents',
+                '',
+                '- Local: valid.md',
+                '- Invalid: this is ignored',
+                '- Just a plain list item',
+                '- External: https://valid.com',
+            ].join('\n');
             const result = parseRequiredReading(markdown);
             expect(result.length).toBe(2);
-            expect(result.every((item) => item.source === "Local" || item.source === "External")).toBe(true);
+            expect(result.every((item) => item.source === 'Local' || item.source === 'External')).toBe(true);
         });
-        it("stops at next section header", () => {
+        it('stops at next section header', () => {
             const markdown = [
-                "## Required Reading for Agents",
-                "",
-                "- Local: before.md",
-                "",
-                "## Another Section",
-                "",
-                "- Local: after.md",
-            ].join("\n");
+                '## Required Reading for Agents',
+                '',
+                '- Local: before.md',
+                '',
+                '## Another Section',
+                '',
+                '- Local: after.md',
+            ].join('\n');
             const result = parseRequiredReading(markdown);
             expect(result.length).toBe(1);
-            expect(result[0].value).toBe("before.md");
+            expect(result[0].value).toBe('before.md');
         });
-        it("handles multiple required reading sections (takes first one)", () => {
+        it('handles multiple required reading sections (takes first one)', () => {
             const markdown = [
-                "## Required Reading for Agents",
-                "",
-                "- Local: first.md",
-                "",
-                "## Other Section",
-                "",
-                "## Required Reading for Agents",
-                "",
-                "- Local: second.md",
-            ].join("\n");
+                '## Required Reading for Agents',
+                '',
+                '- Local: first.md',
+                '',
+                '## Other Section',
+                '',
+                '## Required Reading for Agents',
+                '',
+                '- Local: second.md',
+            ].join('\n');
             const result = parseRequiredReading(markdown);
             expect(result.length).toBe(1);
-            expect(result[0].value).toBe("first.md");
+            expect(result[0].value).toBe('first.md');
         });
     });
-    describe("edge cases", () => {
-        it("handles markdown with just the section", () => {
-            const markdown = "## Required Reading for Agents";
+    describe('edge cases', () => {
+        it('handles markdown with just the section', () => {
+            const markdown = '## Required Reading for Agents';
             const result = parseRequiredReading(markdown);
             expect(result).toEqual([]);
         });
-        it("handles section with empty lines", () => {
+        it('handles section with empty lines', () => {
             const markdown = [
-                "## Required Reading for Agents",
-                "",
-                "",
-                "- Local: item.md",
-                "",
-                "",
-            ].join("\n");
+                '## Required Reading for Agents',
+                '',
+                '',
+                '- Local: item.md',
+                '',
+                '',
+            ].join('\n');
             const result = parseRequiredReading(markdown);
             expect(result.length).toBe(1);
-            expect(result[0].value).toBe("item.md");
+            expect(result[0].value).toBe('item.md');
         });
-        it("handles mixed case section headers", () => {
+        it('handles mixed case section headers', () => {
             const markdown = [
-                "## required reading for agents",
-                "",
-                "- Local: lowercase.md",
-            ].join("\n");
+                '## required reading for agents',
+                '',
+                '- Local: lowercase.md',
+            ].join('\n');
             const result = parseRequiredReading(markdown);
             expect(result.length).toBe(1);
         });

package/output/source/resources/reports.js

@@ -1,24 +1,24 @@
-import { isValidRoadmapId } from "../tools/roadmap.js";
-import { isValidTaskId } from "../tools/task.js";
+import { isValidRoadmapId } from '../tools/roadmap.js';
+import { isValidTaskId } from '../tools/task.js';
 export function parseReportMetadata(markdown) {
     const lines = markdown.split(/\r?\n/);
     const metadata = {};
     for (const line of lines) {
         // Remove markdown bold markers (**)
-        const cleanLine = line.replace(/\*\*/g, "");
-        const [rawKey, ...rawValue] = cleanLine.split(":");
+        const cleanLine = line.replace(/\*\*/g, '');
+        const [rawKey, ...rawValue] = cleanLine.split(':');
         if (!rawKey || rawValue.length === 0) {
             continue;
         }
         const key = rawKey.trim().toLowerCase();
-        const value = rawValue.join(":").trim();
-        if (key === "task")
+        const value = rawValue.join(':').trim();
+        if (key === 'task')
             metadata.task = value;
-        if (key === "roadmap")
+        if (key === 'roadmap')
             metadata.roadmap = value;
-        if (key === "owner")
+        if (key === 'owner')
             metadata.owner = value;
-        if (key === "date")
+        if (key === 'date')
             metadata.date = value;
     }
     return metadata;
@@ -26,7 +26,7 @@ export function parseReportMetadata(markdown) {
 export function validateReportMetadata(metadata) {
     const errors = [];
     if (!metadata.task) {
-        errors.push("Missing Task metadata");
+        errors.push('Missing Task metadata');
     }
     else if (!isValidTaskId(metadata.task)) {
         errors.push(`Invalid Task metadata format: ${metadata.task}`);

package/output/source/resources/reports.test.js

@@ -1,148 +1,148 @@
-import { describe, expect, it } from "vitest";
-import { parseReportMetadata, validateReportMetadata, } from "./reports.js";
-describe("reports module", () => {
-    describe("parseReportMetadata", () => {
-        it("parses task metadata from markdown", () => {
+import { describe, expect, it } from 'vitest';
+import { parseReportMetadata, validateReportMetadata, } from './reports.js';
+describe('reports module', () => {
+    describe('parseReportMetadata', () => {
+        it('parses task metadata from markdown', () => {
             const markdown = [
-                "# Task Report",
-                "",
-                "**Task:** TASK-0001",
-                "**Owner:** ai-copilot",
-                "**Date:** 2026-02-22",
-                "",
-                "Some content here",
-            ].join("\n");
+                '# Task Report',
+                '',
+                '**Task:** TASK-0001',
+                '**Owner:** ai-copilot',
+                '**Date:** 2026-02-22',
+                '',
+                'Some content here',
+            ].join('\n');
             const metadata = parseReportMetadata(markdown);
-            expect(metadata.task).toBe("TASK-0001");
-            expect(metadata.owner).toBe("ai-copilot");
-            expect(metadata.date).toBe("2026-02-22");
+            expect(metadata.task).toBe('TASK-0001');
+            expect(metadata.owner).toBe('ai-copilot');
+            expect(metadata.date).toBe('2026-02-22');
         });
-        it("parses roadmap metadata from markdown", () => {
+        it('parses roadmap metadata from markdown', () => {
             const markdown = [
-                "# Roadmap Report",
-                "",
-                "**Roadmap:** ROADMAP-0001",
-                "",
-                "Some content here",
-            ].join("\n");
+                '# Roadmap Report',
+                '',
+                '**Roadmap:** ROADMAP-0001',
+                '',
+                'Some content here',
+            ].join('\n');
             const metadata = parseReportMetadata(markdown);
-            expect(metadata.roadmap).toBe("ROADMAP-0001");
+            expect(metadata.roadmap).toBe('ROADMAP-0001');
         });
-        it("returns empty object for markdown without metadata", () => {
+        it('returns empty object for markdown without metadata', () => {
             const markdown = [
-                "# Simple Report",
-                "",
-                "No metadata here",
-            ].join("\n");
+                '# Simple Report',
+                '',
+                'No metadata here',
+            ].join('\n');
             const metadata = parseReportMetadata(markdown);
             expect(metadata).toEqual({});
         });
-        it("handles empty string", () => {
-            const metadata = parseReportMetadata("");
+        it('handles empty string', () => {
+            const metadata = parseReportMetadata('');
             expect(metadata).toEqual({});
         });
-        it("handles malformed metadata lines", () => {
+        it('handles malformed metadata lines', () => {
             const markdown = [
-                "# Report",
-                "",
-                "Task without colon",
-                "Not a metadata line",
-                ":",
-                "Task:",
-            ].join("\n");
+                '# Report',
+                '',
+                'Task without colon',
+                'Not a metadata line',
+                ':',
+                'Task:',
+            ].join('\n');
             const metadata = parseReportMetadata(markdown);
             expect(metadata).toBeDefined();
         });
-        it("parses metadata in different formats", () => {
+        it('parses metadata in different formats', () => {
             const markdown = [
-                "Task: TASK-0001",
-                "task: TASK-0002",
-                "TASK: TASK-0003",
-                "  task  :  TASK-0004  ",
-            ].join("\n");
+                'Task: TASK-0001',
+                'task: TASK-0002',
+                'TASK: TASK-0003',
+                '  task  :  TASK-0004  ',
+            ].join('\n');
             const metadata = parseReportMetadata(markdown);
             expect(metadata.task).toBeDefined();
         });
     });
-    describe("validateReportMetadata", () => {
-        it("validates correct task metadata", () => {
+    describe('validateReportMetadata', () => {
+        it('validates correct task metadata', () => {
             const metadata = {
-                task: "TASK-0001",
-                owner: "ai-copilot",
-                date: "2026-02-22",
+                task: 'TASK-0001',
+                owner: 'ai-copilot',
+                date: '2026-02-22',
             };
             const result = validateReportMetadata(metadata);
             expect(result.ok).toBe(true);
             expect(result.errors).toEqual([]);
         });
-        it("rejects missing task metadata", () => {
+        it('rejects missing task metadata', () => {
             const metadata = {
-                owner: "ai-copilot",
+                owner: 'ai-copilot',
             };
             const result = validateReportMetadata(metadata);
             expect(result.ok).toBe(false);
-            expect(result.errors).toContain("Missing Task metadata");
+            expect(result.errors).toContain('Missing Task metadata');
         });
-        it("rejects invalid task ID format", () => {
+        it('rejects invalid task ID format', () => {
             const metadata = {
-                task: "invalid-format",
+                task: 'invalid-format',
             };
             const result = validateReportMetadata(metadata);
             expect(result.ok).toBe(false);
-            expect(result.errors.some((e) => e.includes("Invalid Task"))).toBe(true);
+            expect(result.errors.some((e) => e.includes('Invalid Task'))).toBe(true);
         });
-        it("validates optional roadmap metadata", () => {
+        it('validates optional roadmap metadata', () => {
             const metadata = {
-                task: "TASK-0001",
-                roadmap: "ROADMAP-0001",
+                task: 'TASK-0001',
+                roadmap: 'ROADMAP-0001',
             };
             const result = validateReportMetadata(metadata);
             expect(result.ok).toBe(true);
         });
-        it("rejects invalid roadmap ID format", () => {
+        it('rejects invalid roadmap ID format', () => {
             const metadata = {
-                task: "TASK-0001",
-                roadmap: "invalid-roadmap",
+                task: 'TASK-0001',
+                roadmap: 'invalid-roadmap',
             };
             const result = validateReportMetadata(metadata);
             expect(result.ok).toBe(false);
-            expect(result.errors.some((e) => e.includes("Invalid Roadmap"))).toBe(true);
+            expect(result.errors.some((e) => e.includes('Invalid Roadmap'))).toBe(true);
         });
-        it("handles empty metadata object", () => {
+        it('handles empty metadata object', () => {
             const metadata = {};
             const result = validateReportMetadata(metadata);
             expect(result.ok).toBe(false);
             expect(result.errors.length).toBeGreaterThan(0);
         });
-        it("collects multiple validation errors", () => {
+        it('collects multiple validation errors', () => {
             const metadata = {
-                task: "invalid-task",
-                roadmap: "invalid-roadmap",
+                task: 'invalid-task',
+                roadmap: 'invalid-roadmap',
             };
             const result = validateReportMetadata(metadata);
             expect(result.ok).toBe(false);
             expect(result.errors.length).toBeGreaterThan(1);
         });
     });
-    describe("integration", () => {
-        it("parses and validates complete report metadata", () => {
+    describe('integration', () => {
+        it('parses and validates complete report metadata', () => {
             const markdown = [
-                "# Task Completion Report",
-                "",
-                "**Task:** TASK-0001",
-                "**Roadmap:** ROADMAP-0002",
-                "**Owner:** ai-copilot",
-                "**Date:** 2026-02-22",
-                "",
-                "## Summary",
-                "Task completed successfully",
-            ].join("\n");
+                '# Task Completion Report',
+                '',
+                '**Task:** TASK-0001',
+                '**Roadmap:** ROADMAP-0002',
+                '**Owner:** ai-copilot',
+                '**Date:** 2026-02-22',
+                '',
+                '## Summary',
+                'Task completed successfully',
+            ].join('\n');
             const metadata = parseReportMetadata(markdown);
             const validation = validateReportMetadata(metadata);
-            expect(metadata.task).toBe("TASK-0001");
-            expect(metadata.roadmap).toBe("ROADMAP-0002");
-            expect(metadata.owner).toBe("ai-copilot");
-            expect(metadata.date).toBe("2026-02-22");
+            expect(metadata.task).toBe('TASK-0001');
+            expect(metadata.roadmap).toBe('ROADMAP-0002');
+            expect(metadata.owner).toBe('ai-copilot');
+            expect(metadata.date).toBe('2026-02-22');
             expect(validation.ok).toBe(true);
         });
     });

package/output/source/tools/index.js

@@ -1,6 +1,6 @@
-import { registerProjectTools } from "./project.js";
-import { registerTaskTools } from "./task.js";
-import { registerRoadmapTools } from "./roadmap.js";
+import { registerProjectTools } from './project.js';
+import { registerTaskTools } from './task.js';
+import { registerRoadmapTools } from './roadmap.js';
 export function registerTools(server) {
     registerProjectTools(server);
     registerTaskTools(server);

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

@@ -0,0 +1,23 @@
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('./project.js', () => ({
+    registerProjectTools: vi.fn(),
+}));
+vi.mock('./task.js', () => ({
+    registerTaskTools: vi.fn(),
+}));
+vi.mock('./roadmap.js', () => ({
+    registerRoadmapTools: vi.fn(),
+}));
+import { registerProjectTools } from './project.js';
+import { registerTaskTools } from './task.js';
+import { registerRoadmapTools } from './roadmap.js';
+import { registerTools } from './index.js';
+describe('tools index module', () => {
+    it('registers all tool groups', () => {
+        const server = {};
+        registerTools(server);
+        expect(registerProjectTools).toHaveBeenCalledWith(server);
+        expect(registerTaskTools).toHaveBeenCalledWith(server);
+        expect(registerRoadmapTools).toHaveBeenCalledWith(server);
+    });
+});