@tamyla/clodo-framework 3.1.21 → 3.1.22

package/dist/service-management/generators/tooling/DockerComposeGenerator.js

@@ -1,71 +0,0 @@
-import { BaseGenerator } from '../BaseGenerator.js';
-import { join } from 'path';
-import { writeFileSync } from 'fs';
-
-/**
- * Docker Compose Generator
- * Generates docker-compose.yml for local development environment
- */
-export class DockerComposeGenerator extends BaseGenerator {
-  /**
-   * Generate docker-compose.yml file
-   * @param {Object} context - Generation context
-   * @returns {Promise<string>} Path to generated docker-compose.yml file
-   */
-  async generate(context) {
-    const {
-      coreInputs,
-      confirmedValues,
-      servicePath
-    } = this.extractContext(context);
-    if (!this.shouldGenerate(context)) {
-      return null;
-    }
-    const dockerComposeContent = this._generateDockerComposeContent(coreInputs, confirmedValues);
-    const filePath = join(servicePath, 'docker-compose.yml');
-    writeFileSync(filePath, dockerComposeContent, 'utf8');
-    return filePath;
-  }
-
-  /**
-   * Generate docker-compose.yml content
-   * @private
-   */
-  _generateDockerComposeContent(coreInputs, confirmedValues) {
-    return `version: '3.8'
-
-services:
-  ${coreInputs.serviceName}:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    ports:
-      - "8787:8787"
-    environment:
-      - NODE_ENV=development
-      - SERVICE_NAME=${coreInputs.serviceName}
-      - SERVICE_TYPE=${coreInputs.serviceType}
-      - ENVIRONMENT=development
-    volumes:
-      - .:/app
-      - /app/node_modules
-    command: npm run dev
-
-  ${coreInputs.serviceName}-db:
-    image: cloudflare/d1
-    ports:
-      - "8788:8787"
-    environment:
-      - DATABASE_NAME=${confirmedValues.databaseName}
-    volumes:
-      - .wrangler:/data
-`;
-  }
-
-  /**
-   * Determine if generator should run
-   */
-  shouldGenerate(context) {
-    return true; // Always generate docker-compose.yml
-  }
-}

package/dist/service-management/generators/tooling/GitignoreGenerator.js

@@ -1,143 +0,0 @@
-import { BaseGenerator } from '../BaseGenerator.js';
-import { join } from 'path';
-import { writeFileSync } from 'fs';
-
-/**
- * Gitignore Generator
- * Generates comprehensive .gitignore file for Cloudflare Workers projects
- */
-export class GitignoreGenerator extends BaseGenerator {
-  /**
-   * Generate .gitignore file
-   * @param {Object} context - Generation context
-   * @returns {Promise<string>} Path to generated .gitignore file
-   */
-  async generate(context) {
-    const {
-      coreInputs,
-      confirmedValues,
-      servicePath
-    } = this.extractContext(context);
-    if (!this.shouldGenerate(context)) {
-      return null;
-    }
-    const gitignoreContent = this._generateGitignoreContent(coreInputs, confirmedValues);
-    const filePath = join(servicePath, '.gitignore');
-    writeFileSync(filePath, gitignoreContent, 'utf8');
-    return filePath;
-  }
-
-  /**
-   * Generate .gitignore content
-   * @private
-   */
-  _generateGitignoreContent(coreInputs, confirmedValues) {
-    return `# Dependencies
-node_modules/
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# Environment variables
-.env
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
-
-# Build outputs
-dist/
-build/
-coverage/
-
-# Logs
-logs/
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-lerna-debug.log*
-
-# Runtime data
-pids/
-*.pid
-*.seed
-*.pid.lock
-
-# Coverage directory used by tools like istanbul
-coverage/
-*.lcov
-
-# nyc test coverage
-.nyc_output/
-
-# Dependency directories
-jspm_packages/
-
-# Optional npm cache directory
-.npm
-
-# Optional eslint cache
-.eslintcache
-
-# Microbundle cache
-.rpt2_cache/
-.rts2_cache_cjs/
-.rts2_cache_es/
-.rts2_cache_umd/
-
-# Optional REPL history
-.node_repl_history
-
-# Output of 'npm pack'
-*.tgz
-
-# Yarn Integrity file
-.yarn-integrity
-
-# parcel-bundler cache (https://parceljs.org/)
-.cache
-.parcel-cache
-
-# Next.js build / generate output
-.next
-
-# Nuxt.js build / generate output
-.nuxt
-dist
-
-# Gatsby files
-.cache/
-public
-
-# Storybook build outputs
-.out
-.storybook-out
-
-# Temporary folders
-tmp/
-temp/
-
-# Editor directories and files
-.vscode/*
-!.vscode/extensions.json
-.idea
-.DS_Store
-*.suo
-*.ntvs*
-*.njsproj
-*.sln
-*.sw?
-
-# Cloudflare
-.wrangler/
-`;
-  }
-
-  /**
-   * Determine if generator should run
-   */
-  shouldGenerate(context) {
-    return true; // Always generate .gitignore
-  }
-}

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

