@ourroadmaps/mcp 0.18.1 → 0.19.0

package/dist/index.js

@@ -899,6 +899,36 @@ class ApiClient {
       method: "DELETE"
     });
   }
+  async listInitiatives() {
+    const response = await this.request("/v1/initiatives");
+    return response.data;
+  }
+  async getInitiative(id) {
+    return await this.request(`/v1/initiatives/${id}`);
+  }
+  async createInitiative(data) {
+    return await this.request("/v1/initiatives", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateInitiative(id, data) {
+    return await this.request(`/v1/initiatives/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteInitiative(id) {
+    await this.request(`/v1/initiatives/${id}`, {
+      method: "DELETE"
+    });
+  }
+  async reorderInitiatives(items) {
+    return await this.request("/v1/initiatives/reorder", {
+      method: "POST",
+      body: JSON.stringify({ items })
+    });
+  }
   async updateDesignDescription(roadmapId, description) {
     const response = await this.request(`/v1/designs/roadmaps/${roadmapId}/design`, {
       method: "PATCH",
@@ -1018,6 +1048,12 @@ function registerAllTools(server) {
   registerGetHistorySummary(server);
   registerCreateStatusUpdate(server);
   registerSaveStories(server);
+  registerSearchInitiatives(server);
+  registerGetInitiative(server);
+  registerCreateInitiative(server);
+  registerUpdateInitiative(server);
+  registerDeleteInitiative(server);
+  registerReorderInitiatives(server);
   registerUploadWireframe(server);
   registerUpdateWireframe(server);
   registerDeleteWireframe(server);
@@ -1345,19 +1381,25 @@ function registerCreateRoadmapItem(server) {
     inputSchema: {
       title: z11.string().describe("Title of the roadmap item"),
       status: roadmapStatusSchema.optional().describe('Status (defaults to "not_started")'),
-      horizon: horizonSchema.optional().describe('Planning horizon (defaults to "inbox")')
+      horizon: horizonSchema.optional().describe('Planning horizon (defaults to "inbox")'),
+      initiativeId: z11.string().optional().describe("UUID of initiative to link this item to on creation")
     }
   }, async ({
     title,
     status,
-    horizon
+    horizon,
+    initiativeId
   }) => {
     const client2 = getApiClient();
-    const roadmap2 = await client2.createRoadmap({
+    const createData = {
       title,
       status: status ?? "not_started",
       horizon: horizon ?? "inbox"
-    });
+    };
+    if (initiativeId) {
+      createData.initiativeId = initiativeId;
+    }
+    const roadmap2 = await client2.createRoadmap(createData);
     return {
       content: [
         {
@@ -1379,7 +1421,7 @@ function registerCreateRoadmapItem(server) {
 var effortSizeSchema = z11.enum(["xs", "s", "m", "l", "xl"]);
 function registerUpdateRoadmapItem(server) {
   server.registerTool("update_roadmap_item", {
-    description: "Update an existing roadmap item. Can update title, status, horizon, value, effort, order, prompt, or brainstorm notes.",
+    description: "Update an existing roadmap item. Can update title, status, horizon, value, effort, order, prompt, initiative link, or brainstorm notes.",
     inputSchema: {
       id: z11.string().describe("The UUID of the roadmap item to update"),
       title: z11.string().optional().describe("New title"),
@@ -1388,6 +1430,7 @@ function registerUpdateRoadmapItem(server) {
       value: z11.number().int().min(1).max(3).nullable().optional().describe("Value rating (1-3 stars, where 3 is highest value)"),
       effort: effortSizeSchema.nullable().optional().describe("Effort estimate (xs=extra small, s=small, m=medium, l=large, xl=extra large)"),
       order: z11.number().int().min(0).optional().describe("Sort order for prioritization (lower numbers appear first)"),
+      initiativeId: z11.string().nullable().optional().describe("UUID to link item to initiative, or null to unlink from any initiative"),
       designDescription: z11.string().nullable().optional().describe("Description for the Design phase"),
       planDescription: z11.string().nullable().optional().describe("Description for the Planning phase"),
       buildDescription: z11.string().nullable().optional().describe("Description for the Build phase"),
@@ -1402,6 +1445,7 @@ function registerUpdateRoadmapItem(server) {
     value,
     effort,
     order,
+    initiativeId,
     designDescription,
     planDescription,
     buildDescription,
@@ -1422,6 +1466,8 @@ function registerUpdateRoadmapItem(server) {
       updates.effort = effort;
     if (order !== undefined)
       updates.order = order;
+    if (initiativeId !== undefined)
+      updates.initiativeId = initiativeId;
     const roadmap2 = Object.keys(updates).length > 0 ? await client2.updateRoadmap(id, updates) : await client2.getRoadmap(id);
     const phaseUpdates = {};
     if (designDescription !== undefined) {
@@ -3068,6 +3114,231 @@ Expires: ${expiryDate}`
     };
   });
 }
