@projitive/mcp 1.0.8 → 1.1.2

package/output/source/index.test.js

@@ -0,0 +1,110 @@
+import { describe, it, expect, beforeAll, afterAll, vi, beforeEach } from "vitest";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+const currentFilePath = fileURLToPath(import.meta.url);
+const sourceDir = path.dirname(currentFilePath);
+// Mock McpServer and StdioServerTransport
+vi.mock("@modelcontextprotocol/sdk/server/mcp.js", () => ({
+    McpServer: vi.fn().mockImplementation(() => ({
+        registerResource: vi.fn(),
+        registerPrompt: vi.fn(),
+        connect: vi.fn().mockResolvedValue(undefined),
+    })),
+}));
+vi.mock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
+    StdioServerTransport: vi.fn().mockImplementation(() => ({})),
+}));
+// Mock the registration functions
+vi.mock("./tools/project.js", () => ({
+    registerProjectTools: vi.fn(),
+}));
+vi.mock("./tools/task.js", () => ({
+    registerTaskTools: vi.fn(),
+}));
+vi.mock("./tools/roadmap.js", () => ({
+    registerRoadmapTools: vi.fn(),
+}));
+vi.mock("./resources/governance.js", () => ({
+    registerGovernanceResources: vi.fn(),
+}));
+vi.mock("./resources/designs.js", () => ({
+    registerDesignFilesResources: vi.fn(),
+}));
+vi.mock("./prompts/governance.js", () => ({
+    registerGovernancePrompts: vi.fn(),
+}));
+describe("index module", () => {
+    let tempDir;
+    let testProjectDir;
+    beforeAll(async () => {
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "projitive-index-test-"));
+        testProjectDir = path.join(tempDir, "test-project");
+        await fs.mkdir(testProjectDir);
+    });
+    afterAll(async () => {
+        await fs.rm(tempDir, { recursive: true, force: true });
+    });
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should export the main server entry point", async () => {
+        const indexPath = path.join(sourceDir, "index.ts");
+        const exists = await fs.access(indexPath).then(() => true).catch(() => false);
+        expect(exists).toBe(true);
+    });
+    it("should have the correct shebang and imports", async () => {
+        const indexPath = path.join(sourceDir, "index.ts");
+        const content = await fs.readFile(indexPath, "utf-8");
+        expect(content.startsWith("#!/usr/bin/env node")).toBe(true);
+        expect(content).toContain("McpServer");
+        expect(content).toContain("StdioServerTransport");
+        expect(content).toContain("registerTools");
+        expect(content).toContain("registerResources");
+        expect(content).toContain("registerPrompts");
+    });
+    it("should define PROJITIVE_SPEC_VERSION as 1.1.0", async () => {
+        const indexPath = path.join(sourceDir, "index.ts");
+        const content = await fs.readFile(indexPath, "utf-8");
+        expect(content).toContain("PROJITIVE_SPEC_VERSION");
+        expect(content).toContain('"1.1.0"');
+    });
+    it("should have main function with server startup", async () => {
+        const indexPath = path.join(sourceDir, "index.ts");
+        const content = await fs.readFile(indexPath, "utf-8");
+        expect(content).toContain("async function main");
+        expect(content).toContain("server.connect");
+        expect(content).toContain("StdioServerTransport");
+    });
+    it("should register all tool categories", async () => {
+        const indexPath = path.join(sourceDir, "index.ts");
+        const content = await fs.readFile(indexPath, "utf-8");
+        expect(content).toContain("registerTools(server)");
+        expect(content).toContain("registerResources(server, repoRoot)");
+        expect(content).toContain("registerPrompts(server)");
+    });
+    it("should have proper error handling in main", async () => {
+        const indexPath = path.join(sourceDir, "index.ts");
+        const content = await fs.readFile(indexPath, "utf-8");
+        expect(content).toContain("void main().catch");
+        expect(content).toContain("console.error(\"Server error:\", error)");
+        expect(content).toContain("process.exit(1)");
+    });
+    it("should log server startup information", async () => {
+        const indexPath = path.join(sourceDir, "index.ts");
+        const content = await fs.readFile(indexPath, "utf-8");
+        expect(content).toContain("console.error(`[projitive-mcp] starting server`)");
+        expect(content).toContain("console.error(`[projitive-mcp] version=");
+        expect(content).toContain("spec=");
+        expect(content).toContain("transport=stdio");
+        expect(content).toContain("pid=");
+    });
+    it("should define MCP server with correct metadata", async () => {
+        const indexPath = path.join(sourceDir, "index.ts");
+        const content = await fs.readFile(indexPath, "utf-8");
+        expect(content).toContain("name: \"projitive\"");
+        expect(content).toContain("version: MCP_RUNTIME_VERSION");
+        expect(content).toContain("description:");
+    });
+});

