@codigodoleo/wp-kit 1.0.0

package/git-deploy.sh

@@ -0,0 +1,74 @@
+#!/bin/bash
+
+# Script para inicializar git, adicionar remote e fazer push forçado
+# Uso: ./git-deploy.sh [remote-url] [branch] [commit-message]
+
+set -e  # Sai se algum comando falhar
+
+# Configurações padrão
+DEFAULT_REMOTE="git@gitlab.com:pipefy/wordpress/web-template.git"
+DEFAULT_BRANCH="main"
+DEFAULT_COMMIT_MESSAGE="Initial commit"
+
+# Parâmetros
+REMOTE_URL=${1:-$DEFAULT_REMOTE}
+BRANCH=${2:-$DEFAULT_BRANCH}
+COMMIT_MESSAGE=${3:-$DEFAULT_COMMIT_MESSAGE}
+
+echo "🚀 Iniciando processo de deploy..."
+echo "Remote: $REMOTE_URL"
+echo "Branch: $BRANCH"
+echo "Commit message: $COMMIT_MESSAGE"
+echo ""
+
+# Verificar se estamos em um diretório com arquivos
+if [ ! "$(ls -A .)" ]; then
+    echo "❌ Erro: Diretório vazio. Adicione alguns arquivos antes de executar."
+    exit 1
+fi
+
+# Inicializar git
+echo "📦 Inicializando repositório Git..."
+git init
+
+# Verificar se o remote já existe e remover se necessário
+if git remote get-url origin &>/dev/null; then
+    echo "🔄 Removendo remote origin existente..."
+    git remote remove origin
+fi
+
+# Adicionar remote
+echo "🔗 Adicionando remote origin..."
+git remote add origin "$REMOTE_URL"
+
+# Verificar se há arquivos para adicionar
+echo "📋 Adicionando arquivos ao stage..."
+git add .
+
+# Verificar se há algo para commitar
+if git diff --cached --quiet; then
+    echo "ℹ️  Nenhuma mudança para commitar."
+else
+    echo "💾 Criando commit..."
+    git commit -m "$COMMIT_MESSAGE"
+fi
+
+# Confirmar push forçado
+echo ""
+echo "⚠️  ATENÇÃO: Este comando fará um push FORÇADO para a branch '$BRANCH'."
+echo "   Isso pode sobrescrever o histórico existente no repositório remoto."
+echo ""
+read -p "Deseja continuar? (y/N): " -n 1 -r
+echo ""
+
+if [[ $REPLY =~ ^[Yy]$ ]]; then
+    echo "🚀 Fazendo push forçado para $BRANCH..."
+    git push -f origin "$BRANCH"
+    echo ""
+    echo "✅ Deploy concluído com sucesso!"
+    echo "🔗 Repositório: $REMOTE_URL"
+    echo "🌿 Branch: $BRANCH"
+else
+    echo "❌ Deploy cancelado pelo usuário."
+    exit 1
+fi

package/index.php

@@ -0,0 +1,17 @@
+<?php
+/**
+ * Front to the WordPress application. This file doesn't do anything, but loads
+ * wp-blog-header.php which does and tells WordPress to load the theme.
+ *
+ * @package WordPress
+ */
+
+/**
+ * Tells WordPress to load the WordPress theme and output it.
+ *
+ * @var bool
+ */
+define( 'WP_USE_THEMES', true );
+
+/** Loads the WordPress Environment and Template */
+require __DIR__ . '/wp/wp-blog-header.php';

package/lib/cli.js

@@ -0,0 +1,15 @@
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+
+const program = new Command();
+
+export function runCli() {
+  program
+    .name('leo-wp')
+    .description('WP Kit — Scaffold/Kit WordPress com CI dinâmico (@codigodoleo)')
+    .version('0.1.0');
+
+  program.addCommand(initCommand);
+
+  program.parse();
+}

package/lib/commands/init.js

