@tamyla/clodo-framework 3.0.13 → 3.0.14

package/CHANGELOG.md

@@ -1,9 +1,19 @@
-## [3.0.13](https://github.com/tamylaa/clodo-framework/compare/v3.0.12...v3.0.13) (2025-10-16)
+## [3.0.14](https://github.com/tamylaa/clodo-framework/compare/v3.0.13...v3.0.14) (2025-10-20)
 
 
 ### Bug Fixes
 
-* resolve circular dependency in unified-config-manager ([dff0841](https://github.com/tamylaa/clodo-framework/commit/dff0841c3bfc4ce0200b057c99ab76ea09641c68))
+* add test environment compatibility fixes for ES modules ([71a033d](https://github.com/tamylaa/clodo-framework/commit/71a033d5d959480879c1a4771005553116e8671f))
+* ignore deployment artifacts in deployments/ directory ([768f453](https://github.com/tamylaa/clodo-framework/commit/768f453cbabb984509613a382d86875c1309bcd2))
+* resolve circular dependency in FeatureFlagManager ([d04956f](https://github.com/tamylaa/clodo-framework/commit/d04956f83527d3236fce2fe9750f71cdf0ba8d8e))
+* resolve ESLint errors and update test expectations ([b1188be](https://github.com/tamylaa/clodo-framework/commit/b1188be66d3723bfff62431f6e0eabec685b0111))
+* revert Jest config to working configuration that passes tests ([35a2846](https://github.com/tamylaa/clodo-framework/commit/35a28466c8a48c78011c128f89695399e8500341))
+* update Jest config to properly handle ES modules ([1a951c7](https://github.com/tamylaa/clodo-framework/commit/1a951c7ae147ddb8bef0ec1508c858ac044423b7))
+* update package-lock.json to sync with package.json dependencies ([a3ef884](https://github.com/tamylaa/clodo-framework/commit/a3ef8844cba2b5657a3493b8339c98049a57dd72))
+* update package.json semantic release config to support main branch ([a06b2e8](https://github.com/tamylaa/clodo-framework/commit/a06b2e899ceb7699b67292157991d64c88dedae3))
+* update semantic release config to support main branch ([4102e6c](https://github.com/tamylaa/clodo-framework/commit/4102e6c4cb4f52d065750239c2a0c5a89b733ac0))
+* update version to 3.0.13 to sync with release history ([f9bb4d4](https://github.com/tamylaa/clodo-framework/commit/f9bb4d463a3884b82e972962e5fcd21a272c3acb))
+* use os.tmpdir() for test paths to fix CI permission errors ([022c771](https://github.com/tamylaa/clodo-framework/commit/022c771994635002410c27d8eb7ec8f0614acf6f))
 
 ## [3.0.12](https://github.com/tamylaa/clodo-framework/compare/v3.0.11...v3.0.12) (2025-10-14)
 

package/bin/clodo-service.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 /**
  * Clodo Framework - Unified Three-Tier Service Management CLI
@@ -527,6 +527,86 @@ program
     }
   });
 
+// Professional Edition: assess command (from clodo-orchestration)
+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')
+  .action(async (servicePath, options) => {
+    try {
+      // Try to load professional orchestration package
+      let orchestrationModule;
+      try {
+        orchestrationModule = await import('@tamyla/clodo-orchestration');
+      } catch (err) {
+        console.error(chalk.red('❌ clodo-orchestration package not found'));
+        console.error(chalk.yellow('💡 Install with: npm install @tamyla/clodo-orchestration'));
+        process.exit(1);
+      }
+
+      const { 
+        CapabilityAssessmentEngine, 
+        ServiceAutoDiscovery,
+        runAssessmentWorkflow 
+      } = orchestrationModule;
+
+      const targetPath = servicePath || process.cwd();
+      console.log(chalk.cyan('\n🧠 Professional Capability Assessment'));
+      console.log(chalk.gray('─'.repeat(60)));
+      console.log(chalk.white(`Service Path: ${targetPath}`));
+      
+      if (options.domain) {
+        console.log(chalk.white(`Domain: ${options.domain}`));
+      }
+      if (options.serviceType) {
+        console.log(chalk.white(`Service Type: ${options.serviceType}`));
+      }
+      console.log(chalk.gray('─'.repeat(60)));
+
+      // Use the assessment workflow
+      const assessment = await runAssessmentWorkflow({
+        servicePath: targetPath,
+        domain: options.domain,
+        serviceType: options.serviceType,
+        token: options.token || process.env.CLOUDFLARE_API_TOKEN
+      });
+
+      // Display results
+      console.log(chalk.cyan('\n✅ Assessment Results'));
+      console.log(chalk.gray('─'.repeat(60)));
+      console.log(chalk.white(`Service Type: ${assessment.mergedInputs?.serviceType || assessment.serviceType || 'Not determined'}`));
+      console.log(chalk.white(`Confidence: ${assessment.confidence}%`));
+      
+      if (assessment.gapAnalysis?.missing) {
+        console.log(chalk.white(`Missing Capabilities: ${assessment.gapAnalysis.missing.length}`));
+        if (assessment.gapAnalysis.missing.length > 0) {
+          console.log(chalk.yellow('\n⚠️  Missing:'));
+          assessment.gapAnalysis.missing.forEach(gap => {
+            console.log(chalk.yellow(`   • ${gap.capability}: ${gap.reason || 'Not available'}`));
+          });
+        }
+      }
+
+      console.log(chalk.gray('─'.repeat(60)));
+
+      // Export results if requested
+      if (options.export) {
+        require('fs').writeFileSync(options.export, JSON.stringify(assessment, null, 2));
+        console.log(chalk.green(`\n📄 Results exported to: ${options.export}`));
+      }
+
+    } catch (error) {
+      console.error(chalk.red(`Assessment failed: ${error.message}`));
+      if (process.env.DEBUG) {
+        console.error(chalk.gray(error.stack));
+      }
+      process.exit(1);
+    }
+  });
+
 // Deploy command - using existing InputCollector + CustomerConfigLoader (reusable pattern)
 program
   .command('deploy')
@@ -698,6 +778,19 @@ program
           // Tier 3: Execute deployment
           console.log(chalk.cyan('\n⚙️  Tier 3: Automated Deployment\n'));
           
+          // OPTIONAL: Try to load professional orchestration package if available
+          let professionalOrchestration = null;
+          try {
+            const { runAssessmentWorkflow } = await import('@tamyla/clodo-orchestration');
+            professionalOrchestration = { runAssessmentWorkflow };
+            console.log(chalk.cyan('📊 Professional Edition (clodo-orchestration) detected'));
+          } catch (err) {
+            // clodo-orchestration not installed, continue with standard assessment
+            if (process.env.DEBUG) {
+              console.log(chalk.gray(`   ℹ️  clodo-orchestration not available: ${err.message}`));
+            }
+          }
+          
           // INTEGRATION: Add intelligent service discovery and assessment
           console.log(chalk.cyan('🧠 Performing Intelligent Service Assessment...'));
           const { CapabilityAssessmentEngine } = await import('../dist/service-management/CapabilityAssessmentEngine.js');

package/bin/shared/security/secret-generator.js

@@ -17,8 +17,13 @@ import { execSync } from 'child_process';
 import { fileURLToPath } from 'url';
 
 const __dirname = (() => {
-  const filename = fileURLToPath(import.meta.url);
-  return dirname(filename);
+  try {
+    const filename = fileURLToPath(import.meta.url);
+    return dirname(filename);
+  } catch (error) {
+    // Fallback for test environments - use current working directory
+    return process.cwd();
+  }
 })();
 
 const SECRET_CONFIGS = {

package/dist/config/customers.js

@@ -3,10 +3,16 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSy
 import { resolve, join } from 'path';
 import toml from '@iarna/toml';
 import { createDomainConfigSchema, validateDomainConfig, createDomainRegistry } from './domains.js';
-import { createLogger } from '../utils/index.js';
 import { getDirname } from '../utils/esm-helper.js';
 const __dirname = getDirname(import.meta.url, 'src/config');
-const logger = createLogger('CustomerConfig');
+
+// Simple inline logger to avoid circular dependency with index.js
+const logger = {
+  info: (message, ...args) => console.log(`[CustomerConfig] ${message}`, ...args),
+  error: (message, ...args) => console.error(`[CustomerConfig] ${message}`, ...args),
+  warn: (message, ...args) => console.warn(`[CustomerConfig] ${message}`, ...args),
+  debug: (message, ...args) => console.debug(`[CustomerConfig] ${message}`, ...args)
+};
 
 /**
  * Customer Configuration Manager

package/dist/config/domains.js

@@ -1,5 +1,11 @@
-import { deepMerge, validateRequired, createLogger } from '../utils/index.js';
-const logger = createLogger('DomainConfig');
+// Simple inline logger to avoid circular dependency with index.js
+import { validateRequired, deepMerge } from '../utils/index.js';
+const logger = {
+  info: (message, ...args) => console.log(`[DomainConfig] ${message}`, ...args),
+  error: (message, ...args) => console.error(`[DomainConfig] ${message}`, ...args),
+  warn: (message, ...args) => console.warn(`[DomainConfig] ${message}`, ...args),
+  debug: (message, ...args) => console.debug(`[DomainConfig] ${message}`, ...args)
+};
 
 /**
  * Creates a base domain configuration schema

package/dist/config/features.js

@@ -1,5 +1,10 @@
-import { createLogger } from '../utils/index.js';
-const logger = createLogger('FeatureFlags');
+// Simple inline logger to avoid circular dependency with index.js
+const logger = {
+  info: (message, ...args) => console.log(`[FeatureFlagManager] ${message}`, ...args),
+  error: (message, ...args) => console.error(`[FeatureFlagManager] ${message}`, ...args),
+  warn: (message, ...args) => console.warn(`[FeatureFlagManager] ${message}`, ...args),
+  debug: (message, ...args) => console.debug(`[FeatureFlagManager] ${message}`, ...args)
+};
 
 /**
  * Feature Flag Manager Class

package/dist/index.js

@@ -24,6 +24,14 @@ export { WranglerDeployer } from './deployment/wrangler-deployer.js';
 // Security components
 export * from './security/index.js';
 
+// Service management components
+export { ServiceCreator, createService } from './service-management/ServiceCreator.js';
+export { ServiceOrchestrator } from './service-management/ServiceOrchestrator.js';
+export { InputHandler } from './service-management/handlers/InputHandler.js';
+export { ConfirmationHandler } from './service-management/handlers/ConfirmationHandler.js';
+export { GenerationHandler } from './service-management/handlers/GenerationHandler.js';
+export { ValidationHandler } from './service-management/handlers/ValidationHandler.js';
+
 // Framework version info
 export const FRAMEWORK_VERSION = '1.0.0';
 export const FRAMEWORK_NAME = 'Clodo Framework';

package/dist/service-management/GenerationEngine.js

@@ -36,8 +36,13 @@ import { fileURLToPath } from 'url';
 import { dirname, join, relative } from 'path';
 import { existsSync, mkdirSync, writeFileSync } from 'fs';
 const __dirname = (() => {
-  const filename = fileURLToPath(import.meta.url);
-  return dirname(filename);
+  try {
+    const filename = fileURLToPath(import.meta.url);
+    return dirname(filename);
+  } catch (error) {
+    // Fallback for test environments - use current working directory
+    return process.cwd();
+  }
 })();
 export class GenerationEngine {
   constructor(options = {}) {
@@ -148,12 +153,14 @@ export class GenerationEngine {
     const wranglerConfig = serviceInitializer.generateWranglerConfig(coreInputs.serviceName, {
       type: coreInputs.serviceType,
       env: coreInputs.environment
-    }, [{
-      domain: coreInputs.domainName,
-      accountId: coreInputs.cloudflareAccountId,
-      zoneId: coreInputs.cloudflareZoneId,
-      name: `${coreInputs.serviceName}-${coreInputs.environment}`
-    }]);
+    }, {
+      domains: [{
+        domain: coreInputs.domainName,
+        accountId: coreInputs.cloudflareAccountId,
+        zoneId: coreInputs.cloudflareZoneId,
+        name: `${coreInputs.serviceName}-${coreInputs.environment}`
+      }]
+    });
 
     // Write wrangler.toml
     const wranglerPath = join(servicePath, 'wrangler.toml');
@@ -177,12 +184,14 @@ export class GenerationEngine {
     const domainsContent = serviceInitializer.generateDomainsConfig(coreInputs.serviceName, {
       type: coreInputs.serviceType,
       env: coreInputs.environment
-    }, [{
-      domain: coreInputs.domainName,
-      accountId: coreInputs.cloudflareAccountId,
-      zoneId: coreInputs.cloudflareZoneId,
-      name: `${coreInputs.serviceName}-${coreInputs.environment}`
-    }]);
+    }, {
+      domains: [{
+        domain: coreInputs.domainName,
+        accountId: coreInputs.cloudflareAccountId,
+        zoneId: coreInputs.cloudflareZoneId,
+        name: `${coreInputs.serviceName}-${coreInputs.environment}`
+      }]
+    });
     const domainsPath = join(servicePath, 'src', 'config', 'domains.js');
     writeFileSync(domainsPath, domainsContent, 'utf8');
     files.push(domainsPath);

package/dist/service-management/InputCollector.js

@@ -15,7 +15,9 @@ import { createInterface } from 'readline';
 import chalk from 'chalk';
 import { validateServiceName, validateDomainName } from '../utils/validation.js';
 import { uiStructuresLoader } from '../utils/ui-structures-loader.js';
-import { CapabilityAssessmentEngine } from './CapabilityAssessmentEngine.js';
+
+// Assessment capabilities moved to @tamyla/clodo-orchestration (professional edition)
+
 export class InputCollector {
   constructor(options = {}) {
     this.interactive = options.interactive !== false;
@@ -82,10 +84,7 @@ export class InputCollector {
           required: true
         };
 
-        // Run assessment after API token is collected
-        if (inputDef.id === 'cloudflare-api-token' && value) {
-          await this.runDeploymentReadinessAssessment(result.coreInputs);
-        }
+        // Assessment moved to professional edition (@tamyla/clodo-orchestration)
       }
     }
 
@@ -579,98 +578,6 @@ export class InputCollector {
     });
   }
 
-  /**
-   * Run deployment readiness assessment after API token collection
-   */
-  async runDeploymentReadinessAssessment(coreInputs) {
-    console.log(chalk.cyan('\n🔍 Running Deployment Readiness Assessment...'));
-    console.log(chalk.gray('Analyzing your inputs for deployment feasibility...\n'));
-    try {
-      // Convert core inputs to assessment format
-      const assessmentInputs = {
-        serviceName: coreInputs['service-name']?.value,
-        serviceType: coreInputs['service-type']?.value || 'generic',
-        domainName: coreInputs['domain-name']?.value,
-        environment: coreInputs['environment']?.value || 'development',
-        cloudflareToken: coreInputs['cloudflare-api-token']?.value,
-        customerName: coreInputs['customer-name']?.value
-      };
-
-      // Create assessment engine with caching enabled
-      const assessmentEngine = new CapabilityAssessmentEngine(process.cwd(), {
-        cacheEnabled: true,
-        cache: {
-          ttl: 10 * 60 * 1000
-        } // 10 minutes for interactive sessions
-      });
-
-      // Run assessment
-      const assessment = await assessmentEngine.assessCapabilities(assessmentInputs);
-
-      // Display results
-      this.displayAssessmentResults(assessment);
-
-      // Store assessment in result for later use
-      return assessment;
-    } catch (error) {
-      console.log(chalk.yellow(`⚠️  Assessment failed: ${error.message}`));
-      console.log(chalk.gray('Continuing with service creation...'));
-      return null;
-    }
-  }
-
-  /**
-   * Display assessment results in user-friendly format
-   */
-  displayAssessmentResults(assessment) {
-    const {
-      capabilityManifest,
-      gapAnalysis,
-      confidence,
-      cached
-    } = assessment;
-    console.log(chalk.cyan('\n📊 Assessment Results:'));
-    console.log(chalk.gray('─'.repeat(40)));
-
-    // Service type and confidence
-    console.log(chalk.white(`Service Type: ${capabilityManifest.serviceType}`));
-    console.log(chalk.white(`Confidence: ${confidence.toFixed(1)}%`));
-    if (cached) {
-      console.log(chalk.gray('(Results loaded from cache)'));
-    }
-
-    // Gap analysis summary
-    const missingCount = gapAnalysis.missing.length;
-    const blockedCount = gapAnalysis.missing.filter(gap => gap.priority === 'blocked').length;
-    if (missingCount === 0) {
-      console.log(chalk.green('✅ All required capabilities detected'));
-    } else {
-      console.log(chalk.yellow(`⚠️  ${missingCount} capability gap(s) found`));
-      if (blockedCount > 0) {
-        console.log(chalk.red(`🚫 ${blockedCount} deployment blocker(s) detected`));
-      }
-
-      // Show top 3 gaps
-      gapAnalysis.missing.slice(0, 3).forEach(gap => {
-        const icon = gap.priority === 'blocked' ? '🚫' : '⚠️';
-        console.log(chalk.gray(`   ${icon} ${gap.capability}: ${gap.reason}`));
-      });
-      if (gapAnalysis.missing.length > 3) {
-        console.log(chalk.gray(`   ... and ${gapAnalysis.missing.length - 3} more`));
-      }
-    }
-
-    // Recommendations
-    if (assessment.recommendations && assessment.recommendations.length > 0) {
-      console.log(chalk.blue('\n💡 Recommendations:'));
-      assessment.recommendations.slice(0, 2).forEach(rec => {
-        console.log(chalk.gray(`   • ${rec.message}`));
-      });
-    }
-    console.log(chalk.gray('\n─'.repeat(40)));
-    console.log(chalk.white('Continue with service creation? (Assessment will run again before generation)'));
-  }
-
   /**
    * Close readline interface and clean up
    */

package/dist/service-management/ServiceCreator.js

@@ -9,7 +9,15 @@ import { fileURLToPath } from 'url';
 const SERVICE_TYPES = ['data-service', 'auth-service', 'content-service', 'api-gateway', 'generic'];
 export class ServiceCreator {
   constructor(options = {}) {
-    this.templatesDir = options.templatesDir || join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'templates');
+    const templatesDir = (() => {
+      try {
+        return join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'templates');
+      } catch (error) {
+        // Fallback for test environments - use current working directory
+        return join(process.cwd(), 'templates');
+      }
+    })();
+    this.templatesDir = options.templatesDir || templatesDir;
     this.serviceTypes = options.serviceTypes || SERVICE_TYPES;
   }
 

package/dist/service-management/ServiceInitializer.js

@@ -6,11 +6,20 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, cpSync, readdirSync } from 'fs';
 import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
-const FRAMEWORK_ROOT = (() => {
-  const filename = fileURLToPath(import.meta.url);
-  const dirname_ = dirname(filename);
-  return resolve(dirname_, '..', '..');
-})();
+
+// Get framework root - handle both ES module and CommonJS environments
+const getFrameworkRoot = () => {
+  try {
+    // Try ES module approach
+    const filename = fileURLToPath(import.meta.url);
+    const dirname_ = dirname(filename);
+    return resolve(dirname_, '..', '..');
+  } catch (error) {
+    // Fallback for test environments - use current working directory
+    return process.cwd();
+  }
+};
+const FRAMEWORK_ROOT = getFrameworkRoot();
 const TEMPLATES_DIR = join(FRAMEWORK_ROOT, 'templates');
 const SERVICE_TYPES = ['generic', 'data-service', 'auth-service', 'content-service', 'api-gateway'];
 export class ServiceInitializer {