myaidev-method 0.2.24-1 → 0.2.24-2

package/src/lib/installation-detector.js

@@ -0,0 +1,266 @@
+/**
+ * Installation Detection Utility
+ *
+ * Detects the current installation state of MyAIDev Method:
+ * - Legacy installation (npx-based file copying)
+ * - Plugin installation (Claude Code plugin system)
+ * - Both (dual installation)
+ * - None (not installed)
+ *
+ * This utility ensures backward compatibility during migration to plugin architecture.
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * Installation types enum
+ */
+export const InstallationType = {
+  NONE: 'none',
+  LEGACY: 'legacy',
+  PLUGIN: 'plugin',
+  BOTH: 'both'
+};
+
+/**
+ * Detect the current installation state of MyAIDev Method
+ *
+ * @param {string} projectRoot - The project root directory
+ * @returns {Promise<Object>} Installation detection result
+ */
+export async function detectInstallation(projectRoot = process.cwd()) {
+  const checks = {
+    // Legacy installation indicators
+    hasClaudeDir: await fs.pathExists(path.join(projectRoot, '.claude')),
+    hasClaudeCommands: await fs.pathExists(path.join(projectRoot, '.claude', 'commands')),
+    hasClaudeAgents: await fs.pathExists(path.join(projectRoot, '.claude', 'agents')),
+    hasManifest: await fs.pathExists(path.join(projectRoot, '.myaidev-manifest.json')),
+
+    // Plugin installation indicators
+    hasPluginDir: await fs.pathExists(path.join(projectRoot, '.claude-plugin')),
+    hasPluginJson: await fs.pathExists(path.join(projectRoot, '.claude-plugin', 'plugin.json')),
+
+    // Skills-based installation
+    hasSkills: await fs.pathExists(path.join(projectRoot, 'skills')),
+
+    // Check for myaidev-specific files
+    hasMyAIDevCommands: false,
+    hasMyAIDevAgents: false
+  };
+
+  // Check for myaidev-specific commands
+  if (checks.hasClaudeCommands) {
+    const commandsDir = path.join(projectRoot, '.claude', 'commands');
+    try {
+      const files = await fs.readdir(commandsDir);
+      checks.hasMyAIDevCommands = files.some(f => f.startsWith('myai-'));
+    } catch (e) {
+      // Directory doesn't exist or not readable
+    }
+  }
+
+  // Check for myaidev-specific agents
+  if (checks.hasClaudeAgents) {
+    const agentsDir = path.join(projectRoot, '.claude', 'agents');
+    try {
+      const files = await fs.readdir(agentsDir);
+      checks.hasMyAIDevAgents = files.some(f =>
+        f.includes('content-writer') ||
+        f.includes('visual') ||
+        f.includes('wordpress')
+      );
+    } catch (e) {
+      // Directory doesn't exist or not readable
+    }
+  }
+
+  // Determine installation type
+  const hasLegacy = checks.hasManifest || (checks.hasMyAIDevCommands || checks.hasMyAIDevAgents);
+  const hasPlugin = checks.hasPluginJson;
+
+  let installationType;
+  if (hasLegacy && hasPlugin) {
+    installationType = InstallationType.BOTH;
+  } else if (hasLegacy) {
+    installationType = InstallationType.LEGACY;
+  } else if (hasPlugin) {
+    installationType = InstallationType.PLUGIN;
+  } else {
+    installationType = InstallationType.NONE;
+  }
+
+  // Get version info if available
+  let legacyVersion = null;
+  let pluginVersion = null;
+
+  if (checks.hasManifest) {
+    try {
+      const manifest = await fs.readJson(path.join(projectRoot, '.myaidev-manifest.json'));
+      legacyVersion = manifest.version || '1.0.0';
+    } catch (e) {
+      // Manifest unreadable
+    }
+  }
+
+  if (checks.hasPluginJson) {
+    try {
+      const pluginJson = await fs.readJson(path.join(projectRoot, '.claude-plugin', 'plugin.json'));
+      pluginVersion = pluginJson.version;
+    } catch (e) {
+      // Plugin json unreadable
+    }
+  }
+
+  // Get installed workflows from manifest
+  let installedWorkflows = [];
+  if (checks.hasManifest) {
+    try {
+      const manifest = await fs.readJson(path.join(projectRoot, '.myaidev-manifest.json'));
+      installedWorkflows = manifest.installedWorkflows || [];
+    } catch (e) {
+      // Manifest unreadable
+    }
+  }
+
+  return {
+    installationType,
+    hasLegacy,
+    hasPlugin,
+    canUpgrade: hasLegacy && !hasPlugin,
+    canCoexist: true, // Both installation methods can coexist
+    checks,
+    versions: {
+      legacy: legacyVersion,
+      plugin: pluginVersion
+    },
+    installedWorkflows,
+    recommendations: getRecommendations(installationType, checks)
+  };
+}
+
+/**
+ * Get recommendations based on installation state
+ *
+ * @param {string} installationType - Current installation type
+ * @param {Object} checks - Detection checks
+ * @returns {string[]} Array of recommendation strings
+ */
+function getRecommendations(installationType, checks) {
+  const recommendations = [];
+
+  switch (installationType) {
+    case InstallationType.NONE:
+      recommendations.push('Run "npx myaidev-method init --claude" to install via npx');
+      recommendations.push('Or use "/plugin install myaidev-method" for plugin installation');
+      break;
+
+    case InstallationType.LEGACY:
+      recommendations.push('Legacy installation detected - all existing commands will continue to work');
+      recommendations.push('Consider upgrading to plugin installation for automatic updates');
+      recommendations.push('Use "/plugin install myaidev-method" to add plugin capabilities');
+      break;
+
+    case InstallationType.PLUGIN:
+      recommendations.push('Plugin installation detected - skills are auto-discovered');
+      recommendations.push('Use "/myaidev-method:*" commands or legacy "/myai-*" aliases');
+      break;
+
+    case InstallationType.BOTH:
+      recommendations.push('Both legacy and plugin installations detected - all features available');
+      recommendations.push('You can use both "/myai-*" and "/myaidev-method:*" command formats');
+      break;
+  }
+
+  return recommendations;
+}
+
+/**
+ * Get a human-readable status message for the installation
+ *
+ * @param {string} projectRoot - The project root directory
+ * @returns {Promise<string>} Status message
+ */
+export async function getInstallationStatus(projectRoot = process.cwd()) {
+  const detection = await detectInstallation(projectRoot);
+
+  let status = '\n📦 MyAIDev Method Installation Status\n';
+  status += '════════════════════════════════════════\n\n';
+
+  switch (detection.installationType) {
+    case InstallationType.NONE:
+      status += '❌ Not Installed\n\n';
+      break;
+    case InstallationType.LEGACY:
+      status += '✅ Legacy Installation (npx)\n';
+      if (detection.versions.legacy) {
+        status += `   Version: ${detection.versions.legacy}\n`;
+      }
+      if (detection.installedWorkflows.length > 0) {
+        status += `   Workflows: ${detection.installedWorkflows.join(', ')}\n`;
+      }
+      status += '\n';
+      break;
+    case InstallationType.PLUGIN:
+      status += '✅ Plugin Installation\n';
+      if (detection.versions.plugin) {
+        status += `   Version: ${detection.versions.plugin}\n`;
+      }
+      status += '\n';
+      break;
+    case InstallationType.BOTH:
+      status += '✅ Dual Installation (Legacy + Plugin)\n';
+      if (detection.versions.legacy) {
+        status += `   Legacy Version: ${detection.versions.legacy}\n`;
+      }
+      if (detection.versions.plugin) {
+        status += `   Plugin Version: ${detection.versions.plugin}\n`;
+      }
+      if (detection.installedWorkflows.length > 0) {
+        status += `   Workflows: ${detection.installedWorkflows.join(', ')}\n`;
+      }
+      status += '\n';
+      break;
+  }
+
+  status += '📋 Recommendations:\n';
+  for (const rec of detection.recommendations) {
+    status += `   • ${rec}\n`;
+  }
+
+  return status;
+}
+
+/**
+ * Check if upgrade from legacy to plugin is available
+ *
+ * @param {string} projectRoot - The project root directory
+ * @returns {Promise<Object>} Upgrade availability info
+ */
+export async function checkUpgradeAvailability(projectRoot = process.cwd()) {
+  const detection = await detectInstallation(projectRoot);
+
+  return {
+    canUpgrade: detection.canUpgrade,
+    currentType: detection.installationType,
+    upgradeBenefits: [
+      'Automatic skill discovery',
+      'Namespaced commands (/myaidev-method:*)',
+      'Plugin marketplace updates',
+      'Cross-platform support preparation'
+    ],
+    preservedFeatures: [
+      'All existing /myai-* commands',
+      'Installed workflows and agents',
+      'Configuration and environment variables',
+      '.myaidev-manifest.json tracking'
+    ]
+  };
+}
+
+export default {
+  detectInstallation,
+  getInstallationStatus,
+  checkUpgradeAvailability,
+  InstallationType
+};

