wp_get_post

Instructions

Implementation Reference

• src/tools/posts/PostHandlers.ts:225-315 (handler)

  Core execution logic for wp_get_post tool: validates ID, fetches post via WordPressClient.getPost, enriches with author/categories/tags info, computes word count, formats detailed Markdown response including optional full content and admin links.

  export async function handleGetPost(
    client: WordPressClient,
    params: { id: number; include_content?: boolean },
  ): Promise<WordPressPost | string> {
    try {
      const postId = validateId(params.id, "post ID");
      const post = await client.getPost(postId);
  
      // Get additional metadata for comprehensive response
      const [author, categories, tags] = await Promise.all([
        // Get author information
        post.author
          ? client.getUser(post.author).catch(() => ({ name: `User ${post.author}`, username: `user${post.author}` }))
          : null,
        // Get categories
        post.categories && post.categories.length > 0
          ? Promise.all(post.categories.map((id) => client.getCategory(id).catch(() => ({ id, name: `Category ${id}` }))))
          : [],
        // Get tags
        post.tags && post.tags.length > 0
          ? Promise.all(post.tags.map((id) => client.getTag(id).catch(() => ({ id, name: `Tag ${id}` }))))
          : [],
      ]);
  
      // Format post content
      const date = new Date(post.date);
      const modifiedDate = new Date(post.modified);
      const formattedDate = date.toLocaleDateString("en-US", {
        year: "numeric",
        month: "short",
        day: "numeric",
        hour: "2-digit",
        minute: "2-digit",
      });
      const formattedModified = modifiedDate.toLocaleDateString("en-US", {
        year: "numeric",
        month: "short",
        day: "numeric",
        hour: "2-digit",
        minute: "2-digit",
      });
  
      const content = post.content?.rendered || "";
      const excerpt = post.excerpt?.rendered ? sanitizeHtml(post.excerpt.rendered).trim() : "";
      const wordCount = sanitizeHtml(content).split(/\s+/).filter(Boolean).length;
  
      // Build comprehensive response
      let response = `# ${post.title.rendered}\n\n`;
      response += `**Post ID**: ${post.id}\n`;
      response += `**Status**: ${post.status}\n`;
      response += `**Author**: ${author?.name || author?.username || `User ${post.author}`}\n`;
      response += `**Published**: ${formattedDate}\n`;
      response += `**Modified**: ${formattedModified}\n`;
  
      if (categories.length > 0) {
        response += `**Categories**: ${categories.map((c) => c.name).join(", ")}\n`;
      }
  
      if (tags.length > 0) {
        response += `**Tags**: ${tags.map((t) => t.name).join(", ")}\n`;
      }
  
      response += `**Word Count**: ${wordCount}\n`;
      response += `**Link**: ${post.link}\n`;
  
      if (excerpt) {
        response += `\n## Excerpt\n${excerpt}\n`;
      }
  
      // Only include full content if explicitly requested (for backward compatibility, default to true)
      const includeContent = params.include_content !== false;
      if (content && includeContent) {
        response += `\n## Content\n${content}\n`;
      }
  
      // Add management links and metadata
      const siteUrl = client.getSiteUrl ? client.getSiteUrl() : "";
      if (siteUrl) {
        response += `\n## Management\n`;
        response += `- **Edit**: ${siteUrl}/wp-admin/post.php?post=${post.id}&action=edit\n`;
        response += `- **Preview**: ${siteUrl}/?p=${post.id}&preview=true\n`;
      }
  
      return response;
    } catch (_error) {
      if (_error instanceof Error && _error.message.includes("404")) {
        return `Post with ID ${params.id} not found. Please verify the ID and try again.`;
      }
      throw new Error(`Failed to get post: ${getErrorMessage(_error)}`);
    }
  }

• src/tools/posts/PostToolDefinitions.ts:58-79 (schema)

  Input schema and description definition for the wp_get_post tool, including parameters id (required) and include_content (optional).

  export const getPostTool: MCPTool = {
    name: "wp_get_post",
    description:
      "Retrieves detailed information about a single post including metadata, content statistics, and management links. Optionally includes full HTML content for editing.\n\n" +
      "**Usage Examples:**\n" +
      "• Basic metadata: `wp_get_post --id=123`\n" +
      "• With full content: `wp_get_post --id=123 --include_content=true`",
    inputSchema: {
      type: "object",
      properties: {
        id: {
          type: "number",
          description: "The unique identifier for the post.",
        },
        include_content: {
          type: "boolean",
          description: "If true, includes the full HTML content of the post for editing. Default: false",
        },
      },
      required: ["id"],
    },
  };

• src/tools/posts/index.ts:90-107 (registration)

  Registers the wp_get_post tool by mapping its definition to the bound handler this.handleGetPost in PostTools.getTools(), which is used for MCP tool registration.

  private getHandlerForTool(toolName: string) {
    switch (toolName) {
      case "wp_list_posts":
        return this.handleListPosts.bind(this);
      case "wp_get_post":
        return this.handleGetPost.bind(this);
      case "wp_create_post":
        return this.handleCreatePost.bind(this);
      case "wp_update_post":
        return this.handleUpdatePost.bind(this);
      case "wp_delete_post":
        return this.handleDeletePost.bind(this);
      case "wp_get_post_revisions":
        return this.handleGetPostRevisions.bind(this);
      default:
        throw new Error(`Unknown tool: ${toolName}`);
    }
  }

• src/tools/posts/index.ts:158-168 (handler)

  Wrapper method in PostTools class that extracts parameters and delegates to the core handleGetPost function from PostHandlers.

  public async handleGetPost(
    client: WordPressClient,
    params: { id: number } | Record<string, unknown>,
  ): Promise<WordPressPost | string> {
    // Extract only the relevant parameters
    const postParams = {
      id: params.id as number,
    };
  
    return handleGetPost(client, postParams);
  }

• src/tools/posts/PostToolDefinitions.ts:250-257 (registration)

  Includes wp_get_post tool definition (getPostTool) in the array of post tool definitions used for registration.

  export const postToolDefinitions = [
    listPostsTool,
    getPostTool,
    createPostTool,
    updatePostTool,
    deletePostTool,
    getPostRevisionsTool,
  ];