package/output/source/prompts/index.js

@@ -0,0 +1,9 @@
+// Governance workflow prompts
+import { registerQuickStartPrompt } from "./quickStart.js";
+import { registerTaskDiscoveryPrompt } from "./taskDiscovery.js";
+import { registerTaskExecutionPrompt } from "./taskExecution.js";
+export function registerPrompts(server) {
+    registerQuickStartPrompt(server);
+    registerTaskDiscoveryPrompt(server);
+    registerTaskExecutionPrompt(server);
+}

package/output/source/prompts/quickStart.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+function asUserPrompt(text) {
+    return {
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text,
+                },
+            },
+        ],
+    };
+}
+export function registerQuickStartPrompt(server) {
+    server.registerPrompt("quickStart", {
+        title: "Quick Start",
+        description: "Complete workflow to discover project, load context, and start task execution",
+        argsSchema: {
+            projectPath: z.string().optional(),
+        },
+    }, async ({ projectPath }) => {
+        const text = [
+            "# How to Govern a Project",
+            "",
+            "You are a Projitive governance assistant. Here is the complete workflow:",
+            "",
+            "## Step 1: Discover the Project",
+            "",
+            projectPath
+                ? [
+                    `- Known project path: "${projectPath}"`,
+                    "- Call `projectContext(projectPath=\"" + projectPath + "\")` directly to load project overview",
+                ].join("\n")
+                : [
+                    "- Unknown project path:",
+                    "  1. Call `projectScan()` to discover all governance roots",
+                    "  2. Select a target project",
+                    "  3. Call `projectLocate(inputPath=\"<selected-path>\")` to lock governance root",
+                    "  4. Call `projectContext(projectPath=\"<project-path>\")` to load project overview",
+                ].join("\n"),
+            "",
+            "## Step 2: Understand the Project",
+            "",
+            "After loading project context, read these resources:",
+            "- projitive://governance/workspace - Project overview",
+            "- projitive://governance/tasks - Current task pool",
+            "- projitive://governance/roadmap - Project roadmap",
+            "- projitive://designs/* - Design documents",
+            "",
+            "## Step 3: Discover Tasks",
+            "",
+            "Two ways to discover tasks:",
+            "",
+            "### Option A: Auto-select (Recommended)",
+            "Call `taskNext()` to get highest-priority actionable task.",
+            "",
+            "### Option B: Manual select",
+            "1. Call `taskList()` to list all tasks",
+            "2. Select a task based on status and priority",
+            "3. Call `taskContext(projectPath=\"...\", taskId=\"...\")` for details",
+            "",
+            "## Step 4: Execute the Task",
+            "",
+            "After getting task context:",
+            "1. Read evidence links in Suggested Read Order",
+            "2. Understand task requirements and acceptance criteria",
+            "3. Edit governance markdown only (tasks/designs/reports/roadmap)",
+            "4. Update task status:",
+            "   - TODO → IN_PROGRESS (when starting execution)",
+            "   - IN_PROGRESS → DONE (when completed)",
+            "   - IN_PROGRESS → BLOCKED (when blocked)",
+            "5. Re-run taskContext() to verify changes",
+            "",
+            "## Special Cases",
+            "",
+            "### Case 1: No .projitive directory",
+            "Call `projectInit(projectPath=\"<project-dir>\")` to initialize governance structure.",
+            "",
+            "### Case 2: No actionable tasks",
+            "1. Check if tasks.md is missing",
+            "2. Read design documents in projitive://designs/",
+            "3. Create 1-3 new TODO tasks",
+            "",
+            "## Hard Rules",
+            "",
+            "- **NEVER modify TASK/ROADMAP IDs** - Keep them immutable once assigned",
+            "- **Every status transition must have report evidence** - Create execution reports in reports/ directory",
+            "- **Only edit files under .projitive/** - Unless task scope explicitly requires otherwise",
+            "- **Always verify after updates** - Re-run taskContext() to confirm reference consistency",
+        ].join("\n");
+        return asUserPrompt(text);
+    });
+}

