@o2vend/theme-cli 1.0.0

package/src/commands/package.js

@@ -0,0 +1,208 @@
+/**
+ * O2VEND Theme CLI - Package Command
+ * Package theme for marketplace upload with proper theme.json structure
+ */
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs-extra');
+const archiver = require('archiver');
+const glob = require('glob');
+
+const packageCommand = new Command('package');
+
+packageCommand
+  .description('Package theme for marketplace upload with theme.json manifest')
+  .option('-o, --output <path>', 'Output ZIP file path', 'dist/theme.zip')
+  .option('--exclude <patterns>', 'Files to exclude', '.env,.git,node_modules,.vscode')
+  .option('--validate', 'Run validation before packaging', false)
+  .option('--cwd <path>', 'Working directory (theme path)', process.cwd())
+  .option('--theme-id <id>', 'Theme ID for theme.json', (value, prev) => prev || path.basename(process.cwd()))
+  .option('--theme-name <name>', 'Theme name for theme.json', 'My Theme')
+  .option('--theme-version <version>', 'Theme version for theme.json', '1.0.0')
+  .option('--author <author>', 'Author for theme.json', 'Theme Developer')
+  .action(async (options) => {
+    try {
+      console.log(chalk.cyan('📦 Packaging theme for marketplace...\n'));
+
+      const themePath = path.resolve(options.cwd);
+      const outputPath = path.resolve(options.output);
+      const outputDir = path.dirname(outputPath);
+
+      // Ensure output directory exists
+      await fs.ensureDir(outputDir);
+
+      // Check if theme.json.example exists
+      const themeJsonExamplePath = path.join(themePath, 'theme.json.example');
+      const themeJsonPath = path.join(themePath, 'theme.json');
+
+      // Validate theme structure
+      if (options.validate) {
+        console.log(chalk.yellow('🔍 Validating theme structure...'));
+        
+        // Basic validation
+        const errors = [];
+        const requiredDirs = ['layout', 'templates', 'sections', 'snippets', 'assets', 'config'];
+        requiredDirs.forEach(dir => {
+          const dirPath = path.join(themePath, dir);
+          if (!fs.existsSync(dirPath)) {
+            errors.push(`Required directory missing: ${dir}/`);
+          }
+        });
+
+        const layoutPath = path.join(themePath, 'layout', 'theme.liquid');
+        if (!fs.existsSync(layoutPath)) {
+          errors.push('Required file missing: layout/theme.liquid');
+        }
+
+        if (errors.length > 0) {
+          console.log(chalk.red('\n❌ Validation failed:\n'));
+          errors.forEach(error => console.log(chalk.red(`  - ${error}`)));
+          console.log('');
+          throw new Error('Theme validation failed');
+        }
+        
+        console.log(chalk.green('✅ Validation passed\n'));
+      }
+
+      // Generate or read theme.json
+      let themeJson;
+      if (await fs.pathExists(themeJsonPath)) {
+        // Use existing theme.json
+        themeJson = await fs.readJson(themeJsonPath);
+        console.log(chalk.green('✅ Found theme.json\n'));
+      } else if (await fs.pathExists(themeJsonExamplePath)) {
+        // Copy from example and fill in values
+        themeJson = await fs.readJson(themeJsonExamplePath);
+        themeJson.id = options.themeId;
+        themeJson.name = options.themeName;
+        themeJson.version = options.themeVersion;
+        themeJson.author = options.author;
+        console.log(chalk.yellow('⚠️  Using theme.json.example as template\n'));
+      } else {
+        // Generate minimal theme.json
+        themeJson = {
+          id: options.themeId,
+          name: options.themeName,
+          version: options.themeVersion,
+          author: options.author,
+          description: `${options.themeName} - O2VEND Theme`,
+          migration: {
+            files: {
+              modified: [],
+              added: [],
+              deleted: []
+            },
+            script: null
+          },
+          compatibility: {
+            minO2VENDVersion: '1.0.0',
+            dependencies: []
+          }
+        };
+        console.log(chalk.yellow('⚠️  Generated theme.json from options\n'));
+      }
+
+      // Validate required fields
+      const requiredFields = ['id', 'name', 'version', 'author', 'description'];
+      const missingFields = requiredFields.filter(field => !themeJson[field]);
+      if (missingFields.length > 0) {
+        throw new Error(`Missing required fields in theme.json: ${missingFields.join(', ')}`);
+      }
+
+      // Ensure migration object exists
+      if (!themeJson.migration) {
+        themeJson.migration = {
+          files: {
+            modified: [],
+            added: [],
+            deleted: []
+          },
+          script: null
+        };
+      }
+
+      // Ensure compatibility object exists
+      if (!themeJson.compatibility) {
+        themeJson.compatibility = {
+          minO2VENDVersion: '1.0.0',
+          dependencies: []
+        };
+      }
+
+      console.log(chalk.cyan('📋 Theme metadata:'));
+      console.log(chalk.gray(`   ID: ${themeJson.id}`));
+      console.log(chalk.gray(`   Name: ${themeJson.name}`));
+      console.log(chalk.gray(`   Version: ${themeJson.version}`));
+      console.log(chalk.gray(`   Author: ${themeJson.author}\n`));
+
+      // Create ZIP file
+      console.log(chalk.cyan('📦 Creating ZIP package...'));
+
+      const output = fs.createWriteStream(outputPath);
+      const archive = archiver('zip', {
+        zlib: { level: 9 } // Maximum compression
+      });
+
+      return new Promise((resolve, reject) => {
+        output.on('close', () => {
+          const sizeMB = (archive.pointer() / 1024 / 1024).toFixed(2);
+          console.log(chalk.green(`✅ Package created successfully!`));
+          console.log(chalk.gray(`   File: ${outputPath}`));
+          console.log(chalk.gray(`   Size: ${sizeMB} MB\n`));
+          resolve();
+        });
+
+        archive.on('error', (error) => {
+          reject(error);
+        });
+
+        archive.pipe(output);
+
+        // Add theme.json first
+        archive.append(JSON.stringify(themeJson, null, 2), {
+          name: 'theme.json'
+        });
+
+        // Get all files to include
+        const excludePatterns = options.exclude.split(',').map(p => p.trim());
+        const ignorePatterns = [
+          '**/node_modules/**',
+          '**/.git/**',
+          '**/.vscode/**',
+          '**/.env*',
+          '**/dist/**',
+          '**/.o2vend-cache/**',
+          '**/theme.json.example',
+          '**/migrations/**/*.example', // Exclude example migration scripts
+          '**/migrations/README.md', // Exclude README from migrations
+          '**/*.log',
+          ...excludePatterns.map(p => `**/${p}/**`)
+        ];
+
+        // Add all theme files
+        const files = glob.sync('**/*', {
+          cwd: themePath,
+          ignore: ignorePatterns,
+          nodir: true,
+          dot: false
+        });
+
+        files.forEach(file => {
+          const filePath = path.join(themePath, file);
+          archive.file(filePath, { name: file });
+        });
+
+        archive.finalize();
+      });
+    } catch (error) {
+      console.error(chalk.red('❌ Error packaging theme:'), error.message);
+      if (error.stack && process.env.DEBUG) {
+        console.error(error.stack);
+      }
+      process.exit(1);
+    }
+  });
+
+module.exports = packageCommand;

