@projitive/mcp 1.0.8 → 1.1.2

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

@@ -0,0 +1,154 @@
+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");
+            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");
+        });
+        it("parses roadmap metadata from markdown", () => {
+            const markdown = [
+                "# Design Document",
+                "",
+                "**Roadmap:** ROADMAP-0001",
+                "",
+                "Some content here",
+            ].join("\n");
+            const metadata = parseDesignMetadata(markdown);
+            expect(metadata.roadmap).toBe("ROADMAP-0001");
+        });
+        it("returns empty object for markdown without metadata", () => {
+            const markdown = [
+                "# Simple Design",
+                "",
+                "No metadata here",
+            ].join("\n");
+            const metadata = parseDesignMetadata(markdown);
+            expect(metadata).toEqual({});
+        });
+        it("handles empty string", () => {
+            const metadata = parseDesignMetadata("");
+            expect(metadata).toEqual({});
+        });
+        it("handles malformed metadata lines", () => {
+            const markdown = [
+                "# Report",
+                "",
+                "Task without colon",
+                "Not a metadata line",
+                ":",
+                "Task:",
+            ].join("\n");
+            const metadata = parseDesignMetadata(markdown);
+            expect(metadata).toBeDefined();
+        });
+        it("parses metadata in different formats", () => {
+            const markdown = [
+                "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", () => {
+            const metadata = {
+                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", () => {
+            const metadata = {
+                owner: "ai-copilot",
+            };
+            const result = validateDesignMetadata(metadata);
+            expect(result.ok).toBe(false);
+            expect(result.errors).toContain("Missing Task metadata");
+        });
+        it("rejects invalid task ID format", () => {
+            const metadata = {
+                task: "invalid-format",
+            };
+            const result = validateDesignMetadata(metadata);
+            expect(result.ok).toBe(false);
+            expect(result.errors.some((e) => e.includes("Invalid Task"))).toBe(true);
+        });
+        it("validates optional roadmap metadata", () => {
+            const metadata = {
+                task: "TASK-0001",
+                roadmap: "ROADMAP-0001",
+            };
+            const result = validateDesignMetadata(metadata);
+            expect(result.ok).toBe(true);
+        });
+        it("rejects invalid roadmap ID format", () => {
+            const metadata = {
+                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);
+        });
+        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", () => {
+            const metadata = {
+                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", () => {
+            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");
+            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(validation.ok).toBe(true);
+        });
+    });
+});

package/output/source/resources/governance.js

@@ -0,0 +1,40 @@
+// Governance resource management
+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",
+    }, async () => ({
+        contents: [
+            {
+                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 and status under .projitive/tasks.md",
+        mimeType: "text/markdown",
+    }, async () => ({
+        contents: [
+            {
+                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 under .projitive/roadmap.md",
+        mimeType: "text/markdown",
+    }, async () => ({
+        contents: [
+            {
+                uri: "projitive://governance/roadmap",
+                text: await readMarkdownOrFallback(".projitive/roadmap.md", "Governance Roadmap", repoRoot),
+            },
+        ],
+    }));
+}

package/output/source/resources/index.js

@@ -0,0 +1,6 @@
+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.test.js

@@ -0,0 +1,167 @@
+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: ./design/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: "./design/README.md",
+            });
+            expect(result[1]).toEqual({
+                source: "Local",
+                value: ".projitive/tasks.md",
+            });
+            expect(result[2]).toEqual({
+                source: "External",
+                value: "https://example.com/docs",
+            });
+        });
+        it("parses Chinese section header", () => {
+            const markdown = [
+                "# 项目 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");
+        });
+        it("returns empty array when no required reading section", () => {
+            const markdown = [
+                "# 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("");
+            expect(result).toEqual([]);
+        });
+        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");
+            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");
+        });
+        it("handles items with whitespace variations", () => {
+            const markdown = [
+                "## 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");
+        });
+        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");
+            const result = parseRequiredReading(markdown);
+            expect(result.length).toBe(2);
+            expect(result.every((item) => item.source === "Local" || item.source === "External")).toBe(true);
+        });
+        it("stops at next section header", () => {
+            const markdown = [
+                "## 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");
+        });
+        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");
+            const result = parseRequiredReading(markdown);
+            expect(result.length).toBe(1);
+            expect(result[0].value).toBe("first.md");
+        });
+    });
+    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", () => {
+            const markdown = [
+                "## 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");
+        });
+        it("handles mixed case section headers", () => {
+            const markdown = [
+                "## required reading for agents",
+                "",
+                "- Local: lowercase.md",
+            ].join("\n");
+            const result = parseRequiredReading(markdown);
+            expect(result.length).toBe(1);
+        });
+    });
+});

