@tamyla/clodo-framework 3.0.11 → 3.0.13

package/dist/service-management/ConfirmationEngine.js

@@ -81,10 +81,10 @@ export class ConfirmationEngine {
       version: '1.0.0',
       // 4. Author - Default framework author
       author: 'Clodo Framework',
-      // 5-7. URLs - Derived from domain
-      productionUrl: `https://api.${domainName}`,
-      stagingUrl: `https://staging-api.${domainName}`,
-      developmentUrl: `https://dev-api.${domainName}`,
+      // 5-7. URLs - Derived from domain and service name
+      productionUrl: `https://${serviceName}.${domainName}`,
+      stagingUrl: `https://${serviceName}-staging.${domainName}`,
+      developmentUrl: `https://${serviceName}-dev.${domainName}`,
       // 8. Features - Based on service type
       features: this.generateFeaturesForType(serviceType),
       // 9. Database Name - Cloudflare D1 naming

package/dist/service-management/InputCollector.js

@@ -15,6 +15,7 @@ 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';
 export class InputCollector {
   constructor(options = {}) {
     this.interactive = options.interactive !== false;
@@ -80,6 +81,11 @@ export class InputCollector {
           source: 'user-provided',
           required: true
         };
+
+        // Run assessment after API token is collected
+        if (inputDef.id === 'cloudflare-api-token' && value) {
+          await this.runDeploymentReadinessAssessment(result.coreInputs);
+        }
       }
     }
 
@@ -158,9 +164,9 @@ export class InputCollector {
       case 'production-url':
         return domainName ? `https://api.${domainName}` : '';
       case 'staging-url':
-        return domainName ? `https://staging-api.${domainName}` : '';
+        return domainName && serviceName ? `https://${serviceName}-staging.${domainName}` : '';
       case 'development-url':
-        return domainName ? `https://dev-api.${domainName}` : '';
+        return domainName && serviceName ? `https://${serviceName}-dev.${domainName}` : '';
       case 'service-directory':
         return serviceName ? `./services/${serviceName}` : '';
       case 'database-name':
@@ -386,8 +392,25 @@ export class InputCollector {
             CloudflareAPI
           } = await import('../utils/cloudflare/api.js');
           const cfApi = new CloudflareAPI(token);
-          const isValid = await cfApi.verifyToken();
-          if (isValid) {
+          const tokenCheck = await cfApi.verifyToken();
+          if (tokenCheck.valid) {
+            // Check D1 permissions
+            const permissionCheck = await cfApi.checkD1Permissions();
+            if (!permissionCheck.hasPermission) {
+              console.log(chalk.yellow(`⚠️  ${permissionCheck.error}`));
+              console.log(chalk.white('   💡 You can update permissions at: https://dash.cloudflare.com/profile/api-tokens'));
+              console.log(chalk.white('   💡 Or continue and the framework will fall back to OAuth authentication'));
+              console.log('');
+              const {
+                askYesNo
+              } = await import('../utils/interactive-prompts.js');
+              const continueAnyway = await askYesNo('Continue with limited API token permissions?', false);
+              if (!continueAnyway) {
+                console.log(chalk.blue('Please update your API token permissions and try again.'));
+                process.exit(0);
+              }
+              console.log(chalk.yellow('⚠️  Proceeding with limited permissions - database operations will use OAuth'));
+            }
             console.log(chalk.green('✓ API token verified successfully'));
             return token;
           }
@@ -556,6 +579,98 @@ 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
    */