mcp-wordpress 2.6.4 → 2.7.0

package/src/tools/comments.ts

@@ -14,7 +14,14 @@ export class CommentTools {
   public getTools(): Array<{
     name: string;
     description: string;
-    parameters?: Array<{ name: string; type?: string; description?: string; required?: boolean; enum?: string[]; items?: unknown }>;
+    parameters?: Array<{
+      name: string;
+      type?: string;
+      description?: string;
+      required?: boolean;
+      enum?: string[];
+      items?: unknown;
+    }>;
     handler: (client: WordPressClient, params: Record<string, unknown>) => Promise<unknown>;
   }> {
     return [
@@ -165,8 +172,8 @@ export class CommentTools {
           )
           .join("\n");
       return content;
-    } catch (error) {
-      throw new Error(`Failed to list comments: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to list comments: ${getErrorMessage(_error)}`);
     }
   }
 
@@ -182,8 +189,8 @@ export class CommentTools {
         `- **Status:** ${comment.status}\n` +
         `- **Content:** ${comment.content.rendered}`;
       return content;
-    } catch (error) {
-      throw new Error(`Failed to get comment: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to get comment: ${getErrorMessage(_error)}`);
     }
   }
 
@@ -192,21 +199,18 @@ export class CommentTools {
     try {
       const comment = await client.createComment(createParams);
       return `✅ Comment created successfully with ID: ${comment.id}`;
-    } catch (error) {
-      throw new Error(`Failed to create comment: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to create comment: ${getErrorMessage(_error)}`);
     }
   }
 
-  public async handleUpdateComment(
-    client: WordPressClient,
-    params: Record<string, unknown>,
-  ): Promise<unknown> {
+  public async handleUpdateComment(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
     try {
       const updateParams = params as unknown as UpdateCommentRequest & { id: number };
       const comment = await client.updateComment(updateParams);
       return `✅ Comment ${comment.id} updated successfully. New status: ${comment.status}.`;
-    } catch (error) {
-      throw new Error(`Failed to update comment: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to update comment: ${getErrorMessage(_error)}`);
     }
   }
 
@@ -216,8 +220,8 @@ export class CommentTools {
       await client.deleteComment(id, force);
       const action = force ? "permanently deleted" : "moved to trash";
       return `✅ Comment ${id} has been ${action}`;
-    } catch (error) {
-      throw new Error(`Failed to delete comment: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to delete comment: ${getErrorMessage(_error)}`);
     }
   }
 
@@ -229,8 +233,8 @@ export class CommentTools {
         status: "approved",
       });
       return `✅ Comment ${comment.id} has been approved.`;
-    } catch (error) {
-      throw new Error(`Failed to approve comment: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to approve comment: ${getErrorMessage(_error)}`);
     }
   }
 
@@ -242,8 +246,8 @@ export class CommentTools {
         status: "spam",
       });
       return `✅ Comment ${comment.id} has been marked as spam.`;
-    } catch (error) {
-      throw new Error(`Failed to mark comment as spam: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to mark comment as spam: ${getErrorMessage(_error)}`);
     }
   }
 }

package/src/tools/index.ts

@@ -5,6 +5,7 @@ export { default as MediaTools } from "./media.js";
 export { default as PageTools } from "./pages.js";
 export { default as PerformanceTools } from "./performance.js";
 export { default as PostTools } from "./posts.js";
+export { default as SEOTools } from "./seo/index.js";
 export { default as SiteTools } from "./site.js";
 export { default as TaxonomyTools } from "./taxonomies.js";
 export { default as UserTools } from "./users.js";

package/src/tools/media.ts

