myaidev-method 0.2.15 → 0.2.17

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)
 };
 
 /**
@@ -74,9 +80,11 @@ const PRICING = {
 export function validateAPIKeys() {
   const googleKey = process.env.GOOGLE_API_KEY;
   const openaiKey = process.env.OPENAI_API_KEY;
+  const falKey = process.env.FAL_KEY;
 
   const hasGoogle = !!(googleKey && googleKey.length > 20);
   const hasOpenAI = !!(openaiKey && openaiKey.length > 20);
+  const hasFal = !!(falKey && falKey.length > 20);
 
   const availableServices = [];
   if (hasGoogle) {
@@ -85,11 +93,15 @@ export function validateAPIKeys() {
   if (hasOpenAI) {
     availableServices.push('dalle');
   }
+  if (hasFal) {
+    availableServices.push('flux', 'flux-pro', 'flux-dev', 'veo3');
+  }
 
   return {
     hasGoogle,
     hasOpenAI,
-    hasAny: hasGoogle || hasOpenAI,
+    hasFal,
+    hasAny: hasGoogle || hasOpenAI || hasFal,
     availableServices
   };
 }
@@ -127,6 +139,17 @@ export function estimateCost(service, options = {}) {
     case 'veo':
       return PRICING.veo;
 
+    case 'flux':
+    case 'flux-pro':
+      return PRICING.flux_pro;
+
+    case 'flux-dev':
+      return PRICING.flux_dev;
+
+    case 'veo3':
+    case 'veo3-fast':
+      return PRICING.veo3; // per second, will multiply by duration
+
     default:
       return 0;
   }
@@ -514,6 +537,182 @@ 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
+      });
+
+      // Fal.ai can return images in different formats
+      let imageUrl;
+      let contentType = 'image/png';
+
+      if (result.data && result.data.images && result.data.images[0]) {
+        imageUrl = result.data.images[0].url;
+        contentType = result.data.images[0].content_type || 'image/png';
+      } else if (result.images && result.images[0]) {
+        imageUrl = result.images[0].url;
+        contentType = result.images[0].content_type || 'image/png';
+      } else if (result.image && result.image.url) {
+        imageUrl = result.image.url;
+      } else if (result.data && result.data[0] && result.data[0].url) {
+        imageUrl = result.data[0].url;
+      } else if (typeof result === 'string') {
+        imageUrl = result;
+      }
+
+      if (imageUrl) {
+        // Fal.ai returns URL, need to fetch and convert to base64
+        const imageResponse = await fetch(imageUrl);
+        const imageBuffer = await imageResponse.arrayBuffer();
+        const base64Data = Buffer.from(imageBuffer).toString('base64');
+
+        return {
+          data: base64Data,
+          mimeType: contentType,
+          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 +767,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 +841,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 +850,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 +859,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 +868,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/src/templates/claude/agents/content-writer.md

@@ -65,13 +65,62 @@ if (hasAnyAPIKeys()) {
 - Understanding the target audience
 - Competitive content analysis
 
+## Custom Content Rules
+
+The content-writer agent supports custom content generation rules via a `content-rules.md` file in your project root. If this file exists, the agent will incorporate your custom guidelines into the content generation process.
+
+**To use custom rules:**
+
+1. Create a `content-rules.md` file in your project directory
+2. Define your content preferences, style guidelines, brand voice, or formatting requirements
+3. The agent will automatically detect and apply these rules
+
+**Example content-rules.md:**
+```markdown
+# Content Generation Rules
+
+## Brand Voice
+- Use conversational, friendly tone
+- Avoid jargon unless explaining technical concepts
+- Include real-world examples
+
+## Formatting Preferences
+- Keep paragraphs under 3 sentences
+- Use numbered lists for sequential steps
+- Use bullet points for non-sequential items
+
+## SEO Guidelines
+- Target keyword density: 1-2%
+- Include FAQ section for articles over 1000 words
+- Add "Related Resources" section at the end
+
+## Topics to Avoid
+- Political opinions
+- Medical advice
+- Financial recommendations
+
+## Required Elements
+- Author bio at the end
+- Call-to-action in conclusion
+- Social sharing snippet
+```
+
+**Note:** If `content-rules.md` doesn't exist, the agent will use its default professional content creation guidelines.
+
 ## Writing Process
 
+### Phase 0: Load Custom Rules (if available)
+- Check for `content-rules.md` in project root
+- If found, read and incorporate custom guidelines
+- Merge custom rules with default best practices
+- Continue with standard process if file doesn't exist
+
 ### Phase 1: Understanding
 - Identify the content purpose and goals
 - Define the target audience
 - Determine the desired tone and style
 - Clarify key messages and takeaways
+- **Apply custom content rules if available**
 
 ### Phase 2: Research
 - Conduct thorough topic research using WebSearch

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