sfcc-dev-mcp 1.0.19 → 1.0.21

package/src/utils/path-resolver.ts

@@ -1,69 +0,0 @@
-/**
- * Path Resolver Helper
- *
- * Provides utilities for resolving file and directory paths based on the current working directory.
- * This abstraction allows for easier path management and testing.
- */
-
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-export class PathResolver {
-  /**
-   * Get the current working directory (project root)
-   */
-  static getCurrentWorkingDir(): string {
-    // Get the directory of the current module file
-    // ts-jest may compile with a CommonJS module target in tests; suppress the
-    // diagnostic because runtime uses ESM (NodeNext) where import.meta is valid.
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-
-    // Return the project root (handles both src/ and dist/ locations)
-    return path.resolve(__dirname, '..', '..');
-  }
-
-  /**
-   * Root path for bundled AI instructions (AGENTS.md + skills)
-   */
-  static getAiInstructionsPath(): string {
-    return this.getRelativePath('ai-instructions');
-  }
-
-  /**
-   * Path to the bundled AGENTS.md
-   */
-  static getAgentsInstructionsFile(): string {
-    return path.join(this.getAiInstructionsPath(), 'AGENTS.md');
-  }
-
-  /**
-   * Path to the bundled skills directory
-   */
-  static getSkillsSourcePath(): string {
-    return path.join(this.getAiInstructionsPath(), 'skills');
-  }
-
-  /**
-   * Get a path relative to the current working directory
-   */
-  static getRelativePath(...pathSegments: string[]): string {
-    const currentDir = this.getCurrentWorkingDir();
-
-    return path.join(currentDir, ...pathSegments);
-  }
-
-  /**
-   * Get the docs directory path relative to the current working directory
-   */
-  static getDocsPath(): string {
-    return this.getRelativePath('docs');
-  }
-
-  /**
-   * Get the SFRA docs directory path relative to the current working directory
-   */
-  static getSFRADocsPath(): string {
-    return this.getRelativePath('docs', 'sfra');
-  }
-}

package/src/utils/path-validation.ts

