myaidev-method 0.2.23 → 0.2.24

package/src/lib/content-generator.js

@@ -0,0 +1,427 @@
+/**
+ * Content Generator
+ * Core content generation utilities for MyAIDev Method
+ * Works with content-writer agent to produce SEO-optimized content
+ */
+
+import path from 'path';
+import fs from 'fs-extra';
+import { getConfigManager } from './config-manager.js';
+
+// Content type templates
+const CONTENT_TEMPLATES = {
+  'blog-post': {
+    sections: ['introduction', 'main-content', 'conclusion', 'call-to-action'],
+    defaultWordCount: 1500,
+    frontmatter: ['title', 'description', 'date', 'author', 'categories', 'tags']
+  },
+  'tutorial': {
+    sections: ['overview', 'prerequisites', 'steps', 'troubleshooting', 'conclusion'],
+    defaultWordCount: 2000,
+    frontmatter: ['title', 'description', 'date', 'author', 'difficulty', 'time-to-complete']
+  },
+  'how-to': {
+    sections: ['introduction', 'requirements', 'step-by-step', 'tips', 'summary'],
+    defaultWordCount: 1200,
+    frontmatter: ['title', 'description', 'date', 'author', 'category']
+  },
+  'listicle': {
+    sections: ['introduction', 'list-items', 'summary'],
+    defaultWordCount: 1800,
+    frontmatter: ['title', 'description', 'date', 'author', 'categories']
+  },
+  'product-review': {
+    sections: ['overview', 'features', 'pros-cons', 'verdict', 'alternatives'],
+    defaultWordCount: 1500,
+    frontmatter: ['title', 'description', 'date', 'author', 'rating', 'product-name']
+  },
+  'comparison': {
+    sections: ['introduction', 'criteria', 'comparison-table', 'detailed-analysis', 'recommendation'],
+    defaultWordCount: 2500,
+    frontmatter: ['title', 'description', 'date', 'author', 'compared-items']
+  }
+};
+
+// Tone configurations
+const TONE_SETTINGS = {
+  professional: {
+    vocabulary: 'formal',
+    contractions: false,
+    personalPronouns: 'limited',
+    sentenceLength: 'varied'
+  },
+  conversational: {
+    vocabulary: 'accessible',
+    contractions: true,
+    personalPronouns: 'frequent',
+    sentenceLength: 'shorter'
+  },
+  technical: {
+    vocabulary: 'specialized',
+    contractions: false,
+    personalPronouns: 'minimal',
+    sentenceLength: 'longer'
+  },
+  casual: {
+    vocabulary: 'informal',
+    contractions: true,
+    personalPronouns: 'frequent',
+    sentenceLength: 'shorter'
+  },
+  authoritative: {
+    vocabulary: 'formal',
+    contractions: false,
+    personalPronouns: 'minimal',
+    sentenceLength: 'varied'
+  }
+};
+
+/**
+ * Content Generator Class
+ */
+export class ContentGenerator {
+  constructor(options = {}) {
+    this.configManager = options.configManager || getConfigManager();
+    this.outputDir = options.outputDir || './content';
+    this.defaultTone = options.tone || 'professional';
+    this.defaultWordCount = options.wordCount || 1500;
+  }
+
+  /**
+   * Initialize the content generator with config
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    const config = await this.configManager.loadAll();
+
+    if (config.CONTENT_OUTPUT_DIR) {
+      this.outputDir = config.CONTENT_OUTPUT_DIR;
+    }
+    if (config.DEFAULT_TONE) {
+      this.defaultTone = config.DEFAULT_TONE;
+    }
+    if (config.DEFAULT_WORD_COUNT) {
+      this.defaultWordCount = parseInt(config.DEFAULT_WORD_COUNT, 10);
+    }
+
+    await fs.ensureDir(this.outputDir);
+  }
+
+  /**
+   * Generate content specification for the content-writer agent
+   * @param {string} topic - Content topic
+   * @param {Object} options - Generation options
+   * @returns {Object} Content specification
+   */
+  generateContentSpec(topic, options = {}) {
+    const {
+      contentType = 'blog-post',
+      wordCount = this.defaultWordCount,
+      tone = this.defaultTone,
+      keywords = [],
+      targetAudience = 'general',
+      additionalInstructions = ''
+    } = options;
+
+    const template = CONTENT_TEMPLATES[contentType] || CONTENT_TEMPLATES['blog-post'];
+    const toneSettings = TONE_SETTINGS[tone] || TONE_SETTINGS['professional'];
+
+    return {
+      topic,
+      contentType,
+      template,
+      wordCount,
+      tone,
+      toneSettings,
+      keywords,
+      targetAudience,
+      additionalInstructions,
+      sections: template.sections,
+      requiredFrontmatter: template.frontmatter,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Select the appropriate template for content type
+   * @param {string} contentType - Type of content
+   * @returns {Object} Template configuration
+   */
+  selectTemplate(contentType) {
+    return CONTENT_TEMPLATES[contentType] || CONTENT_TEMPLATES['blog-post'];
+  }
+
+  /**
+   * Apply custom rules from a rules file
+   * @param {string} content - Content to modify
+   * @param {string} rulesFile - Path to rules file
+   * @returns {Promise<string>} Modified content
+   */
+  async applyCustomRules(content, rulesFile) {
+    try {
+      const exists = await fs.pathExists(rulesFile);
+      if (!exists) {
+        return content;
+      }
+
+      const rulesContent = await fs.readFile(rulesFile, 'utf-8');
+      const rules = this.parseRulesFile(rulesContent);
+
+      let modifiedContent = content;
+
+      // Apply text replacements
+      if (rules.replacements) {
+        for (const [pattern, replacement] of Object.entries(rules.replacements)) {
+          const regex = new RegExp(pattern, 'gi');
+          modifiedContent = modifiedContent.replace(regex, replacement);
+        }
+      }
+
+      // Apply formatting rules
+      if (rules.formatting) {
+        modifiedContent = this.applyFormattingRules(modifiedContent, rules.formatting);
+      }
+
+      return modifiedContent;
+    } catch (error) {
+      console.warn(`Warning: Failed to apply custom rules: ${error.message}`);
+      return content;
+    }
+  }
+
+  /**
+   * Parse a rules file content
+   * @param {string} content - Rules file content
+   * @returns {Object} Parsed rules
+   */
+  parseRulesFile(content) {
+    const rules = {
+      replacements: {},
+      formatting: {},
+      style: {}
+    };
+
+    const lines = content.split('\n');
+    let currentSection = null;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      // Skip empty lines and comments
+      if (!trimmed || trimmed.startsWith('#')) {
+        continue;
+      }
+
+      // Check for section headers
+      if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+        currentSection = trimmed.slice(1, -1).toLowerCase();
+        continue;
+      }
+
+      // Parse key-value pairs
+      const match = trimmed.match(/^([^=]+)=(.*)$/);
+      if (match && currentSection) {
+        const key = match[1].trim();
+        const value = match[2].trim();
+
+        if (rules[currentSection]) {
+          rules[currentSection][key] = value;
+        }
+      }
+    }
+
+    return rules;
+  }
+
+  /**
+   * Apply formatting rules to content
+   * @param {string} content - Content to format
+   * @param {Object} rules - Formatting rules
+   * @returns {string} Formatted content
+   */
+  applyFormattingRules(content, rules) {
+    let result = content;
+
+    // Heading case transformation
+    if (rules.headingCase === 'title') {
+      result = result.replace(/^(#{1,6})\s+(.+)$/gm, (match, hashes, title) => {
+        return `${hashes} ${this.toTitleCase(title)}`;
+      });
+    }
+
+    // List formatting
+    if (rules.listStyle === 'dash') {
+      result = result.replace(/^\*\s+/gm, '- ');
+    }
+
+    return result;
+  }
+
+  /**
+   * Convert string to title case
+   * @param {string} str - String to convert
+   * @returns {string} Title case string
+   */
+  toTitleCase(str) {
+    const smallWords = ['a', 'an', 'the', 'and', 'but', 'or', 'for', 'nor', 'on', 'at', 'to', 'by', 'in', 'of'];
+    return str.split(' ').map((word, index) => {
+      const lower = word.toLowerCase();
+      if (index === 0 || !smallWords.includes(lower)) {
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+      }
+      return lower;
+    }).join(' ');
+  }
+
+  /**
+   * Generate YAML frontmatter for content
+   * @param {Object} data - Frontmatter data
+   * @returns {string} YAML frontmatter string
+   */
+  generateFrontmatter(data) {
+    const lines = ['---'];
+
+    for (const [key, value] of Object.entries(data)) {
+      if (value === undefined || value === null) continue;
+
+      if (Array.isArray(value)) {
+        lines.push(`${key}:`);
+        for (const item of value) {
+          lines.push(`  - "${item}"`);
+        }
+      } else if (typeof value === 'object') {
+        lines.push(`${key}:`);
+        for (const [subKey, subValue] of Object.entries(value)) {
+          lines.push(`  ${subKey}: "${subValue}"`);
+        }
+      } else {
+        // Quote strings that might need it
+        const stringValue = String(value);
+        if (stringValue.includes(':') || stringValue.includes('#') || stringValue.includes('"')) {
+          lines.push(`${key}: "${stringValue.replace(/"/g, '\\"')}"`);
+        } else {
+          lines.push(`${key}: ${stringValue}`);
+        }
+      }
+    }
+
+    lines.push('---');
+    lines.push('');
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Create a content file with frontmatter
+   * @param {string} filename - Output filename
+   * @param {Object} frontmatter - Frontmatter data
+   * @param {string} content - Main content
+   * @returns {Promise<string>} Full file path
+   */
+  async createContentFile(filename, frontmatter, content) {
+    const fullPath = path.join(this.outputDir, filename);
+    const frontmatterStr = this.generateFrontmatter(frontmatter);
+    const fullContent = frontmatterStr + content;
+
+    await fs.ensureDir(path.dirname(fullPath));
+    await fs.writeFile(fullPath, fullContent, 'utf-8');
+
+    return fullPath;
+  }
+
+  /**
+   * Generate a slug from a title
+   * @param {string} title - Title to slugify
+   * @returns {string} URL-safe slug
+   */
+  generateSlug(title) {
+    return title
+      .toLowerCase()
+      .trim()
+      .replace(/[^\w\s-]/g, '')
+      .replace(/[\s_-]+/g, '-')
+      .replace(/^-+|-+$/g, '');
+  }
+
+  /**
+   * Generate a filename from title and date
+   * @param {string} title - Content title
+   * @param {string} [extension='md'] - File extension
+   * @returns {string} Generated filename
+   */
+  generateFilename(title, extension = 'md') {
+    const date = new Date().toISOString().split('T')[0];
+    const slug = this.generateSlug(title);
+    return `${date}-${slug}.${extension}`;
+  }
+
+  /**
+   * Get available content types
+   * @returns {string[]} List of content types
+   */
+  getContentTypes() {
+    return Object.keys(CONTENT_TEMPLATES);
+  }
+
+  /**
+   * Get available tones
+   * @returns {string[]} List of tones
+   */
+  getTones() {
+    return Object.keys(TONE_SETTINGS);
+  }
+
+  /**
+   * Validate content options
+   * @param {Object} options - Options to validate
+   * @returns {{valid: boolean, errors: string[]}}
+   */
+  validateOptions(options) {
+    const errors = [];
+
+    if (options.contentType && !CONTENT_TEMPLATES[options.contentType]) {
+      errors.push(`Invalid content type: ${options.contentType}. Valid types: ${Object.keys(CONTENT_TEMPLATES).join(', ')}`);
+    }
+
+    if (options.tone && !TONE_SETTINGS[options.tone]) {
+      errors.push(`Invalid tone: ${options.tone}. Valid tones: ${Object.keys(TONE_SETTINGS).join(', ')}`);
+    }
+
+    if (options.wordCount && (options.wordCount < 100 || options.wordCount > 10000)) {
+      errors.push('Word count must be between 100 and 10000');
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Get content statistics
+   * @param {string} content - Content to analyze
+   * @returns {Object} Content statistics
+   */
+  getContentStats(content) {
+    const words = content.split(/\s+/).filter(w => w.length > 0);
+    const sentences = content.split(/[.!?]+/).filter(s => s.trim().length > 0);
+    const paragraphs = content.split(/\n\n+/).filter(p => p.trim().length > 0);
+    const headings = (content.match(/^#{1,6}\s+.+$/gm) || []).length;
+
+    return {
+      wordCount: words.length,
+      sentenceCount: sentences.length,
+      paragraphCount: paragraphs.length,
+      headingCount: headings,
+      averageWordsPerSentence: sentences.length > 0 ? Math.round(words.length / sentences.length) : 0,
+      readingTime: Math.ceil(words.length / 200) // Assuming 200 words per minute
+    };
+  }
+}
+
+// Factory function for convenience
+export function createContentGenerator(options) {
+  return new ContentGenerator(options);
+}
+
+export default ContentGenerator;