marketing-pipeline-share-content-automation

# AI Providers
ANTHROPIC_API_KEY=your_claude_api_key
OPENAI_API_KEY=your_openai_api_key
 
# Data Sources (RapidAPI)
RAPIDAPI_KEY=your_rapidapi_key
 
# Optional: Custom endpoints
API_BASE_URL=http://localhost:3000

marketing-pineline-share/
├── src/
│   ├── app/              # Next.js app router pages
│   ├── components/       # React components
│   ├── lib/
│   │   ├── ai/          # AI integration (Claude, OpenAI)
│   │   ├── scraper/     # Web scraping modules
│   │   ├── content/     # Content generation logic
│   │   └── video/       # Remotion video rendering
│   └── types/           # TypeScript type definitions
├── remotion/            # Video templates
└── public/              # Static assets

import { researchTopic } from '@/lib/scraper';
 
// Auto-scrape trending news from multiple sources
async function gatherResearch(keyword: string) {
  const research = await researchTopic({
    keyword,
    sources: ['techcrunch', 'twitter', 'linkedin'],
    timeframe: '24h',
    limit: 20
  });
  
  return {
    articles: research.articles,
    insights: research.insights,
    statistics: research.stats
  };
}

import { generateContent } from '@/lib/ai/content-generator';
 
// Generate blog post with Claude/OpenAI
async function createBlogPost(topic: string, research: any) {
  const content = await generateContent({
    provider: 'claude', // or 'openai'
    model: 'claude-3-sonnet-20240229',
    format: 'blog-post', // 'listicle', 'case-study', 'how-to'
    topic,
    research,
    language: 'en', // or 'vi'
    tone: 'professional', // 'friendly', 'humorous'
    length: 'medium' // 'short', 'long'
  });
  
  return {
    title: content.title,
    body: content.body,
    meta: content.metadata,
    images: content.suggestedImages
  };
}

import { ContentPipeline } from '@/lib/content/pipeline';
 
// Generate content in multiple formats from single input
async function generateMultiFormat(keyword: string) {
  const pipeline = new ContentPipeline({
    apiKey: process.env.ANTHROPIC_API_KEY
  });
  
  // Research phase
  await pipeline.research(keyword);
  
  // Generate multiple formats in parallel
  const outputs = await pipeline.generateAll({
    formats: [
      { type: 'blog-post', language: 'en' },
      { type: 'blog-post', language: 'vi' },
      { type: 'social-media', platform: 'linkedin' },
      { type: 'social-media', platform: 'twitter' },
      { type: 'video-script', duration: 60 }
    ]
  });
  
  return outputs;
}

import { renderVideo } from '@/lib/video/renderer';
import { bundle } from '@remotion/bundler';
import { renderMedia } from '@remotion/renderer';
 
// Convert blog post to video
async function createVideoFromPost(post: any) {
  const videoConfig = {
    compositionId: 'BlogPostVideo',
    inputProps: {
      title: post.title,
      content: post.body,
      style: 'modern',
      duration: 90 // seconds
    },
    codec: 'h264',
    outputLocation: `./output/${post.slug}.mp4`,
    // Platform-specific ratios
    width: 1080,
    height: 1920 // 9:16 for TikTok/Reels/Shorts
  };
  
  const bundled = await bundle('./src/remotion/index.ts');
  const result = await renderMedia({
    composition: videoConfig,
    serveUrl: bundled,
    codec: 'h264',
    outputLocation: videoConfig.outputLocation
  });
  
  return result;
}

// Request
{
  "keyword": "AI automation",
  "sources": ["techcrunch", "twitter"],
  "timeframe": "24h"
}
 
// Response
{
  "articles": [...],
  "insights": [...],
  "trending": true
}

// Request
{
  "topic": "AI content automation",
  "format": "blog-post",
  "language": "en",
  "research": {...}
}
 
// Response
{
  "title": "How AI is Transforming Content Creation",
  "body": "...",
  "metadata": {...},
  "images": [...]
}

// Request
{
  "content": {...},
  "template": "modern",
  "aspectRatio": "9:16"
}
 
// Response
{
  "videoUrl": "https://...",
  "thumbnail": "https://...",
  "duration": 90
}

import { ContentAutomation } from '@/lib/automation';
 
