@projitive/mcp 1.0.3 → 1.0.5

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` 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 }) => {
+        const taskEntry = taskId && projectPath
+            ? `1) Run taskContext(projectPath=\"${projectPath}\", taskId=\"${taskId}\").`
+            : `1) Run taskNext(${rootPath ? `rootPath=\"${rootPath}\"` : ""}).`;
         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 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,31 @@ function registerGovernancePrompts() {
     });
     server.registerPrompt("triageProjectGovernance", {
         title: "Triage Project Governance",
-        description: "Template to inspect a project and select next actionable governance task",
+        description: "Discovery-first triage prompt to pick project and next executable task",
         argsSchema: {
             rootPath: z.string().optional(),
         },
     }, async ({ rootPath }) => {
         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.",
+            "1) If project path is unknown, run projectScan() and pick one discovered project.",
+            `2) Run projectNext(${rootPath ? `rootPath=\"${rootPath}\"` : ""}) 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(rootPath=<workspaceRootIfNeeded>) 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

@@ -41,15 +41,27 @@ function parseDepthFromEnv(rawDepth) {
     }
     return Math.min(MAX_SCAN_DEPTH, Math.max(0, parsed));
 }
+function requireEnvVar(name) {
+    const value = process.env[name];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`Missing required environment variable: ${name}`);
+    }
+    return value.trim();
+}
 export function resolveScanRoot(inputPath) {
-    const fallback = process.env.PROJITIVE_SCAN_ROOT_PATH;
-    return normalizePath(inputPath ?? fallback);
+    const configuredRoot = requireEnvVar("PROJITIVE_SCAN_ROOT_PATH");
+    return normalizePath(inputPath ?? configuredRoot);
 }
 export function resolveScanDepth(inputDepth) {
+    const configuredDepthRaw = requireEnvVar("PROJITIVE_SCAN_MAX_DEPTH");
+    const configuredDepth = parseDepthFromEnv(configuredDepthRaw);
+    if (typeof configuredDepth !== "number") {
+        throw new Error("Invalid PROJITIVE_SCAN_MAX_DEPTH: expected integer in range 0-8");
+    }
     if (typeof inputDepth === "number") {
         return inputDepth;
     }
-    return parseDepthFromEnv(process.env.PROJITIVE_SCAN_MAX_DEPTH) ?? DEFAULT_SCAN_DEPTH;
+    return configuredDepth;
 }
 function renderArtifactsMarkdown(artifacts) {
     const rows = artifacts.map((item) => {
@@ -226,16 +238,16 @@ function defaultNoTaskDiscoveryHookMarkdown() {
     ].join("\n");
 }
 export async function initializeProjectStructure(inputPath, governanceDir, force = false) {
-    const rootPath = normalizePath(inputPath);
+    const projectPath = normalizePath(inputPath);
     const governanceDirName = normalizeGovernanceDirName(governanceDir);
-    const rootStat = await catchIt(fs.stat(rootPath));
+    const rootStat = await catchIt(fs.stat(projectPath));
     if (rootStat.isError()) {
-        throw new Error(`Path not found: ${rootPath}`);
+        throw new Error(`Path not found: ${projectPath}`);
     }
     if (!rootStat.value.isDirectory()) {
-        throw new Error(`rootPath must be a directory: ${rootPath}`);
+        throw new Error(`projectPath must be a directory: ${projectPath}`);
     }
-    const governancePath = path.join(rootPath, governanceDirName);
+    const governancePath = path.join(projectPath, governanceDirName);
     const directories = [];
     const requiredDirectories = [governancePath, path.join(governancePath, "designs"), path.join(governancePath, "reports"), path.join(governancePath, "hooks")];
     for (const dirPath of requiredDirectories) {
@@ -252,7 +264,7 @@ export async function initializeProjectStructure(inputPath, governanceDir, force
         writeTextFile(path.join(governancePath, "hooks", "task_no_actionable.md"), defaultNoTaskDiscoveryHookMarkdown(), force),
     ]);
     return {
-        rootPath,
+        projectPath,
         governanceDir: governancePath,
         markerPath,
         directories,
@@ -262,14 +274,14 @@ 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: {
-            rootPath: z.string().optional(),
+            projectPath: z.string().optional(),
             governanceDir: z.string().optional(),
             force: z.boolean().optional(),
         },
-    }, async ({ rootPath, governanceDir, force }) => {
-        const initialized = await initializeProjectStructure(rootPath, governanceDir, force ?? false);
+    }, async ({ projectPath, governanceDir, force }) => {
+        const initialized = await initializeProjectStructure(projectPath, governanceDir, force ?? false);
         const filesByAction = {
             created: initialized.files.filter((item) => item.action === "created"),
             updated: initialized.files.filter((item) => item.action === "updated"),
@@ -279,7 +291,7 @@ export function registerProjectTools(server) {
             toolName: "projectInit",
             sections: [
                 summarySection([
-                    `- rootPath: ${initialized.rootPath}`,
+                    `- projectPath: ${initialized.projectPath}`,
                     `- governanceDir: ${initialized.governanceDir}`,
                     `- markerPath: ${initialized.markerPath}`,
                     `- force: ${force === true ? "true" : "false"}`,
@@ -308,14 +320,11 @@ export function registerProjectTools(server) {
     });
     server.registerTool("projectScan", {
         title: "Project Scan",
-        description: "Scan filesystem and discover project governance roots marked by .projitive",
-        inputSchema: {
-            rootPath: z.string().optional(),
-            maxDepth: z.number().int().min(0).max(8).optional(),
-        },
-    }, async ({ rootPath, maxDepth }) => {
-        const root = resolveScanRoot(rootPath);
-        const depth = resolveScanDepth(maxDepth);
+        description: "Start here when project path is unknown; discover all governance roots",
+        inputSchema: {},
+    }, async () => {
+        const root = resolveScanRoot();
+        const depth = resolveScanDepth();
         const projects = await discoverProjects(root, depth);
         const markdown = renderToolResponseMarkdown({
             toolName: "projectScan",
@@ -345,7 +354,7 @@ 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(),
@@ -414,7 +423,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(),
         },
@@ -439,7 +448,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,7 +543,7 @@ 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(),
@@ -611,7 +611,7 @@ export function registerTaskTools(server) {
                     ]),
                     nextCallSection(preferredProject
                         ? `projectContext(projectPath=\"${preferredProject.governanceDir}\")`
-                        : `projectScan(rootPath=\"${root}\", maxDepth=${depth})`),
+                        : "projectScan()"),
                 ],
             });
             return asText(markdown);
@@ -680,7 +680,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.3",
+  "version": "1.0.5",
   "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';