mcp-wordpress 2.4.2 → 2.5.1

package/src/config/ServerConfiguration.ts

@@ -7,6 +7,8 @@ import { CachedWordPressClient } from "../client/CachedWordPressClient.js";
 import { MockWordPressClient } from "../client/MockWordPressClient.js";
 import { WordPressClientConfig } from "../types/client.js";
 import { getErrorMessage } from "../utils/error.js";
+import { LoggerFactory } from "../utils/logger.js";
+import { ConfigHelpers } from "./Config.js";
 import {
   ConfigurationValidator,
   type SiteType as SiteConfig,
@@ -15,7 +17,7 @@ import {
 } from "./ConfigurationSchema.js";
 
 // Re-export types from schema for backward compatibility
-export type { SiteConfig, MultiSiteConfig };
+export type { SiteConfig, MultiSiteConfig, McpConfigType };
 
 /**
  * Configuration loader for MCP WordPress Server
@@ -23,6 +25,7 @@ export type { SiteConfig, MultiSiteConfig };
  */
 export class ServerConfiguration {
   private static instance: ServerConfiguration;
+  private readonly logger = LoggerFactory.server();
   private rootDir: string;
   private envPath: string;
 
@@ -32,16 +35,36 @@ export class ServerConfiguration {
     this.rootDir = path.resolve(__dirname, "../..");
     this.envPath = path.resolve(this.rootDir, ".env");
 
-    // Load environment variables
-    dotenv.config({ path: this.envPath });
+    // Load environment variables (completely silent for MCP compatibility)
+    // Suppress dotenv output that could interfere with JSON-RPC communication
+    // eslint-disable-next-line no-console
+    const originalConsoleLog = console.log;
+    // eslint-disable-next-line no-console
+    const originalConsoleError = console.error;
+    try {
+      // eslint-disable-next-line no-console
+      console.log = () => {};
+      // eslint-disable-next-line no-console
+      console.error = () => {};
+      dotenv.config({ 
+        path: this.envPath,
+        debug: false,
+        override: false
+      });
+    } finally {
+      // eslint-disable-next-line no-console
+      console.log = originalConsoleLog;
+      // eslint-disable-next-line no-console
+      console.error = originalConsoleError;
+    }
 
     // Debug output for DXT troubleshooting (reduced in DXT mode)
-    const isDXTMode = process.env.NODE_ENV === "dxt";
-    if (!isDXTMode && process.env.DEBUG === "true") {
-      console.error("DEBUG: ServerConfiguration initialized");
-      console.error(`DEBUG: Root directory: ${this.rootDir}`);
-      console.error(`DEBUG: Environment file path: ${this.envPath}`);
-      console.error(`DEBUG: Environment file exists: ${fs.existsSync(this.envPath)}`);
+    if (ConfigHelpers.shouldDebug()) {
+      this.logger.debug("ServerConfiguration initialized", {
+        rootDir: this.rootDir,
+        envPath: this.envPath,
+        envFileExists: fs.existsSync(this.envPath),
+      });
     }
   }
 
@@ -66,15 +89,15 @@ export class ServerConfiguration {
     const configPath = path.resolve(this.rootDir, "mcp-wordpress.config.json");
 
     if (fs.existsSync(configPath)) {
-      if (process.env.NODE_ENV !== "test") {
-        console.error("INFO: Found mcp-wordpress.config.json, loading multi-site configuration.");
+      if (ConfigHelpers.shouldLogInfo()) {
+        this.logger.info("Found multi-site configuration file", { configPath });
       }
       return this.loadMultiSiteConfig(configPath);
     } else {
-      if (process.env.NODE_ENV !== "test") {
-        console.error(
-          "INFO: mcp-wordpress.config.json not found, falling back to environment variables for single-site mode.",
-        );
+      if (ConfigHelpers.shouldLogInfo()) {
+        this.logger.info("Multi-site config not found, using environment variables for single-site mode", {
+          configPath,
+        });
       }
       return this.loadSingleSiteFromEnv(mcpConfig);
     }
@@ -108,21 +131,27 @@ export class ServerConfiguration {
         };
 
         // Use cached client for better performance
-        const client =
-          process.env.DISABLE_CACHE === "true"
-            ? new WordPressClient(clientConfig)
-            : new CachedWordPressClient(clientConfig, site.id);
+        const client = ConfigHelpers.shouldUseCache()
+          ? new CachedWordPressClient(clientConfig, site.id)
+          : new WordPressClient(clientConfig);
         clients.set(site.id, client);
         validConfigs.push(site);
 
-        if (process.env.NODE_ENV !== "test") {
-          console.error(`INFO: Initialized client for site: ${site.name} (ID: ${site.id})`);
+        if (ConfigHelpers.shouldLogInfo()) {
+          this.logger.info("Initialized site client", {
+            siteName: site.name,
+            siteId: site.id,
+            authMethod: site.config.WORDPRESS_AUTH_METHOD,
+          });
         }
       }
 
       return { clients, configs: validConfigs };
     } catch (error) {
-      console.error(`FATAL: Error reading or parsing mcp-wordpress.config.json: ${getErrorMessage(error)}`);
+      this.logger.fatal("Failed to load multi-site configuration", {
+        configPath,
+        error: getErrorMessage(error),
+      });
       process.exit(1);
     }
   }
@@ -131,14 +160,7 @@ export class ServerConfiguration {
    * Check if we're in CI environment
    */
   private isCIEnvironment(): boolean {
-    return (
-      process.env.CI === "true" ||
-      process.env.NODE_ENV === "ci" ||
-      process.env.NODE_ENV === "test" ||
-      process.env.GITHUB_ACTIONS === "true" ||
-      process.env.TRAVIS === "true" ||
-      process.env.CIRCLECI === "true"
-    );
+    return ConfigHelpers.isCI();
   }
 
   /**
@@ -175,7 +197,7 @@ export class ServerConfiguration {
       config: mockConfig,
     };
 
-    console.error("INFO: Using mock configuration for CI environment.");
+    this.logger.info("Using mock configuration for CI environment");
     return { clients, configs: [siteConfig] };
   }
 
@@ -189,14 +211,14 @@ export class ServerConfiguration {
     try {
       // Debug output for DXT troubleshooting (reduced in DXT mode)
       const isDXTMode = process.env.NODE_ENV === "dxt";
-      if (!isDXTMode) {
-        console.error("DEBUG: loadSingleSiteFromEnv called");
-        console.error(`DEBUG: mcpConfig provided: ${mcpConfig ? "YES" : "NO"}`);
-        console.error("DEBUG: Current environment variables:");
-        console.error(`  WORDPRESS_SITE_URL: ${process.env.WORDPRESS_SITE_URL || "NOT SET"}`);
-        console.error(`  WORDPRESS_USERNAME: ${process.env.WORDPRESS_USERNAME || "NOT SET"}`);
-        console.error(`  WORDPRESS_APP_PASSWORD: ${process.env.WORDPRESS_APP_PASSWORD ? "SET" : "NOT SET"}`);
-        console.error(`  WORDPRESS_AUTH_METHOD: ${process.env.WORDPRESS_AUTH_METHOD || "NOT SET"}`);
+      if (!isDXTMode && ConfigHelpers.shouldDebug()) {
+        this.logger.debug("Loading single-site configuration from environment", {
+          mcpConfigProvided: Boolean(mcpConfig),
+          siteUrl: process.env.WORDPRESS_SITE_URL || "NOT SET",
+          username: process.env.WORDPRESS_USERNAME || "NOT SET",
+          appPasswordSet: Boolean(process.env.WORDPRESS_APP_PASSWORD),
+          authMethod: process.env.WORDPRESS_AUTH_METHOD || "NOT SET",
+        });
       }
 
       // Check if we're in CI environment and credentials are missing
@@ -220,12 +242,13 @@ export class ServerConfiguration {
         LOG_LEVEL: process.env.LOG_LEVEL,
       };
 
-      if (!isDXTMode) {
-        console.error("DEBUG: Final envConfig for validation:");
-        console.error(`  WORDPRESS_SITE_URL: ${envConfig.WORDPRESS_SITE_URL || "NOT SET"}`);
-        console.error(`  WORDPRESS_USERNAME: ${envConfig.WORDPRESS_USERNAME || "NOT SET"}`);
-        console.error(`  WORDPRESS_APP_PASSWORD: ${envConfig.WORDPRESS_APP_PASSWORD ? "SET" : "NOT SET"}`);
-        console.error(`  WORDPRESS_AUTH_METHOD: ${envConfig.WORDPRESS_AUTH_METHOD || "NOT SET"}`);
+      if (!isDXTMode && ConfigHelpers.shouldDebug()) {
+        this.logger.debug("Final environment configuration for validation", {
+          siteUrl: envConfig.WORDPRESS_SITE_URL || "NOT SET",
+          username: envConfig.WORDPRESS_USERNAME || "NOT SET",
+          appPasswordSet: Boolean(envConfig.WORDPRESS_APP_PASSWORD),
+          authMethod: envConfig.WORDPRESS_AUTH_METHOD || "NOT SET",
+        });
       }
 
       // Validate environment configuration using Zod schema
@@ -260,14 +283,15 @@ export class ServerConfiguration {
       };
 
       if (!isDXTMode) {
-        console.error("INFO: Initialized client for default site in single-site mode.");
+        this.logger.info("Initialized default site client in single-site mode");
       }
 
       return { clients, configs: [siteConfig] };
     } catch (error) {
-      console.error("ERROR: Configuration validation failed for single-site mode.");
-      console.error(`Details: ${getErrorMessage(error)}`);
-      console.error("Please check your environment variables or MCP configuration.");
+      this.logger.error("Configuration validation failed for single-site mode", {
+        error: getErrorMessage(error),
+        suggestion: "Please check your environment variables or MCP configuration",
+      });
       return { clients: new Map(), configs: [] };
     }
   }

package/src/docs/DocumentationGenerator.ts

@@ -7,6 +7,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as Tools from "../tools/index.js";
 import type { ToolDefinition } from "../server/ToolRegistry.js";
+import { LoggerFactory } from "../utils/logger.js";
 
 export interface DocumentationConfig {
   outputDir: string;
@@ -35,7 +36,7 @@ export interface ParameterDocumentation {
   type: string;
   required: boolean;
   description: string;
-  defaultValue: any;
+  defaultValue: unknown;
   allowedValues: string[] | undefined;
   examples: string[];
 }
@@ -44,11 +45,11 @@ export interface ExampleUsage {
   title: string;
   description: string;
   command: string;
-  parameters: Record<string, any>;
-  expectedResponse: any;
+  parameters: Record<string, unknown>;
+  expectedResponse: unknown;
   errorExample?: {
     scenario: string;
-    error: any;
+    error: unknown;
   };
 }
 
@@ -79,7 +80,7 @@ export interface TypeDocumentation {
   name: string;
   description: string;
   properties: PropertyDocumentation[];
-  examples: any[];
+  examples: unknown[];
   wordpressSource?: string;
 }
 
@@ -93,9 +94,9 @@ export interface PropertyDocumentation {
 
 export interface OpenAPISpecification {
   openapi: string;
-  info: any;
-  paths: Record<string, any>;
-  components: Record<string, any>;
+  info: Record<string, unknown>;
+  paths: Record<string, unknown>;
+  components: Record<string, unknown>;
 }
 
 export interface DocumentationSummary {
@@ -118,6 +119,7 @@ export class DocumentationGenerator {
   private config: DocumentationConfig;
   private toolCategories: Map<string, string[]> = new Map();
   private wordpressEndpoints: Map<string, string> = new Map();
+  private logger = LoggerFactory.api();
 
   constructor(config: Partial<DocumentationConfig> = {}) {
     this.config = {
@@ -138,7 +140,7 @@ export class DocumentationGenerator {
    * Generate complete documentation for all tools and types
    */
   async generateFullDocumentation(): Promise<DocumentationOutput> {
-    console.error("🚀 Starting API documentation generation...");
+    this.logger.info("🚀 Starting API documentation generation...");
 
     const tools = await this.extractAllToolDocumentation();
     const categories = this.generateCategoryDocumentation(tools);
@@ -162,7 +164,7 @@ export class DocumentationGenerator {
     // Write documentation to files
     await this.writeDocumentationFiles(output);
 
-    console.error(`✅ Documentation generation complete! ${tools.length} tools documented.`);
+    this.logger.info(`✅ Documentation generation complete! ${tools.length} tools documented.`);
     return output;
   }
 
@@ -176,23 +178,23 @@ export class DocumentationGenerator {
     for (const [className, ToolClass] of Object.entries(Tools)) {
       try {
         // Create tool instance
-        let toolInstance: any;
+        let toolInstance: { getTools(): unknown[] };
         if (className === "CacheTools" || className === "PerformanceTools") {
           // These tools need client map - use empty map for doc generation
           toolInstance = new ToolClass(new Map());
         } else {
-          toolInstance = new (ToolClass as new () => any)();
+          toolInstance = new (ToolClass as new () => { getTools(): unknown[] })();
         }
 
         const toolDefinitions = toolInstance.getTools();
         const category = this.extractCategoryFromClassName(className);
 
         for (const toolDef of toolDefinitions) {
-          const doc = await this.extractToolDocumentation(toolDef, category, className);
+          const doc = await this.extractToolDocumentation(toolDef as ToolDefinition, category, className);
           toolDocs.push(doc);
         }
       } catch (error) {
-        console.warn(`⚠️ Failed to extract documentation for ${className}:`, error);
+        this.logger.warn(`⚠️ Failed to extract documentation for ${className}:`, { error: String(error) });
       }
     }
 
@@ -231,7 +233,15 @@ export class DocumentationGenerator {
   /**
    * Extract parameter documentation
    */
-  private extractParameterDocumentation(parameters: any[]): ParameterDocumentation[] {
+  private extractParameterDocumentation(
+    parameters: Array<{
+      name: string;
+      type?: string;
+      description?: string;
+      required?: boolean;
+      [key: string]: unknown;
+    }>,
+  ): ParameterDocumentation[] {
     return parameters.map((param) => ({
       name: param.name,
       type: param.type || "string",
@@ -277,7 +287,7 @@ export class DocumentationGenerator {
    */
   private generateBasicExample(toolDef: ToolDefinition, category: string): ExampleUsage | null {
     const toolName = toolDef.name;
-    const basicParams: Record<string, any> = {};
+    const basicParams: Record<string, unknown> = {};
 
     // Add essential parameters
     const requiredParams = (toolDef.parameters || []).filter((p) => p.required);
@@ -406,8 +416,8 @@ export class DocumentationGenerator {
    * Generate OpenAPI specification
    */
   private generateOpenAPISpecification(tools: ToolDocumentation[], types: TypeDocumentation[]): OpenAPISpecification {
-    const paths: Record<string, any> = {};
-    const components: Record<string, any> = {
+    const paths: Record<string, unknown> = {};
+    const components: Record<string, unknown> = {
       schemas: {},
       parameters: {},
       responses: {},
@@ -453,8 +463,9 @@ export class DocumentationGenerator {
     }
 
     // Add type schemas to components
+    const schemas = components.schemas as Record<string, unknown>;
     for (const type of types) {
-      components.schemas[type.name] = this.convertTypeToJsonSchema(type);
+      schemas[type.name] = this.convertTypeToJsonSchema(type);
     }
 
     return {
@@ -520,7 +531,7 @@ export class DocumentationGenerator {
     // Write summary
     await fs.promises.writeFile(path.join(outputDir, "summary.json"), JSON.stringify(output.summary, null, 2));
 
-    console.error(`📁 Documentation written to ${outputDir}/`);
+    this.logger.info(`📁 Documentation written to ${outputDir}/`);
   }
 
   // Helper methods for specific documentation tasks...
@@ -582,8 +593,8 @@ export class DocumentationGenerator {
    * Helper methods for documentation generation
    */
 
-  private getDefaultValue(param: any): any {
-    const defaults: Record<string, any> = {
+  private getDefaultValue(param: { [key: string]: unknown }): unknown {
+    const defaults: Record<string, unknown> = {
       per_page: 10,
       page: 1,
       order: "desc",
@@ -594,10 +605,10 @@ export class DocumentationGenerator {
       includeExamples: true,
       includeTrends: true,
     };
-    return defaults[param.name];
+    return defaults[String(param.name)];
   }
 
-  private getAllowedValues(param: any): string[] | undefined {
+  private getAllowedValues(param: { [key: string]: unknown }): string[] | undefined {
     const allowedValues: Record<string, string[]> = {
       status: ["publish", "draft", "private", "pending", "future"],
       order: ["asc", "desc"],
@@ -608,10 +619,10 @@ export class DocumentationGenerator {
       priority: ["quick_wins", "medium_term", "long_term", "all"],
       focus: ["speed", "reliability", "efficiency", "scaling"],
     };
-    return allowedValues[param.name];
+    return allowedValues[String(param.name)];
   }
 
-  private generateParameterExamples(param: any): string[] {
+  private generateParameterExamples(param: { name: string; type?: string; [key: string]: unknown }): string[] {
     const examples: Record<string, string[]> = {
       id: ["123", "456"],
       title: ["My Blog Post", "Hello World"],
@@ -633,8 +644,8 @@ export class DocumentationGenerator {
     return toolDef.parameters?.some((p) => p.name === "site") ?? true;
   }
 
-  private generateExampleValue(param: any): any {
-    const exampleValues: Record<string, any> = {
+  private generateExampleValue(param: { name: string; type?: string; [key: string]: unknown }): unknown {
+    const exampleValues: Record<string, unknown> = {
       id: 123,
       title: "Example Post Title",
       content: "This is example content for the post.",
@@ -656,7 +667,7 @@ export class DocumentationGenerator {
     return exampleValues[param.name] || "example_value";
   }
 
-  private generateExpectedResponse(toolName: string, category: string, type: string): any {
+  private generateExpectedResponse(toolName: string, category: string, type: string): unknown {
     if (toolName.includes("list")) {
       return {
         success: true,
@@ -724,8 +735,8 @@ export class DocumentationGenerator {
     };
   }
 
-  private getExampleParameters(toolDef: ToolDefinition, type: string | number): Record<string, any> {
-    const params: Record<string, any> = {};
+  private getExampleParameters(toolDef: ToolDefinition, type: string | number): Record<string, unknown> {
+    const params: Record<string, unknown> = {};
     const parameters = toolDef.parameters || [];
 
     if (type === "all") {
@@ -795,7 +806,7 @@ export class DocumentationGenerator {
     );
   }
 
-  private generateWordPressPostExample(): any {
+  private generateWordPressPostExample(): Record<string, unknown> {
     return {
       id: 123,
       title: "Welcome to WordPress",
@@ -811,8 +822,8 @@ export class DocumentationGenerator {
     };
   }
 
-  private generateParameterSchema(parameters: ParameterDocumentation[]): any {
-    const properties: Record<string, any> = {};
+  private generateParameterSchema(parameters: ParameterDocumentation[]): Record<string, unknown> {
+    const properties: Record<string, unknown> = {};
     const required: string[] = [];
 
     for (const param of parameters) {
@@ -822,11 +833,11 @@ export class DocumentationGenerator {
       };
 
       if (param.allowedValues) {
-        properties[param.name].enum = param.allowedValues;
+        (properties[param.name] as Record<string, unknown>).enum = param.allowedValues;
       }
 
       if (param.defaultValue !== undefined) {
-        properties[param.name].default = param.defaultValue;
+        (properties[param.name] as Record<string, unknown>).default = param.defaultValue;
       }
 
       if (param.required) {
@@ -841,8 +852,8 @@ export class DocumentationGenerator {
     };
   }
 
-  private convertTypeToJsonSchema(type: TypeDocumentation): any {
-    const properties: Record<string, any> = {};
+  private convertTypeToJsonSchema(type: TypeDocumentation): Record<string, unknown> {
+    const properties: Record<string, unknown> = {};
     const required: string[] = [];
 
     for (const prop of type.properties) {
@@ -852,7 +863,7 @@ export class DocumentationGenerator {
       };
 
       if (prop.format) {
-        properties[prop.name].format = prop.format;
+        (properties[prop.name] as Record<string, unknown>).format = prop.format;
       }
 
       if (prop.required) {

package/src/docs/MarkdownFormatter.ts

@@ -256,25 +256,20 @@ ${type.examples.length > 1 ? this.generateAdditionalExamples(type.examples.slice
   /**
    * Generate parameters table
    */
-  private generateParametersTable(
-    parameters: ParameterDocumentation[],
-  ): string {
+  private generateParametersTable(parameters: ParameterDocumentation[]): string {
     if (parameters.length === 0) {
       return "*No parameters required.*";
     }
 
-    const headers =
-      "| Parameter | Type | Required | Description | Default | Examples |";
-    const separator =
-      "|-----------|------|----------|-------------|---------|----------|";
+    const headers = "| Parameter | Type | Required | Description | Default | Examples |";
+    const separator = "|-----------|------|----------|-------------|---------|----------|";
 
     const rows = parameters.map((param) => {
       const examples = param.examples
         .slice(0, 2)
         .map((ex) => `\`${ex}\``)
         .join(", ");
-      const defaultVal =
-        param.defaultValue !== undefined ? `\`${param.defaultValue}\`` : "-";
+      const defaultVal = param.defaultValue !== undefined ? `\`${param.defaultValue}\`` : "-";
       const required = param.required ? "✅" : "❌";
 
       return `| \`${param.name}\` | \`${param.type}\` | ${required} | ${param.description} | ${defaultVal} | ${examples || "-"} |`;
@@ -316,10 +311,7 @@ ${example.errorExample ? this.generateErrorExample(example.errorExample) : ""}
   /**
    * Generate error example
    */
-  private generateErrorExample(errorExample: {
-    scenario: string;
-    error: any;
-  }): string {
+  private generateErrorExample(errorExample: { scenario: string; error: unknown }): string {
     return `**Error Example (${errorExample.scenario}):**
 \`\`\`json
 ${JSON.stringify(errorExample.error, null, 2)}
@@ -378,7 +370,7 @@ ${permissions.map((perm) => `- \`${perm}\``).join("\n")}
   /**
    * Generate error documentation
    */
-  private generateErrorDocumentation(errorCodes: any[]): string {
+  private generateErrorDocumentation(errorCodes: unknown[]): string {
     if (errorCodes.length === 0) {
       return `### Common Errors
 
@@ -392,11 +384,11 @@ See [Error Handling Guide](../error-handling.md) for complete error reference.`;
 
     return errorCodes
       .map(
-        (error) => `### ${error.code}
+        (error) => `### ${(error as Record<string, unknown>).code}
 
-**Message:** ${error.message}  
-**Description:** ${error.description}  
-**Resolution:** ${error.resolution}
+**Message:** ${(error as Record<string, unknown>).message}  
+**Description:** ${(error as Record<string, unknown>).description}  
+**Resolution:** ${(error as Record<string, unknown>).resolution}
 `,
       )
       .join("\n\n");
@@ -420,8 +412,7 @@ ${relatedTools.map((tool) => `- [\`${tool}\`](./${tool}.md)`).join("\n")}
     const separator = "|----------|-------|-------------|";
 
     const rows = categories.map(
-      (cat) =>
-        `| [${cat.name}](./categories/${cat.name.toLowerCase()}.md) | ${cat.toolCount} | ${cat.description} |`,
+      (cat) => `| [${cat.name}](./categories/${cat.name.toLowerCase()}.md) | ${cat.toolCount} | ${cat.description} |`,
     );
 
     return [headers, separator, ...rows].join("\n");
@@ -435,8 +426,7 @@ ${relatedTools.map((tool) => `- [\`${tool}\`](./${tool}.md)`).join("\n")}
     const separator = "|------|----------|-------------|";
 
     const rows = tools.map(
-      (tool) =>
-        `| [\`${tool.name}\`](./tools/${tool.name}.md) | ${tool.category} | ${tool.description} |`,
+      (tool) => `| [\`${tool.name}\`](./tools/${tool.name}.md) | ${tool.category} | ${tool.description} |`,
     );
 
     return [headers, separator, ...rows].join("\n");
@@ -445,13 +435,14 @@ ${relatedTools.map((tool) => `- [\`${tool}\`](./${tool}.md)`).join("\n")}
   /**
    * Generate type properties table
    */
-  private generateTypePropertiesTable(properties: any[]): string {
+  private generateTypePropertiesTable(properties: unknown[]): string {
     const headers = "| Property | Type | Required | Description |";
     const separator = "|----------|------|----------|-------------|";
 
     const rows = properties.map((prop) => {
-      const required = prop.required ? "✅" : "❌";
-      return `| \`${prop.name}\` | \`${prop.type}\` | ${required} | ${prop.description} |`;
+      const propObj = prop as Record<string, unknown>;
+      const required = propObj.required ? "✅" : "❌";
+      return `| \`${propObj.name}\` | \`${propObj.type}\` | ${required} | ${propObj.description} |`;
     });
 
     return [headers, separator, ...rows].join("\n");
@@ -486,15 +477,14 @@ ${relatedTools.map((tool) => `- [\`${tool}\`](./${tool}.md)`).join("\n")}
       performance: "brightgreen",
     };
 
-    const color =
-      colors[category.toLowerCase() as keyof typeof colors] || "lightgrey";
+    const color = colors[category.toLowerCase() as keyof typeof colors] || "lightgrey";
     return `![${category}](https://img.shields.io/badge/category-${category}-${color})`;
   }
 
   /**
    * Format parameters for command examples
    */
-  private formatParameters(params: Record<string, any>): string {
+  private formatParameters(params: Record<string, unknown>): string {
     return Object.entries(params)
       .map(([key, value]) => `--${key}="${value}"`)
       .join(" ");
@@ -503,7 +493,7 @@ ${relatedTools.map((tool) => `- [\`${tool}\`](./${tool}.md)`).join("\n")}
   /**
    * Generate additional examples
    */
-  private generateAdditionalExamples(examples: any[]): string {
+  private generateAdditionalExamples(examples: unknown[]): string {
     return `## Additional Examples
 
 ${examples