feat: Add GitHub integration for automated campaign creation

- ✨ Campaign creation wizard with GitHub and manual options
- 🔧 GitHub repository content extraction service
- 🤖 AI-powered campaign generation from README/docs
- 📊 Comprehensive service provider auto-generation
- 🎨 Modern wizard UI with step-by-step guidance
- �� GitHub token setup with clear instructions
- 🏗️ Database schema for GitHub connections
- 🚀 Complete API endpoints for integration
- 🎯 Auto-generation of milestones and pledge tiers
- 📝 Service provider profiles from domain research

Includes:
- Campaign creation wizard (GitHub vs Manual)
- GitHub repository analysis and content extraction
- OpenAI structured output schema fixes
- Service provider auto-generation via Perplexity
- Comprehensive documentation and error handling
- Production-ready build configuration

Author: jazzmind

app/admin/campaigns/[id]/page.tsx

@@ -216,11 +216,10 @@ export default async function AdminCampaignDetail({
             {campaign.description && (
               <div className="mt-6">
                 <h3 className="text-sm font-medium text-gray-500 dark:text-gray-400 mb-2">Description</h3>
-                <div className="prose dark:prose-invert max-w-none">
-                  <p className="text-gray-700 dark:text-gray-300 whitespace-pre-line">
-                    {campaign.description}
-                  </p>
-                </div>
+                <div 
+                  className="prose max-w-none"
+                  dangerouslySetInnerHTML={{ __html: campaign.description }}
+                />
               </div>
             )}
           </div>

app/api/campaigns/[id]/generate-image/route.ts

@@ -1,7 +1,7 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/db';
-import { ImageGenerationService } from '@/lib/services/ImageGenerationService';
+import { ImageLibraryService } from '@/lib/services/ImageLibraryService';
 import { AIClient } from '@/lib/aiClient';
 import { AIError } from '@/lib/aiService';
 
@@ -45,24 +45,28 @@ export async function POST(
       }, { status: 500 });
     }
 
