@tamyla/clodo-framework 3.0.13 → 3.0.15

package/dist/service-management/ServiceOrchestrator.js

@@ -17,7 +17,6 @@ import { ValidationHandler } from './handlers/ValidationHandler.js';
 // Legacy imports for backward compatibility
 import { ServiceCreator } from './ServiceCreator.js';
 import { ErrorTracker } from './ErrorTracker.js';
-import { CapabilityAssessmentEngine } from './CapabilityAssessmentEngine.js';
 import chalk from 'chalk';
 import fs from 'fs/promises';
 import path from 'path';
@@ -61,17 +60,11 @@ export class ServiceOrchestrator {
       // Tier 2: Smart confirmations for 15 derived values
       const confirmedValues = await this.confirmationHandler.generateAndConfirm(coreInputs);
 
-      // Pre-generation assessment for final validation
-      console.log(chalk.yellow('🔍 Pre-Generation Assessment'));
-      console.log(chalk.white('Final validation of deployment readiness...\n'));
-      const finalAssessment = await this.runFinalAssessment(coreInputs, confirmedValues);
-
       // Tier 3: Automated generation of 67 components
       console.log(chalk.yellow('⚙️  Tier 3: Automated Generation'));
       console.log(chalk.white('Generating 67 configuration files and service components...\n'));
       const generationResult = await this.generationHandler.generateService(coreInputs, confirmedValues, {
-        outputPath: this.outputPath,
-        assessment: finalAssessment // Pass assessment for generation optimization
+        outputPath: this.outputPath
       });
 
       // Display results
@@ -631,271 +624,10 @@ export class ServiceOrchestrator {
     return [];
   }
 
-  /**
-   * Run final assessment before generation
-   */
-  async runFinalAssessment(coreInputs, confirmedValues) {
-    try {
-      // Import assessment engine dynamically to avoid circular dependencies
-      const {
-        CapabilityAssessmentEngine
-      } = await import('./CapabilityAssessmentEngine.js');
-
-      // Combine core inputs and confirmed values for assessment
-      const assessmentInputs = {
-        ...coreInputs,
-        ...confirmedValues,
-        // Ensure we have the right field names
-        serviceName: coreInputs.serviceName || coreInputs['service-name'],
-        serviceType: coreInputs.serviceType || coreInputs['service-type'] || 'generic',
-        domainName: coreInputs.domainName || coreInputs['domain-name'],
-        environment: coreInputs.environment || coreInputs['environment'] || 'development',
-        cloudflareToken: coreInputs.cloudflareToken || coreInputs['cloudflare-api-token']
-      };
-
-      // Create assessment engine with caching
-      const assessmentEngine = new CapabilityAssessmentEngine(this.outputPath, {
-        cacheEnabled: true,
-        cache: {
-          ttl: 5 * 60 * 1000
-        } // 5 minutes for final assessment
-      });
-
-      // Run comprehensive assessment
-      const assessment = await assessmentEngine.assessCapabilities(assessmentInputs);
-
-      // Check for deployment blockers
-      const blockers = assessment.gapAnalysis.missing.filter(gap => gap.priority === 'blocked');
-      if (blockers.length > 0) {
-        console.log(chalk.red('\n🚫 Deployment Blockers Detected:'));
-        blockers.forEach(blocker => {
-          console.log(chalk.red(`   • ${blocker.capability}: ${blocker.reason}`));
-        });
-        if (this.interactive) {
-          const proceed = await this.confirmationHandler.promptHandler.confirm('\nContinue with generation despite blockers? (Service may not deploy successfully)', false);
-          if (!proceed) {
-            throw new Error('Service creation cancelled due to deployment blockers');
-          }
-        } else {
-          console.log(chalk.yellow('⚠️  Proceeding with generation despite blockers (non-interactive mode)'));
-        }
-      } else {
-        console.log(chalk.green('✅ No deployment blockers detected'));
-      }
-      return assessment;
-    } catch (error) {
-      console.log(chalk.yellow(`⚠️  Final assessment failed: ${error.message}`));
-      console.log(chalk.gray('Continuing with service generation...'));
-      return null;
-    }
-  }
-
   /**
    * Escape special regex characters for safe replacement
    */
   escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   }
