sfcc-dev-mcp 1.0.15 → 1.0.19

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

@@ -0,0 +1,87 @@
+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 { ISMLClient } from '../clients/isml-client.js';
+
+export const ISML_TOOL_NAMES = [
+  'list_isml_elements',
+  'get_isml_element',
+  'search_isml_elements',
+  'get_isml_elements_by_category',
+  'get_isml_categories',
+] as const;
+
+export type ISMLToolName = typeof ISML_TOOL_NAMES[number];
+export const ISML_TOOL_NAMES_SET = new Set<ISMLToolName>(ISML_TOOL_NAMES);
+
+/**
+ * Configuration for ISML documentation tools
+ * Maps each tool to its validation, execution, and messaging logic
+ */
+export const ISML_TOOL_CONFIG: Record<ISMLToolName, GenericToolSpec<ToolArguments, any>> = {
+  list_isml_elements: {
+    exec: async (_args: ToolArguments, context: ToolExecutionContext) => {
+      const client = context.ismlClient as ISMLClient;
+      return client.getAvailableElements();
+    },
+    logMessage: (_args: ToolArguments) => 'List ISML elements',
+  },
+
+  get_isml_element: {
+    defaults: (args: ToolArguments) => ({
+      ...args,
+      includeContent: args.includeContent ?? true,
+      includeSections: args.includeSections ?? true,
+      includeAttributes: args.includeAttributes ?? true,
+    }),
+    validate: (args: ToolArguments, toolName: string) => {
+      ValidationHelpers.validateArguments(args, CommonValidations.requiredString('elementName'), toolName);
+    },
+    exec: async (args: ToolArguments, context: ToolExecutionContext) => {
+      const client = context.ismlClient as ISMLClient;
+      const result = await client.getISMLElement(args.elementName as string, {
+        includeContent: args.includeContent as boolean,
+        includeSections: args.includeSections as boolean,
+        includeAttributes: args.includeAttributes as boolean,
+      });
+      if (!result) {
+        throw new Error(`ISML element "${args.elementName}" not found`);
+      }
+      return result;
+    },
+    logMessage: (args: ToolArguments) => `ISML element ${args.elementName}`,
+  },
+
+  search_isml_elements: {
+    validate: (args: ToolArguments, toolName: string) => {
+      ValidationHelpers.validateArguments(args, CommonValidations.requiredString('query'), toolName);
+    },
+    exec: async (args: ToolArguments, context: ToolExecutionContext) => {
+      const client = context.ismlClient as ISMLClient;
+      return client.searchISMLElements(args.query as string, {
+        category: args.category as string | undefined,
+        limit: args.limit as number | undefined,
+      });
+    },
+    logMessage: (args: ToolArguments) => `Search ISML ${args.query}`,
+  },
+
+  get_isml_elements_by_category: {
+    validate: (args: ToolArguments, toolName: string) => {
+      ValidationHelpers.validateArguments(args, CommonValidations.requiredString('category'), toolName);
+    },
+    exec: async (args: ToolArguments, context: ToolExecutionContext) => {
+      const client = context.ismlClient as ISMLClient;
+      return client.getElementsByCategory(args.category as string);
+    },
+    logMessage: (args: ToolArguments) => `ISML elements by category ${args.category}`,
+  },
+
+  get_isml_categories: {
+    exec: async (_args: ToolArguments, context: ToolExecutionContext) => {
+      const client = context.ismlClient as ISMLClient;
+      return client.getAvailableCategories();
+    },
+    logMessage: (_args: ToolArguments) => 'ISML categories',
+  },
+};

package/src/tool-configs/job-log-tool-config.ts

@@ -1,9 +1,12 @@
-import { GenericToolSpec, ToolExecutionContext } from '../core/handlers/base-handler.js';
-import { ToolArguments } from '../core/handlers/base-handler.js';
-import { LogToolValidators } from '../utils/log-tool-utils.js';
-import { ValidationHelpers, CommonValidations } from '../core/handlers/validation-helpers.js';
+import { GenericToolSpec, ToolExecutionContext, ToolArguments } from '../core/handlers/base-handler.js';
+import {
+  ValidationHelpers,
+  CommonValidations,
+  validateLogLevel,
+  validateLimit,
+  formatLogMessage,
+} from '../core/handlers/validation-helpers.js';
 import { JobLogToolName, getLimit } from '../utils/log-tool-constants.js';
