myaidev-method 0.2.15 → 0.2.16

package/.env.example

@@ -50,8 +50,15 @@ GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account-key.json
 # Get API key: https://platform.openai.com/api-keys
 OPENAI_API_KEY=
 
+# Fal.ai API (for FLUX, Veo 3, and premium models) - OPTIONAL
+# Get API key: https://fal.ai/dashboard/keys
+# Hybrid Strategy: Use direct APIs (Google/OpenAI) for cost savings
+# Use Fal.ai for exclusive models (FLUX, Veo 3) or fallback
+# Pricing: FLUX Pro $0.06/image, Veo 3 $0.40/second
+FAL_KEY=
+
 # Visual Generation Preferences
-VISUAL_DEFAULT_SERVICE=gemini       # gemini|imagen|dalle|veo
+VISUAL_DEFAULT_SERVICE=gemini       # gemini|imagen|dalle|veo|flux|veo3
 VISUAL_DEFAULT_QUALITY=standard     # standard|hd
 VISUAL_ASSETS_PATH=./content-assets # Where to save generated files
 

package/CHANGELOG.md

@@ -5,6 +5,38 @@ All notable changes to the MyAIDev Method package will be documented in this fil
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.16] - 2025-11-19
+
+### Fixed
+- **Package Publishing**: Removed `.claude/` from published npm package
+  - `.claude/` folder is for local development/testing only
+  - Users get proper setup via `npx myaidev-method@latest init --claude`
+  - Reduces package size and prevents settings.local.json from being distributed
+  - Templates correctly published from `src/templates/claude/`
+
+### Added
+- **Fal.ai Integration**: Hybrid provider strategy for premium models
+  - Added `@fal-ai/client` dependency for Fal.ai API access
+  - `generateImageFal()` function for FLUX models (Pro v1.1 Ultra, Dev)
+  - `generateVideoFal()` function for Veo 3 video generation
+  - Auto-provider selection (uses direct APIs when cheaper, Fal.ai for exclusives)
+  - Support for FLUX Pro ($0.06/image), FLUX Dev ($0.025/MP)
+  - Support for Veo 3 ($0.40/second), Veo 3 Fast
+  - FAL_KEY environment variable configuration
+
+### Changed
+- **Visual Generation**: Enhanced provider ecosystem
+  - Updated pricing constants with Fal.ai models
+  - Enhanced `getServiceInfo()` with FLUX and Veo 3 details
+  - Updated `generateImage()` to support FLUX services
+  - `.env.example` updated with FAL_KEY and hybrid strategy documentation
+  - Hybrid strategy: Direct APIs primary (cost-effective), Fal.ai for premium/exclusive models
+
+### Strategy
+- **Cost Optimization**: Use direct APIs for better pricing (Gemini $0.02 vs Fal $0.0398)
+- **Premium Access**: Use Fal.ai for FLUX (artistic) and Veo 3 (latest video)
+- **Fallback**: Fal.ai available when direct APIs are rate-limited
+
 ## [0.2.15] - 2025-11-19
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myaidev-method",
-  "version": "0.2.15",
+  "version": "0.2.16",
   "description": "Comprehensive development framework with SPARC methodology for AI-assisted software development, AI visual content generation (Gemini, Imagen, DALL-E, Veo), multi-platform publishing (WordPress, PayloadCMS, Astro, Docusaurus, Mintlify), and Coolify deployment",
   "mcpName": "io.github.myaione/myaidev-method",
   "main": "src/index.js",
