sfcc-dev-mcp 1.0.15 → 1.0.19

package/src/core/tool-schemas/sfra-tools.ts

@@ -0,0 +1,65 @@
+/**
+ * SFRA Documentation Tool Schemas
+ */
+
+export const SFRA_DOCUMENTATION_TOOLS = [
+  {
+    name: 'get_available_sfra_documents',
+    description: 'List all SFRA documentation including Server, Request, Response, QueryString, render module, and 26+ model docs (cart, account, billing, shipping, products, pricing).',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+    },
+  },
+  {
+    name: 'get_sfra_document',
+    description: 'Get complete SFRA class or model documentation with properties, methods, and examples. Use for implementing controllers, middleware, or working with SFRA models.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        documentName: {
+          type: 'string',
+          description: 'Document name, e.g., "server", "request", "cart", "product-full", "account". Use get_available_sfra_documents for full list.',
+        },
+      },
+      required: ['documentName'],
+    },
+  },
+  {
+    name: 'search_sfra_documentation',
+    description: 'Search across all SFRA docs for concepts or functionality. Returns relevance-scored results with categorization.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description: 'Search term, e.g., "middleware", "routing", "cache", "cart", "pricing".',
+        },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'get_sfra_documents_by_category',
+    description: 'Get SFRA documents filtered by functional area (core classes, product models, order/cart, customer, pricing, store).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        category: {
+          type: 'string',
+          enum: ['core', 'product', 'order', 'customer', 'pricing', 'store', 'other'],
+          description: 'Category to filter by: core (Server, Request, Response, etc.), product (product models), order (cart, billing, shipping), customer (account, address), pricing (price models), store (store models), other (utilities)',
+        },
+      },
+      required: ['category'],
+    },
+  },
+  {
+    name: 'get_sfra_categories',
+    description: 'Get all SFRA document categories with counts. Use to understand documentation organization before browsing.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+    },
+  },
+];

package/src/core/tool-schemas/shared-schemas.ts

@@ -0,0 +1,158 @@
+/**
+ * Shared MCP Tool Schema Components
+ *
+ * Reusable schema definitions for MCP tool definitions.
+ * DRY: These are used across multiple tool categories.
+ */
+
+/**
+ * Common query schema for OCAPI search operations
+ */
+export const QUERY_SCHEMA = {
+  type: 'object',
+  description: 'Query to filter results',
+  properties: {
+    text_query: {
+      type: 'object',
+      description: 'Search for text in specific fields',
+      properties: {
+        fields: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Fields to search in (e.g., ["id", "display_name", "description"])',
+        },
+        search_phrase: {
+          type: 'string',
+          description: 'Text to search for',
+        },
+      },
+      required: ['fields', 'search_phrase'],
+    },
+    term_query: {
+      type: 'object',
+      description: 'Search for exact term matches',
+      properties: {
+        fields: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Fields to search in',
+        },
+        operator: {
+          type: 'string',
+          description: 'Query operator (e.g., "is", "one_of")',
+        },
+        values: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Values to match',
+        },
+      },
+      required: ['fields', 'operator', 'values'],
+    },
+    bool_query: {
+      type: 'object',
+      description: 'Combine multiple queries with boolean logic',
+      properties: {
+        must: {
+          type: 'array',
+          items: { type: 'object' },
+          description: 'Queries that must match (AND)',
+        },
+        must_not: {
+          type: 'array',
+          items: { type: 'object' },
+          description: 'Queries that must not match',
+        },
+        should: {
+          type: 'array',
+          items: { type: 'object' },
+          description: 'Queries that should match (OR)',
+        },
+      },
+    },
+    match_all_query: {
+      type: 'object',
+      description: 'Match all documents - useful when you want all results or to filter with sorts/pagination only.',
+      properties: {},
+    },
+  },
+} as const;
+
+/**
+ * Common sorts schema for OCAPI search operations
+ */
+export const SORTS_SCHEMA = {
+  type: 'array',
+  description: 'Sort criteria',
+  items: {
+    type: 'object',
+    properties: {
+      field: {
+        type: 'string',
+        description: 'Field to sort by',
+      },
+      sort_order: {
+        type: 'string',
+        enum: ['asc', 'desc'],
+        description: 'Sort order (default: asc)',
+      },
+    },
+    required: ['field'],
+  },
+} as const;
+
+/**
+ * Common pagination schema for OCAPI search operations
+ */
+export const PAGINATION_SCHEMA = {
+  start: {
+    type: 'number',
+    description: 'Start index for pagination (default: 0)',
+    default: 0,
+  },
+  count: {
+    type: 'number',
+    description: 'Number of results to return (default: 200)',
+    default: 200,
+  },
+  select: {
+    type: 'string',
+    description: "Property selector (e.g., '(**)' for all properties)",
+  },
+} as const;
+
+/**
+ * Factory to create search request schema with optional description override
+ */
+export function createSearchRequestSchema(queryDescription?: string) {
+  return {
+    type: 'object',
+    description: 'The search request with query, sorting, and pagination options',
+    properties: {
+      query: queryDescription
+        ? { ...QUERY_SCHEMA, description: queryDescription }
+        : QUERY_SCHEMA,
+      sorts: SORTS_SCHEMA,
+      ...PAGINATION_SCHEMA,
+    },
+  };
+}
+
+/**
+ * Common date parameter schema
+ */
+export const DATE_PARAM_SCHEMA = {
+  type: 'string',
+  description: 'Date in YYYYMMDD format (default: today)',
+} as const;
+
+/**
+ * Common limit parameter schema
+ */
+export function createLimitSchema(defaultValue: number, description?: string) {
+  return {
+    type: 'number',
+    description: description ?? `Number of entries to return (default: ${defaultValue})`,
+    default: defaultValue,
+  };
+}

