myaidev-method 0.0.8 → 0.2.0

package/src/scripts/payloadcms-publish.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+
+/**
+ * PayloadCMS Publishing Script
+ * Publish markdown content to PayloadCMS
+ */
+
+import { PayloadCMSUtils } from '../lib/payloadcms-utils.js';
+
+const args = process.argv.slice(2);
+
+const options = {
+  file: null,
+  collection: 'posts',
+  status: 'draft',
+  id: null,
+  json: args.includes('--json'),
+  verbose: args.includes('--verbose') || args.includes('-v'),
+  dryRun: args.includes('--dry-run')
+};
+
+// Parse arguments
+for (let i = 0; i < args.length; i++) {
+  switch (args[i]) {
+    case '--file':
+    case '-f':
+      options.file = args[++i];
+      break;
+    case '--collection':
+    case '-c':
+      options.collection = args[++i];
+      break;
+    case '--status':
+    case '-s':
+      options.status = args[++i];
+      break;
+    case '--id':
+      options.id = args[++i];
+      break;
+    case '--help':
+    case '-h':
+      printHelp();
+      process.exit(0);
+  }
+}
+
+// If no file specified, check positional argument
+if (!options.file && args.length > 0 && !args[0].startsWith('-')) {
+  options.file = args[0];
+}
+
+function printHelp() {
+  console.log(`
+PayloadCMS Publishing Script
+
+Usage: payloadcms-publish [file] [options]
+
+Arguments:
+  file                       Markdown file to publish (required)
+
+Options:
+  --collection, -c <name>    Target collection (default: posts)
+  --status, -s <status>      Publish status: draft|published (default: draft)
+  --id <doc-id>              Update existing document by ID
+  --dry-run                  Validate without publishing
+  --verbose, -v              Show detailed progress
+  --json                     Output in JSON format
+  --help, -h                 Show this help
+
+Examples:
+  # Publish as draft
+  payloadcms-publish article.md --collection posts --status draft
+
+  # Publish to production
+  payloadcms-publish article.md --status published
+
+  # Update existing document
+  payloadcms-publish article.md --id 60d5ec49f8d2e
+
+  # Dry run
+  payloadcms-publish article.md --dry-run --verbose
+`);
+}
+
+async function publishContent() {
+  try {
+    // Validate required options
+    if (!options.file) {
+      console.error('Error: Markdown file is required');
+      console.error('Run with --help for usage information');
+      process.exit(1);
+    }
+
+    if (options.verbose) {
+      console.error('Initializing PayloadCMS connection...');
+    }
+
+    const payload = new PayloadCMSUtils();
+
+    // Health check
+    const healthy = await payload.healthCheck();
+    if (!healthy) {
+      throw new Error('PayloadCMS is not reachable');
+    }
+
+    if (options.verbose) {
+      console.error('✓ PayloadCMS is reachable');
+      console.error(`Authenticating...`);
+    }
+
+    // Authenticate
+    const authResult = await payload.authenticate();
+
+    if (options.verbose) {
+      console.error(`✓ Authenticated via ${authResult.method}`);
+      console.error(`Publishing to collection: ${options.collection}`);
+      console.error(`Status: ${options.status}`);
+    }
+
+    // Dry run - validate only
+    if (options.dryRun) {
+      if (options.verbose) {
+        console.error('✓ Dry run - validation successful');
+      }
+
+      const output = {
+        success: true,
+        dryRun: true,
+        file: options.file,
+        collection: options.collection,
+        status: options.status
+      };
+
+      if (options.json) {
+        console.log(JSON.stringify(output, null, 2));
+      } else {
+        console.log('Dry run successful - ready to publish');
+      }
+
+      process.exit(0);
+    }
+
+    // Publish content
+    const result = await payload.publishContent(options.file, options.collection, {
+      status: options.status,
+      id: options.id
+    });
+
+    if (options.verbose) {
+      console.error(`✓ Content ${options.id ? 'updated' : 'created'} successfully`);
+    }
+
+    // Prepare output
+    const output = {
+      success: true,
+      action: options.id ? 'updated' : 'created',
+      document: {
+        id: result.doc?.id || result.id,
+        collection: options.collection,
+        status: result.doc?.status || options.status,
+        title: result.doc?.title
+      },
+      timestamp: new Date().toISOString()
+    };
+
+    if (options.json) {
+      console.log(JSON.stringify(output, null, 2));
+    } else {
+      console.log('\\n' + '='.repeat(60));
+      console.log('PayloadCMS Publishing Result');
+      console.log('='.repeat(60));
+      console.log(`Status: ✓ Success`);
+      console.log(`Action: ${output.action}`);
+      console.log(`Document ID: ${output.document.id}`);
+      console.log(`Collection: ${output.document.collection}`);
+      console.log(`Status: ${output.document.status}`);
+      console.log('='.repeat(60));
+    }
+
+    process.exit(0);
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      }, null, 2));
+    } else {
+      console.error(`\\nError: ${error.message}`);
+      if (options.verbose) {
+        console.error(`Stack: ${error.stack}`);
+      }
+    }
+    process.exit(1);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  publishContent();
+}
+
+export { publishContent };

