sfcc-dev-mcp 1.0.19 → 1.0.21

package/src/clients/cartridge/cartridge-templates.ts

@@ -1,246 +0,0 @@
-/**
- * Cartridge File Templates
- *
- * Contains all template generators for SFCC cartridge file generation.
- * Separated from the main client for better maintainability and testability.
- */
-
-export interface CartridgeTemplates {
-  packageJson: (cartridgeName: string) => object;
-  dwJson: () => object;
-  webpackConfig: (cartridgeName: string) => string;
-  dotProject: (cartridgeName: string) => string;
-  projectProperties: (cartridgeName: string) => string;
-  eslintrc: () => object;
-  stylelintrc: () => object;
-  eslintignore: () => string;
-  gitignore: () => string;
-}
-
-/**
- * Creates the complete set of cartridge templates
- */
-export function createCartridgeTemplates(): CartridgeTemplates {
-  return {
-    packageJson: createPackageJsonTemplate,
-    dwJson: createDwJsonTemplate,
-    webpackConfig: createWebpackConfigTemplate,
-    dotProject: createDotProjectTemplate,
-    projectProperties: createProjectPropertiesTemplate,
-    eslintrc: createEslintrcTemplate,
-    stylelintrc: createStylelintrcTemplate,
-    eslintignore: createEslintignoreTemplate,
-    gitignore: createGitignoreTemplate,
-  };
-}
-
-function createPackageJsonTemplate(cartridgeName: string): object {
-  return {
-    name: cartridgeName,
-    version: '0.0.1',
-    description: 'New overlay cartridge',
-    main: 'index.js',
-    scripts: {
-      'lint': 'npm run lint:css && npm run lint:js',
-      'lint:css': 'sgmf-scripts --lint css',
-      'lint:js': 'sgmf-scripts --lint js',
-      'lint:fix': 'eslint cartridges --fix',
-      upload: 'sgmf-scripts --upload -- ',
-      uploadCartridge: `sgmf-scripts --uploadCartridge ${cartridgeName}`,
-      'compile:js': 'sgmf-scripts --compile js',
-      'compile:scss': 'sgmf-scripts --compile css',
-    },
-    devDependencies: {
-      autoprefixer: '^10.4.14',
-      bestzip: '^2.2.1',
-      'css-loader': '^6.0.0',
-      'css-minimizer-webpack-plugin': '^5.0.1',
-      eslint: '^8.56.0',
-      'eslint-config-airbnb-base': '^15.0.0',
-      'eslint-config-prettier': '^9.1.0',
-      'eslint-plugin-import': '^2.29.0',
-      'mini-css-extract-plugin': '^2.7.6',
-      'postcss-loader': '^7.0.0',
-      sass: '^1.69.7',
-      'sass-loader': '^13.3.2',
-      'sgmf-scripts': '^3.0.0',
-      shx: '^0.3.4',
-      stylelint: '^15.4.0',
-      'stylelint-config-standard-scss': '^11.0.0',
-      'webpack-remove-empty-scripts': '^1.0.4',
-    },
-    browserslist: [
-      'last 2 versions',
-      'ie >= 10',
-    ],
-  };
-}
-
-function createDwJsonTemplate(): object {
-  return {
-    hostname: '',
-    username: '',
-    password: '',
-    'code-version': '',
-  };
-}
-
-function createWebpackConfigTemplate(cartridgeName: string): string {
-  return `'use strict';
-
-var path = require('path');
-var MiniCssExtractPlugin = require('mini-css-extract-plugin');
-var CssMinimizerPlugin = require('css-minimizer-webpack-plugin');
-var sgmfScripts = require('sgmf-scripts');
-var RemoveEmptyScriptsPlugin = require('webpack-remove-empty-scripts');
-
-module.exports = [{
-    mode: 'development',
-    name: 'js',
-    entry: sgmfScripts.createJsPath(),
-    output: {
-        path: path.resolve('./cartridges/${cartridgeName}/cartridge/static'),
-        filename: '[name].js'
-    }
-}, {
-    mode: 'none',
-    name: 'scss',
-    entry: sgmfScripts.createScssPath(),
-    output: {
-        path: path.resolve('./cartridges/${cartridgeName}/cartridge/static')
-    },
-    module: {
-        rules: [{
-            test: /\\.scss$/,
-            use: [{
-                loader: MiniCssExtractPlugin.loader,
-                options: {
-                    esModule: false
-                }
-            },
-            {
-                loader: 'css-loader',
-                options: {
-                    url: false
-                }
-            }, {
-                loader: 'postcss-loader',
-                options: {
-                    postcssOptions: {
-                        plugins: [require('autoprefixer')]
-                    }
-                }
-            }, {
-                loader: 'sass-loader',
-                options: {
-                    implementation: require('sass'),
-                    sassOptions: {
-                        includePaths: [
-                            path.resolve(path.resolve(process.cwd(), '../storefront-reference-architecture/node_modules/')),
-                            path.resolve(process.cwd(), '../storefront-reference-architecture/node_modules/flag-icons/sass')
-                        ]
-                    }
-                }
-            }]
-        }]
-    },
-    plugins: [
-        new RemoveEmptyScriptsPlugin(),
-        new MiniCssExtractPlugin({
-            filename: '[name].css',
-            chunkFilename: '[name].css'
-        })
-    ],
-    optimization: {
-        minimizer: ['...', new CssMinimizerPlugin()]
-    }
-}];`;
-}
-
-function createDotProjectTemplate(cartridgeName: string): string {
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-    <name>${cartridgeName}</name>
-    <comment></comment>
-    <projects>
-    </projects>
-    <buildSpec>
-        <buildCommand>
-            <name>com.demandware.studio.core.beehiveElementBuilder</name>
-            <arguments>
-            </arguments>
-        </buildCommand>
-    </buildSpec>
-    <natures>
-        <nature>com.demandware.studio.core.beehiveNature</nature>
-    </natures>
-</projectDescription>`;
-}
-
-function createProjectPropertiesTemplate(cartridgeName: string): string {
-  return `## cartridge.properties for cartridge ${cartridgeName}
-#demandware.cartridges.${cartridgeName}.multipleLanguageStorefront=true`;
-}
-
-function createEslintrcTemplate(): object {
-  return {
-    root: true,
-    extends: 'airbnb-base/legacy',
-    globals: {
-      session: 'readonly',
-      request: 'readonly',
-    },
-    rules: {
-      'import/no-unresolved': 'off',
-      indent: ['error', 4, { SwitchCase: 1, VariableDeclarator: 1 }],
-      'func-names': 'off',
-      'require-jsdoc': 'error',
-      'valid-jsdoc': ['error', {
-        preferType: {
-          Boolean: 'boolean',
-          Number: 'number',
-          object: 'Object',
-          String: 'string',
-        },
-        requireReturn: false,
-      }],
-      'vars-on-top': 'off',
-      'global-require': 'off',
-      'no-shadow': ['error', { allow: ['err', 'callback'] }],
-      'max-len': 'off',
-      'no-plusplus': 'off',
-    },
-  };
-}
-
-function createStylelintrcTemplate(): object {
-  return {
-    extends: 'stylelint-config-standard-scss',
-    plugins: [
-      'stylelint-scss',
-    ],
-  };
-}
-
-function createEslintignoreTemplate(): string {
-  return `node_modules/
-cartridges/**/cartridge/static/
-coverage/
-doc/
-bin/
-codecept.conf.js`;
-}
-
-function createGitignoreTemplate(): string {
-  return `node_modules/
-cartridges/*/cartridge/static/
-.DS_Store
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-coverage/
-.nyc_output/
-.env
-dw.json`;
-}

