@projitive/mcp 1.0.7 → 1.1.1

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) };
 }
@@ -397,12 +395,11 @@ export function registerProjectTools(server) {
         title: "Project Next",
         description: "Rank actionable projects and return the best execution target",
         inputSchema: {
-            maxDepth: z.number().int().min(0).max(8).optional(),
             limit: z.number().int().min(1).max(50).optional(),
         },
-    }, async ({ maxDepth, limit }) => {
+    }, async ({ limit }) => {
         const root = resolveScanRoot();
-        const depth = resolveScanDepth(maxDepth);
+        const depth = resolveScanDepth();
         const projects = await discoverProjects(root, depth);
         const snapshots = await Promise.all(projects.map(async (governanceDir) => {
             const snapshot = await readTasksSnapshot(governanceDir);

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

@@ -0,0 +1,322 @@
+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 { discoverProjects, hasProjectMarker, initializeProjectStructure, resolveGovernanceDir, resolveScanRoot, resolveScanDepth, toProjectPath, registerProjectTools } from "./project.js";
+const tempPaths = [];
+async function createTempDir() {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "projitive-mcp-test-"));
+    tempPaths.push(dir);
+    return dir;
+}
+afterEach(async () => {
+    await Promise.all(tempPaths.splice(0).map(async (dir) => {
+        await fs.rm(dir, { recursive: true, force: true });
+    }));
+    vi.restoreAllMocks();
+});
+describe("projitive module", () => {
+    describe("hasProjectMarker", () => {
+        it("does not treat marker directory as a valid project marker", async () => {
+            const root = await createTempDir();
+            const dirMarkerPath = path.join(root, ".projitive");
+            await fs.mkdir(dirMarkerPath, { recursive: true });
+            const hasMarker = await hasProjectMarker(root);
+            expect(hasMarker).toBe(false);
+        });
+        it("returns true when .projitive marker file exists", async () => {
+            const root = await createTempDir();
+            const markerPath = path.join(root, ".projitive");
+            await fs.writeFile(markerPath, "", "utf-8");
+            const hasMarker = await hasProjectMarker(root);
+            expect(hasMarker).toBe(true);
+        });
+        it("returns false when .projitive marker file does not exist", async () => {
+            const root = await createTempDir();
+            const hasMarker = await hasProjectMarker(root);
+            expect(hasMarker).toBe(false);
+        });
+        it("handles fs.stat errors gracefully", async () => {
+            const root = await createTempDir();
+            vi.spyOn(fs, "stat").mockRejectedValueOnce(new Error("Permission denied"));
+            const hasMarker = await hasProjectMarker(root);
+            expect(hasMarker).toBe(false);
+        });
+    });
+    describe("resolveGovernanceDir", () => {
+        it("resolves governance dir by walking upwards for .projitive", async () => {
+            const root = await createTempDir();
+            const governanceDir = path.join(root, "repo", "governance");
+            const deepDir = path.join(governanceDir, "nested", "module");
+            await fs.mkdir(deepDir, { recursive: true });
+            await fs.writeFile(path.join(governanceDir, ".projitive"), "", "utf-8");
+            const resolved = await resolveGovernanceDir(deepDir);
+            expect(resolved).toBe(governanceDir);
+        });
+        it("resolves nested default governance dir when input path is project root", async () => {
+            const root = await createTempDir();
+            const projectRoot = path.join(root, "repo");
+            const governanceDir = path.join(projectRoot, ".projitive");
+            await fs.mkdir(governanceDir, { recursive: true });
+            await fs.writeFile(path.join(governanceDir, ".projitive"), "", "utf-8");
+            const resolved = await resolveGovernanceDir(projectRoot);
+            expect(resolved).toBe(governanceDir);
+        });
+        it("resolves nested custom governance dir when input path is project root", async () => {
+            const root = await createTempDir();
+            const projectRoot = path.join(root, "repo");
+            const governanceDir = path.join(projectRoot, "governance");
+            await fs.mkdir(governanceDir, { recursive: true });
+            await fs.writeFile(path.join(governanceDir, ".projitive"), "", "utf-8");
+            const resolved = await resolveGovernanceDir(projectRoot);
+            expect(resolved).toBe(governanceDir);
+        });
+        it("throws error when path not found", async () => {
+            const root = await createTempDir();
+            const nonExistentPath = path.join(root, "nonexistent");
+            await expect(resolveGovernanceDir(nonExistentPath)).rejects.toThrow("Path not found");
+        });
+        it("throws error when no .projitive marker found", async () => {
+            const root = await createTempDir();
+            const deepDir = path.join(root, "a", "b", "c");
+            await fs.mkdir(deepDir, { recursive: true });
+            await expect(resolveGovernanceDir(deepDir)).rejects.toThrow("No .projitive marker found");
+        });
+        it("prefers default .projitive directory when multiple governance roots found as children", async () => {
+            const root = await createTempDir();
+            const childDir = path.join(root, "child");
+            const governance1 = path.join(childDir, ".projitive");
+            const governance2 = path.join(childDir, "governance");
+            await fs.mkdir(governance1, { recursive: true });
+            await fs.mkdir(governance2, { recursive: true });
+            await fs.writeFile(path.join(governance1, ".projitive"), "", "utf-8");
+            await fs.writeFile(path.join(governance2, ".projitive"), "", "utf-8");
+            const resolved = await resolveGovernanceDir(childDir);
+            expect(resolved).toBe(governance1); // Should prefer default .projitive
+        });
+        it("resolves file path by using its directory", async () => {
+            const root = await createTempDir();
+            const governanceDir = path.join(root, ".projitive");
+            const filePath = path.join(governanceDir, "tasks.md");
+            await fs.mkdir(governanceDir, { recursive: true });
+            await fs.writeFile(path.join(governanceDir, ".projitive"), "", "utf-8");
+            await fs.writeFile(filePath, "# Tasks", "utf-8");
+            const resolved = await resolveGovernanceDir(filePath);
+            expect(resolved).toBe(governanceDir);
+        });
+    });
+    describe("discoverProjects", () => {
+        it("discovers projects by marker file", async () => {
+            const root = await createTempDir();
+            const p1 = path.join(root, "a");
+            const p2 = path.join(root, "b", "c");
+            await fs.mkdir(p1, { recursive: true });
+            await fs.mkdir(p2, { recursive: true });
+            await fs.writeFile(path.join(p1, ".projitive"), "", "utf-8");
+            await fs.writeFile(path.join(p2, ".projitive"), "", "utf-8");
+            const projects = await discoverProjects(root, 4);
+            expect(projects).toContain(p1);
+            expect(projects).toContain(p2);
+        });
+        it("discovers nested default governance directory under project root", async () => {
+            const root = await createTempDir();
+            const projectRoot = path.join(root, "app");
+            const governanceDir = path.join(projectRoot, ".projitive");
+            await fs.mkdir(governanceDir, { recursive: true });
+            await fs.writeFile(path.join(governanceDir, ".projitive"), "", "utf-8");
+            const projects = await discoverProjects(root, 3);
+            expect(projects).toContain(governanceDir);
+        });
+        it("discovers nested custom governance directory under project root", async () => {
+            const root = await createTempDir();
+            const projectRoot = path.join(root, "app");
+            const governanceDir = path.join(projectRoot, "governance");
+            await fs.mkdir(governanceDir, { recursive: true });
+            await fs.writeFile(path.join(governanceDir, ".projitive"), "", "utf-8");
+            const projects = await discoverProjects(root, 3);
+            expect(projects).toContain(governanceDir);
+        });
+        it("respects maxDepth limit", async () => {
+            const root = await createTempDir();
+            const shallow = path.join(root, "shallow");
+            const deep = path.join(root, "level1", "level2", "level3", "level4", "deep");
+            await fs.mkdir(shallow, { recursive: true });
+            await fs.mkdir(deep, { recursive: true });
+            await fs.writeFile(path.join(shallow, ".projitive"), "", "utf-8");
+            await fs.writeFile(path.join(deep, ".projitive"), "", "utf-8");
+            const projects = await discoverProjects(root, 3);
+            expect(projects).toContain(shallow);
+            expect(projects).not.toContain(deep);
+        });
+        it("ignores common ignore directories", async () => {
+            const root = await createTempDir();
+            const nodeModulesProject = path.join(root, "node_modules", "project");
+            const gitProject = path.join(root, ".git", "project");
+            const validProject = path.join(root, "valid");
+            await fs.mkdir(nodeModulesProject, { recursive: true });
+            await fs.mkdir(gitProject, { recursive: true });
+            await fs.mkdir(validProject, { recursive: true });
+            await fs.writeFile(path.join(nodeModulesProject, ".projitive"), "", "utf-8");
+            await fs.writeFile(path.join(gitProject, ".projitive"), "", "utf-8");
+            await fs.writeFile(path.join(validProject, ".projitive"), "", "utf-8");
+            const projects = await discoverProjects(root, 3);
+            expect(projects).toContain(validProject);
+            expect(projects).not.toContain(nodeModulesProject);
+            expect(projects).not.toContain(gitProject);
+        });
+        it("returns empty array when no projects found", async () => {
+            const root = await createTempDir();
+            const projects = await discoverProjects(root, 3);
+            expect(projects).toEqual([]);
+        });
+        it("returns unique and sorted results", async () => {
+            const root = await createTempDir();
+            const projectB = path.join(root, "b");
+            const projectA = path.join(root, "a");
+            await fs.mkdir(projectB, { recursive: true });
+            await fs.mkdir(projectA, { recursive: true });
+            await fs.writeFile(path.join(projectB, ".projitive"), "", "utf-8");
+            await fs.writeFile(path.join(projectA, ".projitive"), "", "utf-8");
+            const projects = await discoverProjects(root, 3);
+            expect(projects).toEqual([projectA, projectB]);
+        });
+        it("handles fs.readdir errors gracefully", async () => {
+            const root = await createTempDir();
+            vi.spyOn(fs, "readdir").mockRejectedValueOnce(new Error("Permission denied"));
+            const projects = await discoverProjects(root, 3);
+            expect(projects).toEqual([]);
+        });
+    });
+    describe("initializeProjectStructure", () => {
+        it("initializes governance structure under default .projitive directory", async () => {
+            const root = await createTempDir();
+            const initialized = await initializeProjectStructure(root);
+            expect(initialized.governanceDir).toBe(path.join(root, ".projitive"));
+            const expectedPaths = [
+                path.join(root, ".projitive", ".projitive"),
+                path.join(root, ".projitive", "README.md"),
+                path.join(root, ".projitive", "roadmap.md"),
+                path.join(root, ".projitive", "tasks.md"),
+                path.join(root, ".projitive", "hooks", "task_no_actionable.md"),
+                path.join(root, ".projitive", "designs"),
+                path.join(root, ".projitive", "reports"),
+                path.join(root, ".projitive", "hooks"),
+            ];
+            await Promise.all(expectedPaths.map(async (targetPath) => {
+                await expect(fs.access(targetPath)).resolves.toBeUndefined();
+            }));
+        });
+        it("overwrites template files when force is enabled", async () => {
+            const root = await createTempDir();
+            const governanceDir = path.join(root, ".projitive");
+            const readmePath = path.join(governanceDir, "README.md");
+            await initializeProjectStructure(root);
+            await fs.writeFile(readmePath, "custom-content", "utf-8");
+            const initialized = await initializeProjectStructure(root, ".projitive", true);
+            const readmeContent = await fs.readFile(readmePath, "utf-8");
+            expect(readmeContent).toContain("Projitive Governance Workspace");
+            expect(initialized.files.find((item) => item.path === readmePath)?.action).toBe("updated");
+        });
+        it("uses custom governance directory when specified", async () => {
+            const root = await createTempDir();
+            const customDir = "my-governance";
+            const initialized = await initializeProjectStructure(root, customDir);
+            expect(initialized.governanceDir).toBe(path.join(root, customDir));
+        });
+        it("throws error when project path not found", async () => {
+            const root = await createTempDir();
+            const nonExistentPath = path.join(root, "nonexistent");
+            await expect(initializeProjectStructure(nonExistentPath)).rejects.toThrow("Path not found");
+        });
+        it("throws error when project path is not a directory", async () => {
+            const root = await createTempDir();
+            const filePath = path.join(root, "file.txt");
+            await fs.writeFile(filePath, "content", "utf-8");
+            await expect(initializeProjectStructure(filePath)).rejects.toThrow("projectPath must be a directory");
+        });
+        it("creates governance structure with default name when invalid names are provided", async () => {
+            const root = await createTempDir();
+            // When governanceDir is invalid, it should fall back to default
+            // Note: normalizeGovernanceDirName is not exported, so we test initialization behavior
+            const initialized = await initializeProjectStructure(root);
+            expect(initialized.governanceDir).toBe(path.join(root, ".projitive"));
+        });
+        it("skips existing files when force is disabled", async () => {
+            const root = await createTempDir();
+            const governanceDir = path.join(root, ".projitive");
+            const readmePath = path.join(governanceDir, "README.md");
+            await initializeProjectStructure(root);
+            await fs.writeFile(readmePath, "custom-content", "utf-8");
+            const initialized = await initializeProjectStructure(root, ".projitive", false);
+            const readmeContent = await fs.readFile(readmePath, "utf-8");
+            expect(readmeContent).toBe("custom-content");
+            expect(initialized.files.find((item) => item.path === readmePath)?.action).toBe("skipped");
+        });
+        it("creates all required subdirectories", async () => {
+            const root = await createTempDir();
+            const initialized = await initializeProjectStructure(root);
+            expect(initialized.directories.some(d => d.path.includes("designs"))).toBe(true);
+            expect(initialized.directories.some(d => d.path.includes("reports"))).toBe(true);
+            expect(initialized.directories.some(d => d.path.includes("hooks"))).toBe(true);
+        });
+    });
+    describe("utility functions", () => {
+        describe("toProjectPath", () => {
+            it("returns parent directory of governance dir", () => {
+                expect(toProjectPath("/path/to/project/.projitive")).toBe("/path/to/project");
+                expect(toProjectPath("/a/b/c")).toBe("/a/b");
+            });
+        });
+        describe("resolveScanRoot", () => {
+            it("uses environment variable when no input path", () => {
+                vi.stubEnv("PROJITIVE_SCAN_ROOT_PATH", "/test/root");
+                expect(resolveScanRoot()).toBe("/test/root");
+                vi.unstubAllEnvs();
+            });
+            it("uses input path when provided", () => {
+                vi.stubEnv("PROJITIVE_SCAN_ROOT_PATH", "/test/root");
+                expect(resolveScanRoot("/custom/path")).toBe("/custom/path");
+                vi.unstubAllEnvs();
+            });
+            it("throws error when required environment variable missing", () => {
+                vi.unstubAllEnvs();
+                expect(() => resolveScanRoot()).toThrow("Missing required environment variable: PROJITIVE_SCAN_ROOT_PATH");
+            });
+        });
+        describe("resolveScanDepth", () => {
+            it("uses environment variable when no input depth", () => {
+                vi.stubEnv("PROJITIVE_SCAN_ROOT_PATH", "/test/root");
+                vi.stubEnv("PROJITIVE_SCAN_MAX_DEPTH", "5");
+                expect(resolveScanDepth()).toBe(5);
+                vi.unstubAllEnvs();
+            });
+            it("uses input depth when provided", () => {
+                vi.stubEnv("PROJITIVE_SCAN_ROOT_PATH", "/test/root");
+                vi.stubEnv("PROJITIVE_SCAN_MAX_DEPTH", "5");
+                expect(resolveScanDepth(3)).toBe(3);
+                vi.unstubAllEnvs();
+            });
+            it("clamps depth to MAX_SCAN_DEPTH", () => {
+                vi.stubEnv("PROJITIVE_SCAN_ROOT_PATH", "/test/root");
+                vi.stubEnv("PROJITIVE_SCAN_MAX_DEPTH", "10");
+                expect(resolveScanDepth()).toBe(8);
+                vi.unstubAllEnvs();
+            });
+            it("throws error for invalid depth configuration", () => {
+                vi.stubEnv("PROJITIVE_SCAN_ROOT_PATH", "/test/root");
+                vi.stubEnv("PROJITIVE_SCAN_MAX_DEPTH", "not-a-number");
+                expect(() => resolveScanDepth()).toThrow("Invalid PROJITIVE_SCAN_MAX_DEPTH");
+                vi.unstubAllEnvs();
+            });
+        });
+    });
+    describe("registerProjectTools", () => {
+        it("registers project tools without throwing", () => {
+            const mockServer = {
+                registerTool: vi.fn(),
+            };
+            expect(() => registerProjectTools(mockServer)).not.toThrow();
+            expect(mockServer.registerTool).toHaveBeenCalled();
+        });
+    });
+});

package/output/source/{roadmap.js → tools/roadmap.js}

@@ -1,13 +1,10 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
-import { candidateFilesFromArtifacts } from "./helpers/artifacts/index.js";
-import { discoverGovernanceArtifacts } from "./helpers/files/index.js";
-import { ROADMAP_LINT_CODES, renderLintSuggestions } from "./helpers/linter/index.js";
-import { findTextReferences } from "./helpers/markdown/index.js";
-import { asText, evidenceSection, guidanceSection, lintSection, nextCallSection, renderErrorMarkdown, renderToolResponseMarkdown, summarySection, } from "./helpers/response/index.js";
-import { resolveGovernanceDir, toProjectPath } from "./projitive.js";
-import { loadTasks } from "./tasks.js";
+import { candidateFilesFromArtifacts, discoverGovernanceArtifacts, ROADMAP_LINT_CODES, renderLintSuggestions, findTextReferences } 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}$/;
 function collectRoadmapLintSuggestionItems(roadmapIds, tasks) {
     const suggestions = [];

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

@@ -0,0 +1,103 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { isValidRoadmapId, collectRoadmapLintSuggestions } from "./roadmap.js";
+describe("roadmap module", () => {
+    let tempDir;
+    beforeAll(async () => {
+        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);
+            expect(isValidRoadmapId("ROADMAP-9999")).toBe(true);
+        });
+        it("should reject invalid roadmap IDs", () => {
+            expect(isValidRoadmapId("roadmap-0001")).toBe(false);
+            expect(isValidRoadmapId("ROADMAP-001")).toBe(false);
+            expect(isValidRoadmapId("ROADMAP-00001")).toBe(false);
+            expect(isValidRoadmapId("TASK-0001")).toBe(false);
+            expect(isValidRoadmapId("")).toBe(false);
+            expect(isValidRoadmapId("invalid")).toBe(false);
+        });
+    });
+    describe("collectRoadmapLintSuggestions", () => {
+        it("should return lint suggestion for empty roadmap IDs", () => {
+            const suggestions = collectRoadmapLintSuggestions([], []);
+            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 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",
+                    links: [],
+                    roadmapRefs: [],
+                },
+            ];
+            const suggestions = collectRoadmapLintSuggestions(["ROADMAP-0001"], tasks);
+            expect(suggestions.some(s => s.includes("TASK_REFS_EMPTY"))).toBe(true);
+        });
+        it("should return lint suggestion for unknown roadmap refs", () => {
+            const tasks = [
+                {
+                    id: "TASK-0001",
+                    title: "Test Task",
+                    status: "TODO",
+                    owner: "ai-copilot",
+                    summary: "Test",
+                    updatedAt: "2026-01-01T00:00:00.000Z",
+                    links: [],
+                    roadmapRefs: ["ROADMAP-9999"],
+                },
+            ];
+            const suggestions = collectRoadmapLintSuggestions(["ROADMAP-0001"], tasks);
+            expect(suggestions.some(s => s.includes("UNKNOWN_REFS"))).toBe(true);
+        });
+        it("should return lint suggestion for roadmaps with no linked tasks", () => {
+            const tasks = [
+                {
+                    id: "TASK-0001",
+                    title: "Test Task",
+                    status: "TODO",
+                    owner: "ai-copilot",
+                    summary: "Test",
+                    updatedAt: "2026-01-01T00:00:00.000Z",
+                    links: [],
+                    roadmapRefs: ["ROADMAP-0001"],
+                },
+            ];
+            const suggestions = collectRoadmapLintSuggestions(["ROADMAP-0001", "ROADMAP-0002"], tasks);
+            expect(suggestions.some(s => s.includes("ZERO_LINKED_TASKS"))).toBe(true);
+        });
+        it("should return no lint suggestions for valid setup", () => {
+            const tasks = [
+                {
+                    id: "TASK-0001",
+                    title: "Test Task",
+                    status: "TODO",
+                    owner: "ai-copilot",
+                    summary: "Test",
+                    updatedAt: "2026-01-01T00:00:00.000Z",
+                    links: [],
+                    roadmapRefs: ["ROADMAP-0001"],
+                },
+            ];
+            const suggestions = collectRoadmapLintSuggestions(["ROADMAP-0001"], tasks);
+            expect(suggestions.length).toBe(0);
+        });
+    });
+});