-import { JobLogValidators, JobLogFormatters } from '../utils/job-log-utils.js';
 import { SFCCLogClient } from '../clients/log-client.js';
 
 /**
@@ -16,12 +19,12 @@ export const JOB_LOG_TOOL_CONFIG: Record<JobLogToolName, GenericToolSpec<ToolArg
       limit: getLimit(args.limit as number, 'jobFiles'),
     }),
     validate: (args: ToolArguments, toolName: string) =>
-      LogToolValidators.validateLimit(args.limit as number, toolName),
+      validateLimit(args.limit as number, toolName),
     exec: async (args: ToolArguments, context: ToolExecutionContext) => {
       const client = context.logClient as SFCCLogClient;
       return client.getLatestJobLogFiles(args.limit as number);
     },
-    logMessage: (args: ToolArguments) => JobLogFormatters.formatJobLogMessage('Fetching latest job log files', {
+    logMessage: (args: ToolArguments) => formatLogMessage('Fetching latest job log files', {
       limit: args.limit as number,
     }),
   },
@@ -32,13 +35,13 @@ export const JOB_LOG_TOOL_CONFIG: Record<JobLogToolName, GenericToolSpec<ToolArg
     }),
     validate: (args: ToolArguments, toolName: string) => {
       ValidationHelpers.validateArguments(args, CommonValidations.requiredString('jobName'), toolName);
-      LogToolValidators.validateLimit(args.limit as number, toolName);
+      validateLimit(args.limit as number, toolName);
     },
     exec: async (args: ToolArguments, context: ToolExecutionContext) => {
       const client = context.logClient as SFCCLogClient;
       return client.searchJobLogsByName(args.jobName as string, args.limit as number);
     },
-    logMessage: (args: ToolArguments) => JobLogFormatters.formatJobLogMessage('Searching job logs by name', {
+    logMessage: (args: ToolArguments) => formatLogMessage('Searching job logs by name', {
       jobName: args.jobName as string,
       limit: args.limit as number,
     }),
@@ -50,8 +53,8 @@ export const JOB_LOG_TOOL_CONFIG: Record<JobLogToolName, GenericToolSpec<ToolArg
       limit: getLimit(args.limit as number, 'jobEntries'),
     }),
     validate: (args: ToolArguments, toolName: string) => {
-      JobLogValidators.validateJobLogLevel(args.level as string, toolName);
-      LogToolValidators.validateLimit(args.limit as number, toolName);
+      validateLogLevel(args.level as string, toolName);
+      validateLimit(args.limit as number, toolName);
     },
     exec: async (args: ToolArguments, context: ToolExecutionContext) => {
       const client = context.logClient as SFCCLogClient;
@@ -61,7 +64,7 @@ export const JOB_LOG_TOOL_CONFIG: Record<JobLogToolName, GenericToolSpec<ToolArg
         args.jobName as string,
       );
     },
-    logMessage: (args: ToolArguments) => JobLogFormatters.formatJobLogMessage('Fetching job log entries', {
+    logMessage: (args: ToolArguments) => formatLogMessage('Fetching job log entries', {
       level: args.level as string,
       limit: args.limit as number,
       jobName: args.jobName as string,
@@ -75,9 +78,8 @@ export const JOB_LOG_TOOL_CONFIG: Record<JobLogToolName, GenericToolSpec<ToolArg
     }),
     validate: (args: ToolArguments, toolName: string) => {
       ValidationHelpers.validateArguments(args, CommonValidations.requiredString('pattern'), toolName);
-      JobLogValidators.validateJobLogLevel(args.level as string, toolName);
-      LogToolValidators.validateLimit(args.limit as number, toolName);
-      // Validate optional jobName parameter - must be string if provided
+      validateLogLevel(args.level as string, toolName);
+      validateLimit(args.limit as number, toolName);
       if (args.jobName !== undefined) {
         ValidationHelpers.validateArguments(args, CommonValidations.optionalField(
           'jobName',
@@ -96,7 +98,7 @@ export const JOB_LOG_TOOL_CONFIG: Record<JobLogToolName, GenericToolSpec<ToolArg
         args.jobName as string,
       );
     },
-    logMessage: (args: ToolArguments) => JobLogFormatters.formatJobLogMessage('Searching job logs', {
+    logMessage: (args: ToolArguments) => formatLogMessage('Searching job logs', {
       pattern: args.pattern as string,
       level: args.level as string,
       limit: args.limit as number,
@@ -105,7 +107,6 @@ export const JOB_LOG_TOOL_CONFIG: Record<JobLogToolName, GenericToolSpec<ToolArg
   },
 
   get_job_execution_summary: {
-    defaults: (args: ToolArguments) => args,
     validate: (args: ToolArguments, toolName: string) => {
       ValidationHelpers.validateArguments(args, CommonValidations.requiredString('jobName'), toolName);
     },

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

@@ -1,69 +1,55 @@
-import { GenericToolSpec, ToolExecutionContext } from '../core/handlers/base-handler.js';
-import { ToolArguments } from '../core/handlers/base-handler.js';
-import { LogToolValidators, LogMessageFormatter } from '../utils/log-tool-utils.js';
-import { ValidationHelpers, CommonValidations } from '../core/handlers/validation-helpers.js';
+import { GenericToolSpec, ToolExecutionContext, ToolArguments } from '../core/handlers/base-handler.js';
+import {
+  ValidationHelpers,
+  CommonValidations,
+  validateLimit,
+  validateLogLevel,
+  validateFilename,
+  validateMaxBytes,
+  formatLogMessage,
+} from '../core/handlers/validation-helpers.js';
 import { LogToolName, getLimit } from '../utils/log-tool-constants.js';
 import { SFCCLogClient } from '../clients/log-client.js';
+import { LogLevel } from '../clients/logs/log-types.js';
 
 /**
- * Configuration for standard log tools
- * Maps each tool to its validation, execution, and messaging logic
+ * Factory function to create get_latest_* tool specifications
+ * Eliminates repetition across error/warn/info/debug tools
  */
