@tamyla/clodo-framework 1.0.0

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

@@ -0,0 +1,130 @@
+/**
+ * Configuration Mutator Module
+ * Focused module for safe configuration file mutations
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+export class ConfigMutator {
+  constructor(options = {}) {
+    this.dryRun = options.dryRun || false;
+  }
+
+  /**
+   * Safely update domain configuration
+   */
+  async updateDomainConfig(servicePath, currentConfig, updates) {
+    const domainConfigPath = path.join(servicePath, 'src/config/domains.js');
+    let domainConfig = await fs.readFile(domainConfigPath, 'utf8');
+    if (updates.domainName) {
+      // Use regex-based replacement for safety
+      domainConfig = domainConfig.replace(new RegExp(`name: ['"]${this.escapeRegExp(currentConfig.domainName)}['"]`, 'g'), `name: '${updates.domainName}'`);
+
+      // Update domain URLs
+      domainConfig = domainConfig.replace(new RegExp(`https://[^'"]*${this.escapeRegExp(currentConfig.domainName)}[^'"]*`, 'g'), match => match.replace(currentConfig.domainName, updates.domainName));
+    }
+    if (!this.dryRun) {
+      await fs.writeFile(domainConfigPath, domainConfig, 'utf8');
+    }
+    return {
+      updated: true,
+      path: domainConfigPath
+    };
+  }
+
+  /**
+   * Update Cloudflare configuration
+   */
+  async updateCloudflareConfig(servicePath, currentConfig, updates) {
+    const domainConfigPath = path.join(servicePath, 'src/config/domains.js');
+    let domainConfig = await fs.readFile(domainConfigPath, 'utf8');
+    if (updates.accountId) {
+      domainConfig = domainConfig.replace(new RegExp(`accountId:\\s*['"]${this.escapeRegExp(currentConfig.cloudflareAccountId || '')}['"]`, 'g'), `accountId: '${updates.accountId}'`);
+    }
+    if (updates.zoneId) {
+      domainConfig = domainConfig.replace(new RegExp(`zoneId:\\s*['"]${this.escapeRegExp(currentConfig.cloudflareZoneId || '')}['"]`, 'g'), `zoneId: '${updates.zoneId}'`);
+    }
+    if (!this.dryRun) {
+      await fs.writeFile(domainConfigPath, domainConfig, 'utf8');
+    }
+    return {
+      updated: true,
+      path: domainConfigPath
+    };
+  }
+
+  /**
+   * Update environment configuration
+   */
+  async updateEnvironmentConfig(servicePath, currentConfig, updates) {
+    const wranglerConfigPath = path.join(servicePath, 'wrangler.toml');
+    let wranglerConfig = await fs.readFile(wranglerConfigPath, 'utf8');
+    if (updates.environment) {
+      // Update environment-specific names
+      wranglerConfig = wranglerConfig.replace(new RegExp(`name\\s*=\\s*['"].*${this.escapeRegExp(currentConfig.environment)}.*['"]`, 'g'), `name = "${currentConfig.serviceName}-${updates.environment}"`);
+      wranglerConfig = wranglerConfig.replace(new RegExp(`\\[env\\.${this.escapeRegExp(currentConfig.environment)}\\]`, 'g'), `[env.${updates.environment}]`);
+    }
+    if (!this.dryRun) {
+      await fs.writeFile(wranglerConfigPath, wranglerConfig, 'utf8');
+    }
+    return {
+      updated: true,
+      path: wranglerConfigPath
+    };
+  }
+
+  /**
+   * Update feature configuration
+   */
+  async updateFeatureConfig(servicePath, action, feature) {
+    const domainConfigPath = path.join(servicePath, 'src/config/domains.js');
+    let domainConfig = await fs.readFile(domainConfigPath, 'utf8');
+    if (action === 'add') {
+      // Add feature flag
+      const featureLine = `    ${feature}: true,`;
+      domainConfig = domainConfig.replace(/(\s+)(cors:\s*(?:true|false),?)(\n)/, `$1$2$3$1${featureLine}$3`);
+    } else if (action === 'remove') {
+      // Remove feature flag
+      const featureLinePattern = new RegExp(`\\s+${this.escapeRegExp(feature)}:\\s*(?:true|false),?\\n`, 'g');
+      domainConfig = domainConfig.replace(featureLinePattern, '');
+    }
+    if (!this.dryRun) {
+      await fs.writeFile(domainConfigPath, domainConfig, 'utf8');
+    }
+    return {
+      updated: true,
+      path: domainConfigPath
+    };
+  }
+
+  /**
+   * Validate configuration file exists and is writable
+   */
+  async validateConfigFile(filePath) {
+    try {
+      await fs.access(filePath, fs.constants.R_OK | fs.constants.W_OK);
+      return {
+        valid: true
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        error: `Configuration file not accessible: ${filePath}`
+      };
+    }
+  }
+
+  /**
+   * Escape special regex characters for safe replacement
+   */
+  escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+
+  /**
+   * Enable/disable dry run mode
+   */
+  setDryRun(enabled) {
+    this.dryRun = enabled;
+  }
+}

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