@@ -1,113 +0,0 @@
-/**
- * Path Validation Utilities
- *
- * Provides secure path validation for file operations.
- * Prevents path traversal attacks and validates file names.
- */
-
-import * as path from 'path';
-
-export interface PathValidationOptions {
-  /** Allowed file extensions (e.g., ['.md', '.json']) */
-  allowedExtensions?: string[];
-  /** Whether to normalize the name to lowercase */
-  normalizeToLowerCase?: boolean;
-}
-
-export class PathValidationError extends Error {
-  constructor(message: string, public readonly code: string = 'PATH_VALIDATION_ERROR') {
-    super(message);
-    this.name = 'PathValidationError';
-  }
-}
-
-/**
- * Validate a file/document name for security issues
- * @param name - The name to validate
- * @param fieldName - Human-readable field name for error messages
- * @throws PathValidationError if validation fails
- */
-export function validateFileName(name: string, fieldName: string = 'name'): void {
-  if (!name || typeof name !== 'string') {
-    throw new PathValidationError(`Invalid ${fieldName}: must be a non-empty string`, 'INVALID_TYPE');
-  }
-
-  // Prevent null bytes
-  if (name.includes('\0') || name.includes('\x00')) {
-    throw new PathValidationError(`Invalid ${fieldName}: contains null bytes`, 'NULL_BYTES');
-  }
-
-  // Prevent path traversal sequences
-  if (name.includes('..') || name.includes('/') || name.includes('\\')) {
-    throw new PathValidationError(`Invalid ${fieldName}: contains path traversal sequences`, 'PATH_TRAVERSAL');
-  }
-
-  // Only allow safe characters
-  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
-    throw new PathValidationError(`Invalid ${fieldName}: contains invalid characters`, 'INVALID_CHARACTERS');
-  }
-}
-
-/**
- * Construct and validate a file path within a base directory
- * @param basePath - The base directory path
- * @param fileName - The file name (without extension)
- * @param options - Validation options
- * @returns The validated, resolved file path
- * @throws PathValidationError if validation fails
- */
-export function constructValidatedPath(
-  basePath: string,
-  fileName: string,
-  options: PathValidationOptions = {},
-): string {
-  const { allowedExtensions = ['.md'], normalizeToLowerCase = true } = options;
-
-  // Validate the file name first
-  validateFileName(fileName, 'file name');
-
-  // Normalize if requested
-  const normalizedName = normalizeToLowerCase ? fileName.toLowerCase() : fileName;
-
-  // Determine extension (use first allowed extension by default)
-  const extension = allowedExtensions[0] ?? '.md';
-
-  // Construct the path
-  const filePath = path.join(basePath, `${normalizedName}${extension}`);
-  const resolvedPath = path.resolve(filePath);
-  const resolvedBasePath = path.resolve(basePath);
-
-  // Ensure the path is within the base directory
-  if (!resolvedPath.startsWith(resolvedBasePath)) {
-    throw new PathValidationError('Invalid file name: path outside allowed directory', 'OUTSIDE_BASE_DIR');
-  }
-
-  // Ensure the file has the correct extension
-  const hasValidExtension = allowedExtensions.some(ext =>
-    resolvedPath.toLowerCase().endsWith(ext.toLowerCase()),
-  );
-  if (!hasValidExtension) {
-    throw new PathValidationError(
-      `Invalid file name: must reference a ${allowedExtensions.join(' or ')} file`,
-      'INVALID_EXTENSION',
-    );
-  }
-
-  return resolvedPath;
-}
-
-/**
- * Validate binary content
- * @param content - The content to validate
- * @param fieldName - Human-readable field name for error messages
- * @throws PathValidationError if content appears to be binary
- */
-export function validateTextContent(content: string, fieldName: string = 'content'): void {
-  if (!content.trim()) {
-    throw new PathValidationError(`Empty ${fieldName}`, 'EMPTY_CONTENT');
-  }
-
-  if (content.includes('\0')) {
-    throw new PathValidationError(`Invalid ${fieldName}: contains binary data`, 'BINARY_CONTENT');
-  }
-}

package/src/utils/query-builder.ts

@@ -1,84 +0,0 @@
-/**
- * Query Builder Utility
- *
- * This module provides utilities for building query strings and handling URL parameters
- * for SFCC API requests with proper encoding and array handling.
- */
-
-/**
- * Query parameter builder for SFCC APIs
- */
-export class QueryBuilder {
-  private params: URLSearchParams;
-
-  constructor() {
-    this.params = new URLSearchParams();
-  }
-
-  /**
-   * Add a parameter to the query string
-   */
-  add(key: string, value: string | number | boolean): QueryBuilder {
-    if (value !== undefined && value !== null) {
-      this.params.append(key, value.toString());
-    }
-    return this;
-  }
-
-  /**
-   * Add an array parameter with proper handling for different parameter types
-   */
-  addArray(key: string, values: (string | number)[]): QueryBuilder {
-    if (!Array.isArray(values) || values.length === 0) {
-      return this;
-    }
-
-    if (key === 'refine') {
-      // Special handling for OCAPI refine parameters (multiple entries)
-      values.forEach(value => this.params.append(key, value.toString()));
-    } else {
-      // Join arrays with comma for most parameters
-      this.params.append(key, values.join(','));
-    }
-
-    return this;
-  }
-
-  /**
-   * Add multiple parameters from an object
-   */
-  addFromObject(params: Record<string, any>): QueryBuilder {
-    Object.entries(params).forEach(([key, value]) => {
-      if (value !== undefined && value !== null) {
-        if (Array.isArray(value)) {
-          this.addArray(key, value);
-        } else {
-          this.add(key, value);
-        }
-      }
-    });
-    return this;
-  }
-
-  /**
-   * Build the final query string
-   */
-  build(): string {
-    return this.params.toString();
-  }
-
-  /**
-   * Reset the builder
-   */
-  reset(): QueryBuilder {
-    this.params = new URLSearchParams();
-    return this;
-  }
-
-  /**
-   * Static method to build query string from object
-   */
-  static fromObject(params: Record<string, any>): string {
-    return new QueryBuilder().addFromObject(params).build();
-  }
-}