-export const LOG_TOOL_CONFIG: Record<LogToolName, GenericToolSpec<ToolArguments, any>> = {
-  get_latest_error: {
-    defaults: (args: ToolArguments) => ({
-      limit: getLimit(args.limit as number, 'latest'),
-    }),
-    validate: (args: ToolArguments) => LogToolValidators.validateLimit(args.limit as number, 'get_latest_error'),
-    exec: async (args: ToolArguments, context: ToolExecutionContext) => {
-      const client = context.logClient as SFCCLogClient;
-      return client.getLatestLogs('error', args.limit as number, args.date as string);
-    },
-    logMessage: (args: ToolArguments) => LogMessageFormatter.formatLatestLogs('error', args.limit as number, args.date as string),
-  },
-
-  get_latest_warn: {
-    defaults: (args: ToolArguments) => ({
-      limit: getLimit(args.limit as number, 'latest'),
-    }),
-    validate: (args: ToolArguments) => LogToolValidators.validateLimit(args.limit as number, 'get_latest_warn'),
-    exec: async (args: ToolArguments, context: ToolExecutionContext) => {
-      const client = context.logClient as SFCCLogClient;
-      return client.getLatestLogs('warn', args.limit as number, args.date as string);
-    },
-    logMessage: (args: ToolArguments) => LogMessageFormatter.formatLatestLogs('warn', args.limit as number, args.date as string),
-  },
-
-  get_latest_info: {
+function createLatestLogTool(
+  level: LogLevel,
+  toolName: LogToolName,
+): GenericToolSpec<ToolArguments, any> {
+  return {
     defaults: (args: ToolArguments) => ({
       limit: getLimit(args.limit as number, 'latest'),
     }),
-    validate: (args: ToolArguments) => LogToolValidators.validateLimit(args.limit as number, 'get_latest_info'),
+    validate: (args: ToolArguments) => validateLimit(args.limit as number, toolName),
     exec: async (args: ToolArguments, context: ToolExecutionContext) => {
       const client = context.logClient as SFCCLogClient;
-      return client.getLatestLogs('info', args.limit as number, args.date as string);
+      return client.getLatestLogs(level, args.limit as number, args.date as string);
     },
-    logMessage: (args: ToolArguments) => LogMessageFormatter.formatLatestLogs('info', args.limit as number, args.date as string),
-  },
+    logMessage: (args: ToolArguments) =>
+      formatLogMessage(`Fetching latest ${level} logs`, { limit: args.limit as number, date: args.date as string ?? 'today' }),
+  };
+}
 
-  get_latest_debug: {
-    defaults: (args: ToolArguments) => ({
-      limit: getLimit(args.limit as number, 'latest'),
-    }),
-    validate: (args: ToolArguments) => LogToolValidators.validateLimit(args.limit as number, 'get_latest_debug'),
-    exec: async (args: ToolArguments, context: ToolExecutionContext) => {
-      const client = context.logClient as SFCCLogClient;
-      return client.getLatestLogs('debug', args.limit as number, args.date as string);
-    },
-    logMessage: (args: ToolArguments) => LogMessageFormatter.formatLatestLogs('debug', args.limit as number, args.date as string),
-  },
+/**
+ * Configuration for standard log tools
+ * Maps each tool to its validation, execution, and messaging logic
+ */
+export const LOG_TOOL_CONFIG: Record<LogToolName, GenericToolSpec<ToolArguments, any>> = {
+  get_latest_error: createLatestLogTool('error', 'get_latest_error'),
+  get_latest_warn: createLatestLogTool('warn', 'get_latest_warn'),
+  get_latest_info: createLatestLogTool('info', 'get_latest_info'),
+  get_latest_debug: createLatestLogTool('debug', 'get_latest_debug'),
 
   summarize_logs: {
     exec: async (args: ToolArguments, context: ToolExecutionContext) => {
       const client = context.logClient as SFCCLogClient;
       return client.summarizeLogs(args.date as string);
     },
-    logMessage: (args: ToolArguments) => LogMessageFormatter.formatSummarizeLogs(args.date as string),
+    logMessage: (args: ToolArguments) => formatLogMessage('Summarizing logs for date', { date: args.date as string ?? 'today' }),
   },
 
   search_logs: {
@@ -72,9 +58,9 @@ export const LOG_TOOL_CONFIG: Record<LogToolName, GenericToolSpec<ToolArguments,
     }),
     validate: (args: ToolArguments, toolName: string) => {
       ValidationHelpers.validateArguments(args, CommonValidations.requiredString('pattern'), toolName);
-      LogToolValidators.validateLimit(args.limit as number, toolName);
+      validateLimit(args.limit as number, toolName);
       if (args.logLevel) {
-        LogToolValidators.validateLogLevel(args.logLevel as string, toolName);
+        validateLogLevel(args.logLevel as string, toolName);
       }
     },
     exec: async (args: ToolArguments, context: ToolExecutionContext) => {
@@ -86,12 +72,11 @@ export const LOG_TOOL_CONFIG: Record<LogToolName, GenericToolSpec<ToolArguments,
         args.date as string,
       );
     },
