@tamyla/clodo-framework 3.1.23 → 3.1.24

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [3.1.24](https://github.com/tamylaa/clodo-framework/compare/v3.1.23...v3.1.24) (2025-11-08)
+
+
+### Bug Fixes
+
+* Add comprehensive framework assessment and strategic evolution plan ([bed4108](https://github.com/tamylaa/clodo-framework/commit/bed41085c253e025bd065e507296efe261616652))
+* resolve linting error and enhance CI pipeline ([ece5b5a](https://github.com/tamylaa/clodo-framework/commit/ece5b5aa7232bc990b1d85d3e53ccf7e2d215c98))
+
 ## [3.1.23](https://github.com/tamylaa/clodo-framework/compare/v3.1.22...v3.1.23) (2025-11-07)
 
 

package/dist/cli/commands/assess.js

@@ -4,35 +4,46 @@
  */
 
 import chalk from 'chalk';
+import path from 'path';
+import { ServiceOrchestrator } from '../service-management/ServiceOrchestrator.js';
 import { StandardOptions } from '../lib/shared/utils/cli-options.js';
-import { ConfigLoader } from '../lib/shared/utils/config-loader.js';
+import { ServiceConfigManager } from '../lib/shared/utils/service-config-manager.js';
 export function registerAssessCommand(program) {
-  const command = program.command('assess [service-path]').description('Run intelligent capability assessment (requires @tamyla/clodo-orchestration)').option('--export <file>', 'Export assessment results to JSON file').option('--domain <domain>', 'Domain name for assessment').option('--service-type <type>', 'Service type for assessment').option('--token <token>', 'Cloudflare API token');
+  const command = program.command('assess [service-path]').description('Run intelligent capability assessment (requires @tamyla/clodo-orchestration)').option('--export <file>', 'Export assessment results to JSON file').option('--domain <domain>', 'Domain name for assessment').option('--service-type <type>', 'Service type for assessment').option('--token <token>', 'Cloudflare API token').option('--show-config-sources', 'Display all configuration sources and merged result');
 
   // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
   StandardOptions.define(command).action(async (servicePath, options) => {
     try {
       const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options);
-      const configLoader = new ConfigLoader({
+      const configManager = new ServiceConfigManager({
         verbose: options.verbose,
         quiet: options.quiet,
-        json: options.json
+        json: options.json,
+        showSources: options.showConfigSources
       });
+      const orchestrator = new ServiceOrchestrator();
+      const targetPath = servicePath || process.cwd();
 
-      // Load config from file if specified
-      let configFileData = {};
-      if (options.configFile) {
-        configFileData = configLoader.loadSafe(options.configFile, {});
-        if (options.verbose && !options.quiet) {
-          output.info(`Loaded configuration from: ${options.configFile}`);
+      // Validate service path with better error handling
+      try {
+        servicePath = await configManager.validateServicePath(targetPath, orchestrator);
+      } catch (error) {
+        output.error(error.message);
+        if (error.suggestions) {
+          output.info('Suggestions:');
+          output.list(error.suggestions);
         }
+        process.exit(1);
       }
 
-      // Substitute environment variables
-      configFileData = configLoader.substituteEnvironmentVariables(configFileData);
-
-      // Merge config file defaults with CLI options (CLI takes precedence)
-      const mergedOptions = configLoader.merge(configFileData, options);
+      // Load and merge all configurations
+      const mergedOptions = await configManager.loadServiceConfig(servicePath, options, {
+        export: null,
+        domain: null,
+        serviceType: null,
+        token: null
+      });
+      let assessment; // Declare here so it's available in the entire scope
 
       // Try to load professional orchestration package
       let orchestrationModule;
@@ -45,8 +56,6 @@ export function registerAssessCommand(program) {
         output.info('💡 Using basic assessment capabilities');
         output.info('💡 For advanced assessment: npm install @tamyla/clodo-orchestration');
       }
-      let assessment;
-      const targetPath = servicePath || process.cwd();
       if (hasEnterprisePackage) {
         output.section('Professional Capability Assessment');
         output.list([`Service Path: ${targetPath}`, mergedOptions.domain ? `Domain: ${mergedOptions.domain}` : null, mergedOptions.serviceType ? `Service Type: ${mergedOptions.serviceType}` : null, 'Enterprise Package: ✅ Available'].filter(Boolean));

package/dist/cli/commands/deploy.js

@@ -19,6 +19,7 @@ import { CloudflareServiceValidator } from '../lib/shared/config/cloudflare-serv
 import { DeploymentCredentialCollector } from '../lib/shared/deployment/credential-collector.js';
 import { StandardOptions } from '../lib/shared/utils/cli-options.js';
 import { ConfigLoader } from '../lib/shared/utils/config-loader.js';
+import { ServiceConfigManager } from '../lib/shared/utils/service-config-manager.js';
 import { DomainRouter } from '../lib/shared/routing/domain-router.js';
 import { MultiDomainOrchestrator } from '../orchestration/multi-domain-orchestrator.js';
 
@@ -30,7 +31,7 @@ import { handleDeploymentError } from './helpers/error-recovery.js';
 export function registerDeployCommand(program) {
   const command = program.command('deploy').description('Deploy a Clodo service with smart credential handling and domain selection')
   // Cloudflare-specific options
-  .option('--token <token>', 'Cloudflare API token').option('--account-id <id>', 'Cloudflare account ID').option('--zone-id <id>', 'Cloudflare zone ID').option('--domain <domain>', 'Specific domain to deploy to (otherwise prompted if multiple exist)').option('--environment <env>', 'Target environment (development, staging, production)', 'production').option('--development', 'Deploy to development environment (shorthand for --environment development)').option('--staging', 'Deploy to staging environment (shorthand for --environment staging)').option('--production', 'Deploy to production environment (shorthand for --environment production)').option('--all-domains', 'Deploy to all configured domains (ignores --domain flag)').option('--dry-run', 'Simulate deployment without making changes').option('-y, --yes', 'Skip confirmation prompts (for CI/CD)').option('--service-path <path>', 'Path to service directory', '.');
+  .option('--token <token>', 'Cloudflare API token').option('--account-id <id>', 'Cloudflare account ID').option('--zone-id <id>', 'Cloudflare zone ID').option('--domain <domain>', 'Specific domain to deploy to (otherwise prompted if multiple exist)').option('--environment <env>', 'Target environment (development, staging, production)', 'production').option('--development', 'Deploy to development environment (shorthand for --environment development)').option('--staging', 'Deploy to staging environment (shorthand for --environment staging)').option('--production', 'Deploy to production environment (shorthand for --environment production)').option('--all-domains', 'Deploy to all configured domains (ignores --domain flag)').option('--dry-run', 'Simulate deployment without making changes').option('-y, --yes', 'Skip confirmation prompts (for CI/CD)').option('--service-path <path>', 'Path to service directory', '.').option('--show-config-sources', 'Display all configuration sources and merged result');
 
   // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
   StandardOptions.define(command).action(async options => {
@@ -60,15 +61,36 @@ export function registerDeployCommand(program) {
         }
       }
 
-      // Substitute environment variables in config
-      configFileData = configLoader.substituteEnvironmentVariables(configFileData);
+      // Use ServiceConfigManager for standardized config loading
+      const configManager = new ServiceConfigManager({
+        verbose: options.verbose,
+        quiet: options.quiet,
+        json: options.json,
+        showSources: options.showConfigSources
+      });
 
-      // Merge config file defaults with CLI options (CLI takes precedence)
-      const mergedOptions = configLoader.merge(configFileData, options);
+      // For deploy command, we use current directory as service path
+      const deployServicePath = resolve(options.servicePath || '.');
+
+      // Load and merge all configurations
+      const mergedOptions = await configManager.loadServiceConfig(deployServicePath, {
+        ...options,
+        configFile: options.configFile // Pass through the config file option
+      }, {
+        token: null,
+        accountId: null,
+        zoneId: null,
+        domain: null,
+        environment: 'production',
+        allDomains: false,
+        dryRun: false,
+        yes: false,
+        servicePath: '.'
+      });
       output.info('🚀 Clodo Service Deployment');
 
       // Step 1: Load and validate service configuration
-      const servicePath = resolve(mergedOptions.servicePath || '.');
+      const servicePath = resolve(mergedOptions.servicePath || deployServicePath);
       const serviceConfig = await ManifestLoader.loadAndValidateCloudflareService(servicePath);
       if (!serviceConfig.manifest) {
         if (serviceConfig.error === 'NOT_A_CLOUDFLARE_SERVICE') {

package/dist/cli/commands/diagnose.js

@@ -1,41 +1,41 @@
 import chalk from 'chalk';
+import path from 'path';
 import { ServiceOrchestrator } from '../service-management/ServiceOrchestrator.js';
 import { StandardOptions } from '../lib/shared/utils/cli-options.js';
-import { ConfigLoader } from '../lib/shared/utils/config-loader.js';
+import { ServiceConfigManager } from '../lib/shared/utils/service-config-manager.js';
 export function registerDiagnoseCommand(program) {
-  const command = program.command('diagnose [service-path]').description('Diagnose and report issues with an existing service').option('--deep-scan', 'Perform deep analysis including dependencies and deployment readiness').option('--export-report <file>', 'Export diagnostic report to file').option('--fix-suggestions', 'Include suggested fixes for issues');
+  const command = program.command('diagnose [service-path]').description('Diagnose and report issues with an existing service').option('--deep-scan', 'Perform deep analysis including dependencies and deployment readiness').option('--export-report <file>', 'Export diagnostic report to file').option('--fix-suggestions', 'Include suggested fixes for issues').option('--show-config-sources', 'Display all configuration sources and merged result');
 
   // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
   StandardOptions.define(command).action(async (servicePath, options) => {
     try {
       const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options);
-      const configLoader = new ConfigLoader({
+      const configManager = new ServiceConfigManager({
         verbose: options.verbose,
         quiet: options.quiet,
-        json: options.json
+        json: options.json,
+        showSources: options.showConfigSources
       });
-
-      // Load config from file if specified
-      let configFileData = {};
-      if (options.configFile) {
-        configFileData = configLoader.loadSafe(options.configFile, {});
-        if (options.verbose && !options.quiet) {
-          output.info(`Loaded configuration from: ${options.configFile}`);
-        }
-      }
-
-      // Merge config file defaults with CLI options (CLI takes precedence)
-      const mergedOptions = configLoader.merge(configFileData, options);
       const orchestrator = new ServiceOrchestrator();
 
-      // Auto-detect service path if not provided
-      if (!servicePath) {
-        servicePath = await orchestrator.detectServicePath();
-        if (!servicePath) {
-          output.error('No service path provided and could not auto-detect service directory');
-          process.exit(1);
+      // Validate service path with better error handling
+      try {
+        servicePath = await configManager.validateServicePath(servicePath, orchestrator);
+      } catch (error) {
+        output.error(error.message);
+        if (error.suggestions) {
+          output.info('Suggestions:');
+          output.list(error.suggestions);
         }
+        process.exit(1);
       }
+
+      // Load and merge all configurations
+      const mergedOptions = await configManager.loadServiceConfig(servicePath, options, {
+        deepScan: false,
+        exportReport: null,
+        fixSuggestions: false
+      });
       output.info('🔍 Diagnosing service...');
       const diagnosis = await orchestrator.diagnoseService(servicePath, mergedOptions);
 

package/dist/cli/commands/update.js

@@ -3,36 +3,61 @@
  */
 
 import chalk from 'chalk';
+import path from 'path';
 import { ServiceOrchestrator } from '../service-management/ServiceOrchestrator.js';
 import { StandardOptions } from '../lib/shared/utils/cli-options.js';
-import { ConfigLoader } from '../lib/shared/utils/config-loader.js';
+import { ServiceConfigManager } from '../lib/shared/utils/service-config-manager.js';
 export function registerUpdateCommand(program) {
-  const command = program.command('update [service-path]').description('Update an existing service configuration').option('-i, --interactive', 'Run in interactive mode to select what to update').option('--domain-name <domain>', 'Update domain name').option('--cloudflare-token <token>', 'Update Cloudflare API token').option('--cloudflare-account-id <id>', 'Update Cloudflare account ID').option('--cloudflare-zone-id <id>', 'Update Cloudflare zone ID').option('--environment <env>', 'Update target environment: development, staging, production').option('--add-feature <feature>', 'Add a feature flag').option('--remove-feature <feature>', 'Remove a feature flag').option('--regenerate-configs', 'Regenerate all configuration files').option('--fix-errors', 'Attempt to fix common configuration errors').option('--preview', 'Show what would be changed without applying').option('--force', 'Skip confirmation prompts');
+  const command = program.command('update [service-path]').description('Update an existing service configuration').option('-i, --interactive', 'Run in interactive mode to select what to update').option('--domain-name <domain>', 'Update domain name').option('--cloudflare-token <token>', 'Update Cloudflare API token').option('--cloudflare-account-id <id>', 'Update Cloudflare account ID').option('--cloudflare-zone-id <id>', 'Update Cloudflare zone ID').option('--environment <env>', 'Update target environment: development, staging, production').option('--add-feature <feature>', 'Add a feature flag').option('--remove-feature <feature>', 'Remove a feature flag').option('--regenerate-configs', 'Regenerate all configuration files').option('--fix-errors', 'Attempt to fix common configuration errors').option('--preview', 'Show what would be changed without applying').option('--show-config-sources', 'Display all configuration sources and merged result').option('--force', 'Skip confirmation prompts');
 
   // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
   StandardOptions.define(command).action(async (servicePath, options) => {
     try {
       const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options);
-      const configLoader = new ConfigLoader({
+      const configManager = new ServiceConfigManager({
         verbose: options.verbose,
         quiet: options.quiet,
-        json: options.json
+        json: options.json,
+        showSources: options.showConfigSources
       });
+      const orchestrator = new ServiceOrchestrator();
 
-      // Load config from file if specified
-      let configFileData = {};
-      if (options.configFile) {
-        configFileData = configLoader.loadSafe(options.configFile, {});
-        if (options.verbose && !options.quiet) {
-          output.info(`Loaded configuration from: ${options.configFile}`);
+      // Auto-detect service path if not provided
+      if (!servicePath) {
+        servicePath = await orchestrator.detectServicePath();
+        if (!servicePath) {
+          output.error('No service path provided and could not auto-detect service directory');
+          process.exit(1);
         }
       }
 
-      // Merge config file defaults with CLI options (CLI takes precedence)
-      const mergedOptions = configLoader.merge(configFileData, options);
-      const orchestrator = new ServiceOrchestrator();
+      // Validate service path with better error handling
+      try {
+        servicePath = await configManager.validateServicePath(servicePath, orchestrator);
+      } catch (error) {
+        output.error(error.message);
+        if (error.suggestions) {
+          output.info('Suggestions:');
+          output.list(error.suggestions);
+        }
+        process.exit(1);
+      }
 
-      // Auto-detect service path if not provided
+      // Load and merge all configurations
+      const mergedOptions = await configManager.loadServiceConfig(servicePath, options, {
+        interactive: false,
+        domainName: null,
+        cloudflareToken: null,
+        cloudflareAccountId: null,
+        cloudflareZoneId: null,
+        environment: null,
+        addFeature: null,
+        removeFeature: null,
+        regenerateConfigs: false,
+        fixErrors: false,
+        preview: false,
+        force: false
+      });
       if (!servicePath) {
         servicePath = await orchestrator.detectServicePath();
         if (!servicePath) {
@@ -44,7 +69,9 @@ export function registerUpdateCommand(program) {
       }
 
       // Validate it's a service directory
-      const isValid = await orchestrator.validateService(servicePath);
+      const isValid = await orchestrator.validateService(servicePath, {
+        customConfig: mergedOptions
+      });
       if (!isValid.valid) {
         output.warning('Service has configuration issues. Use --fix-errors to attempt automatic fixes.');
         if (!mergedOptions.fixErrors) {

package/dist/cli/commands/validate.js

@@ -3,37 +3,46 @@
  */
 
 import chalk from 'chalk';
+import path from 'path';
 import { ServiceOrchestrator } from '../service-management/ServiceOrchestrator.js';
 import { StandardOptions } from '../lib/shared/utils/cli-options.js';
-import { ConfigLoader } from '../lib/shared/utils/config-loader.js';
+import { ServiceConfigManager } from '../lib/shared/utils/service-config-manager.js';
 export function registerValidateCommand(program) {
-  const command = program.command('validate <service-path>').description('Validate an existing service configuration').option('--deep-scan', 'Run comprehensive validation checks').option('--export-report <file>', 'Export validation report to JSON file');
+  const command = program.command('validate <service-path>').description('Validate an existing service configuration').option('--deep-scan', 'Run comprehensive validation checks').option('--export-report <file>', 'Export validation report to JSON file').option('--show-config-sources', 'Display all configuration sources and merged result');
 
   // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
   StandardOptions.define(command).action(async (servicePath, options) => {
     try {
       const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options);
-      const configLoader = new ConfigLoader({
+      const configManager = new ServiceConfigManager({
         verbose: options.verbose,
         quiet: options.quiet,
-        json: options.json
+        json: options.json,
+        showSources: options.showConfigSources
       });
+      const orchestrator = new ServiceOrchestrator();
 
-      // Load config from file if specified
-      let configFileData = {};
-      if (options.configFile) {
-        configFileData = configLoader.loadSafe(options.configFile, {});
-        if (options.verbose && !options.quiet) {
-          output.info(`Loaded configuration from: ${options.configFile}`);
+      // Validate service path with better error handling
+      try {
+        servicePath = await configManager.validateServicePath(servicePath, orchestrator);
+      } catch (error) {
+        output.error(error.message);
+        if (error.suggestions) {
+          output.info('Suggestions:');
+          output.list(error.suggestions);
         }
+        process.exit(1);
       }
 
-      // Merge config file defaults with CLI options (CLI takes precedence)
-      const mergedOptions = configLoader.merge(configFileData, options);
-      const orchestrator = new ServiceOrchestrator();
+      // Load and merge all configurations
+      const mergedOptions = await configManager.loadServiceConfig(servicePath, options, {
+        deepScan: false,
+        exportReport: null
+      });
       const result = await orchestrator.validateService(servicePath, {
         deepScan: mergedOptions.deepScan,
-        exportReport: mergedOptions.exportReport
+        exportReport: mergedOptions.exportReport,
+        customConfig: mergedOptions.validation // Pass custom validation config
       });
       if (result.valid) {
         output.success('Service configuration is valid');
@@ -42,6 +51,11 @@ export function registerValidateCommand(program) {
         output.list(result.issues || []);
         process.exit(1);
       }
+
+      // Report export success if requested
+      if (mergedOptions.exportReport) {
+        output.success(`📄 Report exported to: ${mergedOptions.exportReport}`);
+      }
     } catch (error) {
       const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options || {});
       output.error(`Validation failed: ${error.message}`);

package/dist/lib/shared/config/manifest-loader.js

@@ -276,13 +276,13 @@ export class ManifestLoader {
    */
   static printManifestInfo(manifest) {
     console.log(chalk.cyan('\n📋 Service Configuration:\n'));
-    console.log(chalk.white(`Service Name: ${chalk.bold(manifest.serviceName)}`));
-    console.log(chalk.white(`Service Type: ${chalk.bold(manifest.serviceType)}`));
+    console.log(chalk.white(`Service Name: ${chalk.bold(manifest.service?.name || manifest.serviceName || 'unknown')}`));
+    console.log(chalk.white(`Service Type: ${chalk.bold(manifest.service?.type || manifest.serviceType || 'unknown')}`));
     console.log(chalk.white(`Source: ${chalk.gray(manifest._source)}`));
     if (manifest._legacyNote) {
       console.log(chalk.yellow(`\nℹ️  ${manifest._legacyNote}`));
     }
-    if (manifest.deployment.domains) {
+    if (manifest.deployment && manifest.deployment.domains) {
       console.log(chalk.white(`\nDomains:`));
       manifest.deployment.domains.forEach(domain => {
         console.log(chalk.gray(`  - ${domain.name} (${domain.environment})`));

package/dist/lib/shared/utils/config-loader.js

@@ -114,8 +114,9 @@ export class ConfigLoader {
   }
 
   /**
-   * Merge configuration file defaults with CLI options
+   * Deep merge configuration file defaults with CLI options
    * CLI options take precedence over config file defaults
+   * Handles nested objects properly (deep merge)
    * @param {Object} configFile - Configuration loaded from file
    * @param {Object} cliOptions - Options from command line
    * @returns {Object} Merged configuration with CLI options taking precedence
@@ -128,22 +129,57 @@ export class ConfigLoader {
       return configFile || {};
     }
 
-    // Create merged result: start with config file, override with CLI options
-    const merged = {
-      ...configFile
-    };
-    for (const [key, value] of Object.entries(cliOptions)) {
-      // Only override with CLI option if it's explicitly provided (not undefined, null, or empty string)
-      if (value !== undefined && value !== null && value !== '') {
-        merged[key] = value;
-      }
-    }
+    // Start with deep copy of config file
+    const merged = this.deepClone(configFile);
+
+    // Deep merge CLI options on top
+    this.deepMergeInto(merged, cliOptions);
     if (this.verbose && !this.quiet) {
       console.log('📋 Configuration merged: CLI options override file defaults');
     }
     return merged;
   }
 
+  /**
+   * Deep clone an object
+   */
+  deepClone(obj) {
+    if (obj === null || typeof obj !== 'object') return obj;
+    if (obj instanceof Date) return new Date(obj.getTime());
+    if (obj instanceof Array) return obj.map(item => this.deepClone(item));
+    if (typeof obj === 'object') {
+      const cloned = {};
+      for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+          cloned[key] = this.deepClone(obj[key]);
+        }
+      }
+      return cloned;
+    }
+  }
+
+  /**
+   * Deep merge source into target (modifies target)
+   */
+  deepMergeInto(target, source) {
+    if (!source || typeof source !== 'object') return;
+    for (const [key, value] of Object.entries(source)) {
+      // Only override if value is explicitly provided (not undefined, null, or empty string)
+      if (value !== undefined && value !== null && value !== '') {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+          // Deep merge nested objects
+          if (!target[key] || typeof target[key] !== 'object' || Array.isArray(target[key])) {
+            target[key] = {};
+          }
+          this.deepMergeInto(target[key], value);
+        } else {
+          // Override with source value (including arrays and primitives)
+          target[key] = value;
+        }
+      }
+    }
+  }
+
   /**
    * Substitute environment variables in configuration values
    * Format: ${ENV_VAR_NAME} in strings will be replaced with environment variable values

package/dist/lib/shared/utils/service-config-manager.js

@@ -0,0 +1,227 @@
+/**
+ * Service Config Manager
+ * Centralized, reusable configuration loading for CLI commands
+ *
+ * Features:
+ * - Standardized config file discovery across all commands
+ * - Proper error handling with user-friendly messages
+ * - Deep merging of nested configuration objects
+ * - Config validation against schemas
+ * - Debugging support with --show-config-sources
+ * - Environment variable substitution
+ */
+
+import { existsSync } from 'fs';
+import path from 'path';
+import { ConfigLoader } from './config-loader.js';
+export class ServiceConfigManager {
+  constructor(options = {}) {
+    this.configLoader = new ConfigLoader(options);
+    this.verbose = options.verbose || false;
+    this.quiet = options.quiet || false;
+    this.json = options.json || false;
+    this.showSources = options.showSources || false;
+  }
+
+  /**
+   * Load and merge configuration for a service command
+   * @param {string} servicePath - Path to the service directory
+   * @param {Object} cliOptions - CLI options from commander
+   * @param {Object} commandDefaults - Default options for this command
+   * @returns {Object} Merged configuration
+   */
+  async loadServiceConfig(servicePath, cliOptions = {}, commandDefaults = {}) {
+    const sources = [];
+
+    // 1. Load framework defaults (always available)
+    const frameworkConfig = this.loadFrameworkDefaults();
+    sources.push({
+      name: 'Framework Defaults',
+      path: 'config/validation-config.json',
+      config: frameworkConfig,
+      priority: 4
+    });
+
+    // 2. Load service-specific config (highest priority for customization)
+    const serviceConfig = await this.loadServiceConfigFile(servicePath);
+    if (serviceConfig) {
+      sources.push({
+        name: 'Service Config',
+        path: path.join(servicePath, 'validation-config.json'),
+        config: serviceConfig,
+        priority: 1
+      });
+    }
+
+    // 3. Load current directory config (for deploy command compatibility)
+    const cwdConfig = this.loadCwdConfigFile();
+    if (cwdConfig) {
+      sources.push({
+        name: 'Current Directory Config',
+        path: path.join(process.cwd(), 'validation-config.json'),
+        config: cwdConfig,
+        priority: 2
+      });
+    }
+
+    // 4. Load explicitly specified config file
+    let explicitConfig = {};
+    if (cliOptions.configFile) {
+      explicitConfig = this.configLoader.loadSafe(cliOptions.configFile, {});
+      if (Object.keys(explicitConfig).length > 0) {
+        sources.push({
+          name: 'Explicit Config File',
+          path: cliOptions.configFile,
+          config: explicitConfig,
+          priority: 0 // Highest priority
+        });
+      }
+    }
+
+    // Sort sources by priority (lower number = higher priority)
+    sources.sort((a, b) => a.priority - b.priority);
+
+    // Show config sources if requested
+    if (this.showSources) {
+      this.displayConfigSources(sources);
+    }
+
+    // Deep merge all configurations
+    let mergedConfig = {
+      ...commandDefaults
+    };
+    for (const source of sources) {
+      mergedConfig = this.deepMerge(mergedConfig, source.config);
+    }
+
+    // CLI options override everything (except when showing sources)
+    if (!this.showSources) {
+      mergedConfig = this.deepMerge(mergedConfig, cliOptions);
+    }
+
+    // Substitute environment variables
+    mergedConfig = this.configLoader.substituteEnvironmentVariables(mergedConfig);
+    return mergedConfig;
+  }
+
+  /**
+   * Load framework default configuration
+   */
+  loadFrameworkDefaults() {
+    try {
+      const frameworkConfigPath = path.join(process.cwd(), 'config', 'validation-config.json');
+      return this.configLoader.loadSafe(frameworkConfigPath, {});
+    } catch (error) {
+      // Framework config is optional, return empty object
+      return {};
+    }
+  }
+
+  /**
+   * Load service-specific configuration file
+   */
+  async loadServiceConfigFile(servicePath) {
+    if (!servicePath) return null;
+    const configPath = path.join(servicePath, 'validation-config.json');
+    try {
+      if (!existsSync(configPath)) {
+        return null; // File doesn't exist, which is fine
+      }
+      const config = this.configLoader.load(configPath);
+      if (this.verbose && !this.quiet) {
+        console.log(`✅ Loaded service config: ${configPath}`);
+      }
+      return config;
+    } catch (error) {
+      // This is an actual error (file exists but can't be loaded)
+      if (!this.quiet) {
+        console.warn(`⚠️  Failed to load service config from ${configPath}: ${error.message}`);
+        console.warn(`   Using framework defaults instead.`);
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Load configuration from current working directory
+   */
+  loadCwdConfigFile() {
+    const configPath = path.join(process.cwd(), 'validation-config.json');
+    try {
+      if (!existsSync(configPath)) {
+        return null;
+      }
+      const config = this.configLoader.load(configPath);
+      if (this.verbose && !this.quiet) {
+        console.log(`✅ Loaded current directory config: ${configPath}`);
+      }
+      return config;
+    } catch (error) {
+      if (!this.quiet) {
+        console.warn(`⚠️  Failed to load current directory config from ${configPath}: ${error.message}`);
+        console.warn(`   Using framework defaults instead.`);
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Deep merge two configuration objects
+   */
+  deepMerge(target, source) {
+    if (!source || typeof source !== 'object') return target;
+    if (!target || typeof target !== 'object') return source;
+    const result = {
+      ...target
+    };
+    for (const [key, value] of Object.entries(source)) {
+      if (value && typeof value === 'object' && !Array.isArray(value)) {
+        // Deep merge nested objects
+        result[key] = this.deepMerge(result[key] || {}, value);
+      } else {
+        // Override with source value (including arrays and primitives)
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Display configuration sources for debugging
+   */
+  displayConfigSources(sources) {
+    console.log('\n📋 Configuration Sources (in merge order):');
+    for (const source of sources) {
+      const status = Object.keys(source.config).length > 0 ? '✅ Loaded' : '❌ Empty';
+      console.log(`  ${status} ${source.name}: ${source.path}`);
+    }
+    console.log('\n📋 Final merged configuration:');
+    console.log(JSON.stringify(this.deepMerge({}, ...sources.map(s => s.config)), null, 2));
+    console.log('');
+  }
+
+  /**
+   * Validate service path exists and is accessible
+   */
+  async validateServicePath(servicePath, orchestrator) {
+    if (!servicePath) {
+      // Try auto-detection
+      servicePath = await orchestrator.detectServicePath();
+      if (!servicePath) {
+        const error = new Error('No service path provided and could not auto-detect service directory');
+        error.suggestions = ['Ensure you are in a service directory or specify --service-path', 'Service directories must contain: package.json, src/config/domains.js, wrangler.toml', 'Try: cd /path/to/your/service && clodo-service <command>'];
+        throw error;
+      }
+    }
+
+    // Validate the path exists and is accessible
+    try {
+      await orchestrator.isServiceDirectory(servicePath);
+    } catch (error) {
+      const validationError = new Error(`Invalid service path: ${servicePath}`);
+      validationError.suggestions = ['Ensure the directory exists and is accessible', 'Service directories must contain: package.json, src/config/domains.js, wrangler.toml', `Check permissions for: ${servicePath}`];
+      throw validationError;
+    }
+    return servicePath;
+  }
+}

package/dist/service-management/ServiceOrchestrator.js

@@ -18,6 +18,7 @@ import { ValidationHandler } from './handlers/ValidationHandler.js';
 import { ErrorTracker } from './ErrorTracker.js';
 import chalk from 'chalk';
 import fs from 'fs/promises';
+import fsSync from 'fs';
 import path from 'path';
 export class ServiceOrchestrator {
   constructor(options = {}) {
@@ -97,8 +98,18 @@ export class ServiceOrchestrator {
   /**
    * Validate an existing service configuration
    */
-  async validateService(servicePath) {
-    return await this.validationHandler.validateService(servicePath);
+  async validateService(servicePath, options = {}) {
+    // Create ValidationHandler with custom config if provided
+    const validationHandler = options.customConfig ? new ValidationHandler({
+      customConfig: options.customConfig
+    }) : this.validationHandler;
+    const result = await validationHandler.validateService(servicePath);
+
+    // Export report if requested
+    if (options.exportReport) {
+      await this.exportValidationReport(result, options.exportReport);
+    }
+    return result;
   }
 
   /**
@@ -554,6 +565,13 @@ export class ServiceOrchestrator {
    * Export diagnostic report
    */
   async exportDiagnosticReport(diagnosis, filePath) {
+    // Ensure directory exists
+    const dir = path.dirname(filePath);
+    if (!fsSync.existsSync(dir)) {
+      fsSync.mkdirSync(dir, {
+        recursive: true
+      });
+    }
     const report = {
       timestamp: new Date().toISOString(),
       serviceName: diagnosis.serviceName,
@@ -569,6 +587,29 @@ export class ServiceOrchestrator {
     await fs.writeFile(filePath, JSON.stringify(report, null, 2), 'utf8');
   }
 
+  /**
+   * Export validation report
+   */
+  async exportValidationReport(validation, filePath) {
+    // Ensure directory exists
+    const dir = path.dirname(filePath);
+    if (!fsSync.existsSync(dir)) {
+      fsSync.mkdirSync(dir, {
+        recursive: true
+      });
+    }
+    const report = {
+      timestamp: new Date().toISOString(),
+      servicePath: validation.servicePath || 'unknown',
+      valid: validation.valid,
+      summary: {
+        issues: validation.issues ? validation.issues.length : 0
+      },
+      issues: validation.issues || []
+    };
+    await fs.writeFile(filePath, JSON.stringify(report, null, 2), 'utf8');
+  }
+
   /**
    * Generate service using legacy ServiceCreator (placeholder for GenerationEngine)
    */

package/dist/service-management/handlers/ValidationHandler.js

@@ -8,6 +8,18 @@ import path from 'path';
 export class ValidationHandler {
   constructor(options = {}) {
     this.strict = options.strict || false;
+    this.customConfig = options.customConfig || {};
+
+    // Use custom validation config if provided, otherwise use defaults
+    this.validationConfig = {
+      requiredFiles: this.customConfig.requiredFiles || ['package.json', 'src/config/domains.js', 'src/worker/index.js', 'wrangler.toml'],
+      optionalFiles: this.customConfig.optionalFiles || ['README.md', 'LICENSE', '.gitignore'],
+      requiredFields: this.customConfig.requiredFields || {
+        'package.json': ['name', 'version', 'type', 'main'],
+        'wrangler.toml': ['name', 'main', 'compatibility_date']
+      },
+      serviceTypes: this.customConfig.serviceTypes || ['data-service', 'auth-service', 'content-service', 'api-gateway', 'static-site', 'generic']
+    };
   }
 
   /**
@@ -16,9 +28,8 @@ export class ValidationHandler {
   async validateService(servicePath) {
     const issues = [];
 
-    // Check for required files
-    const requiredFiles = ['package.json', 'src/config/domains.js', 'src/worker/index.js', 'wrangler.toml'];
-    for (const file of requiredFiles) {
+    // Check for required files using custom config
+    for (const file of this.validationConfig.requiredFiles) {
       const filePath = path.join(servicePath, file);
       try {
         await fs.access(filePath);
@@ -53,12 +64,14 @@ export class ValidationHandler {
     const packageJsonPath = path.join(servicePath, 'package.json');
     try {
       const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
-      if (!packageJson.name) {
-        issues.push('package.json: Missing name field');
-      }
-      if (!packageJson.version) {
-        issues.push('package.json: Missing version field');
-      }
+
+      // Check custom required fields for package.json
+      const requiredPackageFields = this.validationConfig.requiredFields['package.json'] || ['name', 'version'];
+      requiredPackageFields.forEach(field => {
+        if (!packageJson[field]) {
+          issues.push(`package.json: Missing required field: ${field}`);
+        }
+      });
       if (!packageJson.type || packageJson.type !== 'module') {
         issues.push('package.json: Should use "type": "module" for ES modules');
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamyla/clodo-framework",
-  "version": "3.1.23",
+  "version": "3.1.24",
   "description": "Reusable framework for Clodo-style software architecture on Cloudflare Workers + D1",
   "type": "module",
   "sideEffects": [