@@ -0,0 +1,71 @@
+/**
+ * Confirmation Handler Module
+ * Focused module for handling smart confirmations and derived values
+ */
+
+import { ConfirmationEngine } from '../ConfirmationEngine.js';
+import { createPromptHandler } from '../../utils/prompt-handler.js';
+export class ConfirmationHandler {
+  constructor(options = {}) {
+    this.interactive = options.interactive !== false;
+    this.promptHandler = createPromptHandler({
+      interactive: this.interactive
+    });
+    this.confirmationEngine = new ConfirmationEngine({
+      interactive: this.interactive
+    });
+  }
+
+  /**
+   * Generate and confirm derived values from core inputs
+   */
+  async generateAndConfirm(coreInputs) {
+    return await this.confirmationEngine.generateAndConfirm(coreInputs);
+  }
+
+  /**
+   * Generate smart defaults without interaction
+   */
+  generateSmartDefaults(coreInputs) {
+    return this.confirmationEngine.generateSmartDefaults(coreInputs);
+  }
+
+  /**
+   * Interactive confirmation of specific values
+   */
+  async confirmValue(field, currentValue, question) {
+    if (!this.interactive) {
+      return currentValue;
+    }
+    const confirmed = await this.promptHandler.confirm(`${question}\nCurrent value: ${currentValue}\nKeep this value?`, true);
+    if (!confirmed) {
+      return await this.promptHandler.prompt('Enter new value: ');
+    }
+    return currentValue;
+  }
+
+  /**
+   * Confirm entire configuration
+   */
+  async confirmConfiguration(config) {
+    if (!this.interactive) {
+      return true;
+    }
+    console.log('\n📋 Configuration Summary:');
+    Object.entries(config).forEach(([key, value]) => {
+      // Mask sensitive values
+      if (key.toLowerCase().includes('token') || key.toLowerCase().includes('secret')) {
+        value = '*'.repeat(8) + value.slice(-4);
+      }
+      console.log(`  ${key}: ${value}`);
+    });
+    return await this.promptHandler.confirm('\nProceed with this configuration?', true);
+  }
+
+  /**
+   * Cleanup resources
+   */
+  async cleanup() {
+    await this.promptHandler.close();
+  }
+}

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

@@ -0,0 +1,80 @@
+/**
+ * Generation Handler Module
+ * Focused module for service generation and file creation
+ */
+
+import { GenerationEngine } from '../GenerationEngine.js';
+export class GenerationHandler {
+  constructor(options = {}) {
+    this.outputPath = options.outputPath || '.';
+    this.templatePath = options.templatePath || './templates';
+    this.generationEngine = new GenerationEngine({
+      outputDir: this.outputPath,
+      templatesDir: this.templatePath
+    });
+  }
+
+  /**
+   * Generate complete service from inputs and confirmed values
+   */
+  async generateService(coreInputs, confirmedValues, options = {}) {
+    const config = {
+      outputPath: this.outputPath,
+      ...options
+    };
+    return await this.generationEngine.generateService(coreInputs, confirmedValues, config);
+  }
+
+  /**
+   * Generate specific component
+   */
+  async generateComponent(componentType, config, outputPath) {
+    // Delegate to generation engine's specific methods
+    switch (componentType) {
+      case 'manifest':
+        return this.generationEngine.createServiceManifest(config.coreInputs, config.confirmedValues, config.generatedFiles || []);
+      case 'directory':
+        return this.generationEngine.createDirectoryStructure(outputPath);
+      default:
+        throw new Error(`Unknown component type: ${componentType}`);
+    }
+  }
+
+  /**
+   * Validate generation prerequisites
+   */
+  async validatePrerequisites(coreInputs, confirmedValues) {
+    const issues = [];
+
+    // Check required inputs
+    if (!coreInputs.serviceName) {
+      issues.push('Service name is required');
+    }
+    if (!coreInputs.serviceType) {
+      issues.push('Service type is required');
+    }
+
+    // Check output path permissions
+    try {
+      const fs = await import('fs/promises');
+      await fs.access(this.outputPath);
+    } catch (error) {
+      issues.push(`Output path not accessible: ${this.outputPath}`);
+    }
+    return {
+      valid: issues.length === 0,
+      issues
+    };
+  }
+
+  /**
+   * Get generation progress information
+   */
+  getGenerationStatus() {
+    return {
+      outputPath: this.outputPath,
+      templatePath: this.templatePath,
+      ready: true
+    };
+  }
+}

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