package/output/source/prompts/taskDiscovery.js

@@ -0,0 +1,190 @@
+import { z } from "zod";
+function asUserPrompt(text) {
+    return {
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text,
+                },
+            },
+        ],
+    };
+}
+export function registerTaskDiscoveryPrompt(server) {
+    server.registerPrompt("taskDiscovery", {
+        title: "Task Discovery",
+        description: "Minimal steps to find, context, and execute the first actionable task",
+        argsSchema: {
+            projectPath: z.string().optional(),
+        },
+    }, async ({ projectPath }) => {
+        const text = [
+            "# How to Discover Tasks",
+            "",
+            "You are a Projitive task discovery assistant. Here is the complete workflow to discover and execute your first task:",
+            "",
+            "## Step 1: Locate the Project",
+            "",
+            projectPath
+                ? [
+                    `- Known project path: "${projectPath}"`,
+                    "- Call `projectContext(projectPath=\"" + projectPath + "\")` directly to load project context",
+                ].join("\n")
+                : [
+                    "- Unknown project path:",
+                    "  1. Call `projectScan()` to discover all governance roots",
+                    "  2. Select a project",
+                    "  3. Call `projectLocate(inputPath=\"<selected-path>\")` to lock governance root",
+                    "  4. Call `projectContext(projectPath=\"<project-path>\")` to load project context",
+                ].join("\n"),
+            "",
+            "## Step 2: Read Project Context",
+            "",
+            "After loading project context, focus on:",
+            "",
+            "### Task Summary",
+            "- total: Total tasks",
+            "- TODO: Pending tasks (highest priority)",
+            "- IN_PROGRESS: In-progress tasks (priority to continue)",
+            "- BLOCKED: Blocked tasks (need to resolve first)",
+            "- DONE: Completed tasks",
+            "",
+            "### Artifacts",
+            "Check if these files exist:",
+            "- \u2705 tasks.md - Task list (required)",
+            "- \u2705 roadmap.md - Roadmap",
+            "- \u2705 README.md - Project description",
+            "- \u2705 designs/ - Design documents directory",
+            "- \u2705 reports/ - Reports directory",
+            "",
+            "## Step 3: Select a Task",
+            "",
+            "### Priority Order",
+            "Select tasks in this priority order:",
+            "",
+            "1. **IN_PROGRESS** - Priority to continue in-progress tasks first",
+            "   - These tasks have already started, should continue to finish",
+            "   - Check updatedAt time, most recent first",
+            "",
+            "2. **TODO** - Next select pending tasks",
+            "   - Tasks with roadmapRefs first",
+            "   - Tasks with explicit owner first",
+            "",
+            "3. **BLOCKED** - Last consider blocked tasks",
+            "   - Need to analyze blocker reason first",
+            "   - May need to create sub-task to resolve blocker",
+            "",
+            "### Discovery Methods",
+            "",
+            "#### Method A: Auto-select with taskNext() (Recommended)",
+            "",
+            "Call `taskNext()`, the tool will automatically:",
+            "- Sort all tasks by priority",
+            "- Select highest-priority actionable task",
+            "- Return task ID and summary",
+            "",
+            "Then call `taskContext(projectPath=\"...\", taskId=\"<task-id>\")` for task details.",
+            "",
+            "#### Method B: Manual select with taskList()",
+            "",
+            "1. Call `taskList()` to get all tasks",
+            "2. Select based on these factors:",
+            "   - status (IN_PROGRESS > TODO > BLOCKED)",
+            "   - updatedAt time (most recent first)",
+            "   - owner assigned (with owner first)",
+            "   - roadmapRefs (with refs first)",
+            "3. Call `taskContext(projectPath=\"...\", taskId=\"<selected-id>\")` for details",
+            "",
+            "## Step 4: Understand Task Context",
+            "",
+            "After getting taskContext, read carefully:",
+            "",
+            "### Summary",
+            "- taskId: Task ID (NEVER modify this)",
+            "- status: Current status",
+            "- owner: Assignee",
+            "- roadmapRefs: Related roadmap",
+            "- updatedAt: Last updated time",
+            "",
+            "### Evidence",
+            "- Candidate Files - Related file list",
+            "- Reference Locations - Reference locations",
+            "",
+            "### Suggested Read Order",
+            "Read files in order, understand:",
+            "- Task background and motivation",
+            "- Task acceptance criteria",
+            "- Related design decisions",
+            "- Previous execution history",
+            "",
+            "### Lint Suggestions",
+            "Check if any warnings need to be resolved first.",
+            "",
+            "## Step 5: Execute the Task",
+            "",
+            "After understanding the task:",
+            "",
+            "1. **If status is TODO",
+            "   - First call `taskUpdate()` to change status to IN_PROGRESS",
+            "   - Set owner (if empty)",
+            "   - Fill subState (optional, Spec v1.1.0)",
+            "",
+            "2. **If status is IN_PROGRESS",
+            "   - Continue previous work",
+            "   - Reference history reports in reports/",
+            "",
+            "3. **Execute task content**",
+            "   - Edit governance files (tasks.md / designs/*.md / reports/*.md / roadmap.md)",
+            "   - Create execution report (reports/ directory)",
+            "   - Update task status to DONE",
+            "",
+            "4. **Verify changes**",
+            "   - Re-run `taskContext()`",
+            "   - Confirm all references still valid",
+            "   - Confirm no new lint suggestions",
+            "",
+            "## Special Cases",
+            "",
+            "### Case 1: No tasks at all",
+            "",
+            "If taskNext() returns empty:",
+            "1. Check if tasks.md exists",
+            "2. Read design documents in designs/ directory",
+            "3. Read roadmap.md to understand project goals",
+            "4. Create 1-3 new TODO tasks",
+            "5. Each task must have:",
+            "   - Unique TASK-xxxx ID",
+            "   - Clear title",
+            "   - Detailed summary",
+            "   - Linked roadmapRefs (if applicable)",
+            "",
+            "### Case 2: All tasks are BLOCKED",
+            "",
+            "1. Select one blocked task and call `taskContext()`",
+            "2. Understand blocker reason (check blocker field, Spec v1.1.0)",
+            "3. Create a new TODO task to resolve blocker",
+            "4. Execute this new task first",
+            "",
+            "### Case 3: Missing required governance files",
+            "",
+            "If tasks.md does not exist:",
+            "1. Call `projectInit(projectPath=\"...\")` to initialize governance structure",
+            "2. Then restart discovery flow",
+            "",
+            "## Quick Reference",
+            "",
+            "| Tool | Purpose |",
+            "|------|---------|",
+            "| `projectScan()` | Discover all governance roots |",
+            "| `projectLocate()` | Lock governance root |",
+            "| `projectContext()` | Load project overview |",
+            "| `taskNext()` | Auto-select best task |",
+            "| `taskList()` | List all tasks |",
+            "| `taskContext()` | Get task details |",
+            "| `taskUpdate()` | Update task status |",
+        ].join("\n");
+        return asUserPrompt(text);
+    });
+}