+var dateGranularitySchema2 = z11.enum(["day", "month", "quarter", "half_year", "year"]);
+function registerSearchInitiatives(server) {
+  server.registerTool("search_initiatives", {
+    description: "Search for initiatives by title or filter by horizon. Returns a list of matching initiatives with item counts.",
+    inputSchema: {
+      query: z11.string().optional().describe("Search query to match against title or description"),
+      horizon: horizonSchema.optional().describe("Filter by planning horizon"),
+      limit: z11.number().int().min(1).max(100).optional().describe("Max items to return (default 10)"),
+      offset: z11.number().int().min(0).optional().describe("Number of items to skip (default 0)")
+    }
+  }, async ({
+    query,
+    horizon,
+    limit = 10,
+    offset = 0
+  }) => {
+    const client2 = getApiClient();
+    let initiatives = await client2.listInitiatives();
+    if (query) {
+      const lowerQuery = query.toLowerCase();
+      initiatives = initiatives.filter((i) => i.title.toLowerCase().includes(lowerQuery) || i.description?.toLowerCase().includes(lowerQuery));
+    }
+    if (horizon) {
+      initiatives = initiatives.filter((i) => i.horizon === horizon);
+    }
+    const total = initiatives.length;
+    const paginatedInitiatives = initiatives.slice(offset, offset + limit);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            items: paginatedInitiatives.map((i) => ({
+              id: i.id,
+              title: i.title,
+              description: i.description,
+              horizon: i.horizon,
+              targetDate: i.targetDate,
+              itemCount: i.itemCount,
+              doneCount: i.doneCount,
+              order: i.order
+            })),
+            pagination: {
+              limit,
+              offset,
+              total,
+              hasMore: offset + limit < total
+            }
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerGetInitiative(server) {
+  server.registerTool("get_initiative", {
+    description: "Get full details of an initiative including all linked roadmap items.",
+    inputSchema: {
+      id: z11.string().describe("The UUID of the initiative")
+    }
+  }, async ({ id }) => {
+    const client2 = getApiClient();
+    const result = await client2.getInitiative(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerCreateInitiative(server) {
+  server.registerTool("create_initiative", {
+    description: "Create a new initiative. Initiatives group related roadmap items for cross-functional coordination.",
+    inputSchema: {
+      title: z11.string().describe("Title of the initiative"),
+      description: z11.string().optional().describe("Description of the initiative (markdown)"),
+      horizon: horizonSchema.optional().describe('Planning horizon (defaults to "inbox")'),
+      dateGranularity: dateGranularitySchema2.optional().describe("Target date granularity: day, month, quarter, half_year, or year"),
+      dateValue: z11.string().optional().describe('Target date value matching granularity (e.g., "2024-Q1", "2024-03")'),
+      targetDate: z11.string().optional().describe("Target date in YYYY-MM-DD format")
+    }
+  }, async ({
+    title,
+    description,
+    horizon,
+    dateGranularity,
+    dateValue,
+    targetDate
+  }) => {
+    const client2 = getApiClient();
+    const initiative = await client2.createInitiative({
+      title,
+      description: description ?? null,
+      horizon: horizon ?? "inbox",
+      dateGranularity: dateGranularity ?? null,
+      dateValue: dateValue ?? null,
+      targetDate: targetDate ?? null
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            initiative: {
+              id: initiative.id,
+              title: initiative.title,
+              description: initiative.description,
+              horizon: initiative.horizon,
+              targetDate: initiative.targetDate,
+              itemCount: initiative.itemCount,
+              doneCount: initiative.doneCount
+            }
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerUpdateInitiative(server) {
+  server.registerTool("update_initiative", {
+    description: "Update an existing initiative.",
+    inputSchema: {
+      id: z11.string().describe("The UUID of the initiative to update"),
+      title: z11.string().optional().describe("New title"),
+      description: z11.string().nullable().optional().describe("New description (null to clear)"),
+      horizon: horizonSchema.optional().describe("New planning horizon"),
+      dateGranularity: dateGranularitySchema2.nullable().optional().describe("New target date granularity (null to clear)"),
+      dateValue: z11.string().nullable().optional().describe("New target date value (null to clear)"),
+      targetDate: z11.string().nullable().optional().describe("New target date in YYYY-MM-DD format (null to clear)"),
+      order: z11.number().int().min(0).optional().describe("Sort order for prioritization (lower numbers appear first)")
+    }
+  }, async ({
+    id,
+    title,
+    description,
+    horizon,
+    dateGranularity,
+    dateValue,
+    targetDate,
+    order
+  }) => {
+    const client2 = getApiClient();
+    const updates = {};
+    if (title !== undefined)
+      updates.title = title;
+    if (description !== undefined)
+      updates.description = description;
+    if (horizon !== undefined)
+      updates.horizon = horizon;
+    if (dateGranularity !== undefined)
+      updates.dateGranularity = dateGranularity;
+    if (dateValue !== undefined)
+      updates.dateValue = dateValue;
+    if (targetDate !== undefined)
+      updates.targetDate = targetDate;
+    if (order !== undefined)
+      updates.order = order;
+    const initiative = await client2.updateInitiative(id, updates);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            initiative: {
+              id: initiative.id,
+              title: initiative.title,
+              description: initiative.description,
+              horizon: initiative.horizon,
+              targetDate: initiative.targetDate,
+              itemCount: initiative.itemCount,
+              doneCount: initiative.doneCount,
+              order: initiative.order
+            }
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerDeleteInitiative(server) {
+  server.registerTool("delete_initiative", {
+    description: "Delete an initiative. This is a soft delete that also unlinks all roadmap items from the initiative.",
+    inputSchema: {
+      id: z11.string().describe("The UUID of the initiative to delete")
+    }
+  }, async ({ id }) => {
+    const client2 = getApiClient();
+    await client2.deleteInitiative(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, deleted: id }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerReorderInitiatives(server) {
+  server.registerTool("reorder_initiatives", {
+    description: "Bulk reorder initiatives by setting their order values. Lower order values appear first.",
+    inputSchema: {
+      items: z11.array(z11.object({
+        id: z11.string().describe("The UUID of the initiative"),
+        order: z11.number().int().min(0).describe("The new order value (0-based)")
+      })).describe("Array of initiatives with their new order values")
+    }
+  }, async ({ items }) => {
+    const client2 = getApiClient();
+    await client2.reorderInitiatives(items);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, reordered: items.length }, null, 2)
+        }
+      ]
+    };
+  });
+}
 
 // src/index.ts
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ourroadmaps/mcp",
-  "version": "0.18.1",
+  "version": "0.19.0",
   "description": "MCP server for OurRoadmaps - manage roadmaps, features, and ideas from Claude Code",
   "type": "module",
   "bin": {