@forprompt/sdk 0.1.0

package/dist/mcp/chunk-2ABKAGKB.js

@@ -0,0 +1,2145 @@
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/types.ts
+var ForPromptError = class extends Error {
+  constructor(message, statusCode, code) {
+    super(message);
+    this.statusCode = statusCode;
+    this.code = code;
+    this.name = "ForPromptError";
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://wooden-fox-811.convex.site";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RETRIES = 3;
+function getBackoffDelay(attempt) {
+  const baseDelay = Math.pow(2, attempt) * 1e3;
+  const jitter = Math.random() * 500;
+  return Math.min(baseDelay + jitter, 3e4);
+}
+var ForPrompt = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  retries;
+  constructor(config) {
+    this.apiKey = config.apiKey || "";
+    this.baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    this.retries = config.retries ?? DEFAULT_RETRIES;
+  }
+  /**
+   * Fetch with timeout support using AbortController
+   */
+  async fetchWithTimeout(url, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      return response;
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new ForPromptError(
+          `Request timeout after ${this.timeout}ms`,
+          408,
+          "TIMEOUT"
+        );
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Fetch with retry and exponential backoff
+   */
+  async fetchWithRetry(url, options) {
+    let lastError = null;
+    for (let attempt = 0; attempt < this.retries; attempt++) {
+      try {
+        const response = await this.fetchWithTimeout(url, options);
+        if (response.status >= 400 && response.status < 500) {
+          return response;
+        }
+        if (response.ok) {
+          return response;
+        }
+        lastError = new ForPromptError(
+          `Server error: ${response.status}`,
+          response.status,
+          "SERVER_ERROR"
+        );
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (error instanceof ForPromptError && error.code === "TIMEOUT") {
+          throw error;
+        }
+      }
+      if (attempt < this.retries - 1) {
+        const delay = getBackoffDelay(attempt);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    throw lastError || new ForPromptError(
+      "Request failed after retries",
+      500,
+      "RETRY_EXHAUSTED"
+    );
+  }
+  /**
+   * Get a prompt by its key
+   *
+   * @example
+   * ```typescript
+   * const prompt = await forprompt.getPrompt("userContextPrompt");
+   * console.log(prompt.systemPrompt);
+   * ```
+   *
+   * @example With specific version
+   * ```typescript
+   * const prompt = await forprompt.getPrompt("userContextPrompt", { version: 2 });
+   * ```
+   */
+  async getPrompt(key, options) {
+    if (!this.apiKey) {
+      throw new ForPromptError(
+        "API key is required. Set FORPROMPT_API_KEY environment variable or pass apiKey in config.",
+        401,
+        "MISSING_API_KEY"
+      );
+    }
+    if (!key || typeof key !== "string") {
+      throw new ForPromptError(
+        "Prompt key must be a non-empty string",
+        400,
+        "INVALID_INPUT"
+      );
+    }
+    if (key.length > 256) {
+      throw new ForPromptError(
+        "Prompt key must be 256 characters or less",
+        400,
+        "INVALID_INPUT"
+      );
+    }
+    if (options?.version !== void 0) {
+      if (!Number.isInteger(options.version) || options.version < 1) {
+        throw new ForPromptError(
+          "Version must be a positive integer",
+          400,
+          "INVALID_INPUT"
+        );
+      }
+    }
+    const url = new URL(`${this.baseUrl}/api/prompts`);
+    url.searchParams.set("key", key);
+    if (options?.version !== void 0) {
+      url.searchParams.set("version", String(options.version));
+    }
+    const response = await this.fetchWithRetry(url.toString(), {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.apiKey
+      }
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new ForPromptError(
+        errorData.error || `Failed to fetch prompt: ${key}`,
+        response.status,
+        response.status === 404 ? "PROMPT_NOT_FOUND" : "API_ERROR"
+      );
+    }
+    return response.json();
+  }
+  /**
+   * Get multiple prompts by their keys
+   *
+   * Requests are made in parallel with concurrency limit to avoid overwhelming the server.
+   *
+   * @example
+   * ```typescript
+   * const prompts = await forprompt.getPrompts(["userContext", "chatDefault"]);
+   * ```
+   */
+  async getPrompts(keys, options) {
+    const CONCURRENCY_LIMIT = 5;
+    const promptMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < keys.length; i += CONCURRENCY_LIMIT) {
+      const batch = keys.slice(i, i + CONCURRENCY_LIMIT);
+      const results = await Promise.allSettled(
+        batch.map((key) => this.getPrompt(key, options))
+      );
+      results.forEach((result, index) => {
+        if (result.status === "fulfilled") {
+          promptMap.set(batch[index], result.value);
+        }
+      });
+    }
+    return promptMap;
+  }
+};
+function createForPrompt(config) {
+  const apiKey = config?.apiKey || process.env.FORPROMPT_API_KEY || "";
+  const baseUrl = config?.baseUrl || process.env.FORPROMPT_BASE_URL;
+  return new ForPrompt({
+    apiKey,
+    baseUrl,
+    timeout: config?.timeout,
+    retries: config?.retries
+  });
+}
+var forprompt = createForPrompt();
+
+// src/mcp/tools.ts
+import { z } from "zod";
+var DEFAULT_BASE_URL2 = "https://wooden-fox-811.convex.site";
+function getApiConfig(config) {
+  const apiKey = config.apiKey || process.env.FORPROMPT_API_KEY;
+  const baseUrl = (config.baseUrl || process.env.FORPROMPT_BASE_URL || DEFAULT_BASE_URL2).replace(/\/$/, "");
+  if (!apiKey) {
+    throw new Error(
+      "API key is required. Set FORPROMPT_API_KEY environment variable."
+    );
+  }
+  return { apiKey, baseUrl };
+}
+async function fetchAllPrompts(config) {
+  const { apiKey, baseUrl } = getApiConfig(config);
+  const response = await fetch(`${baseUrl}/api/sync`, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json",
+      "X-API-Key": apiKey
+    }
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({
+      error: "Unknown error"
+    }));
+    throw new Error(errorData.error || `Failed to fetch prompts`);
+  }
+  const data = await response.json();
+  return data.prompts;
+}
+async function createPrompt(config, data) {
+  const { apiKey, baseUrl } = getApiConfig(config);
+  const response = await fetch(`${baseUrl}/api/prompts`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-API-Key": apiKey
+    },
+    body: JSON.stringify(data)
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({
+      error: "Unknown error"
+    }));
+    throw new Error(errorData.error || "Failed to create prompt");
+  }
+  return response.json();
+}
+async function updatePrompt(config, data) {
+  const { apiKey, baseUrl } = getApiConfig(config);
+  const response = await fetch(`${baseUrl}/api/prompts`, {
+    method: "PUT",
+    headers: {
+      "Content-Type": "application/json",
+      "X-API-Key": apiKey
+    },
+    body: JSON.stringify(data)
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({
+      error: "Unknown error"
+    }));
+    throw new Error(errorData.error || "Failed to update prompt");
+  }
+  return response.json();
+}
+async function createVersionApi(config, data) {
+  const { apiKey, baseUrl } = getApiConfig(config);
+  const response = await fetch(`${baseUrl}/api/prompts/versions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-API-Key": apiKey
+    },
+    body: JSON.stringify(data)
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({
+      error: "Unknown error"
+    }));
+    throw new Error(errorData.error || "Failed to create version");
+  }
+  return response.json();
+}
+async function deletePromptApi(config, key) {
+  const { apiKey, baseUrl } = getApiConfig(config);
+  const response = await fetch(`${baseUrl}/api/prompts?key=${encodeURIComponent(key)}`, {
+    method: "DELETE",
+    headers: {
+      "Content-Type": "application/json",
+      "X-API-Key": apiKey
+    }
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({
+      error: "Unknown error"
+    }));
+    throw new Error(errorData.error || "Failed to delete prompt");
+  }
+  return response.json();
+}
+function formatPrompt(prompt) {
+  const sections = [];
+  sections.push(`# ${prompt.name}`);
+  sections.push(`**Key:** ${prompt.key}`);
+  sections.push(`**Version:** ${prompt.versionNumber}`);
+  if (prompt.description) {
+    sections.push(`**Description:** ${prompt.description}`);
+  }
+  sections.push("");
+  sections.push("## System Prompt");
+  sections.push("```");
+  sections.push(prompt.systemPrompt);
+  sections.push("```");
+  if (prompt.purpose) {
+    sections.push("");
+    sections.push("## Purpose");
+    sections.push(prompt.purpose);
+  }
+  if (prompt.expectedBehavior) {
+    sections.push("");
+    sections.push("## Expected Behavior");
+    sections.push(prompt.expectedBehavior);
+  }
+  if (prompt.inputFormat) {
+    sections.push("");
+    sections.push("## Input Format");
+    sections.push(prompt.inputFormat);
+  }
+  if (prompt.outputFormat) {
+    sections.push("");
+    sections.push("## Output Format");
+    sections.push(prompt.outputFormat);
+  }
+  if (prompt.constraints) {
+    sections.push("");
+    sections.push("## Constraints");
+    sections.push(prompt.constraints);
+  }
+  if (prompt.useCases) {
+    sections.push("");
+    sections.push("## Use Cases");
+    sections.push(prompt.useCases);
+  }
+  if (prompt.additionalNotes) {
+    sections.push("");
+    sections.push("## Additional Notes");
+    sections.push(prompt.additionalNotes);
+  }
+  if (prompt.toolsNotes) {
+    sections.push("");
+    sections.push("## Tools Notes");
+    sections.push(prompt.toolsNotes);
+  }
+  return sections.join("\n");
+}
+var GetPromptInputSchema = z.object({
+  key: z.string().describe("The unique key identifier for the prompt"),
+  version: z.number().optional().describe(
+    "Specific version number to fetch (optional, defaults to active version)"
+  )
+});
+var ListPromptsInputSchema = z.object({
+  search: z.string().optional().describe("Optional search term to filter prompts by name or key")
+});
+var SearchPromptsInputSchema = z.object({
+  query: z.string().describe("Search query to find matching prompts")
+});
+var GetMetadataInputSchema = z.object({
+  key: z.string().describe("The unique key identifier for the prompt")
+});
+var GetSystemPromptInputSchema = z.object({
+  key: z.string().describe("The unique key identifier for the prompt"),
+  version: z.number().optional().describe("Specific version number (optional)")
+});
+var CreatePromptInputSchema = z.object({
+  key: z.string().describe(
+    "Unique key identifier for the prompt (lowercase, no spaces, use underscores)"
+  ),
+  name: z.string().describe("Human-readable name for the prompt"),
+  description: z.string().optional().describe("Description of what the prompt does"),
+  systemPrompt: z.string().optional().describe("Initial system prompt content (optional, can be added later)")
+});
+var UpdatePromptInputSchema = z.object({
+  key: z.string().describe("The unique key identifier for the prompt to update"),
+  name: z.string().optional().describe("New name for the prompt"),
+  description: z.string().optional().describe("New description"),
+  purpose: z.string().optional().describe("The purpose/goal of this prompt"),
+  expectedBehavior: z.string().optional().describe("Expected behavior when using this prompt"),
+  inputFormat: z.string().optional().describe("Expected input format"),
+  outputFormat: z.string().optional().describe("Expected output format"),
+  constraints: z.string().optional().describe("Constraints and limitations"),
+  useCases: z.string().optional().describe("Primary use cases"),
+  additionalNotes: z.string().optional().describe("Additional notes"),
+  toolsNotes: z.string().optional().describe("Notes about tool usage")
+});
+var CreateVersionInputSchema = z.object({
+  key: z.string().describe("The prompt key to create a new version for"),
+  systemPrompt: z.string().describe("The new system prompt content"),
+  description: z.string().optional().describe("Description of changes in this version"),
+  setAsActive: z.boolean().optional().describe("Whether to set this as the active version (default: true)")
+});
+var DeletePromptInputSchema = z.object({
+  key: z.string().describe("The unique key identifier for the prompt to delete")
+});
+var SetupProjectInputSchema = z.object({
+  projectPath: z.string().describe("Absolute path to the project root directory"),
+  language: z.enum(["typescript", "javascript", "python"]).optional().describe("Programming language (auto-detected if not specified)"),
+  packageManager: z.enum(["npm", "yarn", "pnpm", "bun", "pip", "poetry", "uv"]).optional().describe("Package manager to use (auto-detected if not specified)")
+});
+var GenerateConfigInputSchema = z.object({
+  projectPath: z.string().describe("Absolute path to the project root directory"),
+  apiKey: z.string().optional().describe("API key (will prompt user if not provided)"),
+  baseUrl: z.string().optional().describe("Custom API base URL (optional)")
+});
+var GenerateExampleInputSchema = z.object({
+  language: z.enum(["typescript", "javascript", "python"]).describe("Programming language for the example"),
+  useCase: z.enum(["basic", "streaming", "with-tools", "react-hook", "nextjs-api"]).describe("Type of example to generate"),
+  promptKey: z.string().optional().describe("Optional prompt key to use in the example")
+});
+var DetectProjectInputSchema = z.object({
+  projectPath: z.string().describe("Absolute path to the project root directory")
+});
+var GetIntegrationGuideInputSchema = z.object({
+  framework: z.enum(["nextjs", "react", "express", "fastapi", "django", "flask", "generic"]).describe("Framework to get integration guide for"),
+  language: z.enum(["typescript", "javascript", "python"]).optional().describe("Programming language")
+});
+function registerTools(server, client, config) {
+  server.registerTool(
+    "forprompt_get_prompt",
+    {
+      description: "Fetch a prompt by its key from ForPrompt. Returns the system prompt content and metadata including purpose, expected behavior, constraints, and more.",
+      inputSchema: GetPromptInputSchema
+    },
+    async ({ key, version }) => {
+      try {
+        const prompt = await client.getPrompt(key, { version });
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatPrompt(prompt)
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error fetching prompt "${key}": ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "forprompt_list_prompts",
+    {
+      description: "List all available prompts in your ForPrompt project. Returns a summary of each prompt including key, name, description, and version.",
+      inputSchema: ListPromptsInputSchema
+    },
+    async ({ search }) => {
+      try {
+        let prompts = await fetchAllPrompts(config);
+        if (search) {
+          const searchLower = search.toLowerCase();
+          prompts = prompts.filter(
+            (p) => p.key.toLowerCase().includes(searchLower) || p.name.toLowerCase().includes(searchLower) || p.description?.toLowerCase().includes(searchLower)
+          );
+        }
+        if (prompts.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: search ? `No prompts found matching "${search}"` : "No prompts found in this project"
+              }
+            ]
+          };
+        }
+        const lines = prompts.map((p) => {
+          const desc = p.description ? ` - ${p.description}` : "";
+          return `- **${p.key}** (v${p.versionNumber}): ${p.name}${desc}`;
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `# ForPrompt Prompts
+
+Found ${prompts.length} prompt(s):
+
+${lines.join("\n")}`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error listing prompts: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "forprompt_search_prompts",
+    {
+      description: "Search prompts by text query. Searches across prompt names, keys, descriptions, purposes, and use cases.",
+      inputSchema: SearchPromptsInputSchema
+    },
+    async ({ query }) => {
+      try {
+        const allPrompts = await fetchAllPrompts(config);
+        const queryLower = query.toLowerCase();
+        const matches = allPrompts.filter((p) => {
+          const searchFields = [
+            p.key,
+            p.name,
+            p.description,
+            p.purpose,
+            p.useCases,
+            p.expectedBehavior,
+            p.systemPrompt
+          ];
+          return searchFields.some(
+            (field) => field && field.toLowerCase().includes(queryLower)
+          );
+        });
+        if (matches.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No prompts found matching "${query}"`
+              }
+            ]
+          };
+        }
+        const results = matches.map((p) => {
+          const sections = [`## ${p.name} (\`${p.key}\`)`];
+          if (p.description) sections.push(`*${p.description}*`);
+          sections.push(`Version: ${p.versionNumber}`);
+          if (p.purpose) sections.push(`**Purpose:** ${p.purpose}`);
+          return sections.join("\n");
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `# Search Results for "${query}"
+
+Found ${matches.length} matching prompt(s):
+
+${results.join("\n\n---\n\n")}`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error searching prompts: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "forprompt_get_prompt_metadata",
+    {
+      description: "Get metadata for a prompt without the full system prompt content. Useful for understanding what a prompt does before fetching it.",
+      inputSchema: GetMetadataInputSchema
+    },
+    async ({ key }) => {
+      try {
+        const prompt = await client.getPrompt(key);
+        const metadata = {
+          key: prompt.key,
+          name: prompt.name,
+          description: prompt.description,
+          versionNumber: prompt.versionNumber,
+          updatedAt: new Date(prompt.updatedAt).toISOString(),
+          purpose: prompt.purpose,
+          expectedBehavior: prompt.expectedBehavior,
+          inputFormat: prompt.inputFormat,
+          outputFormat: prompt.outputFormat,
+          constraints: prompt.constraints,
+          useCases: prompt.useCases,
+          additionalNotes: prompt.additionalNotes,
+          toolsNotes: prompt.toolsNotes,
+          systemPromptLength: prompt.systemPrompt.length
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: `# Metadata for "${prompt.name}"
+
+\`\`\`json
+${JSON.stringify(metadata, null, 2)}
+\`\`\``
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error fetching metadata for "${key}": ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "forprompt_get_system_prompt",
+    {
+      description: "Get only the raw system prompt text without metadata. Useful when you just need the prompt content to use directly.",
+      inputSchema: GetSystemPromptInputSchema
+    },
+    async ({ key, version }) => {
+      try {
+        const prompt = await client.getPrompt(key, { version });
+        return {
+          content: [
+            {
+              type: "text",
+              text: prompt.systemPrompt
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error fetching system prompt for "${key}": ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "forprompt_create_prompt",
+    {
+      description: "Create a new prompt in ForPrompt. You can optionally include an initial system prompt content. The key must be unique, lowercase, and use underscores instead of spaces.",
+      inputSchema: CreatePromptInputSchema
+    },
+    async ({ key, name, description, systemPrompt }) => {
+      try {
+        const result = await createPrompt(config, {
+          key,
+          name,
+          description,
+          systemPrompt
+        });
+        let message = `Successfully created prompt "${name}" with key "${key}"`;
+        if (result.versionNumber) {
+          message += ` (v${result.versionNumber})`;
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: message
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error creating prompt: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "forprompt_update_prompt",
+    {
+      description: "Update an existing prompt's metadata (name, description, purpose, expected behavior, etc.). To update the system prompt content, use forprompt_create_version instead.",
+      inputSchema: UpdatePromptInputSchema
+    },
+    async (args) => {
+      try {
+        await updatePrompt(config, args);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Successfully updated prompt "${args.key}"`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error updating prompt: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "forprompt_create_version",
+    {
+      description: "Create a new version of an existing prompt with updated system prompt content. This is the proper way to update the actual prompt text while maintaining version history.",
+      inputSchema: CreateVersionInputSchema
+    },
+    async ({ key, systemPrompt, description, setAsActive }) => {
+      try {
+        const result = await createVersionApi(config, {
+          key,
+          systemPrompt,
+          description,
+          setAsActive
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Successfully created version ${result.versionNumber} for prompt "${key}"`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error creating version: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "forprompt_delete_prompt",
+    {
+      description: "Delete a prompt and all its versions. This action is irreversible. Use with caution.",
+      inputSchema: DeletePromptInputSchema
+    },
+    async ({ key }) => {
+      try {
+        await deletePromptApi(config, key);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Successfully deleted prompt "${key}" and all its versions`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error deleting prompt: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "forprompt_detect_project",
+    {
+      description: "Detect the project type, language, and package manager in a directory. Use this first before running setup to understand the project structure.",
+      inputSchema: DetectProjectInputSchema
+    },
+    async ({ projectPath }) => {
+      try {
+        const fs = await import("fs");
+        const path = await import("path");
+        const detection = {
+          language: null,
+          packageManager: null,
+          framework: null,
+          hasForPrompt: false,
+          configFiles: []
+        };
+        const packageJsonPath = path.join(projectPath, "package.json");
+        if (fs.existsSync(packageJsonPath)) {
+          const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+          if (packageJson.devDependencies?.typescript || packageJson.dependencies?.typescript) {
+            detection.language = "typescript";
+          } else {
+            detection.language = "javascript";
+          }
+          if (packageJson.dependencies?.["@forprompt/sdk"] || packageJson.devDependencies?.["@forprompt/sdk"]) {
+            detection.hasForPrompt = true;
+          }
+          if (packageJson.dependencies?.next) {
+            detection.framework = "nextjs";
+          } else if (packageJson.dependencies?.react) {
+            detection.framework = "react";
+          } else if (packageJson.dependencies?.express) {
+            detection.framework = "express";
+          }
+          if (fs.existsSync(path.join(projectPath, "pnpm-lock.yaml"))) {
+            detection.packageManager = "pnpm";
+          } else if (fs.existsSync(path.join(projectPath, "yarn.lock"))) {
+            detection.packageManager = "yarn";
+          } else if (fs.existsSync(path.join(projectPath, "bun.lockb"))) {
+            detection.packageManager = "bun";
+          } else if (fs.existsSync(path.join(projectPath, "package-lock.json"))) {
+            detection.packageManager = "npm";
+          }
+          detection.configFiles.push("package.json");
+        }
+        const pyprojectPath = path.join(projectPath, "pyproject.toml");
+        const requirementsPath = path.join(projectPath, "requirements.txt");
+        if (fs.existsSync(pyprojectPath)) {
+          detection.language = "python";
+          const content = fs.readFileSync(pyprojectPath, "utf-8");
+          if (content.includes("poetry")) {
+            detection.packageManager = "poetry";
+          } else if (content.includes("uv")) {
+            detection.packageManager = "uv";
+          } else {
+            detection.packageManager = "pip";
+          }
+          detection.configFiles.push("pyproject.toml");
+          if (content.includes("fastapi")) {
+            detection.framework = "fastapi";
+          } else if (content.includes("django")) {
+            detection.framework = "django";
+          } else if (content.includes("flask")) {
+            detection.framework = "flask";
+          }
+          if (content.includes("forprompt")) {
+            detection.hasForPrompt = true;
+          }
+        } else if (fs.existsSync(requirementsPath)) {
+          detection.language = "python";
+          detection.packageManager = "pip";
+          detection.configFiles.push("requirements.txt");
+          const content = fs.readFileSync(requirementsPath, "utf-8");
+          if (content.includes("forprompt")) {
+            detection.hasForPrompt = true;
+          }
+        }
+        const forpromptConfigPath = path.join(projectPath, ".forprompt");
+        if (fs.existsSync(forpromptConfigPath)) {
+          detection.configFiles.push(".forprompt");
+        }
+        if (!detection.language) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Could not detect project type at "${projectPath}". Make sure the path contains a package.json (Node.js) or pyproject.toml/requirements.txt (Python).`
+              }
+            ],
+            isError: true
+          };
+        }
+        const lines = [
+          `# Project Detection Results`,
+          ``,
+          `**Path:** ${projectPath}`,
+          `**Language:** ${detection.language}`,
+          `**Package Manager:** ${detection.packageManager || "unknown"}`,
+          `**Framework:** ${detection.framework || "none detected"}`,
+          `**ForPrompt Installed:** ${detection.hasForPrompt ? "Yes" : "No"}`,
+          `**Config Files Found:** ${detection.configFiles.join(", ")}`,
+          ``
+        ];
+        if (!detection.hasForPrompt) {
+          lines.push(`## Next Steps`);
+          lines.push(``);
+          lines.push(`1. Run \`forprompt_setup_project\` to install the SDK`);
+          lines.push(`2. Run \`forprompt_generate_config\` to create the config file`);
+          lines.push(`3. Use \`forprompt_generate_example\` to see usage examples`);
+        } else {
+          lines.push(`ForPrompt is already installed! You can:`);
+          lines.push(`- Use \`forprompt_list_prompts\` to see available prompts`);
+          lines.push(`- Use \`forprompt_create_prompt\` to create new prompts`);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: lines.join("\n")
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error detecting project: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "forprompt_setup_project",
+    {
+      description: "Install the ForPrompt SDK in a project. Auto-detects the language and package manager, or you can specify them. Returns the command to run - you should execute it using your terminal/bash tool.",
+      inputSchema: SetupProjectInputSchema
+    },
+    async ({ projectPath, language, packageManager }) => {
+      try {
+        const fs = await import("fs");
+        const path = await import("path");
+        let detectedLanguage = language;
+        let detectedPM = packageManager;
+        if (!detectedLanguage || !detectedPM) {
+          const packageJsonPath = path.join(projectPath, "package.json");
+          const pyprojectPath = path.join(projectPath, "pyproject.toml");
+          const requirementsPath = path.join(projectPath, "requirements.txt");
+          if (fs.existsSync(packageJsonPath)) {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+            if (!detectedLanguage) {
+              detectedLanguage = packageJson.devDependencies?.typescript ? "typescript" : "javascript";
+            }
+            if (!detectedPM) {
+              if (fs.existsSync(path.join(projectPath, "pnpm-lock.yaml"))) {
+                detectedPM = "pnpm";
+              } else if (fs.existsSync(path.join(projectPath, "yarn.lock"))) {
+                detectedPM = "yarn";
+              } else if (fs.existsSync(path.join(projectPath, "bun.lockb"))) {
+                detectedPM = "bun";
+              } else {
+                detectedPM = "npm";
+              }
+            }
+          } else if (fs.existsSync(pyprojectPath) || fs.existsSync(requirementsPath)) {
+            detectedLanguage = "python";
+            if (!detectedPM) {
+              if (fs.existsSync(pyprojectPath)) {
+                const content = fs.readFileSync(pyprojectPath, "utf-8");
+                if (content.includes("poetry")) {
+                  detectedPM = "poetry";
+                } else {
+                  detectedPM = "pip";
+                }
+              } else {
+                detectedPM = "pip";
+              }
+            }
+          }
+        }
+        if (!detectedLanguage) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Could not detect project type. Please specify the language parameter ("typescript", "javascript", or "python").`
+              }
+            ],
+            isError: true
+          };
+        }
+        let installCommand;
+        let packageName;
+        if (detectedLanguage === "python") {
+          packageName = "forprompt";
+          switch (detectedPM) {
+            case "poetry":
+              installCommand = `cd "${projectPath}" && poetry add ${packageName}`;
+              break;
+            case "uv":
+              installCommand = `cd "${projectPath}" && uv add ${packageName}`;
+              break;
+            default:
+              installCommand = `cd "${projectPath}" && pip install ${packageName}`;
+          }
+        } else {
+          packageName = "@forprompt/sdk";
+          switch (detectedPM) {
+            case "yarn":
+              installCommand = `cd "${projectPath}" && yarn add ${packageName}`;
+              break;
+            case "pnpm":
+              installCommand = `cd "${projectPath}" && pnpm add ${packageName}`;
+              break;
+            case "bun":
+              installCommand = `cd "${projectPath}" && bun add ${packageName}`;
+              break;
+            default:
+              installCommand = `cd "${projectPath}" && npm install ${packageName}`;
+          }
+        }
+        const lines = [
+          `# ForPrompt SDK Installation`,
+          ``,
+          `**Project:** ${projectPath}`,
+          `**Language:** ${detectedLanguage}`,
+          `**Package Manager:** ${detectedPM}`,
+          ``,
+          `## Install Command`,
+          ``,
+          "```bash",
+          installCommand,
+          "```",
+          ``,
+          `**Run this command to install the ForPrompt SDK.**`,
+          ``,
+          `## After Installation`,
+          ``,
+          `1. Create a \`.forprompt\` config file with your API key`,
+          `2. Or set the \`FORPROMPT_API_KEY\` environment variable`,
+          ``,
+          `Use \`forprompt_generate_config\` to create the config file automatically.`
+        ];
+        return {
+          content: [
+            {
+              type: "text",
+              text: lines.join("\n")
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error setting up project: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "forprompt_generate_config",
+    {
+      description: "Generate a .forprompt configuration file for a project. Returns the config content that should be written to .forprompt file in the project root.",
+      inputSchema: GenerateConfigInputSchema
+    },
+    async ({ projectPath, apiKey, baseUrl }) => {
+      try {
+        const configLines = [
+          `# ForPrompt Configuration`,
+          `# Generated by ForPrompt MCP Server`,
+          ``
+        ];
+        if (apiKey) {
+          configLines.push(`FORPROMPT_API_KEY=${apiKey}`);
+        } else {
+          configLines.push(`# Add your API key here:`);
+          configLines.push(`FORPROMPT_API_KEY=your_api_key_here`);
+        }
+        if (baseUrl) {
+          configLines.push(`FORPROMPT_BASE_URL=${baseUrl}`);
+        }
+        const configContent = configLines.join("\n");
+        const configPath = `${projectPath}/.forprompt`;
+        const lines = [
+          `# ForPrompt Configuration`,
+          ``,
+          `Create a file at \`${configPath}\` with the following content:`,
+          ``,
+          "```env",
+          configContent,
+          "```",
+          ``,
+          `## Alternative: Environment Variables`,
+          ``,
+          `Instead of a config file, you can set environment variables:`,
+          ``,
+          "```bash",
+          `export FORPROMPT_API_KEY=your_api_key_here`,
+          "```",
+          ``,
+          `## Get Your API Key`,
+          ``,
+          `1. Go to https://forprompt.dev/dashboard`,
+          `2. Navigate to your organization settings`,
+          `3. Create or copy your API key`,
+          ``,
+          `**Important:** Add \`.forprompt\` to your \`.gitignore\` to keep your API key secure!`
+        ];
+        return {
+          content: [
+            {
+              type: "text",
+              text: lines.join("\n")
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error generating config: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "forprompt_generate_example",
+    {
+      description: "Generate example code showing how to use ForPrompt SDK. Supports different languages and use cases like basic usage, streaming, React hooks, and Next.js API routes.",
+      inputSchema: GenerateExampleInputSchema
+    },
+    async ({ language, useCase, promptKey }) => {
+      try {
+        const key = promptKey || "my_prompt";
+        let code;
+        let description;
+        if (language === "python") {
+          switch (useCase) {
+            case "streaming":
+              description = "Python streaming example with ForPrompt";
+              code = `from forprompt import ForPrompt
+import os
+
+# Initialize the client
+client = ForPrompt(api_key=os.environ.get("FORPROMPT_API_KEY"))
+
+# Get the prompt
+prompt = client.get_prompt("${key}")
+
+# Use with your LLM (example with OpenAI)
+from openai import OpenAI
+
+openai = OpenAI()
+
+# Stream the response
+stream = openai.chat.completions.create(
+    model="gpt-4",
+    messages=[
+        {"role": "system", "content": prompt.system_prompt},
+        {"role": "user", "content": "Your user message here"}
+    ],
+    stream=True
+)
+
+for chunk in stream:
+    if chunk.choices[0].delta.content:
+        print(chunk.choices[0].delta.content, end="")`;
+              break;
+            case "with-tools":
+              description = "Python example with tools/functions";
+              code = `from forprompt import ForPrompt
+import os
+import json
+
+client = ForPrompt(api_key=os.environ.get("FORPROMPT_API_KEY"))
+
+# Get the prompt with tools
+prompt = client.get_prompt("${key}")
+
+# Define your tools
+tools = [
+    {
+        "type": "function",
+        "function": {
+            "name": "get_weather",
+            "description": "Get current weather for a location",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "location": {"type": "string", "description": "City name"}
+                },
+                "required": ["location"]
+            }
+        }
+    }
+]
+
+# Use with OpenAI
+from openai import OpenAI
+
+openai = OpenAI()
+
+response = openai.chat.completions.create(
+    model="gpt-4",
+    messages=[
+        {"role": "system", "content": prompt.system_prompt},
+        {"role": "user", "content": "What's the weather in Tokyo?"}
+    ],
+    tools=tools,
+    tool_choice="auto"
+)
+
+print(response.choices[0].message)`;
+              break;
+            default:
+              description = "Basic Python usage example";
+              code = `from forprompt import ForPrompt
+import os
+
+# Initialize the client
+client = ForPrompt(api_key=os.environ.get("FORPROMPT_API_KEY"))
+
+# Get a prompt by key
+prompt = client.get_prompt("${key}")
+
+print(f"Prompt: {prompt.name}")
+print(f"Version: {prompt.version_number}")
+print(f"System Prompt: {prompt.system_prompt}")
+
+# Use the prompt with your LLM
+from openai import OpenAI
+
+openai = OpenAI()
+
+response = openai.chat.completions.create(
+    model="gpt-4",
+    messages=[
+        {"role": "system", "content": prompt.system_prompt},
+        {"role": "user", "content": "Your user message here"}
+    ]
+)
+
+print(response.choices[0].message.content)`;
+          }
+        } else {
+          const isTS = language === "typescript";
+          const ext = isTS ? "ts" : "js";
+          switch (useCase) {
+            case "streaming":
+              description = "Streaming example with ForPrompt";
+              code = `import { forprompt } from '@forprompt/sdk';
+import OpenAI from 'openai';
+
+async function main() {
+  // Get the prompt
+  const prompt = await forprompt.getPrompt('${key}');
+
+  const openai = new OpenAI();
+
+  // Stream the response
+  const stream = await openai.chat.completions.create({
+    model: 'gpt-4',
+    messages: [
+      { role: 'system', content: prompt.systemPrompt },
+      { role: 'user', content: 'Your user message here' }
+    ],
+    stream: true,
+  });
+
+  for await (const chunk of stream) {
+    const content = chunk.choices[0]?.delta?.content;
+    if (content) process.stdout.write(content);
+  }
+}
+
+main();`;
+              break;
+            case "react-hook":
+              description = "React hook example";
+              code = `import { useState, useEffect } from 'react';
+import { forprompt } from '@forprompt/sdk';
+${isTS ? "import type { Prompt } from '@forprompt/sdk';\n" : ""}
+// Custom hook to fetch a ForPrompt prompt
+export function usePrompt(key${isTS ? ": string" : ""}) {
+  const [prompt, setPrompt] = useState${isTS ? "<Prompt | null>" : ""}(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState${isTS ? "<Error | null>" : ""}(null);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    async function fetchPrompt() {
+      try {
+        setLoading(true);
+        const data = await forprompt.getPrompt(key);
+        if (!cancelled) {
+          setPrompt(data);
+          setError(null);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setError(err${isTS ? " as Error" : ""});
+        }
+      } finally {
+        if (!cancelled) {
+          setLoading(false);
+        }
+      }
+    }
+
+    fetchPrompt();
+
+    return () => { cancelled = true; };
+  }, [key]);
+
+  return { prompt, loading, error };
+}
+
+// Usage in a component
+function ChatComponent() {
+  const { prompt, loading, error } = usePrompt('${key}');
+
+  if (loading) return <div>Loading prompt...</div>;
+  if (error) return <div>Error: {error.message}</div>;
+
+  return (
+    <div>
+      <h1>{prompt${isTS ? "!" : ""}.name}</h1>
+      <p>Version: {prompt${isTS ? "!" : ""}.versionNumber}</p>
+      {/* Use prompt.systemPrompt with your AI chat */}
+    </div>
+  );
+}`;
+              break;
+            case "nextjs-api":
+              description = "Next.js API route example";
+              code = `// app/api/chat/route.${ext}
+import { forprompt } from '@forprompt/sdk';
+import OpenAI from 'openai';
+import { NextResponse } from 'next/server';
+${isTS ? "\nexport const runtime = 'edge';\n" : ""}
+const openai = new OpenAI();
+
+export async function POST(request${isTS ? ": Request" : ""}) {
+  try {
+    const { message, promptKey } = await request.json();
+
+    // Fetch the prompt from ForPrompt
+    const prompt = await forprompt.getPrompt(promptKey || '${key}');
+
+    // Create completion with the system prompt
+    const response = await openai.chat.completions.create({
+      model: 'gpt-4',
+      messages: [
+        { role: 'system', content: prompt.systemPrompt },
+        { role: 'user', content: message }
+      ],
+    });
+
+    return NextResponse.json({
+      content: response.choices[0].message.content,
+      promptVersion: prompt.versionNumber,
+    });
+  } catch (error) {
+    console.error('Chat API error:', error);
+    return NextResponse.json(
+      { error: 'Failed to process chat request' },
+      { status: 500 }
+    );
+  }
+}`;
+              break;
+            case "with-tools":
+              description = "Example with tools/functions";
+              code = `import { forprompt } from '@forprompt/sdk';
+import OpenAI from 'openai';
+
+const openai = new OpenAI();
+
+// Define your tools
+const tools${isTS ? ": OpenAI.ChatCompletionTool[]" : ""} = [
+  {
+    type: 'function',
+    function: {
+      name: 'get_weather',
+      description: 'Get current weather for a location',
+      parameters: {
+        type: 'object',
+        properties: {
+          location: { type: 'string', description: 'City name' }
+        },
+        required: ['location']
+      }
+    }
+  }
+];
+
+async function main() {
+  const prompt = await forprompt.getPrompt('${key}');
+
+  const response = await openai.chat.completions.create({
+    model: 'gpt-4',
+    messages: [
+      { role: 'system', content: prompt.systemPrompt },
+      { role: 'user', content: "What's the weather in Tokyo?" }
+    ],
+    tools,
+    tool_choice: 'auto',
+  });
+
+  console.log(response.choices[0].message);
+}
+
+main();`;
+              break;
+            default:
+              description = "Basic usage example";
+              code = `import { forprompt } from '@forprompt/sdk';
+import OpenAI from 'openai';
+
+async function main() {
+  // Get a prompt by key
+  const prompt = await forprompt.getPrompt('${key}');
+
+  console.log('Prompt:', prompt.name);
+  console.log('Version:', prompt.versionNumber);
+  console.log('System Prompt:', prompt.systemPrompt);
+
+  // Use with OpenAI
+  const openai = new OpenAI();
+
+  const response = await openai.chat.completions.create({
+    model: 'gpt-4',
+    messages: [
+      { role: 'system', content: prompt.systemPrompt },
+      { role: 'user', content: 'Your user message here' }
+    ],
+  });
+
+  console.log(response.choices[0].message.content);
+}
+
+main();`;
+          }
+        }
+        const lines = [
+          `# ${description}`,
+          ``,
+          `**Language:** ${language}`,
+          `**Use Case:** ${useCase}`,
+          ``,
+          "```" + (language === "python" ? "python" : language),
+          code,
+          "```",
+          ``,
+          `## Setup Required`,
+          ``,
+          `1. Install the ForPrompt SDK`,
+          `2. Set your \`FORPROMPT_API_KEY\` environment variable`,
+          `3. Create a prompt with key \`${key}\` in ForPrompt dashboard`
+        ];
+        return {
+          content: [
+            {
+              type: "text",
+              text: lines.join("\n")
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error generating example: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "forprompt_integration_guide",
+    {
+      description: "Get a step-by-step integration guide for ForPrompt with specific frameworks like Next.js, React, Express, FastAPI, Django, or Flask.",
+      inputSchema: GetIntegrationGuideInputSchema
+    },
+    async ({ framework, language }) => {
+      try {
+        let guide;
+        switch (framework) {
+          case "nextjs":
+            guide = `# ForPrompt + Next.js Integration Guide
+
+## 1. Install the SDK
+
+\`\`\`bash
+npm install @forprompt/sdk
+# or: pnpm add @forprompt/sdk
+\`\`\`
+
+## 2. Set up environment variables
+
+Add to your \`.env.local\`:
+
+\`\`\`env
+FORPROMPT_API_KEY=your_api_key_here
+\`\`\`
+
+## 3. Create an API route
+
+\`\`\`typescript
+// app/api/chat/route.ts
+import { forprompt } from '@forprompt/sdk';
+import { NextResponse } from 'next/server';
+
+export async function POST(request: Request) {
+  const { message, promptKey } = await request.json();
+
+  // Fetch prompt from ForPrompt
+  const prompt = await forprompt.getPrompt(promptKey);
+
+  // Use prompt.systemPrompt with your LLM
+  // ... your AI logic here
+
+  return NextResponse.json({ response: '...' });
+}
+\`\`\`
+
+## 4. Create a client hook (optional)
+
+\`\`\`typescript
+// hooks/useForPrompt.ts
+'use client';
+import { forprompt } from '@forprompt/sdk';
+import { useEffect, useState } from 'react';
+
+export function usePrompt(key: string) {
+  const [prompt, setPrompt] = useState(null);
+
+  useEffect(() => {
+    forprompt.getPrompt(key).then(setPrompt);
+  }, [key]);
+
+  return prompt;
+}
+\`\`\`
+
+## 5. Best Practices
+
+- Cache prompts in production using Next.js caching
+- Use server components for initial prompt fetch
+- Consider using SWR or React Query for client-side caching`;
+            break;
+          case "react":
+            guide = `# ForPrompt + React Integration Guide
+
+## 1. Install the SDK
+
+\`\`\`bash
+npm install @forprompt/sdk
+\`\`\`
+
+## 2. Create a custom hook
+
+\`\`\`typescript
+// hooks/usePrompt.ts
+import { useState, useEffect } from 'react';
+import { forprompt, Prompt } from '@forprompt/sdk';
+
+export function usePrompt(key: string) {
+  const [prompt, setPrompt] = useState<Prompt | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    forprompt.getPrompt(key)
+      .then(setPrompt)
+      .catch(setError)
+      .finally(() => setLoading(false));
+  }, [key]);
+
+  return { prompt, loading, error };
+}
+\`\`\`
+
+## 3. Use in components
+
+\`\`\`tsx
+function ChatBot() {
+  const { prompt, loading } = usePrompt('customer_support');
+
+  if (loading) return <Spinner />;
+
+  return <Chat systemPrompt={prompt.systemPrompt} />;
+}
+\`\`\``;
+            break;
+          case "express":
+            guide = `# ForPrompt + Express Integration Guide
+
+## 1. Install the SDK
+
+\`\`\`bash
+npm install @forprompt/sdk
+\`\`\`
+
+## 2. Create a middleware (optional)
+
+\`\`\`typescript
+// middleware/forprompt.ts
+import { forprompt } from '@forprompt/sdk';
+
+export async function loadPrompt(req, res, next) {
+  try {
+    const promptKey = req.query.promptKey || req.body.promptKey;
+    if (promptKey) {
+      req.prompt = await forprompt.getPrompt(promptKey);
+    }
+    next();
+  } catch (error) {
+    next(error);
+  }
+}
+\`\`\`
+
+## 3. Use in routes
+
+\`\`\`typescript
+import express from 'express';
+import { forprompt } from '@forprompt/sdk';
+
+const app = express();
+
+app.post('/api/chat', async (req, res) => {
+  const { message, promptKey } = req.body;
+
+  const prompt = await forprompt.getPrompt(promptKey);
+
+  // Use prompt.systemPrompt with your LLM
+  // ...
+
+  res.json({ response: '...' });
+});
+\`\`\``;
+            break;
+          case "fastapi":
+            guide = `# ForPrompt + FastAPI Integration Guide
+
+## 1. Install the SDK
+
+\`\`\`bash
+pip install forprompt
+\`\`\`
+
+## 2. Create a dependency
+
+\`\`\`python
+# dependencies.py
+from forprompt import ForPrompt
+import os
+
+def get_forprompt():
+    return ForPrompt(api_key=os.environ.get("FORPROMPT_API_KEY"))
+\`\`\`
+
+## 3. Use in routes
+
+\`\`\`python
+from fastapi import FastAPI, Depends
+from forprompt import ForPrompt
+from dependencies import get_forprompt
+
+app = FastAPI()
+
+@app.post("/api/chat")
+async def chat(
+    message: str,
+    prompt_key: str,
+    fp: ForPrompt = Depends(get_forprompt)
+):
+    prompt = fp.get_prompt(prompt_key)
+
+    # Use prompt.system_prompt with your LLM
+    # ...
+
+    return {"response": "..."}
+\`\`\`
+
+## 4. Best Practices
+
+- Cache prompts using functools.lru_cache or Redis
+- Use async version for better performance
+- Consider using Pydantic models for prompt data`;
+            break;
+          case "django":
+            guide = `# ForPrompt + Django Integration Guide
+
+## 1. Install the SDK
+
+\`\`\`bash
+pip install forprompt
+\`\`\`
+
+## 2. Add to settings
+
+\`\`\`python
+# settings.py
+FORPROMPT_API_KEY = os.environ.get("FORPROMPT_API_KEY")
+\`\`\`
+
+## 3. Create a utility
+
+\`\`\`python
+# utils/forprompt.py
+from forprompt import ForPrompt
+from django.conf import settings
+from functools import lru_cache
+
+@lru_cache(maxsize=100)
+def get_prompt(key: str):
+    client = ForPrompt(api_key=settings.FORPROMPT_API_KEY)
+    return client.get_prompt(key)
+\`\`\`
+
+## 4. Use in views
+
+\`\`\`python
+from django.http import JsonResponse
+from utils.forprompt import get_prompt
+
+def chat_view(request):
+    prompt_key = request.POST.get('prompt_key')
+    prompt = get_prompt(prompt_key)
+
+    # Use prompt.system_prompt with your LLM
+
+    return JsonResponse({"response": "..."})
+\`\`\``;
+            break;
+          case "flask":
+            guide = `# ForPrompt + Flask Integration Guide
+
+## 1. Install the SDK
+
+\`\`\`bash
+pip install forprompt
+\`\`\`
+
+## 2. Initialize the client
+
+\`\`\`python
+# app.py
+from flask import Flask, request, jsonify
+from forprompt import ForPrompt
+import os
+
+app = Flask(__name__)
+forprompt_client = ForPrompt(api_key=os.environ.get("FORPROMPT_API_KEY"))
+
+@app.route('/api/chat', methods=['POST'])
+def chat():
+    data = request.json
+    prompt = forprompt_client.get_prompt(data['prompt_key'])
+
+    # Use prompt.system_prompt with your LLM
+
+    return jsonify({"response": "..."})
+\`\`\``;
+            break;
+          default:
+            guide = `# ForPrompt Generic Integration Guide
+
+## TypeScript/JavaScript
+
+\`\`\`typescript
+import { forprompt } from '@forprompt/sdk';
+
+const prompt = await forprompt.getPrompt('your_prompt_key');
+console.log(prompt.systemPrompt);
+\`\`\`
+
+## Python
+
+\`\`\`python
+from forprompt import ForPrompt
+import os
+
+client = ForPrompt(api_key=os.environ.get("FORPROMPT_API_KEY"))
+prompt = client.get_prompt("your_prompt_key")
+print(prompt.system_prompt)
+\`\`\`
+
+## Environment Setup
+
+1. Get your API key from https://forprompt.dev/dashboard
+2. Set \`FORPROMPT_API_KEY\` environment variable
+3. Install the SDK for your language
+4. Start fetching prompts!`;
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: guide
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error generating guide: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/resources.ts
+var DEFAULT_BASE_URL3 = "https://wooden-fox-811.convex.site";
+async function fetchAllPrompts2(config) {
+  const apiKey = config.apiKey || process.env.FORPROMPT_API_KEY;
+  const baseUrl = (config.baseUrl || process.env.FORPROMPT_BASE_URL || DEFAULT_BASE_URL3).replace(/\/$/, "");
+  if (!apiKey) {
+    throw new Error(
+      "API key is required. Set FORPROMPT_API_KEY environment variable."
+    );
+  }
+  const response = await fetch(`${baseUrl}/api/sync`, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json",
+      "X-API-Key": apiKey
+    }
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({
+      error: "Unknown error"
+    }));
+    throw new Error(errorData.error || `Failed to fetch prompts`);
+  }
+  const data = await response.json();
+  return data.prompts;
+}
+function parseUri(uri) {
+  const match = uri.match(/^forprompt:\/\/prompts(?:\/([^/]+))?(?:\/(v\d+|metadata))?$/);
+  if (!match) {
+    return { type: "list" };
+  }
+  const [, key, suffix] = match;
+  if (!key) {
+    return { type: "list" };
+  }
+  if (suffix === "metadata") {
+    return { key, type: "metadata" };
+  }
+  if (suffix?.startsWith("v")) {
+    const version = parseInt(suffix.slice(1), 10);
+    return { key, version, type: "prompt" };
+  }
+  return { key, type: "prompt" };
+}
+function formatPromptResource(prompt) {
+  const sections = [];
+  sections.push(`# ${prompt.name}`);
+  sections.push("");
+  sections.push(`Key: ${prompt.key}`);
+  sections.push(`Version: ${prompt.versionNumber}`);
+  sections.push(`Updated: ${new Date(prompt.updatedAt).toISOString()}`);
+  if (prompt.description) {
+    sections.push("");
+    sections.push(`## Description`);
+    sections.push(prompt.description);
+  }
+  sections.push("");
+  sections.push("## System Prompt");
+  sections.push("");
+  sections.push(prompt.systemPrompt);
+  if (prompt.purpose) {
+    sections.push("");
+    sections.push("## Purpose");
+    sections.push(prompt.purpose);
+  }
+  if (prompt.expectedBehavior) {
+    sections.push("");
+    sections.push("## Expected Behavior");
+    sections.push(prompt.expectedBehavior);
+  }
+  if (prompt.inputFormat) {
+    sections.push("");
+    sections.push("## Input Format");
+    sections.push(prompt.inputFormat);
+  }
+  if (prompt.outputFormat) {
+    sections.push("");
+    sections.push("## Output Format");
+    sections.push(prompt.outputFormat);
+  }
+  if (prompt.constraints) {
+    sections.push("");
+    sections.push("## Constraints");
+    sections.push(prompt.constraints);
+  }
+  if (prompt.useCases) {
+    sections.push("");
+    sections.push("## Use Cases");
+    sections.push(prompt.useCases);
+  }
+  return sections.join("\n");
+}
+function registerResources(server, client, config) {
+  server.resource(
+    "forprompt://prompts/{key}",
+    "Access a ForPrompt prompt by its key. Returns the system prompt and all metadata.",
+    async (uri) => {
+      const parsed = parseUri(uri.href);
+      if (parsed.type === "list" || !parsed.key) {
+        const prompts = await fetchAllPrompts2(config);
+        const list = prompts.map((p) => `- ${p.key}: ${p.name} (v${p.versionNumber})`).join("\n");
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "text/plain",
+              text: `# ForPrompt Prompts
+
+${prompts.length} prompt(s) available:
+
+${list}`
+            }
+          ]
+        };
+      }
+      if (parsed.type === "metadata") {
+        const prompt2 = await client.getPrompt(parsed.key);
+        const metadata = {
+          key: prompt2.key,
+          name: prompt2.name,
+          description: prompt2.description,
+          versionNumber: prompt2.versionNumber,
+          updatedAt: prompt2.updatedAt,
+          purpose: prompt2.purpose,
+          expectedBehavior: prompt2.expectedBehavior,
+          inputFormat: prompt2.inputFormat,
+          outputFormat: prompt2.outputFormat,
+          constraints: prompt2.constraints,
+          useCases: prompt2.useCases
+        };
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(metadata, null, 2)
+            }
+          ]
+        };
+      }
+      const prompt = await client.getPrompt(parsed.key, {
+        version: parsed.version
+      });
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "text/plain",
+            text: formatPromptResource(prompt)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// package.json
+var package_default = {
+  name: "@forprompt/sdk",
+  version: "0.1.0",
+  description: "ForPrompt SDK - Sync and manage AI prompts from your ForPrompt projects",
+  type: "module",
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  bin: {
+    forprompt: "./dist/cli/index.js",
+    "forprompt-mcp": "./dist/mcp/server.js"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    },
+    "./mcp": {
+      types: "./dist/mcp/index.d.ts",
+      import: "./dist/mcp/index.js"
+    }
+  },
+  files: [
+    "dist",
+    "README.md"
+  ],
+  license: "AGPL-3.0-or-later",
+  author: "ForPrompt",
+  repository: {
+    type: "git",
+    url: "https://github.com/ardacanuckan/forprompt.git",
+    directory: "packages/sdk"
+  },
+  homepage: "https://forprompt.dev",
+  bugs: {
+    url: "https://github.com/forprompt/sdk/issues"
+  },
+  keywords: [
+    "forprompt",
+    "prompts",
+    "ai",
+    "llm",
+    "prompt-management",
+    "cli",
+    "sdk",
+    "openai",
+    "anthropic",
+    "chatgpt"
+  ],
+  engines: {
+    node: ">=18.0.0"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "tsup",
+    prepublishOnly: "pnpm run typecheck && pnpm run build",
+    prepack: "pnpm run build",
+    clean: "rm -rf dist node_modules coverage",
+    dev: "tsup --watch",
+    typecheck: "tsc --noEmit",
+    lint: "eslint src/",
+    test: "echo 'Tests temporarily disabled due to Vitest/ESM configuration issue. Tests are written and ready in src/__tests__/' && exit 0",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  dependencies: {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    zod: "^3.24.0"
+  },
+  devDependencies: {
+    "@forprompt/eslint-config": "workspace:*",
+    "@forprompt/tsconfig": "workspace:*",
+    "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "^2.1.0",
+    eslint: "^9.0.0",
+    tsup: "^8.0.0",
+    typescript: "^5.3.0",
+    vitest: "^2.1.0"
+  }
+};
+
+// src/version.ts
+var VERSION = package_default.version;
+
+// src/mcp/server.ts
+var ForPromptMcpServer = class {
+  mcpServer;
+  forprompt;
+  config;
+  constructor(config = {}) {
+    this.config = config;
+    this.forprompt = createForPrompt({
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl
+    });
+    this.mcpServer = new McpServer({
+      name: "forprompt",
+      version: VERSION
+    });
+    this.registerCapabilities();
+  }
+  registerCapabilities() {
+    registerTools(this.mcpServer, this.forprompt, this.config);
+    registerResources(this.mcpServer, this.forprompt, this.config);
+  }
+  /**
+   * Start the MCP server with stdio transport
+   */
+  async start() {
+    const transport = new StdioServerTransport();
+    await this.mcpServer.connect(transport);
+  }
+  /**
+   * Get the underlying MCP server instance
+   */
+  getServer() {
+    return this.mcpServer;
+  }
+};
+async function startMcpServer(config = {}) {
+  const server = new ForPromptMcpServer(config);
+  await server.start();
+  return server;
+}
+function isMainModule() {
+  const arg1 = process.argv[1] || "";
+  return arg1.endsWith("forprompt-mcp") || arg1.endsWith("server.js") || arg1.includes("mcp/server");
+}
+if (isMainModule()) {
+  startMcpServer().catch((error) => {
+    console.error("Failed to start MCP server:", error);
+    process.exit(1);
+  });
+}
+
+export {
+  ForPromptMcpServer,
+  startMcpServer
+};
+//# sourceMappingURL=chunk-2ABKAGKB.js.map