@projitive/mcp 2.0.0 → 2.0.1

package/README.md

@@ -5,7 +5,7 @@ Language: English | [简体中文](README_CN.md)
 ## Version
 
 - Current Spec Version: projitive-spec v1.0.0
-- MCP Version: 2.0.0
+- MCP Version: 2.0.1
 
 ## 60-Second Start
 
@@ -157,7 +157,7 @@ sequenceDiagram
 
 ### 3. Evidence-First Execution
 
-- State changes should be backed by report/design/readme evidence.
+- State changes should be backed by report/designs/readme evidence.
 - Tool output format is agent-friendly markdown for chained execution.
 
 ### 4. Deterministic Multi-Agent Workflow

package/output/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@projitive/mcp",
-    "version": "2.0.0",
+    "version": "2.0.1",
     "description": "Projitive MCP Server for project and task discovery/update",
     "license": "ISC",
     "author": "",

package/output/source/common/linter.js

@@ -13,6 +13,7 @@ export const TASK_LINT_CODES = {
     ROADMAP_REFS_EMPTY: "TASK_ROADMAP_REFS_EMPTY",
     OUTSIDE_MARKER: "TASK_OUTSIDE_MARKER",
     LINK_TARGET_MISSING: "TASK_LINK_TARGET_MISSING",
+    LINK_PATH_FORMAT_INVALID: "TASK_LINK_PATH_FORMAT_INVALID",
     HOOK_FILE_MISSING: "TASK_HOOK_FILE_MISSING",
     FILTER_EMPTY: "TASK_FILTER_EMPTY",
     CONTEXT_HOOK_HEAD_MISSING: "TASK_CONTEXT_HOOK_HEAD_MISSING",

package/output/source/prompts/quickStart.js

@@ -99,7 +99,7 @@ export function registerQuickStartPrompt(server) {
             "2. If roadmap has active goals, split milestones into 1-3 executable TODO tasks",
             "3. Apply task creation gate before adding each task:",
             "   - Clear outcome: one-sentence done condition",
-            "   - Verifiable evidence: at least one report/design/readme link target",
+            "   - Verifiable evidence: at least one report/designs/readme link target",
             "   - Small slice: should be completable in one focused execution cycle",
             "   - Traceability: include at least one roadmapRefs item when applicable",
             "   - Distinct scope: avoid overlap with existing DONE/BLOCKED tasks",

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

@@ -10,7 +10,7 @@ describe("readme module", () => {
                 "",
                 "## Required Reading for Agents",
                 "",
-                "- Local: ./design/README.md",
+                "- Local: ./designs/README.md",
                 "- Local: .projitive/tasks.md",
                 "- External: https://example.com/docs",
                 "",
@@ -22,7 +22,7 @@ describe("readme module", () => {
             expect(result.length).toBe(3);
             expect(result[0]).toEqual({
                 source: "Local",
-                value: "./design/README.md",
+                value: "./designs/README.md",
             });
             expect(result[1]).toEqual({
                 source: "Local",

package/output/source/tools/task.js

@@ -42,7 +42,7 @@ const DEFAULT_NO_TASK_DISCOVERY_GUIDANCE = [
     "- If all remaining tasks are BLOCKED, create one unblock task with explicit unblock condition and dependency owner.",
     "- Start from active roadmap milestones and split into the smallest executable slices with a single done condition each.",
     "- Prefer slices that unlock multiple downstream tasks before isolated refactors or low-impact cleanups.",
-    "- Create TODO tasks only when evidence is clear: each new task must produce at least one report/design/readme artifact update.",
+    "- Create TODO tasks only when evidence is clear: each new task must produce at least one report/designs/readme artifact update.",
     "- Skip duplicate scope: do not create tasks that overlap existing TODO/IN_PROGRESS/BLOCKED task intent.",
     "- Use quality gates for discovery candidates: user value, delivery risk reduction, or measurable throughput improvement.",
     "- Keep each discovery round small (1-3 tasks), then rerun taskNext immediately for re-ranking and execution.",
@@ -85,11 +85,33 @@ export function renderTaskSeedTemplate(roadmapRef) {
         "- updatedAt: 2026-01-01T00:00:00.000Z",
         `- roadmapRefs: ${roadmapRef}`,
         "- links:",
-        "  - ./README.md",
-        "  - ./roadmap.md",
+        "  - README.md",
+        "  - .projitive/roadmap.md",
         "```",
     ];
 }
+function isHttpUrl(value) {
+    return /^https?:\/\//i.test(value);
+}
+function isProjectRootRelativePath(value) {
+    return value.length > 0
+        && !value.startsWith("/")
+        && !value.startsWith("./")
+        && !value.startsWith("../")
+        && !/^[A-Za-z]:\//.test(value);
+}
+function normalizeTaskLink(link) {
+    const trimmed = link.trim();
+    if (trimmed.length === 0 || isHttpUrl(trimmed)) {
+        return trimmed;
+    }
+    const slashNormalized = trimmed.replace(/\\/g, "/");
+    const withoutDotPrefix = slashNormalized.replace(/^\.\//, "");
+    return withoutDotPrefix.replace(/^\/+/, "");
+}
+function resolveTaskLinkPath(projectPath, link) {
+    return path.join(projectPath, link);
+}
 async function readActionableTaskCandidates(governanceDirs) {
     const snapshots = await Promise.all(governanceDirs.map(async (governanceDir) => {
         const tasksPath = path.join(governanceDir, ".projitive");
@@ -206,7 +228,12 @@ export function normalizeTask(task) {
         owner: task.owner ? String(task.owner) : "",
         summary: task.summary ? String(task.summary) : "",
         updatedAt: task.updatedAt ? String(task.updatedAt) : nowIso(),
-        links: Array.isArray(task.links) ? task.links.map(String) : [],
+        links: Array.isArray(task.links)
+            ? Array.from(new Set(task.links
+                .map(String)
+                .map((value) => normalizeTaskLink(value))
+                .filter((value) => value.length > 0)))
+            : [],
         roadmapRefs: Array.from(new Set(normalizedRoadmapRefs)),
     };
     // Include optional v1.1.0 fields if present
@@ -274,6 +301,17 @@ function collectTaskLintSuggestionItems(tasks) {
             fixHint: "Bind at least one ROADMAP-xxxx when applicable.",
         });
     }
+    const invalidLinkPathFormat = tasks.filter((task) => task.links.some((link) => {
+        const normalized = link.trim();
+        return normalized.length > 0 && !isHttpUrl(normalized) && !isProjectRootRelativePath(normalized);
+    }));
+    if (invalidLinkPathFormat.length > 0) {
+        suggestions.push({
+            code: TASK_LINT_CODES.LINK_PATH_FORMAT_INVALID,
+            message: `${invalidLinkPathFormat.length} task(s) contain invalid links path format.`,
+            fixHint: "Use project-root-relative paths without leading slash (for example reports/task-0001.md) or http(s) URL.",
+        });
+    }
     // ============================================================================
     // Spec v1.1.0 - Blocker Categorization Validation
     // ============================================================================
@@ -349,6 +387,17 @@ function collectSingleTaskLintSuggestions(task) {
             fixHint: "Add at least one evidence link.",
         });
     }
+    const invalidLinkPathFormat = task.links.some((link) => {
+        const normalized = link.trim();
+        return normalized.length > 0 && !isHttpUrl(normalized) && !isProjectRootRelativePath(normalized);
+    });
+    if (invalidLinkPathFormat) {
+        suggestions.push({
+            code: TASK_LINT_CODES.LINK_PATH_FORMAT_INVALID,
+            message: "Current task has invalid links path format.",
+            fixHint: "Use project-root-relative paths without leading slash (for example reports/task-0001.md) or http(s) URL.",
+        });
+    }
     if (task.status === "BLOCKED" && task.summary.trim().length === 0) {
         suggestions.push({
             code: TASK_LINT_CODES.BLOCKED_SUMMARY_EMPTY,
@@ -422,6 +471,7 @@ function collectSingleTaskLintSuggestions(task) {
 }
 async function collectTaskFileLintSuggestions(governanceDir, task) {
     const suggestions = [];
+    const projectPath = toProjectPath(governanceDir);
     for (const link of task.links) {
         const normalized = link.trim();
         if (normalized.length === 0) {
@@ -430,7 +480,15 @@ async function collectTaskFileLintSuggestions(governanceDir, task) {
         if (/^https?:\/\//i.test(normalized)) {
             continue;
         }
-        const resolvedPath = path.resolve(governanceDir, normalized);
+        if (!isProjectRootRelativePath(normalized)) {
+            suggestions.push({
+                code: TASK_LINT_CODES.LINK_PATH_FORMAT_INVALID,
+                message: `Link path should be project-root-relative without leading slash: ${normalized}.`,
+                fixHint: "Use path/from/project/root format.",
+            });
+            continue;
+        }
+        const resolvedPath = resolveTaskLinkPath(projectPath, normalized);
         const exists = await fs.access(resolvedPath).then(() => true).catch(() => false);
         if (!exists) {
             suggestions.push({

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

@@ -111,6 +111,30 @@ describe("tasks module", () => {
         expect(lint.some((line) => line.includes("BLOCKED_WITHOUT_BLOCKER"))).toBe(true);
         expect(lint.some((line) => line.includes("IN_PROGRESS_WITHOUT_SUBSTATE"))).toBe(true);
     });
+    it("normalizes links to project-root-relative format without leading slash", () => {
+        const task = normalizeTask({
+            id: "TASK-0003",
+            title: "link normalize",
+            status: "TODO",
+            links: ["/reports/a.md", "./designs/b.md", "reports/c.md", "https://example.com/evidence"],
+        });
+        expect(task.links).toContain("reports/a.md");
+        expect(task.links).toContain("designs/b.md");
+        expect(task.links).toContain("reports/c.md");
+        expect(task.links).toContain("https://example.com/evidence");
+        expect(task.links.some((item) => item.startsWith("/"))).toBe(false);
+    });
+    it("lints invalid links path format", () => {
+        const task = normalizeTask({
+            id: "TASK-0004",
+            title: "invalid link",
+            status: "TODO",
+            links: ["../outside.md"],
+            roadmapRefs: ["ROADMAP-0001"],
+        });
+        const lint = collectTaskLintSuggestions([task]);
+        expect(lint.some((line) => line.includes("TASK_LINK_PATH_FORMAT_INVALID"))).toBe(true);
+    });
     it("renders seed task template with provided roadmap ref", () => {
         const lines = renderTaskSeedTemplate("ROADMAP-0099");
         const markdown = lines.join("\n");

package/output/source/types.js

@@ -36,6 +36,7 @@ export const TASK_LINT_CODES = {
     OUTSIDE_MARKER: "TASK_OUTSIDE_MARKER",
     FILTER_EMPTY: "TASK_FILTER_EMPTY",
     LINK_TARGET_MISSING: "TASK_LINK_TARGET_MISSING",
+    LINK_PATH_FORMAT_INVALID: "TASK_LINK_PATH_FORMAT_INVALID",
     // Spec v1.1.0 - Blocker Categorization
     BLOCKED_WITHOUT_BLOCKER: "TASK_BLOCKED_WITHOUT_BLOCKER",
     BLOCKER_TYPE_INVALID: "TASK_BLOCKER_TYPE_INVALID",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projitive/mcp",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Projitive MCP Server for project and task discovery/update",
   "license": "ISC",
   "author": "",