@@ -0,0 +1,59 @@
+/**
+ * Input Handler Module
+ * Focused module for collecting core service inputs
+ */
+
+import { InputCollector } from '../InputCollector.js';
+import { createPromptHandler } from '../../utils/prompt-handler.js';
+export class InputHandler {
+  constructor(options = {}) {
+    this.interactive = options.interactive !== false;
+    this.promptHandler = createPromptHandler({
+      interactive: this.interactive
+    });
+    this.inputCollector = new InputCollector({
+      interactive: this.interactive
+    });
+  }
+
+  /**
+   * Collect the 6 core inputs required for service creation
+   */
+  async collectCoreInputs() {
+    return await this.inputCollector.collectCoreInputs();
+  }
+
+  /**
+   * Validate core inputs without prompting
+   */
+  async validateCoreInputs(inputs) {
+    return await this.inputCollector.validateCoreInputs(inputs);
+  }
+
+  /**
+   * Interactive input collection with custom prompts
+   */
+  async promptForInput(field, question, defaultValue = '', required = false) {
+    if (!this.interactive) {
+      return defaultValue;
+    }
+    let answer;
+    do {
+      answer = await this.promptHandler.prompt(question);
+      if (!answer && defaultValue) {
+        answer = defaultValue;
+      }
+      if (required && !answer) {
+        console.log('This field is required. Please provide a value.');
+      }
+    } while (required && !answer);
+    return answer;
+  }
+
+  /**
+   * Cleanup resources
+   */
+  async cleanup() {
+    await this.promptHandler.close();
+  }
+}

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