async function fullContentPipeline(keyword: string) {
  const automation = new ContentAutomation({
    anthropicKey: process.env.ANTHROPIC_API_KEY,
    openaiKey: process.env.OPENAI_API_KEY,
    rapidApiKey: process.env.RAPIDAPI_KEY
  });
  
  // 1. Research
  console.log('🔍 Researching topic...');
  const research = await automation.research(keyword);
  
  // 2. Generate content
  console.log('✍️ Generating content...');
  const content = await automation.generate({
    topic: keyword,
    research,
    formats: ['blog', 'social', 'video-script']
  });
  
  // 3. Create visuals
  console.log('🎬 Rendering video...');
  const video = await automation.renderVideo({
    script: content.videoScript,
    style: 'professional'
  });
  
  // 4. Export all assets
  return {
    blogPost: content.blog,
    socialPosts: content.social,
    video: video.url,
    publishReady: true
  };
}

import { CronJob } from 'cron';
import { ContentAutomation } from '@/lib/automation';
 
// Auto-generate daily content
const dailyContentJob = new CronJob('0 9 * * *', async () => {
  const automation = new ContentAutomation({
    anthropicKey: process.env.ANTHROPIC_API_KEY
  });
  
  const trendingTopics = await automation.getTrendingTopics({
    category: 'marketing',
    count: 3
  });
  
  for (const topic of trendingTopics) {
    const content = await fullContentPipeline(topic);
    await automation.publishToQueue(content);
  }
});
 
dailyContentJob.start();

import { ContentGenerator } from '@/lib/ai/content-generator';
 
// Create custom content template
const generator = new ContentGenerator({
  provider: 'claude',
  apiKey: process.env.ANTHROPIC_API_KEY
});
 
const customTemplate = {
  name: 'product-launch',
  structure: [
    { section: 'hook', prompt: 'Create attention-grabbing opening' },
    { section: 'problem', prompt: 'Describe pain points' },
    { section: 'solution', prompt: 'Introduce product benefits' },
    { section: 'features', prompt: 'List 5 key features' },
    { section: 'cta', prompt: 'Strong call-to-action' }
  ],
  tone: 'exciting',
  length: 800
};
 
const content = await generator.generateFromTemplate(
  customTemplate,
  { product: 'AI Content Tool', audience: 'marketers' }
);

// src/config/content.ts
export const contentConfig = {
  ai: {
    defaultProvider: 'claude',
    fallbackProvider: 'openai',
    maxTokens: 4000,
    temperature: 0.7
  },
  research: {
    sources: ['techcrunch', 'twitter', 'linkedin', 'producthunt'],
    maxArticles: 20,
    timeframe: '24h'
  },
  video: {
    defaultDuration: 60,
    outputFormat: 'mp4',
    quality: 'high',
    aspectRatios: {
      tiktok: '9:16',
      youtube: '16:9',
      instagram: '1:1'
    }
  }
};

// src/remotion/config.ts
export const videoConfig = {
  fps: 30,
  durationInFrames: 90 * 30, // 90 seconds
  width: 1080,
  height: 1920,
  compositions: [
    {
      id: 'BlogPostVideo',
      component: BlogPostComposition,
      defaultProps: {
        theme: 'dark',
        animation: 'smooth'
      }
    }
  ]
};

// Implement retry logic with exponential backoff
import { retry } from '@/lib/utils/retry';
 
const content = await retry(
  () => generateContent({ topic, research }),
  { maxAttempts: 3, delayMs: 1000 }
);

# Ensure Remotion CLI is installed
npm install -g @remotion/cli
 
# Check Remotion dependencies
npx remotion versions
 
# Common fix: Clear bundle cache
rm -rf .remotion

// Handle failed scrapes gracefully
try {
  const research = await researchTopic(keyword);
} catch (error) {
  console.warn('Scraping failed, using fallback');
  // Use cached data or alternative source
  const fallback = await getFallbackResearch(keyword);
}

// Process content in chunks
async function processLargeDataset(items: any[]) {
  const chunkSize = 10;
  const results = [];
  
  for (let i = 0; i < items.length; i += chunkSize) {
    const chunk = items.slice(i, i + chunkSize);
    const processed = await Promise.all(
      chunk.map(item => generateContent(item))
    );
    results.push(...processed);
  }
  
  return results;
}

# Development mode
npm run dev
 
# Build for production
npm run build
 
# Start production server
npm start
 
# Render single video (CLI)
npx remotion render BlogPostVideo output.mp4 --props='{"title":"My Post"}'