@@ -0,0 +1,132 @@
+import { Command } from 'commander';
+import path from 'path';
+import fs from 'fs-extra';
+import { runPrompts } from '../prompts/index.js';
+import { Generator } from '../core/generator.js';
+import { log, color } from '../utils/logger.js';
+import { inferCiCapabilities } from '../core/infer-ci-capabilities.js';
+
+export const initCommand = new Command('init')
+  .option('-o, --output <dir>', 'Output directory', '__test-sandbox__/test-project')
+  .option('--defaults', 'Use default answers without prompting')
+  .option('--debug', 'Ativa modo debug para logs detalhados')
+  .action(async ({ output, defaults, debug }) => {
+    const target = path.resolve(output);
+    const { enabledModules, ...context } = await runPrompts({ defaults });
+
+    // Normalização de chaves para consistência entre módulos
+    if (context.enable_sage === true) {
+      context.useSage = true;
+    }
+    if (context.git_provider && !context.gitProvider) {
+      context.gitProvider = context.git_provider;
+    }
+
+    // 🔧 Ajustes automáticos para Sage 11
+    if (context.useSage && context.sageVersion === '11') {
+      context.phpVersion = '8.3';
+      context.nodeVersion = '23';
+      context.wpCoreVersion = '7.5';
+
+      log(color.orange, '🔧 Sage 11 selected — automatically adjusting versions:');
+      log(color.orange, '  → PHP: 8.3');
+      log(color.orange, '  → Node: 23');
+      log(color.orange, '  → WP Core: 7.5');
+    }
+
+    context.cwd = target;
+
+    // 🧠 Inferência de capacidades de CI
+    context.ci = inferCiCapabilities(context);
+
+    log(color.blue, '[ci] Capacidades inferidas:');
+    log(color.blue, `  → composer: ${context.ci.build.composer}`);
+    log(color.blue, `  → node: ${context.ci.build.node}`);
+    log(color.blue, `  → sage: ${context.ci.build.sage}`);
+    log(color.blue, `  → deploy.docker: ${context.ci.deploy.docker}`);
+    log(color.blue, `  → nodeVersion: ${context.ci.nodeVersion}`);
+    if (context.ci.theme.paths.themeRoot) {
+      log(color.blue, `  → themeRoot: ${context.ci.theme.paths.themeRoot}`);
+    }
+
+    const generator = new Generator(target);
+    await fs.ensureDir(target);
+
+    await generator.generateFile('.gitignore', context);
+    await generator.generateFile('README.md', context);
+    await generator.generateFile('.env', context);
+    await generator.generateFile('.editorconfig', context);
+    await generator.generateFile('server/cmd/install-wp.sh', context);
+
+    await generator.copyFile('.cspell.json');
+
+    await generator.copyFile('server/php/php.ini');
+
+    await generator.copyFile('.gitkeep', null, 'content/uploads/.gitkeep');
+    await generator.copyFile('.gitkeep', null, 'content/plugins/.gitkeep');
+    await generator.copyFile('.gitkeep', null, 'content/themes/.gitkeep');
+    await generator.copyFile('.gitkeep', null, 'content/mu-plugins/.gitkeep');
+    await generator.copyFile('.gitkeep', null, 'content/languages/.gitkeep');
+
+    await fs.chmod(path.join(target, 'content/uploads'), 0o777);
+    await fs.chmod(path.join(target, 'server/cmd/install-wp.sh'), 0o755);
+
+    await generator.generateFile('server/www/vhosts.conf', context);
+    if (context.useRocket) {
+      await generator.copyFile('server/www/rocket.conf');
+    }
+
+    await generator.copyFile('wp-config.php');
+    await generator.copyFile('index.php');
+
+    log(color.blue, `🧩 Enabled modules: ${enabledModules.join(', ')}`);
+
+    await generator.generateModularFile({
+      baseTemplate: 'package.json',
+      modules: enabledModules,
+      context,
+      format: 'json',
+      mergeStrategy: 'concat'
+    });
+
+    await generator.generateModularFile({
+      baseTemplate: 'composer.json',
+      modules: enabledModules,
+      context,
+      format: 'json',
+      mergeStrategy: 'concat'
+    });
+
+    await generator.generateModularFile({
+      baseTemplate: '.lando.yml',
+      modules: enabledModules,
+      context,
+      mergeStrategy: 'concat'
+    });
+
+    await generator.generateModularFile({
+      baseTemplate: 'workspace.json',
+      outputFile: `${context.projectName}.code-workspace`,
+      modules: enabledModules,
+      context,
+      format: 'json',
+      mergeStrategy: 'concat'
+    });
+
+    for (const mod of enabledModules) {
+      const modIndexPath = path.resolve('modules', mod, 'index.js');
+      if (await fs.pathExists(modIndexPath)) {
+        const { setupModule } = await import(modIndexPath);
+        if (typeof setupModule === 'function') {
+          log(color.blue, `↪ Running setup for module: ${mod}`);
+          await setupModule(context, generator);
+        }
+      }
+    }
+
+    // Executa hooks após todo o setup dos módulos
+    log(color.blue, '🔗 Executing post-setup hooks...');
+    generator.hooks.doAction('after_setup_complete', context, generator);
+
+    log(color.green, '✅ Project initialized with templates.');
+  });