-
-  /**
-   * Run pre-deploy assessment to validate deployment readiness
-   */
-  async runPreDeployAssessment(deployConfig) {
-    console.log(chalk.yellow('🔍 Running Pre-Deploy Assessment...'));
-    try {
-      // Create assessment engine
-      const assessmentEngine = new CapabilityAssessmentEngine(this.outputPath, {
-        cacheEnabled: true,
-        cache: {
-          ttl: 10 * 60 * 1000
-        } // 10 minutes for deploy assessment
-      });
-
-      // Run assessment
-      const assessment = await assessmentEngine.assessCapabilities(deployConfig);
-
-      // Check for critical gaps
-      const criticalGaps = assessment.gapAnalysis.missing.filter(gap => gap.priority === 'blocked');
-      const warningGaps = assessment.gapAnalysis.missing.filter(gap => gap.priority === 'warning');
-      if (criticalGaps.length > 0) {
-        console.log(chalk.red('\n🚫 Critical Deployment Blockers:'));
-        criticalGaps.forEach(gap => {
-          console.log(chalk.red(`   • ${gap.capability}: ${gap.reason}`));
-        });
-        console.log(chalk.red('\nDeployment blocked due to critical gaps.'));
-        return {
-          ...assessment,
-          deployable: false,
-          reason: 'Critical deployment blockers detected'
-        };
-      }
-      if (warningGaps.length > 0) {
-        console.log(chalk.yellow('\n⚠️  Deployment Warnings:'));
-        warningGaps.forEach(gap => {
-          console.log(chalk.yellow(`   • ${gap.capability}: ${gap.reason}`));
-        });
-        console.log(chalk.yellow('Deployment possible but may have issues.'));
-        return {
-          ...assessment,
-          deployable: true,
-          warnings: warningGaps.length
-        };
-      }
-      console.log(chalk.green('✅ Deployment assessment passed - no blockers detected'));
-      return {
-        ...assessment,
-        deployable: true
-      };
-    } catch (error) {
-      console.log(chalk.red(`❌ Pre-deploy assessment failed: ${error.message}`));
-      throw error;
-    }
-  }
-
-  /**
-   * Deploy service with assessment integration
-   */
-  async deployService(deployOptions) {
-    console.log(chalk.cyan('🚀 Deploying Service with Assessment Integration...'));
-    const {
-      skipAssessment = false,
-      forceDeployment = false,
-      saveAssessment = false
-    } = deployOptions;
-    try {
-      // Run pre-deploy assessment unless skipped
-      if (!skipAssessment) {
-        console.log(chalk.yellow('🔍 Running Pre-Deploy Assessment...'));
-        const assessmentResult = await this.runPreDeployAssessment(deployOptions);
-
-        // Check if deployment should be blocked
-        if (!assessmentResult.deployable && !forceDeployment) {
-          console.log(chalk.red('Deployment blocked by assessment. Use --force to override.'));
-          return {
-            success: false,
-            reason: 'Assessment blocked deployment',
-            assessment: assessmentResult
-          };
-        }
-        if (assessmentResult.warnings && !forceDeployment) {
-          const proceed = await this.confirmDeploymentWithAssessment(assessmentResult);
-          if (!proceed) {
-            console.log(chalk.yellow('Deployment cancelled by user.'));
-            return {
-              success: false,
-              reason: 'User cancelled deployment',
-              assessment: assessmentResult
-            };
-          }
-        }
-
-        // Save assessment results if requested
-        if (saveAssessment) {
-          await this.saveAssessmentResults(assessmentResult, deployOptions.servicePath || this.outputPath);
-        }
-        deployOptions.assessment = assessmentResult;
-      }
-
-      // Execute deployment
-      console.log(chalk.yellow('⚙️  Executing Deployment...'));
-      const deployResult = await this.executeDeployment(deployOptions);
-      console.log(chalk.green('✅ Deployment completed successfully'));
-      return {
-        success: true,
-        deployment: deployResult
-      };
-    } catch (error) {
-      console.log(chalk.red(`❌ Deployment failed: ${error.message}`));
-      throw error;
-    }
-  }
-
-  /**
-   * Execute the actual deployment process
-   */
-  async executeDeployment(deployOptions) {
-    // This would integrate with actual deployment logic
-    // For now, return a mock successful result
-    console.log(chalk.gray('   • Validating deployment configuration...'));
-    console.log(chalk.gray('   • Uploading worker script...'));
-    console.log(chalk.gray('   • Configuring routes...'));
-    console.log(chalk.gray('   • Deployment completed'));
-    return {
-      workerId: 'mock-worker-id',
-      deploymentId: 'mock-deployment-id',
-      urls: {
-        worker: `https://${deployOptions.workerName || 'worker'}.example.com`,
-        api: `https://${deployOptions.serviceName || 'service'}.example.com`
-      },
-      timestamp: new Date().toISOString()
-    };
-  }
-
-  /**
-   * Confirm deployment with assessment warnings
-   */
-  async confirmDeploymentWithAssessment(assessmentResult) {
-    if (!this.interactive) {
-      return true; // Auto-confirm in non-interactive mode
-    }
-    if (!assessmentResult || !assessmentResult.gapAnalysis) {
-      return true; // Auto-confirm if no assessment result
-    }
-    const warnings = (assessmentResult.gapAnalysis.missing || []).filter(gap => gap.priority === 'warning');
-    const recommendations = (assessmentResult.recommendations || []).slice(0, 3);
-    console.log(chalk.yellow('\n⚠️  Assessment detected warnings:'));
-    warnings.forEach(warning => {
-      console.log(chalk.yellow(`   • ${warning.capability}: ${warning.reason}`));
-    });
-    if (recommendations.length > 0) {
-      console.log(chalk.blue('\n💡 Recommendations:'));
-      recommendations.forEach(rec => {
-        console.log(chalk.blue(`   • ${rec.action}`));
-      });
-    }
-    const proceed = await this.confirmationHandler.promptHandler.confirm('\nContinue with deployment despite warnings?', true);
-    return proceed;
-  }
-
-  /**
-   * Save assessment results for post-deploy reference
-   */
-  async saveAssessmentResults(assessment, servicePath) {
-    const assessmentFile = path.join(servicePath, '.clodo-assessment.json');
-    try {
-      await fs.writeFile(assessmentFile, JSON.stringify({
-        ...assessment,
-        savedAt: new Date().toISOString(),
-        version: '1.0'
-      }, null, 2));
-      console.log(chalk.gray(`   • Assessment results saved to ${assessmentFile}`));
-    } catch (error) {
-      console.log(chalk.yellow(`⚠️  Failed to save assessment results: ${error.message}`));
-    }
-  }
-
-  /**
-   * Load previous assessment results
-   */
-  async loadPreviousAssessment(servicePath) {
-    const assessmentFile = path.join(servicePath, '.clodo-assessment.json');
-    try {
-      const data = await fs.readFile(assessmentFile, 'utf8');
-      const assessment = JSON.parse(data);
-      console.log(chalk.gray(`   • Loaded previous assessment from ${assessmentFile}`));
-      return assessment;
-    } catch (error) {
-      console.log(chalk.yellow(`⚠️  No previous assessment found: ${error.message}`));
-      return null;
-    }
-  }
-
-  /**
-   * Create readline interface for interactive prompts
-   */
-  createReadlineInterface() {
-    // This would create a readline interface for interactive prompts
-    // For now, return null as this is handled by the confirmation handler
-    return null;
-  }
 }

