myaidev-method 0.2.23 → 0.2.24-2

package/src/lib/wordpress-client.js

@@ -0,0 +1,633 @@
+/**
+ * WordPress Client
+ * High-level WordPress API client for content publishing
+ * Wraps wordpress-admin-utils.js functionality
+ */
+
+import { getConfigManager } from './config-manager.js';
+
+/**
+ * WordPress Client Class
+ */
+export class WordPressClient {
+  constructor(options = {}) {
+    this.siteUrl = options.siteUrl || null;
+    this.username = options.username || null;
+    this.appPassword = options.appPassword || null;
+    this.configManager = options.configManager || getConfigManager();
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize the client with configuration
+   * @returns {Promise<boolean>} True if initialization successful
+   */
+  async initialize() {
+    if (this.initialized) {
+      return true;
+    }
+
+    const config = await this.configManager.loadAll();
+
+    this.siteUrl = this.siteUrl || config.WORDPRESS_URL;
+    this.username = this.username || config.WORDPRESS_USERNAME;
+    this.appPassword = this.appPassword || config.WORDPRESS_APP_PASSWORD;
+    this.defaultStatus = config.WORDPRESS_DEFAULT_STATUS || 'draft';
+
+    // Validate required fields
+    if (!this.siteUrl || !this.username || !this.appPassword) {
+      return false;
+    }
+
+    // Normalize site URL
+    this.siteUrl = this.siteUrl.replace(/\/+$/, '');
+    if (!this.siteUrl.startsWith('http')) {
+      this.siteUrl = 'https://' + this.siteUrl;
+    }
+
+    this.initialized = true;
+    return true;
+  }
+
+  /**
+   * Get authentication header
+   * @returns {Object} Headers object with authorization
+   */
+  getAuthHeaders() {
+    const auth = Buffer.from(`${this.username}:${this.appPassword}`).toString('base64');
+    return {
+      'Authorization': `Basic ${auth}`,
+      'Content-Type': 'application/json'
+    };
+  }
+
+  /**
+   * Validate connection to WordPress
+   * @returns {Promise<{valid: boolean, message: string, user?: Object}>}
+   */
+  async validateConnection() {
+    const initialized = await this.initialize();
+    if (!initialized) {
+      return {
+        valid: false,
+        message: 'WordPress credentials not configured. Run /myai-configure wordpress'
+      };
+    }
+
+    try {
+      const response = await fetch(`${this.siteUrl}/wp-json/wp/v2/users/me`, {
+        method: 'GET',
+        headers: this.getAuthHeaders()
+      });
+
+      if (!response.ok) {
+        const text = await response.text();
+        return {
+          valid: false,
+          message: `Authentication failed: ${response.status} ${text}`
+        };
+      }
+
+      const user = await response.json();
+      return {
+        valid: true,
+        message: `Connected as ${user.name} (${user.slug})`,
+        user
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        message: `Connection error: ${error.message}`
+      };
+    }
+  }
+
+  /**
+   * Publish a post to WordPress
+   * @param {Object} postData - Post data
+   * @param {string} postData.title - Post title
+   * @param {string} postData.content - Post content (HTML or markdown)
+   * @param {string} [postData.status='draft'] - Post status (draft, publish, pending)
+   * @param {string} [postData.excerpt] - Post excerpt
+   * @param {number[]} [postData.categories] - Category IDs
+   * @param {number[]} [postData.tags] - Tag IDs
+   * @param {string} [postData.slug] - URL slug
+   * @param {number} [postData.featured_media] - Featured image ID
+   * @returns {Promise<{success: boolean, post?: Object, error?: string}>}
+   */
+  async publishPost(postData) {
+    const initialized = await this.initialize();
+    if (!initialized) {
+      return {
+        success: false,
+        error: 'WordPress credentials not configured'
+      };
+    }
+
+    try {
+      const payload = {
+        title: postData.title,
+        content: this.convertMarkdownToHtml(postData.content),
+        status: postData.status || this.defaultStatus,
+        excerpt: postData.excerpt || '',
+        categories: postData.categories || [],
+        tags: postData.tags || [],
+        slug: postData.slug || this.generateSlug(postData.title),
+        featured_media: postData.featured_media || 0
+      };
+
+      const response = await fetch(`${this.siteUrl}/wp-json/wp/v2/posts`, {
+        method: 'POST',
+        headers: this.getAuthHeaders(),
+        body: JSON.stringify(payload)
+      });
+
+      if (!response.ok) {
+        const error = await response.json();
+        return {
+          success: false,
+          error: error.message || `HTTP ${response.status}`
+        };
+      }
+
+      const post = await response.json();
+      return {
+        success: true,
+        post: {
+          id: post.id,
+          title: post.title.rendered,
+          status: post.status,
+          link: post.link,
+          editLink: `${this.siteUrl}/wp-admin/post.php?post=${post.id}&action=edit`
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Create a draft post
+   * @param {Object} postData - Post data (same as publishPost)
+   * @returns {Promise<{success: boolean, post?: Object, error?: string}>}
+   */
+  async createDraft(postData) {
+    return this.publishPost({ ...postData, status: 'draft' });
+  }
+
+  /**
+   * Update an existing post
+   * @param {number} postId - Post ID to update
+   * @param {Object} data - Data to update
+   * @returns {Promise<{success: boolean, post?: Object, error?: string}>}
+   */
+  async updatePost(postId, data) {
+    const initialized = await this.initialize();
+    if (!initialized) {
+      return {
+        success: false,
+        error: 'WordPress credentials not configured'
+      };
+    }
+
+    try {
+      const payload = {};
+
+      if (data.title) payload.title = data.title;
+      if (data.content) payload.content = this.convertMarkdownToHtml(data.content);
+      if (data.status) payload.status = data.status;
+      if (data.excerpt) payload.excerpt = data.excerpt;
+      if (data.categories) payload.categories = data.categories;
+      if (data.tags) payload.tags = data.tags;
+      if (data.slug) payload.slug = data.slug;
+      if (data.featured_media !== undefined) payload.featured_media = data.featured_media;
+
+      const response = await fetch(`${this.siteUrl}/wp-json/wp/v2/posts/${postId}`, {
+        method: 'POST',
+        headers: this.getAuthHeaders(),
+        body: JSON.stringify(payload)
+      });
+
+      if (!response.ok) {
+        const error = await response.json();
+        return {
+          success: false,
+          error: error.message || `HTTP ${response.status}`
+        };
+      }
+
+      const post = await response.json();
+      return {
+        success: true,
+        post: {
+          id: post.id,
+          title: post.title.rendered,
+          status: post.status,
+          link: post.link,
+          editLink: `${this.siteUrl}/wp-admin/post.php?post=${post.id}&action=edit`
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Search for posts
+   * @param {string} keyword - Search keyword
+   * @param {Object} [options] - Search options
+   * @param {string} [options.status] - Filter by status
+   * @param {number} [options.perPage=10] - Results per page
+   * @returns {Promise<{success: boolean, posts?: Object[], error?: string}>}
+   */
+  async searchPosts(keyword, options = {}) {
+    const initialized = await this.initialize();
+    if (!initialized) {
+      return {
+        success: false,
+        error: 'WordPress credentials not configured'
+      };
+    }
+
+    try {
+      const params = new URLSearchParams({
+        search: keyword,
+        per_page: String(options.perPage || 10)
+      });
+
+      if (options.status) {
+        params.append('status', options.status);
+      }
+
+      const response = await fetch(
+        `${this.siteUrl}/wp-json/wp/v2/posts?${params.toString()}`,
+        {
+          method: 'GET',
+          headers: this.getAuthHeaders()
+        }
+      );
+
+      if (!response.ok) {
+        const error = await response.json();
+        return {
+          success: false,
+          error: error.message || `HTTP ${response.status}`
+        };
+      }
+
+      const posts = await response.json();
+      return {
+        success: true,
+        posts: posts.map(p => ({
+          id: p.id,
+          title: p.title.rendered,
+          status: p.status,
+          link: p.link,
+          date: p.date,
+          modified: p.modified
+        }))
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Get a single post by ID
+   * @param {number} postId - Post ID
+   * @returns {Promise<{success: boolean, post?: Object, error?: string}>}
+   */
+  async getPost(postId) {
+    const initialized = await this.initialize();
+    if (!initialized) {
+      return {
+        success: false,
+        error: 'WordPress credentials not configured'
+      };
+    }
+
+    try {
+      const response = await fetch(
+        `${this.siteUrl}/wp-json/wp/v2/posts/${postId}`,
+        {
+          method: 'GET',
+          headers: this.getAuthHeaders()
+        }
+      );
+
+      if (!response.ok) {
+        const error = await response.json();
+        return {
+          success: false,
+          error: error.message || `HTTP ${response.status}`
+        };
+      }
+
+      const post = await response.json();
+      return {
+        success: true,
+        post: {
+          id: post.id,
+          title: post.title.rendered,
+          content: post.content.rendered,
+          status: post.status,
+          link: post.link,
+          date: post.date,
+          modified: post.modified,
+          categories: post.categories,
+          tags: post.tags
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Delete a post
+   * @param {number} postId - Post ID
+   * @param {boolean} [force=false] - Permanently delete (skip trash)
+   * @returns {Promise<{success: boolean, error?: string}>}
+   */
+  async deletePost(postId, force = false) {
+    const initialized = await this.initialize();
+    if (!initialized) {
+      return {
+        success: false,
+        error: 'WordPress credentials not configured'
+      };
+    }
+
+    try {
+      const params = force ? '?force=true' : '';
+      const response = await fetch(
+        `${this.siteUrl}/wp-json/wp/v2/posts/${postId}${params}`,
+        {
+          method: 'DELETE',
+          headers: this.getAuthHeaders()
+        }
+      );
+
+      if (!response.ok) {
+        const error = await response.json();
+        return {
+          success: false,
+          error: error.message || `HTTP ${response.status}`
+        };
+      }
+
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Get categories
+   * @returns {Promise<{success: boolean, categories?: Object[], error?: string}>}
+   */
+  async getCategories() {
+    const initialized = await this.initialize();
+    if (!initialized) {
+      return {
+        success: false,
+        error: 'WordPress credentials not configured'
+      };
+    }
+
+    try {
+      const response = await fetch(
+        `${this.siteUrl}/wp-json/wp/v2/categories?per_page=100`,
+        {
+          method: 'GET',
+          headers: this.getAuthHeaders()
+        }
+      );
+
+      if (!response.ok) {
+        return {
+          success: false,
+          error: `HTTP ${response.status}`
+        };
+      }
+
+      const categories = await response.json();
+      return {
+        success: true,
+        categories: categories.map(c => ({
+          id: c.id,
+          name: c.name,
+          slug: c.slug,
+          count: c.count
+        }))
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Get tags
+   * @returns {Promise<{success: boolean, tags?: Object[], error?: string}>}
+   */
+  async getTags() {
+    const initialized = await this.initialize();
+    if (!initialized) {
+      return {
+        success: false,
+        error: 'WordPress credentials not configured'
+      };
+    }
+
+    try {
+      const response = await fetch(
+        `${this.siteUrl}/wp-json/wp/v2/tags?per_page=100`,
+        {
+          method: 'GET',
+          headers: this.getAuthHeaders()
+        }
+      );
+
+      if (!response.ok) {
+        return {
+          success: false,
+          error: `HTTP ${response.status}`
+        };
+      }
+
+      const tags = await response.json();
+      return {
+        success: true,
+        tags: tags.map(t => ({
+          id: t.id,
+          name: t.name,
+          slug: t.slug,
+          count: t.count
+        }))
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Create a category
+   * @param {string} name - Category name
+   * @param {string} [description] - Category description
+   * @returns {Promise<{success: boolean, category?: Object, error?: string}>}
+   */
+  async createCategory(name, description = '') {
+    const initialized = await this.initialize();
+    if (!initialized) {
+      return {
+        success: false,
+        error: 'WordPress credentials not configured'
+      };
+    }
+
+    try {
+      const response = await fetch(
+        `${this.siteUrl}/wp-json/wp/v2/categories`,
+        {
+          method: 'POST',
+          headers: this.getAuthHeaders(),
+          body: JSON.stringify({
+            name,
+            description,
+            slug: this.generateSlug(name)
+          })
+        }
+      );
+
+      if (!response.ok) {
+        const error = await response.json();
+        return {
+          success: false,
+          error: error.message || `HTTP ${response.status}`
+        };
+      }
+
+      const category = await response.json();
+      return {
+        success: true,
+        category: {
+          id: category.id,
+          name: category.name,
+          slug: category.slug
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Convert markdown to HTML (basic conversion)
+   * @param {string} markdown - Markdown content
+   * @returns {string} HTML content
+   */
+  convertMarkdownToHtml(markdown) {
+    if (!markdown) return '';
+
+    let html = markdown;
+
+    // Headers
+    html = html.replace(/^######\s+(.+)$/gm, '<h6>$1</h6>');
+    html = html.replace(/^#####\s+(.+)$/gm, '<h5>$1</h5>');
+    html = html.replace(/^####\s+(.+)$/gm, '<h4>$1</h4>');
+    html = html.replace(/^###\s+(.+)$/gm, '<h3>$1</h3>');
+    html = html.replace(/^##\s+(.+)$/gm, '<h2>$1</h2>');
+    html = html.replace(/^#\s+(.+)$/gm, '<h1>$1</h1>');
+
+    // Bold and italic
+    html = html.replace(/\*\*\*(.+?)\*\*\*/g, '<strong><em>$1</em></strong>');
+    html = html.replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>');
+    html = html.replace(/\*(.+?)\*/g, '<em>$1</em>');
+
+    // Links
+    html = html.replace(/\[(.+?)\]\((.+?)\)/g, '<a href="$2">$1</a>');
+
+    // Images
+    html = html.replace(/!\[(.+?)\]\((.+?)\)/g, '<img src="$2" alt="$1">');
+
+    // Code blocks
+    html = html.replace(/```(\w+)?\n([\s\S]+?)```/g, '<pre><code>$2</code></pre>');
+    html = html.replace(/`(.+?)`/g, '<code>$1</code>');
+
+    // Lists
+    html = html.replace(/^\*\s+(.+)$/gm, '<li>$1</li>');
+    html = html.replace(/^-\s+(.+)$/gm, '<li>$1</li>');
+    html = html.replace(/(<li>.*<\/li>\n?)+/g, '<ul>$&</ul>');
+
+    html = html.replace(/^\d+\.\s+(.+)$/gm, '<li>$1</li>');
+    html = html.replace(/(<li>.*<\/li>\n?)+/g, (match) => {
+      if (match.includes('<ul>')) return match;
+      return '<ol>' + match + '</ol>';
+    });
+
+    // Paragraphs
+    html = html.replace(/\n\n+/g, '</p><p>');
+    html = '<p>' + html + '</p>';
+    html = html.replace(/<p>(<h\d>)/g, '$1');
+    html = html.replace(/(<\/h\d>)<\/p>/g, '$1');
+    html = html.replace(/<p>(<ul>)/g, '$1');
+    html = html.replace(/(<\/ul>)<\/p>/g, '$1');
+    html = html.replace(/<p>(<ol>)/g, '$1');
+    html = html.replace(/(<\/ol>)<\/p>/g, '$1');
+    html = html.replace(/<p>(<pre>)/g, '$1');
+    html = html.replace(/(<\/pre>)<\/p>/g, '$1');
+    html = html.replace(/<p>\s*<\/p>/g, '');
+
+    // Line breaks
+    html = html.replace(/\n/g, '<br>');
+    html = html.replace(/<br><br>/g, '</p><p>');
+
+    return html;
+  }
+
+  /**
+   * Generate URL slug from title
+   * @param {string} title - Title to slugify
+   * @returns {string} URL slug
+   */
+  generateSlug(title) {
+    return title
+      .toLowerCase()
+      .trim()
+      .replace(/[^\w\s-]/g, '')
+      .replace(/[\s_]+/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-+|-+$/g, '');
+  }
+}
+
+// Factory function
+export function createWordPressClient(options) {
+  return new WordPressClient(options);
+}
+
+export default WordPressClient;

package/src/lib/workflow-installer.js

@@ -107,7 +107,7 @@ class WorkflowInstaller {
 
     let installed = 0;
     for (const agent of agents) {
-      const sourcePath = path.join(__dirname, '..', 'agents', `${agent}.md`);
+      const sourcePath = path.join(__dirname, '..', 'templates', 'claude', 'agents', `${agent}.md`);
       const targetPath = path.join(agentsDir, `${agent}.md`);
 
       try {
@@ -141,7 +141,7 @@ class WorkflowInstaller {
 
     let installed = 0;
     for (const command of commands) {
-      const sourcePath = path.join(__dirname, '..', 'commands', `${command}.md`);
+      const sourcePath = path.join(__dirname, '..', 'templates', 'claude', 'commands', `${command}.md`);
       const targetPath = path.join(commandsDir, `${command}.md`);
 
       try {
@@ -240,7 +240,7 @@ class WorkflowInstaller {
 
     let installed = 0;
     for (const doc of docs) {
-      const sourcePath = path.join(__dirname, '..', '..', 'docs', doc);
+      const sourcePath = path.join(__dirname, '..', 'templates', 'docs', doc);
       const targetPath = path.join(docsDir, doc);
 
       try {