-    // Generate image using the new service
-    const service = new ImageGenerationService();
-    const result = await service.generateCampaignImage({
-      id: campaign.id,
-      title: campaign.title,
-      summary: campaign.summary || undefined,
-      description: campaign.description || undefined
+    // Generate and store image using the library service
+    const service = new ImageLibraryService();
+    const result = await service.generateAndStoreImage({
+      prompt: `Professional hero image for "${campaign.title}". ${campaign.summary || ''}`,
+      userId: session.user.id,
+      organizationId: campaign.organizationId || undefined,
+      campaignTitle: campaign.title,
+      theme: 'technology',
+      tags: ['campaign', 'hero', 'professional'],
+      isPublic: false
     });
 
-    // Update campaign with new image path
+    // Update campaign with new image URL
     await prisma.campaign.update({
       where: { id: campaign.id },
-      data: { image: result.data.imagePath }
+      data: { image: result.data.blobUrl }
     });
 
     return NextResponse.json({ 
       success: true, 
-      imagePath: result.data.imagePath,
+      imagePath: result.data.blobUrl,
+      imageUrl: result.data.blobUrl,
       prompt: result.data.prompt,
       message: 'Image generated successfully!' 
     }, {

app/api/campaigns/[id]/route.ts

@@ -59,6 +59,9 @@ export async function PUT(request: NextRequest, { params }: RouteParams) {
       sectors,
       requireBackerAccount,
       onlyBackersComment,
+      milestones,
+      stretchGoals,
+      priceTiers,
     } = body;
 
     // Get existing campaign
@@ -103,6 +106,65 @@ export async function PUT(request: NextRequest, { params }: RouteParams) {
       if (onlyBackersComment !== undefined) updateData.onlyBackersComment = onlyBackersComment;
     }
 
+    // Handle milestones and stretch goals updates
+    if (milestones !== undefined && (existingCampaign.status === 'draft' || isAdmin)) {
+      // Delete existing milestones and create new ones
+      await prisma.milestone.deleteMany({
+        where: { campaignId: resolvedParams.id }
+      });
+
+      if (milestones.length > 0) {
+        await prisma.milestone.createMany({
+          data: milestones.map((milestone: any) => ({
+            campaignId: resolvedParams.id,
+            name: milestone.name,
+            pct: milestone.pct,
+            acceptance: milestone.acceptance,
+            status: 'pending'
+          }))
+        });
+      }
+    }
+
+    if (stretchGoals !== undefined && (existingCampaign.status === 'draft' || isAdmin)) {
+      // Delete existing stretch goals and create new ones
+      await prisma.stretchGoal.deleteMany({
+        where: { campaignId: resolvedParams.id }
+      });
+
+      if (stretchGoals.length > 0) {
+        await prisma.stretchGoal.createMany({
+          data: stretchGoals.map((goal: any, index: number) => ({
+            campaignId: resolvedParams.id,
+            title: goal.title,
+            description: goal.description,
+            targetDollars: goal.targetDollars,
+            order: goal.order || index + 1
+          }))
+        });
+      }
+    }
+
+    if (priceTiers !== undefined && (existingCampaign.status === 'draft' || isAdmin)) {
+      // Delete existing price tiers and create new ones
+      await prisma.pledgeTier.deleteMany({
+        where: { campaignId: resolvedParams.id }
+      });
+
+      if (priceTiers.length > 0) {
+        await prisma.pledgeTier.createMany({
+          data: priceTiers.map((tier: any, index: number) => ({
+            campaignId: resolvedParams.id,
+            title: tier.title,
+            description: tier.description,
+            amountDollars: tier.amountDollars,
+            benefits: JSON.stringify(tier.benefits || []),
+            order: tier.order || index + 1
+          }))
+        });
+      }
+    }
+
     // Update the campaign
     const updatedCampaign = await prisma.campaign.update({
       where: { id: resolvedParams.id },
@@ -113,7 +175,10 @@ export async function PUT(request: NextRequest, { params }: RouteParams) {
         },
         organization: {
           select: { id: true, name: true }
-        }
+        },
+        milestones: true,
+        stretchGoals: { orderBy: { order: 'asc' } },
+        pledgeTiers: { orderBy: { order: 'asc' } }
       }
     });
 

app/api/campaigns/auto-generate-image/route.ts

@@ -1,7 +1,7 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/db';
-import { ImageGenerationService } from '@/lib/services/ImageGenerationService';
+import { ImageLibraryService } from '@/lib/services/ImageLibraryService';
 import { AIClient } from '@/lib/aiClient';
 import { AIError } from '@/lib/aiService';
 
@@ -58,24 +58,28 @@ export async function POST(request: NextRequest) {
       });
     }
 
