@limeadelabs/launchpad-mcp 1.0.0 → 1.2.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

@@ -20,8 +20,8 @@ var LaunchPadClient = class {
     this.apiKey = config.apiKey;
     this.timeoutMs = config.timeoutMs ?? 1e4;
   }
-  async request(method, path, body) {
-    const url = `${this.baseUrl}/api/v1${path}`;
+  async request(method, path2, body) {
+    const url = `${this.baseUrl}/api/v1${path2}`;
     const res = await fetch(url, {
       method,
       headers: {
@@ -34,7 +34,7 @@ var LaunchPadClient = class {
     if (!res.ok) {
       const error = await res.json().catch(() => ({ error: res.statusText }));
       throw new LaunchPadError(
-        `${method} ${path}: ${res.status} \u2014 ${error.error || res.statusText}`,
+        `${method} ${path2}: ${res.status} \u2014 ${error.error || res.statusText}`,
         res.status
       );
     }
@@ -99,6 +99,44 @@ 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", `/contexts${query ? `?${query}` : ""}`);
+  }
+  getContextEntry(identifier) {
+    return this.request("GET", `/contexts/${encodeURIComponent(identifier)}`);
+  }
+  getTaskContextPackage(taskId) {
+    return this.request("GET", `/tasks/${taskId}/context`);
+  }
+  updateContextEntry(identifier, data) {
+    return this.request("PATCH", `/contexts/${encodeURIComponent(identifier)}`, data);
+  }
+  createSession(taskId, agentType, agentId) {
+    return this.request("POST", "/sessions", {
+      task_id: taskId,
+      agent_type: agentType ?? "claude_code",
+      ...agentId !== void 0 && { agent_id: agentId }
+    });
+  }
+  sessionHeartbeat(sessionId) {
+    return this.request("POST", `/sessions/${sessionId}/heartbeat`);
+  }
+  updateSession(sessionId, data) {
+    return this.request("PATCH", `/sessions/${sessionId}`, data);
+  }
+  createSessionEvent(sessionId, eventType, payload) {
+    return this.request("POST", `/sessions/${sessionId}/events`, {
+      event_type: eventType,
+      payload
+    });
+  }
 };
 
 // src/tools/shared.ts
@@ -402,6 +440,281 @@ 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 task details, context entries, specs, pages, 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/tools/sessions.ts
+import { z as z9 } from "zod";
+
+// src/session-store.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var SESSION_FILE = path.join(os.homedir(), ".launchpad", "active-session.json");
+function saveSession(taskId, sessionId) {
+  const dir = path.dirname(SESSION_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  const data = fs.existsSync(SESSION_FILE) ? JSON.parse(fs.readFileSync(SESSION_FILE, "utf8")) : {};
+  data[String(taskId)] = sessionId;
+  fs.writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2));
+}
+function getSessionId(taskId) {
+  if (!fs.existsSync(SESSION_FILE)) return null;
+  const data = JSON.parse(fs.readFileSync(SESSION_FILE, "utf8"));
+  return data[String(taskId)] ?? null;
+}
+function clearSession(taskId) {
+  if (!fs.existsSync(SESSION_FILE)) return;
+  const data = JSON.parse(fs.readFileSync(SESSION_FILE, "utf8"));
+  delete data[String(taskId)];
+  fs.writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2));
+}
+
+// src/tools/sessions.ts
+function registerSessionTools(server2, client2) {
+  server2.tool(
+    "lp_session_start",
+    "Start a new agent session for a task. Creates session via API and saves session_id to disk for later lookup.",
+    {
+      task_id: z9.number().describe("LaunchPad task ID"),
+      agent_type: z9.string().optional().describe("Agent type (default: claude_code)")
+    },
+    async ({ task_id, agent_type }) => {
+      try {
+        const result = await client2.createSession(task_id, agent_type);
+        saveSession(task_id, result.session.id);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        return handleError(error, client2.timeoutMs);
+      }
+    }
+  );
+  server2.tool(
+    "lp_session_heartbeat",
+    "Send a heartbeat for an active session. Provide session_id directly or task_id to look up session from disk. Graceful no-op if neither provided.",
+    {
+      session_id: z9.number().optional().describe("Session ID"),
+      task_id: z9.number().optional().describe("Task ID to look up session from disk")
+    },
+    async ({ session_id, task_id }) => {
+      try {
+        const resolvedId = session_id ?? (task_id !== void 0 ? getSessionId(task_id) : null);
+        if (resolvedId === null) {
+          return {
+            content: [{ type: "text", text: "No active session found. Provide session_id or task_id." }]
+          };
+        }
+        const result = await client2.sessionHeartbeat(resolvedId);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        return handleError(error, client2.timeoutMs);
+      }
+    }
+  );
+  server2.tool(
+    "lp_session_progress",
+    'Report progress on an active session. Sends an activity update with action "progress".',
+    {
+      session_id: z9.number().describe("Session ID"),
+      detail: z9.string().describe("Description of progress made")
+    },
+    async ({ session_id, detail }) => {
+      try {
+        const result = await client2.updateSession(session_id, {
+          activity: { action: "progress", detail }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        return handleError(error, client2.timeoutMs);
+      }
+    }
+  );
+  server2.tool(
+    "lp_session_event",
+    "Log a discrete event for a session (commit, ci_pass, ci_fail, pr_opened, blocker, cost_update).",
+    {
+      session_id: z9.number().describe("Session ID"),
+      event_type: z9.enum(["commit", "ci_pass", "ci_fail", "pr_opened", "blocker", "cost_update"]).describe("Type of event"),
+      payload: z9.record(z9.unknown()).describe("Event payload data")
+    },
+    async ({ session_id, event_type, payload }) => {
+      try {
+        const result = await client2.createSessionEvent(session_id, event_type, payload);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        return handleError(error, client2.timeoutMs);
+      }
+    }
+  );
+  server2.tool(
+    "lp_session_blocked",
+    'Mark a session as blocked. Updates status to "blocked" and logs a blocker event.',
+    {
+      session_id: z9.number().describe("Session ID"),
+      reason: z9.string().describe("Reason the session is blocked")
+    },
+    async ({ session_id, reason }) => {
+      try {
+        const [sessionResult, eventResult] = await Promise.all([
+          client2.updateSession(session_id, { status: "blocked" }),
+          client2.createSessionEvent(session_id, "blocker", { reason })
+        ]);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ session: sessionResult.session, event: eventResult.event }, null, 2)
+          }]
+        };
+      } catch (error) {
+        return handleError(error, client2.timeoutMs);
+      }
+    }
+  );
+  server2.tool(
+    "lp_session_complete",
+    "Mark a session as completed with a result summary. Clears session from disk.",
+    {
+      session_id: z9.number().describe("Session ID"),
+      result_summary: z9.string().describe("Summary of what was accomplished"),
+      task_id: z9.number().optional().describe("Task ID to clear from disk (if not provided, derived from session)")
+    },
+    async ({ session_id, result_summary, task_id }) => {
+      try {
+        const result = await client2.updateSession(session_id, {
+          status: "completed",
+          result_summary
+        });
+        const resolvedTaskId = task_id ?? result.session.task_id;
+        clearSession(resolvedTaskId);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        return handleError(error, client2.timeoutMs);
+      }
+    }
+  );
+  server2.tool(
+    "lp_session_fail",
+    "Mark a session as failed with an error detail. Clears session from disk.",
+    {
+      session_id: z9.number().describe("Session ID"),
+      error_detail: z9.string().describe("Description of the failure"),
+      task_id: z9.number().optional().describe("Task ID to clear from disk (if not provided, derived from session)")
+    },
+    async ({ session_id, error_detail, task_id }) => {
+      try {
+        const result = await client2.updateSession(session_id, {
+          status: "failed",
+          result_summary: error_detail
+        });
+        const resolvedTaskId = task_id ?? result.session.task_id;
+        clearSession(resolvedTaskId);
+        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 +792,80 @@ 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));
+      if (!slug) throw new Error("Empty slug in context entry URI");
+      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 z10 } 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: z10.string().optional().describe("Optional project ID to filter tasks")
     },
     async (args) => {
       const projectLine = args.project_id ? ` Project ID: ${args.project_id}.` : "";
@@ -516,14 +895,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 z11 } 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: z11.string().describe("Task ID to submit"),
+      summary: z11.string().describe("Summary of what was completed")
     },
     async (args) => {
       return {
@@ -572,7 +951,7 @@ try {
 }
 var server = new McpServer({
   name: "launchpad",
-  version: "1.0.0"
+  version: "1.2.0"
 });
 registerBootstrapTool(server, client);
 registerProjectTools(server, client);
@@ -582,8 +961,11 @@ registerCommentTools(server, client);
 registerTimeTools(server, client);
 registerPromptTools(server, client);
 registerPageTools(server, client);
+registerContextTools(server, client);
+registerSessionTools(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.2.0",
   "description": "LaunchPad MCP server for Claude Code — AI-native project management integration",
   "type": "module",
   "exports": {