initialised repo

app/api/search/route.ts

@@ -0,0 +1,245 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { EnhancedProductAnalysis, Opportunity, DorkQuery } from '@/lib/types'
+
+// Search result from any source
+interface SearchResult {
+  title: string
+  url: string
+  snippet: string
+  source: string
+}
+
+const bodySchema = z.object({
+  analysis: z.object({
+    productName: z.string(),
+    dorkQueries: z.array(z.object({
+      query: z.string(),
+      platform: z.string(),
+      intent: z.string(),
+      priority: z.string()
+    })),
+    keywords: z.array(z.object({
+      term: z.string()
+    })),
+    personas: z.array(z.object({
+      name: z.string(),
+      searchBehavior: z.array(z.string())
+    })),
+    problemsSolved: z.array(z.object({
+      problem: z.string(),
+      searchTerms: z.array(z.string())
+    }))
+  })
+})
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json()
+    const { analysis } = bodySchema.parse(body)
+
+    console.log(`🔍 Finding opportunities for: ${analysis.productName}`)
+    
+    // Sort queries by priority
+    const sortedQueries = analysis.dorkQueries
+      .sort((a, b) => {
+        const priorityOrder = { high: 0, medium: 1, low: 2 }
+        return priorityOrder[a.priority as keyof typeof priorityOrder] - priorityOrder[b.priority as keyof typeof priorityOrder]
+      })
+      .slice(0, 15) // Limit to top 15 queries
+
+    const allResults: SearchResult[] = []
+    
+    // Execute searches
+    for (const query of sortedQueries) {
+      try {
+        console.log(`   Searching: ${query.query.substring(0, 60)}...`)
+        const results = await searchGoogle(query.query, 5)
+        allResults.push(...results)
+        
+        // Small delay to avoid rate limiting
+        await new Promise(r => setTimeout(r, 500))
+      } catch (e) {
+        console.error(`   Search failed for query: ${query.query.substring(0, 40)}`)
+      }
+    }
+
+    console.log(`   Found ${allResults.length} raw results`)
+
+    // Analyze and score opportunities
+    const opportunities = await analyzeOpportunities(allResults, analysis as EnhancedProductAnalysis)
+    console.log(`   ✓ Analyzed ${opportunities.length} opportunities`)
+
+    return NextResponse.json({
+      success: true,
+      data: {
+        totalFound: opportunities.length,
+        opportunities: opportunities.slice(0, 20),
+        searchStats: {
+          queriesUsed: sortedQueries.length,
+          platformsSearched: [...new Set(sortedQueries.map(q => q.platform))],
+          averageRelevance: opportunities.reduce((a, o) => a + o.relevanceScore, 0) / opportunities.length || 0
+        }
+      }
+    })
+
+  } catch (error: any) {
+    console.error('❌ Search error:', error)
+    
+    return NextResponse.json(
+      { error: error.message || 'Failed to find opportunities' },
+      { status: 500 }
+    )
+  }
+}
+
+async function searchGoogle(query: string, num: number): Promise<SearchResult[]> {
+  // Try Serper first
+  if (process.env.SERPER_API_KEY) {
+    try {
+      return await searchSerper(query, num)
+    } catch (e) {
+      console.error('Serper failed, falling back to direct')
+    }
+  }
+  return searchDirect(query, num)
+}
+
+async function searchSerper(query: string, num: number): Promise<SearchResult[]> {
+  const response = await fetch('https://google.serper.dev/search', {
+    method: 'POST',
+    headers: {
+      'X-API-KEY': process.env.SERPER_API_KEY!,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({ q: query, num })
+  })
+
+  if (!response.ok) throw new Error('Serper API error')
+
+  const data = await response.json()
+  return (data.organic || []).map((r: any) => ({
+    title: r.title,
+    url: r.link,
+    snippet: r.snippet,
+    source: getSource(r.link)
+  }))
+}
+
+async function searchDirect(query: string, num: number): Promise<SearchResult[]> {
+  const encodedQuery = encodeURIComponent(query)
+  const url = `https://www.google.com/search?q=${encodedQuery}&num=${num}`
+
+  const response = await fetch(url, {
+    headers: { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36' }
+  })
+
+  const html = await response.text()
+  const results: SearchResult[] = []
+  
+  // Simple regex parsing
+  const resultBlocks = html.match(/<div class="g"[^>]*>([\s\S]*?)<\/div>\s*<\/div>/g) || []
+  
+  for (const block of resultBlocks.slice(0, num)) {
+    const titleMatch = block.match(/<h3[^>]*>(.*?)<\/h3>/)
+    const linkMatch = block.match(/<a href="([^"]+)"/)
+    const snippetMatch = block.match(/<div class="VwiC3b[^"]*"[^>]*>(.*?)<\/div>/)
+    
+    if (titleMatch && linkMatch) {
+      results.push({
+        title: titleMatch[1].replace(/<[^>]+>/g, ''),
+        url: linkMatch[1],
+        snippet: snippetMatch ? snippetMatch[1].replace(/<[^>]+>/g, '') : '',
+        source: getSource(linkMatch[1])
+      })
+    }
+  }
+
+  return results
+}
+
+function getSource(url: string): string {
+  if (url.includes('reddit.com')) return 'Reddit'
+  if (url.includes('news.ycombinator.com')) return 'Hacker News'
+  if (url.includes('indiehackers.com')) return 'Indie Hackers'
+  if (url.includes('quora.com')) return 'Quora'
+  if (url.includes('twitter.com') || url.includes('x.com')) return 'Twitter/X'
+  if (url.includes('stackexchange.com') || url.includes('stackoverflow.com')) return 'Stack Exchange'
+  return 'Other'
+}
+
+async function analyzeOpportunities(
+  results: SearchResult[], 
+  analysis: EnhancedProductAnalysis
+): Promise<Opportunity[]> {
+  const opportunities: Opportunity[] = []
+  const seen = new Set<string>()
+
+  for (const result of results) {
+    if (seen.has(result.url)) continue
+    seen.add(result.url)
+
+    // Calculate relevance score
+    const content = (result.title + ' ' + result.snippet).toLowerCase()
+    
+    // Match keywords
+    const matchedKeywords = analysis.keywords
+      .filter(k => content.includes(k.term.toLowerCase()))
+      .map(k => k.term)
+    
+    // Match problems
+    const matchedProblems = analysis.problemsSolved
+      .filter(p => content.includes(p.problem.toLowerCase()))
+      .map(p => p.problem)
+    
+    // Calculate score
+    const keywordScore = Math.min(matchedKeywords.length * 0.15, 0.6)
+    const problemScore = Math.min(matchedProblems.length * 0.2, 0.4)
+    const relevanceScore = Math.min(keywordScore + problemScore, 1)
+
+    // Determine intent
+    let intent: Opportunity['intent'] = 'looking-for'
+    if (content.includes('frustrated') || content.includes('hate') || content.includes('sucks')) {
+      intent = 'frustrated'
+    } else if (content.includes('alternative') || content.includes('switching')) {
+      intent = 'alternative'
+    } else if (content.includes('vs') || content.includes('comparison') || content.includes('better')) {
+      intent = 'comparison'
+    } else if (content.includes('how to') || content.includes('fix') || content.includes('solution')) {
+      intent = 'problem-solving'
+    }
+
+    // Find matching persona
+    const matchedPersona = analysis.personas.find(p => 
+      p.searchBehavior.some(b => content.includes(b.toLowerCase()))
+    )?.name
+
+    if (relevanceScore >= 0.3) {
+      opportunities.push({
+        title: result.title,
+        url: result.url,
+        source: result.source,
+        snippet: result.snippet.slice(0, 300),
+        relevanceScore,
+        painPoints: matchedProblems.slice(0, 3),
+        suggestedApproach: generateApproach(intent, analysis.productName),
+        matchedKeywords: matchedKeywords.slice(0, 5),
+        matchedPersona,
+        intent
+      })
+    }
+  }
+
+  return opportunities.sort((a, b) => b.relevanceScore - a.relevanceScore)
+}
+
+function generateApproach(intent: string, productName: string): string {
+  const approaches: Record<string, string> = {
+    'frustrated': `Empathize with their frustration. Share how ${productName} solves this specific pain point without being pushy.`,
+    'alternative': `Highlight key differentiators. Focus on why teams switch to ${productName} from their current solution.`,
+    'comparison': `Provide an honest comparison. Be helpful and mention specific features that address their needs.`,
+    'problem-solving': `Offer a clear solution. Share a specific example of how ${productName} solves this exact problem.`,
+    'looking-for': `Introduce ${productName} as a relevant option. Focus on the specific features they're looking for.`
+  }
+  return approaches[intent] || approaches['looking-for']
+}