@projitive/mcp 1.0.4 → 1.0.6

package/output/source/index.js

@@ -10,6 +10,7 @@ import packageJson from "../package.json" with { type: "json" };
 import { registerProjectTools } from "./projitive.js";
 import { registerTaskTools } from "./tasks.js";
 import { registerRoadmapTools } from "./roadmap.js";
+import { registerDesignContextResources, registerDesignContextPrompts } from "./design-context.js";
 const PROJITIVE_SPEC_VERSION = "1.0.0";
 const currentFilePath = fileURLToPath(import.meta.url);
 const sourceDir = path.dirname(currentFilePath);
@@ -43,23 +44,24 @@ function renderMethodCatalogMarkdown() {
     return [
         "# MCP Method Catalog",
         "",
-        "## Core Pattern",
-        "- Prefer List/Context for primary discovery/detail flows.",
-        "- Use Next/Scan/Locate for acceleration and bootstrapping.",
+        "## Start Here",
+        "- Unknown project path: `projectScan` -> `projectLocate` -> `projectContext` -> `taskNext`.",
+        "- Known project path: `projectContext` -> `taskNext` (or `taskList`) -> `taskContext`.",
+        "- Need to bootstrap governance: call `projectInit(projectPath=\"<project-dir>\")` only when `.projitive` is missing.",
         "",
         "## Methods",
-        "| Group | Method | Role |",
-        "|---|---|---|",
-        "| Project | projectInit | initialize governance directory structure |",
-        "| Project | projectScan | discover governance projects by marker |",
-        "| Project | projectNext | rank actionable projects |",
-        "| Project | projectLocate | resolve nearest governance root |",
-        "| Project | projectContext | summarize project governance context |",
-        "| Task | taskList | list tasks with optional filters |",
-        "| Task | taskNext | select top actionable task |",
-        "| Task | taskContext | inspect one task with references |",
-        "| Roadmap | roadmapList | list roadmap IDs and linked tasks |",
-        "| Roadmap | roadmapContext | inspect one roadmap with references |",
+        "| Order | Group | Method | Agent Use |",
+        "|---|---|---|---|",
+        "| 1 | Project | projectScan | discover governance roots when project is unknown |",
+        "| 2 | Project | projectLocate | lock nearest governance root from any path |",
+        "| 3 | Project | projectContext | load project summary before task decisions |",
+        "| 4 | Task | taskNext | auto-pick highest-priority actionable task |",
+        "| 5 | Task | taskList | list/filter tasks for manual selection |",
+        "| 6 | Task | taskContext | inspect one task with evidence and read order |",
+        "| 7 | Roadmap | roadmapList | inspect roadmap-task linkage |",
+        "| 8 | Roadmap | roadmapContext | inspect one roadmap with references |",
+        "| 9 | Project | projectNext | rank actionable projects across workspace |",
+        "| 10 | Project | projectInit | bootstrap governance files if missing |"
     ].join("\n");
 }
 function registerGovernanceResources() {
@@ -128,23 +130,28 @@ function asUserPrompt(text) {
 function registerGovernancePrompts() {
     server.registerPrompt("executeTaskWorkflow", {
         title: "Execute Task Workflow",
-        description: "Guide an agent through taskNext -> taskContext -> artifact update -> verification",
+        description: "Primary execution prompt: select one task, execute, and verify evidence consistency",
         argsSchema: {
-            rootPath: z.string().optional(),
             projectPath: z.string().optional(),
             taskId: z.string().optional(),
         },
-    }, async ({ rootPath, projectPath, taskId }) => {
+    }, async ({ projectPath, taskId }) => {
+        const taskEntry = taskId && projectPath
+            ? `1) Run taskContext(projectPath=\"${projectPath}\", taskId=\"${taskId}\").`
+            : "1) Run taskNext().";
         const text = [
-            "You are executing Projitive governance workflow.",
+            "You are executing Projitive governance workflow in agent-first mode.",
             "",
-            "Execution order:",
-            taskId && projectPath
-                ? `1) Run taskContext(projectPath=\"${projectPath}\", taskId=\"${taskId}\").`
-                : `1) Run taskNext(${rootPath ? `rootPath=\"${rootPath}\"` : ""}).`,
-            "2) Read Suggested Read Order and collect blocking gaps.",
-            "3) Update markdown artifacts only (tasks/designs/reports/roadmap as needed).",
-            "4) Re-run taskContext for the selected task and verify references are consistent.",
+            "Fast path:",
+            taskEntry,
+            "2) Follow Suggested Read Order and identify execution blockers.",
+            "3) Edit governance markdown only (tasks/designs/reports/roadmap).",
+            "4) Re-run taskContext for the selected task and verify references.",
+            "",
+            "Fallbacks:",
+            "- If `.projitive` is missing for a known project, run `projectInit(projectPath=\"<project-dir>\")` first.",
+            "- If taskNext returns no actionable task, follow its no-task checklist and create 1-3 TODO tasks.",
+            "- If project is unknown, run projectScan -> projectLocate -> projectContext before task tools.",
             "",
             "Hard rules:",
             "- Keep TASK/ROADMAP IDs immutable.",
@@ -155,7 +162,7 @@ function registerGovernancePrompts() {
     });
     server.registerPrompt("updateTaskStatusWithEvidence", {
         title: "Update Task Status With Evidence",
-        description: "Template for safe task status transitions and evidence alignment",
+        description: "Safe status transition playbook with mandatory evidence backfill",
         argsSchema: {
             projectPath: z.string(),
             taskId: z.string(),
@@ -163,13 +170,14 @@ function registerGovernancePrompts() {
         },
     }, async ({ projectPath, taskId, targetStatus }) => {
         const text = [
-            "Perform a safe task status update using Projitive rules.",
+            "Perform a safe task status update with evidence alignment.",
             "",
             `1) Run taskContext(projectPath=\"${projectPath}\", taskId=\"${taskId}\").`,
-            `2) Plan status transition toward ${targetStatus}.`,
+            `2) Confirm transition to ${targetStatus} is valid.`,
             "3) Update tasks.md status and updatedAt.",
             "4) Add or update a report under reports/ with concrete evidence.",
             "5) Re-run taskContext and confirm status/evidence/reference consistency.",
+            "6) If lint remains, fix and re-run taskContext once more.",
             "",
             "Checklist:",
             "- Transition is valid per status machine.",
@@ -180,29 +188,30 @@ function registerGovernancePrompts() {
     });
     server.registerPrompt("triageProjectGovernance", {
         title: "Triage Project Governance",
-        description: "Template to inspect a project and select next actionable governance task",
-        argsSchema: {
-            rootPath: z.string().optional(),
-        },
-    }, async ({ rootPath }) => {
+        description: "Discovery-first triage prompt to pick project and next executable task",
+        argsSchema: {},
+    }, async () => {
         const text = [
-            "Triage governance across projects and pick execution target.",
+            "Triage governance and pick one execution target quickly.",
             "",
-            `1) Run projectNext(${rootPath ? `rootPath=\"${rootPath}\"` : ""}).`,
-            "2) Select top ranked project.",
+            "0) If known project has no `.projitive`, run projectInit(projectPath=<project-dir>) first.",
+            "1) If project path is unknown, run projectScan() and pick one discovered project.",
+            "2) Run projectNext() to rank projects.",
             "3) Run projectContext(projectPath=<selectedProject>).",
-            "4) Run taskList(projectPath=<selectedProject>, status=IN_PROGRESS).",
-            "5) If none, run taskNext to select TODO/IN_PROGRESS candidate.",
-            "6) Continue with taskContext for detailed evidence mapping.",
+            "4) Run taskNext() for best actionable task.",
+            "5) If manual filtering is needed, run taskList(projectPath=<selectedProject>, status=IN_PROGRESS).",
+            "6) Continue with taskContext(projectPath=<selectedProject>, taskId=<selectedTaskId>).",
         ].join("\n");
         return asUserPrompt(text);
     });
 }
-registerTaskTools(server);
 registerProjectTools(server);
+registerTaskTools(server);
 registerRoadmapTools(server);
 registerGovernanceResources();
 registerGovernancePrompts();
+registerDesignContextResources(server);
+registerDesignContextPrompts(server);
 async function main() {
     console.error(`[projitive-mcp] starting server`);
     console.error(`[projitive-mcp] version=${MCP_RUNTIME_VERSION} spec=${PROJITIVE_SPEC_VERSION} transport=stdio pid=${process.pid}`);

package/output/source/projitive.js

@@ -274,9 +274,9 @@ export async function initializeProjectStructure(inputPath, governanceDir, force
 export function registerProjectTools(server) {
     server.registerTool("projectInit", {
         title: "Project Init",
-        description: "Initialize Projitive governance directory structure manually (default .projitive)",
+        description: "Bootstrap governance files when a project has no .projitive yet",
         inputSchema: {
-            projectPath: z.string().optional(),
+            projectPath: z.string(),
             governanceDir: z.string().optional(),
             force: z.boolean().optional(),
         },
@@ -320,7 +320,7 @@ export function registerProjectTools(server) {
     });
     server.registerTool("projectScan", {
         title: "Project Scan",
-        description: "Scan filesystem and discover project governance roots marked by .projitive",
+        description: "Start here when project path is unknown; discover all governance roots",
         inputSchema: {},
     }, async () => {
         const root = resolveScanRoot();
@@ -354,14 +354,13 @@ export function registerProjectTools(server) {
     });
     server.registerTool("projectNext", {
         title: "Project Next",
-        description: "Directly list recently actionable projects for immediate agent progression",
+        description: "Rank actionable projects and return the best execution target",
         inputSchema: {
-            rootPath: z.string().optional(),
             maxDepth: z.number().int().min(0).max(8).optional(),
             limit: z.number().int().min(1).max(50).optional(),
         },
-    }, async ({ rootPath, maxDepth, limit }) => {
-        const root = resolveScanRoot(rootPath);
+    }, async ({ maxDepth, limit }) => {
+        const root = resolveScanRoot();
         const depth = resolveScanDepth(maxDepth);
         const projects = await discoverProjects(root, depth);
         const snapshots = await Promise.all(projects.map(async (governanceDir) => {
@@ -423,7 +422,7 @@ export function registerProjectTools(server) {
     });
     server.registerTool("projectLocate", {
         title: "Project Locate",
-        description: "Resolve current project governance root from an in-project path by finding the nearest .projitive marker",
+        description: "Resolve the nearest governance root from any in-project path",
         inputSchema: {
             inputPath: z.string(),
         },
@@ -448,7 +447,7 @@ export function registerProjectTools(server) {
     });
     server.registerTool("projectContext", {
         title: "Project Context",
-        description: "Summarize project governance context for task execution planning",
+        description: "Get project-level summary before selecting or executing a task",
         inputSchema: {
             projectPath: z.string(),
         },

package/output/source/roadmap.js

@@ -73,7 +73,7 @@ async function readRoadmapIds(governanceDir) {
 export function registerRoadmapTools(server) {
     server.registerTool("roadmapList", {
         title: "Roadmap List",
-        description: "List roadmap IDs and related tasks for project planning",
+        description: "List roadmap IDs and task linkage for planning or traceability",
         inputSchema: {
             projectPath: z.string(),
         },
@@ -107,7 +107,7 @@ export function registerRoadmapTools(server) {
     });
     server.registerTool("roadmapContext", {
         title: "Roadmap Context",
-        description: "Get one roadmap with related tasks, references, and execution context",
+        description: "Inspect one roadmap with linked tasks and reference locations",
         inputSchema: {
             projectPath: z.string(),
             roadmapId: z.string(),

package/output/source/tasks.js

@@ -496,7 +496,7 @@ export function validateTransition(from, to) {
 export function registerTaskTools(server) {
     server.registerTool("taskList", {
         title: "Task List",
-        description: "List project tasks with optional status filter for agent planning",
+        description: "List tasks for a known project and optionally filter by status",
         inputSchema: {
             projectPath: z.string(),
             status: z.enum(["TODO", "IN_PROGRESS", "BLOCKED", "DONE"]).optional(),
@@ -543,14 +543,13 @@ export function registerTaskTools(server) {
     });
     server.registerTool("taskNext", {
         title: "Task Next",
-        description: "One-step discover and select the most actionable task with evidence and start guidance",
+        description: "Start here to auto-select the highest-priority actionable task",
         inputSchema: {
-            rootPath: z.string().optional(),
             maxDepth: z.number().int().min(0).max(8).optional(),
             topCandidates: z.number().int().min(1).max(20).optional(),
         },
-    }, async ({ rootPath, maxDepth, topCandidates }) => {
-        const root = resolveScanRoot(rootPath);
+    }, async ({ maxDepth, topCandidates }) => {
+        const root = resolveScanRoot();
         const depth = resolveScanDepth(maxDepth);
         const projects = await discoverProjects(root, depth);
         const rankedCandidates = rankActionableTaskCandidates(await readActionableTaskCandidates(projects));
@@ -680,7 +679,7 @@ export function registerTaskTools(server) {
     });
     server.registerTool("taskContext", {
         title: "Task Context",
-        description: "Get one task with detail, evidence locations, and execution guidance",
+        description: "Get deep context, evidence links, and read order for one task",
         inputSchema: {
             projectPath: z.string(),
             taskId: z.string(),

package/package.json

@@ -1,22 +1,21 @@
 {
   "name": "@projitive/mcp",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Projitive MCP Server for project and task discovery/update",
   "license": "ISC",
   "author": "",
   "type": "module",
   "bin": {
-    "mcp": "output/index.js"
+    "mcp": "output/source/index.js"
   },
-  "main": "./output/index.js",
-  "types": "./output/index.d.ts",
+  "main": "./output/source/index.js",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
     "test": "vitest run",
     "lint": "tsc -p tsconfig.json --noEmit",
-    "build": "tsc -p tsconfig.json",
+    "build": "rm -rf output && tsc -p tsconfig.json",
     "prepublishOnly": "npm run build",
     "dev": "tsc -p tsconfig.json --watch"
   },

package/output/designs.js

@@ -1,38 +0,0 @@
-import { isValidRoadmapId } from "./roadmap.js";
-import { isValidTaskId } from "./tasks.js";
-export function parseDesignMetadata(markdown) {
-    const lines = markdown.split(/\r?\n/);
-    const metadata = {};
-    for (const line of lines) {
-        const [rawKey, ...rawValue] = line.split(":");
-        if (!rawKey || rawValue.length === 0) {
-            continue;
-        }
-        const key = rawKey.trim().toLowerCase();
-        const value = rawValue.join(":").trim();
-        if (key === "task")
-            metadata.task = value;
-        if (key === "roadmap")
-            metadata.roadmap = value;
-        if (key === "owner")
-            metadata.owner = value;
-        if (key === "status")
-            metadata.status = value;
-        if (key === "last updated")
-            metadata.lastUpdated = value;
-    }
-    return metadata;
-}
-export function validateDesignMetadata(metadata) {
-    const errors = [];
-    if (!metadata.task) {
-        errors.push("Missing Task metadata");
-    }
-    else if (!isValidTaskId(metadata.task)) {
-        errors.push(`Invalid Task metadata format: ${metadata.task}`);
-    }
-    if (metadata.roadmap && !isValidRoadmapId(metadata.roadmap)) {
-        errors.push(`Invalid Roadmap metadata format: ${metadata.roadmap}`);
-    }
-    return { ok: errors.length === 0, errors };
-}

package/output/helpers/artifacts/artifacts.js

@@ -1,10 +0,0 @@
-export function candidateFilesFromArtifacts(artifacts) {
-    return artifacts
-        .filter((item) => item.exists)
-        .flatMap((item) => {
-        if (item.kind === "file") {
-            return [item.path];
-        }
-        return (item.markdownFiles ?? []).map((entry) => entry.path);
-    });
-}

package/output/helpers/artifacts/artifacts.test.js

@@ -1,18 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { candidateFilesFromArtifacts } from "./artifacts.js";
-describe("candidateFilesFromArtifacts", () => {
-    it("collects existing file artifacts and markdown files from existing directories", () => {
-        const candidates = candidateFilesFromArtifacts([
-            { name: "README.md", kind: "file", path: "/a/README.md", exists: true, lineCount: 3 },
-            { name: "tasks.md", kind: "file", path: "/a/tasks.md", exists: false },
-            {
-                name: "designs",
-                kind: "directory",
-                path: "/a/designs",
-                exists: true,
-                markdownFiles: [{ path: "/a/designs/d1.md", lineCount: 10 }],
-            },
-        ]);
-        expect(candidates).toEqual(["/a/README.md", "/a/designs/d1.md"]);
-    });
-});

package/output/helpers/artifacts/index.js

@@ -1 +0,0 @@
-export * from "./artifacts.js";

package/output/helpers/catch/catch.js

@@ -1,48 +0,0 @@
-// 辅助函数：检查是否为 PromiseLike
-function isPromiseLike(value) {
-    return value != null && typeof value === 'object' && 'then' in value && typeof value.then === 'function';
-}
-/**
- * 构造成功结果对象
- * isError 始终返回 false
- */
-function createSuccess(value) {
-    return {
-        value,
-        error: undefined,
-        isError() { return false; }
-    };
-}
-/**
- * 构造失败结果对象
- * isError 始终返回 true
- */
-function createFailure(error) {
-    return {
-        error,
-        value: undefined,
-        isError() { return true; }
-    };
-}
-export async function catchIt(input) {
-    try {
-        if (isPromiseLike(input)) {
-            const result = await Promise.resolve(input);
-            return createSuccess(result);
-        }
-        else if (typeof input === 'function') {
-            const result = input();
-            if (isPromiseLike(result)) {
-                return catchIt(result);
-            }
-            else {
-                return createSuccess(result);
-            }
-        }
-    }
-    catch (error) {
-        return createFailure(error);
-    }
-    // 理论上不会到达这里，兜底类型安全
-    return createFailure(new Error('Unexpected input type'));
-}

package/output/helpers/catch/catch.test.js

@@ -1,43 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { catchIt } from './catch.js';
-describe('catchIt', () => {
-    it('同步函数返回值应为 value，error 为 undefined，isError 为 false', async () => {
-        const result = await catchIt(() => 123);
-        expect(result.value).toBe(123);
-        expect(result.error).toBeUndefined();
-        expect(result.isError()).toBe(false);
-    });
-    it('异步函数返回值应为 value，error 为 undefined，isError 为 false', async () => {
-        const result = await catchIt(async () => 456);
-        expect(result.value).toBe(456);
-        expect(result.error).toBeUndefined();
-        expect(result.isError()).toBe(false);
-    });
-    it('同步抛出异常时应返回 error，value 为 undefined，isError 为 true', async () => {
-        const error = new Error('fail');
-        const result = await catchIt(() => { throw error; });
-        expect(result.value).toBeUndefined();
-        expect(result.error).toBe(error);
-        expect(result.isError()).toBe(true);
-    });
-    it('异步抛出异常时应返回 error，value 为 undefined，isError 为 true', async () => {
-        const error = new Error('fail-async');
-        const result = await catchIt(() => Promise.reject(error));
-        expect(result.value).toBeUndefined();
-        expect(result.error).toBe(error);
-        expect(result.isError()).toBe(true);
-    });
-    it('PromiseLike resolve 时应返回 value，error 为 undefined，isError 为 false', async () => {
-        const result = await catchIt(Promise.resolve('ok'));
-        expect(result.value).toBe('ok');
-        expect(result.error).toBeUndefined();
-        expect(result.isError()).toBe(false);
-    });
-    it('PromiseLike reject 时应返回 error，value 为 undefined，isError 为 true', async () => {
-        const error = new Error('promise-fail');
-        const result = await catchIt(Promise.reject(error));
-        expect(result.value).toBeUndefined();
-        expect(result.error).toBe(error);
-        expect(result.isError()).toBe(true);
-    });
-});

package/output/helpers/catch/index.js

@@ -1 +0,0 @@
-export * from './catch.js';

package/output/helpers/files/files.js

@@ -1,62 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { catchIt } from "../catch/index.js";
-const FILE_ARTIFACTS = ["README.md", "roadmap.md", "tasks.md"];
-const DIRECTORY_ARTIFACTS = ["designs", "reports", "hooks"];
-async function fileLineCount(filePath) {
-    const content = await fs.readFile(filePath, "utf-8");
-    if (!content) {
-        return 0;
-    }
-    return content.split(/\r?\n/).length;
-}
-async function listMarkdownFiles(dirPath) {
-    const entriesResult = await catchIt(fs.readdir(dirPath, { withFileTypes: true }));
-    if (entriesResult.isError()) {
-        return [];
-    }
-    const entries = entriesResult.value;
-    const files = entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md"));
-    const result = [];
-    for (const file of files) {
-        const fullPath = path.join(dirPath, file.name);
-        result.push({ path: fullPath, lineCount: await fileLineCount(fullPath) });
-    }
-    return result.sort((a, b) => a.path.localeCompare(b.path));
-}
-export async function discoverGovernanceArtifacts(governanceDir) {
-    const result = [];
-    for (const artifact of FILE_ARTIFACTS) {
-        const artifactPath = path.join(governanceDir, artifact);
-        const accessResult = await catchIt(fs.access(artifactPath));
-        if (!accessResult.isError()) {
-            result.push({
-                name: artifact,
-                kind: "file",
-                path: artifactPath,
-                exists: true,
-                lineCount: await fileLineCount(artifactPath),
-            });
-        }
-        else {
-            result.push({ name: artifact, kind: "file", path: artifactPath, exists: false });
-        }
-    }
-    for (const artifact of DIRECTORY_ARTIFACTS) {
-        const artifactPath = path.join(governanceDir, artifact);
-        const accessResult = await catchIt(fs.access(artifactPath));
-        if (!accessResult.isError()) {
-            result.push({
-                name: artifact,
-                kind: "directory",
-                path: artifactPath,
-                exists: true,
-                markdownFiles: await listMarkdownFiles(artifactPath),
-            });
-        }
-        else {
-            result.push({ name: artifact, kind: "directory", path: artifactPath, exists: false, markdownFiles: [] });
-        }
-    }
-    return result;
-}

package/output/helpers/files/files.test.js

@@ -1,32 +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 { discoverGovernanceArtifacts } from "./files.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("files module", () => {
-    it("discovers governance artifacts with paths and line counts", async () => {
-        const root = await createTempDir();
-        await fs.writeFile(path.join(root, "README.md"), "# Readme\n", "utf-8");
-        await fs.writeFile(path.join(root, "tasks.md"), "# Tasks\n## TODO\n", "utf-8");
-        await fs.mkdir(path.join(root, "designs"), { recursive: true });
-        await fs.writeFile(path.join(root, "designs", "feature-design.md"), "# Design\n", "utf-8");
-        const artifacts = await discoverGovernanceArtifacts(root);
-        const readme = artifacts.find((item) => item.name === "README.md");
-        const designs = artifacts.find((item) => item.name === "designs");
-        expect(readme?.exists).toBe(true);
-        expect(readme?.lineCount).toBe(2);
-        expect(designs?.exists).toBe(true);
-        expect(designs?.markdownFiles?.[0].path.endsWith("feature-design.md")).toBe(true);
-    });
-});

package/output/helpers/files/index.js

@@ -1 +0,0 @@
-export * from './files.js';

package/output/helpers/index.js

@@ -1,6 +0,0 @@
-export * from './artifacts/index.js';
-export * from './catch/index.js';
-export * from './files/index.js';
-export * from './linter/index.js';
-export * from './markdown/index.js';
-export * from './response/index.js';

package/output/helpers/linter/codes.js

@@ -1,25 +0,0 @@
-export const TASK_LINT_CODES = {
-    DUPLICATE_ID: "TASK_DUPLICATE_ID",
-    IN_PROGRESS_OWNER_EMPTY: "TASK_IN_PROGRESS_OWNER_EMPTY",
-    DONE_LINKS_MISSING: "TASK_DONE_LINKS_MISSING",
-    BLOCKED_SUMMARY_EMPTY: "TASK_BLOCKED_SUMMARY_EMPTY",
-    UPDATED_AT_INVALID: "TASK_UPDATED_AT_INVALID",
-    ROADMAP_REFS_EMPTY: "TASK_ROADMAP_REFS_EMPTY",
-    OUTSIDE_MARKER: "TASK_OUTSIDE_MARKER",
-    LINK_TARGET_MISSING: "TASK_LINK_TARGET_MISSING",
-    HOOK_FILE_MISSING: "TASK_HOOK_FILE_MISSING",
-    FILTER_EMPTY: "TASK_FILTER_EMPTY",
-    CONTEXT_HOOK_HEAD_MISSING: "TASK_CONTEXT_HOOK_HEAD_MISSING",
-    CONTEXT_HOOK_FOOTER_MISSING: "TASK_CONTEXT_HOOK_FOOTER_MISSING",
-};
-export const ROADMAP_LINT_CODES = {
-    IDS_EMPTY: "ROADMAP_IDS_EMPTY",
-    TASKS_EMPTY: "ROADMAP_TASKS_EMPTY",
-    TASK_REFS_EMPTY: "ROADMAP_TASK_REFS_EMPTY",
-    UNKNOWN_REFS: "ROADMAP_UNKNOWN_REFS",
-    ZERO_LINKED_TASKS: "ROADMAP_ZERO_LINKED_TASKS",
-    CONTEXT_RELATED_TASKS_EMPTY: "ROADMAP_CONTEXT_RELATED_TASKS_EMPTY",
-};
-export const PROJECT_LINT_CODES = {
-    TASKS_FILE_MISSING: "PROJECT_TASKS_FILE_MISSING",
-};

package/output/helpers/linter/index.js

@@ -1,2 +0,0 @@
-export * from './linter.js';
-export * from './codes.js';

package/output/helpers/linter/linter.js

@@ -1,6 +0,0 @@
-export function renderLintSuggestions(suggestions) {
-    return suggestions.map((item) => {
-        const suffix = item.fixHint ? ` ${item.fixHint}` : "";
-        return `- [${item.code}] ${item.message}${suffix}`;
-    });
-}

package/output/helpers/linter/linter.test.js

@@ -1,16 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { renderLintSuggestions } from "./linter.js";
-describe("renderLintSuggestions", () => {
-    it("renders lint lines with code and message", () => {
-        const lines = renderLintSuggestions([
-            { code: "TASK_001", message: "Example lint" },
-        ]);
-        expect(lines).toEqual(["- [TASK_001] Example lint"]);
-    });
-    it("appends fixHint when provided", () => {
-        const lines = renderLintSuggestions([
-            { code: "TASK_002", message: "Missing field.", fixHint: "Set owner." },
-        ]);
-        expect(lines).toEqual(["- [TASK_002] Missing field. Set owner."]);
-    });
-});

package/output/helpers/markdown/index.js

@@ -1 +0,0 @@
-export * from './markdown.js';