@limeadelabs/launchpad-mcp 1.0.0 → 1.1.0

package/README.md

@@ -54,11 +54,21 @@ Or add manually to `~/.claude/claude_desktop_config.json`:
 | `lp_list_pages` | List spec/doc pages for a project |
 | `lp_get_page` | Get a page's full content |
 | `lp_get_workflow` | Get valid workflow states and transitions |
+| `lp_context_list` | List context entries with optional filters (project, type, search) |
+| `lp_context_get` | Fetch a context entry's full content by slug or ID |
+| `lp_context_package` | Get assembled context package for a task (org + project entries, specs, comments) |
+| `lp_context_update` | Update a context entry's content (requires write access) |
 
 ## Resources
 
 - `launchpad://project/{id}/context` — Project instructions, conventions, and page summaries
 - `launchpad://task/{id}/spec` — Full generated task spec
+- `context://entries` — Browse all active context entries
+- `context://entries/{slug}` — Read a specific context entry
+
+### Resources vs Tools
+
+Resources are for **passive browsing** in the Claude Code resource panel. Tools are for **active agent invocation** during conversation. Both access the same underlying context registry API.
 
 ## Prompts
 

package/dist/index.js

@@ -99,6 +99,25 @@ var LaunchPadClient = class {
   getWorkflow(projectId) {
     return this.request("GET", `/projects/${projectId}/workflow`);
   }
+  listContextEntries(params) {
+    const searchParams = new URLSearchParams();
+    if (params?.project_id !== void 0) searchParams.set("project_id", String(params.project_id));
+    if (params?.entry_type) searchParams.set("entry_type", params.entry_type);
+    if (params?.search) searchParams.set("search", params.search);
+    if (params?.limit !== void 0) searchParams.set("limit", String(params.limit));
+    if (params?.offset !== void 0) searchParams.set("offset", String(params.offset));
+    const query = searchParams.toString();
+    return this.request("GET", `/context_entries${query ? `?${query}` : ""}`);
+  }
+  getContextEntry(identifier) {
+    return this.request("GET", `/context_entries/${encodeURIComponent(identifier)}`);
+  }
+  getTaskContextPackage(taskId) {
+    return this.request("GET", `/tasks/${taskId}/context`);
+  }
+  updateContextEntry(identifier, data) {
+    return this.request("PATCH", `/context_entries/${encodeURIComponent(identifier)}`, data);
+  }
 };
 
 // src/tools/shared.ts
@@ -402,6 +421,96 @@ function registerPageTools(server2, client2) {
   );
 }
 