package/src/scripts/test-coolify-deploy.js

@@ -0,0 +1,47 @@
+import fetch from 'node-fetch';
+import { readFileSync } from 'fs';
+import { parse } from 'dotenv';
+
+const envContent = readFileSync('.env', 'utf8');
+const env = parse(envContent);
+
+const apiKey = env.COOLIFY_API_KEY;
+const url = env.COOLIFY_URL;
+
+const payload = {
+  project_uuid: 'zg44coscocg0sko8k0wgcgkw',
+  server_uuid: 'vcscogc44gko4k880ww880kk',
+  environment_name: 'production',
+  git_repository: 'https://github.com/vercel/micro',
+  git_branch: 'main',
+  name: 'test-micro-app',
+  build_pack: 'nixpacks',
+  ports_exposes: '3000'
+};
+
+console.log('Testing Coolify deployment...');
+console.log('Payload:', JSON.stringify(payload, null, 2));
+
+try {
+  const response = await fetch(`${url}/api/v1/applications/public`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+      'Accept': 'application/json'
+    },
+    body: JSON.stringify(payload)
+  });
+
+  console.log('Status:', response.status);
+  console.log('Status Text:', response.statusText);
+
+  const data = await response.json().catch(() => ({}));
+  console.log('Response:', JSON.stringify(data, null, 2));
+
+  if (!response.ok) {
+    console.error('Error details:', data);
+  }
+} catch (error) {
+  console.error('Error:', error.message);
+}

package/src/scripts/wordpress-comprehensive-report.js