-    logMessage: (args: ToolArguments) => LogMessageFormatter.formatSearchLogs(
-      args.pattern as string,
-      args.logLevel as string,
-      args.limit as number,
-      args.date as string,
-    ),
+    logMessage: (args: ToolArguments) => formatLogMessage('Searching logs', {
+      pattern: args.pattern as string,
+      level: args.logLevel as string ?? 'all',
+      limit: args.limit as number ?? 20,
+    }),
   },
 
   list_log_files: {
@@ -99,14 +84,14 @@ export const LOG_TOOL_CONFIG: Record<LogToolName, GenericToolSpec<ToolArguments,
       const client = context.logClient as SFCCLogClient;
       return client.listLogFiles();
     },
-    logMessage: () => LogMessageFormatter.formatListLogFiles(),
+    logMessage: () => 'Listing log files',
   },
 
   get_log_file_contents: {
     validate: (args: ToolArguments, toolName: string) => {
       ValidationHelpers.validateArguments(args, CommonValidations.requiredString('filename'), toolName);
-      LogToolValidators.validateFilename(args.filename as string, toolName);
-      LogToolValidators.validateMaxBytes(args.maxBytes as number, toolName);
+      validateFilename(args.filename as string, toolName);
+      validateMaxBytes(args.maxBytes as number, toolName);
     },
     exec: async (args: ToolArguments, context: ToolExecutionContext) => {
       const client = context.logClient as SFCCLogClient;
@@ -116,10 +101,10 @@ export const LOG_TOOL_CONFIG: Record<LogToolName, GenericToolSpec<ToolArguments,
         args.tailOnly as boolean,
       );
     },