package/src/core/tool-schemas/system-object-tools.ts

@@ -0,0 +1,127 @@
+/**
+ * System Object Tool Schemas
+ */
+
+import { createSearchRequestSchema } from './shared-schemas.js';
+
+export const SYSTEM_OBJECT_TOOLS = [
+  {
+    name: 'get_system_object_definitions',
+    description: 'Get all system object definitions with metadata (not attributes). Use to discover available objects and identify Custom Objects via the _type field.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        start: {
+          type: 'number',
+          description: 'Start index for pagination (default: 0)',
+          default: 0,
+        },
+        count: {
+          type: 'number',
+          description: 'Number of items to return (default: 200)',
+          default: 200,
+        },
+        select: {
+          type: 'string',
+          description: 'OCAPI field selector. Examples: "(**)" for all, "(data.(object_type, display_name))" for specific fields.',
+          default: '(**)',
+        },
+      },
+    },
+  },
+  {
+    name: 'get_system_object_definition',
+    description: 'Get metadata for a specific system object (attribute count, group count, flags). For attribute details, use search_system_object_attribute_definitions. Does not work for Custom Objects.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        objectType: {
+          type: 'string',
+          description: 'System object type, e.g., "Product", "Customer", "Order", "Category".',
+        },
+      },
+      required: ['objectType'],
+    },
+  },
+  {
+    name: 'search_system_object_attribute_definitions',
+    description: 'Search attribute definitions within a system object. Supports text search, filtering by mandatory/searchable/system, and sorting. Use match_all_query to get all attributes.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        objectType: {
+          type: 'string',
+          description: 'System object type, e.g., "Product", "Customer", "Order".',
+        },
+        searchRequest: createSearchRequestSchema('Query to filter attribute definitions'),
+      },
+      required: ['objectType', 'searchRequest'],
+    },
+  },
+  {
+    name: 'search_site_preferences',
+    description: 'Search site preferences by name, description, or type. Use to validate preference names and types when working with Site.getCurrent().getCustomPreferenceValue() or dw.system.Site.current.preferences.custom.*.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        groupId: {
+          type: 'string',
+          description: 'The ID of the preference group to search within',
+        },
+        instanceType: {
+          type: 'string',
+          enum: ['staging', 'development', 'sandbox', 'production'],
+          description: 'The instance type to search preferences for. Since this MCP server is aimed at development and testing, the default is "sandbox".',
+          default: 'sandbox',
+        },
+        searchRequest: createSearchRequestSchema('Query to filter site preferences'),
+        options: {
+          type: 'object',
+          description: 'Additional options for the search',
+          properties: {
+            maskPasswords: {
+              type: 'boolean',
+              description: 'Whether to mask password type preference values (default: true)',
+              default: true,
+            },
+            expand: {
+              type: 'string',
+              description: 'Expand options (use "value" to retrieve value definitions)',
+            },
+          },
+        },
+      },
+      required: ['groupId', 'instanceType', 'searchRequest'],
+    },
+  },
+  {
+    name: 'search_system_object_attribute_groups',
+    description: 'Search attribute groups for a system object. Use "SitePreferences" as objectType to find preference groups needed for the site preferences API.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        objectType: {
+          type: 'string',
+          description: 'System object type, e.g., "Product", "Customer", "SitePreferences".',
+        },
+        searchRequest: createSearchRequestSchema('Query to filter attribute groups'),
+      },
+      required: ['objectType', 'searchRequest'],
+    },
+  },
+  {
+    name: 'search_custom_object_attribute_definitions',
+    description: 'Search attribute definitions within a custom object type (user-defined objects, not system objects). Supports text search, filtering, and sorting.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        objectType: {
+          type: 'string',
+          description: 'Custom object type, e.g., "Global_String", "MyCustomObject".',
+        },
+        searchRequest: createSearchRequestSchema('Query to filter attribute definitions'),
+      },
+      required: ['objectType', 'searchRequest'],
+    },
+  },
+];