package/dist/service-management/index.js

@@ -5,6 +5,10 @@
 
 export { ServiceCreator, createService } from './ServiceCreator.js';
 export { ServiceInitializer, initializeService } from './ServiceInitializer.js';
-export { AssessmentCache } from './AssessmentCache.js';
-export { CapabilityAssessmentEngine } from './CapabilityAssessmentEngine.js';
-export { ServiceAutoDiscovery } from './ServiceAutoDiscovery.js';
+
+// Assessment capabilities moved to @tamyla/clodo-orchestration
+// - AssessmentCache
+// - CapabilityAssessmentEngine
+// - ServiceAutoDiscovery
+// - Data-bridge components
+// These are only available in the professional edition (clodo-orchestration)

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

@@ -16,8 +16,13 @@ import { join, dirname } from 'path';
 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 = {
   'AUTH_JWT_SECRET': {

package/dist/worker/integration.js

@@ -1,7 +1,13 @@
 import { featureManager, COMMON_FEATURES } from '../config/features.js';
 import { getDomainFromEnv, createEnvironmentConfig } from '../config/domains.js';
-import { createLogger } from '../utils/index.js';
-const logger = createLogger('WorkerIntegration');
+
+// Simple inline logger to avoid circular dependency with index.js
+const logger = {
+  info: (message, ...args) => console.log(`[WorkerIntegration] ${message}`, ...args),
+  error: (message, ...args) => console.error(`[WorkerIntegration] ${message}`, ...args),
+  warn: (message, ...args) => console.warn(`[WorkerIntegration] ${message}`, ...args),
+  debug: (message, ...args) => console.debug(`[WorkerIntegration] ${message}`, ...args)
+};
 
 /**
  * Initializes a service with domain and feature context

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamyla/clodo-framework",
-  "version": "3.0.13",
+  "version": "3.0.15",
   "description": "Reusable framework for Clodo-style software architecture on Cloudflare Workers + D1",
   "type": "module",
   "sideEffects": [
@@ -74,7 +74,7 @@
     "clean": "rimraf dist",
     "clean:generated": "rimraf generated",
     "clean:all": "npm run clean && npm run clean:generated",
-    "test": "jest --passWithNoTests",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --passWithNoTests",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
     "lint": "eslint --config ./eslint.config.js src",
@@ -112,7 +112,7 @@
     "modular"
   ],
   "author": "Tamyla",
-  "license": "GPL-3.0-or-later",
+  "license": "MIT",
   "dependencies": {
     "@iarna/toml": "^2.2.5",
     "chalk": "^5.3.0",
@@ -129,6 +129,7 @@
     "@semantic-release/git": "^10.0.1",
     "@types/node": "^20.19.19",
     "babel-plugin-transform-import-meta": "^2.3.3",
+    "cross-env": "^10.1.0",
     "eslint": "^8.54.0",
     "jest": "^29.7.0",
     "rimraf": "^5.0.10",
@@ -148,6 +149,7 @@
   "homepage": "https://clodo-framework.tamyla.com",
   "release": {
     "branches": [
+      "main",
       "master"
     ],
     "plugins": [

package/dist/service-management/AssessmentCache.js

@@ -1,303 +0,0 @@
-/**
- * Assessment Cache System
- *
- * Caches assessment results to avoid redundant analysis of project artifacts.
- * Provides intelligent cache invalidation based on file changes and time-based expiration.
- */
-
-import crypto from 'crypto';
-import fs from 'fs/promises';
-import path from 'path';
-import { existsSync } from 'fs';
-export class AssessmentCache {
-  constructor(options = {}) {
-    this.cacheDir = options.cacheDir || './.clodo-cache/assessment';
-    this.ttl = options.ttl || 5 * 60 * 1000; // 5 minutes default
-    this.maxEntries = options.maxEntries || 50;
-    this.enableDiskCache = options.enableDiskCache !== false;
-    this.memoryCache = new Map();
-    this.initialized = false;
-  }
-
-  /**
-   * Initialize the cache system
-   */
-  async initialize() {
-    if (this.initialized) return;
-    if (this.enableDiskCache) {
-      await this.ensureCacheDirectory();
-      await this.loadFromDisk();
-    }
-    this.initialized = true;
-  }
-
-  /**
-   * Generate cache key from project state and inputs
-   */
-  async generateCacheKey(projectPath, inputs = {}) {
-    const keyData = {
-      projectPath: path.resolve(projectPath),
-      inputs: this.sanitizeInputs(inputs),
-      projectFiles: await this.getProjectFileHashes(projectPath)
-    };
-    const keyString = JSON.stringify(keyData, Object.keys(keyData).sort());
-    return crypto.createHash('sha256').update(keyString).digest('hex');
-  }
-
-  /**
-   * Sanitize inputs for cache key generation (remove sensitive data)
-   */
-  sanitizeInputs(inputs) {
-    const sanitized = {
-      ...inputs
-    };
-
-    // Remove sensitive fields but keep their presence for cache invalidation
-    const sensitiveFields = ['apiToken', 'cloudflareToken', 'token', 'secret', 'password'];
-    sensitiveFields.forEach(field => {
-      if (sanitized[field]) {
-        sanitized[field] = 'present'; // Just mark presence, not value
-      }
-    });
-    return sanitized;
-  }
-
-  /**
-   * Get hashes of relevant project files for cache invalidation
-   */
-  async getProjectFileHashes(projectPath) {
-    const relevantFiles = ['package.json', 'wrangler.toml', 'src/index.js', 'src/worker.js', 'dist/index.js'];
-    const hashes = {};
-    for (const file of relevantFiles) {
-      const filePath = path.join(projectPath, file);
-      try {
-        const stats = await fs.stat(filePath);
-        const content = await fs.readFile(filePath, 'utf8');
-        hashes[file] = {
-          mtime: stats.mtime.getTime(),
-          size: stats.size,
-          hash: crypto.createHash('md5').update(content).digest('hex').substring(0, 8)
-        };
-      } catch (error) {
-        // File doesn't exist, that's fine
-        hashes[file] = null;
-      }
-    }
-    return hashes;
-  }
-
-  /**
-   * Get cached assessment result
-   */
-  async get(cacheKey) {
-    await this.initialize();
-
-    // Check memory cache first
-    const memoryEntry = this.memoryCache.get(cacheKey);
-    if (memoryEntry && !this.isExpired(memoryEntry)) {
-      return memoryEntry.data;
-    }
-
-    // Check disk cache if enabled
-    if (this.enableDiskCache) {
-      const diskEntry = await this.loadFromDiskCache(cacheKey);
-      if (diskEntry && !this.isExpired(diskEntry)) {
-        // Restore to memory cache
-        this.memoryCache.set(cacheKey, diskEntry);
-        return diskEntry.data;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Store assessment result in cache
-   */
-  async set(cacheKey, data) {
-    await this.initialize();
-    const entry = {
-      data,
-      timestamp: Date.now(),
-      key: cacheKey
-    };
-
-    // Store in memory
-    this.memoryCache.set(cacheKey, entry);
-
-    // Store on disk if enabled
-    if (this.enableDiskCache) {
-      await this.saveToDiskCache(cacheKey, entry);
-    }
-
-    // Maintain cache size limits
-    await this.cleanup();
-  }
-
-  /**
-   * Check if cache entry is expired
-   */
-  isExpired(entry) {
-    return Date.now() - entry.timestamp > this.ttl;
-  }
-
-  /**
-   * Clear expired entries and maintain size limits
-   */
-  async cleanup() {
-    const now = Date.now();
-    const validEntries = new Map();
-
-    // Clean memory cache
-    for (const [key, entry] of this.memoryCache) {
-      if (!this.isExpired(entry)) {
-        validEntries.set(key, entry);
-      }
-    }
-
-    // If still too many entries, remove oldest
-    if (validEntries.size > this.maxEntries) {
-      const sortedEntries = Array.from(validEntries.entries()).sort((a, b) => a[1].timestamp - b[1].timestamp);
-      const toKeep = sortedEntries.slice(-this.maxEntries);
-      validEntries.clear();
-      toKeep.forEach(([key, entry]) => validEntries.set(key, entry));
-    }
-    this.memoryCache = validEntries;
-
-    // Clean disk cache
-    if (this.enableDiskCache) {
-      await this.cleanupDiskCache();
-    }
-  }
-
-  /**
-   * Clear all cache entries
-   */
-  async clear() {
-    this.memoryCache.clear();
-    if (this.enableDiskCache) {
-      await this.clearDiskCache();
-    }
-  }
-
-  /**
-   * Get cache statistics
-   */
-  async getStats() {
-    const now = Date.now();
-    const memoryEntries = Array.from(this.memoryCache.values());
-    return {
-      memory: {
-        total: memoryEntries.length,
-        valid: memoryEntries.filter(entry => !this.isExpired(entry)).length,
-        expired: memoryEntries.filter(entry => this.isExpired(entry)).length
-      },
-      disk: this.enableDiskCache ? await this.getDiskStats() : null,
-      ttl: this.ttl,
-      maxEntries: this.maxEntries
-    };
-  }
-
-  // Disk cache implementation
-  async ensureCacheDirectory() {
-    try {
-      await fs.mkdir(this.cacheDir, {
-        recursive: true
-      });
-    } catch (error) {
-      // Directory might already exist, ignore
-    }
-  }
-  getCacheFilePath(key) {
-    return path.join(this.cacheDir, `${key}.json`);
-  }
-  async saveToDiskCache(key, entry) {
-    try {
-      const filePath = this.getCacheFilePath(key);
-      await fs.writeFile(filePath, JSON.stringify(entry, null, 2));
-    } catch (error) {
-      // Disk cache failure shouldn't break functionality
-      console.warn('Failed to save to disk cache:', error.message);
-    }
-  }
-  async loadFromDiskCache(key) {
-    try {
-      const filePath = this.getCacheFilePath(key);
-      const content = await fs.readFile(filePath, 'utf8');
-      return JSON.parse(content);
-    } catch (error) {
-      return null;
-    }
-  }
-  async loadFromDisk() {
-    try {
-      const files = await fs.readdir(this.cacheDir);
-      const cacheFiles = files.filter(file => file.endsWith('.json'));
-      for (const file of cacheFiles) {
-        const key = file.replace('.json', '');
-        const entry = await this.loadFromDiskCache(key);
-        if (entry && !this.isExpired(entry)) {
-          this.memoryCache.set(key, entry);
-        }
-      }
-    } catch (error) {
-      // Disk cache loading failure is not critical
-    }
-  }
-  async cleanupDiskCache() {
-    try {
-      const files = await fs.readdir(this.cacheDir);
-      const cacheFiles = files.filter(file => file.endsWith('.json'));
-      for (const file of cacheFiles) {
-        const key = file.replace('.json', '');
-        const entry = await this.loadFromDiskCache(key);
-        if (!entry || this.isExpired(entry)) {
-          await fs.unlink(path.join(this.cacheDir, file));
-        }
-      }
-    } catch (error) {
-      // Cleanup failure is not critical
-    }
-  }
-  async clearDiskCache() {
-    try {
-      const files = await fs.readdir(this.cacheDir);
-      for (const file of files) {
-        if (file.endsWith('.json')) {
-          await fs.unlink(path.join(this.cacheDir, file));
-        }
-      }
-    } catch (error) {
-      // Clear failure is not critical
-    }
-  }
-  async getDiskStats() {
-    try {
-      const files = await fs.readdir(this.cacheDir);
-      const cacheFiles = files.filter(file => file.endsWith('.json'));
-      let valid = 0;
-      let expired = 0;
-      for (const file of cacheFiles) {
-        const key = file.replace('.json', '');
-        const entry = await this.loadFromDiskCache(key);
-        if (entry) {
-          if (this.isExpired(entry)) {
-            expired++;
-          } else {
-            valid++;
-          }
-        }
-      }
-      return {
-        total: cacheFiles.length,
-        valid,
-        expired
-      };
-    } catch (error) {
-      return {
-        total: 0,
-        valid: 0,
-        expired: 0
-      };
-    }
-  }
-}