package/output/source/prompts/taskExecution.js

@@ -0,0 +1,161 @@
+import { z } from "zod";
+function asUserPrompt(text) {
+    return {
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text,
+                },
+            },
+        ],
+    };
+}
+export function registerTaskExecutionPrompt(server) {
+    server.registerPrompt("taskExecution", {
+        title: "Task Execution",
+        description: "Primary execution prompt: select one task, execute, and verify evidence consistency",
+        argsSchema: {
+            projectPath: z.string().optional(),
+            taskId: z.string().optional(),
+        },
+    }, async ({ projectPath, taskId }) => {
+        const taskEntry = taskId && projectPath
+            ? `1) Run taskContext(projectPath="${projectPath}", taskId="${taskId}").`
+            : "1) Run taskNext().";
+        const text = [
+            "# Execute Task Workflow",
+            "",
+            "You are a Projitive task execution assistant. Here is the complete workflow:",
+            "",
+            "## Step 1: Get the Task",
+            "",
+            taskEntry,
+            "",
+            "## Step 2: Understand the Task",
+            "",
+            "After getting task context, read carefully:",
+            "",
+            "### Suggested Read Order",
+            "Read each file in order:",
+            "- Note content and location of each file",
+            "- Understand task background and motivation",
+            "- Identify task acceptance criteria",
+            "- Look for related design decisions",
+            "",
+            "### Evidence",
+            "- Candidate Files - Related file list",
+            "- Reference Locations - Where TASK/ROADMAP IDs appear",
+            "",
+            "### Lint Suggestions",
+            "Resolve any warnings before starting task execution.",
+            "",
+            "## Step 3: Execute the Task",
+            "",
+            "### Status Management",
+            "",
+            "| Current Status | Next Step | Description |",
+            "|----------------|-----------|-------------|",
+            "| TODO | \u2192 IN_PROGRESS | When starting execution |",
+            "| IN_PROGRESS | \u2192 DONE | When task is complete |",
+            "| IN_PROGRESS | \u2192 BLOCKED | When blocked |",
+            "| BLOCKED | \u2192 TODO | When blocker is resolved |",
+            "",
+            "### Execution Steps",
+            "",
+            "1. **Prepare (if status is TODO)",
+            "   - Call `taskUpdate()` to change status to IN_PROGRESS",
+            "   - Set owner (if empty)",
+            "   - Fill subState (optional, Spec v1.1.0)",
+            "",
+            "2. **Execute task content**",
+            "   - Only edit files under .projitive/",
+            "   - tasks.md - Update task status and metadata",
+            "   - designs/*.md - Add or update design documents",
+            "   - reports/*.md - Create execution reports",
+            "   - roadmap.md - Update roadmap (if needed)",
+            "",
+            "3. **Create execution report**",
+            "   - Create new report file in reports/ directory",
+            "   - Record what changes were made",
+            "   - Record why changes were made",
+            "   - Record verification results",
+            "",
+            "4. **Complete task (if status is IN_PROGRESS)",
+            "   - Confirm all acceptance criteria are met",
+            "   - Call `taskUpdate()` to change status to DONE",
+            "   - Update updatedAt timestamp",
+            "",
+            "## Step 4: Verify Changes",
+            "",
+            "After execution:",
+            "",
+            "1. **Re-run taskContext()",
+            "   - Confirm task status updated correctly",
+            "   - Confirm updatedAt timestamp updated",
+            "",
+            "2. **Check reference consistency",
+            "   - Confirm all TASK/ROADMAP IDs still valid",
+            "   - Confirm no broken links in Reference Locations",
+            "",
+            "3. **Check Lint Suggestions",
+            "   - Confirm no new warnings",
+            "   - If there are warnings, resolve them first",
+            "",
+            "4. **Continue to next task (optional)",
+            "   - Call `taskNext()` for next task",
+            "   - Repeat above workflow",
+            "",
+            "## Special Cases",
+            "",
+            "### Case 1: Encountered a blocker",
+            "",
+            "If unable to continue task execution:",
+            "1. Call `taskUpdate()` to change status to BLOCKED",
+            "2. Fill blocker field (Spec v1.1.0):",
+            "   - type: Blocker type (dependency/missing-info/technical-debt/other)",
+            "   - description: Blocker description",
+            "   - relatedLinks: Related links (optional)",
+            "3. Create a new TODO task to resolve blocker",
+            "",
+            "### Case 2: No actionable tasks",
+            "",
+            "If taskNext() returns empty:",
+            "1. Call `projectContext()` to recheck project state",
+            "2. Read design documents in designs/ directory",
+            "3. Create 1-3 new TODO tasks",
+            "",
+            "### Case 3: Need to initialize governance",
+            "",
+            "If .projitive directory does not exist:",
+            "1. Call `projectInit(projectPath=\"<project-dir>\")`",
+            "2. Then restart",
+            "",
+            "## Hard Rules (NEVER violate)",
+            "",
+            "1. **NEVER modify TASK/ROADMAP IDs**",
+            "   - Keep them immutable once assigned",
+            "   - If you need to reference, keep them as-is",
+            "",
+            "2. **Every status transition must have report evidence**",
+            "   - TODO \u2192 IN_PROGRESS: Report not required",
+            "   - IN_PROGRESS \u2192 DONE: Report REQUIRED",
+            "   - IN_PROGRESS \u2192 BLOCKED: Report recommended to explain blocker",
+            "",
+            "3. **Only edit files under .projitive/**",
+            "   - Unless task scope explicitly requires modifying other files",
+            "   - Any non-governance file edits must be explained in task summary",
+            "",
+            "4. **Always verify after updates**",
+            "   - After every taskUpdate() call",
+            "   - Re-run taskContext()",
+            "   - Confirm reference consistency",
+            "",
+            "5. **Keep updatedAt in sync**",
+            "   - Every time you update a task",
+            "   - Must update updatedAt to current time (ISO 8601 format)",
+        ].join("\n");
+        return asUserPrompt(text);
+    });
+}

