@projitive/mcp 2.0.2 → 2.0.4

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

@@ -1,153 +1,153 @@
-import { describe, expect, it } from "vitest";
-import { parseDesignMetadata, validateDesignMetadata } from "./designs.js";
-describe("designs module", () => {
-    describe("parseDesignMetadata", () => {
-        it("parses task metadata from markdown", () => {
+import { describe, expect, it } from 'vitest';
+import { parseDesignMetadata, validateDesignMetadata } from './designs.js';
+describe('designs module', () => {
+    describe('parseDesignMetadata', () => {
+        it('parses task metadata from markdown', () => {
             const markdown = [
-                "# Design Document",
-                "",
-                "**Task:** TASK-0001",
-                "**Owner:** ai-copilot",
-                "**Status:** Draft",
-                "**Last Updated:** 2026-02-22",
-                "",
-                "Some content here",
-            ].join("\n");
+                '# Design Document',
+                '',
+                '**Task:** TASK-0001',
+                '**Owner:** ai-copilot',
+                '**Status:** Draft',
+                '**Last Updated:** 2026-02-22',
+                '',
+                'Some content here',
+            ].join('\n');
             const metadata = parseDesignMetadata(markdown);
-            expect(metadata.task).toBe("TASK-0001");
-            expect(metadata.owner).toBe("ai-copilot");
-            expect(metadata.status).toBe("Draft");
-            expect(metadata.lastUpdated).toBe("2026-02-22");
+            expect(metadata.task).toBe('TASK-0001');
+            expect(metadata.owner).toBe('ai-copilot');
+            expect(metadata.status).toBe('Draft');
+            expect(metadata.lastUpdated).toBe('2026-02-22');
         });
-        it("parses roadmap metadata from markdown", () => {
+        it('parses roadmap metadata from markdown', () => {
             const markdown = [
-                "# Design Document",
-                "",
-                "**Roadmap:** ROADMAP-0001",
-                "",
-                "Some content here",
-            ].join("\n");
+                '# Design Document',
+                '',
+                '**Roadmap:** ROADMAP-0001',
+                '',
+                'Some content here',
+            ].join('\n');
             const metadata = parseDesignMetadata(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 Design",
-                "",
-                "No metadata here",
-            ].join("\n");
+                '# Simple Design',
+                '',
+                'No metadata here',
+            ].join('\n');
             const metadata = parseDesignMetadata(markdown);
             expect(metadata).toEqual({});
         });
-        it("handles empty string", () => {
-            const metadata = parseDesignMetadata("");
+        it('handles empty string', () => {
+            const metadata = parseDesignMetadata('');
             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 = parseDesignMetadata(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 = parseDesignMetadata(markdown);
             expect(metadata.task).toBeDefined();
         });
     });
-    describe("validateDesignMetadata", () => {
-        it("validates correct task metadata", () => {
+    describe('validateDesignMetadata', () => {
+        it('validates correct task metadata', () => {
             const metadata = {
-                task: "TASK-0001",
-                owner: "ai-copilot",
-                status: "Draft",
-                lastUpdated: "2026-02-22",
+                task: 'TASK-0001',
+                owner: 'ai-copilot',
+                status: 'Draft',
+                lastUpdated: '2026-02-22',
             };
             const result = validateDesignMetadata(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 = validateDesignMetadata(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 = validateDesignMetadata(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 = validateDesignMetadata(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 = validateDesignMetadata(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 = validateDesignMetadata(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 = validateDesignMetadata(metadata);
             expect(result.ok).toBe(false);
             expect(result.errors.length).toBeGreaterThan(1);
         });
     });
-    describe("integration", () => {
-        it("parses and validates complete design metadata", () => {
+    describe('integration', () => {
+        it('parses and validates complete design metadata', () => {
             const markdown = [
-                "# Design Completion Report",
-                "",
-                "**Task:** TASK-0001",
-                "**Roadmap:** ROADMAP-0002",
-                "**Owner:** ai-copilot",
-                "**Status:** Completed",
-                "**Last Updated:** 2026-02-22",
-                "",
-                "## Summary",
-                "Design completed successfully",
-            ].join("\n");
+                '# Design Completion Report',
+                '',
+                '**Task:** TASK-0001',
+                '**Roadmap:** ROADMAP-0002',
+                '**Owner:** ai-copilot',
+                '**Status:** Completed',
+                '**Last Updated:** 2026-02-22',
+                '',
+                '## Summary',
+                'Design completed successfully',
+            ].join('\n');
             const metadata = parseDesignMetadata(markdown);
             const validation = validateDesignMetadata(metadata);
-            expect(metadata.task).toBe("TASK-0001");
-            expect(metadata.roadmap).toBe("ROADMAP-0002");
-            expect(metadata.owner).toBe("ai-copilot");
-            expect(metadata.status).toBe("Completed");
-            expect(metadata.lastUpdated).toBe("2026-02-22");
+            expect(metadata.task).toBe('TASK-0001');
+            expect(metadata.roadmap).toBe('ROADMAP-0002');
+            expect(metadata.owner).toBe('ai-copilot');
+            expect(metadata.status).toBe('Completed');
+            expect(metadata.lastUpdated).toBe('2026-02-22');
             expect(validation.ok).toBe(true);
         });
     });

package/output/source/resources/governance.js

@@ -1,39 +1,39 @@
 // Governance resource management
-import { readMarkdownOrFallback } from "../common/utils.js";
+import { readMarkdownOrFallback } from '../common/utils.js';
 export function registerGovernanceResources(server, repoRoot) {
-    server.registerResource("governanceWorkspace", "projitive://governance/workspace", {
-        title: "Governance Workspace",
-        description: "Primary governance README under .projitive",
-        mimeType: "text/markdown",
+    server.registerResource('governanceWorkspace', 'projitive://governance/workspace', {
+        title: 'Governance Workspace',
+        description: 'Primary governance README under .projitive',
+        mimeType: 'text/markdown',
     }, async () => ({
         contents: [
             {
-                uri: "projitive://governance/workspace",
-                text: await readMarkdownOrFallback(".projitive/README.md", "Governance Workspace", repoRoot),
+                uri: 'projitive://governance/workspace',
+                text: await readMarkdownOrFallback('.projitive/README.md', 'Governance Workspace', repoRoot),
             },
         ],
     }));
-    server.registerResource("governanceTasks", "projitive://governance/tasks", {
-        title: "Governance Tasks",
-        description: "Current task pool markdown view generated from .projitive sqlite task table",
-        mimeType: "text/markdown",
+    server.registerResource('governanceTasks', 'projitive://governance/tasks', {
+        title: 'Governance Tasks',
+        description: 'Current task pool markdown view generated from .projitive governance store',
+        mimeType: 'text/markdown',
     }, async () => ({
         contents: [
             {
-                uri: "projitive://governance/tasks",
-                text: await readMarkdownOrFallback(".projitive/tasks.md", "Governance Tasks", repoRoot),
+                uri: 'projitive://governance/tasks',
+                text: await readMarkdownOrFallback('.projitive/tasks.md', 'Governance Tasks', repoRoot),
             },
         ],
     }));
-    server.registerResource("governanceRoadmap", "projitive://governance/roadmap", {
-        title: "Governance Roadmap",
-        description: "Current roadmap markdown view generated from .projitive sqlite roadmap table",
-        mimeType: "text/markdown",
+    server.registerResource('governanceRoadmap', 'projitive://governance/roadmap', {
+        title: 'Governance Roadmap',
+        description: 'Current roadmap markdown view generated from .projitive governance store',
+        mimeType: 'text/markdown',
     }, async () => ({
         contents: [
             {
-                uri: "projitive://governance/roadmap",
-                text: await readMarkdownOrFallback(".projitive/roadmap.md", "Governance Roadmap", repoRoot),
+                uri: 'projitive://governance/roadmap',
+                text: await readMarkdownOrFallback('.projitive/roadmap.md', 'Governance Roadmap', repoRoot),
             },
         ],
     }));

package/output/source/resources/index.js

@@ -1,5 +1,5 @@
-import { registerGovernanceResources } from "./governance.js";
-import { registerDesignFilesResources } from "./designs.js";
+import { registerGovernanceResources } from './governance.js';
+import { registerDesignFilesResources } from './designs.js';
 export function registerResources(server, repoRoot) {
     registerGovernanceResources(server, repoRoot);
     registerDesignFilesResources(server, repoRoot);

package/output/source/resources/readme.js

@@ -8,18 +8,18 @@ export function parseRequiredReading(markdown) {
             inSection = true;
             continue;
         }
-        if (inSection && trimmed.startsWith("## ")) {
+        if (inSection && trimmed.startsWith('## ')) {
             break;
         }
-        if (!inSection || !trimmed.startsWith("- ")) {
+        if (!inSection || !trimmed.startsWith('- ')) {
             continue;
         }
-        const payload = trimmed.replace(/^-\s+/, "");
-        if (payload.startsWith("Local:")) {
-            result.push({ source: "Local", value: payload.replace("Local:", "").trim() });
+        const payload = trimmed.replace(/^-\s+/, '');
+        if (payload.startsWith('Local:')) {
+            result.push({ source: 'Local', value: payload.replace('Local:', '').trim() });
         }
-        if (payload.startsWith("External:")) {
-            result.push({ source: "External", value: payload.replace("External:", "").trim() });
+        if (payload.startsWith('External:')) {
+            result.push({ source: 'External', value: payload.replace('External:', '').trim() });
         }
     }
     return result;

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);
         });