myaidev-method 0.2.23 → 0.2.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myaidev-method",
-  "version": "0.2.23",
+  "version": "0.2.24",
   "description": "Comprehensive development framework with SPARC methodology for AI-assisted software development, security testing (PTES, OWASP, penetration testing, compliance auditing), AI visual content generation (Gemini, OpenAI GPT Image 1.5, Imagen, FLUX 2, Veo 3), OpenStack VM management, multi-platform publishing (WordPress, PayloadCMS, Astro, Docusaurus, Mintlify), and Coolify deployment",
   "mcpName": "io.github.myaione/myaidev-method",
   "main": "src/index.js",
@@ -14,6 +14,7 @@
     "test": "node test/run-tests.js",
     "test:gutenberg": "node test/test-gutenberg-converter.js",
     "test:install": "node test/test-installation.js",
+    "test:workflows": "node test/test-workflow-installer.js",
     "test:mcp": "node test/test-enhanced-mcp-server.js",
     "test:mcp:simple": "node test/test-simple-mcp.js",
     "mcp:start": "node src/mcp/mcp-launcher.js start",
@@ -50,6 +51,7 @@
     "configure": "node src/scripts/configure-cms.js",
     "configure:visual": "node src/scripts/configure-visual-apis.js",
     "generate:visual": "node src/scripts/generate-visual-cli.js",
