myaidev-method 0.1.0 → 0.2.0

package/README.md

@@ -33,11 +33,13 @@ A comprehensive package for AI CLI tools (Claude Code, Gemini CLI, Codex CLI) th
 - 🤖 **Custom Subagents**: Pre-configured AI agents in Markdown format with YAML frontmatter
 - 📝 **Content Writer Agent**: Professional content creation with SEO optimization
 - 🔐 **WordPress Admin Agent**: Site administration, security analysis, and performance optimization
-- 🔌 **WordPress MCP Integration**: Direct publishing and administration via REST API
-- 💻 **SSH Integration**: Server-level operations for advanced WordPress administration
+- 📤 **Multi-Platform Publishing**: Publish to WordPress, PayloadCMS, Docusaurus, Mintlify, and Astro
+- 🚀 **Coolify Deployment**: Self-hosted PaaS deployment and management
+- 🔌 **MCP Integration**: WordPress, git-based workflows, and more
+- 💻 **SSH Integration**: Server-level operations for advanced administration
 - 🎯 **Slash Commands**: Easy-to-use Markdown-based commands for Claude Code
-- 🚀 **Multi-CLI Support**: Works with Claude Code, Gemini CLI, and Codex CLI
-- ✅ **Standards Compliant**: Follows Claude Code's official `.claude/` folder structure
+- 🔄 **Git-Based Publishing**: Automated git workflows for static sites
+- ✅ **Standards Compliant**: Follows Claude Code 2.0 agent patterns
 
 ## 🚀 Installation
 
@@ -111,16 +113,76 @@ Professional content writer specializing in creating high-quality, engaging, and
 - Multiple tone and audience support
 - Keyword optimization
 
-### WordPress Admin Agent
+### Publishing Agents
+
+#### WordPress Admin Agent
 **File:** `.claude/agents/wordpress-admin.md`
 
 WordPress administrator for comprehensive site management, security, performance, and health analysis.
 
 **Capabilities:**
-- **Security:** Vulnerability scanning, malware detection, user auditing
-- **Performance:** Speed optimization, database cleanup, caching setup
-- **Health:** Site monitoring, error analysis, backup verification
-- **Administration:** User/plugin/theme management, content cleanup
+- Security: Vulnerability scanning, malware detection, user auditing
+- Performance: Speed optimization, database cleanup, caching setup
+- Health: Site monitoring, error analysis, backup verification
+- Administration: User/plugin/theme management, content cleanup
+
+#### PayloadCMS Publishing Agent
+**File:** `.claude/agents/payloadcms-publish.md`
+
+Publish markdown content to PayloadCMS headless CMS with Lexical rich text conversion.
+
+**Capabilities:**
+- Markdown to Lexical conversion
+- JWT authentication
+- Draft and published workflows
+- Custom collections support
+- Document updates
+
+#### Docusaurus Publishing Agent
+**File:** `.claude/agents/docusaurus-publish.md`
+
+Git-based publishing for Docusaurus documentation sites.
+
+**Capabilities:**
+- Docs, blog, and pages support
+- Automatic frontmatter transformation
+- Sidebar configuration
+- Git commit and push automation
+
+#### Mintlify Publishing Agent
+**File:** `.claude/agents/mintlify-publish.md`
+
+Git-based publishing for Mintlify documentation with automatic navigation.
+
+**Capabilities:**
+- MDX transformation
+- mint.json navigation updates
+- Icon and metadata support
+- Git workflow automation
+
+#### Astro Publishing Agent
+**File:** `.claude/agents/astro-publish.md`
+
+Git-based publishing for Astro sites with content collections support.
+
+**Capabilities:**
+- Content collections publishing
+- Schema-validated frontmatter
+- pubDate transformation
+- Draft/published workflow
+
+### Deployment Agent
+
+#### Coolify Deployment Agent
+**File:** `.claude/agents/coolify-deploy.md`
+
+Self-hosted PaaS deployment for applications.
+
+**Capabilities:**
+- Application deployment
+- Health monitoring
+- Resource management
+- Multi-environment support
 
 ## 🎯 Slash Commands
 
@@ -179,34 +241,70 @@ Comprehensive WordPress site administration.
 /myai-wordpress-admin staging-deploy
 ```
 
-### `/myai-wordpress-publish`
-Publish existing markdown content to WordPress.
+### Publishing Commands
+
+#### `/myai-wordpress-publish`
+Publish markdown content to WordPress.
 
 ```bash