@@ -0,0 +1,203 @@
+/**
+ * Validation Handler Module
+ * Focused module for service validation and health checks
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+export class ValidationHandler {
+  constructor(options = {}) {
+    this.strict = options.strict || false;
+  }
+
+  /**
+   * Validate complete service configuration
+   */
+  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) {
+      const filePath = path.join(servicePath, file);
+      try {
+        await fs.access(filePath);
+      } catch {
+        issues.push(`Missing required file: ${file}`);
+      }
+    }
+
+    // Validate package.json
+    const packageValidation = await this.validatePackageJson(servicePath);
+    issues.push(...packageValidation.issues);
+
+    // Validate domain configuration
+    const domainValidation = await this.validateDomainConfig(servicePath);
+    issues.push(...domainValidation.issues);
+
+    // Validate wrangler configuration
+    const wranglerValidation = await this.validateWranglerConfig(servicePath);
+    issues.push(...wranglerValidation.issues);
+    return {
+      valid: issues.length === 0,
+      issues,
+      servicePath
+    };
+  }
+
+  /**
+   * Validate package.json structure
+   */
+  async validatePackageJson(servicePath) {
+    const issues = [];
+    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');
+      }
+      if (!packageJson.type || packageJson.type !== 'module') {
+        issues.push('package.json: Should use "type": "module" for ES modules');
+      }
+
+      // Check for required dependencies
+      const requiredDeps = ['@tamyla/clodo-framework'];
+      const deps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies
+      };
+      requiredDeps.forEach(dep => {
+        if (!deps[dep]) {
+          issues.push(`package.json: Missing required dependency: ${dep}`);
+        }
+      });
+    } catch (error) {
+      issues.push(`package.json: Invalid JSON format - ${error.message}`);
+    }
+    return {
+      issues
+    };
+  }
+
+  /**
+   * Validate domain configuration
+   */
+  async validateDomainConfig(servicePath) {
+    const issues = [];
+    const domainConfigPath = path.join(servicePath, 'src/config/domains.js');
+    try {
+      const domainConfig = await fs.readFile(domainConfigPath, 'utf8');
+
+      // Check for Clodo Framework integration
+      if (!domainConfig.includes('createDomainConfigSchema')) {
+        issues.push('Domain configuration missing Clodo Framework integration');
+      }
+
+      // Check for required exports
+      if (!domainConfig.includes('export const domains')) {
+        issues.push('Domain configuration missing domains export');
+      }
+
+      // Basic domain format validation
+      const domainMatches = domainConfig.match(/domain:\s*['"]([^'"]+)['"]/g);
+      if (domainMatches) {
+        domainMatches.forEach(match => {
+          const domain = match.match(/domain:\s*['"]([^'"]+)['"]/)[1];
+          if (!/^[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9]*\.[a-zA-Z]{2,}$/.test(domain)) {
+            issues.push(`Invalid domain format: ${domain}`);
+          }
+        });
+      }
+    } catch (error) {
+      issues.push(`Domain configuration: Cannot read file - ${error.message}`);
+    }
+    return {
+      issues
+    };
+  }
+
+  /**
+   * Validate wrangler configuration
+   */
+  async validateWranglerConfig(servicePath) {
+    const issues = [];
+    const wranglerConfigPath = path.join(servicePath, 'wrangler.toml');
+    try {
+      const wranglerConfig = await fs.readFile(wranglerConfigPath, 'utf8');
+
+      // Check for required fields
+      if (!wranglerConfig.includes('name =')) {
+        issues.push('wrangler.toml: Missing name field');
+      }
+      if (!wranglerConfig.includes('main =')) {
+        issues.push('wrangler.toml: Missing main field');
+      }
+      if (!wranglerConfig.includes('compatibility_date =')) {
+        issues.push('wrangler.toml: Missing compatibility_date');
+      }
+    } catch (error) {
+      issues.push(`wrangler.toml: Cannot read file - ${error.message}`);
+    }
+    return {
+      issues
+    };
+  }
+
+  /**
+   * Run comprehensive service diagnostics
+   */
+  async diagnoseService(servicePath) {
+    const diagnosis = {
+      errors: [],
+      warnings: [],
+      recommendations: []
+    };
+
+    // Basic validation
+    const validation = await this.validateService(servicePath);
+    validation.issues.forEach(issue => {
+      if (issue.includes('Missing required')) {
+        diagnosis.errors.push({
+          message: issue,
+          severity: 'high',
+          suggestion: 'Run service initialization to create missing files'
+        });
+      } else if (issue.includes('Invalid')) {
+        diagnosis.errors.push({
+          message: issue,
+          severity: 'medium',
+          suggestion: 'Review and correct the configuration'
+        });
+      } else {
+        diagnosis.warnings.push({
+          message: issue,
+          suggestion: 'Consider updating for better compatibility'
+        });
+      }
+    });
+
+    // Additional recommendations
+    try {
+      const packageJson = JSON.parse(await fs.readFile(path.join(servicePath, 'package.json'), 'utf8'));
+      if (!packageJson.scripts || !packageJson.scripts.dev) {
+        diagnosis.recommendations.push('Add development scripts for easier testing');
+      }
+      if (!packageJson.scripts || !packageJson.scripts.deploy) {
+        diagnosis.recommendations.push('Add deployment scripts for easier publishing');
+      }
+    } catch (error) {
+      // Package.json validation already handled above
+    }
+    return diagnosis;
+  }
+
+  /**
+   * Set validation strictness
+   */
+  setStrict(enabled) {
+    this.strict = enabled;
+  }
+}

package/dist/service-management/index.js

@@ -0,0 +1,7 @@
+/**
+ * Clodo Framework - Service Management Module
+ * Programmatic APIs for service creation and initialization
+ */
+
+export { ServiceCreator, createService } from './ServiceCreator.js';
+export { ServiceInitializer, initializeService } from './ServiceInitializer.js';