package/output/source/{reports.js → resources/reports.js}

@@ -1,10 +1,12 @@
-import { isValidRoadmapId } from "./roadmap.js";
-import { isValidTaskId } from "./tasks.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) {
-        const [rawKey, ...rawValue] = line.split(":");
+        // Remove markdown bold markers (**)
+        const cleanLine = line.replace(/\*\*/g, "");
+        const [rawKey, ...rawValue] = cleanLine.split(":");
         if (!rawKey || rawValue.length === 0) {
             continue;
         }

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

@@ -0,0 +1,149 @@
+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");
+            const metadata = parseReportMetadata(markdown);
+            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", () => {
+            const markdown = [
+                "# Roadmap Report",
+                "",
+                "**Roadmap:** ROADMAP-0001",
+                "",
+                "Some content here",
+            ].join("\n");
+            const metadata = parseReportMetadata(markdown);
+            expect(metadata.roadmap).toBe("ROADMAP-0001");
+        });
+        it("returns empty object for markdown without metadata", () => {
+            const markdown = [
+                "# Simple Report",
+                "",
+                "No metadata here",
+            ].join("\n");
+            const metadata = parseReportMetadata(markdown);
+            expect(metadata).toEqual({});
+        });
+        it("handles empty string", () => {
+            const metadata = parseReportMetadata("");
+            expect(metadata).toEqual({});
+        });
+        it("handles malformed metadata lines", () => {
+            const markdown = [
+                "# Report",
+                "",
+                "Task without colon",
+                "Not a metadata line",
+                ":",
+                "Task:",
+            ].join("\n");
+            const metadata = parseReportMetadata(markdown);
+            expect(metadata).toBeDefined();
+        });
+        it("parses metadata in different formats", () => {
+            const markdown = [
+                "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", () => {
+            const metadata = {
+                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", () => {
+            const metadata = {
+                owner: "ai-copilot",
+            };
+            const result = validateReportMetadata(metadata);
+            expect(result.ok).toBe(false);
+            expect(result.errors).toContain("Missing Task metadata");
+        });
+        it("rejects invalid task ID format", () => {
+            const metadata = {
+                task: "invalid-format",
+            };
+            const result = validateReportMetadata(metadata);
+            expect(result.ok).toBe(false);
+            expect(result.errors.some((e) => e.includes("Invalid Task"))).toBe(true);
+        });
+        it("validates optional roadmap metadata", () => {
+            const metadata = {
+                task: "TASK-0001",
+                roadmap: "ROADMAP-0001",
+            };
+            const result = validateReportMetadata(metadata);
+            expect(result.ok).toBe(true);
+        });
+        it("rejects invalid roadmap ID format", () => {
+            const metadata = {
+                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);
+        });
+        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", () => {
+            const metadata = {
+                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", () => {
+            const markdown = [
+                "# 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(validation.ok).toBe(true);
+        });
+    });
+});

package/output/source/tools/index.js

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

package/output/source/{projitive.js → tools/project.js}

@@ -2,11 +2,9 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
 import { z } from "zod";
-import { discoverGovernanceArtifacts } from "./helpers/files/index.js";
-import { catchIt } from "./helpers/catch/index.js";
-import { PROJECT_LINT_CODES, renderLintSuggestions } from "./helpers/linter/index.js";
-import { asText, evidenceSection, guidanceSection, lintSection, nextCallSection, renderToolResponseMarkdown, summarySection, } from "./helpers/response/index.js";
-import { collectTaskLintSuggestions, loadTasksDocument } from "./tasks.js";
+import { discoverGovernanceArtifacts, catchIt, PROJECT_LINT_CODES, renderLintSuggestions } from "../common/index.js";
+import { asText, evidenceSection, guidanceSection, lintSection, nextCallSection, renderToolResponseMarkdown, summarySection, } from "../common/index.js";
+import { collectTaskLintSuggestions, loadTasksDocument } from "./task.js";
 export const PROJECT_MARKER = ".projitive";
 const DEFAULT_GOVERNANCE_DIR = ".projitive";
 const ignoreNames = new Set(["node_modules", ".git", ".next", "dist", "build"]);
@@ -93,7 +91,7 @@ async function readTasksSnapshot(governanceDir) {
             ]),
         };
     }
-    const { parseTasksBlock } = await import("./tasks.js");
+    const { parseTasksBlock } = await import("./task.js");
     const tasks = await parseTasksBlock(markdown);
     return { tasksPath, exists: true, tasks, lintSuggestions: collectTaskLintSuggestions(tasks, markdown) };
 }