@projitive/mcp 2.0.3 → 2.1.0

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 governance store",
-        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 governance store",
-        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/governance.test.js

@@ -0,0 +1,35 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { registerGovernanceResources } from './governance.js';
+const tempPaths = [];
+async function createTempDir() {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'projitive-governance-resource-test-'));
+    tempPaths.push(dir);
+    return dir;
+}
+afterEach(async () => {
+    await Promise.all(tempPaths.splice(0).map((dir) => fs.rm(dir, { recursive: true, force: true })));
+    vi.restoreAllMocks();
+});
+describe('governance resources', () => {
+    it('registers workspace, tasks, and roadmap resources from markdown files', async () => {
+        const root = await createTempDir();
+        const governanceDir = path.join(root, '.projitive');
+        await fs.mkdir(governanceDir, { recursive: true });
+        await fs.writeFile(path.join(governanceDir, 'README.md'), '# Workspace\n', 'utf-8');
+        await fs.writeFile(path.join(governanceDir, 'tasks.md'), '# Tasks\n', 'utf-8');
+        await fs.writeFile(path.join(governanceDir, 'roadmap.md'), '# Roadmap\n', 'utf-8');
+        const server = { registerResource: vi.fn() };
+        registerGovernanceResources(server, root);
+        const calls = server.registerResource.mock.calls;
+        expect(calls).toHaveLength(3);
+        const workspaceHandler = calls[0][3];
+        const tasksHandler = calls[1][3];
+        const roadmapHandler = calls[2][3];
+        await expect(workspaceHandler()).resolves.toMatchObject({ contents: [{ uri: 'projitive://governance/workspace', text: '# Workspace\n' }] });
+        await expect(tasksHandler()).resolves.toMatchObject({ contents: [{ uri: 'projitive://governance/tasks', text: '# Tasks\n' }] });
+        await expect(roadmapHandler()).resolves.toMatchObject({ contents: [{ uri: 'projitive://governance/roadmap', text: '# Roadmap\n' }] });
+    });
+});

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/index.test.js

@@ -0,0 +1,18 @@
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('./governance.js', () => ({
+    registerGovernanceResources: vi.fn(),
+}));
+vi.mock('./designs.js', () => ({
+    registerDesignFilesResources: vi.fn(),
+}));
+import { registerGovernanceResources } from './governance.js';
+import { registerDesignFilesResources } from './designs.js';
+import { registerResources } from './index.js';
+describe('resources index module', () => {
+    it('registers governance and design resources', () => {
+        const server = {};
+        registerResources(server, '/workspace/repo');
+        expect(registerGovernanceResources).toHaveBeenCalledWith(server, '/workspace/repo');
+        expect(registerDesignFilesResources).toHaveBeenCalledWith(server, '/workspace/repo');
+    });
+});

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;