myaidev-method 0.2.22 → 0.2.24-1

package/src/scripts/init/install.js

@@ -0,0 +1,460 @@
+#!/usr/bin/env node
+
+/**
+ * Install Script
+ * Workflow installation orchestrator for MyAIDev Method
+ * Handles installation of workflows, agents, commands, and dependencies
+ */
+
+import WorkflowInstaller from '../../lib/workflow-installer.js';
+import { ConfigManager } from '../../lib/config-manager.js';
+import { logger, ProgressTracker, createSpinner } from '../utils/logger.js';
+import { ensureDir } from '../utils/file-utils.js';
+import inquirer from 'inquirer';
+import path from 'path';
+import fs from 'fs-extra';
+
+/**
+ * Installation Orchestrator Class
+ */
+class InstallationOrchestrator {
+  constructor(targetDir = process.cwd()) {
+    this.targetDir = targetDir;
+    this.configManager = new ConfigManager(targetDir);
+    this.installer = new WorkflowInstaller();
+    this.installedWorkflows = [];
+  }
+
+  /**
+   * Run the installation
+   * @param {Object} options - Installation options
+   */
+  async run(options = {}) {
+    const {
+      workflows = [],
+      cliType = 'claude',
+      interactive = false,
+      force = false,
+      verbose = false
+    } = options;
+
+    logger.header('MyAIDev Method Installation');
+    logger.info(`Target directory: ${this.targetDir}`);
+    logger.info(`CLI type: ${cliType}`);
+    logger.blank();
+
+    try {
+      // Interactive mode - show workflow selection
+      if (interactive) {
+        const selectedWorkflows = await this.selectWorkflows();
+        if (selectedWorkflows.length === 0) {
+          logger.info('No workflows selected. Exiting.');
+          return;
+        }
+        workflows.push(...selectedWorkflows);
+      }
+
+      // If no workflows specified, install core
+      if (workflows.length === 0) {
+        workflows.push('core');
+      }
+
+      // Install each workflow
+      const progress = new ProgressTracker(workflows.length, 'Installation');
+      progress.start();
+
+      for (const workflow of workflows) {
+        try {
+          await this.installWorkflow(workflow, cliType, { force, verbose });
+          progress.increment(workflow);
+          this.installedWorkflows.push(workflow);
+        } catch (error) {
+          progress.fail(workflow, error);
+        }
+      }
+
+      progress.complete();
+
+      // Show summary
+      await this.showSummary();
+
+      // Offer to configure
+      if (interactive && this.needsConfiguration()) {
+        await this.offerConfiguration();
+      }
+
+    } catch (error) {
+      logger.error(`Installation failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Show workflow selection prompt
+   * @returns {Promise<string[]>} Selected workflows
+   */
+  async selectWorkflows() {
+    const available = this.installer.getAvailableWorkflows();
+
+    const { workflows } = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'workflows',
+        message: 'Select workflows to install:',
+        choices: available.map(w => ({
+          name: `${w.name} - ${w.description}`,
+          value: w.id,
+          checked: w.id === 'core'
+        })),
+        validate: (answer) => {
+          if (answer.length === 0) {
+            return 'Please select at least one workflow';
+          }
+          return true;
+        }
+      }
+    ]);
+
+    return workflows;
+  }
+
+  /**
+   * Install a single workflow
+   * @param {string} workflow - Workflow ID
+   * @param {string} cliType - CLI type
+   * @param {Object} options - Installation options
+   */
+  async installWorkflow(workflow, cliType, options = {}) {
+    const { verbose = false } = options;
+
+    if (verbose) {
+      logger.info(`Installing workflow: ${workflow}`);
+    }
+
+    const spinner = createSpinner(`Installing ${workflow}...`);
+    spinner.start();
+
+    try {
+      const result = await this.installer.install(workflow, this.targetDir, cliType);
+
+      if (result.success) {
+        spinner.succeed(`${workflow} installed`);
+
+        if (verbose && result.installed) {
+          if (result.installed.agents?.length > 0) {
+            logger.info(`  Agents: ${result.installed.agents.join(', ')}`);
+          }
+          if (result.installed.commands?.length > 0) {
+            logger.info(`  Commands: ${result.installed.commands.join(', ')}`);
+          }
+        }
+      } else {
+        spinner.fail(`${workflow} failed`);
+        if (result.errors) {
+          for (const error of result.errors) {
+            logger.error(`  ${error}`);
+          }
+        }
+      }
+
+      return result;
+    } catch (error) {
+      spinner.fail(`${workflow} error: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Show installation summary
+   */
+  async showSummary() {
+    logger.section('Installation Summary');
+
+    // Count installed items
+    const claudeDir = path.join(this.targetDir, '.claude');
+    const agentsDir = path.join(claudeDir, 'agents');
+    const commandsDir = path.join(claudeDir, 'commands');
+
+    let agentCount = 0;
+    let commandCount = 0;
+
+    try {
+      if (await fs.pathExists(agentsDir)) {
+        const agents = await fs.readdir(agentsDir);
+        agentCount = agents.filter(f => f.endsWith('.md')).length;
+      }
+      if (await fs.pathExists(commandsDir)) {
+        const commands = await fs.readdir(commandsDir);
+        commandCount = commands.filter(f => f.endsWith('.md')).length;
+      }
+    } catch (error) {
+      // Ignore errors
+    }
+
+    logger.log(`Workflows installed: ${this.installedWorkflows.length}`);
+    logger.log(`  - ${this.installedWorkflows.join(', ')}`);
+    logger.blank();
+    logger.log(`Agents: ${agentCount}`);
+    logger.log(`Commands: ${commandCount}`);
+    logger.blank();
+
+    // Show next steps
+    logger.section('Next Steps');
+    logger.log('1. Configure your settings:');
+    logger.log('   Run: /myai-configure');
+    logger.blank();
+    logger.log('2. Available commands:');
+
+    if (this.installedWorkflows.includes('content') || this.installedWorkflows.includes('core')) {
+      logger.log('   /myai-content-writer - Create SEO-optimized content');
+    }
+    if (this.installedWorkflows.includes('content') || this.installedWorkflows.includes('publish-wordpress')) {
+      logger.log('   /myai-wordpress-publish - Publish to WordPress');
+    }
+    if (this.installedWorkflows.includes('content') || this.installedWorkflows.includes('core')) {
+      logger.log('   /myai-coordinate-content - Coordinate content workflow');
+    }
+
+    logger.blank();
+  }
+
+  /**
+   * Check if configuration is needed
+   * @returns {boolean}
+   */
+  needsConfiguration() {
+    const needsWordPress = this.installedWorkflows.some(w =>
+      ['content', 'publish-wordpress'].includes(w)
+    );
+    const needsOpenStack = this.installedWorkflows.some(w =>
+      ['openstack'].includes(w)
+    );
+
+    return needsWordPress || needsOpenStack;
+  }
+
+  /**
+   * Offer to run configuration
+   */
+  async offerConfiguration() {
+    const { configure } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'configure',
+        message: 'Would you like to configure your settings now?',
+        default: true
+      }
+    ]);
+
+    if (configure) {
+      // Import and run configure script
+      const { default: runConfigure } = await import('./configure.js');
+      // Note: This will run the configure wizard
+    }
+  }
+
+  /**
+   * Uninstall workflows
+   * @param {string[]} workflows - Workflows to uninstall
+   */
+  async uninstall(workflows) {
+    logger.header('Uninstalling Workflows');
+
+    for (const workflow of workflows) {
+      const spinner = createSpinner(`Uninstalling ${workflow}...`);
+      spinner.start();
+
+      try {
+        // Get workflow info
+        const workflowInfo = this.installer.getWorkflow(workflow);
+        if (!workflowInfo) {
+          spinner.warn(`Workflow not found: ${workflow}`);
+          continue;
+        }
+
+        // Remove agents
+        if (workflowInfo.agents) {
+          for (const agent of workflowInfo.agents) {
+            const agentPath = path.join(this.targetDir, '.claude', 'agents', `${agent}.md`);
+            await fs.remove(agentPath);
+          }
+        }
+
+        // Remove commands
+        if (workflowInfo.commands) {
+          for (const command of workflowInfo.commands) {
+            const commandPath = path.join(this.targetDir, '.claude', 'commands', `${command}.md`);
+            await fs.remove(commandPath);
+          }
+        }
+
+        spinner.succeed(`${workflow} uninstalled`);
+      } catch (error) {
+        spinner.fail(`Failed to uninstall ${workflow}: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * List installed workflows
+   */
+  async listInstalled() {
+    logger.header('Installed Workflows');
+
+    const claudeDir = path.join(this.targetDir, '.claude');
+
+    if (!await fs.pathExists(claudeDir)) {
+      logger.info('No workflows installed.');
+      return;
+    }
+
+    const agentsDir = path.join(claudeDir, 'agents');
+    const commandsDir = path.join(claudeDir, 'commands');
+
+    logger.section('Agents');
+    if (await fs.pathExists(agentsDir)) {
+      const agents = await fs.readdir(agentsDir);
+      const mdAgents = agents.filter(f => f.endsWith('.md'));
+      if (mdAgents.length > 0) {
+        for (const agent of mdAgents) {
+          logger.log(`  • ${agent.replace('.md', '')}`);
+        }
+      } else {
+        logger.info('  No agents installed.');
+      }
+    }
+
+    logger.section('Commands');
+    if (await fs.pathExists(commandsDir)) {
+      const commands = await fs.readdir(commandsDir);
+      const mdCommands = commands.filter(f => f.endsWith('.md'));
+      if (mdCommands.length > 0) {
+        for (const command of mdCommands) {
+          logger.log(`  • ${command.replace('.md', '')}`);
+        }
+      } else {
+        logger.info('  No commands installed.');
+      }
+    }
+  }
+}
+
+/**
+ * Parse command line arguments
+ * @param {string[]} args - Command line arguments
+ * @returns {Object} Parsed options
+ */
+function parseArgs(args) {
+  const options = {
+    workflows: [],
+    cliType: 'claude',
+    interactive: false,
+    force: false,
+    verbose: false,
+    uninstall: false,
+    list: 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 === '--interactive' || arg === '-i') {
+      options.interactive = true;
+    } else if (arg === '--force' || arg === '-f') {
+      options.force = true;
+    } else if (arg === '--verbose' || arg === '-v') {
+      options.verbose = true;
+    } else if (arg === '--claude') {
+      options.cliType = 'claude';
+    } else if (arg === '--gemini') {
+      options.cliType = 'gemini';
+    } else if (arg === '--codex') {
+      options.cliType = 'codex';
+    } else if (arg === '--uninstall' || arg === '-u') {
+      options.uninstall = true;
+    } else if (arg === '--list' || arg === '-l') {
+      options.list = true;
+    } else if (!arg.startsWith('-')) {
+      options.workflows.push(arg);
+    }
+
+    i++;
+  }
+
+  return options;
+}
+
+/**
+ * Show help message
+ */
+function showHelp() {
+  console.log(`
+MyAIDev Method - Installation Script
+
+Usage: node install.js [workflows...] [options]
+
+Workflows:
+  core              Core workflow with configuration tools
+  content           Content creation with SEO optimization
+  visual            Visual content generation
+  publish-wordpress WordPress publishing
+  development       Development tools
+  security-pentest  Security penetration testing
+  security-audit    Security auditing
+
+Options:
+  -h, --help        Show this help message
+  -i, --interactive Run interactive workflow selection
+  -f, --force       Force overwrite existing files
+  -v, --verbose     Show detailed output
+  --claude          Configure for Claude Code (default)
+  --gemini          Configure for Gemini CLI
+  --codex           Configure for Codex CLI
+  -l, --list        List installed workflows
+  -u, --uninstall   Uninstall specified workflows
+
+Examples:
+  node install.js core content --claude
+  node install.js --interactive
+  node install.js --list
+  node install.js content --uninstall
+`);
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+
+  if (options.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  const orchestrator = new InstallationOrchestrator();
+
+  try {
+    if (options.list) {
+      await orchestrator.listInstalled();
+    } else if (options.uninstall) {
+      if (options.workflows.length === 0) {
+        logger.error('Please specify workflows to uninstall.');
+        process.exit(1);
+      }
+      await orchestrator.uninstall(options.workflows);
+    } else {
+      await orchestrator.run(options);
+    }
+  } catch (error) {
+    logger.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/src/scripts/ping.js

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+
+import { exec } from "child_process";
+import { promisify } from "util";
+import os from "os";
+
+const execAsync = promisify(exec);
+
+/**
+ * Location to IP mapping
+ */
+export const LOCATIONS = {
+	"ashburn-va": "8.8.8.8", // Google DNS (East Coast reference)
+	"los-angeles": "1.1.1.1", // Cloudflare DNS (West Coast reference)
+	chicago: "8.8.4.4", // Google DNS secondary
+	europe: "1.0.0.1", // Cloudflare secondary
+	asia: "208.67.222.222", // OpenDNS
+	amsterdam: "213.165.253.121", // aditya's ramnode vm
+};
+
+/**
+ * Get device's local IP
+ */
+function getLocalIP() {
+	const interfaces = os.networkInterfaces();
+
+	for (const name of Object.keys(interfaces)) {
+		for (const iface of interfaces[name]) {
+			// Skip internal and non-IPv4
+			if (iface.family === "IPv4" && !iface.internal) {
+				return iface.address;
+			}
+		}
+	}
+
+	return "127.0.0.1";
+}
+
+/**
+ * Get public IP and location info
+ */
+async function getPublicIPInfo() {
+	try {
+		// Try ip-api.com first (free, no key needed)
+		const response = await fetch("http://ip-api.com/json/");
+		const data = await response.json();
+
+		// Check if we got valid data
+		if (data.status === "success" && data.query) {
+			return {
+				ip: data.query,
+				city: data.city || "Unknown City",
+				region: data.regionName || data.region,
+				country: data.country || "Unknown Country",
+				location: `${data.city}, ${data.country}`,
+			};
+		}
+
+		// Fallback if API returns error
+		throw new Error("Invalid response from IP API");
+	} catch (error) {
+		// Use local IP as fallback
+		const localIP = getLocalIP();
+		return {
+			ip: localIP,
+			location: `Local Network (${localIP})`,
+		};
+	}
+}
+
+/**
+ * Simple ping function
+ * @param {string} destination - IP address or hostname to ping
+ * @param {string} source - Source IP (defaults to device IP)
+ * @returns {Promise<object>} Ping results
+ */
+export async function ping(destination, source = null) {
+	const sourceIP = source || getLocalIP();
+
+	try {
+		const platform = process.platform;
+		const countFlag = platform === "win32" ? "-n" : "-c";
+		const command = `ping ${countFlag} 4 ${destination}`;
+
+		const { stdout } = await execAsync(command);
+
+		// Parse average latency
+		let avgLatency = null;
+
+		if (platform === "win32") {
+			const match = stdout.match(/Average = (\d+)ms/);
+			if (match) avgLatency = parseFloat(match[1]);
+		} else {
+			const match = stdout.match(/min\/avg\/max\/[^\s]+ = [\d.]+\/([\d.]+)\//);
+			if (match) avgLatency = parseFloat(match[1]);
+		}
+
+		return {
+			source: sourceIP,
+			destination,
+			latency: avgLatency,
+			unit: "ms",
+			success: true,
+		};
+	} catch (error) {
+		return {
+			source: sourceIP,
+			destination,
+			latency: null,
+			error: error.message,
+			success: false,
+		};
+	}
+}
+
+/**
+ * Ping multiple locations
+ * @param {Array<string>} locations - Array of location keys from LOCATIONS
+ * @param {string} source - Source IP (optional)
+ * @returns {Promise<Array>} Array of ping results
+ */
+export async function pingLocations(locations, source = null) {
+	const results = [];
+
+	for (const loc of locations) {
+		const ip = LOCATIONS[loc];
+		if (!ip) {
+			results.push({
+				location: loc,
+				error: "Unknown location",
+				success: false,
+			});
+			continue;
+		}
+
+		const result = await ping(ip, source);
+		results.push({
+			location: loc,
+			...result,
+		});
+	}
+
+	return results;
+}
+
+/**
+ * Format ping results as markdown
+ * @param {Array} results - Array of ping results from pingLocations
+ * @param {object} options - Formatting options
+ * @returns {string} Markdown formatted output
+ */
+export async function formatAsMarkdown(results, options = {}) {
+	const { includeMetadata = true, title = "Network Latency Test Results" } =
+		options;
+
+	let md = `## ${title}\n\n`;
+
+	if (includeMetadata && results.length > 0) {
+		const timestamp = new Date().toISOString();
+		const ipInfo = await getPublicIPInfo();
+
+		md += `**Test Date**: ${timestamp}\n`;
+		md += `**Source**: ${ipInfo.location} (${ipInfo.ip})\n\n`;
+	}
+
+	// Build table
+	md += "| Location | Destination | Latency | Status |\n";
+	md += "|----------|-------------|---------|--------|\n";
+
+	for (const result of results) {
+		const location = result.location || "N/A";
+		const destination = result.destination || "N/A";
+		const latency = result.success ? `${result.latency}ms` : "-";
+		const status = result.success
+			? "✅ Success"
+			: `❌ ${result.error || "Failed"}`;
+
+		md += `| ${location} | ${destination} | ${latency} | ${status} |\n`;
+	}
+
+	// Add summary statistics
+	const successful = results.filter((r) => r.success);
+	if (successful.length > 0) {
+		md += "\n### Summary\n\n";
+
+		const latencies = successful.map((r) => r.latency);
+		const avgLatency = (
+			latencies.reduce((a, b) => a + b, 0) / latencies.length
+		).toFixed(2);
+		const minLatency = Math.min(...latencies).toFixed(2);
+		const maxLatency = Math.max(...latencies).toFixed(2);
+
+		md += `- **Average Latency**: ${avgLatency}ms\n`;
+		md += `- **Best Latency**: ${minLatency}ms\n`;
+		md += `- **Worst Latency**: ${maxLatency}ms\n`;
+		md += `- **Success Rate**: ${successful.length}/${results.length} (${((successful.length / results.length) * 100).toFixed(0)}%)\n`;
+	}
+
+	return md;
+}
+
+// CLI interface
+if (import.meta.url === `file://${process.argv[1]}`) {
+	const args = process.argv.slice(2);
+
+	// Check for --all flag
+	if (args.includes("--all")) {
+		console.log("Testing all locations...\n");
+		const allLocations = Object.keys(LOCATIONS);
+		const results = await pingLocations(allLocations);
+		const markdown = await formatAsMarkdown(results);
+		console.log(markdown);
+		process.exit(0);
+	}
+
+	// Check for multiple locations
+	if (args.length > 1) {
+		console.log(`Testing ${args.length} locations...\n`);
+		const results = await pingLocations(args);
+		const markdown = await formatAsMarkdown(results);
+		console.log(markdown);
+		process.exit(0);
+	}
+
+	const destination = args[0];
+
+	if (!destination) {
+		console.log("Usage:");
+		console.log(
+			"  node ping.js <destination>           # Single location (markdown output)",
+		);
+		console.log(
+			"  node ping.js <loc1> <loc2> <loc3>    # Multiple locations (markdown output)",
+		);
+		console.log(
+			"  node ping.js --all                   # Test all locations (markdown output)",
+		);
+		console.log("\nAvailable locations:");
+		Object.keys(LOCATIONS).forEach((loc) => {
+			console.log(`  ${loc} -> ${LOCATIONS[loc]}`);
+		});
+		process.exit(1);
+	}
+
+	// Single location - markdown output (consistent with multiple locations)
+	console.log(`Testing ${destination}...\n`);
+	const results = await pingLocations([destination]);
+	const markdown = await formatAsMarkdown(results);
+	console.log(markdown);
+}