package/src/commands/serve.js

@@ -0,0 +1,105 @@
+/**
+ * O2VEND Theme CLI - Serve Command
+ * Start local development server with hot reload
+ */
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const DevServer = require('../lib/dev-server');
+require('dotenv').config();
+
+const serveCommand = new Command('serve')
+  .alias('s'); // Allow 'o2vend s' as shorthand
+
+serveCommand
+  .description('Start development server with hot reload')
+  .option('-m, --mode <mode>', 'API mode (mock|real)', process.env.API_MODE || 'mock')
+  .option('-p, --port <port>', 'Server port', process.env.PORT || '3000')
+  .option('--host <host>', 'Server host', process.env.HOST || 'localhost')
+  .option('--cwd <path>', 'Working directory (theme path)', process.cwd())
+  .option('--open', 'Open browser automatically', process.env.OPEN_BROWSER !== 'false')
+  .option('--no-open', 'Don\'t open browser')
+  .option('--mock-api-port <port>', 'Mock API port', process.env.MOCK_API_PORT || '3001')
+  .action(async (options) => {
+    try {
+      console.log(chalk.cyan('🚀 Starting O2VEND Theme Development Server\n'));
+
+      // Resolve theme path
+      const themePath = path.resolve(options.cwd);
+      
+      // Check if theme path exists
+      if (!fs.existsSync(themePath)) {
+        console.error(chalk.red(`❌ Theme path does not exist: ${themePath}`));
+        process.exit(1);
+      }
+
+      // Check for theme structure
+      const layoutPath = path.join(themePath, 'layout', 'theme.liquid');
+      if (!fs.existsSync(layoutPath)) {
+        console.warn(chalk.yellow(`⚠️  Theme layout not found: ${layoutPath}`));
+        console.warn(chalk.yellow('   Creating basic theme structure...'));
+        // Create basic structure
+        fs.ensureDirSync(path.join(themePath, 'layout'));
+        fs.ensureDirSync(path.join(themePath, 'templates'));
+        fs.writeFileSync(layoutPath, '<!DOCTYPE html>\n<html><head><title>{{ shop.name }}</title></head><body>{{ content }}</body></html>');
+      }
+
+      // Create dev server
+      const devServer = new DevServer({
+        themePath: themePath,
+        port: parseInt(options.port),
+        host: options.host,
+        mode: options.mode,
+        mockApiPort: parseInt(options.mockApiPort),
+        open: options.open !== false
+      });
+
+      // Handle graceful shutdown
+      process.on('SIGINT', async () => {
+        console.log(chalk.yellow('\n\n👋 Shutting down server...'));
+        await devServer.stop();
+        if (devServer.mockApi) {
+          await devServer.mockApi.stop();
+        }
+        process.exit(0);
+      });
+
+      process.on('SIGTERM', async () => {
+        await devServer.stop();
+        if (devServer.mockApi) {
+          await devServer.mockApi.stop();
+        }
+        process.exit(0);
+      });
+
+      // Handle 'q' key press in terminal
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', async (key) => {
+          if (key === 'q' || key === '\u0003') {
+            console.log(chalk.yellow('\n\n👋 Shutting down server...'));
+            await devServer.stop();
+            if (devServer.mockApi) {
+              await devServer.mockApi.stop();
+            }
+            process.exit(0);
+          }
+        });
+      }
+
+      // Start server
+      await devServer.start();
+    } catch (error) {
+      console.error(chalk.red('❌ Error starting server:'), error.message);
+      if (error.stack && process.env.DEBUG) {
+        console.error(error.stack);
+      }
+      process.exit(1);
+    }
+  });
+
+module.exports = serveCommand;

