@projitive/mcp 1.0.8 → 1.1.2

package/output/source/projitive.test.js

@@ -1,111 +0,0 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { discoverProjects, hasProjectMarker, initializeProjectStructure, resolveGovernanceDir } from "./projitive.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 });
-    }));
-});
-describe("projitive module", () => {
-    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("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("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("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");
-    });
-});

package/output/source/roadmap.test.js

@@ -1,11 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { collectRoadmapLintSuggestions } from "./roadmap.js";
-import { normalizeTask } from "./tasks.js";
-describe("roadmap lint rendering alignment", () => {
-    it("renders roadmap lint in code-prefixed markdown lines", () => {
-        const lint = collectRoadmapLintSuggestions(["ROADMAP-0001"], [
-            normalizeTask({ id: "TASK-0001", title: "x", status: "TODO", roadmapRefs: [] }),
-        ]);
-        expect(lint.some((line) => line.startsWith("- [ROADMAP_TASK_REFS_EMPTY]"))).toBe(true);
-    });
-});

package/output/source/tasks.test.js

@@ -1,152 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { TASKS_END, TASKS_START, collectTaskLintSuggestions, isValidTaskId, normalizeTask, parseTasksBlock, rankActionableTaskCandidates, resolveNoTaskDiscoveryGuidance, renderTaskSeedTemplate, renderTasksMarkdown, taskPriority, toTaskUpdatedAtMs, validateTransition, } from "./tasks.js";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-function buildCandidate(partial) {
-    const task = normalizeTask({
-        id: partial.id,
-        title: partial.title,
-        status: partial.status,
-        updatedAt: partial.task?.updatedAt ?? "2026-01-01T00:00:00.000Z",
-    });
-    return {
-        governanceDir: partial.governanceDir ?? "/workspace/a",
-        tasksPath: partial.tasksPath ?? "/workspace/a/tasks.md",
-        task,
-        projectScore: partial.projectScore ?? 1,
-        projectLatestUpdatedAt: partial.projectLatestUpdatedAt ?? "2026-01-01T00:00:00.000Z",
-        taskUpdatedAtMs: partial.taskUpdatedAtMs ?? toTaskUpdatedAtMs(task.updatedAt),
-        taskPriority: partial.taskPriority ?? taskPriority(task.status),
-    };
-}
-describe("tasks module", () => {
-    it("parses markdown task block and normalizes task fields", async () => {
-        const markdown = [
-            "# Tasks",
-            TASKS_START,
-            "## TASK-0001 | TODO | hello",
-            "- owner: alice",
-            "- summary: first task",
-            "- updatedAt: 2026-02-17T00:00:00.000Z",
-            "- roadmapRefs: ROADMAP-0001",
-            "- links:",
-            "  - ./designs/example.md",
-            TASKS_END,
-        ].join("\n");
-        const tasks = await parseTasksBlock(markdown);
-        expect(tasks).toHaveLength(1);
-        expect(tasks[0].id).toBe("TASK-0001");
-        expect(tasks[0].status).toBe("TODO");
-        expect(tasks[0].roadmapRefs).toEqual(["ROADMAP-0001"]);
-        expect(tasks[0].links).toEqual(["./designs/example.md"]);
-    });
-    it("renders markdown containing markers", () => {
-        const task = normalizeTask({ id: "TASK-0002", title: "render", status: "IN_PROGRESS" });
-        const markdown = renderTasksMarkdown([task]);
-        expect(markdown.includes(TASKS_START)).toBe(true);
-        expect(markdown.includes(TASKS_END)).toBe(true);
-        expect(markdown.includes("## TASK-0002 | IN_PROGRESS | render")).toBe(true);
-    });
-    it("validates task IDs", () => {
-        expect(isValidTaskId("TASK-0001")).toBe(true);
-        expect(isValidTaskId("TASK-001")).toBe(false);
-    });
-    it("allows and rejects expected transitions", () => {
-        expect(validateTransition("TODO", "IN_PROGRESS")).toBe(true);
-        expect(validateTransition("IN_PROGRESS", "DONE")).toBe(true);
-        expect(validateTransition("DONE", "IN_PROGRESS")).toBe(false);
-    });
-    it("assigns priority for actionable statuses", () => {
-        expect(taskPriority("IN_PROGRESS")).toBe(2);
-        expect(taskPriority("TODO")).toBe(1);
-        expect(taskPriority("BLOCKED")).toBe(0);
-    });
-    it("returns zero timestamp for invalid date", () => {
-        expect(toTaskUpdatedAtMs("invalid")).toBe(0);
-    });
-    it("ranks by project score, then task priority, then recency", () => {
-        const candidates = [
-            buildCandidate({ id: "TASK-0001", title: "A", status: "TODO", projectScore: 2 }),
-            buildCandidate({ id: "TASK-0002", title: "B", status: "IN_PROGRESS", projectScore: 2 }),
-            buildCandidate({ id: "TASK-0003", title: "C", status: "IN_PROGRESS", projectScore: 3 }),
-        ];
-        const ranked = rankActionableTaskCandidates(candidates);
-        expect(ranked[0].task.id).toBe("TASK-0003");
-        expect(ranked[1].task.id).toBe("TASK-0002");
-        expect(ranked[2].task.id).toBe("TASK-0001");
-    });
-    it("renders lint lines with stable code prefix", () => {
-        const task = normalizeTask({
-            id: "TASK-0001",
-            title: "lint",
-            status: "IN_PROGRESS",
-            owner: "",
-            roadmapRefs: [],
-        });
-        const lint = collectTaskLintSuggestions([task]);
-        expect(lint.some((line) => line.startsWith("- [TASK_IN_PROGRESS_OWNER_EMPTY]"))).toBe(true);
-        expect(lint.some((line) => line.startsWith("- [TASK_ROADMAP_REFS_EMPTY]"))).toBe(true);
-    });
-    it("scopes outside-marker lint to provided task IDs", () => {
-        const tasks = [
-            normalizeTask({ id: "TASK-0001", title: "A", status: "TODO", roadmapRefs: ["ROADMAP-0001"] }),
-            normalizeTask({ id: "TASK-0002", title: "B", status: "TODO", roadmapRefs: ["ROADMAP-0001"] }),
-        ];
-        const markdown = [
-            "# Tasks",
-            "TASK-0002 outside",
-            "TASK-0003 outside",
-            TASKS_START,
-            "## TASK-0001 | TODO | A",
-            "- owner: (none)",
-            "- summary: (none)",
-            "- updatedAt: 2026-02-18T00:00:00.000Z",
-            "- roadmapRefs: ROADMAP-0001",
-            "- links:",
-            "  - (none)",
-            "## TASK-0002 | TODO | B",
-            "- owner: (none)",
-            "- summary: (none)",
-            "- updatedAt: 2026-02-18T00:00:00.000Z",
-            "- roadmapRefs: ROADMAP-0001",
-            "- links:",
-            "  - (none)",
-            TASKS_END,
-        ].join("\n");
-        const scoped = collectTaskLintSuggestions(tasks, markdown, new Set(["TASK-0001"]));
-        const scopedOutside = scoped.find((line) => line.includes("TASK IDs found outside marker block"));
-        expect(scopedOutside).toBeUndefined();
-        const all = collectTaskLintSuggestions(tasks, markdown);
-        const allOutside = all.find((line) => line.includes("TASK IDs found outside marker block"));
-        expect(allOutside).toContain("TASK-0002");
-        expect(allOutside).toContain("TASK-0003");
-    });
-    it("renders seed task template with provided roadmap ref", () => {
-        const lines = renderTaskSeedTemplate("ROADMAP-0099");
-        const markdown = lines.join("\n");
-        expect(markdown).toContain("## TASK-0001 | TODO | Define initial executable objective");
-        expect(markdown).toContain("- roadmapRefs: ROADMAP-0099");
-        expect(markdown).toContain("- links:");
-        expect(markdown).not.toContain("- hooks:");
-    });
-    it("uses default no-task guidance when hook file is absent", async () => {
-        const guidance = await resolveNoTaskDiscoveryGuidance("/path/that/does/not/exist");
-        expect(guidance.length).toBeGreaterThan(3);
-        expect(guidance.some((line) => line.includes("TODO/FIXME/HACK"))).toBe(true);
-    });
-    it("uses hook checklist when task_no_actionable hook exists", async () => {
-        const dir = await fs.mkdtemp(path.join(os.tmpdir(), "projitive-mcp-test-"));
-        const hooksDir = path.join(dir, "hooks");
-        await fs.mkdir(hooksDir, { recursive: true });
-        await fs.writeFile(path.join(hooksDir, "task_no_actionable.md"), [
-            "Objective:",
-            "- custom-item-1",
-            "- custom-item-2",
-        ].join("\n"), "utf-8");
-        const guidance = await resolveNoTaskDiscoveryGuidance(dir);
-        expect(guidance).toContain("- custom-item-1");
-        expect(guidance).toContain("- custom-item-2");
-        await fs.rm(dir, { recursive: true, force: true });
-    });
-});