@@ -1,179 +0,0 @@
-/**
- * FileWriter - Handles atomic file writing operations
- * 
- * Provides safe file writing with directory creation, overwrite protection,
- * and atomic operations.
- * 
- * 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 FileWriter {
-  /**
-   * Create a new file writer instance
-   * @param {Object} options - Configuration options
-   * @param {string} options.basePath - Base path for all file operations
-   * @param {boolean} options.dryRun - If true, simulate writes without actually writing (default: false)
-   */
-  constructor(options = {}) {
-    this.basePath = options.basePath;
-    this.dryRun = options.dryRun === true;
-    this.writtenFiles = [];
-  }
-
-  /**
-   * Write content to a file
-   * Creates parent directories if they don't exist
-   * @param {string} filePath - Path relative to basePath (or absolute)
-   * @param {string} content - File content to write
-   * @param {Object} options - Write options
-   * @param {boolean} options.overwrite - Whether to overwrite existing files (default: true)
-   * @param {string} options.encoding - File encoding (default: 'utf8')
-   * @returns {Promise<Object>} - Result object { written: boolean, path: string, reason?: string }
-   */
-  async writeFile(filePath, content, options = {}) {
-    const overwrite = options.overwrite !== false; // Default to true
-    const encoding = options.encoding || 'utf8';
-
-    // Resolve full path
-    const fullPath = this.basePath ? path.join(this.basePath, filePath) : filePath;
-
-    // Validate path (security check)
-    if (this.basePath) {
-      const resolved = path.resolve(fullPath);
-      const baseResolved = path.resolve(this.basePath);
-      if (!resolved.startsWith(baseResolved)) {
-        throw new Error(`Path traversal detected: ${filePath}`);
-      }
-    }
-
-    // Check if file exists
-    const exists = await this.fileExists(fullPath);
-    if (exists && !overwrite) {
-      return {
-        written: false,
-        path: fullPath,
-        reason: 'File exists and overwrite is disabled'
-      };
-    }
-
-    // Dry run mode
-    if (this.dryRun) {
-      this.writtenFiles.push(fullPath);
-      return {
-        written: true,
-        path: fullPath,
-        dryRun: true
-      };
-    }
-
-    // Ensure parent directory exists
-    await this.ensureDirectory(path.dirname(fullPath));
-
-    // Write file atomically (write to temp file, then rename)
-    const tempPath = `${fullPath}.tmp`;
-    try {
-      await fs.writeFile(tempPath, content, encoding);
-      await fs.rename(tempPath, fullPath);
-      this.writtenFiles.push(fullPath);
-      return {
-        written: true,
-        path: fullPath
-      };
-    } catch (error) {
-      // Clean up temp file if it exists
-      try {
-        await fs.unlink(tempPath);
-      } catch {
-        // Ignore cleanup errors
-      }
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to write file '${filePath}': ${errorMessage}`);
-    }
-  }
-
-  /**
-   * Ensure a directory exists, creating it recursively if needed
-   * @param {string} dirPath - Directory path
-   * @returns {Promise<void>}
-   */
-  async ensureDirectory(dirPath) {
-    if (this.dryRun) {
-      return; // Skip in dry run mode
-    }
-    try {
-      await fs.mkdir(dirPath, {
-        recursive: true
-      });
-    } catch (error) {
-      // Ignore error if directory already exists
-      if (error.code !== 'EEXIST') {
-        throw new Error(`Failed to create directory '${dirPath}': ${error.message}`);
-      }
-    }
-  }
-
-  /**
-   * Check if a file exists
-   * @param {string} filePath - Path to check
-   * @returns {Promise<boolean>} - True if file exists
-   */
-  async fileExists(filePath) {
-    try {
-      await fs.access(filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Delete a file
-   * @param {string} filePath - Path to delete
-   * @returns {Promise<boolean>} - True if file was deleted
-   */
-  async deleteFile(filePath) {
-    const fullPath = this.basePath ? path.join(this.basePath, filePath) : filePath;
-    if (this.dryRun) {
-      return true;
-    }
-    try {
-      await fs.unlink(fullPath);
-      return true;
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        return false; // File doesn't exist
-      }
-      throw new Error(`Failed to delete file '${filePath}': ${error.message}`);
-    }
-  }
-
-  /**
-   * Get list of files written in this session
-   * @returns {string[]} - Array of file paths
-   */
-  getWrittenFiles() {
-    return [...this.writtenFiles];
-  }
-
-  /**
-   * Clear the written files list
-   */
-  clearHistory() {
-    this.writtenFiles = [];
-  }
-
-  /**
-   * Get statistics about write operations
-   * @returns {Object} - Statistics
-   */
-  getStats() {
-    return {
-      filesWritten: this.writtenFiles.length,
-      dryRun: this.dryRun,
-      basePath: this.basePath
-    };
-  }
-}
-export default FileWriter;

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

@@ -1,157 +0,0 @@
-/**
- * PathResolver - Handles cross-platform path resolution
- * 
- * Provides platform-independent path operations with security checks
- * and consistent path handling across Windows, Linux, and macOS.
- */
-import path from 'path';
-export class PathResolver {
-  /**
-   * Create a new path resolver instance
-   * @param {Object} options - Configuration options
-   * @param {string} options.basePath - Base path for all path operations
-   */
-  constructor(options = {}) {
-    this.basePath = options.basePath;
-  }
-
-  /**
-   * Resolve a path relative to the base path
-   * @param {...string} paths - Path segments to resolve
-   * @returns {string} - Resolved absolute path
-   */
-  resolve(...paths) {
-    if (this.basePath) {
-      return path.resolve(this.basePath, ...paths);
-    }
-    return path.resolve(...paths);
-  }
-
-  /**
-   * Join path segments
-   * @param {...string} paths - Path segments to join
-   * @returns {string} - Joined path
-   */
-  join(...paths) {
-    return path.join(...paths);
-  }
-
-  /**
-   * Normalize a path (resolve . and .., convert slashes)
-   * @param {string} filepath - Path to normalize
-   * @returns {string} - Normalized path
-   */
-  normalize(filepath) {
-    return path.normalize(filepath);
-  }
-
-  /**
-   * Get the relative path from one location to another
-   * @param {string} from - Starting path
-   * @param {string} to - Target path
-   * @returns {string} - Relative path
-   */
-  relative(from, to) {
-    return path.relative(from, to);
-  }
-
-  /**
-   * Get the directory name of a path
-   * @param {string} filepath - File path
-   * @returns {string} - Directory name
-   */
-  dirname(filepath) {
-    return path.dirname(filepath);
-  }
-
-  /**
-   * Get the base name of a path (filename with extension)
-   * @param {string} filepath - File path
-   * @param {string} ext - Optional extension to remove
-   * @returns {string} - Base name
-   */
-  basename(filepath, ext) {
-    return path.basename(filepath, ext);
-  }
-
-  /**
-   * Get the extension of a path
-   * @param {string} filepath - File path
-   * @returns {string} - Extension (including the dot)
-   */
-  extname(filepath) {
-    return path.extname(filepath);
-  }
-
-  /**
-   * Check if a path is absolute
-   * @param {string} filepath - Path to check
-   * @returns {boolean} - True if absolute
-   */
-  isAbsolute(filepath) {
-    return path.isAbsolute(filepath);
-  }
-
-  /**
-   * Validate a path for security (no path traversal outside base)
-   * @param {string} filepath - Path to validate
-   * @returns {boolean} - True if path is safe
-   * @throws {Error} - If path attempts to traverse outside base
-   */
-  validatePath(filepath) {
-    if (!this.basePath) {
-      return true; // No base path, can't validate
-    }
-    const resolved = path.resolve(this.basePath, filepath);
-    const baseResolved = path.resolve(this.basePath);
-    if (!resolved.startsWith(baseResolved)) {
-      throw new Error(`Path traversal detected: ${filepath} resolves outside base path`);
-    }
-    return true;
-  }
-
-  /**
-   * Convert a path to use forward slashes (for URLs, cross-platform consistency)
-   * @param {string} filepath - Path to convert
-   * @returns {string} - Path with forward slashes
-   */
-  toForwardSlashes(filepath) {
-    return filepath.split(path.sep).join('/');
-  }
-
-  /**
-   * Convert a path to use the platform's native separators
-   * @param {string} filepath - Path to convert
-   * @returns {string} - Path with native separators
-   */
-  toNativeSeparators(filepath) {
-    return filepath.split('/').join(path.sep);
-  }
-
-  /**
-   * Get the platform-specific path separator
-   * @returns {string} - Path separator ('/' or '\')
-   */
-  getSeparator() {
-    return path.sep;
-  }
-
-  /**
-   * Parse a path into its components
-   * @param {string} filepath - Path to parse
-   * @returns {Object} - Path components { root, dir, base, ext, name }
-   */
-  parse(filepath) {
-    return path.parse(filepath);
-  }
-
-  /**
-   * Format path components into a path string
-   * @param {Object} pathObject - Path components
-   * @returns {string} - Formatted path
-   */
-  format(pathObject) {
-    return path.format(pathObject);
-  }
-}
-export default PathResolver;

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

@@ -1,111 +0,0 @@
-import { relative } from 'path';
-
-/**
- * Service Manifest Generator
- * Creates service manifests with metadata, file categorization, and checksums
- */
-export class ServiceManifestGenerator {
-  /**
-   * Create a service manifest
-   * @param {Object} coreInputs - Core service configuration
-   * @param {Object} confirmedValues - User-confirmed values
-   * @param {Array<string>} generatedFiles - List of generated file paths
-   * @returns {Object} Service manifest
-   */
-  createManifest(coreInputs, confirmedValues, generatedFiles) {
-    return {
-      manifestVersion: '1.0.0',
-      frameworkVersion: '3.0.0',
-      generatedAt: new Date().toISOString(),
-      service: {
-        name: coreInputs.serviceName,
-        displayName: confirmedValues.displayName,
-        description: confirmedValues.description,
-        type: coreInputs.serviceType,
-        version: confirmedValues.version,
-        author: confirmedValues.author
-      },
-      configuration: {
-        coreInputs,
-        confirmedValues,
-        urls: {
-          production: confirmedValues.productionUrl,
-          staging: confirmedValues.stagingUrl,
-          development: confirmedValues.developmentUrl,
-          documentation: confirmedValues.documentationUrl
-        },
-        api: {
-          basePath: confirmedValues.apiBasePath,
-          healthCheckPath: confirmedValues.healthCheckPath
-        },
-        cloudflare: {
-          accountId: coreInputs.cloudflareAccountId,
-          zoneId: coreInputs.cloudflareZoneId,
-          workerName: confirmedValues.workerName,
-          databaseName: confirmedValues.databaseName
-        },
-        features: confirmedValues.features
-      },
-      files: {
-        total: generatedFiles.length,
-        list: generatedFiles.map(file => relative(process.cwd(), file)),
-        byCategory: this.categorizeFiles(generatedFiles)
-      },
-      metadata: {
-        generationEngine: 'GenerationEngine v1.0.0',
-        tier: 'Tier 3 - Automated Generation',
-        checksum: this.generateChecksum(generatedFiles)
-      }
-    };
-  }
-
-  /**
-   * Categorize generated files by type
-   * @param {Array<string>} files - List of file paths
-   * @returns {Object} Categorized files
-   */
-  categorizeFiles(files) {
-    const categories = {
-      core: [],
-      service: [],
-      environment: [],
-      testing: [],
-      documentation: [],
-      automation: []
-    };
-    files.forEach(file => {
-      const relativePath = relative(process.cwd(), file);
-      if (relativePath.includes('package.json') || relativePath.includes('wrangler.toml') || relativePath.includes('.env')) {
-        categories.core.push(relativePath);
-      } else if (relativePath.includes('src/')) {
-        categories.service.push(relativePath);
-      } else if (relativePath.includes('config/') || relativePath.includes('scripts/')) {
-        categories.environment.push(relativePath);
-      } else if (relativePath.includes('test/') || relativePath.includes('jest.config.js') || relativePath.includes('.eslintrc.js')) {
-        categories.testing.push(relativePath);
-      } else if (relativePath.includes('docs/') || relativePath.includes('README.md')) {
-        categories.documentation.push(relativePath);
-      } else if (relativePath.includes('.github/') || relativePath.includes('.gitignore') || relativePath.includes('docker-compose.yml')) {
-        categories.automation.push(relativePath);
-      }
-    });
-    return categories;
-  }
-
-  /**
-   * Generate checksum for file verification
-   * @param {Array<string>} files - List of file paths
-   * @returns {string} Hexadecimal checksum
-   */
-  generateChecksum(files) {
-    // Simple checksum based on file count and names
-    const fileString = files.map(f => relative(process.cwd(), f)).sort().join('');
-    let hash = 0;
-    for (let i = 0; i < fileString.length; i++) {
-      const char = fileString.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash; // Convert to 32-bit integer
-    }
-    return Math.abs(hash).toString(16);
-  }
-}