package/src/commands/validate.js

@@ -0,0 +1,191 @@
+/**
+ * O2VEND Theme CLI - Validate Command
+ * Validate theme structure and configuration
+ */
+
+const { Command } = require('commander');
+const path = require('path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+
+const validateCommand = new Command('validate');
+
+validateCommand
+  .description('Validate theme structure and configuration')
+  .option('--strict', 'Enable strict validation')
+  .option('--fix', 'Auto-fix issues where possible')
+  .option('--json', 'Output as JSON')
+  .option('--report <path>', 'Save report to file')
+  .option('--cwd <path>', 'Working directory (theme path)', process.cwd())
+  .action(async (options) => {
+    try {
+      console.log(chalk.cyan('🔍 Validating theme...\n'));
+
+      const themePath = path.resolve(options.cwd);
+      const errors = [];
+      const warnings = [];
+
+      // Check if theme directory exists
+      if (!fs.existsSync(themePath)) {
+        errors.push(`Theme directory does not exist: ${themePath}`);
+        outputResults(errors, warnings, options);
+        process.exit(1);
+      }
+
+      // Required directories
+      const requiredDirs = ['layout', 'templates', 'sections', 'snippets', 'assets', 'config'];
+      requiredDirs.forEach(dir => {
+        const dirPath = path.join(themePath, dir);
+        if (!fs.existsSync(dirPath)) {
+          errors.push(`Required directory missing: ${dir}/`);
+        } else if (!fs.statSync(dirPath).isDirectory()) {
+          errors.push(`${dir}/ exists but is not a directory`);
+        }
+      });
+
+      // Required files
+      const layoutPath = path.join(themePath, 'layout', 'theme.liquid');
+      if (!fs.existsSync(layoutPath)) {
+        errors.push('Required file missing: layout/theme.liquid');
+      }
+
+      const indexTemplatePath = path.join(themePath, 'templates', 'index.liquid');
+      if (!fs.existsSync(indexTemplatePath)) {
+        warnings.push('Recommended file missing: templates/index.liquid (homepage template)');
+      }
+
+      // Validate settings_schema.json
+      const settingsSchemaPath = path.join(themePath, 'config', 'settings_schema.json');
+      if (fs.existsSync(settingsSchemaPath)) {
+        try {
+          const schema = await fs.readJson(settingsSchemaPath);
+          if (!schema.name) {
+            warnings.push('settings_schema.json missing "name" field');
+          }
+          if (!Array.isArray(schema.settings)) {
+            warnings.push('settings_schema.json should have "settings" array');
+          }
+        } catch (error) {
+          errors.push(`Invalid JSON in settings_schema.json: ${error.message}`);
+        }
+      } else {
+        warnings.push('settings_schema.json not found (optional but recommended)');
+      }
+
+      // Validate settings_data.json if exists
+      const settingsDataPath = path.join(themePath, 'config', 'settings_data.json');
+      if (fs.existsSync(settingsDataPath)) {
+        try {
+          await fs.readJson(settingsDataPath);
+        } catch (error) {
+          errors.push(`Invalid JSON in settings_data.json: ${error.message}`);
+        }
+      }
+
+      // Validate theme.json if exists
+      const themeJsonPath = path.join(themePath, 'theme.json');
+      if (fs.existsSync(themeJsonPath)) {
+        try {
+          const themeJson = await fs.readJson(themeJsonPath);
+          const requiredFields = ['id', 'name', 'version', 'author', 'description'];
+          requiredFields.forEach(field => {
+            if (!themeJson[field]) {
+              errors.push(`theme.json missing required field: ${field}`);
+            }
+          });
+
+          // Validate version format (semantic versioning)
+          if (themeJson.version && !/^\d+\.\d+\.\d+/.test(themeJson.version)) {
+            warnings.push(`theme.json version should follow semantic versioning (e.g., "1.0.0"): ${themeJson.version}`);
+          }
+        } catch (error) {
+          errors.push(`Invalid JSON in theme.json: ${error.message}`);
+        }
+      }
+
+      // Check for Liquid files
+      const liquidFiles = findFiles(themePath, '.liquid');
+      if (liquidFiles.length === 0) {
+        warnings.push('No .liquid template files found');
+      }
+
+      // Output results
+      outputResults(errors, warnings, options);
+
+      if (errors.length > 0) {
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ Validation failed:'), error.message);
+      if (error.stack && process.env.DEBUG) {
+        console.error(error.stack);
+      }
+      process.exit(1);
+    }
+  });
+
+/**
+ * Find files by extension
+ */
+function findFiles(dir, ext) {
+  const files = [];
+  if (!fs.existsSync(dir)) return files;
+
+  const items = fs.readdirSync(dir);
+  items.forEach(item => {
+    const itemPath = path.join(dir, item);
+    const stat = fs.statSync(itemPath);
+    if (stat.isDirectory()) {
+      files.push(...findFiles(itemPath, ext));
+    } else if (item.endsWith(ext)) {
+      files.push(itemPath);
+    }
+  });
+
+  return files;
+}
+
+/**
+ * Output validation results
+ */
+function outputResults(errors, warnings, options) {
+  const result = {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    errorCount: errors.length,
+    warningCount: warnings.length
+  };
+
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    if (errors.length > 0) {
+      console.log(chalk.red(`\n❌ Found ${errors.length} error(s):\n`));
+      errors.forEach((error, index) => {
+        console.log(chalk.red(`  ${index + 1}. ${error}`));
+      });
+    }
+
+    if (warnings.length > 0) {
+      console.log(chalk.yellow(`\n⚠️  Found ${warnings.length} warning(s):\n`));
+      warnings.forEach((warning, index) => {
+        console.log(chalk.yellow(`  ${index + 1}. ${warning}`));
+      });
+    }
+
+    if (errors.length === 0 && warnings.length === 0) {
+      console.log(chalk.green('✅ Validation passed!'));
+    } else if (errors.length === 0) {
+      console.log(chalk.green('\n✅ Validation passed (with warnings)'));
+    }
+  }
+
+  // Save report if requested
+  if (options.report) {
+    fs.writeJsonSync(options.report, result, { spaces: 2 });
+    console.log(chalk.gray(`\n📄 Report saved to: ${options.report}`));
+  }
+}
+
+module.exports = validateCommand;