@@ -54,7 +54,14 @@ export class MediaTools {
   public getTools(): Array<{
     name: string;
     description: string;
-    parameters?: Array<{ name: string; type?: string; description?: string; required?: boolean; enum?: string[]; items?: unknown }>;
+    parameters?: Array<{
+      name: string;
+      type?: string;
+      description?: string;
+      required?: boolean;
+      enum?: string[];
+      items?: unknown;
+    }>;
     handler: (client: WordPressClient, params: Record<string, unknown>) => Promise<unknown>;
   }> {
     return [
@@ -197,8 +204,8 @@ export class MediaTools {
         `Found ${media.length} media items:\n\n` +
         media.map((m) => `- ID ${m.id}: **${m.title.rendered}** (${m.mime_type})\n  Link: ${m.source_url}`).join("\n");
       return content;
-    } catch (error) {
-      throw new Error(`Failed to list media: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to list media: ${getErrorMessage(_error)}`);
     }
   }
 
@@ -215,38 +222,34 @@ export class MediaTools {
         (media.alt_text ? `- **Alt Text:** ${media.alt_text}\n` : "") +
         (media.caption.rendered ? `- **Caption:** ${media.caption.rendered}\n` : "");
       return content;
-    } catch (error) {
-      throw new Error(`Failed to get media item: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to get media item: ${getErrorMessage(_error)}`);
     }
   }
 
-  public async handleUploadMedia(
-    client: WordPressClient,
-    params: Record<string, unknown>,
-  ): Promise<unknown> {
+  public async handleUploadMedia(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
     const uploadParams = params as unknown as UploadMediaRequest & { file_path: string };
     try {
-      if (!fs.existsSync(uploadParams.file_path)) {
+      try {
+        await fs.promises.access(uploadParams.file_path);
+      } catch (_error) {
         throw new Error(`File not found at path: ${uploadParams.file_path}`);
       }
 
       const media = await client.uploadMedia(uploadParams);
       return `✅ Media uploaded successfully!\n- ID: ${media.id}\n- Title: ${media.title.rendered}\n- URL: ${media.source_url}`;
-    } catch (error) {
-      throw new Error(`Failed to upload media: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to upload media: ${getErrorMessage(_error)}`);
     }
   }
 
-  public async handleUpdateMedia(
-    client: WordPressClient,
-    params: Record<string, unknown>,
-  ): Promise<unknown> {
+  public async handleUpdateMedia(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
     const updateParams = params as unknown as UpdateMediaRequest & { id: number };
     try {
       const media = await client.updateMedia(updateParams);
       return `✅ Media ${media.id} updated successfully.`;
-    } catch (error) {
-      throw new Error(`Failed to update media: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to update media: ${getErrorMessage(_error)}`);
     }
   }
 
@@ -256,8 +259,8 @@ export class MediaTools {
       await client.deleteMedia(id, force);
       const action = force ? "permanently deleted" : "moved to trash";
       return `✅ Media item ${id} has been ${action}`;
-    } catch (error) {
-      throw new Error(`Failed to delete media: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to delete media: ${getErrorMessage(_error)}`);
     }
   }
 }

package/src/tools/pages.ts

@@ -14,7 +14,14 @@ export class PageTools {
   public getTools(): Array<{
     name: string;
     description: string;
-    parameters?: Array<{ name: string; type?: string; description?: string; required?: boolean; enum?: string[]; items?: unknown }>;
+    parameters?: Array<{
+      name: string;
+      type?: string;
+      description?: string;
+      required?: boolean;
+      enum?: string[];
+      items?: unknown;
+    }>;
     handler: (client: WordPressClient, params: Record<string, unknown>) => Promise<unknown>;
   }> {
     return [
@@ -152,8 +159,8 @@ export class PageTools {
         `Found ${pages.length} pages:\n\n` +
         pages.map((p) => `- ID ${p.id}: **${p.title.rendered}** (${p.status})\n  Link: ${p.link}`).join("\n");
       return content;
-    } catch (error) {
-      throw new Error(`Failed to list pages: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to list pages: ${getErrorMessage(_error)}`);
     }
   }
 
@@ -168,8 +175,8 @@ export class PageTools {
         `- **Link:** ${page.link}\n` +
         `- **Date:** ${new Date(page.date).toLocaleString()}`;
       return content;
-    } catch (error) {
-      throw new Error(`Failed to get page: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to get page: ${getErrorMessage(_error)}`);
     }
   }
 
@@ -178,8 +185,8 @@ export class PageTools {
     try {
       const page = await client.createPage(createParams);
       return `✅ Page created successfully!\n- ID: ${page.id}\n- Title: ${page.title.rendered}\n- Link: ${page.link}`;
-    } catch (error) {
-      throw new Error(`Failed to create page: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to create page: ${getErrorMessage(_error)}`);
     }
   }
 
@@ -188,8 +195,8 @@ export class PageTools {
     try {
       const page = await client.updatePage(updateParams);
       return `✅ Page ${page.id} updated successfully.`;
-    } catch (error) {
-      throw new Error(`Failed to update page: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to update page: ${getErrorMessage(_error)}`);
     }
   }
 
@@ -199,8 +206,8 @@ export class PageTools {
       await client.deletePage(id, force);
       const action = params.force ? "permanently deleted" : "moved to trash";
       return `✅ Page ${id} has been ${action}.`;
-    } catch (error) {
-      throw new Error(`Failed to delete page: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to delete page: ${getErrorMessage(_error)}`);
     }
   }
 
@@ -217,8 +224,8 @@ export class PageTools {
           .map((r) => `- Revision by user ID ${r.author} at ${new Date(r.modified).toLocaleString()}`)
           .join("\n");
       return content;
-    } catch (error) {
-      throw new Error(`Failed to get page revisions: ${getErrorMessage(error)}`);
+    } catch (_error) {
+      throw new Error(`Failed to get page revisions: ${getErrorMessage(_error)}`);
     }
   }
 }

