@forprompt/sdk 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,3143 @@
+#!/usr/bin/env node
+
+// src/cli/commands/init.ts
+import * as readline from "readline";
+
+// src/cli/utils/config.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var GLOBAL_CONFIG_DIR = path.join(os.homedir(), ".forprompt");
+var GLOBAL_CONFIG_FILE = path.join(GLOBAL_CONFIG_DIR, "config.json");
+var PROJECT_CONFIG_DIR = "forprompt";
+var PROJECT_CONFIG_FILE = ".forpromptrc";
+var ENV_FILE = ".env";
+function ensureProjectConfigDir(cwd = process.cwd()) {
+  const configDir = path.join(cwd, PROJECT_CONFIG_DIR);
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  return configDir;
+}
+function loadProjectConfig(cwd = process.cwd()) {
+  try {
+    const configPath = path.join(cwd, PROJECT_CONFIG_DIR, PROJECT_CONFIG_FILE);
+    if (!fs.existsSync(configPath)) {
+      return null;
+    }
+    const content = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function saveProjectConfig(config, cwd = process.cwd()) {
+  ensureProjectConfigDir(cwd);
+  const configPath = path.join(cwd, PROJECT_CONFIG_DIR, PROJECT_CONFIG_FILE);
+  const { apiKey: _, ...configWithoutKey } = config;
+  fs.writeFileSync(configPath, JSON.stringify(configWithoutKey, null, 2));
+}
+function getApiKey(cwd = process.cwd()) {
+  if (process.env.FORPROMPT_API_KEY) {
+    return process.env.FORPROMPT_API_KEY;
+  }
+  try {
+    const envPath = path.join(cwd, ENV_FILE);
+    if (!fs.existsSync(envPath)) {
+      return null;
+    }
+    const content = fs.readFileSync(envPath, "utf-8");
+    const match = content.match(/^FORPROMPT_API_KEY=(.+)$/m);
+    return match ? match[1].trim().replace(/^["']|["']$/g, "") : null;
+  } catch {
+    return null;
+  }
+}
+function saveApiKeyToEnv(apiKey, cwd = process.cwd()) {
+  const envPath = path.join(cwd, ENV_FILE);
+  let content = "";
+  if (fs.existsSync(envPath)) {
+    content = fs.readFileSync(envPath, "utf-8");
+    if (content.match(/^FORPROMPT_API_KEY=/m)) {
+      content = content.replace(/^FORPROMPT_API_KEY=.+$/m, `FORPROMPT_API_KEY=${apiKey}`);
+    } else {
+      content = content.trim() + `
+FORPROMPT_API_KEY=${apiKey}
+`;
+    }
+  } else {
+    content = `FORPROMPT_API_KEY=${apiKey}
+`;
+  }
+  fs.writeFileSync(envPath, content);
+}
+function isProjectInitialized(cwd = process.cwd()) {
+  const projectConfig = loadProjectConfig(cwd);
+  const apiKey = getApiKey(cwd);
+  return !!(projectConfig && apiKey);
+}
+function getForpromptDir(cwd = process.cwd()) {
+  return path.join(cwd, PROJECT_CONFIG_DIR);
+}
+
+// src/cli/utils/api.ts
+var DEFAULT_BASE_URL = "https://wooden-fox-811.convex.site";
+var ApiClient = class {
+  baseUrl;
+  constructor(baseUrl) {
+    this.baseUrl = (baseUrl || DEFAULT_BASE_URL).replace(/\/$/, "");
+  }
+  /**
+   * Validate API key and get project info
+   */
+  async validateApiKey(apiKey) {
+    const response = await fetch(`${this.baseUrl}/api/cli/validate`, {
+      method: "GET",
+      headers: {
+        "X-API-Key": apiKey,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new Error(error.error || `HTTP ${response.status}`);
+    }
+    return response.json();
+  }
+  /**
+   * Deploy - fetch all prompts for a project
+   */
+  async deploy(apiKey) {
+    const response = await fetch(`${this.baseUrl}/api/cli/deploy`, {
+      method: "GET",
+      headers: {
+        "X-API-Key": apiKey,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new Error(error.error || `HTTP ${response.status}`);
+    }
+    return response.json();
+  }
+};
+function createApiClient(baseUrl) {
+  return new ApiClient(baseUrl);
+}
+
+// src/cli/commands/init.ts
+async function prompt(question, defaultValue) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    const promptText = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
+    rl.question(promptText, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue || "");
+    });
+  });
+}
+async function initCommand(options) {
+  console.log("\n\u{1F680} Initializing ForPrompt...\n");
+  const existingConfig = loadProjectConfig();
+  const existingApiKey = getApiKey();
+  if (existingConfig && existingApiKey) {
+    const overwrite = await prompt(
+      "Project already initialized. Overwrite? (y/N)",
+      "N"
+    );
+    if (overwrite.toLowerCase() !== "y") {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  let apiKey = options.apiKey;
+  if (!apiKey) {
+    apiKey = await prompt("Enter your ForPrompt API key");
+  }
+  if (!apiKey) {
+    console.error("\u274C API key is required");
+    process.exit(1);
+  }
+  console.log("\n\u{1F511} Validating API key...");
+  const baseUrl = options.baseUrl || process.env.FORPROMPT_BASE_URL;
+  const api = createApiClient(baseUrl);
+  try {
+    const result = await api.validateApiKey(apiKey);
+    if (!result.valid || !result.project) {
+      console.error("\u274C Invalid API key");
+      process.exit(1);
+    }
+    const { project } = result;
+    console.log(`
+\u2705 Connected to project: ${project.projectName}`);
+    if (project.orgName) {
+      console.log(`   Organization: ${project.orgName}`);
+    }
+    saveApiKeyToEnv(apiKey);
+    console.log("\n\u{1F4DD} Saved API key to .env");
+    saveProjectConfig({
+      projectId: project.projectId,
+      projectName: project.projectName,
+      projectSlug: project.projectSlug,
+      apiKey,
+      // Won't be saved to file, just used for reference
+      baseUrl: baseUrl || "https://wooden-fox-811.convex.site"
+    });
+    console.log(`\u{1F4C1} Created ${getForpromptDir()}/.forpromptrc`);
+    console.log("\n\u2728 ForPrompt initialized successfully!");
+    console.log("\nNext steps:");
+    console.log("  1. Run 'npx forprompt deploy' to sync your prompts");
+    console.log("  2. Import prompts in your code:");
+    console.log("     import { userContextPrompt } from './forprompt';");
+    console.log("");
+  } catch (error) {
+    console.error(
+      "\u274C Failed to validate API key:",
+      error instanceof Error ? error.message : "Unknown error"
+    );
+    process.exit(1);
+  }
+}
+
+// src/cli/utils/generator.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+function generatePromptFiles(prompts, outputDir) {
+  let created = 0;
+  let updated = 0;
+  if (!fs2.existsSync(outputDir)) {
+    fs2.mkdirSync(outputDir, { recursive: true });
+  }
+  for (const prompt2 of prompts) {
+    const promptDir = path2.join(outputDir, prompt2.key);
+    const versionsDir = path2.join(promptDir, "versions");
+    if (!fs2.existsSync(promptDir)) {
+      fs2.mkdirSync(promptDir, { recursive: true });
+      created++;
+    } else {
+      updated++;
+    }
+    if (!fs2.existsSync(versionsDir)) {
+      fs2.mkdirSync(versionsDir, { recursive: true });
+    }
+    generatePromptFile(prompt2, promptDir);
+    generateMetadataFile(prompt2, promptDir);
+    generateVersionFiles(prompt2, versionsDir);
+  }
+  generateIndexFile(prompts, outputDir);
+  return { created, updated };
+}
+function generatePromptFile(prompt2, promptDir) {
+  const activeVersion = prompt2.activeVersion;
+  if (!activeVersion) return;
+  const content = `/**
+ * ${prompt2.name}
+ * ${prompt2.description || ""}
+ *
+ * Version: ${activeVersion.versionNumber}
+ * Last updated: ${new Date(activeVersion.updatedAt).toISOString()}
+ *
+ * @generated by ForPrompt CLI - Do not edit manually
+ */
+
+export const ${prompt2.key} = ${JSON.stringify(activeVersion.systemPrompt)};
+
+export const ${prompt2.key}Info = {
+  key: "${prompt2.key}",
+  name: "${prompt2.name}",
+  version: ${activeVersion.versionNumber},
+  updatedAt: ${activeVersion.updatedAt},
+} as const;
+
+export default ${prompt2.key};
+`;
+  fs2.writeFileSync(path2.join(promptDir, "prompt.ts"), content);
+}
+function generateMetadataFile(prompt2, promptDir) {
+  const metadata = {
+    key: prompt2.key,
+    name: prompt2.name,
+    description: prompt2.description,
+    activeVersion: prompt2.activeVersion?.versionNumber || null,
+    totalVersions: prompt2.versions.length,
+    purpose: prompt2.purpose,
+    expectedBehavior: prompt2.expectedBehavior,
+    inputFormat: prompt2.inputFormat,
+    outputFormat: prompt2.outputFormat,
+    constraints: prompt2.constraints,
+    useCases: prompt2.useCases,
+    additionalNotes: prompt2.additionalNotes,
+    toolsNotes: prompt2.toolsNotes,
+    tools: prompt2.tools,
+    createdAt: prompt2.createdAt,
+    updatedAt: prompt2.updatedAt,
+    lastDeployedAt: Date.now()
+  };
+  fs2.writeFileSync(
+    path2.join(promptDir, "metadata.json"),
+    JSON.stringify(metadata, null, 2)
+  );
+}
+function generateVersionFiles(prompt2, versionsDir) {
+  for (const version of prompt2.versions) {
+    const filename = `v${version.versionNumber}.md`;
+    const content = `# Version ${version.versionNumber}
+# Created: ${new Date(version.createdAt).toISOString()}
+${version.description ? `# ${version.description}
+` : ""}
+${version.systemPrompt}`;
+    fs2.writeFileSync(path2.join(versionsDir, filename), content);
+  }
+}
+function generateIndexFile(prompts, outputDir) {
+  const exports = prompts.filter((p) => p.activeVersion).map((p) => `export { ${p.key}, ${p.key}Info } from "./${p.key}/prompt";`).join("\n");
+  const promptMap = prompts.filter((p) => p.activeVersion).map((p) => `  "${p.key}": ${p.key},`).join("\n");
+  const imports = prompts.filter((p) => p.activeVersion).map((p) => p.key).join(", ");
+  const content = `/**
+ * ForPrompt - Auto-generated prompt exports
+ *
+ * @generated by ForPrompt CLI - Do not edit manually
+ * Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+ */
+
+${exports}
+
+import { ${imports} } from "./";
+
+/**
+ * All prompts as a map for dynamic access
+ */
+export const prompts = {
+${promptMap}
+} as const;
+
+/**
+ * Get a prompt by key
+ */
+export function getPrompt(key: keyof typeof prompts): string {
+  return prompts[key];
+}
+
+export type PromptKey = keyof typeof prompts;
+`;
+  fs2.writeFileSync(path2.join(outputDir, "index.ts"), content);
+}
+function cleanupRemovedPrompts(serverPrompts, outputDir) {
+  const removed = [];
+  const serverKeys = new Set(serverPrompts.map((p) => p.key));
+  if (!fs2.existsSync(outputDir)) return removed;
+  const entries = fs2.readdirSync(outputDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith(".")) continue;
+    if (!serverKeys.has(entry.name)) {
+      const promptDir = path2.join(outputDir, entry.name);
+      fs2.rmSync(promptDir, { recursive: true, force: true });
+      removed.push(entry.name);
+    }
+  }
+  return removed;
+}
+
+// src/cli/commands/deploy.ts
+async function deployCommand(options) {
+  console.log("\n\u{1F4E6} Deploying prompts...\n");
+  if (!isProjectInitialized()) {
+    console.error("\u274C Project not initialized. Run 'npx forprompt init' first.");
+    process.exit(1);
+  }
+  const projectConfig = loadProjectConfig();
+  const apiKey = getApiKey();
+  const outputDir = getForpromptDir();
+  console.log(`\u{1F4C2} Project: ${projectConfig.projectName}`);
+  console.log(`\u{1F4C1} Output: ${outputDir}
+`);
+  const baseUrl = options.baseUrl || projectConfig.baseUrl || process.env.FORPROMPT_BASE_URL;
+  const api = createApiClient(baseUrl);
+  try {
+    console.log("\u{1F504} Fetching prompts from server...");
+    const deployResult = await api.deploy(apiKey);
+    const { prompts, project, deployedAt } = deployResult;
+    if (prompts.length === 0) {
+      console.log("\n\u26A0\uFE0F  No prompts found in project.");
+      console.log("   Create prompts in the ForPrompt dashboard first.");
+      return;
+    }
+    console.log(`   Found ${prompts.length} prompt(s)
+`);
+    if (options.clean) {
+      console.log("\u{1F9F9} Cleaning up removed prompts...");
+      const removed = cleanupRemovedPrompts(prompts, outputDir);
+      if (removed.length > 0) {
+        console.log(`   Removed: ${removed.join(", ")}`);
+      }
+    }
+    console.log("\u{1F4DD} Generating prompt files...");
+    const { created, updated } = generatePromptFiles(prompts, outputDir);
+    saveProjectConfig({
+      ...projectConfig,
+      apiKey,
+      lastDeployedAt: deployedAt
+    });
+    console.log("\n\u2728 Deploy complete!\n");
+    console.log("Summary:");
+    console.log(`  \u2022 ${prompts.length} prompt(s) synced`);
+    if (created > 0) console.log(`  \u2022 ${created} new prompt(s) created`);
+    if (updated > 0) console.log(`  \u2022 ${updated} prompt(s) updated`);
+    console.log("\nPrompts:");
+    for (const prompt2 of prompts) {
+      const version = prompt2.activeVersion?.versionNumber || "no active version";
+      console.log(`  \u2022 ${prompt2.key} (v${version})`);
+    }
+    console.log("\nUsage:");
+    console.log('  import { getPrompt } from "./forprompt";');
+    console.log('  const prompt = getPrompt("userContextPrompt");');
+    console.log("\n  // Or import directly:");
+    console.log('  import { userContextPrompt } from "./forprompt";');
+    console.log("");
+  } catch (error) {
+    console.error(
+      "\u274C Deploy failed:",
+      error instanceof Error ? error.message : "Unknown error"
+    );
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/mcp.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+import * as readline2 from "readline";
+
+// 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_URL2 = "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_URL2).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_URL3 = "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_URL3).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(prompt2) {
+  const sections = [];
+  sections.push(`# ${prompt2.name}`);
+  sections.push(`**Key:** ${prompt2.key}`);
+  sections.push(`**Version:** ${prompt2.versionNumber}`);
+  if (prompt2.description) {
+    sections.push(`**Description:** ${prompt2.description}`);
+  }
+  sections.push("");
+  sections.push("## System Prompt");
+  sections.push("```");
+  sections.push(prompt2.systemPrompt);
+  sections.push("```");
+  if (prompt2.purpose) {
+    sections.push("");
+    sections.push("## Purpose");
+    sections.push(prompt2.purpose);
+  }
+  if (prompt2.expectedBehavior) {
+    sections.push("");
+    sections.push("## Expected Behavior");
+    sections.push(prompt2.expectedBehavior);
+  }
+  if (prompt2.inputFormat) {
+    sections.push("");
+    sections.push("## Input Format");
+    sections.push(prompt2.inputFormat);
+  }
+  if (prompt2.outputFormat) {
+    sections.push("");
+    sections.push("## Output Format");
+    sections.push(prompt2.outputFormat);
+  }
+  if (prompt2.constraints) {
+    sections.push("");
+    sections.push("## Constraints");
+    sections.push(prompt2.constraints);
+  }
+  if (prompt2.useCases) {
+    sections.push("");
+    sections.push("## Use Cases");
+    sections.push(prompt2.useCases);
+  }
+  if (prompt2.additionalNotes) {
+    sections.push("");
+    sections.push("## Additional Notes");
+    sections.push(prompt2.additionalNotes);
+  }
+  if (prompt2.toolsNotes) {
+    sections.push("");
+    sections.push("## Tools Notes");
+    sections.push(prompt2.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 prompt2 = await client.getPrompt(key, { version });
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatPrompt(prompt2)
+            }
+          ]
+        };
+      } 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 prompt2 = await client.getPrompt(key);
+        const metadata = {
+          key: prompt2.key,
+          name: prompt2.name,
+          description: prompt2.description,
+          versionNumber: prompt2.versionNumber,
+          updatedAt: new Date(prompt2.updatedAt).toISOString(),
+          purpose: prompt2.purpose,
+          expectedBehavior: prompt2.expectedBehavior,
+          inputFormat: prompt2.inputFormat,
+          outputFormat: prompt2.outputFormat,
+          constraints: prompt2.constraints,
+          useCases: prompt2.useCases,
+          additionalNotes: prompt2.additionalNotes,
+          toolsNotes: prompt2.toolsNotes,
+          systemPromptLength: prompt2.systemPrompt.length
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: `# Metadata for "${prompt2.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 prompt2 = await client.getPrompt(key, { version });
+        return {
+          content: [
+            {
+              type: "text",
+              text: prompt2.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 fs4 = await import("fs");
+        const path5 = await import("path");
+        const detection = {
+          language: null,
+          packageManager: null,
+          framework: null,
+          hasForPrompt: false,
+          configFiles: []
+        };
+        const packageJsonPath = path5.join(projectPath, "package.json");
+        if (fs4.existsSync(packageJsonPath)) {
+          const packageJson = JSON.parse(fs4.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 (fs4.existsSync(path5.join(projectPath, "pnpm-lock.yaml"))) {
+            detection.packageManager = "pnpm";
+          } else if (fs4.existsSync(path5.join(projectPath, "yarn.lock"))) {
+            detection.packageManager = "yarn";
+          } else if (fs4.existsSync(path5.join(projectPath, "bun.lockb"))) {
+            detection.packageManager = "bun";
+          } else if (fs4.existsSync(path5.join(projectPath, "package-lock.json"))) {
+            detection.packageManager = "npm";
+          }
+          detection.configFiles.push("package.json");
+        }
+        const pyprojectPath = path5.join(projectPath, "pyproject.toml");
+        const requirementsPath = path5.join(projectPath, "requirements.txt");
+        if (fs4.existsSync(pyprojectPath)) {
+          detection.language = "python";
+          const content = fs4.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 (fs4.existsSync(requirementsPath)) {
+          detection.language = "python";
+          detection.packageManager = "pip";
+          detection.configFiles.push("requirements.txt");
+          const content = fs4.readFileSync(requirementsPath, "utf-8");
+          if (content.includes("forprompt")) {
+            detection.hasForPrompt = true;
+          }
+        }
+        const forpromptConfigPath = path5.join(projectPath, ".forprompt");
+        if (fs4.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 fs4 = await import("fs");
+        const path5 = await import("path");
+        let detectedLanguage = language;
+        let detectedPM = packageManager;
+        if (!detectedLanguage || !detectedPM) {
+          const packageJsonPath = path5.join(projectPath, "package.json");
+          const pyprojectPath = path5.join(projectPath, "pyproject.toml");
+          const requirementsPath = path5.join(projectPath, "requirements.txt");
+          if (fs4.existsSync(packageJsonPath)) {
+            const packageJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf-8"));
+            if (!detectedLanguage) {
+              detectedLanguage = packageJson.devDependencies?.typescript ? "typescript" : "javascript";
+            }
+            if (!detectedPM) {
+              if (fs4.existsSync(path5.join(projectPath, "pnpm-lock.yaml"))) {
+                detectedPM = "pnpm";
+              } else if (fs4.existsSync(path5.join(projectPath, "yarn.lock"))) {
+                detectedPM = "yarn";
+              } else if (fs4.existsSync(path5.join(projectPath, "bun.lockb"))) {
+                detectedPM = "bun";
+              } else {
+                detectedPM = "npm";
+              }
+            }
+          } else if (fs4.existsSync(pyprojectPath) || fs4.existsSync(requirementsPath)) {
+            detectedLanguage = "python";
+            if (!detectedPM) {
+              if (fs4.existsSync(pyprojectPath)) {
+                const content = fs4.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_URL4 = "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_URL4).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(prompt2) {
+  const sections = [];
+  sections.push(`# ${prompt2.name}`);
+  sections.push("");
+  sections.push(`Key: ${prompt2.key}`);
+  sections.push(`Version: ${prompt2.versionNumber}`);
+  sections.push(`Updated: ${new Date(prompt2.updatedAt).toISOString()}`);
+  if (prompt2.description) {
+    sections.push("");
+    sections.push(`## Description`);
+    sections.push(prompt2.description);
+  }
+  sections.push("");
+  sections.push("## System Prompt");
+  sections.push("");
+  sections.push(prompt2.systemPrompt);
+  if (prompt2.purpose) {
+    sections.push("");
+    sections.push("## Purpose");
+    sections.push(prompt2.purpose);
+  }
+  if (prompt2.expectedBehavior) {
+    sections.push("");
+    sections.push("## Expected Behavior");
+    sections.push(prompt2.expectedBehavior);
+  }
+  if (prompt2.inputFormat) {
+    sections.push("");
+    sections.push("## Input Format");
+    sections.push(prompt2.inputFormat);
+  }
+  if (prompt2.outputFormat) {
+    sections.push("");
+    sections.push("## Output Format");
+    sections.push(prompt2.outputFormat);
+  }
+  if (prompt2.constraints) {
+    sections.push("");
+    sections.push("## Constraints");
+    sections.push(prompt2.constraints);
+  }
+  if (prompt2.useCases) {
+    sections.push("");
+    sections.push("## Use Cases");
+    sections.push(prompt2.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 prompt3 = await client.getPrompt(parsed.key);
+        const metadata = {
+          key: prompt3.key,
+          name: prompt3.name,
+          description: prompt3.description,
+          versionNumber: prompt3.versionNumber,
+          updatedAt: prompt3.updatedAt,
+          purpose: prompt3.purpose,
+          expectedBehavior: prompt3.expectedBehavior,
+          inputFormat: prompt3.inputFormat,
+          outputFormat: prompt3.outputFormat,
+          constraints: prompt3.constraints,
+          useCases: prompt3.useCases
+        };
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(metadata, null, 2)
+            }
+          ]
+        };
+      }
+      const prompt2 = await client.getPrompt(parsed.key, {
+        version: parsed.version
+      });
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "text/plain",
+            text: formatPromptResource(prompt2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// 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);
+  });
+}
+
+// src/mcp/config/generators.ts
+import * as os2 from "os";
+import * as path3 from "path";
+function getEditorConfigPath(editor) {
+  const home = os2.homedir();
+  switch (editor) {
+    case "claude-desktop":
+      if (process.platform === "darwin") {
+        return path3.join(
+          home,
+          "Library",
+          "Application Support",
+          "Claude",
+          "claude_desktop_config.json"
+        );
+      } else if (process.platform === "win32") {
+        return path3.join(
+          process.env.APPDATA || path3.join(home, "AppData", "Roaming"),
+          "Claude",
+          "claude_desktop_config.json"
+        );
+      } else {
+        return path3.join(home, ".config", "Claude", "claude_desktop_config.json");
+      }
+    case "claude-code":
+      return path3.join(process.cwd(), ".mcp.json");
+    case "cursor":
+      return path3.join(process.cwd(), ".cursor", "mcp.json");
+    case "continue":
+      return path3.join(home, ".continue", "config.json");
+    case "windsurf":
+      return path3.join(home, ".windsurf", "mcp.json");
+    case "vscode":
+      return path3.join(process.cwd(), ".vscode", "mcp.json");
+    default:
+      throw new Error(`Unknown editor: ${editor}`);
+  }
+}
+function generateClaudeDesktopConfig(apiKey, baseUrl) {
+  const config = {
+    mcpServers: {
+      forprompt: {
+        command: "npx",
+        args: ["-y", "@forprompt/sdk", "mcp", "start"],
+        env: {
+          FORPROMPT_API_KEY: apiKey,
+          ...baseUrl && { FORPROMPT_BASE_URL: baseUrl }
+        }
+      }
+    }
+  };
+  return JSON.stringify(config, null, 2);
+}
+function generateClaudeCodeConfig(apiKey, baseUrl) {
+  const config = {
+    mcpServers: {
+      forprompt: {
+        command: "npx",
+        args: ["-y", "@forprompt/sdk", "mcp", "start"],
+        env: {
+          FORPROMPT_API_KEY: apiKey,
+          ...baseUrl && { FORPROMPT_BASE_URL: baseUrl }
+        }
+      }
+    }
+  };
+  return JSON.stringify(config, null, 2);
+}
+function generateCursorConfig(apiKey, baseUrl) {
+  const config = {
+    mcpServers: {
+      forprompt: {
+        command: "npx",
+        args: ["-y", "@forprompt/sdk", "mcp", "start"],
+        env: {
+          FORPROMPT_API_KEY: apiKey,
+          ...baseUrl && { FORPROMPT_BASE_URL: baseUrl }
+        }
+      }
+    }
+  };
+  return JSON.stringify(config, null, 2);
+}
+function generateContinueConfig(apiKey, baseUrl) {
+  const config = {
+    mcpServers: [
+      {
+        name: "forprompt",
+        command: "npx",
+        args: ["-y", "@forprompt/sdk", "mcp", "start"],
+        env: {
+          FORPROMPT_API_KEY: apiKey,
+          ...baseUrl && { FORPROMPT_BASE_URL: baseUrl }
+        }
+      }
+    ]
+  };
+  return JSON.stringify(config, null, 2);
+}
+function generateWindsurfConfig(apiKey, baseUrl) {
+  const config = {
+    mcpServers: {
+      forprompt: {
+        command: "npx",
+        args: ["-y", "@forprompt/sdk", "mcp", "start"],
+        env: {
+          FORPROMPT_API_KEY: apiKey,
+          ...baseUrl && { FORPROMPT_BASE_URL: baseUrl }
+        }
+      }
+    }
+  };
+  return JSON.stringify(config, null, 2);
+}
+function generateVSCodeConfig(apiKey, baseUrl) {
+  const config = {
+    mcpServers: {
+      forprompt: {
+        command: "npx",
+        args: ["-y", "@forprompt/sdk", "mcp", "start"],
+        env: {
+          FORPROMPT_API_KEY: apiKey,
+          ...baseUrl && { FORPROMPT_BASE_URL: baseUrl }
+        }
+      }
+    }
+  };
+  return JSON.stringify(config, null, 2);
+}
+var editorConfigs = {
+  "claude-desktop": {
+    name: "Claude Desktop",
+    description: "Anthropic's Claude desktop application",
+    configPath: getEditorConfigPath("claude-desktop"),
+    configFileName: "claude_desktop_config.json",
+    generate: generateClaudeDesktopConfig,
+    instructions: `
+1. Open the config file at the path shown above
+2. Add or merge the ForPrompt MCP server configuration
+3. Restart Claude Desktop
+4. You can now ask Claude to "list my ForPrompt prompts" or "get the [prompt-key] prompt"
+`
+  },
+  "claude-code": {
+    name: "Claude Code",
+    description: "Anthropic's Claude Code CLI tool",
+    configPath: getEditorConfigPath("claude-code"),
+    configFileName: ".mcp.json",
+    generate: generateClaudeCodeConfig,
+    instructions: `
+1. Create .mcp.json in your project root directory
+2. Add the ForPrompt MCP server configuration
+3. Claude Code will automatically detect and load the MCP server
+4. You can now ask Claude Code to manage your ForPrompt prompts
+`
+  },
+  cursor: {
+    name: "Cursor",
+    description: "Cursor AI-powered code editor",
+    configPath: getEditorConfigPath("cursor"),
+    configFileName: "mcp.json",
+    generate: generateCursorConfig,
+    instructions: `
+1. Create the .cursor directory in your project root if it doesn't exist
+2. Save the configuration to .cursor/mcp.json
+3. Restart Cursor or reload the window
+4. Your ForPrompt prompts will be available via MCP
+`
+  },
+  continue: {
+    name: "Continue.dev",
+    description: "Continue - open-source AI code assistant",
+    configPath: getEditorConfigPath("continue"),
+    configFileName: "config.json",
+    generate: generateContinueConfig,
+    instructions: `
+1. Open your Continue config file (~/.continue/config.json)
+2. Add the ForPrompt MCP server to the mcpServers array
+3. Restart your IDE or reload Continue
+4. Your ForPrompt prompts will be available via MCP
+`
+  },
+  windsurf: {
+    name: "Windsurf",
+    description: "Windsurf AI-powered IDE",
+    configPath: getEditorConfigPath("windsurf"),
+    configFileName: "mcp.json",
+    generate: generateWindsurfConfig,
+    instructions: `
+1. Create the ~/.windsurf directory if it doesn't exist
+2. Save the configuration to ~/.windsurf/mcp.json
+3. Restart Windsurf
+4. Your ForPrompt prompts will be available via MCP
+`
+  },
+  vscode: {
+    name: "VS Code",
+    description: "Visual Studio Code with MCP extension",
+    configPath: getEditorConfigPath("vscode"),
+    configFileName: "mcp.json",
+    generate: generateVSCodeConfig,
+    instructions: `
+1. Install an MCP-compatible extension in VS Code
+2. Create .vscode/mcp.json in your project
+3. Add the ForPrompt MCP server configuration
+4. Reload VS Code
+`
+  }
+};
+function generateConfig(editor, apiKey, baseUrl) {
+  const editorConfig = editorConfigs[editor];
+  if (!editorConfig) {
+    throw new Error(
+      `Unknown editor: ${editor}. Supported editors: ${getSupportedEditors().join(", ")}`
+    );
+  }
+  return {
+    config: editorConfig.generate(apiKey, baseUrl),
+    path: editorConfig.configPath,
+    instructions: editorConfig.instructions
+  };
+}
+function getSupportedEditors() {
+  return Object.keys(editorConfigs);
+}
+
+// src/cli/commands/mcp.ts
+async function promptUser(question) {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function getApiKey2() {
+  return getApiKey() || void 0;
+}
+async function startCommand(options) {
+  console.log("Starting ForPrompt MCP server...");
+  const apiKey = getApiKey2();
+  if (!apiKey) {
+    console.error(
+      "\nError: No API key found. Please run 'npx forprompt init' first or set FORPROMPT_API_KEY environment variable.\n"
+    );
+    process.exit(1);
+  }
+  try {
+    await startMcpServer({
+      apiKey,
+      baseUrl: process.env.FORPROMPT_BASE_URL
+    });
+  } catch (error) {
+    console.error("Failed to start MCP server:", error);
+    process.exit(1);
+  }
+}
+async function configCommand(options) {
+  const apiKey = getApiKey2();
+  if (!apiKey) {
+    console.log("\nNo API key found. Let me help you set one up.\n");
+    const inputKey = await promptUser("Enter your ForPrompt API key: ");
+    if (!inputKey) {
+      console.error("Error: API key is required.");
+      process.exit(1);
+    }
+    saveApiKeyToEnv(inputKey);
+    console.log(`
+\u2713 API key saved to .env
+`);
+    process.env.FORPROMPT_API_KEY = inputKey;
+    return configCommand({ ...options });
+  }
+  const baseUrl = process.env.FORPROMPT_BASE_URL;
+  if (options.all) {
+    console.log("\nGenerating MCP configurations for all supported editors:\n");
+    for (const editor2 of getSupportedEditors()) {
+      try {
+        const { config, path: configPath, instructions } = generateConfig(
+          editor2,
+          apiKey,
+          baseUrl
+        );
+        console.log(`
+## ${editorConfigs[editor2].name}`);
+        console.log(`Config file: ${configPath}`);
+        console.log("\n```json");
+        console.log(config);
+        console.log("```");
+        console.log(instructions);
+      } catch (error) {
+        console.error(`Error generating config for ${editor2}:`, error);
+      }
+    }
+    return;
+  }
+  const editor = options.editor;
+  if (!editor) {
+    console.log("\nForPrompt MCP Configuration Generator\n");
+    console.log("Supported editors:");
+    for (const [key, config] of Object.entries(editorConfigs)) {
+      console.log(`  - ${key}: ${config.description}`);
+    }
+    console.log("\nUsage:");
+    console.log("  npx forprompt mcp config --editor=claude-desktop");
+    console.log("  npx forprompt mcp config --editor=cursor");
+    console.log("  npx forprompt mcp config --all");
+    return;
+  }
+  if (!getSupportedEditors().includes(editor)) {
+    console.error(
+      `
+Error: Unknown editor "${editor}". Supported editors: ${getSupportedEditors().join(", ")}
+`
+    );
+    process.exit(1);
+  }
+  try {
+    const { config, path: configPath, instructions } = generateConfig(
+      editor,
+      apiKey,
+      baseUrl
+    );
+    console.log(`
+# ${editorConfigs[editor].name} MCP Configuration
+`);
+    console.log(`Config file: ${configPath}
+`);
+    console.log("Add this to your configuration file:\n");
+    console.log("```json");
+    console.log(config);
+    console.log("```");
+    console.log(instructions);
+    const shouldWrite = await promptUser(
+      "\nWould you like to write this config file? (y/N): "
+    );
+    if (shouldWrite.toLowerCase() === "y") {
+      const configDir = path4.dirname(configPath);
+      if (!fs3.existsSync(configDir)) {
+        fs3.mkdirSync(configDir, { recursive: true });
+      }
+      if (fs3.existsSync(configPath)) {
+        const overwrite = await promptUser(
+          `
+File ${configPath} already exists. Overwrite? (y/N): `
+        );
+        if (overwrite.toLowerCase() !== "y") {
+          console.log("\nConfig not written. You can copy the config above manually.");
+          return;
+        }
+      }
+      fs3.writeFileSync(configPath, config);
+      console.log(`
+\u2713 Config written to ${configPath}`);
+      console.log(
+        `
+Remember to restart ${editorConfigs[editor].name} to apply changes.`
+      );
+    }
+  } catch (error) {
+    console.error("Error generating config:", error);
+    process.exit(1);
+  }
+}
+async function infoCommand() {
+  console.log(`
+ForPrompt MCP Server
+====================
+
+The ForPrompt MCP server exposes your prompts to AI assistants like
+Claude Desktop, Cursor, Continue.dev, and other MCP-compatible tools.
+
+Setup & Integration Tools:
+  - forprompt_detect_project       Detect project type, language, package manager
+  - forprompt_setup_project        Get install command for ForPrompt SDK
+  - forprompt_generate_config      Generate .forprompt config file
+  - forprompt_generate_example     Generate code examples for your language
+  - forprompt_integration_guide    Get framework-specific integration guide
+
+Read Tools:
+  - forprompt_get_prompt           Fetch a prompt by its key
+  - forprompt_list_prompts         List all available prompts
+  - forprompt_search_prompts       Search prompts by text
+  - forprompt_get_prompt_metadata  Get prompt metadata only
+  - forprompt_get_system_prompt    Get raw system prompt text
+
+Write Tools:
+  - forprompt_create_prompt        Create a new prompt
+  - forprompt_update_prompt        Update prompt metadata
+  - forprompt_create_version       Create a new version (update prompt text)
+  - forprompt_delete_prompt        Delete a prompt
+
+Available Resources:
+  - forprompt://prompts              List all prompts
+  - forprompt://prompts/{key}        Get a specific prompt
+  - forprompt://prompts/{key}/v{n}   Get a specific version
+  - forprompt://prompts/{key}/metadata  Get metadata only
+
+Quick Start:
+  1. Run: npx forprompt mcp config --editor=claude-desktop
+  2. Restart Claude Desktop
+  3. Ask Claude: "Integrate ForPrompt into my project"
+  4. Or: "List my ForPrompt prompts"
+  5. Or: "Create a new prompt called customer_support"
+
+Example Conversations:
+  "Integrate ForPrompt into this project"
+  "Show me how to use ForPrompt with Next.js"
+  "Create a prompt for customer support with key customer_support_v1"
+  "Update the system prompt for my chatbot"
+
+Environment Variables:
+  FORPROMPT_API_KEY    Your project API key (required)
+  FORPROMPT_BASE_URL   Custom API URL (optional)
+
+For more information, visit: https://forprompt.dev/docs/mcp
+`);
+}
+async function mcpCommand(options) {
+  const subcommand = options.subcommand || "help";
+  switch (subcommand) {
+    case "start":
+      await startCommand(options);
+      break;
+    case "config":
+      await configCommand(options);
+      break;
+    case "info":
+      await infoCommand();
+      break;
+    case "help":
+    default:
+      console.log(`
+ForPrompt MCP Commands
+======================
+
+Usage:
+  npx forprompt mcp <command> [options]
+
+Commands:
+  start     Start the MCP server (stdio transport)
+  config    Generate configuration for AI editors
+  info      Show MCP server information
+
+Config Options:
+  --editor=<name>   Generate config for specific editor
+                    Options: claude-code, claude-desktop, cursor, continue, windsurf, vscode
+  --all             Generate configs for all supported editors
+
+Examples:
+  npx forprompt mcp start
+  npx forprompt mcp config --editor=claude-code
+  npx forprompt mcp config --editor=claude-desktop
+  npx forprompt mcp config --editor=cursor
+  npx forprompt mcp config --all
+  npx forprompt mcp info
+
+For detailed documentation, visit: https://forprompt.dev/docs/mcp
+`);
+  }
+}
+
+// src/cli/index.ts
+function parseArgs(args) {
+  const options = {};
+  let command;
+  let subcommand;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const [key, value] = arg.slice(2).split("=");
+      if (key) {
+        options[key] = value || true;
+      }
+    } else if (arg.startsWith("-")) {
+      const key = arg.slice(1);
+      if (key) {
+        options[key] = true;
+      }
+    } else if (!command) {
+      command = arg;
+    } else if (!subcommand) {
+      subcommand = arg;
+    }
+  }
+  return { command, subcommand, options };
+}
+function showHelp() {
+  console.log(`
+ForPrompt CLI v${VERSION}
+
+Sync prompts from your ForPrompt projects to local files.
+
+Usage:
+  npx forprompt <command> [options]
+
+Commands:
+  init              Initialize ForPrompt in the current directory
+  deploy            Fetch and sync prompts to local files
+  mcp               MCP server management (start, config, info)
+  help              Show this help message
+
+Init Options:
+  --api-key=<key>   Provide API key directly (otherwise prompted)
+
+Deploy Options:
+  --clean           Remove local prompts that no longer exist on server
+
+MCP Options:
+  mcp start         Start MCP server (stdio transport)
+  mcp config        Generate config for AI editors
+    --editor=<name> Editor: claude-desktop, cursor, continue, windsurf, vscode
+    --all           Generate configs for all editors
+  mcp info          Show MCP server information
+
+Examples:
+  npx forprompt init
+  npx forprompt init --api-key=fp_xxx
+  npx forprompt deploy
+  npx forprompt deploy --clean
+  npx forprompt mcp start
+  npx forprompt mcp config --editor=claude-desktop
+
+Environment Variables:
+  FORPROMPT_API_KEY     API key (alternative to .env file)
+  FORPROMPT_BASE_URL    Custom API base URL (for self-hosted)
+
+Documentation:
+  https://forprompt.dev/docs/cli
+`);
+}
+function showVersion() {
+  console.log(`forprompt v${VERSION}`);
+}
+async function main() {
+  const { command, subcommand, options } = parseArgs(process.argv.slice(2));
+  if (options.version || options.v) {
+    showVersion();
+    return;
+  }
+  if (options.help || options.h) {
+    showHelp();
+    return;
+  }
+  switch (command) {
+    case "init":
+      await initCommand({
+        apiKey: options["api-key"],
+        baseUrl: options["base-url"]
+      });
+      break;
+    case "deploy":
+      await deployCommand({
+        clean: options.clean,
+        baseUrl: options["base-url"]
+      });
+      break;
+    case "mcp":
+      await mcpCommand({
+        subcommand,
+        editor: options.editor,
+        all: options.all,
+        transport: options.transport,
+        port: options.port ? parseInt(options.port, 10) : void 0
+      });
+      break;
+    case "help":
+    case void 0:
+      showHelp();
+      break;
+    case "version":
+      showVersion();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.log("Run 'npx forprompt help' for usage.");
+      process.exit(1);
+  }
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map