package/src/clients/cartridge/index.ts

@@ -1,6 +0,0 @@
-/**
- * Cartridge Module Exports
- */
-export { CartridgeGenerationClient } from './cartridge-generation-client.js';
-export { createCartridgeTemplates, type CartridgeTemplates } from './cartridge-templates.js';
-export { CARTRIDGE_DIRECTORIES, ROOT_PROJECT_FILES } from './cartridge-structure.js';

package/src/clients/docs/class-content-parser.ts

@@ -1,308 +0,0 @@
-/**
- * Class Content Parser
- *
- * Responsible for parsing markdown documentation content and extracting
- * structured class information including constants, properties, methods, and inheritance.
- *
- * Single Responsibility: Converting markdown content to structured data
- */
-
-import { Logger } from '../../utils/logger.js';
-
-export interface SFCCMethod {
-  name: string;
-  signature: string;
-  description: string;
-  parameters?: string[];
-  returnType?: string;
-  deprecated?: boolean;
-  deprecationMessage?: string;
-}
-
-export interface SFCCProperty {
-  name: string;
-  type: string;
-  description: string;
-  modifiers?: string[];
-  deprecated?: boolean;
-  deprecationMessage?: string;
-}
-
-export interface SFCCConstant {
-  name: string;
-  type: string;
-  value?: string;
-  description: string;
-  deprecated?: boolean;
-  deprecationMessage?: string;
-}
-
-export interface SFCCClassDetails {
-  className: string;
-  packageName: string;
-  description: string;
-  constants: SFCCConstant[];
-  properties: SFCCProperty[];
-  methods: SFCCMethod[];
-  inheritance?: string[];
-  constructorInfo?: string;
-}
-
-export class ClassContentParser {
-  private logger: Logger;
-
-  constructor() {
-    this.logger = Logger.getChildLogger('ClassContentParser');
-  }
-
-  /**
-   * Parse markdown content and extract structured class information
-   */
-  parseClassContent(content: string): SFCCClassDetails {
-    const lines = content.split('\n');
-
-    let currentSection = '';
-    let className = '';
-    let packageName = '';
-    let description = '';
-    const constants: SFCCConstant[] = [];
-    const properties: SFCCProperty[] = [];
-    const methods: SFCCMethod[] = [];
-    const inheritance: string[] = [];
-    let constructorInfo = '';
-
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim();
-
-      // Extract package name
-      if (line.startsWith('## Package:')) {
-        packageName = line.replace('## Package:', '').trim();
-      }
-
-      // Extract class name
-      if (line.startsWith('# ') && !line.startsWith('## ')) {
-        className = line.replace('# ', '').replace('Class ', '').trim();
-      }
-
-      // Track current section
-      if (line.startsWith('## ')) {
-        currentSection = line.replace('## ', '').trim();
-      }
-
-      // Extract description
-      if (currentSection === 'Description' && line && !line.startsWith('#')) {
-        description += `${line} `;
-      }
-
-      // Extract inheritance hierarchy
-      if (currentSection === 'Inheritance Hierarchy' && line.includes('-')) {
-        const hierarchyItem = line.replace(/^[\s-]*/, '').trim();
-        if (hierarchyItem) {
-          inheritance.push(hierarchyItem);
-        }
-      }
-
-      // Extract constants
-      if (currentSection === 'Constants' && line.startsWith('### ')) {
-        const constant = this.parseConstant(line, lines, i);
-        if (constant) {
-          constants.push(constant);
-        }
-      }
-
-      // Extract properties
-      if (currentSection === 'Properties' && line.startsWith('### ')) {
-        const property = this.parseProperty(line, lines, i);
-        if (property) {
-          properties.push(property);
-        }
-      }
-
-      // Extract methods
-      if ((currentSection === 'Method Summary' || currentSection === 'Method Details') && line.startsWith('### ')) {
-        const method = this.parseMethod(line, lines, i);
-        if (method) {
-          methods.push(method);
-        }
-      }
-
-      // Extract constructor info
-      if (currentSection === 'Constructor Summary' && line && !line.startsWith('#')) {
-        constructorInfo += `${line} `;
-      }
-    }
-
-    return {
-      className: className.trim(),
-      packageName: packageName.trim(),
-      description: description.trim(),
-      constants,
-      properties,
-      methods,
-      inheritance: inheritance.length > 0 ? inheritance : undefined,
-      constructorInfo: constructorInfo.trim() || undefined,
-    };
-  }
-
-  /**
-   * Parse a constant definition from markdown content
-   */
-  private parseConstant(headerLine: string, lines: string[], startIndex: number): SFCCConstant | null {
-    const constName = headerLine.replace('### ', '').trim();
-    let constType = '';
-    let constValue = '';
-    let constDesc = '';
-    let deprecated = false;
-    let deprecationMessage = '';
-
-    // Look for type, value and description in following lines
-    for (let j = startIndex + 1; j < lines.length && !lines[j].startsWith('#'); j++) {
-      const nextLine = lines[j].trim();
-
-      if (nextLine.startsWith('**Type:**')) {
-        const typeMatch = nextLine.match(/\*\*Type:\*\*\s*(.+)/);
-        if (typeMatch) {
-          const typeInfo = typeMatch[1];
-          // Extract type and value if present (e.g., "String = 'COMPLETED'" or "Number = 8")
-          const valueMatch = typeInfo.match(/^(\w+)\s*=\s*(.+)$/);
-          if (valueMatch) {
-            constType = valueMatch[1];
-            constValue = valueMatch[2];
-          } else {
-            constType = typeInfo.trim();
-          }
-        }
-      } else if (nextLine.startsWith('**Deprecated:**')) {
-        const deprecationInfo = this.parseDeprecationInfo(nextLine, lines, j);
-        deprecated = true;
-        deprecationMessage = deprecationInfo.message;
-      } else if (nextLine && !nextLine.startsWith('**') && !nextLine.startsWith('#')) {
-        constDesc += `${nextLine} `;
-      }
-    }
-
-    return {
-      name: constName,
-      type: constType,
-      value: constValue || undefined,
-      description: constDesc.trim(),
-      deprecated: deprecated || undefined,
-      deprecationMessage: deprecationMessage || undefined,
-    };
-  }
-
-  /**
-   * Parse a property definition from markdown content
-   */
-  private parseProperty(headerLine: string, lines: string[], startIndex: number): SFCCProperty | null {
-    const propName = headerLine.replace('### ', '').trim();
-    let propType = '';
-    let propDesc = '';
-    const modifiers: string[] = [];
-    let deprecated = false;
-    let deprecationMessage = '';
-
-    // Look for type and description in following lines
-    for (let j = startIndex + 1; j < lines.length && !lines[j].startsWith('#'); j++) {
-      const nextLine = lines[j].trim();
-
-      if (nextLine.startsWith('**Type:**')) {
-        const typeMatch = nextLine.match(/\*\*Type:\*\*\s*(.+)/);
-        if (typeMatch) {
-          const typeInfo = typeMatch[1];
-          propType = typeInfo.split(' ')[0];
-          if (typeInfo.includes('(Read Only)')) {
-            modifiers.push('Read Only');
-          }
-          if (typeInfo.includes('(Static)')) {
-            modifiers.push('Static');
-          }
-        }
-      } else if (nextLine.startsWith('**Deprecated:**')) {
-        const deprecationInfo = this.parseDeprecationInfo(nextLine, lines, j);
-        deprecated = true;
-        deprecationMessage = deprecationInfo.message;
-      } else if (nextLine && !nextLine.startsWith('**') && !nextLine.startsWith('#')) {
-        propDesc += `${nextLine} `;
-      }
-    }
-
-    return {
-      name: propName,
-      type: propType,
-      description: propDesc.trim(),
-      modifiers: modifiers.length > 0 ? modifiers : undefined,
-      deprecated: deprecated || undefined,
-      deprecationMessage: deprecationMessage || undefined,
-    };
-  }
-
-  /**
-   * Parse a method definition from markdown content
-   */
-  private parseMethod(headerLine: string, lines: string[], startIndex: number): SFCCMethod | null {
-    const methodName = headerLine.replace('### ', '').trim();
-    let signature = '';
-    let methodDesc = '';
-    let deprecated = false;
-    let deprecationMessage = '';
-
-    // Look for signature and description in following lines
-    for (let j = startIndex + 1; j < lines.length && !lines[j].startsWith('#'); j++) {
-      const nextLine = lines[j].trim();
-
-      if (nextLine.startsWith('**Signature:**')) {
-        const sigMatch = nextLine.match(/\*\*Signature:\*\*\s*`(.+)`/);
-        if (sigMatch) {
-          signature = sigMatch[1];
-        }
-      } else if (nextLine.startsWith('**Description:**')) {
-        methodDesc = nextLine.replace('**Description:**', '').trim();
-      } else if (nextLine.startsWith('**Deprecated:**')) {
-        const deprecationInfo = this.parseDeprecationInfo(nextLine, lines, j);
-        deprecated = true;
-        deprecationMessage = deprecationInfo.message;
-      } else if (nextLine && !nextLine.startsWith('**') && !nextLine.startsWith('#') && !nextLine.startsWith('---')) {
-        if (!methodDesc && !nextLine.includes('Signature:')) {
-          methodDesc += `${nextLine} `;
-        }
-      }
-    }
-
-    return {
-      name: methodName,
-      signature: signature || methodName,
-      description: methodDesc.trim(),
-      deprecated: deprecated || undefined,
-      deprecationMessage: deprecationMessage || undefined,
-    };
-  }
-
-  /**
-   * Parse deprecation information from markdown content
-   */
-  private parseDeprecationInfo(deprecationLine: string, lines: string[], startIndex: number): { message: string } {
-    let deprecationMessage = '';
-
-    // Check if there's a message on the same line
-    const sameLineMessage = deprecationLine.replace('**Deprecated:**', '').trim();
-    if (sameLineMessage) {
-      deprecationMessage = sameLineMessage;
-    } else {
-      // Look for the deprecation message on subsequent lines until next ** marker
-      const depLines: string[] = [];
-      for (let k = startIndex + 1; k < lines.length && !lines[k].startsWith('#'); k++) {
-        const depLine = lines[k].trim();
-        if (depLine.startsWith('**') && !depLine.startsWith('**Deprecated:**')) {
-          break; // Stop at next ** marker
-        }
-        if (depLine && !depLine.startsWith('---')) {
-          depLines.push(depLine);
-        }
-      }
-      deprecationMessage = depLines.join(' ').trim();
-    }
-
-    return { message: deprecationMessage };
-  }
-}