@@ -0,0 +1,325 @@
+#!/usr/bin/env node
+
+/**
+ * WordPress Comprehensive Report Script
+ * Runs all checks and synthesizes into a comprehensive report
+ *
+ * Usage:
+ *   npx myaidev-method wordpress:comprehensive-report [options]
+ *   node src/scripts/wordpress-comprehensive-report.js [options]
+ */
+
+import { WordPressAdminUtils } from '../lib/wordpress-admin-utils.js';
+import { ReportSynthesizer } from '../lib/report-synthesizer.js';
+import { writeFileSync } from 'fs';
+import { resolve } from 'path';
+
+const args = process.argv.slice(2);
+
+const options = {
+  format: 'markdown', // markdown or json
+  output: null, // file path for output
+  verbose: false,
+  includeHealth: true,
+  includeSecurity: true,
+  includePerformance: true,
+  saveIndividual: false // Save individual reports as well
+};
+
+// Parse arguments
+for (let i = 0; i < args.length; i++) {
+  switch (args[i]) {
+    case '--format':
+      options.format = args[++i] || 'markdown';
+      break;
+    case '--output':
+    case '-o':
+      options.output = args[++i];
+      break;
+    case '--verbose':
+    case '-v':
+      options.verbose = true;
+      break;
+    case '--save-individual':
+      options.saveIndividual = true;
+      break;
+    case '--health-only':
+      options.includeSecurity = false;
+      options.includePerformance = false;
+      break;
+    case '--security-only':
+      options.includeHealth = false;
+      options.includePerformance = false;
+      break;
+    case '--performance-only':
+      options.includeHealth = false;
+      options.includeSecurity = false;
+      break;
+    case '--help':
+    case '-h':
+      printHelp();
+      process.exit(0);
+  }
+}
+
+function printHelp() {
+  console.log(`
+WordPress Comprehensive Report Script
+
+Runs all WordPress admin checks and synthesizes them into a comprehensive report.
+Perfect for regular site maintenance and agent-driven analysis.
+
+Usage:
+  npx myaidev-method wordpress:comprehensive-report [options]
+
+Options:
+  --format <type>        Output format: markdown or json (default: markdown)
+  --output <file>        Write output to file (default: stdout)
+  -o <file>              Alias for --output
+  --verbose              Show detailed progress information
+  -v                     Alias for --verbose
+  --save-individual      Save individual report files as well
+  --health-only          Only run health check
+  --security-only        Only run security scan
+  --performance-only     Only run performance check
+  --help                 Show this help message
+  -h                     Alias for --help
+
+Environment Variables (from .env):
+  WORDPRESS_URL            WordPress site URL
+  WORDPRESS_USERNAME       Admin username
+  WORDPRESS_APP_PASSWORD   Application password
+
+This script runs:
+  ✓ Health Check - Site health assessment
+  ✓ Security Scan - Security vulnerability detection
+  ✓ Performance Analysis - Performance metrics collection
+
+Then synthesizes all results into a comprehensive report with:
+  ✓ Executive summary with scores
+  ✓ Critical issues requiring immediate attention
+  ✓ Warnings and recommendations
+  ✓ Prioritized action items
+  ✓ Key metrics and statistics
+
+Examples:
+  # Generate comprehensive markdown report
+  npx myaidev-method wordpress:comprehensive-report
+
+  # Save comprehensive report to file
+  npx myaidev-method wordpress:comprehensive-report --output wp-report.md
+
+  # Generate JSON report for agent processing
+  npx myaidev-method wordpress:comprehensive-report --format json
+
+  # Save all reports (comprehensive + individual)
+  npx myaidev-method wordpress:comprehensive-report --save-individual --output report.md
+
+  # Verbose mode with progress information
+  npx myaidev-method wordpress:comprehensive-report --verbose
+
+Agent Integration:
+  This script is designed to work with the wordpress-admin agent. The agent can:
+  1. Run this script to get structured data
+  2. Process the JSON or markdown output
+  3. Generate natural language analysis
+  4. Provide actionable recommendations
+
+Exit Codes:
+  0 - Report generated successfully, no critical issues
+  1 - Error occurred during analysis
+  2 - Report generated with warnings
+  3 - Report generated with critical issues
+`);
+}
+
+async function runComprehensiveReport() {
+  const timestamp = new Date().toISOString();
+  const reports = [];
+
+  try {
+    if (options.verbose) {
+      console.error('WordPress Comprehensive Report');
+      console.error('='.repeat(60));
+      console.error('Initializing WordPress connection...');
+    }
+
+    const wpUtils = new WordPressAdminUtils();
+    const synthesizer = new ReportSynthesizer();
+
+    // Run health check
+    if (options.includeHealth) {
+      if (options.verbose) {
+        console.error('\n[1/3] Running health check...');
+      }
+
+      const healthData = await wpUtils.runHealthCheck();
+      synthesizer.addReport(healthData, 'health');
+      reports.push({ type: 'health', data: healthData });
+
+      if (options.saveIndividual && options.output) {
+        const healthFile = options.output.replace(/\.(md|json)$/, '-health.json');
+        writeFileSync(healthFile, JSON.stringify(healthData, null, 2), 'utf8');
+        if (options.verbose) {
+          console.error(`  Saved: ${healthFile}`);
+        }
+      }
+    }
+
+    // Run security scan
+    if (options.includeSecurity) {
+      if (options.verbose) {
+        console.error('\n[2/3] Running security scan...');
+      }
+
+      const securityData = await wpUtils.runSecurityScan();
+      synthesizer.addReport(securityData, 'security');
+      reports.push({ type: 'security', data: securityData });
+
+      if (options.saveIndividual && options.output) {
+        const securityFile = options.output.replace(/\.(md|json)$/, '-security.json');
+        writeFileSync(securityFile, JSON.stringify(securityData, null, 2), 'utf8');
+        if (options.verbose) {
+          console.error(`  Saved: ${securityFile}`);
+        }
+      }
+    }
+
+    // Run performance check
+    if (options.includePerformance) {
+      if (options.verbose) {
+        console.error('\n[3/3] Running performance analysis...');
+      }
+
+      const perfData = await wpUtils.getPerformanceMetrics();
+      const timing = await measureResponseTime(wpUtils, 3);
+
+      const performanceData = {
+        success: true,
+        timestamp,
+        site: await wpUtils.getSiteInfo().catch(() => ({ url: wpUtils.url })),
+        performance_score: 85, // Calculate based on metrics
+        timing,
+        metrics: perfData,
+        recommendations: []
+      };
+
+      synthesizer.addReport(performanceData, 'performance');
+      reports.push({ type: 'performance', data: performanceData });
+
+      if (options.saveIndividual && options.output) {
+        const perfFile = options.output.replace(/\.(md|json)$/, '-performance.json');
+        writeFileSync(perfFile, JSON.stringify(performanceData, null, 2), 'utf8');
+        if (options.verbose) {
+          console.error(`  Saved: ${perfFile}`);
+        }
+      }
+    }
+
+    if (options.verbose) {
+      console.error('\nSynthesizing comprehensive report...');
+    }
+
+    // Generate comprehensive report
+    let output;
+    if (options.format === 'json') {
+      output = synthesizer.generateJSONReport();
+    } else {
+      output = synthesizer.generateMarkdownReport();
+    }
+
+    if (options.verbose) {
+      console.error('Report generation completed.');
+      console.error('='.repeat(60));
+    }
+
+    // Write output
+    if (options.output) {
+      const outputPath = resolve(options.output);
+      writeFileSync(outputPath, output, 'utf8');
+
+      if (options.verbose) {
+        console.error(`\nComprehensive report written to: ${outputPath}`);
+      }
+
+      // Output summary for piping
+      const synthesis = synthesizer.synthesize();
+      console.log(JSON.stringify({
+        success: true,
+        output_file: outputPath,
+        overall_status: synthesis.executive_summary.overall_status,
+        critical_issues: synthesis.critical_issues.length,
+        warnings: synthesis.warnings.length,
+        reports_generated: reports.length
+      }));
+    } else {
+      console.log(output);
+    }
+
+    // Determine exit code
+    const synthesis = synthesizer.synthesize();
+    const criticalCount = synthesis.critical_issues.length;
+    const warningCount = synthesis.warnings.length;
+
+    if (criticalCount > 0) {
+      process.exit(3); // Critical issues
+    } else if (warningCount > 0) {
+      process.exit(2); // Warnings
+    } else {
+      process.exit(0); // All clear
+    }
+  } catch (error) {
+    const errorOutput = {
+      success: false,
+      error: error.message,
+      timestamp,
+      reports_completed: reports.length
+    };
+
+    if (options.format === 'json') {
+      console.log(JSON.stringify(errorOutput, null, 2));
+    } else {
+      console.error(`\nERROR: ${error.message}`);
+      console.error(`Stack: ${error.stack}`);
+    }
+
+    process.exit(1);
+  }
+}
+
+async function measureResponseTime(wpUtils, iterations) {
+  const measurements = [];
+
+  for (let i = 0; i < iterations; i++) {
+    const start = Date.now();
+    try {
+      await wpUtils.request('/');
+      measurements.push(Date.now() - start);
+    } catch (error) {
+      // Skip failed measurements
+    }
+
+    if (i < iterations - 1) {
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+  }
+
+  if (measurements.length === 0) return null;
+
+  const avg = measurements.reduce((a, b) => a + b, 0) / measurements.length;
+  const sorted = measurements.sort((a, b) => a - b);
+
+  return {
+    average: Math.round(avg),
+    median: Math.round(sorted[Math.floor(sorted.length / 2)]),
+    min: sorted[0],
+    max: sorted[sorted.length - 1]
+  };
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runComprehensiveReport();
+}
+
+export { runComprehensiveReport };