package/output/source/resources/designs.js

@@ -0,0 +1,108 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { isValidRoadmapId } from "../tools/roadmap.js";
+import { isValidTaskId } from "../tools/task.js";
+export function parseDesignMetadata(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    const metadata = {};
+    for (const line of lines) {
+        // Remove markdown bold markers (**)
+        const cleanLine = line.replace(/\*\*/g, "");
+        const [rawKey, ...rawValue] = cleanLine.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 };
+}
+async function findAllMarkdownFiles(dir) {
+    const result = [];
+    async function walk(currentDir, relativeBase) {
+        const entries = await fs.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(fullPath, path.join(relativeBase, entry.name));
+            }
+            else if (entry.isFile() && entry.name.endsWith(".md")) {
+                result.push({
+                    filePath: fullPath,
+                    relativePath: path.join(relativeBase, entry.name),
+                });
+            }
+        }
+    }
+    await walk(dir, "");
+    return result;
+}
+export async function registerDesignFilesResources(server, repoRoot) {
+    const designsDir = path.join(repoRoot, ".projitive", "designs");
+    try {
+        // Check if design documents directory exists
+        await fs.access(designsDir);
+        // Recursively read all .md files (including subdirectories)
+        const markdownFiles = await findAllMarkdownFiles(designsDir);
+        // Register each design file as a resource
+        for (const { filePath, relativePath } of markdownFiles) {
+            // Generate designId from relative path, replace path separators with '-'
+            const designId = relativePath
+                .slice(0, -3) // Remove .md suffix
+                .replace(/[\\/]/g, "-"); // Replace path separators with '-'
+            const content = await fs.readFile(filePath, "utf-8");
+            // Register resource
+            server.registerResource(`design-${designId}`, `projitive://designs/${designId}`, {
+                title: designId,
+                description: `Design document: ${relativePath}`,
+                mimeType: "text/markdown",
+            }, async () => ({
+                contents: [
+                    {
+                        uri: `projitive://designs/${designId}`,
+                        text: content,
+                    },
+                ],
+            }));
+        }
+    }
+    catch (error) {
+        // If design documents directory doesn't exist, register a default resource
+        console.warn(`Designs directory not found at ${designsDir}, registering default design resource`);
+        server.registerResource("designs", "projitive://designs", {
+            title: "Designs",
+            description: "Design documents directory",
+            mimeType: "text/markdown",
+        }, async () => ({
+            contents: [
+                {
+                    uri: "projitive://designs",
+                    text: `# Designs Directory\n\nDesign documents not found. Please create design files in .projitive/designs/ directory.`,
+                },
+            ],
+        }));
+    }
+}