+// src/tools/context.ts
+import { z as z8 } from "zod";
+function registerContextTools(server2, client2) {
+  server2.tool(
+    "lp_context_list",
+    "List available context entries with optional filters",
+    {
+      project_id: z8.number().optional().describe("Filter by project ID"),
+      entry_type: z8.string().optional().describe("Filter by entry type"),
+      search: z8.string().optional().describe("Text search on entry name"),
+      limit: z8.number().min(1).max(100).optional().describe("Max entries to return (default 50)"),
+      offset: z8.number().min(0).optional().describe("Offset for pagination")
+    },
+    async (params) => {
+      try {
+        const result = await client2.listContextEntries(params);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return handleError(error, client2.timeoutMs);
+      }
+    }
+  );
+  server2.tool(
+    "lp_context_get",
+    "Fetch a specific context entry by slug or ID",
+    {
+      slug: z8.string().optional().describe("Entry slug"),
+      id: z8.number().optional().describe("Entry ID")
+    },
+    async (params) => {
+      const identifier = params.slug || (params.id !== void 0 ? String(params.id) : void 0);
+      if (!identifier) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: true, code: "validation_error", message: "Either slug or id is required" }) }],
+          isError: true
+        };
+      }
+      try {
+        const result = await client2.getContextEntry(identifier);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return handleError(error, client2.timeoutMs);
+      }
+    }
+  );
+  server2.tool(
+    "lp_context_package",
+    "Get the assembled context package for a task \u2014 org entries, project entries, specs, comments",
+    {
+      task_id: z8.number().describe("Task ID")
+    },
+    async (params) => {
+      try {
+        const result = await client2.getTaskContextPackage(params.task_id);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return handleError(error, client2.timeoutMs);
+      }
+    }
+  );
+  server2.tool(
+    "lp_context_update",
+    "Update a context entry's content (requires write access)",
+    {
+      slug: z8.string().optional().describe("Entry slug"),
+      id: z8.number().optional().describe("Entry ID"),
+      content: z8.string().describe("New markdown content"),
+      change_summary: z8.string().describe("What changed and why")
+    },
+    async (params) => {
+      const identifier = params.slug || (params.id !== void 0 ? String(params.id) : void 0);
+      if (!identifier) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: true, code: "validation_error", message: "Either slug or id is required" }) }],
+          isError: true
+        };
+      }
+      try {
+        const result = await client2.updateContextEntry(identifier, {
+          content: params.content,
+          change_summary: params.change_summary
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return handleError(error, client2.timeoutMs);
+      }
+    }
+  );
+}
+
 // src/resources/project-context.ts
 function registerProjectContextResource(server2, client2) {
   server2.resource(
@@ -479,14 +588,79 @@ function registerTaskSpecResource(server2, client2) {
   );
 }
 
+// src/resources/context-entries.ts
+function registerContextEntriesResource(server2, client2) {
+  server2.resource(
+    "context-entries",
+    "context://entries",
+    {
+      description: "Browse all active context entries"
+    },
+    async (uri) => {
+      const result = await client2.listContextEntries();
+      const lines = ["# Context Entries\n"];
+      for (const entry of result.entries) {
+        const project = entry.project ? ` (${entry.project.name})` : "";
+        lines.push(`- **${entry.name}**${project} \u2014 \`${entry.slug}\` [${entry.entry_type}] (v${entry.version_count}, updated ${entry.updated_at})`);
+      }
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "text/markdown",
+            text: lines.join("\n")
+          }
+        ]
+      };
+    }
+  );
+  server2.resource(
+    "context-entry",
+    "context://entries/{slug}",
+    {
+      description: "Read a specific context entry by slug"
+    },
+    async (uri) => {
+      if (uri.host !== "entries" || !uri.pathname || uri.pathname === "/") {
+        throw new Error(`Invalid URI: ${uri.href}`);
+      }
+      const slug = decodeURIComponent(uri.pathname.slice(1));
+      const result = await client2.getContextEntry(slug);
+      const entry = result.entry;
+      const text = [
+        `# ${entry.name}`,
+        ``,
+        `- **Type:** ${entry.entry_type}`,
+        `- **Slug:** ${entry.slug}`,
+        `- **Version:** ${entry.version}`,
+        `- **Updated:** ${entry.updated_at}`,
+        entry.project ? `- **Project:** ${entry.project.name}` : null,
+        ``,
+        `---`,
+        ``,
+        entry.content
+      ].filter(Boolean).join("\n");
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "text/markdown",
+            text
+          }
+        ]
+      };
+    }
+  );
+}
+
 // src/prompts/start-task.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 function registerStartTaskPrompt(server2) {
   server2.prompt(
     "lp_start_task",
     "Guided workflow: find a task, claim it, get context, start working",
     {
-      project_id: z8.string().optional().describe("Optional project ID to filter tasks")
+      project_id: z9.string().optional().describe("Optional project ID to filter tasks")
     },
     async (args) => {
       const projectLine = args.project_id ? ` Project ID: ${args.project_id}.` : "";
@@ -516,14 +690,14 @@ IMPORTANT: If this task takes more than 20 minutes, call lp_heartbeat every 20 m
 }
 
 // src/prompts/submit-task.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 function registerSubmitTaskPrompt(server2) {
   server2.prompt(
     "lp_submit_task",
     "Guided workflow: mark task done, add summary comment, release claim",
     {
-      task_id: z9.string().describe("Task ID to submit"),
-      summary: z9.string().describe("Summary of what was completed")
+      task_id: z10.string().describe("Task ID to submit"),
+      summary: z10.string().describe("Summary of what was completed")
     },
     async (args) => {
       return {
@@ -572,7 +746,7 @@ try {
 }
 var server = new McpServer({
   name: "launchpad",
-  version: "1.0.0"
+  version: "1.1.0"
 });
 registerBootstrapTool(server, client);
 registerProjectTools(server, client);
@@ -582,8 +756,10 @@ registerCommentTools(server, client);
 registerTimeTools(server, client);
 registerPromptTools(server, client);
 registerPageTools(server, client);
+registerContextTools(server, client);
 registerProjectContextResource(server, client);
 registerTaskSpecResource(server, client);
+registerContextEntriesResource(server, client);
 registerStartTaskPrompt(server);
 registerSubmitTaskPrompt(server);
 var transport = new StdioServerTransport();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limeadelabs/launchpad-mcp",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "LaunchPad MCP server for Claude Code — AI-native project management integration",
   "type": "module",
   "exports": {