package/lib/core/generator.js

@@ -0,0 +1,261 @@
+// lib/core/generator.js
+import fs from 'fs-extra';
+import path from 'path';
+import handlebars from 'handlebars';
+import crypto from 'crypto';
+import mergeWith from 'lodash.mergewith';
+import yaml from 'js-yaml';
+import { log, color } from '../utils/logger.js';
+import { HookManager } from './hook-manager.js';
+
+export class Generator {
+  constructor(baseDir = process.cwd()) {
+    this.cwd = baseDir;
+    this.hooks = new HookManager();
+  }
+
+  async copyFile(sourcePathRelative, moduleName = null, outputName = "") {
+    const baseDir = moduleName
+      ? path.resolve('modules', moduleName)
+      : path.resolve();
+
+    outputName = outputName ? outputName : sourcePathRelative;
+
+    const sourcePath = path.resolve(baseDir, sourcePathRelative);
+    const outputPath = path.join(this.cwd, outputName);
+
+    await fs.copy(sourcePath, outputPath);
+    log(color.blue, `📋 File copied: ${outputName}`);
+  }
+
+  /**
+   * Copia uma pasta inteira para o diretório de destino
+   * @param {string} sourcePathRelative - Caminho relativo da pasta de origem
+   * @param {string|null} moduleName - Nome do módulo (opcional)
+   * @param {string} outputName - Nome da pasta de destino (opcional)
+   * @param {boolean} overwrite - Se deve sobrescrever arquivos existentes (padrão: true)
+   */
+  async copyDirectory(sourcePathRelative, moduleName = null, outputName = "", overwrite = true) {
+    const baseDir = moduleName
+      ? path.resolve('modules', moduleName)
+      : path.resolve();
+
+    outputName = outputName ? outputName : sourcePathRelative;
+
+    const sourcePath = path.resolve(baseDir, sourcePathRelative);
+    const outputPath = path.join(this.cwd, outputName);
+
+    // Verifica se a pasta de origem existe
+    if (!await fs.pathExists(sourcePath)) {
+      throw new Error(`Source directory not found: ${sourcePath}`);
+    }
+
+    // Verifica se é realmente uma pasta
+    const sourceStats = await fs.stat(sourcePath);
+    if (!sourceStats.isDirectory()) {
+      throw new Error(`Source path is not a directory: ${sourcePath}`);
+    }
+
+    // Se a pasta de destino não existe, copia tudo
+    if (!await fs.pathExists(outputPath)) {
+      await fs.copy(sourcePath, outputPath);
+      log(color.blue, `📁 Directory copied: ${outputName}`);
+      return;
+    }
+
+    // Se a pasta de destino existe e overwrite é false, não faz nada
+    if (!overwrite) {
+      log(color.yellow, `📁 Directory already exists, skipping: ${outputName}`);
+      return;
+    }
+
+    // Se a pasta de destino existe e overwrite é true, copia arquivos individualmente
+    await this._copyDirectoryContents(sourcePath, outputPath);
+    log(color.blue, `📁 Directory contents merged: ${outputName}`);
+  }
+
+  /**
+   * Método auxiliar para copiar conteúdo de uma pasta para outra
+   * @param {string} sourcePath - Caminho absoluto da pasta de origem
+   * @param {string} outputPath - Caminho absoluto da pasta de destino
+   */
+  async _copyDirectoryContents(sourcePath, outputPath) {
+    const items = await fs.readdir(sourcePath);
+
+    for (const item of items) {
+      const sourceItemPath = path.join(sourcePath, item);
+      const outputItemPath = path.join(outputPath, item);
+      const stats = await fs.stat(sourceItemPath);
+
+      if (stats.isDirectory()) {
+        // Se é uma pasta, cria se não existir e copia recursivamente
+        if (!await fs.pathExists(outputItemPath)) {
+          await fs.mkdir(outputItemPath, { recursive: true });
+        }
+        await this._copyDirectoryContents(sourceItemPath, outputItemPath);
+      } else {
+        // Se é um arquivo, copia (sobrescreve se existir)
+        await fs.copy(sourceItemPath, outputItemPath);
+      }
+    }
+  }
+
+  async generateFile(templatePathRelative, context, moduleName = null, outputName = "") {
+    const baseDir = moduleName
+      ? path.resolve('modules', moduleName, 'templates')
+      : path.resolve('templates');
+
+    outputName = outputName ? outputName : templatePathRelative;
+
+    const templatePath = path.resolve(baseDir, templatePathRelative + '.hbs');
+    const outputPath = path.join(this.cwd, outputName);
+
+    const content = await fs.readFile(templatePath, 'utf8');
+    const template = handlebars.compile(content);
+    const result = template(context);
+
+    await fs.outputFile(outputPath, result);
+    log(color.blue, `📄 File generated: ${outputName}`);
+  }
+
+  /**
+   * Gera um arquivo modular combinando templates base e de módulos.
+   * @param {Object} options
+   * @param {string} options.baseTemplate - Caminho do template base
+   * @param {string} options.outputFile - Nome do arquivo de saída
+   * @param {string[]} [options.modules=[]] - Lista de módulos
+   * @param {Object} [options.context={}] - Contexto para handlebars
+   * @param {'json'|'yaml'} [options.format='yaml'] - Formato do arquivo
+   * @param {'concat'|'replace'} [options.mergeStrategy='concat'] - Estratégia de merge de arrays
+   */
+  async generateModularFile({ baseTemplate, outputFile = "", modules = [], context = {}, format = 'yaml', mergeStrategy = 'replace', debug = false }) {
+    const baseTemplatePath = path.resolve('templates', baseTemplate + '.hbs');
+    const baseRaw = await fs.readFile(baseTemplatePath, 'utf8');
+    const compiledBase = handlebars.compile(baseRaw);
+    outputFile = outputFile ? outputFile : baseTemplate;
+    let mergedOutput;
+    try {
+      mergedOutput = format === 'json'
+        ? JSON.parse(compiledBase(context))
+        : yaml.load(compiledBase(context));
+    } catch (err) {
+      if (debug) {
+        log(color.red, '[DEBUG] Erro ao fazer parse do template base:');
+        log(color.red, compiledBase(context));
+        log(color.red, err);
+      }
+      throw err;
+    }
+
+    function customizer(objValue, srcValue) {
+      if (Array.isArray(objValue) && Array.isArray(srcValue)) {
+        return mergeStrategy === 'concat'
+          ? objValue.concat(srcValue)
+          : srcValue;
+      }
+    }
+
+    for (const mod of modules) {
+      const modPath = path.resolve('modules', mod, 'templates', path.basename(baseTemplate) + '.hbs');
+
+      if (await fs.pathExists(modPath)) {
+        const modRaw = await fs.readFile(modPath, 'utf8');
+        const compiledMod = handlebars.compile(modRaw);
+        let modParsed;
+        try {
+          modParsed = format === 'json'
+            ? JSON.parse(compiledMod(context))
+            : yaml.load(compiledMod(context));
+        } catch (err) {
+          if (debug) {
+            log(color.red, `[DEBUG] Erro ao fazer parse do template do módulo ${mod}:`);
+            log(color.red, compiledMod(context));
+            log(color.red, err);
+          }
+          throw err;
+        }
+        mergedOutput = mergeWith({}, mergedOutput, modParsed, customizer);
+      }
+    }
+
+    const finalOutput = format === 'json'
+      ? JSON.stringify(mergedOutput, null, 2)
+      : yaml.dump(mergedOutput, { lineWidth: 120 });
+
+    const outputPath = path.join(this.cwd, outputFile);
+    await fs.outputFile(outputPath, finalOutput);
+    log(color.blue, `🧩 Modular file generated: ${outputFile}`);
+  }
+
+  async mergeWithExistingFile({ existingFile, moduleTemplatePath, context, format = 'json', moduleName = null, mergeStrategy = 'replace', debug = false }) {
+    const existingPath = path.isAbsolute(existingFile)
+      ? existingFile
+      : path.resolve(this.cwd, existingFile);
+
+    const fileExists = await fs.pathExists(existingPath);
+    if (!fileExists) {
+      throw new Error(`File to merge not found: ${existingPath}`);
+    }
+
+    const existingRaw = await fs.readFile(existingPath, 'utf8');
+    let existingParsed;
+    try {
+      existingParsed = format === 'json' ? JSON.parse(existingRaw) : yaml.load(existingRaw);
+    } catch (err) {
+      if (debug) {
+        log(color.red, '[DEBUG] Erro ao fazer parse do arquivo existente:');
+        log(color.red, existingRaw);
+        log(color.red, err);
+      }
+      throw err;
+    }
+
+    const moduleBase = moduleName
+      ? path.resolve('modules', moduleName, 'templates')
+      : path.resolve('templates');
+    const templatePath = path.resolve(moduleBase, moduleTemplatePath + '.hbs');
+
+    const modRaw = await fs.readFile(templatePath, 'utf8');
+    const compiledMod = handlebars.compile(modRaw);
+    let modParsed;
+    try {
+      modParsed = format === 'json'
+        ? JSON.parse(compiledMod(context))
+        : yaml.load(compiledMod(context));
+    } catch (err) {
+      if (debug) {
+        log(color.red, '[DEBUG] Erro ao fazer parse do template do módulo:');
+        log(color.red, compiledMod(context));
+        log(color.red, err);
+      }
+      throw err;
+    }
+
+    function customizer(objValue, srcValue) {
+      if (Array.isArray(objValue) && Array.isArray(srcValue)) {
+        return mergeStrategy === 'concat'
+          ? objValue.concat(srcValue)
+          : srcValue;
+      }
+    }
+
+    const merged = mergeWith({}, existingParsed, modParsed, customizer);
+
+    const output = format === 'json'
+      ? JSON.stringify(merged, null, 2)
+      : yaml.dump(merged, { lineWidth: 120 });
+
+    await fs.outputFile(existingPath, output);
+    log(color.blue, `🔀 Merged into: ${existingPath}`);
+  }
+
+  static generateSalts() {
+    return [
+      'AUTH_KEY', 'SECURE_AUTH_KEY', 'LOGGED_IN_KEY', 'NONCE_KEY',
+      'AUTH_SALT', 'SECURE_AUTH_SALT', 'LOGGED_IN_SALT', 'NONCE_SALT'
+    ].reduce((acc, key) => {
+      acc[key] = crypto.randomBytes(64).toString('base64');
+      return acc;
+    }, {});
+  }
+}

