myaidev-method 0.2.23 → 0.2.24-2

package/src/scripts/utils/write-content.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+
+/**
+ * Write Content CLI
+ * Command-line wrapper for content generation
+ * Usage: node write-content.js "Topic" [options]
+ */
+
+import { ContentGenerator } from '../../lib/content-generator.js';
+import { SEOOptimizer } from '../../lib/seo-optimizer.js';
+import { logger, formatTable } from './logger.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * Parse command line arguments
+ * @param {string[]} args - Command line arguments
+ * @returns {Object} Parsed options
+ */
+function parseArgs(args) {
+  const options = {
+    topic: '',
+    contentType: 'blog-post',
+    wordCount: 1500,
+    tone: 'professional',
+    keywords: [],
+    outputDir: './content',
+    outputFile: '',
+    analyze: false,
+    help: false
+  };
+
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+    } else if (arg === '--type' || arg === '-t') {
+      options.contentType = args[++i];
+    } else if (arg === '--word-count' || arg === '-w') {
+      options.wordCount = parseInt(args[++i], 10);
+    } else if (arg === '--tone') {
+      options.tone = args[++i];
+    } else if (arg === '--keywords' || arg === '-k') {
+      options.keywords = args[++i].split(',').map(k => k.trim());
+    } else if (arg === '--output' || arg === '-o') {
+      options.outputFile = args[++i];
+    } else if (arg === '--output-dir') {
+      options.outputDir = args[++i];
+    } else if (arg === '--analyze' || arg === '-a') {
+      options.analyze = true;
+    } else if (!arg.startsWith('-')) {
+      options.topic = arg;
+    }
+
+    i++;
+  }
+
+  return options;
+}
+
+/**
+ * Show help message
+ */
+function showHelp() {
+  console.log(`
+Write Content - Content Generation CLI
+
+Usage: node write-content.js "Topic" [options]
+
+Options:
+  -h, --help              Show this help message
+  -t, --type <type>       Content type (blog-post, tutorial, how-to, listicle, product-review, comparison)
+  -w, --word-count <num>  Target word count (default: 1500)
+  --tone <tone>           Writing tone (professional, conversational, technical, casual, authoritative)
+  -k, --keywords <list>   Comma-separated keywords for SEO
+  -o, --output <file>     Output filename (auto-generated if not specified)
+  --output-dir <dir>      Output directory (default: ./content)
+  -a, --analyze           Analyze content for SEO after generation
+
+Examples:
+  node write-content.js "How to Train a Puppy" --type tutorial --tone conversational
+  node write-content.js "Best Laptops 2024" --type listicle --keywords "laptops,tech,reviews"
+  node write-content.js "React vs Vue" --type comparison --word-count 2500 --analyze
+`);
+}
+
+/**
+ * Generate content specification for the content-writer agent
+ * @param {Object} options - Generation options
+ */
+async function generateContentSpec(options) {
+  const generator = new ContentGenerator({
+    outputDir: options.outputDir,
+    tone: options.tone,
+    wordCount: options.wordCount
+  });
+
+  await generator.initialize();
+
+  // Validate options
+  const validation = generator.validateOptions(options);
+  if (!validation.valid) {
+    for (const error of validation.errors) {
+      logger.error(error);
+    }
+    process.exit(1);
+  }
+
+  // Generate content specification
+  const spec = generator.generateContentSpec(options.topic, {
+    contentType: options.contentType,
+    wordCount: options.wordCount,
+    tone: options.tone,
+    keywords: options.keywords
+  });
+
+  logger.header('Content Specification');
+  logger.log(`Topic: ${spec.topic}`);
+  logger.log(`Type: ${spec.contentType}`);
+  logger.log(`Word Count Target: ${spec.wordCount}`);
+  logger.log(`Tone: ${spec.tone}`);
+  logger.log(`Keywords: ${spec.keywords.length > 0 ? spec.keywords.join(', ') : 'None specified'}`);
+  logger.blank();
+
+  logger.section('Required Sections');
+  for (const section of spec.sections) {
+    logger.log(`  • ${section}`);
+  }
+
+  logger.section('Frontmatter Fields');
+  for (const field of spec.requiredFrontmatter) {
+    logger.log(`  • ${field}`);
+  }
+
+  // Generate filename
+  const filename = options.outputFile || generator.generateFilename(options.topic);
+  const outputPath = path.join(options.outputDir, filename);
+
+  logger.section('Output');
+  logger.log(`Filename: ${filename}`);
+  logger.log(`Path: ${outputPath}`);
+  logger.blank();
+
+  // Generate frontmatter template
+  const frontmatterData = {
+    title: options.topic,
+    description: '',
+    date: new Date().toISOString().split('T')[0],
+    author: '',
+    categories: [],
+    tags: options.keywords,
+    status: 'draft'
+  };
+
+  const frontmatter = generator.generateFrontmatter(frontmatterData);
+
+  // Create template file
+  const templateContent = `${frontmatter}
+# ${options.topic}
+
+<!-- Introduction -->
+
+## Overview
+
+[Write introduction here]
+
+${spec.sections.slice(1).map(section => `
+## ${section.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')}
+
+[Write ${section} content here]
+`).join('\n')}
+
+<!-- Call to Action -->
+
+## Conclusion
+
+[Write conclusion here]
+`;
+
+  await fs.ensureDir(options.outputDir);
+  await fs.writeFile(outputPath, templateContent, 'utf-8');
+
+  logger.success(`Template created: ${outputPath}`);
+  logger.blank();
+  logger.info('Use the content-writer agent to generate full content:');
+  logger.log(`  /myai-content-writer "${options.topic}" --type ${options.contentType}`);
+
+  return { spec, outputPath, templateContent };
+}
+
+/**
+ * Analyze existing content file
+ * @param {string} filePath - Path to content file
+ * @param {string[]} keywords - Keywords to check
+ */
+async function analyzeContent(filePath, keywords) {
+  const optimizer = new SEOOptimizer();
+
+  const content = await fs.readFile(filePath, 'utf-8');
+
+  // Extract title from frontmatter or first heading
+  const titleMatch = content.match(/^title:\s*(.+)$/m) || content.match(/^#\s+(.+)$/m);
+  const title = titleMatch ? titleMatch[1].trim() : '';
+
+  logger.header('SEO Analysis');
+  logger.log(`File: ${filePath}`);
+  logger.log(`Title: ${title || 'Not found'}`);
+  logger.blank();
+
+  const analysis = optimizer.analyzeSEO(content, keywords, title);
+
+  // Score display
+  const scoreColor = analysis.score >= 80 ? 'green' : analysis.score >= 60 ? 'yellow' : 'red';
+  logger.log(`SEO Score: ${analysis.score}/100 (Grade: ${analysis.grade})`);
+  logger.log(`Word Count: ${analysis.wordCount}`);
+  if (analysis.keywordDensity !== null) {
+    logger.log(`Keyword Density: ${analysis.keywordDensity}%`);
+  }
+  logger.blank();
+
+  // Issues
+  if (analysis.issues.length > 0) {
+    logger.section('Issues');
+    for (const issue of analysis.issues) {
+      logger.error(issue);
+    }
+  }
+
+  // Recommendations
+  if (analysis.recommendations.length > 0) {
+    logger.section('Recommendations');
+    for (const rec of analysis.recommendations) {
+      logger.warn(rec);
+    }
+  }
+
+  // Meta description
+  logger.section('Generated Meta Description');
+  const metaDesc = optimizer.generateMetaDescription(content);
+  logger.log(metaDesc);
+  logger.log(`Length: ${metaDesc.length} characters`);
+
+  // Slug
+  if (title) {
+    logger.section('Generated Slug');
+    logger.log(optimizer.generateSlug(title));
+  }
+
+  return analysis;
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+
+  if (options.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  if (!options.topic && !options.analyze) {
+    logger.error('Topic is required. Use --help for usage information.');
+    process.exit(1);
+  }
+
+  try {
+    if (options.analyze && options.topic) {
+      // If topic looks like a file path, analyze it
+      if (options.topic.endsWith('.md') || options.topic.includes('/')) {
+        await analyzeContent(options.topic, options.keywords);
+      } else {
+        // Generate spec and analyze
+        const { outputPath } = await generateContentSpec(options);
+        await analyzeContent(outputPath, options.keywords);
+      }
+    } else if (options.analyze && !options.topic) {
+      logger.error('Please provide a file path to analyze.');
+      process.exit(1);
+    } else {
+      await generateContentSpec(options);
+    }
+  } catch (error) {
+    logger.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();