@projitive/mcp 2.0.3 → 2.0.4

package/output/source/tools/roadmap.js

@@ -1,32 +1,31 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { z } from "zod";
-import { candidateFilesFromArtifacts, discoverGovernanceArtifacts, ROADMAP_LINT_CODES, renderLintSuggestions, findTextReferences, ensureStore, loadRoadmapsFromStore, upsertRoadmapInStore, getStoreVersion, getMarkdownViewState, markMarkdownViewBuilt, } from "../common/index.js";
-import { asText, evidenceSection, guidanceSection, lintSection, nextCallSection, renderErrorMarkdown, renderToolResponseMarkdown, summarySection, } from "../common/index.js";
-import { resolveGovernanceDir, toProjectPath } from "./project.js";
-import { loadTasks } from "./task.js";
-export const ROADMAP_ID_REGEX = /^ROADMAP-\d{4}$/;
-export const ROADMAP_MARKDOWN_FILE = "roadmap.md";
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+import { candidateFilesFromArtifacts, discoverGovernanceArtifacts, ROADMAP_LINT_CODES, renderLintSuggestions, findTextReferences, ensureStore, loadRoadmapsFromStore, upsertRoadmapInStore, getStoreVersion, getMarkdownViewState, markMarkdownViewBuilt, } from '../common/index.js';
+import { asText, evidenceSection, guidanceSection, lintSection, nextCallSection, renderErrorMarkdown, renderToolResponseMarkdown, summarySection, } from '../common/index.js';
+import { resolveGovernanceDir, toProjectPath } from './project.js';
+import { loadTasks, loadTasksDocument } from './task.js';
+export const ROADMAP_ID_REGEX = /^ROADMAP-(\d+)$/;
+export const ROADMAP_MARKDOWN_FILE = 'roadmap.md';
 function nowIso() {
     return new Date().toISOString();
 }
 function nextRoadmapId(milestones) {
     const maxSuffix = milestones
         .map((item) => toRoadmapIdNumericSuffix(item.id))
-        .filter((value) => Number.isFinite(value) && value >= 0)
+        .filter((value) => value > 0)
         .reduce((max, value) => Math.max(max, value), 0);
     const next = maxSuffix + 1;
-    if (next > 9999) {
-        throw new Error("ROADMAP ID overflow: maximum supported ID is ROADMAP-9999");
-    }
-    return `ROADMAP-${String(next).padStart(4, "0")}`;
+    const minWidth = Math.max(4, String(next).length);
+    return `ROADMAP-${String(next).padStart(minWidth, '0')}`;
 }
 function toRoadmapIdNumericSuffix(roadmapId) {
-    const match = roadmapId.match(/^(?:ROADMAP-)(\d{4})$/);
+    const match = roadmapId.match(ROADMAP_ID_REGEX);
     if (!match) {
         return -1;
     }
-    return Number.parseInt(match[1], 10);
+    const suffix = Number.parseInt(match[1], 10);
+    return Number.isFinite(suffix) ? suffix : -1;
 }
 function sortMilestonesNewestFirst(milestones) {
     return [...milestones].sort((a, b) => {
@@ -45,9 +44,9 @@ function normalizeMilestone(raw) {
     return {
         id: String(raw.id),
         title: String(raw.title),
-        status: raw.status === "done" ? "done" : "active",
-        time: typeof raw.time === "string" && raw.time.trim().length > 0 ? raw.time.trim() : undefined,
-        updatedAt: typeof raw.updatedAt === "string" && Number.isFinite(new Date(raw.updatedAt).getTime()) ? raw.updatedAt : nowIso(),
+        status: raw.status === 'done' ? 'done' : 'active',
+        time: typeof raw.time === 'string' && raw.time.trim().length > 0 ? raw.time.trim() : undefined,
+        updatedAt: typeof raw.updatedAt === 'string' && Number.isFinite(new Date(raw.updatedAt).getTime()) ? raw.updatedAt : nowIso(),
     };
 }
 function normalizeAndSortMilestones(milestones) {
@@ -57,29 +56,33 @@ function normalizeAndSortMilestones(milestones) {
 }
 export function renderRoadmapMarkdown(milestones) {
     const lines = sortMilestonesNewestFirst(milestones).map((item) => {
-        const checkbox = item.status === "done" ? "x" : " ";
-        const timeText = item.time ? ` (time: ${item.time})` : "";
+        const checkbox = item.status === 'done' ? 'x' : ' ';
+        const timeText = item.time ? ` (time: ${item.time})` : '';
         return `- [${checkbox}] ${item.id}: ${item.title}${timeText}`;
     });
     return [
-        "# Roadmap",
-        "",
-        "This file is generated from .projitive governance store by Projitive MCP. Manual edits will be overwritten.",
-        "",
-        "## Active Milestones",
-        ...(lines.length > 0 ? lines : ["- (no milestones)"]),
-        "",
-    ].join("\n");
+        '# Roadmap',
+        '',
+        'Projitive is an AI-first project governance framework for tasks, roadmaps, reports, and designs.',
+        'Author: yinxulai',
+        'Repository: https://github.com/yinxulai/projitive',
+        'Do not edit this file manually. This file is automatically generated by Projitive.',
+        'This file is generated from .projitive governance store by Projitive MCP. Manual edits will be overwritten.',
+        '',
+        '## Active Milestones',
+        ...(lines.length > 0 ? lines : ['- (no milestones)']),
+        '',
+    ].join('\n');
 }
 function resolveRoadmapArtifactPaths(governanceDir) {
     return {
-        roadmapPath: path.join(governanceDir, ".projitive"),
+        roadmapPath: path.join(governanceDir, '.projitive'),
         markdownPath: path.join(governanceDir, ROADMAP_MARKDOWN_FILE),
     };
 }
 async function syncRoadmapMarkdownView(roadmapPath, markdownPath, markdown, force = false) {
-    const sourceVersion = await getStoreVersion(roadmapPath, "roadmaps");
-    const viewState = await getMarkdownViewState(roadmapPath, "roadmaps_markdown");
+    const sourceVersion = await getStoreVersion(roadmapPath, 'roadmaps');
+    const viewState = await getMarkdownViewState(roadmapPath, 'roadmaps_markdown');
     const markdownExists = await fs.access(markdownPath).then(() => true).catch(() => false);
     const shouldWrite = force
         || !markdownExists
@@ -88,8 +91,8 @@ async function syncRoadmapMarkdownView(roadmapPath, markdownPath, markdown, forc
     if (!shouldWrite) {
         return;
     }
-    await fs.writeFile(markdownPath, markdown, "utf-8");
-    await markMarkdownViewBuilt(roadmapPath, "roadmaps_markdown", sourceVersion);
+    await fs.writeFile(markdownPath, markdown, 'utf-8');
+    await markMarkdownViewBuilt(roadmapPath, 'roadmaps_markdown', sourceVersion);
 }
 export async function loadRoadmapDocument(inputPath) {
     return loadRoadmapDocumentWithOptions(inputPath, false);
@@ -118,15 +121,15 @@ function collectRoadmapLintSuggestionItems(roadmapIds, tasks) {
     if (roadmapIds.length === 0) {
         suggestions.push({
             code: ROADMAP_LINT_CODES.IDS_EMPTY,
-            message: "No roadmap IDs found in .projitive roadmap table.",
-            fixHint: "Add at least one ROADMAP-xxxx milestone.",
+            message: 'No roadmap IDs found in .projitive roadmap table.',
+            fixHint: 'Add at least one ROADMAP-xxxx milestone.',
         });
     }
     if (tasks.length === 0) {
         suggestions.push({
             code: ROADMAP_LINT_CODES.TASKS_EMPTY,
-            message: "No tasks found in .projitive task table.",
-            fixHint: "Add task cards and bind roadmapRefs for traceability.",
+            message: 'No tasks found in .projitive task table.',
+            fixHint: 'Add task cards and bind roadmapRefs for traceability.',
         });
         return suggestions;
     }
@@ -136,15 +139,15 @@ function collectRoadmapLintSuggestionItems(roadmapIds, tasks) {
         suggestions.push({
             code: ROADMAP_LINT_CODES.TASK_REFS_EMPTY,
             message: `${unboundTasks.length} task(s) have empty roadmapRefs.`,
-            fixHint: "Bind ROADMAP-xxxx where applicable.",
+            fixHint: 'Bind ROADMAP-xxxx where applicable.',
         });
     }
     const unknownRefs = Array.from(new Set(tasks.flatMap((task) => task.roadmapRefs).filter((id) => !roadmapSet.has(id))));
     if (unknownRefs.length > 0) {
         suggestions.push({
             code: ROADMAP_LINT_CODES.UNKNOWN_REFS,
-            message: `Unknown roadmapRefs detected: ${unknownRefs.join(", ")}.`,
-            fixHint: "Add missing roadmap IDs or fix task references.",
+            message: `Unknown roadmapRefs detected: ${unknownRefs.join(', ')}.`,
+            fixHint: 'Add missing roadmap IDs or fix task references.',
         });
     }
     const noLinkedRoadmaps = roadmapIds.filter((id) => !tasks.some((task) => task.roadmapRefs.includes(id)));
@@ -152,7 +155,7 @@ function collectRoadmapLintSuggestionItems(roadmapIds, tasks) {
         suggestions.push({
             code: ROADMAP_LINT_CODES.ZERO_LINKED_TASKS,
             message: `${noLinkedRoadmaps.length} roadmap ID(s) have zero linked tasks.`,
-            fixHint: `Consider binding tasks to: ${noLinkedRoadmaps.slice(0, 3).join(", ")}${noLinkedRoadmaps.length > 3 ? ", ..." : ""}.`,
+            fixHint: `Consider binding tasks to: ${noLinkedRoadmaps.slice(0, 3).join(', ')}${noLinkedRoadmaps.length > 3 ? ', ...' : ''}.`,
         });
     }
     return suggestions;
@@ -161,48 +164,51 @@ export function collectRoadmapLintSuggestions(roadmapIds, tasks) {
     return renderLintSuggestions(collectRoadmapLintSuggestionItems(roadmapIds, tasks));
 }
 export function isValidRoadmapId(id) {
-    return ROADMAP_ID_REGEX.test(id);
+    return toRoadmapIdNumericSuffix(id) > 0;
 }
 export function registerRoadmapTools(server) {
-    server.registerTool("roadmapList", {
-        title: "Roadmap List",
-        description: "List roadmap IDs and task linkage for planning or traceability",
+    server.registerTool('roadmapList', {
+        title: 'Roadmap List',
+        description: 'List roadmap IDs and task linkage for planning or traceability',
         inputSchema: {
             projectPath: z.string(),
         },
     }, async ({ projectPath }) => {
         const governanceDir = await resolveGovernanceDir(projectPath);
         const normalizedProjectPath = toProjectPath(governanceDir);
-        const roadmapIds = await loadRoadmapIds(governanceDir);
-        const { tasks } = await loadTasks(governanceDir);
+        const { milestones, markdownPath: roadmapViewPath } = await loadRoadmapDocument(governanceDir);
+        const roadmapIds = milestones.map((item) => item.id);
+        const { tasks, markdownPath: tasksViewPath } = await loadTasksDocument(governanceDir);
         const lintSuggestions = collectRoadmapLintSuggestions(roadmapIds, tasks);
         const markdown = renderToolResponseMarkdown({
-            toolName: "roadmapList",
+            toolName: 'roadmapList',
             sections: [
                 summarySection([
                     `- projectPath: ${normalizedProjectPath}`,
                     `- governanceDir: ${governanceDir}`,
+                    `- tasksView: ${tasksViewPath}`,
+                    `- roadmapView: ${roadmapViewPath}`,
                     `- roadmapCount: ${roadmapIds.length}`,
                 ]),
                 evidenceSection([
-                    "- roadmaps:",
+                    '- roadmaps:',
                     ...roadmapIds.map((id) => {
                         const linkedTasks = tasks.filter((task) => task.roadmapRefs.includes(id));
                         return `- ${id} | linkedTasks=${linkedTasks.length}`;
                     }),
                 ]),
-                guidanceSection(["- Pick one roadmap ID and call `roadmapContext`."]),
+                guidanceSection(['- Pick one roadmap ID and call `roadmapContext`.']),
                 lintSection(lintSuggestions),
                 nextCallSection(roadmapIds[0]
-                    ? `roadmapContext(projectPath=\"${toProjectPath(governanceDir)}\", roadmapId=\"${roadmapIds[0]}\")`
+                    ? `roadmapContext(projectPath="${toProjectPath(governanceDir)}", roadmapId="${roadmapIds[0]}")`
                     : undefined),
             ],
         });
         return asText(markdown);
     });
-    server.registerTool("roadmapContext", {
-        title: "Roadmap Context",
-        description: "Inspect one roadmap with linked tasks and reference locations",
+    server.registerTool('roadmapContext', {
+        title: 'Roadmap Context',
+        description: 'Inspect one roadmap with linked tasks and reference locations',
         inputSchema: {
             projectPath: z.string(),
             roadmapId: z.string(),
@@ -210,16 +216,17 @@ export function registerRoadmapTools(server) {
     }, async ({ projectPath, roadmapId }) => {
         if (!isValidRoadmapId(roadmapId)) {
             return {
-                ...asText(renderErrorMarkdown("roadmapContext", `Invalid roadmap ID format: ${roadmapId}`, ["expected format: ROADMAP-0001", "retry with a valid roadmap ID"], `roadmapContext(projectPath=\"${projectPath}\", roadmapId=\"ROADMAP-0001\")`)),
+                ...asText(renderErrorMarkdown('roadmapContext', `Invalid roadmap ID format: ${roadmapId}`, ['expected format: ROADMAP-1 or ROADMAP-0001', 'retry with a valid roadmap ID'], `roadmapContext(projectPath="${projectPath}", roadmapId="ROADMAP-0001")`)),
                 isError: true,
             };
         }
         const governanceDir = await resolveGovernanceDir(projectPath);
         const normalizedProjectPath = toProjectPath(governanceDir);
+        const { markdownPath: roadmapViewPath } = resolveRoadmapArtifactPaths(governanceDir);
         const artifacts = await discoverGovernanceArtifacts(governanceDir);
         const fileCandidates = candidateFilesFromArtifacts(artifacts);
         const referenceLocations = (await Promise.all(fileCandidates.map((file) => findTextReferences(file, roadmapId)))).flat();
-        const { tasks } = await loadTasks(governanceDir);
+        const { tasks, markdownPath: tasksViewPath } = await loadTasksDocument(governanceDir);
         const relatedTasks = tasks.filter((task) => task.roadmapRefs.includes(roadmapId));
         const roadmapIds = await loadRoadmapIds(governanceDir);
         const lintSuggestionItems = collectRoadmapLintSuggestionItems(roadmapIds, tasks);
@@ -227,70 +234,73 @@ export function registerRoadmapTools(server) {
             lintSuggestionItems.push({
                 code: ROADMAP_LINT_CODES.CONTEXT_RELATED_TASKS_EMPTY,
                 message: `relatedTasks=0 for ${roadmapId}.`,
-                fixHint: "Batch bind task roadmapRefs to improve execution traceability.",
+                fixHint: 'Batch bind task roadmapRefs to improve execution traceability.',
             });
         }
         const lintSuggestions = renderLintSuggestions(lintSuggestionItems);
         const markdown = renderToolResponseMarkdown({
-            toolName: "roadmapContext",
+            toolName: 'roadmapContext',
             sections: [
                 summarySection([
                     `- projectPath: ${normalizedProjectPath}`,
                     `- governanceDir: ${governanceDir}`,
+                    `- tasksView: ${tasksViewPath}`,
+                    `- roadmapView: ${roadmapViewPath}`,
                     `- roadmapId: ${roadmapId}`,
                     `- relatedTasks: ${relatedTasks.length}`,
                     `- references: ${referenceLocations.length}`,
                 ]),
                 evidenceSection([
-                    "### Related Tasks",
+                    '### Related Tasks',
                     ...relatedTasks.map((task) => `- ${task.id} | ${task.status} | ${task.title}`),
-                    "",
-                    "### Reference Locations",
+                    '',
+                    '### Reference Locations',
                     ...referenceLocations.map((item) => `- ${item.filePath}#L${item.line}: ${item.text}`),
                 ]),
                 guidanceSection([
-                    "- Read roadmap references first, then related tasks.",
-                    "- Keep ROADMAP/TASK IDs unchanged while updating markdown files.",
-                    "- Re-run `roadmapContext` after edits to confirm references remain consistent.",
+                    '- Read roadmap references first, then related tasks.',
+                    '- Keep ROADMAP/TASK IDs unchanged while updating markdown files.',
+                    '- Re-run `roadmapContext` after edits to confirm references remain consistent.',
                 ]),
                 lintSection(lintSuggestions),
-                nextCallSection(`roadmapContext(projectPath=\"${toProjectPath(governanceDir)}\", roadmapId=\"${roadmapId}\")`),
+                nextCallSection(`roadmapContext(projectPath="${toProjectPath(governanceDir)}", roadmapId="${roadmapId}")`),
             ],
         });
         return asText(markdown);
     });
-    server.registerTool("roadmapCreate", {
-        title: "Roadmap Create",
-        description: "Create one roadmap milestone in governance store",
+    server.registerTool('roadmapCreate', {
+        title: 'Roadmap Create',
+        description: 'Create one roadmap milestone in governance store',
         inputSchema: {
             projectPath: z.string(),
             roadmapId: z.string().optional(),
             title: z.string(),
-            status: z.enum(["active", "done"]).optional(),
+            status: z.enum(['active', 'done']).optional(),
             time: z.string().optional(),
         },
     }, async ({ projectPath, roadmapId, title, status, time }) => {
         if (roadmapId && !isValidRoadmapId(roadmapId)) {
             return {
-                ...asText(renderErrorMarkdown("roadmapCreate", `Invalid roadmap ID format: ${roadmapId}`, ["expected format: ROADMAP-0001", "omit roadmapId to auto-generate next ID"], `roadmapCreate(projectPath=\"${projectPath}\", title=\"Define milestone\", time=\"2026-Q2\")`)),
+                ...asText(renderErrorMarkdown('roadmapCreate', `Invalid roadmap ID format: ${roadmapId}`, ['expected format: ROADMAP-1 or ROADMAP-0001', 'omit roadmapId to auto-generate next ID'], `roadmapCreate(projectPath="${projectPath}", title="Define milestone", time="2026-Q2")`)),
                 isError: true,
             };
         }
         const governanceDir = await resolveGovernanceDir(projectPath);
         const normalizedProjectPath = toProjectPath(governanceDir);
         const doc = await loadRoadmapDocument(governanceDir);
+        const { markdownPath: tasksViewPath } = await loadTasksDocument(governanceDir);
         const finalRoadmapId = roadmapId ?? nextRoadmapId(doc.milestones);
         const duplicated = doc.milestones.some((item) => item.id === finalRoadmapId);
         if (duplicated) {
             return {
-                ...asText(renderErrorMarkdown("roadmapCreate", `Roadmap milestone already exists: ${finalRoadmapId}`, ["roadmap IDs must be unique", "use roadmapUpdate for existing milestone"], `roadmapUpdate(projectPath=\"${normalizedProjectPath}\", roadmapId=\"${finalRoadmapId}\", updates={...})`)),
+                ...asText(renderErrorMarkdown('roadmapCreate', `Roadmap milestone already exists: ${finalRoadmapId}`, ['roadmap IDs must be unique', 'use roadmapUpdate for existing milestone'], `roadmapUpdate(projectPath="${normalizedProjectPath}", roadmapId="${finalRoadmapId}", updates={...})`)),
                 isError: true,
             };
         }
         const created = normalizeMilestone({
             id: finalRoadmapId,
             title,
-            status: status ?? "active",
+            status: status ?? 'active',
             time,
             updatedAt: nowIso(),
         });
@@ -299,58 +309,61 @@ export function registerRoadmapTools(server) {
         const { tasks } = await loadTasks(governanceDir);
         const lintSuggestions = collectRoadmapLintSuggestions(refreshed.milestones.map((item) => item.id), tasks);
         const markdown = renderToolResponseMarkdown({
-            toolName: "roadmapCreate",
+            toolName: 'roadmapCreate',
             sections: [
                 summarySection([
                     `- projectPath: ${normalizedProjectPath}`,
                     `- governanceDir: ${governanceDir}`,
+                    `- tasksView: ${tasksViewPath}`,
+                    `- roadmapView: ${refreshed.markdownPath}`,
                     `- roadmapId: ${created.id}`,
                     `- status: ${created.status}`,
                     `- updatedAt: ${created.updatedAt}`,
                 ]),
                 evidenceSection([
-                    "### Created Milestone",
-                    `- ${created.id} | ${created.status} | ${created.title}${created.time ? ` | time=${created.time}` : ""}`,
-                    "",
-                    "### Roadmap Count",
+                    '### Created Milestone',
+                    `- ${created.id} | ${created.status} | ${created.title}${created.time ? ` | time=${created.time}` : ''}`,
+                    '',
+                    '### Roadmap Count',
                     `- total: ${refreshed.milestones.length}`,
                 ]),
                 guidanceSection([
-                    "Milestone created successfully and roadmap.md has been synced.",
-                    "Re-run roadmapContext to verify linked task traceability.",
+                    'Milestone created successfully and roadmap.md has been synced.',
+                    'Re-run roadmapContext to verify linked task traceability.',
                 ]),
                 lintSection(lintSuggestions),
-                nextCallSection(`roadmapContext(projectPath=\"${normalizedProjectPath}\", roadmapId=\"${created.id}\")`),
+                nextCallSection(`roadmapContext(projectPath="${normalizedProjectPath}", roadmapId="${created.id}")`),
             ],
         });
         return asText(markdown);
     });
-    server.registerTool("roadmapUpdate", {
-        title: "Roadmap Update",
-        description: "Update one roadmap milestone fields incrementally in governance store",
+    server.registerTool('roadmapUpdate', {
+        title: 'Roadmap Update',
+        description: 'Update one roadmap milestone fields incrementally in governance store',
         inputSchema: {
             projectPath: z.string(),
             roadmapId: z.string(),
             updates: z.object({
                 title: z.string().optional(),
-                status: z.enum(["active", "done"]).optional(),
+                status: z.enum(['active', 'done']).optional(),
                 time: z.string().optional(),
             }),
         },
     }, async ({ projectPath, roadmapId, updates }) => {
         if (!isValidRoadmapId(roadmapId)) {
             return {
-                ...asText(renderErrorMarkdown("roadmapUpdate", `Invalid roadmap ID format: ${roadmapId}`, ["expected format: ROADMAP-0001", "retry with a valid roadmap ID"], `roadmapUpdate(projectPath="${projectPath}", roadmapId="ROADMAP-0001", updates={...})`)),
+                ...asText(renderErrorMarkdown('roadmapUpdate', `Invalid roadmap ID format: ${roadmapId}`, ['expected format: ROADMAP-1 or ROADMAP-0001', 'retry with a valid roadmap ID'], `roadmapUpdate(projectPath="${projectPath}", roadmapId="ROADMAP-0001", updates={...})`)),
                 isError: true,
             };
         }
         const governanceDir = await resolveGovernanceDir(projectPath);
         const normalizedProjectPath = toProjectPath(governanceDir);
         const doc = await loadRoadmapDocument(governanceDir);
+        const { markdownPath: tasksViewPath } = await loadTasksDocument(governanceDir);
         const existing = doc.milestones.find((item) => item.id === roadmapId);
         if (!existing) {
             return {
-                ...asText(renderErrorMarkdown("roadmapUpdate", `Roadmap milestone not found: ${roadmapId}`, ["run roadmapList to discover existing roadmap IDs", "retry with an existing roadmap ID"], `roadmapList(projectPath="${toProjectPath(governanceDir)}")`)),
+                ...asText(renderErrorMarkdown('roadmapUpdate', `Roadmap milestone not found: ${roadmapId}`, ['run roadmapList to discover existing roadmap IDs', 'retry with an existing roadmap ID'], `roadmapList(projectPath="${toProjectPath(governanceDir)}")`)),
                 isError: true,
             };
         }
@@ -364,26 +377,28 @@ export function registerRoadmapTools(server) {
         await upsertRoadmapInStore(doc.roadmapPath, updated);
         const refreshed = await loadRoadmapDocumentWithOptions(governanceDir, true);
         const markdown = renderToolResponseMarkdown({
-            toolName: "roadmapUpdate",
+            toolName: 'roadmapUpdate',
             sections: [
                 summarySection([
                     `- projectPath: ${normalizedProjectPath}`,
                     `- governanceDir: ${governanceDir}`,
+                    `- tasksView: ${tasksViewPath}`,
+                    `- roadmapView: ${refreshed.markdownPath}`,
                     `- roadmapId: ${roadmapId}`,
                     `- newStatus: ${updated.status}`,
                     `- updatedAt: ${updated.updatedAt}`,
                 ]),
                 evidenceSection([
-                    "### Updated Milestone",
-                    `- ${updated.id} | ${updated.status} | ${updated.title}${updated.time ? ` | time=${updated.time}` : ""}`,
-                    "",
-                    `### Roadmap Count`,
+                    '### Updated Milestone',
+                    `- ${updated.id} | ${updated.status} | ${updated.title}${updated.time ? ` | time=${updated.time}` : ''}`,
+                    '',
+                    '### Roadmap Count',
                     `- total: ${refreshed.milestones.length}`,
                 ]),
                 guidanceSection([
-                    "Milestone updated successfully and roadmap.md has been synced.",
-                    "Re-run roadmapContext to verify linked task traceability.",
-                    ".projitive governance store is source of truth; roadmap.md is a generated view and may be overwritten.",
+                    'Milestone updated successfully and roadmap.md has been synced.',
+                    'Re-run roadmapContext to verify linked task traceability.',
+                    '.projitive governance store is source of truth; roadmap.md is a generated view and may be overwritten.',
                 ]),
                 lintSection([]),
                 nextCallSection(`roadmapContext(projectPath="${toProjectPath(governanceDir)}", roadmapId="${roadmapId}")`),

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

@@ -1,75 +1,83 @@
-import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
-import fs from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-import { isValidRoadmapId, collectRoadmapLintSuggestions, loadRoadmapDocument, renderRoadmapMarkdown, registerRoadmapTools } from "./roadmap.js";
-describe("roadmap module", () => {
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { isValidRoadmapId, collectRoadmapLintSuggestions, loadRoadmapDocument, renderRoadmapMarkdown, registerRoadmapTools } from './roadmap.js';
+describe('roadmap module', () => {
     let tempDir;
     beforeAll(async () => {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "projitive-roadmap-test-"));
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'projitive-roadmap-test-'));
     });
     afterAll(async () => {
         await fs.rm(tempDir, { recursive: true, force: true });
     });
-    describe("isValidRoadmapId", () => {
-        it("should validate correct roadmap IDs", () => {
-            expect(isValidRoadmapId("ROADMAP-0001")).toBe(true);
-            expect(isValidRoadmapId("ROADMAP-1234")).toBe(true);
+    describe('isValidRoadmapId', () => {
+        it('should validate correct roadmap IDs', () => {
+            expect(isValidRoadmapId('ROADMAP-0001')).toBe(true);
+            expect(isValidRoadmapId('ROADMAP-1')).toBe(true);
+            expect(isValidRoadmapId('ROADMAP-1234')).toBe(true);
+            expect(isValidRoadmapId('ROADMAP-12345')).toBe(true);
         });
-        it("should reject invalid roadmap IDs", () => {
-            expect(isValidRoadmapId("roadmap-0001")).toBe(false);
-            expect(isValidRoadmapId("TASK-0001")).toBe(false);
-            expect(isValidRoadmapId("invalid")).toBe(false);
+        it('should reject invalid roadmap IDs', () => {
+            expect(isValidRoadmapId('roadmap-0001')).toBe(false);
+            expect(isValidRoadmapId('TASK-0001')).toBe(false);
+            expect(isValidRoadmapId('invalid')).toBe(false);
         });
     });
-    describe("collectRoadmapLintSuggestions", () => {
-        it("should return lint suggestion for empty roadmap IDs", () => {
+    describe('collectRoadmapLintSuggestions', () => {
+        it('should return lint suggestion for empty roadmap IDs', () => {
             const suggestions = collectRoadmapLintSuggestions([], []);
-            expect(suggestions.some(s => s.includes("IDS_EMPTY"))).toBe(true);
+            expect(suggestions.some(s => s.includes('IDS_EMPTY'))).toBe(true);
         });
-        it("should return lint suggestion for empty tasks", () => {
-            const suggestions = collectRoadmapLintSuggestions(["ROADMAP-0001"], []);
-            expect(suggestions.some(s => s.includes("TASKS_EMPTY"))).toBe(true);
+        it('should return lint suggestion for empty tasks', () => {
+            const suggestions = collectRoadmapLintSuggestions(['ROADMAP-0001'], []);
+            expect(suggestions.some(s => s.includes('TASKS_EMPTY'))).toBe(true);
         });
-        it("should return lint suggestion for tasks without roadmap refs", () => {
+        it('should return lint suggestion for tasks without roadmap refs', () => {
             const tasks = [{
-                    id: "TASK-0001",
-                    title: "Test Task",
-                    status: "TODO",
-                    owner: "ai-copilot",
-                    summary: "Test",
-                    updatedAt: "2026-01-01T00:00:00.000Z",
+                    id: 'TASK-0001',
+                    title: 'Test Task',
+                    status: 'TODO',
+                    owner: 'ai-copilot',
+                    summary: 'Test',
+                    updatedAt: '2026-01-01T00:00:00.000Z',
                     links: [],
                     roadmapRefs: [],
                 }];
-            const suggestions = collectRoadmapLintSuggestions(["ROADMAP-0001"], tasks);
-            expect(suggestions.some(s => s.includes("TASK_REFS_EMPTY"))).toBe(true);
+            const suggestions = collectRoadmapLintSuggestions(['ROADMAP-0001'], tasks);
+            expect(suggestions.some(s => s.includes('TASK_REFS_EMPTY'))).toBe(true);
         });
-        it("loads from governance store and rewrites roadmap markdown view", async () => {
-            const governanceDir = path.join(tempDir, ".projitive-db");
+        it('loads from governance store and rewrites roadmap markdown view', async () => {
+            const governanceDir = path.join(tempDir, '.projitive-db');
             await fs.mkdir(governanceDir, { recursive: true });
-            await fs.writeFile(path.join(governanceDir, ".projitive"), "", "utf-8");
+            await fs.writeFile(path.join(governanceDir, '.projitive'), '', 'utf-8');
             const doc = await loadRoadmapDocument(governanceDir);
-            expect(doc.roadmapPath.endsWith(".projitive")).toBe(true);
-            expect(doc.markdownPath.endsWith("roadmap.md")).toBe(true);
-            const markdown = await fs.readFile(path.join(governanceDir, "roadmap.md"), "utf-8");
-            expect(markdown).toContain("generated from .projitive governance store");
+            expect(doc.roadmapPath.endsWith('.projitive')).toBe(true);
+            expect(doc.markdownPath.endsWith('roadmap.md')).toBe(true);
+            const markdown = await fs.readFile(path.join(governanceDir, 'roadmap.md'), 'utf-8');
+            expect(markdown).toContain('generated from .projitive governance store');
+            expect(markdown).toContain('Author: yinxulai');
+            expect(markdown).toContain('Repository: https://github.com/yinxulai/projitive');
+            expect(markdown).toContain('Do not edit this file manually.');
         });
-        it("renders milestones in newest-first order", () => {
+        it('renders milestones in newest-first order', () => {
             const markdown = renderRoadmapMarkdown([
-                { id: "ROADMAP-0001", title: "Older", status: "active", updatedAt: "2026-01-01T00:00:00.000Z" },
-                { id: "ROADMAP-0002", title: "Newer", status: "done", updatedAt: "2026-02-01T00:00:00.000Z" },
+                { id: 'ROADMAP-0001', title: 'Older', status: 'active', updatedAt: '2026-01-01T00:00:00.000Z' },
+                { id: 'ROADMAP-0002', title: 'Newer', status: 'done', updatedAt: '2026-02-01T00:00:00.000Z' },
             ]);
-            expect(markdown.indexOf("ROADMAP-0002")).toBeLessThan(markdown.indexOf("ROADMAP-0001"));
-            expect(markdown).toContain("[x] ROADMAP-0002");
+            expect(markdown.indexOf('ROADMAP-0002')).toBeLessThan(markdown.indexOf('ROADMAP-0001'));
+            expect(markdown).toContain('[x] ROADMAP-0002');
         });
-        it("registers roadmapCreate tool", () => {
+        it('registers roadmapCreate tool', () => {
             const mockServer = {
-                registerTool: (..._args) => undefined,
+                registerTool: (...args) => {
+                    void args;
+                    return undefined;
+                },
             };
-            const spy = vi.spyOn(mockServer, "registerTool");
+            const spy = vi.spyOn(mockServer, 'registerTool');
             registerRoadmapTools(mockServer);
-            expect(spy.mock.calls.some((call) => call[0] === "roadmapCreate")).toBe(true);
+            expect(spy.mock.calls.some((call) => call[0] === 'roadmapCreate')).toBe(true);
         });
     });
 });