-    logMessage: (args: ToolArguments) => LogMessageFormatter.formatGetLogFileContents(
-      args.filename as string,
-      args.maxBytes as number,
-      args.tailOnly as boolean,
-    ),
+    logMessage: (args: ToolArguments) => formatLogMessage('Reading log file contents:', {
+      filename: args.filename as string,
+      maxBytes: args.maxBytes as number,
+      tailOnly: args.tailOnly as boolean,
+    }),
   },
 };

package/src/tool-configs/script-debugger-tool-config.ts

@@ -0,0 +1,69 @@
+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 { ScriptDebuggerClient } from '../clients/script-debugger/index.js';
+
+export const SCRIPT_DEBUGGER_TOOL_NAMES = ['evaluate_script'] as const;
+
+export type ScriptDebuggerToolName = (typeof SCRIPT_DEBUGGER_TOOL_NAMES)[number];
+export const SCRIPT_DEBUGGER_TOOL_NAMES_SET = new Set<ScriptDebuggerToolName>(SCRIPT_DEBUGGER_TOOL_NAMES);
+
+/**
+ * Configuration for script debugger tools
+ * Maps each tool to its validation, execution, and messaging logic
+ */
+export const SCRIPT_DEBUGGER_TOOL_CONFIG: Record<
+  ScriptDebuggerToolName,
+  GenericToolSpec<ToolArguments, any>
+> = {
+  evaluate_script: {
+    validate: (args: ToolArguments, toolName: string) => {
+      ValidationHelpers.validateArguments(
+        args,
+        CommonValidations.requiredString('script'),
+        toolName,
+      );
+
+      // Optional locale
+      ValidationHelpers.validateArguments(
+        args,
+        CommonValidations.optionalField(
+          'locale',
+          'string',
+          (value: string) => value.trim().length > 0,
+          'locale must be a non-empty string when provided',
+        ),
+        toolName,
+      );
+
+      // Optional breakpointLine (defaults to 1 when breakpointFile is provided)
+      ValidationHelpers.validateArguments(
+        args,
+        CommonValidations.optionalField(
+          'breakpointLine',
+          'number',
+          (value: number) => Number.isInteger(value) && value >= 1,
+          'breakpointLine must be an integer >= 1 when provided',
+        ),
+        toolName,
+      );
+    },
+    exec: async (args: ToolArguments, context: ToolExecutionContext) => {
+      const client = context.scriptDebuggerClient as ScriptDebuggerClient;
+      const result = await client.evaluateScript(args.script as string, {
+        timeout: args.timeout as number | undefined,
+        siteId: args.siteId as string | undefined,
+        locale: args.locale as string | undefined,
+        breakpointFile: args.breakpointFile as string | undefined,
+        breakpointLine: args.breakpointLine as number | undefined,
+      });
+
+      return result;
+    },
+    logMessage: (args: ToolArguments) => {
+      const script = (args?.script as string) ?? '';
+      const preview = script.length > 50 ? `${script.substring(0, 50)  }...` : script;
+      return `Evaluate script: ${preview}`;
+    },
+  },
+};

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