package/lib/core/hook-manager.js

@@ -0,0 +1,172 @@
+import { log, color } from '../utils/logger.js';
+
+/**
+ * Sistema de hooks similar ao WordPress
+ * Permite registrar callbacks que serão executados em momentos específicos
+ */
+export class HookManager {
+  constructor() {
+    this.hooks = new Map();
+    this.currentHook = null;
+  }
+
+  /**
+   * Registra uma função para ser executada em um hook específico
+   * @param {string} hookName - Nome do hook
+   * @param {Function} callback - Função a ser executada
+   * @param {number} priority - Prioridade (padrão: 10, menor número = maior prioridade)
+   * @param {number} acceptedArgs - Número de argumentos aceitos pela função
+   */
+  addAction(hookName, callback, priority = 10, acceptedArgs = 1) {
+    if (!this.hooks.has(hookName)) {
+      this.hooks.set(hookName, []);
+    }
+
+    const hook = this.hooks.get(hookName);
+    hook.push({
+      callback,
+      priority,
+      acceptedArgs
+    });
+
+    // Ordena por prioridade (menor número = maior prioridade)
+    hook.sort((a, b) => a.priority - b.priority);
+  }
+
+  /**
+   * Registra uma função que retorna um valor (filtro)
+   * @param {string} hookName - Nome do hook
+   * @param {Function} callback - Função a ser executada
+   * @param {number} priority - Prioridade (padrão: 10)
+   * @param {number} acceptedArgs - Número de argumentos aceitos pela função
+   */
+  addFilter(hookName, callback, priority = 10, acceptedArgs = 1) {
+    this.addAction(hookName, callback, priority, acceptedArgs);
+  }
+
+  /**
+   * Executa todos os callbacks registrados para um hook
+   * @param {string} hookName - Nome do hook
+   * @param {...any} args - Argumentos para passar aos callbacks
+   */
+  doAction(hookName, ...args) {
+    if (!this.hooks.has(hookName)) {
+      return;
+    }
+
+    const hook = this.hooks.get(hookName);
+    const previousHook = this.currentHook;
+    this.currentHook = hookName;
+
+    log(color.blue, `🔗 Executing hook: ${hookName} (${hook.length} callbacks)`);
+
+    for (const { callback, acceptedArgs } of hook) {
+      try {
+        const callbackArgs = args.slice(0, acceptedArgs);
+        callback(...callbackArgs);
+      } catch (error) {
+        log(color.red, `❌ Error in hook ${hookName}: ${error.message}`);
+      }
+    }
+
+    this.currentHook = previousHook;
+  }
+
+  /**
+   * Executa um filtro e retorna o valor modificado
+   * @param {string} hookName - Nome do hook
+   * @param {any} value - Valor inicial
+   * @param {...any} args - Argumentos adicionais
+   * @returns {any} Valor modificado pelos filtros
+   */
+  applyFilters(hookName, value, ...args) {
+    if (!this.hooks.has(hookName)) {
+      return value;
+    }
+
+    const hook = this.hooks.get(hookName);
+    const previousHook = this.currentHook;
+    this.currentHook = hookName;
+
+    log(color.blue, `🔗 Applying filter: ${hookName} (${hook.length} callbacks)`);
+
+    let result = value;
+    for (const { callback, acceptedArgs } of hook) {
+      try {
+        const callbackArgs = [result, ...args].slice(0, acceptedArgs);
+        result = callback(...callbackArgs);
+      } catch (error) {
+        log(color.red, `❌ Error in filter ${hookName}: ${error.message}`);
+      }
+    }
+
+    this.currentHook = previousHook;
+    return result;
+  }
+
+  /**
+   * Remove um callback de um hook
+   * @param {string} hookName - Nome do hook
+   * @param {Function} callback - Função a ser removida
+   * @param {number} priority - Prioridade da função
+   */
+  removeAction(hookName, callback, priority = 10) {
+    if (!this.hooks.has(hookName)) {
+      return;
+    }
+
+    const hook = this.hooks.get(hookName);
+    const index = hook.findIndex(
+      item => item.callback === callback && item.priority === priority
+    );
+
+    if (index !== -1) {
+      hook.splice(index, 1);
+    }
+  }
+
+  /**
+   * Remove um filtro
+   * @param {string} hookName - Nome do hook
+   * @param {Function} callback - Função a ser removida
+   * @param {number} priority - Prioridade da função
+   */
+  removeFilter(hookName, callback, priority = 10) {
+    this.removeAction(hookName, callback, priority);
+  }
+
+  /**
+   * Verifica se um hook tem callbacks registrados
+   * @param {string} hookName - Nome do hook
+   * @returns {boolean}
+   */
+  hasAction(hookName) {
+    return this.hooks.has(hookName) && this.hooks.get(hookName).length > 0;
+  }
+
+  /**
+   * Verifica se um filtro tem callbacks registrados
+   * @param {string} hookName - Nome do hook
+   * @returns {boolean}
+   */
+  hasFilter(hookName) {
+    return this.hasAction(hookName);
+  }
+
+  /**
+   * Lista todos os hooks registrados
+   * @returns {string[]}
+   */
+  getHooks() {
+    return Array.from(this.hooks.keys());
+  }
+
+  /**
+   * Obtém informações sobre um hook específico
+   * @param {string} hookName - Nome do hook
+   * @returns {Array|null}
+   */
+  getHook(hookName) {
+    return this.hooks.get(hookName) || null;
+  }
+}