@tamyla/clodo-framework 3.1.21 → 3.1.22

package/dist/service-management/generators/utils/TemplateEngine.js

@@ -1,185 +0,0 @@
-/**
- * TemplateEngine - Handles template loading and rendering
- * 
- * Provides centralized template management with variable replacement,
- * partial support, and future support for conditionals and loops.
- * 
- * NOTE: This class uses Node.js filesystem APIs and is designed for
- * build-time usage during service generation, not runtime in Cloudflare Workers.
- */
-import { promises as fs } from 'fs';
-import path from 'path';
-export class TemplateEngine {
-  /**
-   * Create a new template engine instance
-   * @param {Object} options - Configuration options
-   * @param {string} options.templatesPath - Root path to templates directory
-   * @param {string} options.partialsPath - Path to partials directory (optional)
-   */
-  constructor(options = {}) {
-    this.templatesPath = options.templatesPath;
-    this.partialsPath = options.partialsPath || (this.templatesPath ? path.join(this.templatesPath, 'partials') : null);
-    this.cache = new Map();
-    this.cacheEnabled = options.cache !== false; // Default to true
-  }
-
-  /**
-   * Load a template file from the templates directory
-   * @param {string} templateName - Template filename or path relative to templatesPath
-   * @returns {Promise<string>} - Template content
-   */
-  async loadTemplate(templateName) {
-    if (!this.templatesPath) {
-      throw new Error('templatesPath not configured');
-    }
-
-    // Check cache first
-    if (this.cacheEnabled && this.cache.has(templateName)) {
-      return this.cache.get(templateName);
-    }
-    const templatePath = path.join(this.templatesPath, templateName);
-    try {
-      const content = await fs.readFile(templatePath, 'utf8');
-
-      // Cache the template
-      if (this.cacheEnabled) {
-        this.cache.set(templateName, content);
-      }
-      return content;
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        throw new Error(`Template not found: ${templateName} (looked in ${templatePath})`);
-      }
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to load template '${templateName}': ${errorMessage}`);
-    }
-  }
-
-  /**
-   * Load a partial template
-   * @param {string} partialName - Partial filename or path relative to partialsPath
-   * @returns {Promise<string>} - Partial content
-   */
-  async loadPartial(partialName) {
-    if (!this.partialsPath) {
-      throw new Error('partialsPath not configured');
-    }
-    const cacheKey = `partial:${partialName}`;
-
-    // Check cache first
-    if (this.cacheEnabled && this.cache.has(cacheKey)) {
-      return this.cache.get(cacheKey);
-    }
-    const partialPath = path.join(this.partialsPath, partialName);
-    try {
-      const content = await fs.readFile(partialPath, 'utf8');
-
-      // Cache the partial
-      if (this.cacheEnabled) {
-        this.cache.set(cacheKey, content);
-      }
-      return content;
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        throw new Error(`Partial not found: ${partialName} (looked in ${partialPath})`);
-      }
-      throw new Error(`Failed to load partial '${partialName}': ${error.message}`);
-    }
-  }
-
-  /**
-   * Render a template with variables
-   * Replaces {{variable}} placeholders with values from the variables object
-   * Supports dot notation: {{config.name}}
-   * @param {string} template - Template string with {{placeholders}}
-   * @param {Object} variables - Variable values to replace
-   * @param {Object} options - Rendering options
-   * @param {boolean} options.strict - Throw error on missing variables (default: false)
-   * @returns {string} - Rendered template
-   */
-  render(template, variables = {}, options = {}) {
-    if (typeof template !== 'string') {
-      throw new Error('Template must be a string');
-    }
-    const strict = options.strict === true;
-
-    // Replace {{variable}} placeholders
-    let result = template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
-      const trimmedKey = key.trim();
-
-      // Get value using dot notation
-      const value = this.getNestedValue(variables, trimmedKey);
-      if (value === undefined || value === null) {
-        if (strict) {
-          throw new Error(`Missing variable: ${trimmedKey}`);
-        }
-        return match; // Keep placeholder if variable not found
-      }
-      return String(value);
-    });
-    return result;
-  }
-
-  /**
-   * Render a template with partial support
-   * Replaces {{> partialName}} with the content of the partial
-   * @param {string} template - Template string
-   * @param {Object} variables - Variable values
-   * @param {Object} options - Rendering options
-   * @returns {Promise<string>} - Rendered template
-   */
-  async renderWithPartials(template, variables = {}, options = {}) {
-    // First, replace partials
-    const partialRegex = /\{\{>\s*([^}]+)\}\}/g;
-    const partialMatches = [...template.matchAll(partialRegex)];
-    let result = template;
-    for (const match of partialMatches) {
-      const partialName = match[1].trim();
-      const partial = await this.loadPartial(partialName);
-      result = result.replace(match[0], partial);
-    }
-
-    // Then render variables
-    return this.render(result, variables, options);
-  }
-
-  /**
-   * Get a nested value from an object using dot notation
-   * @param {Object} obj - Object to search
-   * @param {string} path - Dot-notation path (e.g., 'config.server.port')
-   * @returns {*} - Value or undefined
-   */
-  getNestedValue(obj, path) {
-    if (!path) return obj;
-    const keys = path.split('.');
-    let value = obj;
-    for (const key of keys) {
-      if (value && typeof value === 'object' && key in value) {
-        value = value[key];
-      } else {
-        return undefined;
-      }
-    }
-    return value;
-  }
-
-  /**
-   * Clear the template cache
-   */
-  clearCache() {
-    this.cache.clear();
-  }
-
-  /**
-   * Get cache statistics
-   * @returns {Object} - Cache stats
-   */
-  getCacheStats() {
-    return {
-      size: this.cache.size,
-      enabled: this.cacheEnabled,
-      keys: Array.from(this.cache.keys())
-    };
-  }
-}
-export default TemplateEngine;

package/dist/service-management/generators/utils/index.js

@@ -1,18 +0,0 @@
-/**
- * Generator Utilities - Centralized exports
- *
- * Provides template engine, file writer, and path resolver utilities
- * for use by all generators.
- */
-
-import { TemplateEngine } from './TemplateEngine.js';
-import { FileWriter } from './FileWriter.js';
-import { PathResolver } from './PathResolver.js';
-export { TemplateEngine } from './TemplateEngine.js';
-export { FileWriter } from './FileWriter.js';
-export { PathResolver } from './PathResolver.js';
-export default {
-  TemplateEngine,
-  FileWriter,
-  PathResolver
-};

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

@@ -1,71 +0,0 @@
-/**
- * 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

@@ -1,80 +0,0 @@
-/**
- * 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

@@ -1,59 +0,0 @@
-/**
- * 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

@@ -1,203 +0,0 @@
-/**
- * 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

@@ -1,14 +0,0 @@
-/**
- * Clodo Framework - Service Management Module
- * Programmatic APIs for service creation and initialization
- */
-
-export { ServiceCreator, createService } from './ServiceCreator.js';
-export { ServiceInitializer, initializeService } from './ServiceInitializer.js';
-
-// Assessment capabilities moved to @tamyla/clodo-orchestration
-// - AssessmentCache
-// - CapabilityAssessmentEngine
-// - ServiceAutoDiscovery
-// - Data-bridge components
-// These are only available in the professional edition (clodo-orchestration)