@@ -20,10 +20,6 @@ export const SFRA_TOOL_NAMES_SET = new Set<SFRAToolName>(SFRA_TOOL_NAMES);
  */
 export const SFRA_TOOL_CONFIG: Record<SFRAToolName, GenericToolSpec<ToolArguments, any>> = {
   get_available_sfra_documents: {
-    defaults: (args: ToolArguments) => args,
-    validate: (_args: ToolArguments, _toolName: string) => {
-      // No validation needed for list operation
-    },
     exec: async (_args: ToolArguments, context: ToolExecutionContext) => {
       const client = context.sfraClient as SFRAClient;
       return client.getAvailableDocuments();
@@ -32,7 +28,6 @@ export const SFRA_TOOL_CONFIG: Record<SFRAToolName, GenericToolSpec<ToolArgument
   },
 
   get_sfra_document: {
-    defaults: (args: ToolArguments) => args,
     validate: (args: ToolArguments, toolName: string) => {
       ValidationHelpers.validateArguments(args, CommonValidations.requiredString('documentName'), toolName);
     },
@@ -48,7 +43,6 @@ export const SFRA_TOOL_CONFIG: Record<SFRAToolName, GenericToolSpec<ToolArgument
   },
 
   search_sfra_documentation: {
-    defaults: (args: ToolArguments) => args,
     validate: (args: ToolArguments, toolName: string) => {
       ValidationHelpers.validateArguments(args, CommonValidations.requiredString('query'), toolName);
     },
@@ -60,7 +54,6 @@ export const SFRA_TOOL_CONFIG: Record<SFRAToolName, GenericToolSpec<ToolArgument
   },
 
   get_sfra_documents_by_category: {
-    defaults: (args: ToolArguments) => args,
     validate: (args: ToolArguments, toolName: string) => {
       ValidationHelpers.validateArguments(args, CommonValidations.requiredString('category'), toolName);
     },
@@ -72,10 +65,6 @@ export const SFRA_TOOL_CONFIG: Record<SFRAToolName, GenericToolSpec<ToolArgument
   },
 
   get_sfra_categories: {
-    defaults: (args: ToolArguments) => args,
-    validate: (_args: ToolArguments, _toolName: string) => {
-      // No validation needed for list operation
-    },
     exec: async (_args: ToolArguments, context: ToolExecutionContext) => {
       const client = context.sfraClient as SFRAClient;
       return client.getAvailableCategories();

package/src/tool-configs/system-object-tool-config.ts

@@ -21,10 +21,6 @@ export const SYSTEM_OBJECT_TOOL_NAMES_SET = new Set<SystemObjectToolName>(SYSTEM
  */
 export const SYSTEM_OBJECT_TOOL_CONFIG: Record<SystemObjectToolName, GenericToolSpec<ToolArguments, any>> = {
   get_system_object_definitions: {
-    defaults: (args: ToolArguments) => args,
-    validate: (_args: ToolArguments, _toolName: string) => {
-      // No validation needed for list operation
-    },
     exec: async (args: ToolArguments, context: ToolExecutionContext) => {
       const client = context.ocapiClient as OCAPIClient;
       // Pass pagination parameters to the client
@@ -45,7 +41,6 @@ export const SYSTEM_OBJECT_TOOL_CONFIG: Record<SystemObjectToolName, GenericTool
   },
 
   get_system_object_definition: {
-    defaults: (args: ToolArguments) => args,
     validate: (args: ToolArguments, toolName: string) => {
       ValidationHelpers.validateArguments(args, CommonValidations.requiredString('objectType'), toolName);
     },

package/src/types/types.ts

@@ -22,6 +22,8 @@ export interface SFCCConfig {
   clientSecret?: string;
   /** Site ID for SFCC instance */
   siteId?: string;
+  /** Code version for cartridge deployment */
+  codeVersion?: string;
 }
 
 /**

package/src/utils/cache.ts

@@ -191,106 +191,101 @@ export class InMemoryCache<T> {
 
 /**
  * Multi-layer cache manager for different types of data
+ * Simplified using a generic cache registry pattern
  */
 export class CacheManager {
-  private fileContentCache: InMemoryCache<string>;
-  private classDetailsCache: InMemoryCache<any>;
-  private searchResultsCache: InMemoryCache<any>;
-  private methodSearchCache: InMemoryCache<any>;
+  private caches: Map<string, InMemoryCache<any>>;
 
-  constructor() {
-    // Much longer TTL for static documentation data that doesn't change during server runtime
-    this.fileContentCache = new InMemoryCache<string>({
-      maxSize: 500,
-      ttlMs: 4 * 60 * 60 * 1000, // 4 hours - raw file content is completely static
-      cleanupIntervalMs: 30 * 60 * 1000, // 30 minutes cleanup interval
-    });
+  // Cache configuration for different data types
+  private static readonly CACHE_CONFIGS = {
+    fileContent: { maxSize: 500, ttlMs: 4 * 60 * 60 * 1000, cleanupIntervalMs: 30 * 60 * 1000 },
+    classDetails: { maxSize: 300, ttlMs: 2 * 60 * 60 * 1000, cleanupIntervalMs: 20 * 60 * 1000 },
+    searchResults: { maxSize: 200, ttlMs: 60 * 60 * 1000, cleanupIntervalMs: 15 * 60 * 1000 },
+    methodSearch: { maxSize: 100, ttlMs: 60 * 60 * 1000, cleanupIntervalMs: 15 * 60 * 1000 },
+  } as const;
 
-    this.classDetailsCache = new InMemoryCache({
-      maxSize: 300,
-      ttlMs: 2 * 60 * 60 * 1000, // 2 hours - parsed data is static
-      cleanupIntervalMs: 20 * 60 * 1000, // 20 minutes cleanup interval
-    });
+  constructor() {
+    this.caches = new Map();
+    // Initialize all caches
+    for (const [name, config] of Object.entries(CacheManager.CACHE_CONFIGS)) {
+      this.caches.set(name, new InMemoryCache(config));
+    }
+  }
 
-    this.searchResultsCache = new InMemoryCache({
-      maxSize: 200,
-      ttlMs: 60 * 60 * 1000, // 1 hour - search results are static
-      cleanupIntervalMs: 15 * 60 * 1000, // 15 minutes cleanup interval
-    });
+  /**
+   * Generic cache get operation
+   */
+  private getFromCache<T>(cacheName: string, key: string): T | undefined {
+    return this.caches.get(cacheName)?.get(key);
+  }
 
-    this.methodSearchCache = new InMemoryCache({
-      maxSize: 100,
-      ttlMs: 60 * 60 * 1000, // 1 hour - method search results are static
-      cleanupIntervalMs: 15 * 60 * 1000, // 15 minutes cleanup interval
-    });
+  /**
+   * Generic cache set operation
+   */
+  private setInCache<T>(cacheName: string, key: string, value: T): void {
+    this.caches.get(cacheName)?.set(key, value);
   }
 
+  // Typed accessors for backward compatibility
   getFileContent(key: string): string | undefined {
-    return this.fileContentCache.get(key);
+    return this.getFromCache<string>('fileContent', key);
   }
 
   setFileContent(key: string, content: string): void {
-    this.fileContentCache.set(key, content);
+    this.setInCache('fileContent', key, content);
   }
 
   getClassDetails(key: string): any {
-    return this.classDetailsCache.get(key);
+    return this.getFromCache('classDetails', key);
   }
 
   setClassDetails(key: string, details: any): void {
-    this.classDetailsCache.set(key, details);
+    this.setInCache('classDetails', key, details);
   }
 
   getSearchResults(key: string): any {
-    return this.searchResultsCache.get(key);
+    return this.getFromCache('searchResults', key);
   }
 
   setSearchResults(key: string, results: any): void {
-    this.searchResultsCache.set(key, results);
+    this.setInCache('searchResults', key, results);
   }
 
   getMethodSearch(key: string): any {
-    return this.methodSearchCache.get(key);
+    return this.getFromCache('methodSearch', key);
   }
 
   setMethodSearch(key: string, results: any): void {
-    this.methodSearchCache.set(key, results);
+    this.setInCache('methodSearch', key, results);
   }
 
   /**
    * Get comprehensive cache statistics
    */
-  getAllStats(): {
-    fileContent: ReturnType<InMemoryCache<any>['getStats']>;
-    classDetails: ReturnType<InMemoryCache<any>['getStats']>;
-    searchResults: ReturnType<InMemoryCache<any>['getStats']>;
-    methodSearch: ReturnType<InMemoryCache<any>['getStats']>;
-    } {
-    return {
-      fileContent: this.fileContentCache.getStats(),
-      classDetails: this.classDetailsCache.getStats(),
-      searchResults: this.searchResultsCache.getStats(),
-      methodSearch: this.methodSearchCache.getStats(),
-    };
+  getAllStats(): Record<string, ReturnType<InMemoryCache<any>['getStats']>> {
+    const stats: Record<string, ReturnType<InMemoryCache<any>['getStats']>> = {};
+    for (const [name, cache] of this.caches) {
+      stats[name] = cache.getStats();
+    }
+    return stats;
   }
 
   /**
    * Clear all caches
    */
   clearAll(): void {
-    this.fileContentCache.clear();
-    this.classDetailsCache.clear();
-    this.searchResultsCache.clear();
-    this.methodSearchCache.clear();
+    for (const cache of this.caches.values()) {
+      cache.clear();
+    }
   }
 
   /**
    * Cleanup all resources
    */
   destroy(): void {
-    this.fileContentCache.destroy();
-    this.classDetailsCache.destroy();
-    this.searchResultsCache.destroy();
-    this.methodSearchCache.destroy();
+    for (const cache of this.caches.values()) {
+      cache.destroy();
+    }
+    this.caches.clear();
   }
 }