package/src/main.ts

@@ -2,13 +2,27 @@
 
 /**
  * Main entry point for the SFCC Development MCP Server
+ *
+ * This module handles:
+ * - Command-line argument parsing
+ * - Configuration discovery (dw.json) from multiple sources
+ * - Secure path validation for configuration files
+ * - Server initialization and lifecycle management
+ *
+ * Configuration discovery priority (highest to lowest):
+ * 1. Explicit --dw-json command line argument
+ * 2. Environment variables (SFCC_HOSTNAME, etc.)
+ * 3. MCP workspace roots discovery (after client connection)
+ * 4. Current working directory fallback (disabled by default, unreliable)
+ *
+ * Note: CWD-based discovery is disabled because MCP servers often run
+ * with cwd set to the user's home directory, not the project directory.
+ * The MCP workspace roots mechanism provides the correct project context.
  */
 
 import { SFCCDevServer } from './core/server.js';
 import { ConfigurationFactory } from './config/configuration-factory.js';
 import { Logger } from './utils/logger.js';
-import { existsSync } from 'fs';
-import { resolve } from 'path';
 
 /**
  * Parse command line arguments to extract configuration options
@@ -37,29 +51,24 @@ function parseCommandLineArgs(): { dwJsonPath?: string; debug?: boolean } {
 }
 
 /**
- * Find dw.json file in common locations
+ * Check if environment variables provide SFCC credentials
  */