-# Publish as draft (default)
-/myai-wordpress-publish "content/article.md"
+/myai-wordpress-publish "article.md" --status draft
+/myai-wordpress-publish "article.md" --status published
+```
 
-# Publish immediately
-/myai-wordpress-publish "blog-post.md" --status publish
+#### `/myai-payloadcms-publish`
+Publish markdown content to PayloadCMS.
 
-# Publish with specific status
-/myai-wordpress-publish "draft-post.md" --status pending
+```bash
+/myai-payloadcms-publish "article.md" --collection posts
+/myai-payloadcms-publish "article.md" --status published --id 12345
 ```
 
-### `/myai-configure`
-Configure MyAI Method settings.
+#### `/myai-docusaurus-publish`
+Publish markdown content to Docusaurus.
+
+```bash
+/myai-docusaurus-publish "guide.md"
+/myai-docusaurus-publish "post.md" --type blog
+```
+
+#### `/myai-mintlify-publish`
+Publish markdown content to Mintlify.
+
+```bash
+/myai-mintlify-publish "guide.mdx"
+/myai-mintlify-publish "api-ref.md" --nav-section "API Reference"
+```
+
+#### `/myai-astro-publish`
+Publish markdown content to Astro.
 
 ```bash
-# WordPress setup
-/myai-configure wordpress
+/myai-astro-publish "article.md" --collection blog
+/myai-astro-publish "page.md" --pages
+```
+
+### Deployment Commands
 
-# Default content settings
-/myai-configure defaults
+#### `/myai-coolify-deploy`
+Deploy applications to Coolify.
 
-# Agent management
-/myai-configure agents
+```bash
+/myai-coolify-deploy
 ```
 
+### Configuration
+
+#### `/myai-configure`
+Configure MyAI Method settings.
+
+```bash
+/myai-configure
+```
+
+### Comprehensive Guide
+
+For detailed publishing workflows and platform-specific guides, see **[PUBLISHING_GUIDE.md](PUBLISHING_GUIDE.md)**
+
 ## ⚙️ Configuration
 
 After installation for Claude Code, the package creates a `.claude` directory following official standards:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myaidev-method",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "AI CLI tools package with custom subagents and MCP integrations for Claude Code, Gemini CLI, and more",
   "mcpName": "io.github.myaione/myaidev-method",
   "main": "src/index.js",
@@ -29,15 +29,31 @@
     "wordpress:performance-check": "node src/scripts/wordpress-performance-check.js",
     "wordpress:comprehensive-report": "node src/scripts/wordpress-comprehensive-report.js",
     "coolify:status": "node src/scripts/coolify-status.js",
-    "coolify:list": "node src/scripts/coolify-list-resources.js"
+    "coolify:list": "node src/scripts/coolify-list-resources.js",
+    "payloadcms:publish": "node src/scripts/payloadcms-publish.js",
+    "docusaurus:publish": "node src/scripts/docusaurus-publish.js",
+    "mintlify:publish": "node src/scripts/mintlify-publish.js",
+    "astro:publish": "node src/scripts/astro-publish.js",
+    "configure": "node src/scripts/configure-cms.js",
+    "init": "node src/scripts/init-project.js"
   },
   "keywords": [
     "claude-code",
     "ai-cli",
     "mcp",
     "wordpress",
+    "payloadcms",
+    "payload",
+    "docusaurus",
+    "mintlify",
+    "astro",
     "coolify",
     "content-writer",
+    "cms",
+    "headless-cms",
+    "publishing",
+    "static-site",
+    "documentation",
     "ai-agents",
     "automation",
     "deployment",
@@ -56,9 +72,12 @@
     "commander": "^12.0.0",
     "dotenv": "^16.4.1",
     "fs-extra": "^11.2.0",
+    "gray-matter": "^4.0.3",
     "inquirer": "^9.2.15",
+    "marked": "^11.0.0",
     "node-fetch": "^3.3.2",
     "ora": "^8.0.1",
+    "simple-git": "^3.22.0",
     "ssh2": "^1.15.0",
     "zod": "^3.23.8"
   },
@@ -80,7 +99,10 @@
     "LICENSE",
     ".env.example",
     "WORDPRESS_ADMIN_SCRIPTS.md",
-    "COOLIFY_DEPLOYMENT.md"
+    "COOLIFY_DEPLOYMENT.md",
+    "PAYLOADCMS_PUBLISHING.md",
+    "STATIC_SITE_PUBLISHING.md",
+    "PUBLISHING_GUIDE.md"
   ],
   "engines": {
     "node": ">=18.0.0"

package/src/lib/payloadcms-utils.js

@@ -0,0 +1,394 @@
+/**
+ * PayloadCMS API Utilities
+ * Reusable functions for PayloadCMS content publishing and management
+ * Optimized for Claude Code 2.0 agent integration
+ */
+
+import fetch from 'node-fetch';
+import { readFileSync } from 'fs';
+import { parse } from 'dotenv';
+import { marked } from 'marked';
+
+export class PayloadCMSUtils {
+  constructor(config = {}) {
+    // Load config from .env if not provided
+    if (!config.url || (!config.email && !config.apiKey)) {
+      const envConfig = this.loadEnvConfig();
+      config = { ...envConfig, ...config };
+    }
+
+    this.url = config.url?.replace(/\/$/, '');
+    this.email = config.email;
+    this.password = config.password;
+    this.apiKey = config.apiKey;
+    this.token = null;
+  }
+
+  loadEnvConfig() {
+    try {
+      const envPath = process.env.ENV_PATH || '.env';
+      const envContent = readFileSync(envPath, 'utf8');
+      const parsed = parse(envContent);
+
+      return {
+        url: parsed.PAYLOADCMS_URL,
+        email: parsed.PAYLOADCMS_EMAIL,
+        password: parsed.PAYLOADCMS_PASSWORD,
+        apiKey: parsed.PAYLOADCMS_API_KEY
+      };
+    } catch (error) {
+      throw new Error(`Failed to load PayloadCMS configuration: ${error.message}`);
+    }
+  }
+
+  /**
+   * Authenticate with PayloadCMS and get JWT token
+   */
+  async authenticate() {
+    // If API key is provided, use that instead
+    if (this.apiKey) {
+      this.token = this.apiKey;
+      return { success: true, method: 'api-key' };
+    }
+
+    if (!this.email || !this.password) {
+      throw new Error('Email and password required for authentication');
+    }
+
+    try {
+      const response = await fetch(`${this.url}/api/users/login`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          email: this.email,
+          password: this.password
+        })
+      });
+
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Authentication failed: ${error}`);
+      }
+
+      const data = await response.json();
+      this.token = data.token;
+
+      return {
+        success: true,
+        method: 'jwt',
+        user: data.user,
+        token: this.token
+      };
+    } catch (error) {
+      throw new Error(`PayloadCMS authentication failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Make authenticated API request
+   */
+  async request(endpoint, options = {}) {
+    if (!this.token) {
+      await this.authenticate();
+    }
+
+    const url = `${this.url}${endpoint}`;
+    const headers = {
+      'Content-Type': 'application/json',
+      'Authorization': `JWT ${this.token}`,
+      ...options.headers
+    };
+
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers
+      });
+
+      const data = await response.json().catch(() => ({}));
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${data.message || response.statusText}`);
+      }
+
+      return data;
+    } catch (error) {
+      throw new Error(`PayloadCMS API request failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Convert markdown to Lexical rich text format
+   * PayloadCMS uses Lexical editor by default
+   */
+  convertMarkdownToLexical(markdown) {
+    const tokens = marked.lexer(markdown);
+
+    const convertToken = (token) => {
+      switch (token.type) {
+        case 'heading':
+          return {
+            type: 'heading',
+            tag: `h${token.depth}`,
+            children: [{ type: 'text', text: token.text, format: 0 }],
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            version: 1
+          };
+
+        case 'paragraph':
+          return {
+            type: 'paragraph',
+            children: this.parseInlineText(token.text),
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            version: 1
+          };
+
+        case 'list':
+          return {
+            type: token.ordered ? 'number' : 'bullet',
+            listType: token.ordered ? 'number' : 'bullet',
+            start: token.start || 1,
+            tag: token.ordered ? 'ol' : 'ul',
+            children: token.items.map(item => ({
+              type: 'listitem',
+              value: 1,
+              children: [{
+                type: 'paragraph',
+                children: this.parseInlineText(item.text),
+                direction: 'ltr',
+                format: '',
+                indent: 0
+              }],
+              direction: 'ltr',
+              format: '',
+              indent: 0
+            })),
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            version: 1
+          };
+
+        case 'code':
+          return {
+            type: 'code',
+            language: token.lang || 'plaintext',
+            children: [{ type: 'text', text: token.text, format: 0 }],
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            version: 1
+          };
+
+        case 'blockquote':
+          return {
+            type: 'quote',
+            children: [{
+              type: 'paragraph',
+              children: this.parseInlineText(token.text),
+              direction: 'ltr',
+              format: '',
+              indent: 0
+            }],
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            version: 1
+          };
+
+        case 'hr':
+          return {
+            type: 'horizontalrule',
+            version: 1
+          };
+
+        default:
+          return {
+            type: 'paragraph',
+            children: [{ type: 'text', text: token.raw || '', format: 0 }],
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            version: 1
+          };
+      }
+    };
+
+    const children = tokens.map(convertToken);
+
+    return {
+      root: {
+        type: 'root',
+        format: '',
+        indent: 0,
+        version: 1,
+        children,
+        direction: 'ltr'
+      }
+    };
+  }
+
+  /**
+   * Parse inline text with formatting (bold, italic, code, links)
+   */
+  parseInlineText(text) {
+    // Simple inline parser for bold, italic, code, links
+    const children = [];
+
+    // For now, return simple text node
+    // TODO: Enhance with full inline formatting support
+    children.push({
+      type: 'text',
+      text: text.replace(/<[^>]+>/g, ''), // Strip HTML tags
+      format: 0,
+      mode: 'normal',
+      style: '',
+      detail: 0,
+      version: 1
+    });
+
+    return children;
+  }
+
+  /**
+   * List all collections
+   */
+  async listCollections() {
+    return await this.request('/api');
+  }
+
+  /**
+   * Get documents from a collection
+   */
+  async getDocuments(collection, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.append('limit', options.limit);
+    if (options.page) params.append('page', options.page);
+    if (options.where) params.append('where', JSON.stringify(options.where));
+
+    const query = params.toString() ? `?${params.toString()}` : '';
+    return await this.request(`/api/${collection}${query}`);
+  }
+
+  /**
+   * Get a single document by ID
+   */
+  async getDocument(collection, id) {
+    return await this.request(`/api/${collection}/${id}`);
+  }
+
+  /**
+   * Create a new document in a collection
+   */
+  async createDocument(collection, data) {
+    return await this.request(`/api/${collection}`, {
+      method: 'POST',
+      body: JSON.stringify(data)
+    });
+  }
+
+  /**
+   * Update an existing document
+   */
+  async updateDocument(collection, id, data) {
+    return await this.request(`/api/${collection}/${id}`, {
+      method: 'PATCH',
+      body: JSON.stringify(data)
+    });
+  }
+
+  /**
+   * Delete a document
+   */
+  async deleteDocument(collection, id) {
+    return await this.request(`/api/${collection}/${id}`, {
+      method: 'DELETE'
+    });
+  }
+
+  /**
+   * Upload media file
+   */
+  async uploadMedia(filePath, altText = '') {
+    if (!this.token) {
+      await this.authenticate();
+    }
+
+    const FormData = (await import('form-data')).default;
+    const fs = await import('fs');
+
+    const formData = new FormData();
+    formData.append('file', fs.createReadStream(filePath));
+    if (altText) formData.append('alt', altText);
+
+    try {
+      const response = await fetch(`${this.url}/api/media`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `JWT ${this.token}`,
+          ...formData.getHeaders()
+        },
+        body: formData
+      });
+
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Upload failed: ${error}`);
+      }
+
+      return await response.json();
+    } catch (error) {
+      throw new Error(`Media upload failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Publish markdown content to PayloadCMS
+   */
+  async publishContent(markdownFile, collection, options = {}) {
+    const fs = await import('fs');
+    const grayMatter = (await import('gray-matter')).default;
+
+    // Read and parse markdown file
+    const fileContent = fs.readFileSync(markdownFile, 'utf8');
+    const { data: frontmatter, content } = grayMatter(fileContent);
+
+    // Convert markdown to Lexical format
+    const richText = this.convertMarkdownToLexical(content);
+
+    // Prepare document data
+    const documentData = {
+      ...frontmatter,
+      content: richText,
+      status: options.status || frontmatter.status || 'draft',
+      ...options.additionalFields
+    };
+
+    // Create or update document
+    if (options.id) {
+      return await this.updateDocument(collection, options.id, documentData);
+    } else {
+      return await this.createDocument(collection, documentData);
+    }
+  }
+
+  /**
+   * Health check
+   */
+  async healthCheck() {
+    try {
+      const response = await fetch(`${this.url}/api`);
+      return response.ok;
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+export default PayloadCMSUtils;