@promptprojectmanager/mcp-server 2.8.1

package/dist/index.js

@@ -0,0 +1,1010 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import minimist from "minimist";
+
+// src/convex-client.ts
+import { ConvexHttpClient } from "convex/browser";
+var PROD_URL = "https://trustworthy-squirrel-735.convex.cloud";
+var DEV_URL = "https://hallowed-shrimp-344.convex.cloud";
+function createConvexClient(isDev) {
+  const url = isDev ? DEV_URL : PROD_URL;
+  return new ConvexHttpClient(url);
+}
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/prompt-builder.ts
+function sanitizeForMcp(str) {
+  return str.trim().toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").trim();
+}
+function buildPromptName(prompt) {
+  const workspace = sanitizeForMcp(prompt.workspaceSlug || "default") || "default";
+  const promptSlug = sanitizeForMcp(prompt.slug || "unknown") || "unknown";
+  return `${workspace}:${promptSlug}`.trim();
+}
+function buildPromptSchema(prompt) {
+  return {
+    name: buildPromptName(prompt),
+    description: prompt.description || `Prompt: ${prompt.name}`,
+    arguments: []
+  };
+}
+function buildPromptHandler(prompt, config, convexClient) {
+  return async () => {
+    let flattenedPrompt = prompt.flattenedPrompt;
+    let promptName = prompt.name;
+    try {
+      let freshPrompts = await convexClient.query("mcp_prompts:getMcpPrompts", {
+        apiKey: config.apiKey
+      });
+      if (config.selectedWorkspaces.length > 0) {
+        freshPrompts = freshPrompts.filter(
+          (p) => p.workspaceSlug && config.selectedWorkspaces.includes(p.workspaceSlug)
+        );
+      }
+      const freshPrompt = freshPrompts.find((p) => p.slug === prompt.slug && p.workspaceSlug === prompt.workspaceSlug);
+      if (freshPrompt) {
+        flattenedPrompt = freshPrompt.flattenedPrompt;
+        promptName = freshPrompt.name;
+        console.error(`[MCP] Fetched fresh data for: ${buildPromptName(prompt)}`);
+      } else {
+        console.error(
+          `[MCP] WARNING: Prompt "${prompt.slug}" not found in fresh fetch, using cached version`
+        );
+      }
+    } catch (error) {
+      console.error(
+        `[MCP] WARNING: Failed to fetch fresh data, using cached version: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+    if (!flattenedPrompt) {
+      throw new Error(
+        `Prompt "${promptName}" has no flattened content. Please re-save the prompt in ContextFS to regenerate it.`
+      );
+    }
+    console.error(`[MCP] Executed prompt: ${buildPromptName(prompt)}`);
+    return {
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: flattenedPrompt
+          }
+        }
+      ]
+    };
+  };
+}
+
+// src/server.ts
+var SYSTEM_TOOLS = [
+  // User-facing slash command: /ppm:system:optimize
+  {
+    name: "system:optimize",
+    description: "Evaluate a prompt and submit optimization suggestions to Prompt Project Manager",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    },
+    isSlashCommand: true,
+    promptContent: `# Optimize
+
+Evaluate the prompt you just used and submit optimization suggestions.
+
+## Instructions
+
+1. **Identify the prompt** from the PREVIOUS tool call in this conversation:
+   - Look at the last \`/ppm:*\` slash command or MCP tool you called
+   - The format is \`/ppm:workspace:prompt\` (e.g., \`/ppm:test:joke\` means workspace=\`test\`, prompt=\`joke\`)
+   - Extract the workspace slug (before the colon) and prompt slug (after the colon)
+   - **CRITICAL**: Use the EXACT slugs from the tool name, do NOT guess or invent slugs
+
+2. **Evaluate** for issues in these categories:
+   - **clarity**: Is the language clear and unambiguous?
+   - **specificity**: Are instructions specific enough?
+   - **structure**: Is the organization logical?
+   - **completeness**: Are there missing instructions?
+   - **efficiency**: Is there redundancy to remove?
+
+3. **Call the submission tool** (\`system:optimize-prompt\`) with:
+   - \`promptSlug\`: The prompt's slug
+   - \`workspaceSlug\`: The workspace slug
+   - \`suggestions\`: Array of issues found, each with category, priority, issue, originalText (optional), suggestedText
+
+4. The tool will submit and confirm the count
+
+## Scope of Analysis
+
+**CRITICAL - READ CAREFULLY**:
+
+The flattened prompt contains TWO parts:
+1. **MAIN PROMPT CONTENT** (at the top) - This is what you should analyze
+2. **Technical Reference Footer** (at the bottom) - **COMPLETELY IGNORE THIS ENTIRE SECTION**
+
+**The Technical Reference Footer starts with \`# Technical Reference\` and includes:**
+- \`## Variable Definitions:\` - Contains variable names, types, and descriptions
+- \`## Snippet Definitions:\` - Contains snippet content
+- \`## CRITICAL RULES:\` - System rules
+- \`## Runtime Variables:\` - Runtime placeholders
+
+**IGNORE ALL CONTENT IN THE TECHNICAL REFERENCE FOOTER** - even if it contains typos, grammar issues, or formatting problems. These sections are auto-generated from user-defined resources and should NOT be optimized through this tool.
+
+**Only analyze and suggest changes for content BEFORE the \`# Technical Reference\` heading.**
+
+## User Feedback
+
+If the user provided feedback about issues they experienced, it appears below:
+
+**Feedback**: $ARGUMENTS
+
+When feedback is provided:
+- Treat it as context about real problems encountered during use
+- Prioritize suggestions that address the described issues
+- Look for patterns in the prompt that could cause the mentioned problem
+
+## Important
+
+- Don't suggest changes to variable references like \`[VARIABLE_NAME]\` - those are intentional
+- The user will review suggestions in Prompt Project Manager web UI`
+  },
+  // User-facing slash command: /ppm:system:feedback
+  {
+    name: "system:feedback",
+    description: "Submit user feedback about a prompt to create an optimization suggestion",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    },
+    isSlashCommand: true,
+    promptContent: `# Feedback
+
+Submit your feedback about a prompt to create an optimization suggestion.
+
+## Instructions
+
+1. **Identify the prompt** from the PREVIOUS tool call in this conversation:
+   - Look at the last \`/ppm:*\` slash command or MCP tool you called
+   - The format is \`/ppm:workspace:prompt\` (e.g., \`/ppm:test:joke\` means workspace=\`test\`, prompt=\`joke\`)
+   - Extract the workspace slug (before the colon) and prompt slug (after the colon)
+   - **CRITICAL**: Use the EXACT slugs from the tool name, do NOT guess or invent slugs
+
+2. **Read the user's feedback** from $ARGUMENTS below
+
+3. **Structure the feedback** into a proper optimization suggestion:
+   - Determine the most appropriate category: clarity, specificity, structure, completeness, or efficiency
+   - Assess priority: "high" (critical issue), "medium" (noticeable problem), "low" (minor improvement)
+   - Identify the specific text to change (originalText) if applicable
+   - Write a clear, actionable fix (suggestedText)
+
+4. **Call the submission tool** (\`system:optimize-prompt\`) with:
+   - \`promptSlug\`: The prompt's slug
+   - \`workspaceSlug\`: The workspace slug
+   - \`suggestions\`: Array containing a SINGLE suggestion based on the user's feedback
+
+## User Feedback
+
+**$ARGUMENTS**
+
+## Scope of Analysis
+
+When analyzing the prompt to address the feedback:
+- **ONLY** focus on content BEFORE the \`# Technical Reference\` heading
+- **IGNORE** the Technical Reference Footer (Variable Definitions, Snippet Definitions, CRITICAL RULES, Runtime Variables)
+- Don't suggest changes to variable references like \`[VARIABLE_NAME]\` - those are intentional
+
+## Example
+
+If the user runs:
+\`/feedback the output format should specify JSON not markdown\`
+
+You should:
+1. Find the prompt that was used earlier in the session
+2. Create a suggestion like:
+   \`\`\`json
+   {
+     "category": "specificity",
+     "priority": "medium",
+     "issue": "Output format should specify JSON instead of markdown",
+     "originalText": "Output format: markdown",
+     "suggestedText": "Output format: JSON with fields: { result: string, status: string }"
+   }
+   \`\`\`
+3. Submit via \`system:optimize-prompt\` tool
+
+## Important
+
+- Create exactly ONE suggestion from the user's feedback (not multiple)
+- The suggestion will be reviewed in Prompt Project Manager web UI
+- Use your understanding of the session to interpret vague feedback into actionable fixes`
+  },
+  // Utility tool: /ppm:system:prompts
+  {
+    name: "system:prompts",
+    description: "List all available prompts from Prompt Project Manager",
+    inputSchema: {
+      type: "object",
+      properties: {
+        search: {
+          type: "string",
+          description: "Optional search term to filter prompts by name or description (case-insensitive)"
+        }
+      }
+    },
+    isSlashCommand: true,
+    promptContent: `# List Prompts
+
+This is a utility tool. Call it directly as a tool to list all available prompts.
+
+Example: Use the \`system:prompts\` tool with optional \`search\` parameter to filter results.`
+  },
+  // Backend submission tool (called by system:optimize and system:feedback)
+  // NOT a slash command - only available as a tool for AI to call
+  {
+    name: "system:optimize-prompt",
+    description: "Submit optimization suggestions to Prompt Project Manager (internal tool)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        promptSlug: {
+          type: "string",
+          description: "The slug of the prompt to optimize (e.g., 'code-review')"
+        },
+        workspaceSlug: {
+          type: "string",
+          description: "The workspace containing the prompt (e.g., 'personal')"
+        },
+        suggestions: {
+          type: "array",
+          description: "Array of optimization suggestions",
+          items: {
+            type: "object",
+            properties: {
+              category: {
+                type: "string",
+                description: "Category: 'clarity', 'specificity', 'structure', 'completeness', 'efficiency'"
+              },
+              priority: {
+                type: "string",
+                enum: ["high", "medium", "low"],
+                description: "Priority level"
+              },
+              issue: {
+                type: "string",
+                description: "Brief description of the problem"
+              },
+              originalText: {
+                type: "string",
+                description: "Optional: The specific text that should be changed"
+              },
+              suggestedText: {
+                type: "string",
+                description: "The improved text"
+              }
+            },
+            required: ["category", "priority", "issue", "suggestedText"]
+          }
+        }
+      },
+      required: ["promptSlug", "workspaceSlug", "suggestions"]
+    },
+    isSlashCommand: false,
+    // Tool only - not a slash command
+    promptContent: `# Submit Optimization Suggestions
+
+This is an internal submission tool. Do not call it directly.
+
+Use \`/ppm:system:optimize\` for full prompt evaluation or \`/ppm:system:feedback\` to submit specific feedback.`
+  }
+];
+async function startServer(config, convexClient) {
+  console.error("[MCP] Validating API key...");
+  const validation = await validateApiKey(convexClient, config.apiKey);
+  if (!validation.valid) {
+    throw new Error(`Invalid API key: ${validation.error}`);
+  }
+  console.error(`[MCP] API key validated for user: ${validation.userId}`);
+  console.error("[MCP] Fetching exposed prompts...");
+  const prompts = await fetchMcpPrompts(convexClient, config.apiKey, config.selectedWorkspaces);
+  console.error(`[MCP] Found ${prompts.length} exposed prompts`);
+  if (prompts.length === 0) {
+    if (config.selectedWorkspaces.length > 0) {
+      console.error(
+        `[MCP] WARNING: No prompts found in workspaces: ${config.selectedWorkspaces.join(", ")}. Check that these workspace slugs exist and contain prompts.`
+      );
+    } else {
+      console.error(
+        "[MCP] WARNING: No prompts found. Create some prompts in Prompt Project Manager to expose them via MCP."
+      );
+    }
+  }
+  const validPrompts = prompts.filter((p) => {
+    if (!p.flattenedPrompt) {
+      console.error(
+        `[MCP] WARNING: Skipping prompt "${p.name}" (${p.slug}) - missing flattened content. Re-save in ContextFS to regenerate.`
+      );
+      return false;
+    }
+    return true;
+  });
+  if (config.selectedWorkspaces.length > 0) {
+    console.error(`[MCP] Workspace filter: ${config.selectedWorkspaces.join(", ")}`);
+  } else {
+    console.error(`[MCP] Workspace filter: ALL (no --workspaces specified)`);
+  }
+  console.error(`[MCP] Registering ${validPrompts.length} prompts...`);
+  const workspaceSlugs = new Set(validPrompts.map((p) => p.workspaceSlug).filter((s) => !!s));
+  const dynamicTicketTools = [];
+  for (const workspaceSlug of workspaceSlugs) {
+    dynamicTicketTools.push({
+      name: `${workspaceSlug}:tickets:list`,
+      description: `List pending tickets in the "${workspaceSlug}" workspace queue`,
+      workspaceSlug,
+      type: "list"
+    });
+    dynamicTicketTools.push({
+      name: `${workspaceSlug}:tickets:next`,
+      description: `Execute and remove the next ticket from the "${workspaceSlug}" workspace queue. Optionally specify a ticket number or slug to execute a specific ticket.`,
+      workspaceSlug,
+      type: "next"
+    });
+    dynamicTicketTools.push({
+      name: `${workspaceSlug}:tickets:get`,
+      description: `Get a specific ticket from the "${workspaceSlug}" workspace by number or slug`,
+      workspaceSlug,
+      type: "get"
+    });
+    dynamicTicketTools.push({
+      name: `${workspaceSlug}:tickets:create`,
+      description: `Create a new ticket in the "${workspaceSlug}" workspace queue`,
+      workspaceSlug,
+      type: "create"
+    });
+  }
+  console.error(`[MCP] Registering ${dynamicTicketTools.length} ticket tools for ${workspaceSlugs.size} workspace(s)...`);
+  const promptNames = /* @__PURE__ */ new Set();
+  const duplicates = [];
+  validPrompts.forEach((p) => {
+    const name = buildPromptName(p);
+    if (promptNames.has(name)) {
+      duplicates.push(name);
+    }
+    promptNames.add(name);
+  });
+  if (duplicates.length > 0) {
+    console.error(
+      `[MCP] WARNING: Duplicate prompt names detected: ${duplicates.join(", ")}. Only the first occurrence will be registered.`
+    );
+  }
+  const server = new Server(
+    {
+      name: "ppm-mcp-server",
+      version: "2.8.1"
+    },
+    {
+      capabilities: {
+        prompts: {},
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    const uniquePrompts = Array.from(
+      new Map(validPrompts.map((p) => [buildPromptName(p), p])).values()
+    );
+    const systemPromptSchemas = SYSTEM_TOOLS.filter((st) => st.isSlashCommand).map((st) => ({
+      name: st.name,
+      description: st.description
+    }));
+    const ticketPromptSchemas = dynamicTicketTools.filter((tt) => tt.type !== "get").map((tt) => ({
+      name: tt.name,
+      description: tt.description
+    }));
+    return {
+      prompts: [
+        ...systemPromptSchemas,
+        ...ticketPromptSchemas,
+        ...uniquePrompts.map(buildPromptSchema)
+      ]
+    };
+  });
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const promptName = request.params.name;
+    const systemTool = SYSTEM_TOOLS.find((st) => st.name === promptName);
+    if (systemTool) {
+      return {
+        description: systemTool.description,
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: systemTool.promptContent
+            }
+          }
+        ]
+      };
+    }
+    const ticketTool = dynamicTicketTools.find((tt) => tt.name === promptName);
+    const ticketNextMatch = promptName.match(/^(.+):tickets:next\s+(.+)$/);
+    if (ticketTool || ticketNextMatch) {
+      let promptContent;
+      let description;
+      if (ticketNextMatch) {
+        const workspaceSlug = ticketNextMatch[1];
+        const ticketArg = ticketNextMatch[2].trim();
+        description = `Execute ticket "${ticketArg}" from "${workspaceSlug}"`;
+        promptContent = `Execute ticket "${ticketArg}" from the "${workspaceSlug}" workspace queue.
+
+Call the \`${workspaceSlug}:tickets:next\` tool with ticketSlug: "${ticketArg}" to get and close the specified ticket.`;
+      } else if (ticketTool.type === "list") {
+        description = ticketTool.description;
+        promptContent = `List all pending tickets in the "${ticketTool.workspaceSlug}" workspace queue.
+
+Call the \`${ticketTool.name}\` tool to get the list.`;
+      } else if (ticketTool.type === "next") {
+        description = ticketTool.description;
+        promptContent = `Get and execute the next ticket from the "${ticketTool.workspaceSlug}" workspace queue.
+
+Call the \`${ticketTool.name}\` tool to get the next ticket. This will atomically close the ticket and return its content.
+
+You can also specify a ticket: /ppm:${ticketTool.workspaceSlug}:tickets:next <number-or-slug>`;
+      } else if (ticketTool.type === "create") {
+        description = ticketTool.description;
+        promptContent = `Create a new ticket in the "${ticketTool.workspaceSlug}" workspace queue.
+
+## How This Works
+The user provides **instructions** (not raw content). You interpret those instructions to generate the ticket.
+
+## Instructions
+1. **Read the user's request** - they may reference a file, ask you to summarize a session, or describe what they want
+2. **Process the input** - read files, extract relevant sections, summarize as needed
+3. **Generate ticket content** with a clear, descriptive title as the first line
+4. **Call the tool** with the generated content
+
+## Content Format
+\`\`\`
+[Clear descriptive title - this becomes the slug]
+
+[Body content - tasks, description, context, etc.]
+\`\`\`
+
+## Examples
+- "create a ticket from /path/to/plan.md" \u2192 Read file, use as ticket content
+- "summarize our brainstorm into a ticket" \u2192 Extract key points from conversation
+- "create a ticket for the auth bug we discussed" \u2192 Generate from session context
+- "just the tasks from this file" \u2192 Extract only task items
+
+Call the \`${ticketTool.name}\` tool with the final generated content.`;
+      } else {
+        description = ticketTool.description;
+        promptContent = `This command is not available as a slash command. Use the \`${ticketTool.name}\` tool directly to inspect a ticket.`;
+      }
+      return {
+        description,
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: promptContent
+            }
+          }
+        ]
+      };
+    }
+    const prompt = validPrompts.find((p) => buildPromptName(p) === promptName);
+    if (!prompt) {
+      throw new Error(`Unknown prompt: ${promptName}`);
+    }
+    const handler = buildPromptHandler(prompt, config, convexClient);
+    return await handler();
+  });
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const uniquePrompts = Array.from(
+      new Map(validPrompts.map((p) => [buildPromptName(p), p])).values()
+    );
+    const tools = [
+      // System tools with full input schemas
+      ...SYSTEM_TOOLS.map((st) => ({
+        name: st.name,
+        description: st.description,
+        inputSchema: st.inputSchema
+      })),
+      // Dynamic ticket tools per workspace (Ticket 135, 149)
+      ...dynamicTicketTools.map((tt) => ({
+        name: tt.name,
+        description: tt.description,
+        inputSchema: tt.type === "get" ? {
+          type: "object",
+          properties: {
+            ticketSlug: {
+              type: "string",
+              description: "Ticket number (e.g., '102') or full slug (e.g., '102-fix-auth')"
+            }
+          },
+          required: ["ticketSlug"]
+        } : tt.type === "next" ? {
+          type: "object",
+          properties: {
+            ticketSlug: {
+              type: "string",
+              description: "Optional: Ticket number (e.g., '102') or full slug (e.g., '102-fix-auth'). If not provided, executes the next ticket in queue."
+            }
+          },
+          required: []
+        } : tt.type === "create" ? {
+          type: "object",
+          properties: {
+            content: {
+              type: "string",
+              description: "The generated ticket content. First line should be a clear descriptive title (becomes the slug). Body contains tasks, description, context as needed."
+            }
+          },
+          required: ["content"]
+        } : {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      })),
+      // Each user prompt becomes a discoverable tool
+      ...uniquePrompts.map((prompt) => ({
+        name: buildPromptName(prompt),
+        description: prompt.description || `Prompt: ${prompt.name}`,
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      }))
+    ];
+    return { tools };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const toolName = request.params.name;
+    if (toolName === "system:prompts") {
+      const searchTerm = request.params.arguments?.search;
+      const uniquePrompts = Array.from(
+        new Map(validPrompts.map((p) => [buildPromptName(p), p])).values()
+      );
+      let filteredSystemTools = SYSTEM_TOOLS;
+      if (searchTerm) {
+        const lowerSearch = searchTerm.toLowerCase();
+        filteredSystemTools = SYSTEM_TOOLS.filter(
+          (st) => st.name.toLowerCase().includes(lowerSearch) || st.description.toLowerCase().includes(lowerSearch)
+        );
+      }
+      let filteredPrompts = uniquePrompts;
+      if (searchTerm) {
+        const lowerSearch = searchTerm.toLowerCase();
+        filteredPrompts = uniquePrompts.filter(
+          (p) => buildPromptName(p).toLowerCase().includes(lowerSearch) || p.name.toLowerCase().includes(lowerSearch) || p.description?.toLowerCase().includes(lowerSearch)
+        );
+      }
+      filteredPrompts.sort((a, b) => {
+        const aName = buildPromptName(a);
+        const bName = buildPromptName(b);
+        return aName.localeCompare(bName);
+      });
+      const systemToolList = filteredSystemTools.map((st) => `\u2022 ${st.name}
+  Type: System
+  Description: ${st.description}`).join("\n\n");
+      const userPromptList = filteredPrompts.map((p) => {
+        const name = buildPromptName(p);
+        const workspace = p.workspaceSlug || "unknown";
+        const desc = p.description || "No description";
+        return `\u2022 ${name}
+  Workspace: ${workspace}
+  Description: ${desc}`;
+      }).join("\n\n");
+      const totalCount = filteredSystemTools.length + filteredPrompts.length;
+      const summary = searchTerm ? `Found ${totalCount} prompts matching "${searchTerm}":` : `Available prompts (${totalCount} total):`;
+      const sections = [];
+      if (systemToolList) {
+        sections.push(`**System Tools:**
+
+${systemToolList}`);
+      }
+      if (userPromptList) {
+        sections.push(`**User Prompts:**
+
+${userPromptList}`);
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `${summary}
+
+${sections.join("\n\n") || "No prompts found."}`
+          }
+        ]
+      };
+    }
+    if (toolName === "system:optimize-prompt") {
+      const input = request.params.arguments;
+      if (!input.promptSlug || !input.workspaceSlug || !input.suggestions) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Error: Missing required fields. Please provide promptSlug, workspaceSlug, and suggestions."
+            }
+          ],
+          isError: true
+        };
+      }
+      if (!Array.isArray(input.suggestions) || input.suggestions.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Error: suggestions must be a non-empty array."
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const result2 = await convexClient.mutation(
+          "prompts:addOptimizationSuggestions",
+          {
+            apiKey: config.apiKey,
+            workspaceSlug: input.workspaceSlug,
+            promptSlug: input.promptSlug,
+            suggestions: input.suggestions
+          }
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Submitted ${result2.addedCount} optimization suggestion(s) for prompt "${input.promptSlug}" in workspace "${input.workspaceSlug}". Review and apply them in Prompt Project Manager.`
+            }
+          ]
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        console.error(`[MCP] system:optimize-prompt error:`, error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error submitting optimization suggestions: ${errorMessage}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+    const ticketTool = dynamicTicketTools.find((tt) => tt.name === toolName);
+    if (ticketTool) {
+      if (ticketTool.type === "list") {
+        try {
+          const tickets = await convexClient.query(
+            "mcp_tickets:getMcpTickets",
+            {
+              apiKey: config.apiKey,
+              workspaceSlug: ticketTool.workspaceSlug
+            }
+          );
+          if (tickets.length === 0) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `No pending tickets in workspace "${ticketTool.workspaceSlug}".`
+                }
+              ]
+            };
+          }
+          const ticketList = tickets.map((t) => `${t.position}. [${t.slug}] ${t.preview}`).join("\n");
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Pending tickets in "${ticketTool.workspaceSlug}" (${tickets.length} total):
+
+${ticketList}`
+              }
+            ]
+          };
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          console.error(`[MCP] tickets:list error:`, error);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error listing tickets: ${errorMessage}`
+              }
+            ],
+            isError: true
+          };
+        }
+      } else if (ticketTool.type === "next") {
+        const ticketSlug = request.params.arguments?.ticketSlug;
+        try {
+          const result2 = await convexClient.mutation(
+            "mcp_tickets:executeMcpNextTicket",
+            {
+              apiKey: config.apiKey,
+              workspaceSlug: ticketTool.workspaceSlug,
+              ticketSlug
+              // Optional: specific ticket to execute
+            }
+          );
+          if (!result2) {
+            const message = ticketSlug ? `Ticket "${ticketSlug}" not found or already closed in workspace "${ticketTool.workspaceSlug}".` : `No pending tickets in workspace "${ticketTool.workspaceSlug}".`;
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: message
+                }
+              ]
+            };
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: `# Ticket: ${result2.slug}
+
+${result2.content}
+
+---
+_Ticket closed. ${result2.remainingTickets} ticket(s) remaining in queue._`
+              }
+            ]
+          };
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          console.error(`[MCP] tickets:next error:`, error);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error executing ticket: ${errorMessage}`
+              }
+            ],
+            isError: true
+          };
+        }
+      } else if (ticketTool.type === "create") {
+        const content = request.params.arguments?.content;
+        if (!content) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: Missing content parameter. Provide the ticket content (first line becomes the slug).`
+              }
+            ],
+            isError: true
+          };
+        }
+        try {
+          const result2 = await convexClient.mutation(
+            "mcp_tickets:createMcpTicket",
+            {
+              apiKey: config.apiKey,
+              workspaceSlug: ticketTool.workspaceSlug,
+              content
+            }
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `\u2705 Created ticket [${result2.slug}] in workspace "${ticketTool.workspaceSlug}".
+
+Position: #${result2.position} of ${result2.totalOpen} open tickets
+Preview: ${result2.preview}`
+              }
+            ]
+          };
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          console.error(`[MCP] tickets:create error:`, error);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error creating ticket: ${errorMessage}`
+              }
+            ],
+            isError: true
+          };
+        }
+      } else {
+        const ticketSlug = request.params.arguments?.ticketSlug;
+        if (!ticketSlug) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: Missing ticketSlug parameter. Usage: Provide a ticket number (e.g., "102") or full slug (e.g., "102-fix-auth").`
+              }
+            ],
+            isError: true
+          };
+        }
+        try {
+          const result2 = await convexClient.query(
+            "mcp_tickets:getMcpTicket",
+            {
+              apiKey: config.apiKey,
+              workspaceSlug: ticketTool.workspaceSlug,
+              ticketSlug
+            }
+          );
+          if (!result2) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Ticket "${ticketSlug}" not found in workspace "${ticketTool.workspaceSlug}".`
+                }
+              ]
+            };
+          }
+          const statusLabel = result2.status === "open" ? "\u{1F7E2} OPEN" : "\u26AB CLOSED";
+          const closedInfo = result2.closedAt ? `
+Closed: ${new Date(result2.closedAt).toISOString()}` : "";
+          return {
+            content: [
+              {
+                type: "text",
+                text: `# Ticket: ${result2.slug}
+
+Status: ${statusLabel}${closedInfo}
+
+---
+
+${result2.content}`
+              }
+            ]
+          };
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          console.error(`[MCP] tickets:get error:`, error);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error getting ticket: ${errorMessage}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    }
+    const prompt = validPrompts.find((p) => buildPromptName(p) === toolName);
+    if (!prompt) {
+      throw new Error(`Unknown tool: ${toolName}`);
+    }
+    const handler = buildPromptHandler(prompt, config, convexClient);
+    const result = await handler();
+    const promptText = result.messages.map((msg) => typeof msg.content === "string" ? msg.content : msg.content.text).join("\n\n");
+    return {
+      content: [
+        {
+          type: "text",
+          text: promptText
+        }
+      ]
+    };
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[MCP] Server started successfully");
+  console.error(`[MCP] Deployment: ${config.isDev ? "DEVELOPMENT" : "PRODUCTION"}`);
+  console.error(`[MCP] Convex URL: ${config.convexUrl}`);
+  console.error(`[MCP] Data mode: REAL-TIME (fetches fresh data on each invocation)`);
+  const allPromptNames = [...Array.from(promptNames)].sort();
+  console.error(`[MCP] Prompts available: ${allPromptNames.join(", ")}`);
+  console.error(`[MCP]   - Total prompts: ${promptNames.size}`);
+  setInterval(() => {
+  }, 6e4);
+  return new Promise(() => {
+  });
+}
+async function validateApiKey(client, apiKey) {
+  try {
+    const result = await client.query("apiKeys:validateApiKey", { key: apiKey });
+    if (result) {
+      return { valid: true, userId: result.userId };
+    }
+    return { valid: false, error: "Invalid API key" };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+async function fetchMcpPrompts(client, apiKey, workspaces) {
+  try {
+    const prompts = await client.query("mcp_prompts:getMcpPrompts", {
+      apiKey,
+      workspaces: workspaces.length > 0 ? workspaces : void 0
+      // Only pass if specified
+    });
+    return prompts;
+  } catch (error) {
+    throw new Error(
+      `Failed to fetch prompts: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+
+// src/index.ts
+async function main() {
+  try {
+    const argv = minimist(process.argv.slice(2));
+    const isDev = argv.dev === true;
+    const workspacesArg = argv.workspaces || argv.w;
+    let selectedWorkspaces = [];
+    if (workspacesArg) {
+      if (Array.isArray(workspacesArg)) {
+        selectedWorkspaces = workspacesArg.flatMap((w) => String(w).split(","));
+      } else {
+        selectedWorkspaces = String(workspacesArg).split(",");
+      }
+      selectedWorkspaces = selectedWorkspaces.map((s) => s.trim()).filter(Boolean);
+    }
+    const apiKey = process.env.PPM_API_KEY || process.env.THEPROMPTEDITOR_API_KEY;
+    if (!apiKey) {
+      console.error(
+        "[MCP] ERROR: Missing PPM_API_KEY environment variable"
+      );
+      console.error(
+        "[MCP] Please set your API key from Prompt Project Manager Settings page:"
+      );
+      console.error("[MCP]   export PPM_API_KEY=your_api_key_here");
+      process.exit(1);
+    }
+    const convexClient = createConvexClient(isDev);
+    const convexUrl = isDev ? "https://hallowed-shrimp-344.convex.cloud" : "https://trustworthy-squirrel-735.convex.cloud";
+    const config = {
+      apiKey,
+      isDev,
+      convexUrl,
+      selectedWorkspaces
+      // Workspace slugs to filter (empty = all workspaces)
+    };
+    await startServer(config, convexClient);
+    console.error("[MCP] WARNING: startServer promise resolved unexpectedly!");
+  } catch (error) {
+    console.error(
+      "[MCP] FATAL ERROR:",
+      error instanceof Error ? error.message : "Unknown error"
+    );
+    if (error instanceof Error && error.stack) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+process.on("SIGINT", () => {
+  console.error("[MCP] Received SIGINT, shutting down gracefully...");
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  console.error("[MCP] Received SIGTERM, shutting down gracefully...");
+  process.exit(0);
+});
+main();
+//# sourceMappingURL=index.js.map