-function findDwJsonFile(): string | undefined {
-  const commonPaths = [
-    './dw.json',
-    '../dw.json',
-    '../../dw.json',
-    process.env.HOME ? resolve(process.env.HOME, 'dw.json') : null,
-  ].filter(Boolean) as string[];
-
-  for (const path of commonPaths) {
-    if (existsSync(path)) {
-      const logger = Logger.getInstance();
-      logger.debug(`Found dw.json at: ${path}`);
-      return path;
-    }
-  }
-
-  return undefined;
+function hasEnvironmentCredentials(): boolean {
+  const hasBasicAuth = !!(process.env.SFCC_USERNAME && process.env.SFCC_PASSWORD);
+  const hasOAuth = !!(process.env.SFCC_CLIENT_ID && process.env.SFCC_CLIENT_SECRET);
+  return !!(process.env.SFCC_HOSTNAME && (hasBasicAuth || hasOAuth));
 }
 
 /**
  * Main application entry point
+ *
+ * Configuration discovery priority:
+ * 1. CLI --dw-json parameter (explicit, highest priority)
+ * 2. Environment variables (SFCC_HOSTNAME, etc.)
+ * 3. MCP workspace roots (discovered after client connection - most reliable for project context)
+ *
+ * Note: CWD-based auto-discovery is intentionally NOT used because MCP servers
+ * often start with cwd=/Users/xxx (home directory), not the project directory.
  */
 async function main(): Promise<void> {
   try {
@@ -71,17 +80,33 @@ async function main(): Promise<void> {
     const logger = Logger.getInstance();
 
     logger.log('Starting SFCC Development MCP Server...');
+    logger.log(`[main] Current working directory: ${process.cwd()}`);
+    logger.log(`[main] Command line args: ${JSON.stringify(process.argv.slice(2))}`);
     if (debug) {
-      logger.log('Debug mode enabled');
+      logger.log('[main] Debug mode enabled');
+    }
+
+    // Priority 1: Explicit CLI parameter
+    if (options.dwJsonPath) {
+      logger.log(`[main] Using explicit dw.json path from CLI: ${options.dwJsonPath}`);
+    }
+
+    // Priority 2: Environment variables
+    const hasEnvCredentials = hasEnvironmentCredentials();
+    if (hasEnvCredentials) {
+      logger.log('[main] Environment variables provide SFCC credentials');
     }
 
-    // Try to find dw.json if not explicitly provided
-    const dwJsonPath = options.dwJsonPath ?? findDwJsonFile();
+    // Determine initial configuration source
+    // - If CLI path provided: use it
+    // - If env vars set: use them
+    // - Otherwise: start in local mode, MCP workspace discovery will upgrade later
+    const dwJsonPath = options.dwJsonPath; // Only use explicit CLI path, not auto-discovery
 
     // Create configuration using the factory
     const config = ConfigurationFactory.create({
       dwJsonPath,
-      // Add support for environment variables as fallback
+      // Environment variables as fallback (Priority 2)
       hostname: process.env.SFCC_HOSTNAME,
       username: process.env.SFCC_USERNAME,
       password: process.env.SFCC_PASSWORD,
@@ -89,19 +114,27 @@ async function main(): Promise<void> {
       clientSecret: process.env.SFCC_CLIENT_SECRET,
     });
 
+    logger.log(`[main] Config created - hostname: "${config.hostname}"`);
+
     // Log configuration summary (without sensitive data)
     const capabilities = ConfigurationFactory.getCapabilities(config);
+    logger.log(`[main] Capabilities: ${JSON.stringify(capabilities)}`);
 
     if (capabilities.isLocalMode) {
-      logger.log('Running in Local Mode - SFCC class documentation only');
-      logger.log('To access SFCC logs and OCAPI, provide hostname and credentials');
+      logger.log('[main] Starting in Local Mode - documentation only');
+      logger.log('[main] MCP workspace roots discovery will attempt to find dw.json after client connects');
+      logger.log('[main] To skip discovery, use --dw-json or set SFCC_* environment variables');
     } else {
-      logger.log(`Configuration loaded - Hostname: ${config.hostname}`);
-      logger.log(`Available features: Logs=${capabilities.canAccessLogs}, OCAPI=${capabilities.canAccessOCAPI}, WebDAV=${capabilities.canAccessWebDAV}`);
+      const source = options.dwJsonPath ? 'CLI parameter' : 'environment variables';
+      logger.log(`[main] Configuration loaded from ${source}`);
+      logger.log(`[main] Hostname: ${config.hostname}`);
+      logger.log(`[main] Available features: Logs=${capabilities.canAccessLogs}, OCAPI=${capabilities.canAccessOCAPI}, WebDAV=${capabilities.canAccessWebDAV}`);
     }
 
     // Create and start the server
+    logger.log('[main] Creating SFCCDevServer...');
     const server = new SFCCDevServer(config);
+    logger.log('[main] Starting server.run()...');
     await server.run();
   } catch (error) {
     const logger = Logger.getInstance();
@@ -110,8 +143,8 @@ async function main(): Promise<void> {
     if (error instanceof Error) {
       if (error.message.includes('not found')) {
         logger.log('\nConfiguration Help:');
-        logger.log('1. Create a dw.json file with your SFCC credentials');
-        logger.log('2. Use --dw-json /path/to/dw.json');
+        logger.log('1. Open a VS Code workspace with a dw.json file (recommended - auto-discovered)');
+        logger.log('2. Use --dw-json /path/to/dw.json (explicit path)');
         logger.log('3. Set environment variables: SFCC_HOSTNAME, SFCC_USERNAME, SFCC_PASSWORD');
       }
     }

package/src/services/index.ts

@@ -4,14 +4,8 @@
  * Re-exports all service interfaces and implementations for easy importing
  */
 
-export {
-  IFileSystemService,
-  FileSystemService,
-  MockFileSystemService,
-} from './file-system-service.js';
+export type { IFileSystemService } from './file-system-service.js';
+export { FileSystemService, MockFileSystemService } from './file-system-service.js';
 
-export {
-  IPathService,
-  PathService,
-  MockPathService,
-} from './path-service.js';
+export type { IPathService } from './path-service.js';
+export { PathService, MockPathService } from './path-service.js';

package/src/tool-configs/agent-instructions-tool-config.ts

@@ -0,0 +1,83 @@
+import { GenericToolSpec, ToolArguments } from '../core/handlers/base-handler.js';
+import { ValidationHelpers } from '../core/handlers/validation-helpers.js';
+import { AgentInstructionsClient } from '../clients/agent-instructions-client.js';
+import { InstructionAdvisor } from '../core/instruction-advisor.js';
+
+export const AGENT_INSTRUCTION_TOOL_NAMES = [
+  'sync_agent_instructions',
+  'disable_agent_sync',
+] as const;
+
+export type AgentInstructionToolName = typeof AGENT_INSTRUCTION_TOOL_NAMES[number];
+export const AGENT_INSTRUCTION_TOOL_NAMES_SET = new Set<AgentInstructionToolName>(AGENT_INSTRUCTION_TOOL_NAMES);
+
+const DESTINATION_VALUES = ['project', 'user', 'temp'];
+const MERGE_VALUES = ['append', 'replace', 'skip'];
+
+export const AGENT_INSTRUCTION_TOOL_CONFIG: Record<AgentInstructionToolName, GenericToolSpec<ToolArguments, any>> = {
+  sync_agent_instructions: {
+    validate: (args: ToolArguments, toolName: string) => {
+      ValidationHelpers.validateArguments(args, [
+        {
+          field: 'destinationType',
+          required: false,
+          type: 'string',
+          validator: (value: string) => DESTINATION_VALUES.includes(value),
+          errorMessage: 'destinationType must be one of project | user | temp',
+        },
+        {
+          field: 'mergeStrategy',
+          required: false,
+          type: 'string',
+          validator: (value: string) => MERGE_VALUES.includes(value),
+          errorMessage: 'mergeStrategy must be one of append | replace | skip',
+        },
+        { field: 'preferredRoot', required: false, type: 'string' },
+        { field: 'skillsDir', required: false, type: 'string' },
+        { field: 'tempDir', required: false, type: 'string' },
+        { field: 'includeAgents', required: false, type: 'boolean' },
+        { field: 'includeSkills', required: false, type: 'boolean' },
+        { field: 'installMissingOnly', required: false, type: 'boolean' },
+        { field: 'dryRun', required: false, type: 'boolean' },
+      ], toolName);
+    },
+    exec: async (args: ToolArguments, context) => {
+      const client = context.agentInstructionsClient as AgentInstructionsClient;
+      return client.syncInstructions({
+        destinationType: args.destinationType,
+        preferredRoot: args.preferredRoot,
+        skillsDir: args.skillsDir,
+        mergeStrategy: args.mergeStrategy,
+        includeAgents: args.includeAgents,
+        includeSkills: args.includeSkills,
+        installMissingOnly: args.installMissingOnly,
+        dryRun: args.dryRun,
+        tempDir: args.tempDir,
+      });
+    },
+    logMessage: (args: ToolArguments) => `Sync agent instructions (${args.destinationType ?? 'project'})`,
+  },
+  disable_agent_sync: {
+    validate: (args: ToolArguments, toolName: string) => {
+      ValidationHelpers.validateArguments(args, [
+        { field: 'preferredRoot', required: false, type: 'string' },
+      ], toolName);
+    },
+    exec: async (args: ToolArguments, context) => {
+      const client = context.agentInstructionsClient as AgentInstructionsClient;
+      const advisor = context.instructionAdvisor as InstructionAdvisor;
+
+      // Get workspace root from client status
+      const status = await client.getStatus(args.preferredRoot);
+      if (!status.workspaceRoot) {
+        return {
+          success: false,
+          message: 'Cannot disable agent sync: no workspace root found. Provide preferredRoot parameter.',
+        };
+      }
+
+      return advisor.disableAgentSync(status.workspaceRoot);
+    },
+    logMessage: () => 'Disable agent sync suggestions',
+  },
+};

package/src/tool-configs/cartridge-tool-config.ts

@@ -1,7 +1,7 @@
 import { GenericToolSpec, ToolExecutionContext } from '../core/handlers/base-handler.js';
 import { ToolArguments } from '../core/handlers/base-handler.js';
 import { ValidationHelpers, CommonValidations } from '../core/handlers/validation-helpers.js';
-import { CartridgeGenerationClient } from '../clients/cartridge-generation-client.js';
+import { CartridgeGenerationClient } from '../clients/cartridge/index.js';
 
 export const CARTRIDGE_TOOL_NAMES = [
   'generate_cartridge_structure',

package/src/tool-configs/code-version-tool-config.ts

@@ -17,10 +17,6 @@ export const CODE_VERSION_TOOL_NAMES_SET = new Set<CodeVersionToolName>(CODE_VER
  */
 export const CODE_VERSION_TOOL_CONFIG: Record<CodeVersionToolName, GenericToolSpec<ToolArguments, any>> = {
   get_code_versions: {
-    defaults: (args: ToolArguments) => args,
-    validate: (_args: ToolArguments, _toolName: string) => {
-      // No validation needed for list operation
-    },
     exec: async (_args: ToolArguments, context: ToolExecutionContext) => {
       const client = context.codeVersionsClient as OCAPICodeVersionsClient;
       return client.getCodeVersions();
@@ -29,7 +25,6 @@ export const CODE_VERSION_TOOL_CONFIG: Record<CodeVersionToolName, GenericToolSp
   },
 
   activate_code_version: {
-    defaults: (args: ToolArguments) => args,
     validate: (args: ToolArguments, toolName: string) => {
       ValidationHelpers.validateArguments(args, CommonValidations.requiredString('codeVersionId'), toolName);
     },

package/src/tool-configs/docs-tool-config.ts

@@ -57,7 +57,6 @@ export const DOCS_TOOL_CONFIG: Record<DocToolName, GenericToolSpec<ToolArguments
   },
 
   search_sfcc_classes: {
-    defaults: (args: ToolArguments) => args,
     validate: (args: ToolArguments, toolName: string) => {
       ValidationHelpers.validateArguments(args, CommonValidations.requiredString('query'), toolName);
     },
@@ -69,7 +68,6 @@ export const DOCS_TOOL_CONFIG: Record<DocToolName, GenericToolSpec<ToolArguments
   },
 
   search_sfcc_methods: {
-    defaults: (args: ToolArguments) => args,
     validate: (args: ToolArguments, toolName: string) => {
       ValidationHelpers.validateArguments(args, CommonValidations.requiredString('methodName'), toolName);
     },
@@ -81,10 +79,6 @@ export const DOCS_TOOL_CONFIG: Record<DocToolName, GenericToolSpec<ToolArguments
   },
 
   list_sfcc_classes: {
-    defaults: (args: ToolArguments) => args,
-    validate: (_args: ToolArguments, _toolName: string) => {
-      // No validation needed for list operation
-    },
     exec: async (args: ToolArguments, context: ToolExecutionContext) => {
       const client = context.docsClient as SFCCDocumentationClient;
       return client.getAvailableClasses();
@@ -93,7 +87,6 @@ export const DOCS_TOOL_CONFIG: Record<DocToolName, GenericToolSpec<ToolArguments
   },
 
   get_sfcc_class_documentation: {
-    defaults: (args: ToolArguments) => args,
     validate: (args: ToolArguments, toolName: string) => {
       ValidationHelpers.validateArguments(args, CommonValidations.requiredString('className'), toolName);
     },