package/src/lib/visual-config-utils.js

@@ -74,7 +74,7 @@ export function validateVisualConfig() {
 		validation.errors.push("FAL_KEY appears to be invalid (too short)");
 	}
 
-	validation.hasAnyAPIKeys = validation.hasGoogle || validation.hasOpenAI;
+	validation.hasAnyAPIKeys = validation.hasGoogle || validation.hasOpenAI || validation.hasFal;
 
 	// Validate default service
 	if (

package/src/lib/visual-generation-utils.js

@@ -42,13 +42,16 @@ const OPENAI_IMAGE_MODELS = {
 };
 
 // FLUX 2 Models (via Fal.ai or BFL API)
-const FLUX2_MODELS = {
-	"flux2-pro": "fal-ai/flux-2/pro", // State-of-the-art quality, fastest, lowest cost
-	"flux2-flex": "fal-ai/flux-2/flex", // Developer-controlled parameters
-	"flux2-dev": "fal-ai/flux-2/dev", // 32B open-weight model
+export const FLUX2_MODELS = {
+	"flux2-pro": "fal-ai/flux-2-pro", // State-of-the-art quality, fastest, lowest cost
+	"flux2-flex": "fal-ai/flux-2-flex", // Developer-controlled parameters
+	"flux2-dev": "fal-ai/flux-2-dev", // 32B open-weight model
 	// Legacy FLUX 1.x models (still available)
 	"flux-pro": "fal-ai/flux-pro/v1.1-ultra",
 	"flux-dev": "fal-ai/flux/dev",
+
+	// nano banana models
+	"nano-banana-pro": "fal-ai/nano-banana-pro",
 };
 
 // Pricing (USD per image/video)
@@ -100,6 +103,7 @@ export function validateAPIKeys() {
 	}
 	if (hasFal || hasBFL) {
 		availableServices.push(
+			"nano-banana-pro",
 			"flux2-pro",
 			"flux2-flex",
 			"flux2-dev",
@@ -165,6 +169,9 @@ export function estimateCost(service, options = {}) {
 		case "flux-dev":
 			return PRICING.flux_dev;
 
+		case "nano-banana-pro":
+			return PRICING.nano_banana_pro;
+
 		case "veo3":
 		case "veo3-fast":
 			return PRICING.veo3; // per second, will multiply by duration
@@ -642,7 +649,7 @@ export async function generateImageFlux2(prompt, options = {}) {
 					mimeType: contentType,
 					service: "flux2",
 					model: model,
-					cost: PRICING[model.replace("-", "_")] || PRICING.flux2_pro,
+					cost: PRICING[model.replaceAll("-", "_")] || PRICING.flux2_pro,
 				};
 			}
 
@@ -669,13 +676,17 @@ export async function generateImageFlux2(prompt, options = {}) {
  *
  * @param {string} prompt - Image description
  * @param {Object} options - Generation options
- * @param {string} options.model - FLUX model (flux-pro, flux-dev)
+ * @param {string} options.model - FLUX model (nano-banana-pro, flux-pro, flux-dev)
  * @param {string} options.size - Image size
  * @param {number} options.maxRetries - Maximum retry attempts
  * @returns {Promise<Object>} Generated image data
  */
 export async function generateImageFal(prompt, options = {}) {
-	const { model = "flux-pro", size = "1024x1024", maxRetries = 3 } = options;
+	const {
+		model = "nano-banana-pro",
+		size = "1024x1024",
+		maxRetries = 3,
+	} = options;
 
 	const apiKey = process.env.FAL_KEY;
 	if (!apiKey) {
@@ -724,7 +735,7 @@ export async function generateImageFal(prompt, options = {}) {
 					mimeType: contentType,
 					service: "fal",
 					model: model,
-					cost: PRICING[model.replace("-", "_")] || PRICING.flux_pro,
+					cost: PRICING[model.replaceAll("-", "_")] || PRICING.flux_pro,
 				};
 			}
 
@@ -852,12 +863,21 @@ export async function downloadImage(url) {
 export async function generateImage(prompt, options = {}) {
 	const { preferredService, type = "general", ...serviceOptions } = options;
 
-	// Select service
-	const defaultService = process.env.VISUAL_DEFAULT_SERVICE || "gemini";
-	const service = selectBestService(preferredService || defaultService);
+	// If a model is explicitly specified, use it as the service
+	// This allows --service=fal --model=nano-banana-pro to work correctly
+	let service;
+	if (serviceOptions.model && FLUX2_MODELS[serviceOptions.model]) {
+		service = serviceOptions.model;
+	} else {
+		// Select service normally
+		const defaultService = process.env.VISUAL_DEFAULT_SERVICE || "gemini";
+		service = selectBestService(preferredService || defaultService);
+	}
 
-	const modelInfo = serviceOptions.model ? ` (${serviceOptions.model})` : "";
-	console.log(`🎨 Generating ${type} image using ${modelInfo}...`);
+	const modelInfo = serviceOptions.model
+		? ` ${serviceOptions.model}`
+		: ` ${service}`;
+	console.log(`🎨 Generating ${type} image using${modelInfo}...`);
 
 	// Enhance prompt based on image type
 	const enhancedPrompt = enhancePrompt(prompt, type);
@@ -898,7 +918,7 @@ export async function generateImage(prompt, options = {}) {
 		case "nano-banana-pro":
 			result = await generateImageFal(enhancedPrompt, {
 				...serviceOptions,
-				model: serviceOptions.model || service,,
+				model: serviceOptions.model || service,
 			});
 			break;
 

package/src/scripts/generate-visual-cli.js

@@ -14,9 +14,10 @@
 
 import {
 	generateImage,
-	generateVideoVeo,
+	generateVideo,
 	estimateCost,
 	validateAPIKeys,
+	FLUX2_MODELS,
 } from "../lib/visual-generation-utils.js";
 import {
 	saveImage,
@@ -57,6 +58,7 @@ if (!prompt) {
 const options = {
 	type: getOption("type", "hero"),
 	service: getOption("service", null),
+	model: getOption("model", null),
 	size: getOption("size", "1024x1024"),
 	quality: getOption("quality", "standard"),
 	description: getOption("description", null),
@@ -96,11 +98,24 @@ const options = {
 
 		// Estimate cost
 		let service = options.service;
-		if (!service) {
-			// Auto-select based on available services
-			const validation = validateAPIKeys();
-			service = validation.availableServices[0];
-			console.log(chalk.gray(`Auto-selected service: ${service}`));
+
+		// Video generation always uses veo3, ignore model/service for cost estimation
+		if (options.type === "video") {
+			service = "veo3";
+			console.log(chalk.gray(`Video generation uses: veo3`));
+		} else {
+			// For images: if model is specified, it takes precedence over service
+			if (options.model && FLUX2_MODELS[options.model]) {
+				service = options.model;
+				console.log(chalk.gray(`Using model: ${options.model}`));
+			}
+
+			if (!service) {
+				// Auto-select based on available services
+				const validation = validateAPIKeys();
+				service = validation.availableServices[0];
+				console.log(chalk.gray(`Auto-selected service: ${service}`));
+			}
 		}
 
 		const cost = estimateCost(service, {
@@ -108,13 +123,20 @@ const options = {
 			size: options.size,
 		});
 
+		// For video, multiply by duration
+		const videoDuration = 5; // Default duration
+		const finalCost = options.type === "video" ? cost * videoDuration : cost;
+
 		// Check budget
-		const budget = await checkBudgetLimit(cost);
+		const budget = await checkBudgetLimit(finalCost);
 		const todayCost = await getTodaysCost();
 		const monthCost = await getMonthCost();
 
 		console.log(chalk.cyan("💰 Cost Estimate:"));
-		console.log(chalk.gray(`   This generation: $${cost.toFixed(2)}`));
+		console.log(chalk.gray(`   This generation: $${finalCost.toFixed(2)}`));
+		if (options.type === "video") {
+			console.log(chalk.gray(`   (${videoDuration}s × $${cost.toFixed(2)}/s)`));
+		}
 		console.log(
 			chalk.gray(
 				`   Today: $${todayCost.toFixed(2)} / $${budget.dailyBudget.toFixed(2)} (${Math.round((todayCost / budget.dailyBudget) * 100)}%)`,
@@ -177,7 +199,7 @@ const options = {
 		if (options.type === "video") {
 			// Generate video
 			spinner.text = `Generating video using ${service}...`;
-			result = await generateVideoVeo(prompt, {
+			result = await generateVideo(prompt, {
 				duration: 5,
 				aspectRatio: "16:9",
 			});
@@ -198,6 +220,7 @@ const options = {
 			spinner.text = `Generating ${options.type} using ${service}...`;
 			result = await generateImage(prompt, {
 				preferredService: service,
+				model: options.model,
 				type: options.type,
 				quality: options.quality,
 				size: options.size,
@@ -330,9 +353,15 @@ function showHelp() {
 	console.log(
 		chalk.gray("  --service=<service>   AI service (default: auto-select)"),
 	);
+	console.log(
+		chalk.gray("                        Values: gemini, imagen, dalle, veo"),
+	);
+	console.log(
+		chalk.gray("  --model=<model>       Specific model (for fal service)"),
+	);
 	console.log(
 		chalk.gray(
-			"                        Values: gemini, imagen, dalle, veo, nano-banana-pro, flux-pro, flux-dev",
+			"                        Values: nano-banana-pro, flux-pro, flux-dev",
 		),
 	);
 	console.log(

package/src/scripts/ping.js

@@ -15,7 +15,6 @@ export const LOCATIONS = {
 	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
 };
 
 /**