package/src/tools/performance.ts

@@ -8,9 +8,17 @@
  */
 
 import type { ToolDefinition } from "../server/ToolRegistry.js";
-import { PerformanceMonitor, type PerformanceMetrics, type PerformanceAlert } from "../performance/PerformanceMonitor.js";
+import {
+  PerformanceMonitor,
+  type PerformanceMetrics,
+  type PerformanceAlert,
+} from "../performance/PerformanceMonitor.js";
 import { MetricsCollector } from "../performance/MetricsCollector.js";
-import { PerformanceAnalytics, type BenchmarkComparison, type PerformanceAnomaly } from "../performance/PerformanceAnalytics.js";
+import {
+  PerformanceAnalytics,
+  type BenchmarkComparison,
+  type PerformanceAnomaly,
+} from "../performance/PerformanceAnalytics.js";
 import { toolWrapper } from "../utils/toolWrapper.js";
 import { ConfigHelpers } from "../config/Config.js";
 import { LoggerFactory } from "../utils/logger.js";
@@ -25,10 +33,13 @@ export default class PerformanceTools {
   private monitor: PerformanceMonitor;
   private collector: MetricsCollector;
   private analytics: PerformanceAnalytics;
-  private logger = LoggerFactory.performance();
+  private logger: ReturnType<typeof LoggerFactory.performance>;
   private historicalDataInterval?: NodeJS.Timeout | undefined;
 
   constructor(clients?: Map<string, unknown>) {
+    // Initialize logger first
+    this.logger = LoggerFactory.performance();
+    
     // Initialize performance monitoring system
     this.monitor = new PerformanceMonitor({
       enableRealTimeMonitoring: true,
@@ -273,15 +284,19 @@ export default class PerformanceTools {
    */
   private async getPerformanceStats(_client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
     return toolWrapper(async () => {
-      const { site, category = "overview", format = "summary" } = params as { site?: string; category?: string; format?: string };
+      const {
+        site,
+        category = "overview",
+        format = "summary",
+      } = params as { site?: string; category?: string; format?: string };
 
       // Get current metrics
-  const metrics = this.collector.collectCurrentMetrics();
+      const metrics = this.collector.collectCurrentMetrics();
 
       // Get site-specific metrics if requested
       let siteMetrics = null;
       if (site) {
-  siteMetrics = this.collector.getSiteMetrics(site as string);
+        siteMetrics = this.collector.getSiteMetrics(site as string);
       }
 
       // Filter by category
@@ -372,20 +387,25 @@ export default class PerformanceTools {
    */
   private async getPerformanceHistory(_client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
     return toolWrapper(async () => {
-      const { site, timeframe = "24h", metrics: requestedMetrics, includeTrends = true } = params as { site?: string; timeframe?: string; metrics?: string[]; includeTrends?: boolean };
+      const {
+        site,
+        timeframe = "24h",
+        metrics: requestedMetrics,
+        includeTrends = true,
+      } = params as { site?: string; timeframe?: string; metrics?: string[]; includeTrends?: boolean };
 
       // Convert timeframe to milliseconds
       const timeframMs = this.parseTimeframe(timeframe);
       const startTime = Date.now() - timeframMs;
 
       // Get historical data
-  const historicalData = this.monitor.getHistoricalData(startTime);
+      const historicalData = this.monitor.getHistoricalData(startTime);
 
       // Analyze trends if requested
       let trends = null;
       if (includeTrends) {
         // Add current data for trend analysis
-  this.analytics.addDataPoint(this.collector.collectCurrentMetrics());
+        this.analytics.addDataPoint(this.collector.collectCurrentMetrics());
         trends = this.analytics.analyzeTrends();
 
         // Filter trends by requested metrics
@@ -395,7 +415,7 @@ export default class PerformanceTools {
       }
 
       // Process historical data for charting
-  const chartData = this.processHistoricalDataForChart(historicalData, requestedMetrics as string[] | undefined);
+      const chartData = this.processHistoricalDataForChart(historicalData, requestedMetrics as string[] | undefined);
 
       return {
         success: true,
@@ -427,10 +447,14 @@ export default class PerformanceTools {
    */
   private async getBenchmarkComparison(_client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
     return toolWrapper(async () => {
-      const { site, category = "all", includeRecommendations = true } = params as { site?: string; category?: string; includeRecommendations?: boolean };
+      const {
+        site,
+        category = "all",
+        includeRecommendations = true,
+      } = params as { site?: string; category?: string; includeRecommendations?: boolean };
 
       // Get benchmark comparisons
-  const benchmarks = this.analytics.benchmarkPerformance() as BenchmarkComparison[];
+      const benchmarks = this.analytics.benchmarkPerformance() as BenchmarkComparison[];
 
       // Filter by category if specified
       let filteredBenchmarks = benchmarks;
@@ -441,7 +465,7 @@ export default class PerformanceTools {
           error_rate: "Error Rate",
           system_resources: "Memory Usage",
         };
-  const targetCategory = categoryMap[category as string];
+        const targetCategory = categoryMap[category as string];
         if (targetCategory) {
           filteredBenchmarks = benchmarks.filter((b) => b.category === targetCategory);
         }
@@ -494,10 +518,16 @@ export default class PerformanceTools {
    */
   private async getPerformanceAlerts(_client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
     return toolWrapper(async () => {
-      const { site, severity, category, limit = 20, includeAnomalies = true } = params as { site?: string; severity?: string; category?: string; limit?: number; includeAnomalies?: boolean };
+      const {
+        site,
+        severity,
+        category,
+        limit = 20,
+        includeAnomalies = true,
+      } = params as { site?: string; severity?: string; category?: string; limit?: number; includeAnomalies?: boolean };
 
       // Get alerts from monitor
-  let alerts = this.monitor.getAlerts(severity) as PerformanceAlert[];
+      let alerts = this.monitor.getAlerts(severity) as PerformanceAlert[];
 
       // Filter by category if specified
       if (category) {
@@ -505,7 +535,7 @@ export default class PerformanceTools {
       }
 
       // Limit results
-  alerts = alerts.slice(-(limit as number));
+      alerts = alerts.slice(-(limit as number));
 
       // Get anomalies if requested
       let anomalies: PerformanceAnomaly[] = [];
@@ -561,15 +591,35 @@ export default class PerformanceTools {
   /**
    * Get optimization recommendations
    */
-  private async getOptimizationRecommendations(_client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
+  private async getOptimizationRecommendations(
+    _client: WordPressClient,
+    params: Record<string, unknown>,
+  ): Promise<unknown> {
     return toolWrapper(async () => {
-      const { site, focus = "speed", priority = "all", includeROI = true, includePredictions = true } = params as { site?: string; focus?: string; priority?: string; includeROI?: boolean; includePredictions?: boolean };
+      const {
+        site,
+        focus = "speed",
+        priority = "all",
+        includeROI = true,
+        includePredictions = true,
+      } = params as {
+        site?: string;
+        focus?: string;
+        priority?: string;
+        includeROI?: boolean;
+        includePredictions?: boolean;
+      };
 
       // Generate optimization plan
       const optimizationPlan = this.analytics.generateOptimizationPlan();
 
       // Filter by priority
-  let recommendations: Array<{ priority: string; impact: string; implementationEffort: string; [key: string]: unknown }> = [];
+      let recommendations: Array<{
+        priority: string;
+        impact: string;
+        implementationEffort: string;
+        [key: string]: unknown;
+      }> = [];
       if (priority === "quick_wins" || priority === "all") {
         recommendations.push(
           ...optimizationPlan.quickWins.map((r) => ({
@@ -596,7 +646,7 @@ export default class PerformanceTools {
       }
 
       // Filter by focus area
-  if (focus !== "speed") {
+      if (focus !== "speed") {
         const focusMap: Record<string, string[]> = {
           reliability: ["reliability"],
           efficiency: ["cost", "performance"],
@@ -607,7 +657,7 @@ export default class PerformanceTools {
       }
 
       // Get predictions if requested
-  let predictions: Record<string, unknown> | null = null;
+      let predictions: Record<string, unknown> | null = null;
       if (includePredictions) {
         predictions = this.analytics.predictPerformance(60); // 1 hour prediction
       }
@@ -645,13 +695,25 @@ export default class PerformanceTools {
    */
   private async exportPerformanceReport(_client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
     return toolWrapper(async () => {
-      const { site, format = "json", includeHistorical = true, includeAnalytics = true, timeRange = "24h" } = params as { site?: string; format?: string; includeHistorical?: boolean; includeAnalytics?: boolean; timeRange?: string };
+      const {
+        site,
+        format = "json",
+        includeHistorical = true,
+        includeAnalytics = true,
+        timeRange = "24h",
+      } = params as {
+        site?: string;
+        format?: string;
+        includeHistorical?: boolean;
+        includeAnalytics?: boolean;
+        timeRange?: string;
+      };
 
       // Generate comprehensive analytics report
       const report = this.analytics.exportAnalyticsReport();
 
       // Add additional data based on parameters
-  const exportData: { currentMetrics: PerformanceMetrics; [key: string]: unknown } = {
+      const exportData: { currentMetrics: PerformanceMetrics; [key: string]: unknown } = {
         metadata: {
           generatedAt: new Date().toISOString(),
           site: site || "all",
@@ -660,7 +722,7 @@ export default class PerformanceTools {
           version: "1.0.0",
         },
         summary: report.summary,
-  currentMetrics: this.collector.collectCurrentMetrics(),
+        currentMetrics: this.collector.collectCurrentMetrics(),
       };
 
       if (includeHistorical) {
@@ -798,7 +860,10 @@ export default class PerformanceTools {
     return map[timeframe] || map["24h"];
   }
 
-  private processHistoricalDataForChart(data: PerformanceMetrics[], requestedMetrics?: string[]): Record<string, unknown> {
+  private processHistoricalDataForChart(
+    data: PerformanceMetrics[],
+    requestedMetrics?: string[],
+  ): Record<string, unknown> {
     if (!data.length) return {};
 
     const allMetrics = ["responseTime", "cacheHitRate", "errorRate", "memoryUsage", "requestVolume"];
@@ -887,7 +952,10 @@ export default class PerformanceTools {
     return `${anomaly.metric} is ${Math.abs(anomaly.deviation).toFixed(1)}% ${direction} than expected (${anomaly.expectedValue.toFixed(2)} vs ${anomaly.actualValue.toFixed(2)})`;
   }
 
-  private calculateAlertStatus(alertSummary: { critical: number; error: number; warning: number }, anomalySummary: { critical: number; major: number; moderate: number; minor: number }): string {
+  private calculateAlertStatus(
+    alertSummary: { critical: number; error: number; warning: number },
+    anomalySummary: { critical: number; major: number; moderate: number; minor: number },
+  ): string {
     const critical = alertSummary.critical + anomalySummary.critical;
     const high = alertSummary.error + anomalySummary.major;
 
@@ -916,9 +984,7 @@ export default class PerformanceTools {
     return map[effort] || effort;
   }
 
-  private calculateEstimatedImpact(
-    recommendations: Array<{ priority: string }>,
-  ): string {
+  private calculateEstimatedImpact(recommendations: Array<{ priority: string }>): string {
     const highImpact = recommendations.filter((r) => ["critical", "high"].includes(r.priority)).length;
     const totalImpact = recommendations.length;
 
@@ -945,7 +1011,10 @@ export default class PerformanceTools {
     return csv.join("\n");
   }
 
-  private createSummaryReport(data: { currentMetrics: PerformanceMetrics; analytics?: { insights?: unknown[] } }): Record<string, unknown> {
+  private createSummaryReport(data: {
+    currentMetrics: PerformanceMetrics;
+    analytics?: { insights?: unknown[] };
+  }): Record<string, unknown> {
     const metrics = data.currentMetrics;
     return {
       summary: `Performance Report - ${new Date().toISOString()}`,
@@ -983,9 +1052,9 @@ export default class PerformanceTools {
         this.logger.debug("Historical metrics collected", {
           timestamp: new Date().toISOString(),
         });
-      } catch (error) {
+      } catch (_error) {
         this.logger.error("Failed to collect historical metrics", {
-          error: error instanceof Error ? error.message : String(error),
+          _error: _error instanceof Error ? _error.message : String(_error),
         });
       }
     }, interval);

package/src/tools/posts/PostHandlers.ts

@@ -6,13 +6,13 @@
  * validation, API interaction, and response formatting.
  */
 
-import { WordPressClient } from "../../client/api.js";
-import { CreatePostRequest, PostQueryParams, UpdatePostRequest, WordPressPost } from "../../types/wordpress.js";
-import { getErrorMessage } from "../../utils/error.js";
-import { ErrorHandlers } from "../../utils/enhancedError.js";
-import { validateId, validatePaginationParams, validatePostParams } from "../../utils/validation.js";
-import { sanitizeHtml } from "../../utils/validation/security.js";
-import { WordPressDataStreamer, StreamingUtils, StreamingResult } from "../../utils/streaming.js";
+import { WordPressClient } from "@/client/api.js";
+import { CreatePostRequest, PostQueryParams, UpdatePostRequest, WordPressPost } from "@/types/wordpress.js";
+import { getErrorMessage } from "@/utils/error.js";
+import { ErrorHandlers } from "@/utils/enhancedError.js";
+import { validateId, validatePaginationParams, validatePostParams } from "@/utils/validation.js";
+import { sanitizeHtml } from "@/utils/validation/security.js";
+import { WordPressDataStreamer, StreamingUtils, StreamingResult } from "@/utils/streaming.js";
 
 /**
  * Handles listing WordPress posts with advanced filtering and pagination
@@ -208,8 +208,8 @@ export async function handleListPosts(
     }
 
     return finalContent;
-  } catch (error) {
-    throw new Error(`Failed to list posts: ${getErrorMessage(error)}`);
+  } catch (_error) {
+    throw new Error(`Failed to list posts: ${getErrorMessage(_error)}`);
   }
 }
 
@@ -295,11 +295,11 @@ export async function handleGetPost(client: WordPressClient, params: { id: numbe
     }
 
     return response;
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("404")) {
+  } 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)}`);
+    throw new Error(`Failed to get post: ${getErrorMessage(_error)}`);
   }
 }
 
@@ -334,8 +334,8 @@ export async function handleCreatePost(
     }
 
     return response;
-  } catch (error) {
-    throw new Error(`Failed to create post: ${getErrorMessage(error)}`);
+  } catch (_error) {
+    throw new Error(`Failed to create post: ${getErrorMessage(_error)}`);
   }
 }
 
@@ -386,11 +386,11 @@ export async function handleUpdatePost(
     response += `\n**Link**: ${updatedPost.link}`;
 
     return response;
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("404")) {
+  } 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 update post: ${getErrorMessage(error)}`);
+    throw new Error(`Failed to update post: ${getErrorMessage(_error)}`);
   }
 }
 
@@ -422,11 +422,11 @@ export async function handleDeletePost(
     } else {
       return `Failed to delete post with ID ${params.id}. It may not exist or you may not have permission.`;
     }
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("404")) {
+  } 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 delete post: ${getErrorMessage(error)}`);
+    throw new Error(`Failed to delete post: ${getErrorMessage(_error)}`);
   }
 }
 
@@ -465,10 +465,10 @@ export async function handleGetPostRevisions(
     });
 
     return response;
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("404")) {
+  } 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 revisions: ${getErrorMessage(error)}`);
+    throw new Error(`Failed to get post revisions: ${getErrorMessage(_error)}`);
   }
 }