@tamyla/clodo-framework 4.4.0 → 4.5.0

package/dist/service-management/generators/code/WorkerIndexGenerator.js

@@ -59,121 +59,264 @@ export class WorkerIndexGenerator extends BaseGenerator {
 
   /**
    * Build the complete worker index.js content
+   * 
+   * v4.4.1+: Generates code that imports directly from @tamyla/clodo-framework
+   * using EnhancedRouter, composeMiddleware, createEnvironmentGuard, and
+   * middleware factories — NOT the old MiddlewareRegistry/Composer pattern.
    */
   _buildWorkerIndex(coreInputs, confirmedValues) {
+    const features = confirmedValues.features || {};
+    const serviceName = coreInputs.serviceName;
+    const serviceType = coreInputs.serviceType;
+
+    // Determine which env bindings are required based on features
+    const requiredBindings = [];
+    const optionalBindings = ['DEBUG'];
+    if (features.d1 || features.database) requiredBindings.push('DB');
+    if (features.kv || features.upstash) requiredBindings.push('KV');
+    if (features.r2) requiredBindings.push('R2_STORAGE');
+    if (features.ai) requiredBindings.push('AI');
+    if (features.vectorize) requiredBindings.push('VECTORIZE_INDEX');
+    if (features.queues) requiredBindings.push('QUEUE');
+    if (features.email) requiredBindings.push('EMAIL');
+    if (features.hyperdrive) requiredBindings.push('HYPERDRIVE');
+    if (features.durableObject || features.durableObjects) requiredBindings.push('DURABLE_OBJECT');
+
+    // Build framework imports
+    const frameworkImports = ['createEnhancedRouter', 'createCorsMiddleware', 'createErrorHandler', 'createLogger', 'composeMiddleware', 'createEnvironmentGuard'];
+    if (features.rateLimiting) frameworkImports.push('createRateLimitGuard');
+
+    // Build utility imports based on features
+    const utilityImports = [];
+    if (features.kv || features.upstash) utilityImports.push('getKV', 'putKV', 'listKV', 'deleteKV');
+    if (features.r2) utilityImports.push('putR2Object', 'getR2Object');
+    if (features.ai) utilityImports.push('runAIModel', 'streamAIResponse');
+
+    // Build route stubs based on service type
+    const routeStubs = this._buildRouteStubs(coreInputs, confirmedValues, features);
+
+    // Build queue handler if queues feature is enabled
+    const queueHandler = features.queues ? this._buildQueueHandler(serviceName) : '';
+
+    // Build cron handler if cron feature is enabled
+    const cronHandler = features.cron ? this._buildCronHandler(serviceName) : '';
     return `/**
  * ${confirmedValues.displayName} - Cloudflare Worker
  *
- * Generated by Clodo Framework GenerationEngine
- * Service Type: ${coreInputs.serviceType}
+ * Generated by Clodo Framework v4.4.1
+ * Service Type: ${serviceType}
  */
 
-import { domains } from '../config/domains.js';
-import { createServiceHandlers } from '../handlers/service-handlers.js';
-import { MiddlewareRegistry, MiddlewareComposer } from '../middleware/runtime.js';
-import * as Shared from '../middleware/shared/index.js';
+import {
+  ${frameworkImports.join(',\n  ')}
+} from '@tamyla/clodo-framework';
+${utilityImports.length > 0 ? `\nimport { ${utilityImports.join(', ')} } from '@tamyla/clodo-framework/utilities';\n` : ''}
+// ── Environment validation ────────────────────────────────────────────
+const envGuard = createEnvironmentGuard({
+  required: [${requiredBindings.map(b => `'${b}'`).join(', ')}],
+  optional: [${optionalBindings.map(b => `'${b}'`).join(', ')}]
+});
+
+// ── Middleware stack ──────────────────────────────────────────────────
+const middleware = composeMiddleware(
+  createCorsMiddleware({ origins: ['*'] }),
+  createLogger({ prefix: '${serviceName}', level: 'info' }),${features.rateLimiting ? `\n  createRateLimitGuard({ maxRequests: 100, windowMs: 60000 }),` : ''}
+  createErrorHandler({ includeStack: false })
+);
 
+// ── Router ────────────────────────────────────────────────────────────
+const router = createEnhancedRouter(${features.d1 || features.database ? 'null /* D1 injected per-request via env.DB */' : 'null'}, {
+  autoRegisterGenericRoutes: false
+});
+
+// Health check
+router.get('${confirmedValues.healthCheckPath || '/health'}', (c) => {
+  return c.json({
+    status: 'healthy',
+    service: '${serviceName}',
+    version: '${confirmedValues.version}',
+    timestamp: new Date().toISOString()
+  });
+});
+
+${routeStubs}
+
+// ── Worker entry point ────────────────────────────────────────────────
 export default {
   async fetch(request, env, ctx) {
-    try {
-      // Get service configuration
-      const serviceConfig = domains['${coreInputs.serviceName}'];
+    envGuard.check(env);
+    const url = new URL(request.url);
 
-      // Build shared middleware instances
-      const sharedMiddlewares = [
-        Shared.cors({ origin: serviceConfig.corsPolicy || '*' }),
-        Shared.logging({ level: serviceConfig.logLevel || 'info' })
-      ];
+    return middleware.execute(request, () =>
+      router.handleRequest(request.method, url.pathname, request, env, ctx)
+    );
+  }${queueHandler}${cronHandler}
+};
+`;
+  }
 
-      // Lazy-load service middleware and support legacy factory compatibility
-      let serviceMiddlewareInstance = null;
-      let legacyFactory = null;
+  /**
+   * Generate route stubs based on service type and features
+   */
+  _buildRouteStubs(coreInputs, confirmedValues, features) {
+    const apiBase = confirmedValues.apiBasePath || '/api/v1';
+    const serviceType = coreInputs.serviceType;
 
-      try {
-        const mod = await import('../middleware/service-middleware.js');
-
-        if (mod?.registerMiddleware) {
-          // New-style registration helper
-          mod.registerMiddleware(MiddlewareRegistry, serviceConfig.name);
-          serviceMiddlewareInstance = MiddlewareRegistry.get(serviceConfig.name);
-        } else if (mod?.default) {
-          const def = mod.default;
-          // If the default is a class (constructor), instantiate and register
-          if (typeof def === 'function' && def.prototype) {
-            try {
-              const instance = new def();
-              MiddlewareRegistry.register(serviceConfig.name, instance);
-              serviceMiddlewareInstance = instance;
-            } catch (e) {
-              // ignore instantiation errors
-            }
-          } else if (typeof def === 'function') {
-            // Legacy factory exported as default
-            legacyFactory = def;
-          }
-        } else if (mod?.createServiceMiddleware) {
-          legacyFactory = mod.createServiceMiddleware;
-        }
-      } catch (e) {
-        // No service-specific middleware found - continue with shared only
-      }
+    // REST API routes with KV
+    if ((features.kv || features.upstash) && !features.d1) {
+      return `// ── API Routes (KV-backed) ─────────────────────────────────────────────
 
-      // Compose final middleware chain
-      let chain;
-
-      if (legacyFactory) {
-        const legacyInstance = legacyFactory(serviceConfig, env);
-        const adapter = {
-          preprocess: async (req) => {
-            if (legacyInstance && typeof legacyInstance.processRequest === 'function') {
-              const processed = await legacyInstance.processRequest(req);
-              if (processed instanceof Response) return processed; // short-circuit
-              return null; // continue (legacy returns a Request)
-            }
-            return null;
-          },
-          postprocess: async (res) => {
-            if (legacyInstance && typeof legacyInstance.processResponse === 'function') {
-              const r = await legacyInstance.processResponse(res);
-              return r instanceof Response ? r : res;
-            }
-            return res;
-          }
-        };
-
-        chain = MiddlewareComposer.compose(...sharedMiddlewares, adapter);
-      } else {
-        const svcMw = serviceMiddlewareInstance || MiddlewareRegistry.get(serviceConfig.name);
-        chain = MiddlewareComposer.compose(...sharedMiddlewares, svcMw);
-      }
+router.get('${apiBase}/items', async (c) => {
+  const list = await listKV(c.env.KV, { prefix: 'item:' });
+  const items = await Promise.all(
+    (list.keys || []).map(async (k) => getKV(c.env.KV, k.name, { type: 'json' }))
+  );
+  return c.json({ items: items.filter(Boolean), count: items.length });
+});
+
+router.get('${apiBase}/items/:id', async (c) => {
+  const id = c.req.param('id');
+  const item = await getKV(c.env.KV, \`item:\${id}\`, { type: 'json' });
+  if (!item) return c.json({ error: 'Not found' }, 404);
+  return c.json(item);
+});
 
-      // Execute middleware chain with final handler
-      const response = await chain.execute(request, async (req) => {
-        const handlers = createServiceHandlers(serviceConfig, env);
-        return handlers.handleRequest(req, ctx);
-      });
-
-      return response;
-
-    } catch (error) {
-      console.error('Worker error:', error);
-
-      return new Response(JSON.stringify({
-        error: 'Internal Server Error',
-        message: error.message,
-        timestamp: new Date().toISOString()
-      }), {
-        status: 500,
-        headers: {
-          'Content-Type': 'application/json',
-          'X-Service': '${coreInputs.serviceName}',
-          'X-Version': '${confirmedValues.version}'
-        }
-      });
+router.post('${apiBase}/items', async (c) => {
+  const body = await c.req.json();
+  const id = crypto.randomUUID();
+  const item = { id, ...body, createdAt: new Date().toISOString() };
+  await putKV(c.env.KV, \`item:\${id}\`, JSON.stringify(item));
+  return c.json(item, 201);
+});
+
+router.put('${apiBase}/items/:id', async (c) => {
+  const id = c.req.param('id');
+  const existing = await getKV(c.env.KV, \`item:\${id}\`, { type: 'json' });
+  if (!existing) return c.json({ error: 'Not found' }, 404);
+  const body = await c.req.json();
+  const updated = { ...existing, ...body, id, updatedAt: new Date().toISOString() };
+  await putKV(c.env.KV, \`item:\${id}\`, JSON.stringify(updated));
+  return c.json(updated);
+});
+
+router.delete('${apiBase}/items/:id', async (c) => {
+  const id = c.req.param('id');
+  await deleteKV(c.env.KV, \`item:\${id}\`);
+  return c.json({ deleted: true, id });
+});`;
     }
+
+    // D1-backed routes
+    if (features.d1 || features.database) {
+      return `// ── API Routes (D1-backed) ─────────────────────────────────────────────
+
+router.get('${apiBase}/items', async (c) => {
+  const { results } = await c.env.DB.prepare('SELECT * FROM items ORDER BY created_at DESC LIMIT 50').all();
+  return c.json({ items: results, count: results.length });
+});
+
+router.get('${apiBase}/items/:id', async (c) => {
+  const id = c.req.param('id');
+  const item = await c.env.DB.prepare('SELECT * FROM items WHERE id = ?').bind(id).first();
+  if (!item) return c.json({ error: 'Not found' }, 404);
+  return c.json(item);
+});
+
+router.post('${apiBase}/items', async (c) => {
+  const body = await c.req.json();
+  const id = crypto.randomUUID();
+  await c.env.DB.prepare('INSERT INTO items (id, name, data, created_at) VALUES (?, ?, ?, ?)')
+    .bind(id, body.name, JSON.stringify(body.data || {}), new Date().toISOString())
+    .run();
+  return c.json({ id, ...body, createdAt: new Date().toISOString() }, 201);
+});
+
+router.delete('${apiBase}/items/:id', async (c) => {
+  const id = c.req.param('id');
+  await c.env.DB.prepare('DELETE FROM items WHERE id = ?').bind(id).run();
+  return c.json({ deleted: true, id });
+});`;
+    }
+
+    // AI worker routes
+    if (features.ai) {
+      return `// ── AI Routes ─────────────────────────────────────────────────────────
+
+router.post('${apiBase}/chat', async (c) => {
+  const { messages, model } = await c.req.json();
+  const result = await runAIModel(c.env.AI, model || '@cf/meta/llama-3.1-8b-instruct', {
+    messages: messages || []
+  });
+  return c.json({ response: result.response });
+});
+
+router.post('${apiBase}/chat/stream', async (c) => {
+  const { messages, model } = await c.req.json();
+  const stream = await runAIModel(c.env.AI, model || '@cf/meta/llama-3.1-8b-instruct', {
+    messages: messages || [], stream: true
+  });
+  return streamAIResponse(stream);
+});
+
+router.get('${apiBase}/models', (c) => {
+  return c.json({
+    models: [
+      { name: 'llama-3.1-8b-instruct', type: 'chat' },
+      { name: 'bge-base-en-v1.5', type: 'embeddings' }
+    ]
+  });
+});`;
+    }
+
+    // Default minimal routes
+    return `// ── API Routes ─────────────────────────────────────────────────────────
+
+router.get('${apiBase}/status', (c) => {
+  return c.json({
+    service: '${coreInputs.serviceName}',
+    status: 'running',
+    timestamp: new Date().toISOString()
+  });
+});
+
+// Add your routes here:
+// router.get('${apiBase}/items', async (c) => { ... });
+// router.post('${apiBase}/items', async (c) => { ... });`;
   }
-};
-`;
+
+  /**
+   * Build queue consumer handler
+   */
+  _buildQueueHandler(serviceName) {
+    return `,
+
+  // Queue consumer handler
+  async queue(batch, env, ctx) {
+    console.log(\`[${serviceName}] Processing batch of \${batch.messages.length} messages\`);
+    for (const message of batch.messages) {
+      try {
+        console.log('Processing:', message.body);
+        // Add your message processing logic here
+        message.ack();
+      } catch (error) {
+        console.error('Message processing failed:', error.message);
+        message.retry();
+      }
+    }
+  }`;
+  }
+
+  /**
+   * Build cron/scheduled handler
+   */
+  _buildCronHandler(serviceName) {
+    return `,
+
+  // Scheduled (cron) handler
+  async scheduled(event, env, ctx) {
+    console.log(\`[${serviceName}] Cron triggered: \${event.cron} at \${new Date(event.scheduledTime).toISOString()}\`);
+    // Add your scheduled job logic here
+  }`;
   }
 
   /**

package/dist/service-management/generators/config/WranglerTomlGenerator.js

@@ -1,23 +1,18 @@
 import { BaseGenerator } from '../BaseGenerator.js';
-import { WranglerCompatibilityDetector } from '../../../lib/shared/utils/wrangler-compatibility.js';
 import { join } from 'path';
 
 /**
- * WranglerTomlGenerator
+ * WranglerTomlGenerator (v4.4.1+)
  * 
  * Generates wrangler.toml configuration files for Cloudflare Workers.
  * 
- * Responsibilities:
- * - Generate main worker configuration (name, main, compatibility)
- * - Include routes configuration from RouteGenerator
- * - Include Workers Sites configuration from SiteConfigGenerator
- * - Configure environment-specific settings (dev/staging/production)
- * - Configure D1 database bindings
- * - Configure environment variables and feature flags
- * 
- * Dependencies:
- * - RouteGenerator (for routes configuration)
- * - SiteConfigGenerator (for Workers Sites configuration)
+ * v4.4.1 changes:
+ * - Supports ALL modern Cloudflare bindings: D1, KV, R2, AI, Vectorize,
+ *   Queues, Email, Hyperdrive, Browser, Durable Objects, Analytics Engine
+ * - Uses RECOMMENDED_COMPATIBILITY_DATE from framework
+ * - Generates empty IDs for auto-provisioning in local dev (Wrangler 3.91+)
+ * - Includes [observability] defaults
+ * - Clean comments explaining each binding
  */
 export class WranglerTomlGenerator extends BaseGenerator {
   constructor(options = {}) {
@@ -114,109 +109,155 @@ export class WranglerTomlGenerator extends BaseGenerator {
   }
 
   /**
-   * Build the complete wrangler.toml content
+   * Build the complete wrangler.toml content (v4.4.1+)
+   * Supports all modern Cloudflare bindings.
    */
   async _buildWranglerToml(coreInputs, confirmedValues, routesConfig, siteConfig) {
-    const compatDate = new Date().toISOString().split('T')[0];
+    const compatDate = '2024-12-01'; // Framework recommended compatibility date
 
-    // Detect Wrangler version and get optimal compatibility config
-    let compatibilityString = 'compatibility_flags = ["nodejs_compat"]';
-    let buildString = '\n\n[build]\ncommand = "npm run build"\n\n[build.upload]\nformat = "modules"\n\n[build.upload.external]\ninclude = ["node:*"]';
-    try {
-      const compatibilityDetector = new WranglerCompatibilityDetector();
-      const wranglerVersion = await Promise.race([compatibilityDetector.detectVersion(), new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), 2000)) // 2 second timeout
-      ]);
-      const compatibilityConfig = compatibilityDetector.getOptimalConfig(wranglerVersion);
-      const buildConfig = compatibilityDetector.getBuildConfig(wranglerVersion);
+    const features = confirmedValues.features || {};
+    const workerName = confirmedValues.workerName || coreInputs.serviceName;
 
-      // Build compatibility flags string
-      if (compatibilityConfig.nodejs_compat !== undefined) {
-        compatibilityString = `nodejs_compat = ${compatibilityConfig.nodejs_compat}`;
-      } else if (compatibilityConfig.compatibility_flags) {
-        compatibilityString = `compatibility_flags = ${JSON.stringify(compatibilityConfig.compatibility_flags)}`;
-      }
+    // ── Binding blocks based on features ──────────────────────────────
 
-      // Add any additional build config from detector (if needed)
-      if (buildConfig.command && buildConfig.command !== "npm run build") {
-        buildString += `\n\n# Additional build config from Wrangler ${wranglerVersion}\n[build.v${wranglerVersion.split('.')[0]}]\ncommand = "${buildConfig.command}"`;
-      }
-      if (buildConfig.upload && buildConfig.upload.format && buildConfig.upload.format !== "modules") {
-        buildString += `\nformat_override = "${buildConfig.upload.format}"`;
-      }
-    } catch (error) {
-      // Fall back to default configuration if detection fails
-      console.warn(`⚠️  Wrangler compatibility detection failed, using defaults: ${error.message}`);
-    }
-
-    // Only include D1/kv/r2 bindings when the confirmed values indicate features are enabled
-    const d1Block = confirmedValues.features && confirmedValues.features.d1 ? `
-
-# Database bindings
+    const bindingBlocks = [];
+    if (features.d1 || features.database) {
+      bindingBlocks.push(`
+# ═══ D1 Database ═══════════════════════════════════════════════════
+# Local: Leave database_id empty for auto-provisioned SQLite
+# Production: Run \`wrangler d1 create ${confirmedValues.databaseName || workerName + '-db'}\` and paste ID
 [[d1_databases]]
 binding = "DB"
-database_name = "${confirmedValues.databaseName}"
-database_id = ""  # To be configured during setup
-` : '';
-
-    // Support both generic KV flag and provider-specific flag (upstash)
-    const kvEnabled = confirmedValues.features && (confirmedValues.features.kv || confirmedValues.features.upstash);
-    const kvBlock = kvEnabled ? `
-
-# KV namespaces
+database_name = "${confirmedValues.databaseName || workerName + '-db'}"
+database_id = ""`);
+    }
+    if (features.kv || features.upstash) {
+      bindingBlocks.push(`
+# ═══ KV Namespace ══════════════════════════════════════════════════
+# Local: Leave id empty for auto-provisioned local KV
+# Production: Run \`wrangler kv namespace create KV\` and paste ID
 [[kv_namespaces]]
 binding = "KV"
-namespace_id = ""  # To be configured during setup
-` : '';
-    const r2Block = confirmedValues.features && confirmedValues.features.r2 ? `
-
-# R2 buckets
+id = ""`);
+    }
+    if (features.r2) {
+      bindingBlocks.push(`
+# ═══ R2 Object Storage ═════════════════════════════════════════════
+# Production: Run \`wrangler r2 bucket create ${workerName}-storage\`
 [[r2_buckets]]
 binding = "R2_STORAGE"
-bucket_name = "${confirmedValues.bucketName || confirmedValues.databaseName || ''}"
-bucket_id = ""  # To be configured during setup
+bucket_name = "${confirmedValues.bucketName || workerName + '-storage'}"`);
+    }
+    if (features.ai) {
+      bindingBlocks.push(`
+# ═══ Workers AI ════════════════════════════════════════════════════
+[ai]
+binding = "AI"`);
+    }
+    if (features.vectorize) {
+      bindingBlocks.push(`
+# ═══ Vectorize (Vector Database) ═══════════════════════════════════
+# Production: Run \`wrangler vectorize create ${workerName}-index --dimensions 768 --metric cosine\`
+[[vectorize]]
+binding = "VECTORIZE_INDEX"
+index_name = "${workerName}-index"`);
+    }
+    if (features.queues) {
+      bindingBlocks.push(`
+# ═══ Queues ════════════════════════════════════════════════════════
+[[queues.producers]]
+binding = "QUEUE"
+queue = "${workerName}-queue"
+
+[[queues.consumers]]
+queue = "${workerName}-queue"
+max_batch_size = 10
+max_batch_timeout = 30
+max_retries = 3
+dead_letter_queue = "${workerName}-queue-dlq"`);
+    }
+    if (features.email) {
+      bindingBlocks.push(`
+# ═══ Email Workers ═════════════════════════════════════════════════
+[send_email]
+binding = "EMAIL"`);
+    }
+    if (features.hyperdrive) {
+      bindingBlocks.push(`
+# ═══ Hyperdrive (Postgres Connection Pool) ═════════════════════════
+# Production: Run \`wrangler hyperdrive create ${workerName}-db --connection-string "postgres://..."\`
+[[hyperdrive]]
+binding = "HYPERDRIVE"
+id = ""`);
+    }
+    if (features.browser) {
+      bindingBlocks.push(`
+# ═══ Browser Rendering ═════════════════════════════════════════════
+[browser]
+binding = "BROWSER"`);
+    }
+    if (features.durableObject || features.durableObjects) {
+      bindingBlocks.push(`
+# ═══ Durable Objects ══════════════════════════════════════════════
+[[durable_objects.bindings]]
+name = "DURABLE_OBJECT"
+class_name = "MyDurableObject"
+
+[[migrations]]
+tag = "v1"
+new_classes = ["MyDurableObject"]`);
+    }
+    if (features.analytics) {
+      bindingBlocks.push(`
+# ═══ Analytics Engine ══════════════════════════════════════════════
+[[analytics_engine_datasets]]
+binding = "ANALYTICS"
+dataset = "${workerName}-analytics"`);
+    }
+
+    // ── Cron triggers ─────────────────────────────────────────────────
+    const cronBlock = features.cron ? `
+# ═══ Cron Triggers ═════════════════════════════════════════════════
+[triggers]
+crons = ["*/5 * * * *"]  # Every 5 minutes — customize as needed
 ` : '';
-    return `# Cloudflare Workers Configuration for ${confirmedValues.displayName}
-name = "${confirmedValues.workerName}"
+    return `# ═══════════════════════════════════════════════════════════════════
+# ${confirmedValues.displayName} — Cloudflare Worker Configuration
+# Generated by Clodo Framework v4.4.1
+# ═══════════════════════════════════════════════════════════════════
+name = "${workerName}"
 main = "src/worker/index.js"
 compatibility_date = "${compatDate}"
-${compatibilityString}${buildString}
+compatibility_flags = ["nodejs_compat"]
 
 # Account configuration
-account_id = "${coreInputs.cloudflareAccountId}"
+account_id = "${coreInputs.cloudflareAccountId || ''}"
 
-${routesConfig}
-${siteConfig ? '\n' + siteConfig : ''}
-
-# Environment configurations
+${routesConfig}${siteConfig ? '\n' + siteConfig : ''}
+# ═══ Environment configurations ════════════════════════════════════
 [env.development]
-name = "${confirmedValues.workerName}-dev"
+name = "${workerName}-dev"
 
 [env.staging]
-name = "${confirmedValues.workerName}-staging"
+name = "${workerName}-staging"
 
 [env.production]
-name = "${confirmedValues.workerName}"
-
-${d1Block}${kvBlock}${r2Block}
-# Environment variables
+name = "${workerName}"
+${bindingBlocks.join('\n')}
+${cronBlock}
+# ═══ Environment variables ═════════════════════════════════════════
 [vars]
 SERVICE_NAME = "${coreInputs.serviceName}"
 SERVICE_TYPE = "${coreInputs.serviceType}"
-DOMAIN_NAME = "${coreInputs.domainName}"
-ENVIRONMENT = "${coreInputs.environment}"
-API_BASE_PATH = "${confirmedValues.apiBasePath}"
-HEALTH_CHECK_PATH = "${confirmedValues.healthCheckPath}"
-
-# Domain-specific variables
-PRODUCTION_URL = "${confirmedValues.productionUrl}"
-STAGING_URL = "${confirmedValues.stagingUrl}"
-DEVELOPMENT_URL = "${confirmedValues.developmentUrl}"
 
-# Feature flags
-${this._generateFeatureFlags(confirmedValues.features)}
+# ═══ Observability ═════════════════════════════════════════════════
+[observability]
+enabled = true
 
-# Custom environment variables (configure as needed)
-# CUSTOM_VAR = "value"
+[observability.logs]
+enabled = true
+invocation_logs = true
+# head_sampling_rate = 0.01  # Uncomment in production
 `;
   }
 

package/dist/simple-api.js

@@ -108,10 +108,10 @@ export class Clodo {
    */
   static getInfo() {
     return {
-      name: 'Clodo Framework',
-      version: '3.1.23',
-      description: 'Unified service management framework for Cloudflare Workers',
-      features: ['Service Creation', 'Multi-Domain Deployment', 'Configuration Management', 'Validation & Diagnostics', 'Worker Integration']
+      name: '@tamyla/clodo-framework',
+      version: '4.4.1',
+      description: 'Batteries-included framework for Cloudflare Workers — routing, middleware, AI, KV, R2, Vectorize, Queues & more',
+      features: ['Enhanced Router (Express/Hono-style)', 'Middleware Composition', 'Workers AI Integration', 'KV / R2 / D1 Storage', 'Vectorize (Vector DB)', 'Queues (Producer/Consumer)', 'Cron / Scheduled Handlers', 'Durable Objects', 'Email Workers', 'Service Bindings', 'Analytics Engine', 'Health Checks & Monitoring', 'Feature Flags', 'Rate Limiting', 'Environment Validation', 'Service Creation & Deployment', 'Multi-Domain Orchestration']
     };
   }
 }