package/src/utils/utils.ts

@@ -1,139 +0,0 @@
-/**
- * Utility functions for SFCC MCP Server
- *
- * This module contains helper functions for date formatting, file size conversion,
- * and other common operations used throughout the application.
- */
-
-/**
- * Get current date in YYYYMMDD format
- * Used for filtering log files by date
- *
- * @returns Current date string in YYYYMMDD format
- */
-export function getCurrentDate(): string {
-  const now = new Date();
-  const year = now.getFullYear();
-  const month = String(now.getMonth() + 1).padStart(2, '0');
-  const day = String(now.getDate()).padStart(2, '0');
-  return `${year}${month}${day}`;
-}
-
-/**
- * Convert bytes to human-readable format
- *
- * @param bytes - Number of bytes to format
- * @returns Formatted string with appropriate unit (Bytes, KB, MB, GB)
- */
-export function formatBytes(bytes: number): string {
-  if (bytes === 0) {return '0 Bytes';}
-  const k = 1024;
-  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))  } ${  sizes[i]}`;
-}
-
-/**
- * Parse log content into individual entries based on log level
- * Handles multi-line log entries properly by grouping lines that belong together
- *
- * @param content - Raw log file content
- * @param level - Log level to filter for (ERROR, WARN, INFO)
- * @returns Array of complete log entries
- */
-export function parseLogEntries(content: string, level: string): string[] {
-  const lines = content.split('\n');
-  const entries: string[] = [];
-  let currentEntry = '';
-
-  for (const line of lines) {
-    // Check if this line starts a new log entry for the specified level
-    if (line.includes(`] ${level} `) && line.includes('GMT]')) {
-      // Save the previous entry if it exists
-      if (currentEntry) {
-        entries.push(currentEntry.trim());
-      }
-      // Start a new entry
-      currentEntry = line;
-    } else if (currentEntry && line.trim()) {
-      // Add continuation lines to the current entry
-      currentEntry += `\n${  line}`;
-    }
-  }
-
-  // Don't forget the last entry
-  if (currentEntry) {
-    entries.push(currentEntry.trim());
-  }
-
-  return entries;
-}
-
-/**
- * Extract timestamp from a log entry
- * @param logEntry - Complete log entry string
- * @returns Date object or null if timestamp cannot be parsed
- */
-export function extractTimestampFromLogEntry(logEntry: string): Date | null {
-  // Match pattern: [2025-08-19T10:30:00.000 GMT] or [2025-09-19 20:47:32.324 GMT]
-  const timestampMatch = logEntry.match(/^\[(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}\.\d{3}) GMT\]/);
-
-  if (!timestampMatch) {
-    return null;
-  }
-
-  try {
-    // Normalize the timestamp format for parsing
-    let timestampStr = timestampMatch[1];
-
-    // Convert space format to ISO format if needed
-    if (timestampStr.includes(' ')) {
-      timestampStr = timestampStr.replace(' ', 'T');
-    }
-
-    // Parse the ISO timestamp (adding 'Z' for UTC)
-    const date = new Date(`${timestampStr}Z`);
-
-    // Check if the date is valid
-    if (isNaN(date.getTime())) {
-      return null;
-    }
-
-    return date;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Extract unique error patterns from error log entries
- * Removes timestamps and common formatting to identify core error messages
- *
- * @param errors - Array of error log entries
- * @returns Array of unique error patterns (limited to top 10)
- */
-export function extractUniqueErrors(errors: string[]): string[] {
-  const patterns = new Set<string>();
-
-  for (const error of errors) {
-    // Extract main error message after the class name
-    // Pattern: [timestamp] ERROR ClassName - ErrorMessage
-    const match = error.match(/] ERROR [^-]+ - (.+?)(?:\n|$)/);
-    if (match) {
-      patterns.add(match[1].trim());
-    }
-  }
-
-  return Array.from(patterns).slice(0, 10); // Limit to top 10 unique errors
-}
-
-/**
- * Normalize file path by removing leading slash if present
- * SFCC WebDAV sometimes returns paths with leading slashes that need to be handled
- *
- * @param filePath - File path that may have a leading slash
- * @returns Normalized file path without leading slash
- */
-export function normalizeFilePath(filePath: string): string {
-  return filePath.startsWith('/') ? filePath.substring(1) : filePath;
-}

package/src/utils/validator.ts

@@ -1,162 +0,0 @@
-/**
- * Validation Utilities
- *
- * This module provides validation functions for SFCC API parameters and inputs.
- * It includes common validation patterns used across different API clients.
- */
-
-/**
- * Custom validation error class
- */
-export class ValidationError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'ValidationError';
-  }
-}
-
-/**
- * Valid instance types for SFCC site preferences
- */
-const VALID_INSTANCE_TYPES = ['staging', 'development', 'sandbox', 'production'] as const;
-export type InstanceType = typeof VALID_INSTANCE_TYPES[number];
-
-/**
- * Validation utility class
- */
-export class Validator {
-  /**
-   * Validate that required fields are present and not empty
-   */
-  static validateRequired(params: Record<string, any>, requiredFields: string[]): void {
-    const missingFields: string[] = [];
-
-    for (const field of requiredFields) {
-      const value = params[field];
-      if (value === undefined || value === null || (typeof value === 'string' && value.trim().length === 0)) {
-        missingFields.push(field);
-      }
-    }
-
-    if (missingFields.length > 0) {
-      throw new ValidationError(`Required fields are missing or empty: ${missingFields.join(', ')}`);
-    }
-  }
-
-  /**
-   * Validate instance type for site preferences
-   */
-  static validateInstanceType(instanceType: string): InstanceType {
-    if (!VALID_INSTANCE_TYPES.includes(instanceType as InstanceType)) {
-      throw new ValidationError(
-        `Invalid instance type '${instanceType}'. Must be one of: ${VALID_INSTANCE_TYPES.join(', ')}`,
-      );
-    }
-    return instanceType as InstanceType;
-  }
-
-  /**
-   * Validate that a string is not empty
-   */
-  static validateNotEmpty(value: string, fieldName: string): void {
-    if (!value || value.trim().length === 0) {
-      throw new ValidationError(`${fieldName} cannot be empty`);
-    }
-  }
-
-  /**
-   * Validate that a value is a positive number
-   */
-  static validatePositiveNumber(value: number, fieldName: string): void {
-    if (value < 0) {
-      throw new ValidationError(`${fieldName} must be a positive number`);
-    }
-  }
-
-  /**
-   * Validate object type for system objects
-   */
-  static validateObjectType(objectType: string): void {
-    Validator.validateNotEmpty(objectType, 'objectType');
-
-    // Basic validation - could be extended with specific object type patterns
-    if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(objectType)) {
-      throw new ValidationError(
-        `Invalid object type '${objectType}'. Must start with a letter and contain only letters, numbers, and underscores.`,
-      );
-    }
-  }
-
-  /**
-   * Validate search request structure
-   */
-  static validateSearchRequest(searchRequest: any): void {
-    if (!searchRequest || typeof searchRequest !== 'object') {
-      throw new ValidationError('Search request must be a valid object');
-    }
-
-    // Validate query structure if present
-    if (searchRequest.query) {
-      const query = searchRequest.query;
-
-      // Check that at least one query type is specified
-      const queryTypes = ['text_query', 'term_query', 'filtered_query', 'bool_query', 'match_all_query'];
-      const hasValidQuery = queryTypes.some(type => query[type]);
-
-      if (!hasValidQuery) {
-        throw new ValidationError(
-          `Search query must contain at least one of: ${queryTypes.join(', ')}`,
-        );
-      }
-
-      // Validate text_query structure
-      if (query.text_query) {
-        const textQuery = query.text_query;
-        if (!textQuery.fields || !Array.isArray(textQuery.fields) || textQuery.fields.length === 0) {
-          throw new ValidationError('text_query.fields must be a non-empty array');
-        }
-        if (!textQuery.search_phrase || typeof textQuery.search_phrase !== 'string') {
-          throw new ValidationError('text_query.search_phrase must be a non-empty string');
-        }
-      }
-
-      // Validate term_query structure
-      if (query.term_query) {
-        const termQuery = query.term_query;
-        if (!termQuery.fields || !Array.isArray(termQuery.fields) || termQuery.fields.length === 0) {
-          throw new ValidationError('term_query.fields must be a non-empty array');
-        }
-        if (!termQuery.operator || typeof termQuery.operator !== 'string') {
-          throw new ValidationError('term_query.operator must be a non-empty string');
-        }
-        if (!termQuery.values || !Array.isArray(termQuery.values) || termQuery.values.length === 0) {
-          throw new ValidationError('term_query.values must be a non-empty array');
-        }
-      }
-    }
-
-    // Validate sorts structure if present
-    if (searchRequest.sorts) {
-      if (!Array.isArray(searchRequest.sorts)) {
-        throw new ValidationError('sorts must be an array');
-      }
-
-      searchRequest.sorts.forEach((sort: any, index: number) => {
-        if (!sort.field || typeof sort.field !== 'string') {
-          throw new ValidationError(`sorts[${index}].field must be a non-empty string`);
-        }
-        if (sort.sort_order && !['asc', 'desc'].includes(sort.sort_order)) {
-          throw new ValidationError(`sorts[${index}].sort_order must be either 'asc' or 'desc'`);
-        }
-      });
-    }
-
-    // Validate pagination parameters
-    if (searchRequest.start !== undefined) {
-      Validator.validatePositiveNumber(searchRequest.start, 'start');
-    }
-    if (searchRequest.count !== undefined) {
-      Validator.validatePositiveNumber(searchRequest.count, 'count');
-    }
-  }
-}

package/tests/__mocks__/docs-client.ts

@@ -1,8 +0,0 @@
-// Mock for SFCCDocumentationClient
-export const SFCCDocumentationClient = jest.fn().mockImplementation(() => ({
-  getClassDetailsExpanded: jest.fn(),
-  getAvailableClasses: jest.fn(),
-  searchClasses: jest.fn(),
-  searchMethods: jest.fn(),
-  getClassDocumentation: jest.fn(),
-}));

package/tests/__mocks__/src/clients/base/http-client.js

@@ -1,43 +0,0 @@
-/**
- * Mock for BaseHttpClient
- */
-
-export class BaseHttpClient {
-  constructor(baseUrl) {
-    this.baseUrl = baseUrl;
-    this.logger = {
-      debug: jest.fn(),
-      info: jest.fn(),
-      warn: jest.fn(),
-      error: jest.fn(),
-    };
-  }
-
-  async makeRequest() {
-    return { data: 'mocked' };
-  }
-
-  async get() {
-    return { data: 'mocked' };
-  }
-
-  async post() {
-    return { data: 'mocked' };
-  }
-
-  async put() {
-    return { data: 'mocked' };
-  }
-
-  async patch() {
-    return { data: 'mocked' };
-  }
-
-  async delete() {
-    return { data: 'mocked' };
-  }
-
-  async handleAuthError() {
-    // Mock implementation
-  }
-}

package/tests/__mocks__/webdav.js

@@ -1,14 +0,0 @@
-// Mock implementation of webdav module
-const mockWebdavClient = {
-  getDirectoryContents: jest.fn(),
-  getFileContents: jest.fn(),
-  stat: jest.fn(),
-  createReadStream: jest.fn(),
-};
-
-const createClient = jest.fn(() => mockWebdavClient);
-
-module.exports = {
-  createClient,
-  __mockWebdavClient: mockWebdavClient,
-};