package/src/clients/docs/class-name-resolver.ts

@@ -1,99 +0,0 @@
-/**
- * Class Name Resolver
- *
- * Responsible for normalizing and resolving SFCC class names between
- * different formats (dot notation vs underscore notation) and extracting
- * simple class names from fully qualified names.
- *
- * Single Responsibility: Class name format conversion and resolution
- */
-
-export class ClassNameResolver {
-  /**
-   * Normalize class name to handle both dot and underscore formats
-   * Examples:
-   * - dw.content.ContentMgr -> dw_content.ContentMgr
-   * - dw_content.ContentMgr -> dw_content.ContentMgr (unchanged)
-   * - ContentMgr -> ContentMgr (unchanged)
-   */
-  static normalizeClassName(className: string): string {
-    // If it contains dots but not underscores in the package part, convert dots to underscores
-    if (className.includes('.') && !className.includes('_')) {
-      // Split by dots and convert package parts (all but last) to use underscores
-      const parts = className.split('.');
-      if (parts.length > 1) {
-        const packageParts = parts.slice(0, -1);
-        const simpleClassName = parts[parts.length - 1];
-        return `${packageParts.join('_')}.${simpleClassName}`;
-      }
-    }
-    return className;
-  }
-
-  /**
-   * Extract simple class name from full class name
-   * Examples:
-   * - dw_content.ContentMgr -> ContentMgr
-   * - ContentMgr -> ContentMgr
-   */
-  static extractSimpleClassName(className: string): string {
-    const parts = className.split('.');
-    return parts[parts.length - 1];
-  }
-
-  /**
-   * Convert class names from internal format to official format
-   * Examples:
-   * - dw_content.ContentMgr -> dw.content.ContentMgr
-   * - TopLevel.String -> String
-   */
-  static toOfficialFormat(className: string): string {
-    return className.replace(/_/g, '.');
-  }
-
-  /**
-   * Find class matches by simple class name
-   * Useful when multiple packages contain classes with the same name
-   */
-  static findClassMatches(
-    targetClassName: string,
-    classCache: Map<string, any>,
-  ): Array<{ key: string; info: any }> {
-    const normalizedTarget = this.normalizeClassName(targetClassName);
-    const simpleTarget = this.extractSimpleClassName(normalizedTarget);
-
-    return Array.from(classCache.entries())
-      .filter(([, info]) => info.className === simpleTarget)
-      .map(([key, info]) => ({ key, info }));
-  }
-
-  /**
-   * Resolve class name with fallback logic
-   * First tries exact match, then falls back to simple name matching
-   */
-  static resolveClassName(
-    className: string,
-    classCache: Map<string, any>,
-  ): { key: string; info: any } | null {
-    // Normalize class name to support both formats
-    const normalizedClassName = this.normalizeClassName(className);
-
-    // Try exact match first with normalized name
-    const exactMatch = classCache.get(normalizedClassName);
-    if (exactMatch) {
-      return { key: normalizedClassName, info: exactMatch };
-    }
-
-    // If not found, try to find by class name only (without package)
-    const matches = this.findClassMatches(normalizedClassName, classCache);
-
-    if (matches.length === 1) {
-      return matches[0];
-    } else if (matches.length > 1) {
-      const matchKeys = matches.map(({ key }) => key).join(', ');
-      throw new Error(`Multiple classes found with name "${this.extractSimpleClassName(normalizedClassName)}": ${matchKeys}`);
-    }
-
-    return null;
-  }
-}