myaidev-method 0.2.22 → 0.2.24-1

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();

package/src/scripts/wordpress/publish-to-wordpress.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+/**
+ * Publish markdown content to WordPress
+ *
+ * Usage: node publish-to-wordpress.js <file-path> [--status draft|publish]
+ */
+
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import matter from "gray-matter";
+import dotenv from "dotenv";
+import { marked } from "marked";
+import { GutenbergConverter } from "../../mcp/gutenberg-converter.js";
+import { WordPressMCP } from "../../mcp/wordpress-integration.js";
+
+// Load environment variables
+dotenv.config();
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const filePath = args[0];
+const statusIndex = args.indexOf("--status");
+const requestedStatus =
+	statusIndex !== -1 && args[statusIndex + 1] ? args[statusIndex + 1] : "draft";
+
+if (!filePath) {
+	console.error("Error: File path is required");
+	console.error(
+		"Usage: node publish-to-wordpress.js <file-path> [--status draft|publish]",
+	);
+	process.exit(1);
+}
+
+// Validate WordPress configuration
+if (
+	!process.env.WORDPRESS_URL ||
+	!process.env.WORDPRESS_USERNAME ||
+	!process.env.WORDPRESS_APP_PASSWORD
+) {
+	console.error("Error: WordPress configuration is incomplete");
+	console.error("Required environment variables:");
+	console.error("  - WORDPRESS_URL");
+	console.error("  - WORDPRESS_USERNAME");
+	console.error("  - WORDPRESS_APP_PASSWORD");
+	console.error(
+		"\nRun /myai-configure wordpress to set up your WordPress connection",
+	);
+	process.exit(1);
+}
+
+async function publishToWordPress() {
+	try {
+		// Read and parse markdown file
+		const absolutePath = resolve(filePath);
+		const fileContent = readFileSync(absolutePath, "utf-8");
+		const { data: frontmatter, content } = matter(fileContent);
+
+		console.log("📄 Processing file:", filePath);
+		console.log("📋 Title:", frontmatter.title || "No title");
+
+		// Extract interactive blocks before markdown conversion
+		// const { markdown: cleanMarkdown, interactiveBlocks } =
+		// 	GutenbergConverter.extractInteractiveBlocks(content);
+
+		// if (interactiveBlocks.length > 0) {
+		// 	console.log(
+		// 		`   Interactive blocks: ${interactiveBlocks.length} found`,
+		// 	);
+		// }
+
+		// Convert markdown to HTML using marked (preserves placeholders)
+		const html = marked.parse(content);
+
+		// Convert HTML to Gutenberg blocks
+		let htmlContent = GutenbergConverter.htmlToGutenberg(html);
+
+		// Restore interactive blocks as raw HTML blocks
+		// if (interactiveBlocks.length > 0) {
+		// 	htmlContent = GutenbergConverter.restoreInteractiveBlocks(
+		// 		htmlContent,
+		// 		interactiveBlocks,
+		// 	);
+		// }
+
+		// Prepare WordPress configuration
+		const config = {
+			endpoint: {
+				url: process.env.WORDPRESS_URL,
+				api_version: "wp/v2",
+				authentication: {
+					username: process.env.WORDPRESS_USERNAME,
+					password: process.env.WORDPRESS_APP_PASSWORD,
+				},
+			},
+			defaults: {
+				post_status: requestedStatus,
+				format: "standard",
+				comment_status: "open",
+				ping_status: "open",
+			},
+		};
+
+		// Initialize WordPress client
+		const wp = new WordPressMCP(config);
+
+		// Prepare post data
+		const postParams = {
+			title: frontmatter.title || "Untitled",
+			content: htmlContent,
+			status: requestedStatus,
+			excerpt: frontmatter.meta_description || "",
+			slug: frontmatter.slug || "",
+			use_gutenberg: process.env.USE_GUTENBERG === "true",
+			// Note: Tags and categories require ID mapping which will be added in future versions
+		};
+
+		console.log("🚀 Publishing to WordPress...");
+		console.log("   URL:", process.env.WORDPRESS_URL);
+		console.log("   Status:", requestedStatus);
+		console.log(
+			"   Format:",
+			postParams.use_gutenberg ? "Gutenberg" : "Classic",
+		);
+
+		// Create the post
+		const result = await wp.createPost(postParams);
+
+		// Success!
+		console.log("\n✅ Successfully published to WordPress!");
+		console.log("\n📄 Post Details:");
+		console.log("   Post ID:", result.id);
+		console.log("   Title:", result.title.rendered);
+		console.log("   Status:", result.status);
+		console.log("   Slug:", result.slug);
+
+		console.log("\n🔗 URLs:");
+		console.log("   View:", result.link);
+		console.log(
+			"   Edit:",
+			`${process.env.WORDPRESS_URL}/wp-admin/post.php?post=${result.id}&action=edit`,
+		);
+
+		return result;
+	} catch (error) {
+		console.error("\n❌ Error publishing to WordPress:");
+		console.error(error.message);
+
+		if (error.message.includes("401")) {
+			console.error("\n🔑 Authentication failed. Please check:");
+			console.error("   1. Your WordPress username is correct");
+			console.error("   2. Your Application Password is valid");
+			console.error("   3. Application Passwords are enabled on your site");
+		} else if (error.message.includes("404")) {
+			console.error("\n🌐 WordPress site not found. Please check:");
+			console.error("   1. Your WORDPRESS_URL is correct");
+			console.error("   2. The site is accessible");
+			console.error("   3. The REST API is enabled");
+		}
+
+		process.exit(1);
+	}
+}
+
+// Run the publisher
+publishToWordPress();

package/src/server/auth/services/TokenService.ts

@@ -6,7 +6,7 @@ import { AuthError, JWTPayload } from "../../../shared/types.js";
 const TOKEN_EXPIRY_DAYS = 7;
 const ALGORITHM = "RS256";
 
-let keyPair: { publicKey: jose.KeyLike; privateKey: jose.KeyLike } | null = null;
+let keyPair: { publicKey: jose.CryptoKey; privateKey: jose.CryptoKey } | null = null;
 
 export class TokenService extends Context.Tag("TokenService")<
   TokenService,