-    // Generate image using the new service
-    const service = new ImageGenerationService();
-    const result = await service.generateCampaignImage({
-      id: campaign.id,
-      title: campaign.title,
-      summary: campaign.summary || undefined,
-      description: campaign.description || undefined
+    // Generate and store image using the library service
+    const service = new ImageLibraryService();
+    const result = await service.generateAndStoreImage({
+      prompt: `Professional hero image for "${campaign.title}". ${campaign.summary || ''}`,
+      userId: campaign.makerId,
+      organizationId: campaign.organizationId || undefined,
+      campaignTitle: campaign.title,
+      theme: 'technology',
+      tags: ['campaign', 'hero', 'auto-generated'],
+      isPublic: false
     });
 
-    // Update campaign with new image path
+    // Update campaign with new image URL
     await prisma.campaign.update({
       where: { id: campaign.id },
-      data: { image: result.data.imagePath }
+      data: { image: result.data.blobUrl }
     });
 
     return NextResponse.json({ 
       success: true, 
-      imagePath: result.data.imagePath,
+      imagePath: result.data.blobUrl,
+      imageUrl: result.data.blobUrl,
       prompt: result.data.prompt,
       message: 'Image generated successfully'
     }, {

app/api/campaigns/generate-from-repo/route.ts

@@ -0,0 +1,161 @@
+import { NextRequest, NextResponse } from "next/server";
+import { prisma } from "@/lib/db";
+import { auth } from "@/lib/auth";
+import { z } from "zod";
+import GitHubService from "@/lib/services/GitHubService";
+import CampaignGenerationService from "@/lib/services/CampaignGenerationService";
+
+const GenerateFromRepoSchema = z.object({
+  repoUrl: z.string().url("Valid repository URL is required"),
+  userPrompt: z.string().optional(),
+  autoCreate: z.boolean().default(false).describe("Whether to automatically create the campaign or just return the generated content")
+});
+
+export async function POST(req: NextRequest) {
+  try {
+    const session = await auth();
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const body = await req.json();
+    const { repoUrl, userPrompt, autoCreate } = GenerateFromRepoSchema.parse(body);
+
+    // Get user's GitHub connection
+    const githubConnection = await prisma.gitHubConnection.findUnique({
+      where: { userId: session.user.id }
+    });
+
+    // Initialize GitHub service with token if available
+    const githubService = new GitHubService(githubConnection?.githubToken);
+    
+    // Extract repository content
+    console.log(`🔍 Extracting content from repository: ${repoUrl}`);
+    const repoContent = await githubService.extractRepositoryContent(repoUrl);
+    
+    if (!repoContent.hasDocumentation) {
+      return NextResponse.json({ 
+        error: 'Repository has no README or documentation to generate campaign from',
+        suggestion: 'Add a README.md file to your repository with project description'
+      }, { status: 400 });
+    }
+
+    // Generate campaign content using AI
+    console.log(`🤖 Generating campaign content for: ${repoContent.repository.name}`);
+    const campaignGenerationService = new CampaignGenerationService();
+    
+    const generationResult = await campaignGenerationService.generateCampaign({
+      repository: repoContent.repository,
+      readmeContent: repoContent.readmeContent,
+      docsContent: repoContent.docsContent,
+      userPrompt: userPrompt || ''
+    });
+
+    const generatedCampaign = generationResult.data;
+
+    // If autoCreate is true, create the campaign in the database
+    if (autoCreate) {
+      console.log(`📝 Auto-creating campaign: ${generatedCampaign.title}`);
+      
+      const campaign = await prisma.campaign.create({
+        data: {
+          makerId: session.user.id,
+          title: generatedCampaign.title,
+          summary: generatedCampaign.summary,
+          description: generatedCampaign.description,
+          fundingGoalDollars: generatedCampaign.fundingGoalDollars,
+          repoUrl: repoUrl,
+          sectors: generatedCampaign.sectors,
+          deployModes: generatedCampaign.deployModes,
+          status: 'draft'
+        },
+        include: {
+          maker: {
+            select: {
+              id: true,
+              name: true,
+              email: true
+            }
+          }
+        }
+      });
+
+      // Create milestones
+      const milestones = await Promise.all(
+        generatedCampaign.milestones.map(milestone => 
+          prisma.milestone.create({
+            data: {
+              campaignId: campaign.id,
+              name: milestone.name,
+              pct: milestone.pct,
+              acceptance: milestone.acceptance
+            }
+          })
+        )
+      );
+
+      // Create pledge tiers
+      const pledgeTiers = await Promise.all(
+        generatedCampaign.pledgeTiers.map(tier => 
+          prisma.pledgeTier.create({
+            data: {
+              campaignId: campaign.id,
+              title: tier.title,
+              description: tier.description,
+              amountDollars: tier.amountDollars,
+              order: tier.order
+            }
+          })
+        )
+      );
+
+      return NextResponse.json({
+        success: true,
+        campaign: {
+          ...campaign,
+          milestones,
+          pledgeTiers
+        },
+        generated: generatedCampaign,
+        repository: repoContent.repository
+      }, { status: 201 });
+    }
+
+    // Return generated content without creating campaign
+    return NextResponse.json({
+      success: true,
+      generated: generatedCampaign,
+      repository: repoContent.repository,
+      hasDocumentation: repoContent.hasDocumentation
+    });
+
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json({ 
+        error: 'Invalid input data', 
+        details: error.errors 
+      }, { status: 400 });
+    }
+
+    console.error('Error generating campaign from repository:', error);
+    
+    // Handle specific GitHub errors
+    if (error instanceof Error) {
+      if (error.message.includes('Repository not found')) {
+        return NextResponse.json({ 
+          error: 'Repository not found or not accessible. Please check the URL and ensure the repository is public or you have access.'
+        }, { status: 404 });
+      }
+      
+      if (error.message.includes('GitHub API error')) {
+        return NextResponse.json({ 
+          error: 'GitHub API error. Please try again later or check your GitHub token.'
+        }, { status: 502 });
+      }
+    }
+
+    return NextResponse.json({ 
+      error: 'Internal server error' 
+    }, { status: 500 });
+  }
+}