myaidev-method 0.2.19 → 0.2.23

package/src/index.js

@@ -2,19 +2,32 @@ export { WordPressMCP } from './mcp/wordpress-integration.js';
 
 export const MyAIDevMethod = {
   version: '1.0.0',
-  agents: {
-    'content-writer': {
-      config: './agents/content-writer.json',
-      prompt: './agents/content-writer-prompt.md'
+  templates: {
+    claude: {
+      agents: './templates/claude/agents/',
+      commands: './templates/claude/commands/'
+    },
+    gemini: {
+      commands: './templates/gemini/commands/'
+    },
+    codex: {
+      commands: './templates/codex/commands/'
     }
   },
+  agents: {
+    // Agent templates are now in src/templates/claude/agents/
+    'content-writer': './templates/claude/agents/content-writer.md',
+    'content-rules-setup': './templates/claude/agents/content-rules-setup.md',
+    'visual-content-generator': './templates/claude/agents/visual-content-generator.md',
+    'content-production-coordinator': './templates/claude/agents/content-production-coordinator.md'
+  },
   mcp: {
     wordpress: './mcp/wordpress-mcp.json'
   },
-  commands: {
-    claude: './templates/claude/slash_commands.json',
-    gemini: './templates/gemini/commands.json',
-    codex: './templates/codex/commands.json'
+  lib: {
+    visualGeneration: './lib/visual-generation-utils.js',
+    assetManagement: './lib/asset-management.js',
+    visualConfig: './lib/visual-config-utils.js'
   }
 };
 

package/src/lib/payloadcms-utils.js

@@ -375,6 +375,212 @@ export class PayloadCMSUtils {
     }];
   }
 
+  /**
+   * Validate Lexical JSON structure
+   * Ensures output matches PayloadCMS Lexical editor format
+   * @param {Object} lexicalJSON - The Lexical JSON to validate
+   * @param {Object} options - Validation options
+   * @returns {Object} Validation result with errors array
+   */
+  validateLexicalStructure(lexicalJSON, options = {}) {
+    const errors = [];
+    const warnings = [];
+
+    // Check root structure
+    if (!lexicalJSON || typeof lexicalJSON !== 'object') {
+      errors.push('Lexical JSON must be an object');
+      return { valid: false, errors, warnings };
+    }
+
+    if (!lexicalJSON.root) {
+      errors.push('Missing root node');
+      return { valid: false, errors, warnings };
+    }
+
+    const root = lexicalJSON.root;
+
+    // Validate root node
+    if (root.type !== 'root') {
+      errors.push(`Root type must be 'root', got '${root.type}'`);
+    }
+
+    if (!Array.isArray(root.children)) {
+      errors.push('Root must have children array');
+      return { valid: false, errors, warnings };
+    }
+
+    // Validate each child node
+    const validateNode = (node, path = 'root') => {
+      if (!node || typeof node !== 'object') {
+        errors.push(`${path}: Node must be an object`);
+        return;
+      }
+
+      if (!node.type) {
+        errors.push(`${path}: Node missing type property`);
+        return;
+      }
+
+      // Validate based on node type
+      switch (node.type) {
+        case 'heading':
+          if (!node.tag || !/^h[1-6]$/.test(node.tag)) {
+            errors.push(`${path}: Heading must have tag h1-h6, got '${node.tag}'`);
+          }
+          if (!Array.isArray(node.children)) {
+            errors.push(`${path}: Heading must have children array`);
+          }
+          break;
+
+        case 'paragraph':
+          if (!Array.isArray(node.children)) {
+            errors.push(`${path}: Paragraph must have children array`);
+          }
+          break;
+
+        case 'list':
+          if (!['bullet', 'number', 'check'].includes(node.listType)) {
+            errors.push(`${path}: List listType must be bullet/number/check, got '${node.listType}'`);
+          }
+          if (!['ul', 'ol'].includes(node.tag)) {
+            errors.push(`${path}: List tag must be ul/ol, got '${node.tag}'`);
+          }
+          if (!Array.isArray(node.children)) {
+            errors.push(`${path}: List must have children array`);
+          }
+          // Validate list items
+          node.children?.forEach((item, i) => {
+            if (item.type !== 'listitem') {
+              errors.push(`${path}.children[${i}]: List child must be listitem, got '${item.type}'`);
+            }
+          });
+          break;
+
+        case 'listitem':
+          if (!Array.isArray(node.children)) {
+            errors.push(`${path}: Listitem must have children array`);
+          }
+          break;
+
+        case 'text':
+          if (typeof node.text !== 'string') {
+            errors.push(`${path}: Text node must have string text property`);
+          }
+          if (typeof node.format !== 'number') {
+            errors.push(`${path}: Text node format must be number, got ${typeof node.format}`);
+          }
+          // Validate format is valid bitwise combination
+          if (node.format !== 0 && options.strictFormat) {
+            const validFormats = [1, 2, 3, 4, 8, 16, 32, 64, 128];
+            const isValidCombination = (format) => {
+              // Check if format is valid bitwise combination of base values
+              return format <= 255 && (format & ~255) === 0;
+            };
+            if (!isValidCombination(node.format)) {
+              warnings.push(`${path}: Unusual format value ${node.format}, expected bitwise combination`);
+            }
+          }
+          break;
+
+        case 'link':
+          if (typeof node.url !== 'string') {
+            errors.push(`${path}: Link must have string url property`);
+          }
+          if (!Array.isArray(node.children)) {
+            errors.push(`${path}: Link must have children array`);
+          }
+          break;
+
+        case 'code':
+          if (!Array.isArray(node.children)) {
+            errors.push(`${path}: Code must have children array`);
+          }
+          break;
+
+        case 'quote':
+          if (!Array.isArray(node.children)) {
+            errors.push(`${path}: Quote must have children array`);
+          }
+          break;
+
+        case 'horizontalrule':
+          // HR nodes don't have children
+          break;
+
+        default:
+          if (options.strict) {
+            warnings.push(`${path}: Unknown node type '${node.type}'`);
+          }
+      }
+
+      // Recursively validate children
+      if (Array.isArray(node.children)) {
+        node.children.forEach((child, i) => {
+          validateNode(child, `${path}.children[${i}]`);
+        });
+      }
+    };
+
+    // Validate all root children
+    root.children.forEach((child, i) => {
+      validateNode(child, `root.children[${i}]`);
+    });
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+
+  /**
+   * Validate and optionally fix Lexical format codes
+   * Ensures format codes follow Lexical bitwise specification
+   * @param {number} format - The format code to validate
+   * @returns {Object} Validation result
+   */
+  validateFormatCode(format) {
+    const VALID_FORMATS = {
+      BOLD: 1,            // 1 << 0
+      ITALIC: 2,          // 1 << 1
+      STRIKETHROUGH: 4,   // 1 << 2
+      UNDERLINE: 8,       // 1 << 3
+      CODE: 16,           // 1 << 4
+      SUBSCRIPT: 32,      // 1 << 5
+      SUPERSCRIPT: 64,    // 1 << 6
+      HIGHLIGHT: 128      // 1 << 7
+    };
+
+    if (typeof format !== 'number') {
+      return {
+        valid: false,
+        error: `Format must be number, got ${typeof format}`
+      };
+    }
+
+    if (format < 0 || format > 255) {
+      return {
+        valid: false,
+        error: `Format must be between 0 and 255, got ${format}`
+      };
+    }
+
+    // Decompose format into individual flags
+    const flags = [];
+    Object.entries(VALID_FORMATS).forEach(([name, value]) => {
+      if ((format & value) === value) {
+        flags.push(name);
+      }
+    });
+
+    return {
+      valid: true,
+      format,
+      flags,
+      description: flags.length > 0 ? flags.join(' + ') : 'Plain text'
+    };
+  }
+
   /**
    * List all collections
    */

package/src/lib/update-manager.js

@@ -234,7 +234,8 @@ export async function updateComponent(componentType, projectDir, cliType, source
 
   const files = componentType === 'docs'
     ? ['USER_GUIDE.md', 'PUBLISHING_GUIDE.md', 'COOLIFY_DEPLOYMENT.md', 'DEV_WORKFLOW_GUIDE.md',
-       'MCP_INTEGRATION.md', 'WORDPRESS_ADMIN_SCRIPTS.md', 'TECHNICAL_ARCHITECTURE.md']
+       'MCP_INTEGRATION.md', 'WORDPRESS_ADMIN_SCRIPTS.md', 'TECHNICAL_ARCHITECTURE.md',
+       'WORDPRESS_INTEGRATION.md', 'wordpress-api-examples.md']
     : await fs.readdir(sourceSubDir);
 
   for (const file of files) {