+    "convert:html": "node src/scripts/html-conversion-cli.js",
     "init": "node src/scripts/init-project.js"
   },
   "keywords": [
@@ -119,6 +121,8 @@
     "marked": "^17.0.1",
     "node-fetch": "^3.3.2",
     "ora": "^9.0.0",
+    "pptxgenjs": "^4.0.1",
+    "puppeteer": "^24.35.0",
     "simple-git": "^3.22.0",
     "ssh2": "^1.15.0",
     "zod": "^4.3.5"
@@ -141,6 +145,7 @@
   "files": [
     "bin/",
     "src/",
+    "docs/",
     "dist/",
     "README.md",
     "USER_GUIDE.md",

package/src/config/workflows.js

@@ -6,30 +6,41 @@
  */
 
 const WORKFLOWS = {
-  // Content Creation Workflow
+  // Content Creation Workflow (includes WordPress publishing)
   content: {
     name: 'Content Creation',
     description: 'Professional content writing with SEO optimization and WordPress publishing',
     agents: [
       'content-writer',
-      'proprietary-content-verifier'
+      'proprietary-content-verifier',
+      'wordpress-admin'
     ],
     commands: [
-      'myai-content-writer'
+      'myai-content-writer',
+      'myai-wordpress-publish',
+      'myai-coordinate-content'
     ],
     scripts: [
-      'utils/write-content.js'
+      'utils/write-content.js',
+      'wordpress/publish-to-wordpress.js',
+      'wordpress/wordpress-health-check.js'
     ],
     libs: [
       'content-generator.js',
-      'seo-optimizer.js'
+      'seo-optimizer.js',
+      'wordpress-client.js'
     ],
     docs: [
-      'content-creation-guide.md'
+      'content-creation-guide.md',
+      'wordpress-publishing-guide.md'
     ],
-    mcpServers: [],
+    mcpServers: ['myaidev'],
     dependencies: ['core'],
-    envVars: []
+    envVars: [
+      'WORDPRESS_URL',
+      'WORDPRESS_USERNAME',
+      'WORDPRESS_APP_PASSWORD'
+    ]
   },
 
   // Visual Content Generation Workflow
@@ -92,9 +103,7 @@ const WORKFLOWS = {
     ],
     scripts: [],
     libs: [],
-    docs: [
-      'sparc-methodology.md'
-    ],
+    docs: [],
     mcpServers: [],
     dependencies: ['core'],
     envVars: []
@@ -113,9 +122,7 @@ const WORKFLOWS = {
       'ci/lint.js'
     ],
     libs: [],
-    docs: [
-      'git-workflow-guide.md'
-    ],
+    docs: [],
     mcpServers: [],
     dependencies: ['core'],
     envVars: []
@@ -192,9 +199,7 @@ const WORKFLOWS = {
     libs: [
       'payloadcms-utils.js'
     ],
-    docs: [
-      'payloadcms-publishing-guide.md'
-    ],
+    docs: [],
     mcpServers: [],
     dependencies: ['core', 'content'],
     envVars: [
@@ -219,9 +224,7 @@ const WORKFLOWS = {
     libs: [
       'static-generator.js'
     ],
-    docs: [
-      'static-site-guide.md'
-    ],
+    docs: [],
     mcpServers: [],
     dependencies: ['core', 'content'],
     envVars: []
@@ -242,9 +245,7 @@ const WORKFLOWS = {
     libs: [
       'coolify-client.js'
     ],
-    docs: [
-      'coolify-deployment-guide.md'
-    ],
+    docs: [],
     mcpServers: [],
     dependencies: ['core', 'deployment'],
     envVars: [
@@ -273,10 +274,7 @@ const WORKFLOWS = {
     libs: [
       'config-manager.js'
     ],
-    docs: [
-      'README.md',
-      'TECHNICAL_ARCHITECTURE.md'
-    ],
+    docs: [],
     mcpServers: [],
     dependencies: [],
     envVars: []
@@ -320,12 +318,7 @@ const WORKFLOWS = {
       'security/cvss-calculator.js',
       'security/report-generator.js'
     ],
-    docs: [
-      'SECURITY_TESTING_GUIDE.md',
-      'LEGAL_REQUIREMENTS.md',
-      'TOOL_INSTALLATION.md',
-      'PENTEST_METHODOLOGY.md'
-    ],
+    docs: [],
     mcpServers: [],
     dependencies: ['core', 'development'],
     envVars: [
@@ -371,12 +364,7 @@ const WORKFLOWS = {
       'security/cvss-calculator.js',
       'security/report-generator.js'
     ],
-    docs: [
-      'SECURITY_AUDIT_GUIDE.md',
-      'COMPLIANCE_FRAMEWORKS.md',
-      'SYSTEM_HARDENING.md',
-      'LEGAL_REQUIREMENTS.md'
-    ],
+    docs: [],
     mcpServers: [],
     dependencies: ['core'],
     envVars: [
@@ -416,11 +404,7 @@ const WORKFLOWS = {
       'security/web-scanner.js',
       'security/report-generator.js'
     ],
-    docs: [
-      'WEBAPP_SECURITY_GUIDE.md',
-      'OWASP_TOP10.md',
-      'LEGAL_REQUIREMENTS.md'
-    ],
+    docs: [],
     mcpServers: [],
     dependencies: ['core', 'development', 'security-pentest'],
     envVars: [

package/src/lib/config-manager.js

@@ -0,0 +1,470 @@
+/**
+ * Configuration Manager
+ * Central configuration management for MyAIDev Method
+ * Handles loading, validating, and persisting configurations
+ */
+
+import path from 'path';
+import fs from 'fs-extra';
+
+// Configuration schemas for validation
+export const SCHEMAS = {
+  wordpress: {
+    required: ['WORDPRESS_URL', 'WORDPRESS_USERNAME', 'WORDPRESS_APP_PASSWORD'],
+    optional: ['WORDPRESS_DEFAULT_STATUS', 'WORDPRESS_DEFAULT_CATEGORIES'],
+    defaults: {
+      WORDPRESS_DEFAULT_STATUS: 'draft'
+    }
+  },
+  openstack: {
+    required: ['OS_AUTH_URL', 'OS_USERNAME', 'OS_PASSWORD', 'OS_PROJECT_NAME'],
+    optional: ['OS_REGION_NAME', 'OS_USER_DOMAIN_NAME', 'OS_PROJECT_DOMAIN_NAME'],
+    defaults: {
+      OS_USER_DOMAIN_NAME: 'Default',
+      OS_PROJECT_DOMAIN_NAME: 'Default'
+    }
+  },
+  content: {
+    required: [],
+    optional: ['DEFAULT_WORD_COUNT', 'DEFAULT_TONE', 'CONTENT_OUTPUT_DIR'],
+    defaults: {
+      DEFAULT_WORD_COUNT: '1500',
+      DEFAULT_TONE: 'professional',
+      CONTENT_OUTPUT_DIR: './content'
+    }
+  },
+  defaults: {
+    required: [],
+    optional: ['LOG_LEVEL', 'CLI_TYPE'],
+    defaults: {
+      LOG_LEVEL: 'INFO',
+      CLI_TYPE: 'claude'
+    }
+  }
+};
+
+/**
+ * Configuration Manager Class
+ */
+export class ConfigManager {
+  constructor(projectRoot = process.cwd()) {
+    this.projectRoot = projectRoot;
+    this.configCache = null;
+    this.lastLoad = null;
+  }
+
+  /**
+   * Get path to .env file
+   * @returns {string}
+   */
+  getEnvPath() {
+    return path.join(this.projectRoot, '.env');
+  }
+
+  /**
+   * Get path to .claude/config directory
+   * @returns {string}
+   */
+  getClaudeConfigDir() {
+    return path.join(this.projectRoot, '.claude', 'config');
+  }
+
+  /**
+   * Load all configurations from various sources
+   * @param {boolean} [force=false] - Force reload even if cached
+   * @returns {Promise<Object>} Merged configuration
+   */
+  async loadAll(force = false) {
+    // Return cached config if recent (within 5 seconds)
+    if (!force && this.configCache && this.lastLoad) {
+      const age = Date.now() - this.lastLoad;
+      if (age < 5000) {
+        return this.configCache;
+      }
+    }
+
+    const config = {};
+
+    // 1. Load from .env file
+    const envConfig = await this.loadEnvFile();
+    Object.assign(config, envConfig);
+
+    // 2. Load from .claude/config/*.json files
+    const claudeConfigs = await this.loadClaudeConfigs();
+    Object.assign(config, claudeConfigs);
+
+    // 3. Apply defaults for any missing values
+    this.applyDefaults(config);
+
+    // Cache the result
+    this.configCache = config;
+    this.lastLoad = Date.now();
+
+    return config;
+  }
+
+  /**
+   * Load configuration from .env file
+   * @returns {Promise<Object>}
+   */
+  async loadEnvFile() {
+    const envPath = this.getEnvPath();
+
+    try {
+      const exists = await fs.pathExists(envPath);
+      if (!exists) {
+        return {};
+      }
+
+      const content = await fs.readFile(envPath, 'utf-8');
+      return this.parseEnvContent(content);
+    } catch (error) {
+      console.warn(`Warning: Failed to load .env file: ${error.message}`);
+      return {};
+    }
+  }
+
+  /**
+   * Load configuration files from .claude/config/
+   * @returns {Promise<Object>}
+   */
+  async loadClaudeConfigs() {
+    const configDir = this.getClaudeConfigDir();
+    const merged = {};
+
+    try {
+      const exists = await fs.pathExists(configDir);
+      if (!exists) {
+        return merged;
+      }
+
+      const files = await fs.readdir(configDir);
+      const jsonFiles = files.filter(f => f.endsWith('.json'));
+
+      for (const file of jsonFiles) {
+        const filePath = path.join(configDir, file);
+        try {
+          const content = await fs.readFile(filePath, 'utf-8');
+          const data = JSON.parse(content);
+          Object.assign(merged, data);
+        } catch (err) {
+          console.warn(`Warning: Failed to load config file ${file}: ${err.message}`);
+        }
+      }
+
+      return merged;
+    } catch (error) {
+      console.warn(`Warning: Failed to load claude configs: ${error.message}`);
+      return merged;
+    }
+  }
+
+  /**
+   * Apply default values for missing configuration
+   * @param {Object} config - Configuration object to modify
+   */
+  applyDefaults(config) {
+    for (const schema of Object.values(SCHEMAS)) {
+      for (const [key, value] of Object.entries(schema.defaults || {})) {
+        if (config[key] === undefined) {
+          config[key] = value;
+        }
+      }
+    }
+  }
+
+  /**
+   * Get a specific configuration value
+   * @param {string} key - Configuration key
+   * @param {any} [defaultValue] - Default value if not found
+   * @returns {Promise<any>}
+   */
+  async getConfig(key, defaultValue = undefined) {
+    const config = await this.loadAll();
+    return config[key] !== undefined ? config[key] : defaultValue;
+  }
+
+  /**
+   * Save workflow-specific configuration
+   * @param {string} name - Workflow/config name (e.g., 'wordpress', 'openstack')
+   * @param {Object} config - Configuration values
+   * @returns {Promise<boolean>}
+   */
+  async saveWorkflowConfig(name, config) {
+    const configDir = this.getClaudeConfigDir();
+
+    try {
+      await fs.ensureDir(configDir);
+
+      const configPath = path.join(configDir, `${name}.json`);
+      await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+
+      // Invalidate cache
+      this.configCache = null;
+
+      return true;
+    } catch (error) {
+      console.error(`Failed to save ${name} config: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Save configuration to .env file
+   * @param {Object} config - Configuration to save
+   * @param {boolean} [merge=true] - Merge with existing .env
+   * @returns {Promise<boolean>}
+   */
+  async saveEnvConfig(config, merge = true) {
+    const envPath = this.getEnvPath();
+
+    try {
+      let existing = {};
+      if (merge) {
+        existing = await this.loadEnvFile();
+      }
+
+      const merged = { ...existing, ...config };
+      const content = this.formatEnvContent(merged);
+
+      await fs.writeFile(envPath, content, 'utf-8');
+
+      // Invalidate cache
+      this.configCache = null;
+
+      return true;
+    } catch (error) {
+      console.error(`Failed to save .env config: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Validate configuration against a schema
+   * @param {Object} config - Configuration to validate
+   * @param {string} schemaName - Schema name ('wordpress', 'openstack', etc.)
+   * @returns {{valid: boolean, missing: string[], warnings: string[]}}
+   */
+  validateConfig(config, schemaName) {
+    const schema = SCHEMAS[schemaName];
+    if (!schema) {
+      return { valid: false, missing: [], warnings: [`Unknown schema: ${schemaName}`] };
+    }
+
+    const missing = [];
+    const warnings = [];
+
+    // Check required fields
+    for (const field of schema.required || []) {
+      if (!config[field] || config[field].trim() === '') {
+        missing.push(field);
+      }
+    }
+
+    // Check for empty optional fields
+    for (const field of schema.optional || []) {
+      if (config[field] === '') {
+        warnings.push(`${field} is empty, using default`);
+      }
+    }
+
+    return {
+      valid: missing.length === 0,
+      missing,
+      warnings
+    };
+  }
+
+  /**
+   * Merge multiple configurations
+   * @param {Object} base - Base configuration
+   * @param {...Object} overrides - Override configurations
+   * @returns {Object} Merged configuration
+   */
+  mergeConfigs(base, ...overrides) {
+    const result = { ...base };
+
+    for (const override of overrides) {
+      for (const [key, value] of Object.entries(override)) {
+        if (value !== undefined && value !== null && value !== '') {
+          result[key] = value;
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Check if a specific configuration is complete
+   * @param {string} schemaName - Schema name to check
+   * @returns {Promise<{complete: boolean, missing: string[]}>}
+   */
+  async isConfigured(schemaName) {
+    const config = await this.loadAll();
+    const validation = this.validateConfig(config, schemaName);
+
+    return {
+      complete: validation.valid,
+      missing: validation.missing
+    };
+  }
+
+  /**
+   * Get configuration for a specific workflow
+   * @param {string} workflowName - Workflow name
+   * @returns {Promise<Object>}
+   */
+  async getWorkflowConfig(workflowName) {
+    const config = await this.loadAll();
+    const prefix = workflowName.toUpperCase() + '_';
+
+    const workflowConfig = {};
+    for (const [key, value] of Object.entries(config)) {
+      if (key.startsWith(prefix) || key.startsWith(workflowName.toUpperCase())) {
+        workflowConfig[key] = value;
+      }
+    }
+
+    return workflowConfig;
+  }
+
+  /**
+   * Parse .env content into object
+   * @param {string} content - .env file content
+   * @returns {Object}
+   */
+  parseEnvContent(content) {
+    const result = {};
+    const lines = content.split('\n');
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      // Skip empty lines and comments
+      if (!trimmed || trimmed.startsWith('#')) {
+        continue;
+      }
+
+      const match = trimmed.match(/^([^=]+)=(.*)$/);
+      if (match) {
+        const key = match[1].trim();
+        let value = match[2].trim();
+
+        // Remove quotes if present
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+          value = value.slice(1, -1);
+        }
+
+        result[key] = value;
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Format object as .env content
+   * @param {Object} config - Configuration object
+   * @returns {string}
+   */
+  formatEnvContent(config) {
+    const lines = [];
+
+    // Group by prefix for better organization
+    const groups = {};
+    const noPrefix = [];
+
+    for (const [key, value] of Object.entries(config)) {
+      if (value === undefined || value === null) continue;
+
+      const prefixMatch = key.match(/^([A-Z]+)_/);
+      if (prefixMatch) {
+        const prefix = prefixMatch[1];
+        if (!groups[prefix]) groups[prefix] = [];
+        groups[prefix].push([key, value]);
+      } else {
+        noPrefix.push([key, value]);
+      }
+    }
+
+    // Format groups
+    for (const [prefix, entries] of Object.entries(groups)) {
+      lines.push(`# ${prefix} Configuration`);
+      for (const [key, value] of entries) {
+        lines.push(this.formatEnvLine(key, value));
+      }
+      lines.push('');
+    }
+
+    // Format ungrouped
+    if (noPrefix.length > 0) {
+      lines.push('# General Configuration');
+      for (const [key, value] of noPrefix) {
+        lines.push(this.formatEnvLine(key, value));
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Format a single .env line
+   * @param {string} key - Key
+   * @param {any} value - Value
+   * @returns {string}
+   */
+  formatEnvLine(key, value) {
+    const stringValue = String(value);
+    const needsQuotes = stringValue.includes(' ') ||
+                       stringValue.includes('#') ||
+                       stringValue.includes('=');
+
+    return needsQuotes ? `${key}="${stringValue}"` : `${key}=${stringValue}`;
+  }
+
+  /**
+   * Delete a configuration key
+   * @param {string} key - Key to delete
+   * @returns {Promise<boolean>}
+   */
+  async deleteConfig(key) {
+    const config = await this.loadEnvFile();
+
+    if (config[key] !== undefined) {
+      delete config[key];
+      await this.saveEnvConfig(config, false);
+      this.configCache = null;
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * List all configuration keys
+   * @returns {Promise<string[]>}
+   */
+  async listConfigKeys() {
+    const config = await this.loadAll();
+    return Object.keys(config).sort();
+  }
+}
+
+// Singleton instance for convenience
+let defaultInstance = null;
+
+/**
+ * Get the default ConfigManager instance
+ * @param {string} [projectRoot] - Project root directory
+ * @returns {ConfigManager}
+ */
+export function getConfigManager(projectRoot) {
+  if (!defaultInstance || (projectRoot && projectRoot !== defaultInstance.projectRoot)) {
+    defaultInstance = new ConfigManager(projectRoot);
+  }
+  return defaultInstance;
+}
+
+export default ConfigManager;