@nimara-app/mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,1096 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// ../convex/convex/_generated/api.js
+import { anyApi, componentsGeneric } from "convex/server";
+var api = anyApi;
+var components = componentsGeneric();
+
+// src/convex.ts
+import { ConvexHttpClient } from "convex/browser";
+var cachedClient = null;
+function getConvexClient() {
+  if (cachedClient) return cachedClient;
+  const url = process.env.NIMARA_CONVEX_URL;
+  if (!url) {
+    throw new Error(
+      "NIMARA_CONVEX_URL is not set. Add it to your MCP client config (e.g. Claude Desktop's mcpServers env block)."
+    );
+  }
+  cachedClient = new ConvexHttpClient(url);
+  return cachedClient;
+}
+function getToken() {
+  const token = process.env.NIMARA_TOKEN;
+  if (!token) {
+    throw new Error(
+      "NIMARA_TOKEN is not set. Generate a personal access token from Nimara \u2192 Settings \u2192 Personal Access Tokens, then add it to your MCP client config."
+    );
+  }
+  return token;
+}
+
+// src/tools/list-orgs.ts
+function registerListOrgs(server) {
+  server.registerTool(
+    "list_orgs",
+    {
+      description: "List all organizations (and the personal workspace) the authenticated user belongs to. Use this first to discover org IDs needed by other tools.",
+      inputSchema: {},
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: false
+      }
+    },
+    async () => {
+      const client = getConvexClient();
+      const orgs = await client.action(api.mcp.listOrgs, { token: getToken() });
+      return {
+        content: [{ type: "text", text: JSON.stringify(orgs, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/list-projects.ts
+import { z } from "zod";
+function registerListProjects(server) {
+  server.registerTool(
+    "list_projects",
+    {
+      description: "List projects in a given organization. Call list_orgs first to find the orgId.",
+      inputSchema: { orgId: z.string().describe("orgId from list_orgs") },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({ orgId }) => {
+      const client = getConvexClient();
+      const projects = await client.action(api.mcp.listProjects, {
+        token: getToken(),
+        orgId
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(projects, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/list-work-items.ts
+import { z as z2 } from "zod";
+function registerListWorkItems(server) {
+  server.registerTool(
+    "list_work_items",
+    {
+      // The description is the only place a model learns paging exists, so it
+      // states the shape of the response and what to do when hasMore is true.
+      description: "List non-archived work items in a project, newest-created last. Returns { items, nextCursor, hasMore }. Long descriptions are previewed \u2014 an item with descriptionTruncated: true has more text, readable via fullDescriptions. When hasMore is true, call again with cursor set to nextCursor to get the next page. Call list_projects first for the projectId.",
+      inputSchema: {
+        projectId: z2.string().describe("projectId from list_projects"),
+        limit: z2.number().int().min(1).max(200).optional().describe("Items per page (default 50, max 200)."),
+        cursor: z2.number().optional().describe(
+          "nextCursor from the previous page. Omit for the first page."
+        ),
+        fullDescriptions: z2.boolean().optional().describe(
+          "Return descriptions in full instead of previewed. Costly on large projects \u2014 prefer paging, or read one item at a time."
+        )
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({ projectId, limit, cursor, fullDescriptions }) => {
+      const page = await getConvexClient().action(api.mcp.listWorkItems, {
+        token: getToken(),
+        projectId,
+        limit,
+        cursor,
+        fullDescriptions
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(page, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/list-ai-review-queue.ts
+import { z as z3 } from "zod";
+function registerListAiReviewQueue(server) {
+  server.registerTool(
+    "list_ai_review_queue",
+    {
+      description: "List work items in a project that a human has flagged for AI review (aiReviewRequested). Descriptions come back in full here, since enrichment needs the whole text. Returns { items, nextCursor, hasMore } \u2014 when hasMore is true, call again with cursor set to nextCursor. Process each item, then clear its flag by calling update_work_item with aiReviewRequested: false. Call list_projects first to find the projectId.",
+      inputSchema: {
+        projectId: z3.string().describe("projectId from list_projects"),
+        limit: z3.number().int().min(1).max(200).optional().describe("Items per page (default 50, max 200)."),
+        cursor: z3.number().optional().describe(
+          "nextCursor from the previous page. Omit for the first page."
+        )
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({ projectId, limit, cursor }) => {
+      const page = await getConvexClient().action(api.mcp.listAiReviewQueue, {
+        token: getToken(),
+        projectId,
+        limit,
+        cursor
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(page, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/create-work-item.ts
+import { z as z4 } from "zod";
+function registerCreateWorkItem(server) {
+  server.registerTool(
+    "create_work_item",
+    {
+      description: "Create a new work item in a project. Hierarchy rules: epics live at the root; features go under epics; tasks go under epics or features (or root); subtasks must go under a task. Returns the new workItemId and its display ID (e.g. NIM-42).",
+      inputSchema: {
+        projectId: z4.string().describe("projectId from list_projects"),
+        type: z4.enum(["epic", "feature", "task", "subtask"]).describe("Item type \u2014 drives hierarchy validation"),
+        title: z4.string().min(1).describe("Short, descriptive title"),
+        description: z4.string().optional().describe("Optional markdown body"),
+        parentId: z4.string().optional().describe(
+          "workItemId of the parent. Required for subtask, optional otherwise."
+        ),
+        status: z4.string().optional().describe(
+          "Status name from the project's statusOrder. Defaults to first status (e.g. 'Backlog')."
+        ),
+        priority: z4.enum(["p0", "p1", "p2", "p3"]).optional().describe("p0 highest, p3 lowest. Defaults to p2.")
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const client = getConvexClient();
+      const result = await client.action(api.mcp.createWorkItem, {
+        token: getToken(),
+        ...args
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/create-project.ts
+import { z as z5 } from "zod";
+function registerCreateProject(server) {
+  server.registerTool(
+    "create_project",
+    {
+      description: "Create a new project in an org. Prefix must be unique within the org and is uppercased (e.g. 'NIM' yields work items NIM-1, NIM-2\u2026). Caller becomes the project admin. Returns the new projectId.",
+      inputSchema: {
+        orgId: z5.string().describe("orgId from list_orgs"),
+        name: z5.string().min(1).describe("Project name"),
+        prefix: z5.string().min(1).max(8).describe(
+          "Short uppercase prefix for work item IDs (e.g. 'NIM'). Unique per org."
+        ),
+        description: z5.string().optional().describe("Optional markdown description"),
+        isPrivate: z5.boolean().optional().describe(
+          "If true, only explicitly added members see it. Defaults to false."
+        ),
+        workflowTemplate: z5.enum(["default", "simple", "kanban", "bug"]).optional().describe(
+          "Status workflow. Defaults to 'default' (Backlog/Todo/In Progress/Review/Done)."
+        )
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const client = getConvexClient();
+      const result = await client.action(api.mcp.createProject, {
+        token: getToken(),
+        ...args
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/update-work-item.ts
+import { z as z6 } from "zod";
+function registerUpdateWorkItem(server) {
+  server.registerTool(
+    "update_work_item",
+    {
+      description: "Update an existing work item: title, description, status, priority, parent, or review flags. Any update also stamps the item as AI-touched.",
+      inputSchema: {
+        workItemId: z6.string().describe("workItemId from list_work_items"),
+        title: z6.string().min(1).optional(),
+        description: z6.string().optional(),
+        status: z6.string().optional(),
+        priority: z6.enum(["p0", "p1", "p2", "p3"]).optional(),
+        parentId: z6.string().nullable().optional().describe("New parent workItemId, null to move to root."),
+        needsReview: z6.boolean().optional().describe(
+          "Flag the item for manual human review \u2014 set true when your enrichment was thin or uncertain."
+        ),
+        reviewReason: z6.string().optional().describe(
+          "Short reason the item needs manual review (shown to the human)."
+        ),
+        aiReviewRequested: z6.boolean().optional().describe(
+          "The human\u2192AI review flag. Set false to clear it after you have reviewed/enriched an item from list_ai_review_queue."
+        )
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const result = await getConvexClient().action(api.mcp.updateWorkItem, {
+        token: getToken(),
+        ...args
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/create-document.ts
+import { z as z7 } from "zod";
+function registerCreateDocument(server) {
+  server.registerTool(
+    "create_document",
+    {
+      description: "Create a markdown project document. Use type 'prd' for project docs or 'fd' for feature/work-item documents.",
+      inputSchema: {
+        projectId: z7.string().describe("projectId from list_projects"),
+        title: z7.string().min(1),
+        type: z7.enum(["prd", "fd"]).describe(
+          "Document type. 'fd' is stored as the app's feature document type."
+        ),
+        workItemId: z7.string().optional().describe("Required for fd documents; omitted for prd."),
+        content: z7.string().optional().describe("Optional initial markdown content.")
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const result = await getConvexClient().action(api.mcp.createDocument, {
+        token: getToken(),
+        ...args
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/update-document.ts
+import { z as z8 } from "zod";
+function registerUpdateDocument(server) {
+  server.registerTool(
+    "update_document",
+    {
+      description: "Update an existing document's markdown content and/or title. Use this to fill in or revise a document created earlier (e.g. backfill content into an empty doc). documentId comes from list_documents. Provided content fully replaces the existing content.",
+      inputSchema: {
+        documentId: z8.string().describe("documentId from list_documents"),
+        content: z8.string().optional().describe(
+          "New markdown content. Replaces the document's existing content."
+        ),
+        title: z8.string().min(1).optional().describe("New title (optional).")
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const result = await getConvexClient().action(api.mcp.updateDocument, {
+        token: getToken(),
+        ...args
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/list-documents.ts
+import { z as z9 } from "zod";
+function registerListDocuments(server) {
+  server.registerTool(
+    "list_documents",
+    {
+      description: "List PRD/FD markdown documents for a project, optionally filtered to one work item.",
+      inputSchema: {
+        projectId: z9.string().describe("projectId from list_projects"),
+        workItemId: z9.string().optional().describe("Optional workItemId to list linked FD documents.")
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const result = await getConvexClient().action(api.mcp.listDocuments, {
+        token: getToken(),
+        ...args
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/create-project-link.ts
+import { z as z10 } from "zod";
+var projectLinkCategory = z10.enum([
+  "api",
+  "dashboard",
+  "documentation",
+  "repository",
+  "service",
+  "other"
+]);
+function registerCreateProjectLink(server) {
+  server.registerTool(
+    "create_project_link",
+    {
+      description: "Save a link on a project for resources like APIs, dashboards, documentation, repositories, or services.",
+      inputSchema: {
+        projectId: z10.string().describe("projectId from list_projects"),
+        title: z10.string().min(1).max(120),
+        url: z10.string().url().describe("http(s) URL to save"),
+        description: z10.string().max(500).optional(),
+        category: projectLinkCategory.optional().describe("Defaults to other.")
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const result = await getConvexClient().action(api.mcp.createProjectLink, {
+        token: getToken(),
+        ...args
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/list-project-links.ts
+import { z as z11 } from "zod";
+function registerListProjectLinks(server) {
+  server.registerTool(
+    "list_project_links",
+    {
+      description: "List saved links for a project, such as APIs, dashboards, docs, repositories, and services.",
+      inputSchema: {
+        projectId: z11.string().describe("projectId from list_projects")
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({ projectId }) => {
+      const result = await getConvexClient().action(api.mcp.listProjectLinks, {
+        token: getToken(),
+        projectId
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/add-work-item-image.ts
+import { z as z12 } from "zod";
+function registerAddWorkItemImage(server) {
+  server.registerTool(
+    "add_work_item_image",
+    {
+      description: "Attach an externally hosted image URL to a work item. Use this when an MCP client has a screenshot, mockup, or generated image URL to preserve with the task.",
+      inputSchema: {
+        workItemId: z12.string().describe("workItemId from list_work_items"),
+        imageUrl: z12.string().url().describe("Public or otherwise fetchable http(s) image URL"),
+        filename: z12.string().optional().describe("Optional display filename"),
+        altText: z12.string().optional().describe("Optional description/caption for the image")
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const result = await getConvexClient().action(api.mcp.addWorkItemImage, {
+        token: getToken(),
+        ...args
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/list-work-item-images.ts
+import { z as z13 } from "zod";
+function registerListWorkItemImages(server) {
+  server.registerTool(
+    "list_work_item_images",
+    {
+      description: "List image attachments for a work item, including uploaded images and externally attached MCP images. Call list_work_items first to find the workItemId.",
+      inputSchema: {
+        workItemId: z13.string().describe("workItemId from list_work_items")
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({ workItemId }) => {
+      const result = await getConvexClient().action(
+        api.mcp.listWorkItemImages,
+        {
+          token: getToken(),
+          workItemId
+        }
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/add-work-item-comment.ts
+import { z as z14 } from "zod";
+function registerAddWorkItemComment(server) {
+  server.registerTool(
+    "add_work_item_comment",
+    {
+      description: "Add a timestamped comment to a work item. Use this to record notes, updates, or an 'AI touched' entry instead of editing the description. Comments are stamped with the current time automatically and never overwrite each other.",
+      inputSchema: {
+        workItemId: z14.string().describe("workItemId from list_work_items"),
+        body: z14.string().min(1).describe("Comment text (markdown supported)"),
+        source: z14.enum(["user", "ai"]).optional().describe('Who authored it; defaults to "ai" for MCP callers')
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const result = await getConvexClient().action(
+        api.mcp.addWorkItemComment,
+        {
+          token: getToken(),
+          ...args
+        }
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/list-work-item-comments.ts
+import { z as z15 } from "zod";
+function registerListWorkItemComments(server) {
+  server.registerTool(
+    "list_work_item_comments",
+    {
+      description: "List the timestamped comments on a work item, oldest first. Use this to check whether the item was already touched/commented before adding a new comment.",
+      inputSchema: {
+        workItemId: z15.string().describe("workItemId from list_work_items")
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const result = await getConvexClient().action(
+        api.mcp.listWorkItemComments,
+        {
+          token: getToken(),
+          ...args
+        }
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/list-validations.ts
+import { z as z16 } from "zod";
+function registerListValidations(server) {
+  server.registerTool(
+    "list_validations",
+    {
+      description: "List a project's validation graph: core systems and validation/test tasks with their DERIVED state (passing, failing, stale, unvalidated). A task is 'stale' when a system it covers changed since it was last validated, or an upstream dependency is no longer passing. Call list_projects first to find the projectId.",
+      inputSchema: {
+        projectId: z16.string().describe("projectId from list_projects")
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({ projectId }) => {
+      const client = getConvexClient();
+      const graph = await client.action(api.mcp.listValidations, {
+        token: getToken(),
+        projectId
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(graph, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/record-validation.ts
+import { z as z17 } from "zod";
+function registerRecordValidation(server) {
+  server.registerTool(
+    "record_validation",
+    {
+      description: "Check off a validation task by recording a pass or fail. Stamps the task as validated 'now', clearing any stale flag until a covered system changes or an upstream dependency moves again. Get validationTaskId from list_validations.",
+      inputSchema: {
+        validationTaskId: z17.string().describe("validationTaskId from list_validations"),
+        result: z17.enum(["pass", "fail"]).describe("Outcome of running the test")
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({ validationTaskId, result }) => {
+      const client = getConvexClient();
+      const res = await client.action(api.mcp.recordValidation, {
+        token: getToken(),
+        validationTaskId,
+        result
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(res, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/mark-system-changed.ts
+import { z as z18 } from "zod";
+function registerMarkSystemChanged(server) {
+  server.registerTool(
+    "mark_system_changed",
+    {
+      description: "Mark a core system as changed. This is the single action that invalidates testing: every validation task that covers this system (and everything transitively depending on those tasks) immediately becomes 'stale' and needs revalidation. Get systemId from list_validations.",
+      inputSchema: {
+        systemId: z18.string().describe("systemId from list_validations")
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({ systemId }) => {
+      const client = getConvexClient();
+      const res = await client.action(api.mcp.markSystemChanged, {
+        token: getToken(),
+        systemId
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(res, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/create-system.ts
+import { z as z19 } from "zod";
+function registerCreateSystem(server) {
+  server.registerTool(
+    "create_system",
+    {
+      description: "Create a core system in a project \u2014 a subsystem (e.g. Auth, Payments, Sync) whose change should invalidate the validation tasks that cover it. Returns the new systemId.",
+      inputSchema: {
+        projectId: z19.string().describe("projectId from list_projects"),
+        name: z19.string().min(1).describe("Short system name, e.g. 'Auth'"),
+        description: z19.string().optional().describe("Optional details")
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const client = getConvexClient();
+      const res = await client.action(api.mcp.createSystem, {
+        token: getToken(),
+        ...args
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(res, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/create-validation-task.ts
+import { z as z20 } from "zod";
+function registerCreateValidationTask(server) {
+  server.registerTool(
+    "create_validation_task",
+    {
+      description: "Create a validation/test task in a project. After creating it, use add_system_to_task to declare which systems it exercises (so it goes stale when they change) and add_validation_dependency to order it after other tasks. Returns the new validationTaskId.",
+      inputSchema: {
+        projectId: z20.string().describe("projectId from list_projects"),
+        title: z20.string().min(1).describe("What this test validates"),
+        description: z20.string().optional().describe("Optional steps / details"),
+        kind: z20.enum(["auto", "manual"]).optional().describe(
+          "'auto' if runnable by a test runner, 'manual' if a human checks it. Defaults to manual."
+        ),
+        workItemId: z20.string().optional().describe(
+          "Optional workItemId to link this test to a feature for traceability"
+        )
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const client = getConvexClient();
+      const res = await client.action(api.mcp.createValidationTask, {
+        token: getToken(),
+        ...args
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(res, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/add-system-to-task.ts
+import { z as z21 } from "zod";
+function registerAddSystemToTask(server) {
+  server.registerTool(
+    "add_system_to_task",
+    {
+      description: "Declare that a validation task COVERS (exercises) a system. Once linked, the task becomes 'stale' whenever that system is marked changed. Idempotent. Both IDs come from list_validations and must be in the same project.",
+      inputSchema: {
+        validationTaskId: z21.string().describe("validationTaskId from list_validations"),
+        systemId: z21.string().describe("systemId from list_validations")
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({ validationTaskId, systemId }) => {
+      const client = getConvexClient();
+      const res = await client.action(api.mcp.addSystemToTask, {
+        token: getToken(),
+        validationTaskId,
+        systemId
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(res, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/add-validation-dependency.ts
+import { z as z22 } from "zod";
+function registerAddValidationDependency(server) {
+  server.registerTool(
+    "add_validation_dependency",
+    {
+      description: "Make one validation task depend on another (validationTaskId depends on dependsOnTaskId). The dependent goes 'stale' whenever the upstream task is not passing or gets revalidated. Cycles and self-dependencies are rejected. Idempotent. Both IDs come from list_validations and must be in the same project.",
+      inputSchema: {
+        validationTaskId: z22.string().describe("The dependent (downstream) task"),
+        dependsOnTaskId: z22.string().describe("The dependency (upstream) task it relies on")
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({ validationTaskId, dependsOnTaskId }) => {
+      const client = getConvexClient();
+      const res = await client.action(api.mcp.addValidationDependency, {
+        token: getToken(),
+        validationTaskId,
+        dependsOnTaskId
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(res, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/list-labels.ts
+import { z as z23 } from "zod";
+function registerListLabels(server) {
+  server.registerTool(
+    "list_labels",
+    {
+      description: "List all labels defined in a project. Returns each label's id, name, and color. Use the labelId with add_label_to_work_item / remove_label_from_work_item.",
+      inputSchema: {
+        projectId: z23.string().describe("projectId from list_projects")
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const result = await getConvexClient().action(api.mcp.listLabels, {
+        token: getToken(),
+        ...args
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/create-label.ts
+import { z as z24 } from "zod";
+function registerCreateLabel(server) {
+  server.registerTool(
+    "create_label",
+    {
+      description: "Create a label in a project (or return the existing one if the name is already taken \u2014 idempotent). Returns the labelId. Colors are optional; a neutral default is used when omitted.",
+      inputSchema: {
+        projectId: z24.string().describe("projectId from list_projects"),
+        name: z24.string().min(1).describe("Label name, unique within the project"),
+        color: z24.string().regex(/^#[0-9a-fA-F]{6}$/).optional().describe("Hex color like #2563eb. Defaults to a neutral slate.")
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const result = await getConvexClient().action(api.mcp.createLabel, {
+        token: getToken(),
+        ...args
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/add-label-to-work-item.ts
+import { z as z25 } from "zod";
+function registerAddLabelToWorkItem(server) {
+  server.registerTool(
+    "add_label_to_work_item",
+    {
+      description: "Attach a label to a work item (idempotent). The label and work item must be in the same project. Get labelIds from list_labels / create_label.",
+      inputSchema: {
+        workItemId: z25.string().describe("workItemId from list_work_items"),
+        labelId: z25.string().describe("labelId from list_labels or create_label")
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const result = await getConvexClient().action(api.mcp.setWorkItemLabel, {
+        token: getToken(),
+        ...args,
+        attached: true
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/remove-label-from-work-item.ts
+import { z as z26 } from "zod";
+function registerRemoveLabelFromWorkItem(server) {
+  server.registerTool(
+    "remove_label_from_work_item",
+    {
+      description: "Remove a label from a work item (idempotent \u2014 a no-op if it wasn't attached).",
+      inputSchema: {
+        workItemId: z26.string().describe("workItemId from list_work_items"),
+        labelId: z26.string().describe("labelId from list_labels")
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const result = await getConvexClient().action(api.mcp.setWorkItemLabel, {
+        token: getToken(),
+        ...args,
+        attached: false
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/list-milestones.ts
+import { z as z27 } from "zod";
+function registerListMilestones(server) {
+  server.registerTool(
+    "list_milestones",
+    {
+      description: "List all milestones in a project. Returns each milestone's id, name, description, dueDate (unix ms), and status. Use the milestoneId with add_item_to_milestone / remove_item_from_milestone.",
+      inputSchema: {
+        projectId: z27.string().describe("projectId from list_projects")
+      },
+      annotations: {
+        readOnlyHint: true,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const result = await getConvexClient().action(api.mcp.listMilestones, {
+        token: getToken(),
+        ...args
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/create-milestone.ts
+import { z as z28 } from "zod";
+function registerCreateMilestone(server) {
+  server.registerTool(
+    "create_milestone",
+    {
+      description: "Create a milestone in a project. Returns the milestoneId. Good for grouping work into phases (e.g. 'Phase 1 \u2014 Web', 'Phase 2 \u2014 Native').",
+      inputSchema: {
+        projectId: z28.string().describe("projectId from list_projects"),
+        name: z28.string().min(1).describe("Milestone name"),
+        description: z28.string().optional().describe("Optional markdown description"),
+        dueDate: z28.number().optional().describe("Optional due date as a unix timestamp in milliseconds")
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const result = await getConvexClient().action(api.mcp.createMilestone, {
+        token: getToken(),
+        ...args
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/add-item-to-milestone.ts
+import { z as z29 } from "zod";
+function registerAddItemToMilestone(server) {
+  server.registerTool(
+    "add_item_to_milestone",
+    {
+      description: "Associate a work item with a milestone (idempotent). Both must be in the same project.",
+      inputSchema: {
+        milestoneId: z29.string().describe("milestoneId from list_milestones or create_milestone"),
+        workItemId: z29.string().describe("workItemId from list_work_items")
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const result = await getConvexClient().action(
+        api.mcp.setWorkItemMilestone,
+        {
+          token: getToken(),
+          ...args,
+          attached: true
+        }
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/remove-item-from-milestone.ts
+import { z as z30 } from "zod";
+function registerRemoveItemFromMilestone(server) {
+  server.registerTool(
+    "remove_item_from_milestone",
+    {
+      description: "Remove a work item's association with a milestone (idempotent \u2014 a no-op if it wasn't associated).",
+      inputSchema: {
+        milestoneId: z30.string().describe("milestoneId from list_milestones"),
+        workItemId: z30.string().describe("workItemId from list_work_items")
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (args) => {
+      const result = await getConvexClient().action(
+        api.mcp.setWorkItemMilestone,
+        {
+          token: getToken(),
+          ...args,
+          attached: false
+        }
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/server.ts
+function createServer() {
+  const server = new McpServer({
+    name: "nimara",
+    version: "0.1.0"
+  });
+  registerListOrgs(server);
+  registerListProjects(server);
+  registerListWorkItems(server);
+  registerListAiReviewQueue(server);
+  registerCreateProject(server);
+  registerCreateWorkItem(server);
+  registerUpdateWorkItem(server);
+  registerCreateDocument(server);
+  registerUpdateDocument(server);
+  registerListDocuments(server);
+  registerCreateProjectLink(server);
+  registerListProjectLinks(server);
+  registerAddWorkItemImage(server);
+  registerListWorkItemImages(server);
+  registerAddWorkItemComment(server);
+  registerListWorkItemComments(server);
+  registerListValidations(server);
+  registerRecordValidation(server);
+  registerMarkSystemChanged(server);
+  registerCreateSystem(server);
+  registerCreateValidationTask(server);
+  registerAddSystemToTask(server);
+  registerAddValidationDependency(server);
+  registerListLabels(server);
+  registerCreateLabel(server);
+  registerAddLabelToWorkItem(server);
+  registerRemoveLabelFromWorkItem(server);
+  registerListMilestones(server);
+  registerCreateMilestone(server);
+  registerAddItemToMilestone(server);
+  registerRemoveItemFromMilestone(server);
+  return server;
+}
+
+// src/index.ts
+for (const m of ["log", "info", "warn", "debug"]) {
+  console[m] = (...args) => console.error(...args);
+}
+async function main() {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  console.error("nimara-mcp: fatal error", err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map