@@ -100,6 +100,7 @@
   "type": "module",
   "dependencies": {
     "@effect/platform-node": "^0.98.4",
+    "@fal-ai/client": "^1.7.2",
     "@hono/node-server": "^1.19.5",
     "@modelcontextprotocol/sdk": "^1.18.0",
     "@tsconfig/strictest": "^2.0.5",
@@ -140,7 +141,6 @@
   "files": [
     "bin/",
     "src/",
-    ".claude/",
     "dist/",
     "README.md",
     "USER_GUIDE.md",

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

@@ -52,14 +52,20 @@ async function getVertexAIToken() {
 
 // Pricing (USD per image/video) - GPT-Image-1 pricing
 const PRICING = {
-  gemini: 0.02,        // Gemini 2.5 Flash Image
-  imagen: 0.03,        // Imagen 3
+  gemini: 0.02,        // Gemini 2.5 Flash Image (direct Google API)
+  imagen: 0.03,        // Imagen 3 (direct Google API)
   dalle_low: 0.02,     // GPT-Image-1 low quality
   dalle_medium: 0.07,  // GPT-Image-1 medium quality
   dalle_standard: 0.07, // GPT-Image-1 medium quality (alias for standard)
   dalle_high: 0.19,    // GPT-Image-1 high quality
   dalle_hd: 0.19,      // GPT-Image-1 high quality (alias for hd)
-  veo: 0.10            // Veo 2 (estimated per video)
+  veo: 0.10,           // Veo 2 (estimated per video)
+  // Fal.ai pricing
+  flux_pro: 0.06,      // FLUX Pro v1.1 Ultra
+  flux_dev: 0.025,     // FLUX Dev (per megapixel)
+  veo3: 0.40,          // Veo 3 (per second)
+  gemini_fal: 0.0398,  // Gemini via fal.ai (fallback)
+  imagen_fal: 0.05     // Imagen via fal.ai (fallback)
 };
 
 /**
@@ -514,6 +520,166 @@ export async function generateVideoVeo(prompt, options = {}) {
   throw lastError;
 }
 
+/**
+ * Generate image using Fal.ai
+ * Access to FLUX and other premium models
+ *
+ * @param {string} prompt - Image description
+ * @param {Object} options - Generation options
+ * @param {string} options.model - Fal.ai model (flux-pro, flux-dev, nano-banana, imagen-3-fast)
+ * @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 apiKey = process.env.FAL_KEY;
+  if (!apiKey) {
+    throw new Error('FAL_KEY not configured. Get your key from https://fal.ai/dashboard/keys');
+  }
+
+  // Import fal.ai client
+  const { fal } = await import('@fal-ai/client');
+
+  // Configure credentials
+  fal.config({ credentials: apiKey });
+
+  // Map model names to fal.ai endpoints
+  const modelMap = {
+    'flux-pro': 'fal-ai/flux-pro/v1.1-ultra',
+    'flux-dev': 'fal-ai/flux/dev',
+    'nano-banana': 'fal-ai/nano-banana',
+    'imagen-3-fast': 'fal-ai/fast-imagen'
+  };
+
+  const endpoint = modelMap[model] || modelMap['flux-pro'];
+
+  let lastError;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const result = await fal.subscribe(endpoint, {
+        input: {
+          prompt: prompt,
+          image_size: size === '1024x1024' ? 'square' : 'landscape',
+          num_images: 1
+        },
+        logs: false
+      });
+
+      if (result.images && result.images[0]) {
+        const image = result.images[0];
+
+        // Fal.ai returns URL, need to fetch and convert to base64
+        const imageResponse = await fetch(image.url);
+        const imageBuffer = await imageResponse.arrayBuffer();
+        const base64Data = Buffer.from(imageBuffer).toString('base64');
+
+        return {
+          data: base64Data,
+          mimeType: image.content_type || 'image/png',
+          service: 'fal',
+          model: model,
+          cost: PRICING[`${model.replace('-', '_')}`] || PRICING.flux_pro
+        };
+      }
+
+      throw new Error('No image data in Fal.ai response');
+
+    } catch (error) {
+      lastError = error;
+
+      if (attempt < maxRetries) {
+        const backoff = Math.pow(2, attempt) * 1000;
+        console.log(`⚠️ Fal.ai attempt ${attempt} failed. Retrying in ${backoff/1000}s...`);
+        await sleep(backoff);
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Generate video using Fal.ai (Veo 3)
+ * Latest video generation models
+ *
+ * @param {string} prompt - Video description
+ * @param {Object} options - Generation options
+ * @param {string} options.model - Model (veo3, veo3-fast)
+ * @param {number} options.duration - Video duration in seconds
+ * @param {string} options.aspectRatio - Aspect ratio
+ * @param {number} options.maxRetries - Maximum retry attempts
+ * @returns {Promise<Object>} Generated video data
+ */
+export async function generateVideoFal(prompt, options = {}) {
+  const {
+    model = 'veo3',
+    duration = 5,
+    aspectRatio = '16:9',
+    maxRetries = 3
+  } = options;
+
+  const apiKey = process.env.FAL_KEY;
+  if (!apiKey) {
+    throw new Error('FAL_KEY not configured. Get your key from https://fal.ai/dashboard/keys');
+  }
+
+  // Import fal.ai client
+  const { fal } = await import('@fal-ai/client');
+
+  // Configure credentials
+  fal.config({ credentials: apiKey });
+
+  const endpoint = model === 'veo3-fast' ? 'fal-ai/veo3-fast' : 'fal-ai/veo3';
+
+  let lastError;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const result = await fal.subscribe(endpoint, {
+        input: {
+          prompt: prompt,
+          duration: Math.min(duration, 10),
+          aspect_ratio: aspectRatio
+        },
+        logs: false
+      });
+
+      if (result.video && result.video.url) {
+        // Fal.ai returns video URL
+        const videoResponse = await fetch(result.video.url);
+        const videoBuffer = await videoResponse.arrayBuffer();
+        const base64Data = Buffer.from(videoBuffer).toString('base64');
+
+        return {
+          data: base64Data,
+          mimeType: 'video/mp4',
+          service: 'fal',
+          model: model,
+          cost: PRICING.veo3 * duration
+        };
+      }
+
+      throw new Error('No video data in Fal.ai response');
+
+    } catch (error) {
+      lastError = error;
+
+      if (attempt < maxRetries) {
+        const backoff = Math.pow(2, attempt) * 1000;
+        console.log(`⚠️ Fal.ai video attempt ${attempt} failed. Retrying in ${backoff/1000}s...`);
+        await sleep(backoff);
+      }
+    }
+  }
+
+  throw lastError;
+}
+
 /**
  * Download image from URL and return buffer
  *
@@ -568,6 +734,12 @@ export async function generateImage(prompt, options = {}) {
       result = await generateImageDALLE(enhancedPrompt, serviceOptions);
       break;
 
+    case 'flux':
+    case 'flux-pro':
+    case 'flux-dev':
+      result = await generateImageFal(enhancedPrompt, { ...serviceOptions, model: service });
+      break;
+
     default:
       throw new Error(`Unknown service: ${service}`);
   }
@@ -636,7 +808,8 @@ export function getServiceInfo(service) {
       speed: 'Fast',
       cost: '$0.02/image',
       quality: 'Good',
-      bestFor: 'Quick hero images, high volume'
+      bestFor: 'Quick hero images, high volume',
+      provider: 'Google AI (Direct)'
     },
     imagen: {
       name: 'Imagen 3',
@@ -644,7 +817,8 @@ export function getServiceInfo(service) {
       speed: 'Medium',
       cost: '$0.03/image',
       quality: 'Excellent',
-      bestFor: 'Premium hero images, photorealistic'
+      bestFor: 'Premium hero images, photorealistic',
+      provider: 'Google Vertex AI (Direct)'
     },
     dalle: {
       name: 'DALL-E 3',
@@ -652,7 +826,8 @@ export function getServiceInfo(service) {
       speed: 'Medium',
       cost: '$0.04-0.12/image',
       quality: 'Excellent',
-      bestFor: 'Creative illustrations, concept art'
+      bestFor: 'Creative illustrations, concept art',
+      provider: 'OpenAI (Direct)'
     },
     veo: {
       name: 'Veo 2',
@@ -660,7 +835,44 @@ export function getServiceInfo(service) {
       speed: 'Slow',
       cost: '$0.10/video (estimated)',
       quality: 'Good',
-      bestFor: 'Product demos, animated diagrams'
+      bestFor: 'Product demos, animated diagrams',
+      provider: 'Google AI (Direct)'
+    },
+    flux: {
+      name: 'FLUX Pro v1.1 Ultra',
+      nickname: 'Premium Artistic',
+      speed: 'Medium',
+      cost: '$0.06/image',
+      quality: 'Outstanding',
+      bestFor: 'Premium artistic images, highest quality',
+      provider: 'Fal.ai'
+    },
+    'flux-pro': {
+      name: 'FLUX Pro v1.1 Ultra',
+      nickname: 'Premium Artistic',
+      speed: 'Medium',
+      cost: '$0.06/image',
+      quality: 'Outstanding',
+      bestFor: 'Premium artistic images, highest quality',
+      provider: 'Fal.ai'
+    },
+    'flux-dev': {
+      name: 'FLUX Dev',
+      nickname: 'Developer Friendly',
+      speed: 'Fast',
+      cost: '$0.025/MP',
+      quality: 'Excellent',
+      bestFor: 'Developer workflows, rapid iteration',
+      provider: 'Fal.ai'
+    },
+    veo3: {
+      name: 'Veo 3',
+      nickname: 'Cutting Edge Video',
+      speed: 'Slow',
+      cost: '$0.40/second',
+      quality: 'Outstanding',
+      bestFor: 'Premium video content, latest features',
+      provider: 'Fal.ai'
     }
   };
 

package/.claude/CLAUDE.md

@@ -1,98 +0,0 @@
-# Claude Code Configuration
-
-This project uses the MyAIDev Method package for enhanced AI-assisted development.
-
-## Available Commands
-
-- `/myai-content-writer` - Create SEO-optimized content
-- `/myai-wordpress-publish` - Publish content to WordPress
-- `/myai-coordinate-content` - Coordinate content production workflow (verify and publish)
-- `/myai-configure` - Configure settings
-
-## Available Agents
-
-- `content-writer` - Professional content creation agent
-- `content-production-coordinator` - Orchestrate content verification and publishing workflow
-- `proprietary-content-verifier` - Verify content uniqueness and quality
-
-## WordPress Integration
-
-To use WordPress features, configure your credentials using:
-
-```bash
-/myai-configure wordpress
-```
-
-This will guide you through setting up:
-- WordPress site URL
-- Username
-- Application Password
-
-### Publishing Content
-
-To publish markdown content to WordPress:
-
-```bash
-/myai-wordpress-publish "your-file.md" --status draft
-```
-
-**Note**: This is a Claude Code slash command, not a terminal command. Run it inside Claude Code, not in your terminal.
-
-## Content Production Workflow
-
-The MyAIDev Method includes a comprehensive content production workflow:
-
-### Coordinated Publishing
-
-Use the content production coordinator to verify and publish multiple pieces of content:
-
-```bash
-/myai-coordinate-content ./content-queue/
-```
-
-**Workflow:**
-1. **Verification**: Automatically checks content for uniqueness and quality
-2. **Categorization**: Separates content into "Ready for Publishing" and "Needs Review"
-3. **Reports**: Generates timestamped reports with detailed analysis
-4. **Publishing**: Publishes approved content in parallel for efficiency
-5. **Tracking**: Reports all published URLs back to you
-
-**Options:**
-- `--dry-run` - Only verify content, don't publish
-- `--force` - Skip confirmation prompts
-- `--verbose` - Show detailed progress
-- `--output-dir` - Specify report directory
-
-### Content Verification
-
-The proprietary-content-verifier agent evaluates:
-- **Knowledge Redundancy**: Whether content is unique or duplicates existing knowledge
-- **AI Detection**: Identifies characteristics of AI-generated content
-- **Quality Assessment**: Provides recommendations for improvement
-
-Content is scored as: **High | Medium | Low | Minimal** redundancy
-
-### Agent Architecture
-
-The content production system uses a coordinator pattern:
-- `content-production-coordinator` orchestrates the workflow
-- `proprietary-content-verifier` validates content quality
-- `content-writer` creates and publishes approved content
-
-All agents work in parallel for maximum efficiency.
-
-## Project Conventions
-
-- All custom commands are in `.claude/commands/`
-- All agents are in `.claude/agents/`
-- Commands and agents use Markdown format with YAML frontmatter
-
-## Build Commands
-
-- `npm install` - Install dependencies
-- `npm test` - Run tests
-- `npm run build` - Build the project
-
-## Notes
-
-This configuration follows Claude Code's official standards for custom commands and agents.

package/.claude/agents/content-production-coordinator.md

@@ -1,111 +0,0 @@
----
-name: content-production-coordinator
-description: The Content Production Coordinator Assistant helps you take a repository of Titles, Proprietary Content, References, and Goals and publish them to your website
-tools: Read, Write, Edit, WebSearch, WebFetch, Task
----
-
-You are a Content Production Coordinator specializing in taking a task list and calling your specified subagents to process that list.
-
-## Task
-
-### 1. Initialize Work List
-- Read the provided directory: `$WORK_LIST`
-- Create your "Requested for Publishing List" from the files in that directory
-- Ensure each list item has: Title, Proprietary Content, References, and Goals
-- Display the list to the user for confirmation before proceeding
-
-### 2. Verify Proprietary Content
-- For each list item, call the `proprietary-content-verifier` subagent to check the **Proprietary Content**
-- Send these jobs **in parallel** to your subagent for efficiency
-- You will receive back a REDUNDANCY SCORE and RECOMMENDATION
-- If REDUNDANCY SCORE is Low or Minimal and RECOMMENDATION is "Proceed with publishing", add to Ready for Publishing list
-- If REDUNDANCY SCORE is Medium or High, or RECOMMENDATION is "Needs review" or "Reject", add to Needs Review list
-
-### 3. Categorize Results
-- **Ready for Publishing**: Items with Low/Minimal redundancy scores and "Proceed with publishing" recommendation
-- **Needs Review**: Items with Medium/High redundancy scores or "Needs review"/"Reject" recommendations (include feedback from proprietary-content-verifier)
-
-### 4. Write Output Lists
-- Write both lists to your working directory with clear categorization
-- Use clear filenames with timestamps: `ready-for-publishing-YYYY-MM-DD-HH-MM-SS.md` and `needs-review-YYYY-MM-DD-HH-MM-SS.md`
-- Include all details: Title, Proprietary Content score, Verifier feedback, References, Goals
-
-### 5. User Notification
-- If "Needs Review" list has items: Notify User they need to address them and explain why each item needs review
-- If "Ready for Publishing" list has items: Notify User you will begin publishing and ask for confirmation
-
-### 6. Publish Content
-- For all items on the "Ready for Publishing" list:
-  - Call the `content-writer` subagent **in parallel** for each item
-  - Instruct each subagent to use the markdown file containing that list item's content
-  - Provide the Title, Proprietary Content, References, and Goals to the content-writer
-  - Report the published URL to the User as each subagent finishes
-  - URLs are pre-verified by the subagent's Playwright MCP, no additional verification needed
-
-## Core Competencies
-
-1. **Production Goal**
-   - Verify you have the proper list with your User before beginning
-   - Keep the User informed of followup work they may need to do with the Needs Review list
-   - Process items efficiently in parallel where possible
-
-2. **Quality Control**
-   - Ensure all proprietary content is verified before publishing
-   - Maintain clear documentation of decisions and outcomes
-   - Provide transparency in the verification and publishing process
-
-3. **Efficiency**
-   - Use parallel processing for verification and publishing tasks
-   - Minimize wait times by batching operations
-   - Keep the user informed of progress at each stage
-
-## User Communication
-
-1. **Understanding**: Be sure you have the list from the provided directory `$ARGUMENTS`
-2. **Formatting**: Ensure proper Markdown formatting when writing files
-3. **Transparency**: Clearly communicate progress, issues, and next steps
-4. **Confirmation**: Always ask for user confirmation before beginning the publishing phase
-
-## Output Requirements
-
-Save the content as markdown files with descriptive names plus datetime stamps in the filename:
-- `ready-for-publishing-YYYY-MM-DD-HH-MM-SS.md`
-- `needs-review-YYYY-MM-DD-HH-MM-SS.md`
-
-Each file should include:
-- Summary of total items in the category
-- Detailed list of each item with all metadata
-- For Needs Review: Include specific feedback from verification
-- For Ready for Publishing: Include verification scores and confirmation
-
-## Workflow Example
-
-```
-1. User provides: /coordinate-content-production ./content-queue/
-2. Read all files in ./content-queue/
-3. Display list to user: "Found 10 items for publishing. Proceed with verification? (Y/N)"
-4. User confirms: Y
-5. Launch 10 parallel proprietary-content-verifier agents
-6. Collect results: 7 Ready, 3 Need Review
-7. Write output files with timestamp
-8. Notify user: "3 items need review (see needs-review-2025-11-13-14-30-00.md)"
-9. Notify user: "7 items ready for publishing. Proceed? (Y/N)"
-10. User confirms: Y
-11. Launch 7 parallel content-writer agents
-12. Report each published URL as completed
-```
-
-## Error Handling
-
-- If a file in the work list is malformed, add it to Needs Review with explanation
-- If a subagent fails, report the error and add item to Needs Review
-- If verification takes too long, notify user of progress periodically
-- Always complete the process even if some items fail
-
-## Success Criteria
-
-- All items from the work list are processed
-- Items are correctly categorized based on verification
-- User receives clear output files for both categories
-- Publishing proceeds only after user confirmation
-- All published URLs are reported back to the user