AppHighway für SaaS: Onboarding & User-Data-Verarbeitung automatisieren

// Node.js Sign-Up Webhook Handler
app.post('/webhook/signup', async (req, res) => {
  const { email, name, userId } = req.body;

  try {
    // Step 1: Validate email
    const validation = await fetch('https://apphighway.com/api/v1/email-validator', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ email })
    }).then(r => r.json());

    if (!validation.is_valid || validation.disposable) {
      return res.status(400).json({ 
        error: 'Invalid email',
        suggestion: validation.suggestions?.[0] 
      });
    }

    // Step 2: Enrich with company data (using Clearbit as example)
    const enrichment = await fetch(
      `https://company.clearbit.com/v2/companies/find?email=${email}`,
      { headers: { 'Authorization': `Bearer ${process.env.CLEARBIT_KEY}` } }
    ).then(r => r.json()).catch(() => null);

    // Step 3: Structure data with Structify
    const structured = await fetch('https://apphighway.com/api/v1/structify', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        text: JSON.stringify({ email, name, enrichment }),
        schema: {
          company_name: 'string',
          company_size: 'string (1-10, 11-50, 51-200, 201-1000, 1000+)',
          industry: 'string',
          role: 'string (Developer, Manager, Executive, Marketing, Sales, Other)',
          tech_stack: 'array of strings',
          company_domain: 'string',
          linkedin_url: 'string or null',
          likely_use_case: 'string (describe primary use case based on role and industry)'
        },
        instructions: 'Analyze email domain and enrichment data. Infer user role from email prefix and name. Identify likely tech stack from company industry. Predict primary use case.'
      })
    }).then(r => r.json());

    // Step 4: Update user profile
    await db.users.update({
      where: { id: userId },
      data: {
        email_validated: true,
        company_name: structured.data.company_name,
        company_size: structured.data.company_size,
        industry: structured.data.industry,
        role: structured.data.role,
        tech_stack: structured.data.tech_stack,
        enriched_at: new Date(),
        onboarding_segment: determineSegment(structured.data)
      }
    });

    // Step 5: Trigger personalized onboarding
    await triggerOnboarding(userId, structured.data);

    // Step 6: Update CRM (if using)
    if (process.env.HUBSPOT_TOKEN) {
      await hubspot.contacts.createOrUpdate(email, {
        company: structured.data.company_name,
        company_size: structured.data.company_size,
        industry: structured.data.industry,
        role: structured.data.role,
        lifecycle_stage: 'lead'
      });
    }

    res.json({ success: true, enrichment: structured.data });
  } catch (error) {
    console.error('Enrichment error:', error);
    // Don't block sign-up on enrichment failure
    res.json({ success: true, enrichment: null });
  }
});

// Determine onboarding segment
function determineSegment(data) {
  const { company_size, role, industry } = data;
  
  if (company_size?.includes('1000+')) return 'enterprise';
  if (role?.includes('Developer')) return 'technical';
  if (role?.includes('Executive')) return 'executive';
  if (['Marketing', 'Sales'].some(r => role?.includes(r))) return 'business';
  return 'general';
}

// React: Display enriched data in dashboard
function UserProfileCard({ userId }) {
  const { data: user } = useSWR(`/api/users/${userId}`);
  
  if (!user?.enriched_at) return <EnrichmentLoading />;
  
  return (
    <Card>
      <CardHeader>
        <h3>{user.name}</h3>
        <Badge>{user.role}</Badge>
      </CardHeader>
      <CardContent>
        <div className="space-y-2">
          <div>
            <Label>Company</Label>
            <p>{user.company_name} ({user.company_size})</p>
          </div>
          <div>
            <Label>Industry</Label>
            <p>{user.industry}</p>
          </div>
          <div>
            <Label>Tech Stack</Label>
            <div className="flex gap-2">
              {user.tech_stack?.map(tech => (
                <Badge key={tech} variant="outline">{tech}</Badge>
              ))}
            </div>
          </div>
        </div>
      </CardContent>
    </Card>
  );
}

// Onboarding Email Automation
const ONBOARDING_SEQUENCES = {
  technical: [
    { day: 0, template: 'welcome_developer', tone: 'casual-technical' },
    { day: 1, template: 'quick_start_guide', tone: 'instructional' },
    { day: 3, template: 'api_best_practices', tone: 'technical' },
    { day: 7, template: 'advanced_features', tone: 'technical' }
  ],
  executive: [
    { day: 0, template: 'welcome_executive', tone: 'professional-warm' },
    { day: 2, template: 'roi_calculator', tone: 'professional' },
    { day: 5, template: 'case_studies', tone: 'professional' },
    { day: 10, template: 'team_invitation', tone: 'professional' }
  ],
  business: [
    { day: 0, template: 'welcome_business', tone: 'friendly-professional' },
    { day: 1, template: 'video_walkthrough', tone: 'friendly' },
    { day: 4, template: 'integration_guide', tone: 'helpful' },
    { day: 8, template: 'success_stories', tone: 'inspirational' }
  ]
};

async function scheduleOnboarding(userId, segment) {
  const user = await db.users.findUnique({ where: { id: userId } });
  const sequence = ONBOARDING_SEQUENCES[segment] || ONBOARDING_SEQUENCES.business;
  
  for (const step of sequence) {
    const sendAt = new Date(Date.now() + step.day * 24 * 60 * 60 * 1000);
    
    await db.scheduledEmails.create({
      data: {
        userId,
        template: step.template,
        tone: step.tone,
        locale: user.locale || 'en',
        sendAt,
        variables: {
          name: user.name,
          company: user.company_name,
          role: user.role,
          industry: user.industry
        }
      }
    });
  }
}

// Email processor (runs every minute via cron)
async function processScheduledEmails() {
  const emails = await db.scheduledEmails.findMany({
    where: {
      sendAt: { lte: new Date() },
      sent: false
    },
    include: { user: true }
  });
  
  for (const email of emails) {
    try {
      // Step 1: Get base template
      const template = await getEmailTemplate(email.template);
      
      // Step 2: Adapt tone
      const tonedContent = await fetch('https://apphighway.com/api/v1/tone-rewriter', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          text: template.body,
          targetTone: email.tone,
          preserveFormatting: true,
          maintainLength: true
        })
      }).then(r => r.json());
      
      // Step 3: Translate if needed
      let finalContent = tonedContent.rewrittenText;
      if (email.locale !== 'en') {
        const translated = await fetch('https://apphighway.com/api/v1/translate', {
          method: 'POST',
          headers: {
            'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            text: finalContent,
            targetLanguage: email.locale,
            context: {
              industry: 'SaaS',
              tone: email.tone,
              preserveHtml: true
            }
          })
        }).then(r => r.json());
        
        finalContent = translated.translatedText;
      }
      
      // Step 4: Personalize
      finalContent = personalizeEmail(finalContent, email.variables);
      
      // Step 5: Send via email service
      await sendgrid.send({
        to: email.user.email,
        from: 'onboarding@yourcompany.com',
        subject: personalizeEmail(template.subject, email.variables),
        html: finalContent,
        tracking: {
          clickTracking: true,
          openTracking: true
        }
      });
      
      // Step 6: Mark as sent
      await db.scheduledEmails.update({
        where: { id: email.id },
        data: { sent: true, sentAt: new Date() }
      });
      
    } catch (error) {
      console.error(`Email send failed: ${email.id}`, error);
      await db.scheduledEmails.update({
        where: { id: email.id },
        data: { 
          failureCount: { increment: 1 },
          lastError: error.message 
        }
      });
    }
  }
}

function personalizeEmail(text, variables) {
  return text.replace(/\{\{(\w+)\}\}/g, (match, key) => {
    return variables[key] || match;
  });
}

// Track engagement
app.get('/track/email/:emailId/open', async (req, res) => {
  await db.emailEngagement.create({
    data: {
      emailId: req.params.emailId,
      event: 'open',
      timestamp: new Date()
    }
  });
  
  // Return 1x1 tracking pixel
  res.set('Content-Type', 'image/gif');
  res.send(Buffer.from('R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==', 'base64'));
});

// Daily Analytics Processing Job
async function processUserAnalytics() {
  const users = await db.users.findMany({
    where: { status: 'active' },
    include: {
      activities: {
        where: { createdAt: { gte: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) } }
      },
      supportTickets: {
        where: { createdAt: { gte: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) } }
      }
    }
  });
  
  const insights = [];
  
  for (const user of users) {
    // Step 1: Analyze usage patterns
    const usageAnalysis = await fetch('https://apphighway.com/api/v1/structify', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        text: JSON.stringify(user.activities),
        schema: {
          usage_trend: 'string (increasing, stable, declining, inactive)',
          primary_features: 'array of most used feature names',
          engagement_level: 'string (high, medium, low)',
          last_active_days_ago: 'number',
          session_frequency: 'string (daily, weekly, monthly, rare)',
          feature_adoption_rate: 'number (0-100)',
          anomalies: 'array of unusual patterns or behaviors'
        },
        instructions: 'Analyze user activity patterns. Identify trends, frequently used features, engagement level, and any anomalies.'
      })
    }).then(r => r.json());
    
    // Step 2: Analyze support tickets and feedback
    let sentiment = null;
    if (user.supportTickets.length > 0) {
      const ticketTexts = user.supportTickets.map(t => t.message).join('\n\n---\n\n');
      
      sentiment = await fetch('https://apphighway.com/api/v1/sentiment-summarizer', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          text: ticketTexts,
          options: {
            extractKeyPhrases: true,
            categorizeTopics: true,
            identifyFeatureRequests: true,
            detectChurnSignals: true
          }
        })
      }).then(r => r.json());
    }
    
    // Step 3: Calculate health score
    const healthScore = calculateHealthScore({
      usage: usageAnalysis.data,
      sentiment: sentiment?.data,
      accountAge: user.createdAt,
      plan: user.plan
    });
    
    // Step 4: Generate insights
    const insight = {
      userId: user.id,
      healthScore,
      usageTrend: usageAnalysis.data.usage_trend,
      engagementLevel: usageAnalysis.data.engagement_level,
      primaryFeatures: usageAnalysis.data.primary_features,
      sentimentScore: sentiment?.data?.score || null,
      churnRisk: healthScore < 40 ? 'high' : healthScore < 60 ? 'medium' : 'low',
      expansionOpportunity: healthScore > 80 && user.plan === 'pro' ? 'high' : 'low',
      featureRequests: sentiment?.data?.feature_requests || [],
      recommendedActions: generateActions(healthScore, usageAnalysis.data, sentiment?.data)
    };
    
    insights.push(insight);
    
    // Step 5: Store in database
    await db.userHealthScores.upsert({
      where: { userId: user.id },
      update: insight,
      create: { ...insight, calculatedAt: new Date() }
    });
    
    // Step 6: Send alerts
    if (insight.churnRisk === 'high') {
      await sendChurnAlert(user, insight);
    }
    
    if (insight.expansionOpportunity === 'high') {
      await sendExpansionAlert(user, insight);
    }
  }
  
  // Step 7: Generate summary report
  await generateInsightsReport(insights);
  
  return insights;
}

function calculateHealthScore({ usage, sentiment, accountAge, plan }) {
  let score = 50; // Base score
  
  // Usage trend impact
  if (usage.usage_trend === 'increasing') score += 20;
  if (usage.usage_trend === 'stable') score += 10;
  if (usage.usage_trend === 'declining') score -= 20;
  if (usage.usage_trend === 'inactive') score -= 40;
  
  // Engagement impact
  if (usage.engagement_level === 'high') score += 20;
  if (usage.engagement_level === 'low') score -= 15;
  
  // Sentiment impact
  if (sentiment) {
    score += sentiment.score * 15; // -15 to +15
  }
  
  // Feature adoption impact
  score += (usage.feature_adoption_rate / 100) * 10;
  
  // Session frequency impact
  if (usage.session_frequency === 'daily') score += 10;
  if (usage.session_frequency === 'rare') score -= 15;
  
  return Math.max(0, Math.min(100, score));
}

function generateActions(healthScore, usage, sentiment) {
  const actions = [];
  
  if (healthScore < 40) {
    actions.push('Contact customer success team urgently');
    actions.push('Offer personalized onboarding call');
  }
  
  if (usage.usage_trend === 'declining') {
    actions.push('Send re-engagement email with new feature highlights');
  }
  
  if (usage.feature_adoption_rate < 30) {
    actions.push('Schedule product walkthrough for underutilized features');
  }
  
  if (sentiment?.feature_requests?.length > 0) {
    actions.push('Forward feature requests to product team');
  }
  
  if (healthScore > 80) {
    actions.push('Consider for case study or testimonial');
    actions.push('Explore expansion to enterprise plan');
  }
  
  return actions;
}

// Real-time dashboard
app.get('/api/dashboard/insights', async (req, res) => {
  const insights = await db.userHealthScores.findMany({
    where: { calculatedAt: { gte: new Date(Date.now() - 24 * 60 * 60 * 1000) } },
    include: { user: true },
    orderBy: { healthScore: 'asc' }
  });
  
  const summary = {
    totalUsers: insights.length,
    highChurnRisk: insights.filter(i => i.churnRisk === 'high').length,
    mediumChurnRisk: insights.filter(i => i.churnRisk === 'medium').length,
    expansionOpportunities: insights.filter(i => i.expansionOpportunity === 'high').length,
    avgHealthScore: insights.reduce((sum, i) => sum + i.healthScore, 0) / insights.length,
    topFeatureRequests: aggregateFeatureRequests(insights)
  };
  
  res.json({ summary, insights: insights.slice(0, 50) });
});

// Notification Generator
const NOTIFICATION_TYPES = {
  milestone: {
    context: 'User achieved significant milestone',
    tone: 'celebratory-encouraging',
    channels: ['in-app', 'email']
  },
  inactivity: {
    context: 'User hasn\'t logged in for 7+ days',
    tone: 'friendly-helpful',
    channels: ['email', 'push']
  },
  feature_release: {
    context: 'New feature announcement',
    tone: 'exciting-informative',
    channels: ['in-app', 'push', 'email']
  },
  security: {
    context: 'Security-related alert',
    tone: 'professional-urgent',
    channels: ['email', 'push']
  },
  collaboration: {
    context: 'Team member invited or shared content',
    tone: 'friendly-professional',
    channels: ['in-app', 'email']
  }
};

async function sendSmartNotification({
  userId,
  type,
  data,
  priority = 'normal'
}) {
  const user = await db.users.findUnique({ 
    where: { id: userId },
    include: { preferences: true }
  });
  
  const notifConfig = NOTIFICATION_TYPES[type];
  
  // Step 1: Generate message
  const message = await fetch('https://apphighway.com/api/v1/chatbot-completion', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: `Generate a ${type} notification`,
      context: `
User: ${user.name}
Role: ${user.role}
Company: ${user.company_name}
${notifConfig.context}
Data: ${JSON.stringify(data)}
`,
      instructions: `Create a personalized notification message. Tone: ${notifConfig.tone}. Include specific details from the data. Keep it under 150 characters for in-app/push, under 300 for email subject.`,
      tone: notifConfig.tone,
      format: 'notification'
    })
  }).then(r => r.json());
  
  // Step 2: Select channels based on user preferences and activity
  const channels = selectChannels(
    notifConfig.channels,
    user.preferences,
    user.lastSeenAt,
    priority
  );
  
  // Step 3: Deliver via selected channels
  const deliveries = [];
  
  for (const channel of channels) {
    switch (channel) {
      case 'in-app':
        await db.notifications.create({
          data: {
            userId,
            type,
            title: message.response.split('\n')[0],
            body: message.response,
            data: data,
            read: false
          }
        });
        
        // Send via WebSocket for real-time delivery
        io.to(`user:${userId}`).emit('notification', {
          type,
          message: message.response
        });
        
        deliveries.push({ channel: 'in-app', status: 'sent' });
        break;
        
      case 'push':
        if (user.pushTokens?.length > 0) {
          await firebase.messaging().sendMulticast({
            tokens: user.pushTokens,
            notification: {
              title: message.response.split('\n')[0],
              body: message.response.split('\n').slice(1).join(' ')
            },
            data: data
          });
          deliveries.push({ channel: 'push', status: 'sent' });
        }
        break;
        
      case 'email':
        await sendgrid.send({
          to: user.email,
          from: 'notifications@yourcompany.com',
          subject: message.response.split('\n')[0],
          html: formatNotificationEmail(message.response, type, data),
          trackingSettings: {
            clickTracking: { enable: true },
            openTracking: { enable: true }
          }
        });
        deliveries.push({ channel: 'email', status: 'sent' });
        break;
    }
  }
  
  // Step 4: Log notification
  await db.notificationLog.create({
    data: {
      userId,
      type,
      message: message.response,
      channels: deliveries,
      priority,
      sentAt: new Date()
    }
  });
  
  return { success: true, deliveries };
}

function selectChannels(available, preferences, lastSeenAt, priority) {
  const channels = [];
  
  // Always use in-app for active users
  const isActive = lastSeenAt && (Date.now() - lastSeenAt.getTime()) < 5 * 60 * 1000;
  if (isActive && available.includes('in-app')) {
    channels.push('in-app');
  }
  
  // Use email for high priority or inactive users
  if ((priority === 'high' || !isActive) && available.includes('email')) {
    if (preferences?.emailNotifications !== false) {
      channels.push('email');
    }
  }
  
  // Use push for mobile-active users
  if (available.includes('push') && preferences?.pushNotifications !== false) {
    channels.push('push');
  }
  
  return channels;
}

// Example: Milestone notification
app.post('/api/events/milestone', async (req, res) => {
  const { userId, milestone } = req.body;
  
  await sendSmartNotification({
    userId,
    type: 'milestone',
    data: {
      milestone: milestone.name,
      value: milestone.value,
      nextGoal: milestone.nextGoal
    },
    priority: 'normal'
  });
  
  res.json({ success: true });
});

// React: In-app notification component
function NotificationCenter() {
  const [notifications, setNotifications] = useState([]);
  
  useEffect(() => {
    // Load unread notifications
    fetch('/api/notifications/unread')
      .then(r => r.json())
      .then(data => setNotifications(data));
    
    // Listen for real-time notifications
    socket.on('notification', (notif) => {
      setNotifications(prev => [notif, ...prev]);
      toast(notif.message);
    });
  }, []);
  
  return (
    <DropdownMenu>
      <DropdownMenuTrigger>
        <Bell className="h-5 w-5" />
        {notifications.length > 0 && (
          <Badge className="absolute -top-1 -right-1">
            {notifications.length}
          </Badge>
        )}
      </DropdownMenuTrigger>
      <DropdownMenuContent className="w-80">
        {notifications.map(notif => (
          <DropdownMenuItem key={notif.id}>
            <div className="flex flex-col gap-1">
              <p className="font-medium">{notif.title}</p>
              <p className="text-sm text-muted-foreground">{notif.body}</p>
            </div>
          </DropdownMenuItem>
        ))}
      </DropdownMenuContent>
    </DropdownMenu>
  );
}

// Feature Request Processor
app.post('/api/feedback/submit', async (req, res) => {
  const { userId, feedback, source } = req.body;
  
  const user = await db.users.findUnique({ where: { id: userId } });
  
  try {
    // Step 1: Extract Q&A from feedback
    const qa = await fetch('https://apphighway.com/api/v1/qa-extractor', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        text: feedback,
        options: {
          extractQuestions: true,
          extractRequirements: true,
          identifyPainPoints: true
        }
      })
    }).then(r => r.json());
    
    // Step 2: Generate feature specification
    const featureSpec = await fetch('https://apphighway.com/api/v1/feature-generator', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        text: feedback,
        context: {
          userRole: user.role,
          companySize: user.company_size,
          currentPlan: user.plan
        },
        options: {
          generateUserStory: true,
          extractAcceptanceCriteria: true,
          suggestImplementation: true,
          estimateComplexity: true
        }
      })
    }).then(r => r.json());
    
    // Step 3: Categorize
    const category = await categorizeFeature(featureSpec.data);
    
    // Step 4: Check for duplicates
    const existingRequests = await db.featureRequests.findMany({
      where: { category, status: { in: ['open', 'planned'] } }
    });
    
    let duplicateOf = null;
    for (const existing of existingRequests) {
      const similarity = calculateSimilarity(
        featureSpec.data.title,
        existing.title
      );
      
      if (similarity > 0.85) {
        duplicateOf = existing.id;
        break;
      }
    }
    
    // Step 5: Calculate priority score
    const priorityScore = calculatePriorityScore({
      userPlan: user.plan,
      userMRR: user.mrr,
      complexity: featureSpec.data.complexity,
      requestCount: duplicateOf ? existing.requestCount + 1 : 1
    });
    
    // Step 6: Store feature request
    const request = await db.featureRequests.create({
      data: {
        userId,
        title: featureSpec.data.title,
        description: featureSpec.data.description,
        userStory: featureSpec.data.user_story,
        acceptanceCriteria: featureSpec.data.acceptance_criteria,
        category,
        painPoints: qa.data.pain_points,
        questions: qa.data.questions,
        complexity: featureSpec.data.complexity,
        priorityScore,
        duplicateOf,
        source,
        rawFeedback: feedback,
        status: 'open'
      }
    });
    
    // Step 7: Create Linear ticket (if high priority)
    if (priorityScore > 75) {
      await createLinearIssue(request, featureSpec.data);
    }
    
    // Step 8: Update user
    await sendgrid.send({
      to: user.email,
      from: 'product@yourcompany.com',
      subject: 'Thanks for your feedback!',
      html: `
        <p>Hi ${user.name},</p>
        <p>Thanks for sharing your feedback about: <strong>${featureSpec.data.title}</strong></p>
        ${duplicateOf ? '<p>We\'ve merged your request with a similar existing request. You\'ll be notified when we ship it!</p>' : '<p>We\'ve added this to our product roadmap. You\'ll be notified of any updates.</p>'}
        <p>View all feature requests: <a href="https://yourcompany.com/roadmap">Product Roadmap</a></p>
      `
    });
    
    res.json({ 
      success: true, 
      requestId: request.id,
      isDuplicate: !!duplicateOf
    });
    
  } catch (error) {
    console.error('Feature request processing error:', error);
    res.status(500).json({ error: 'Processing failed' });
  }
});

async function categorizeFeature(featureData) {
  const categories = [
    'Authentication',
    'Analytics',
    'Integrations',
    'API',
    'UI/UX',
    'Performance',
    'Collaboration',
    'Security',
    'Billing',
    'Other'
  ];
  
  // Simple keyword matching (can be enhanced with ML)
  const text = (featureData.title + ' ' + featureData.description).toLowerCase();
  
  for (const category of categories) {
    const keywords = getCategoryKeywords(category);
    if (keywords.some(kw => text.includes(kw))) {
      return category;
    }
  }
  
  return 'Other';
}

function calculatePriorityScore({ userPlan, userMRR, complexity, requestCount }) {
  let score = 0;
  
  // User value impact
  if (userPlan === 'enterprise') score += 40;
  else if (userPlan === 'pro') score += 25;
  else if (userPlan === 'starter') score += 15;
  else score += 5;
  
  // MRR impact
  score += Math.min(30, (userMRR / 100));
  
  // Complexity penalty
  if (complexity === 'low') score += 20;
  else if (complexity === 'medium') score += 10;
  else score -= 10;
  
  // Request count boost
  score += Math.min(20, requestCount * 2);
  
  return Math.min(100, Math.max(0, score));
}

async function createLinearIssue(request, spec) {
  await linear.issueCreate({
    teamId: process.env.LINEAR_PRODUCT_TEAM_ID,
    title: spec.title,
    description: `
## User Story
${spec.user_story}

## Acceptance Criteria
${spec.acceptance_criteria.map(c => `- ${c}`).join('\n')}

## Pain Points
${request.painPoints.map(p => `- ${p}`).join('\n')}

## Complexity
${spec.complexity}

## Priority Score
${request.priorityScore}/100

## Original Feedback
${request.rawFeedback}
    `,
    priority: request.priorityScore > 90 ? 1 : request.priorityScore > 75 ? 2 : 3,
    labelIds: [getCategoryLabelId(request.category)]
  });
}

// Product roadmap view
app.get('/api/roadmap', async (req, res) => {
  const requests = await db.featureRequests.groupBy({
    by: ['category', 'status'],
    _count: true,
    _sum: { priorityScore: true }
  });
  
  res.json({
    byCategory: requests,
    topRequests: await db.featureRequests.findMany({
      where: { status: 'open', duplicateOf: null },
      orderBy: { priorityScore: 'desc' },
      take: 20,
      include: { user: true }
    })
  });
});

// Customer Health Score Calculator
async function calculateHealthScores() {
  // Step 1: Export data sources
  const usageData = await exportUsageData(); // CSV format
  const supportData = await exportSupportTickets(); // CSV format
  const billingData = await exportBillingInfo(); // CSV format
  
  // Step 2: Convert CSV to JSON
  const usage = await fetch('https://apphighway.com/api/v1/csv-to-json', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
      'Content-Type': 'text/csv'
    },
    body: usageData
  }).then(r => r.json());
  
  const support = await fetch('https://apphighway.com/api/v1/csv-to-json', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
      'Content-Type': 'text/csv'
    },
    body: supportData
  }).then(r => r.json());
  
  const billing = await fetch('https://apphighway.com/api/v1/csv-to-json', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
      'Content-Type': 'text/csv'
    },
    body: billingData
  }).then(r => r.json());
  
  // Step 3: Group by customer and analyze
  const customers = groupByCustomer(usage.data, support.data, billing.data);
  
  const healthScores = [];
  
  for (const customer of customers) {
    // Step 4: Use Structify to extract health metrics
    const metrics = await fetch('https://apphighway.com/api/v1/structify', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        text: JSON.stringify(customer),
        schema: {
          usage_trend: 'string (increasing, stable, declining)',
          daily_active_users: 'number',
          monthly_active_users: 'number',
          feature_adoption_rate: 'number (0-100)',
          support_ticket_count_30d: 'number',
          avg_ticket_resolution_time: 'number (hours)',
          negative_feedback_count: 'number',
          payment_status: 'string (current, past_due, churned)',
          contract_end_date: 'string (ISO date)',
          days_until_renewal: 'number',
          expansion_indicators: 'array of strings',
          churn_signals: 'array of strings'
        },
        instructions: 'Extract customer health metrics. Identify usage trends, support patterns, billing status, and signals for expansion or churn.'
      })
    }).then(r => r.json());
    
    // Step 5: Calculate composite health score
    const healthScore = {
      customerId: customer.id,
      customerName: customer.name,
      overallScore: 0,
      dimensions: {},
      status: 'green',
      churnRisk: 'low',
      expansionPotential: 'low',
      recommendedActions: [],
      calculatedAt: new Date()
    };
    
    // Usage health (0-40 points)
    let usageScore = 0;
    if (metrics.data.usage_trend === 'increasing') usageScore += 15;
    else if (metrics.data.usage_trend === 'stable') usageScore += 10;
    else usageScore += 0;
    
    const dau_mau_ratio = metrics.data.daily_active_users / metrics.data.monthly_active_users;
    usageScore += (dau_mau_ratio * 15); // 0-15 points
    
    usageScore += (metrics.data.feature_adoption_rate / 100) * 10; // 0-10 points
    healthScore.dimensions.usage = usageScore;
    
    // Support health (0-25 points)
    let supportScore = 25;
    supportScore -= Math.min(15, metrics.data.support_ticket_count_30d * 2);
    supportScore -= Math.min(5, metrics.data.negative_feedback_count * 5);
    healthScore.dimensions.support = Math.max(0, supportScore);
    
    // Billing health (0-20 points)
    let billingScore = 20;
    if (metrics.data.payment_status === 'past_due') billingScore -= 15;
    else if (metrics.data.payment_status === 'churned') billingScore = 0;
    
    if (metrics.data.days_until_renewal < 30) billingScore -= 5;
    healthScore.dimensions.billing = Math.max(0, billingScore);
    
    // Engagement health (0-15 points)
    const engagementScore = Math.min(15, customer.logins_last_30d / 2);
    healthScore.dimensions.engagement = engagementScore;
    
    // Calculate overall score
    healthScore.overallScore = Object.values(healthScore.dimensions)
      .reduce((sum, score) => sum + score, 0);
    
    // Determine status
    if (healthScore.overallScore >= 75) healthScore.status = 'green';
    else if (healthScore.overallScore >= 50) healthScore.status = 'yellow';
    else healthScore.status = 'red';
    
    // Determine churn risk
    if (healthScore.overallScore < 40 || metrics.data.churn_signals.length > 2) {
      healthScore.churnRisk = 'high';
    } else if (healthScore.overallScore < 60 || metrics.data.churn_signals.length > 0) {
      healthScore.churnRisk = 'medium';
    } else {
      healthScore.churnRisk = 'low';
    }
    
    // Determine expansion potential
    if (healthScore.overallScore > 80 && metrics.data.expansion_indicators.length > 1) {
      healthScore.expansionPotential = 'high';
    } else if (healthScore.overallScore > 65 && metrics.data.expansion_indicators.length > 0) {
      healthScore.expansionPotential = 'medium';
    }
    
    // Generate recommended actions
    healthScore.recommendedActions = generateHealthActions(
      healthScore,
      metrics.data
    );
    
    healthScores.push(healthScore);
    
    // Step 6: Update database
    await db.customerHealth.upsert({
      where: { customerId: customer.id },
      update: healthScore,
      create: healthScore
    });
    
    // Step 7: Update CRM
    if (process.env.HUBSPOT_TOKEN) {
      await hubspot.companies.update(customer.crmId, {
        health_score: healthScore.overallScore,
        health_status: healthScore.status,
        churn_risk: healthScore.churnRisk,
        expansion_potential: healthScore.expansionPotential
      });
    }
    
    // Step 8: Alert CSM for high-risk accounts
    if (healthScore.churnRisk === 'high') {
      await sendChurnAlert(customer, healthScore);
    }
    
    if (healthScore.expansionPotential === 'high') {
      await sendExpansionAlert(customer, healthScore);
    }
  }
  
  return healthScores;
}

function generateHealthActions(healthScore, metrics) {
  const actions = [];
  
  if (healthScore.churnRisk === 'high') {
    actions.push('Schedule urgent check-in call with customer');
    actions.push('Review account setup and identify blockers');
    
    if (metrics.support_ticket_count_30d > 5) {
      actions.push('Escalate support issues to engineering team');
    }
    
    if (metrics.usage_trend === 'declining') {
      actions.push('Offer personalized training session');
    }
  }
  
  if (healthScore.dimensions.usage < 20) {
    actions.push('Send onboarding reminder email');
    actions.push('Identify unused features for training');
  }
  
  if (healthScore.expansionPotential === 'high') {
    actions.push('Schedule expansion conversation');
    actions.push('Prepare ROI analysis for upgrade');
    actions.push('Share enterprise features overview');
  }
  
  if (metrics.days_until_renewal < 30) {
    actions.push('Initiate renewal conversation');
    actions.push('Prepare usage report for stakeholder review');
  }
  
  return actions;
}

// Dashboard view
app.get('/api/health-dashboard', async (req, res) => {
  const scores = await db.customerHealth.findMany({
    include: { customer: true },
    orderBy: { overallScore: 'asc' }
  });
  
  const dashboard = {
    summary: {
      total: scores.length,
      green: scores.filter(s => s.status === 'green').length,
      yellow: scores.filter(s => s.status === 'yellow').length,
      red: scores.filter(s => s.status === 'red').length,
      highChurnRisk: scores.filter(s => s.churnRisk === 'high').length,
      expansionOpportunities: scores.filter(s => s.expansionPotential === 'high').length
    },
    atRiskAccounts: scores.filter(s => s.churnRisk === 'high').slice(0, 20),
    expansionOpportunities: scores.filter(s => s.expansionPotential === 'high').slice(0, 20)
  };
  
  res.json(dashboard);
});

// API Documentation Generator (runs on deploy)
const fs = require('fs');
const yaml = require('yaml');

async function generateAPIDocs() {
  // Step 1: Load OpenAPI spec
  const openAPISpec = yaml.parse(fs.readFileSync('./openapi.yaml', 'utf8'));
  
  const docs = {
    title: openAPISpec.info.title,
    version: openAPISpec.info.version,
    endpoints: []
  };
  
  // Step 2: Process each endpoint
  for (const [path, methods] of Object.entries(openAPISpec.paths)) {
    for (const [method, spec] of Object.entries(methods)) {
      // Step 3: Generate human-readable description
      const description = await fetch('https://apphighway.com/api/v1/summarization', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          text: `
Endpoint: ${method.toUpperCase()} ${path}
Summary: ${spec.summary || ''}
Description: ${spec.description || ''}
Parameters: ${JSON.stringify(spec.parameters || [])}
Request Body: ${JSON.stringify(spec.requestBody || {})}
Responses: ${JSON.stringify(spec.responses || {})}
          `,
          options: {
            style: 'technical',
            length: 'medium',
            includeExamples: true
          }
        })
      }).then(r => r.json());
      
      // Step 4: Generate Q&A examples
      const qa = await fetch('https://apphighway.com/api/v1/qa-extractor', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          text: description.summary + '\n\n' + (spec.description || ''),
          options: {
            generateFAQ: true,
            includeCommonIssues: true
          }
        })
      }).then(r => r.json());
      
      // Step 5: Generate code examples
      const codeExamples = await generateCodeExamples(path, method, spec);
      
      docs.endpoints.push({
        path,
        method: method.toUpperCase(),
        title: spec.summary,
        description: description.summary,
        authentication: spec.security?.length > 0,
        parameters: spec.parameters || [],
        requestBody: spec.requestBody,
        responses: spec.responses,
        codeExamples,
        faq: qa.data.questions,
        tags: spec.tags || []
      });
    }
  }
  
  // Step 6: Push to documentation platform
  await publishToDocs(docs);
  
  return docs;
}

async function generateCodeExamples(path, method, spec) {
  const examples = {};
  
  // JavaScript/Node.js example
  examples.javascript = `
// ${spec.summary}
const response = await fetch('https://api.yourcompany.com${path}', {
  method: '${method.toUpperCase()}',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  }${spec.requestBody ? `,
  body: JSON.stringify({
    // Request parameters
    ${Object.keys(spec.requestBody.content?.['application/json']?.schema?.properties || {}).map(key => `${key}: 'value'`).join(',\n    ')}
  })` : ''}
});

const data = await response.json();
console.log(data);
  `.trim();
  
  // Python example
  examples.python = `
import requests

# ${spec.summary}
response = requests.${method}(
  'https://api.yourcompany.com${path}',
  headers={
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  }${spec.requestBody ? `,
  json={
    # Request parameters
    ${Object.keys(spec.requestBody.content?.['application/json']?.schema?.properties || {}).map(key => `'${key}': 'value'`).join(',\n    ')}
  }` : ''}
)

data = response.json()
print(data)
  `.trim();
  
  // cURL example
  examples.curl = `
curl -X ${method.toUpperCase()} 'https://api.yourcompany.com${path}' \\
  -H 'Authorization: Bearer YOUR_API_KEY' \\
  -H 'Content-Type: application/json'${spec.requestBody ? ` \\
  -d '{
    ${Object.keys(spec.requestBody.content?.['application/json']?.schema?.properties || {}).map(key => `"${key}": "value"`).join(',\n    ')}
  }'` : ''}
  `.trim();
  
  return examples;
}

async function publishToDocs(docs) {
  // Example: Readme.io integration
  if (process.env.READMEIO_API_KEY) {
    for (const endpoint of docs.endpoints) {
      await fetch(`https://dash.readme.io/api/v1/docs/${endpoint.path}`, {
        method: 'PUT',
        headers: {
          'Authorization': `Basic ${Buffer.from(process.env.READMEIO_API_KEY + ':').toString('base64')}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          title: `${endpoint.method} ${endpoint.path}`,
          type: 'endpoint',
          category: endpoint.tags[0],
          body: formatReadmeDoc(endpoint)
        })
      });
    }
  }
  
  // Example: GitBook integration
  if (process.env.GITBOOK_TOKEN) {
    // Generate markdown files
    for (const endpoint of docs.endpoints) {
      const markdown = formatMarkdownDoc(endpoint);
      await updateGitBookPage(endpoint.path, markdown);
    }
  }
}

function formatMarkdownDoc(endpoint) {
  return `
# ${endpoint.method} ${endpoint.path}

${endpoint.description}

## Authentication
${endpoint.authentication ? 'This endpoint requires authentication.' : 'No authentication required.'}

## Parameters
${endpoint.parameters.map(p => `- **${p.name}** (${p.in}, ${p.required ? 'required' : 'optional'}): ${p.description}`).join('\n')}

## Request Body
\`\`\`json
${JSON.stringify(endpoint.requestBody?.content?.['application/json']?.example || {}, null, 2)}
\`\`\`

## Response
\`\`\`json
${JSON.stringify(endpoint.responses['200']?.content?.['application/json']?.example || {}, null, 2)}
\`\`\`

## Code Examples

### JavaScript
\`\`\`javascript
${endpoint.codeExamples.javascript}
\`\`\`

### Python
\`\`\`python
${endpoint.codeExamples.python}
\`\`\`

### cURL
\`\`\`bash
${endpoint.codeExamples.curl}
\`\`\`

## FAQ
${endpoint.faq.map(q => `**${q.question}**\n${q.answer}\n`).join('\n')}
  `.trim();
}

// CI/CD integration
// In your GitHub Actions or GitLab CI:
// - name: Generate API Docs
//   run: node generate-docs.js
//   env:
//     APPHIGHWAY_TOKEN: ${{ secrets.APPHIGHWAY_TOKEN }}
//     READMEIO_API_KEY: ${{ secrets.READMEIO_API_KEY }}

// Multi-Language Translation System
const SUPPORTED_LANGUAGES = [
  'en', 'es', 'fr', 'de', 'pt', 'it', 'nl', 'pl', 'ru', 'ja',
  'ko', 'zh', 'ar', 'hi', 'tr', 'sv', 'da', 'no', 'fi', 'cs'
];

// Middleware: Detect and set language
app.use(async (req, res, next) => {
  let language = 'en'; // Default
  
  // 1. Check user preference (logged in)
  if (req.user?.preferredLanguage) {
    language = req.user.preferredLanguage;
  }
  // 2. Check cookie
  else if (req.cookies.language) {
    language = req.cookies.language;
  }
  // 3. Detect from Accept-Language header
  else {
    const detected = await fetch('https://apphighway.com/api/v1/language-detector', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        text: req.headers['accept-language'],
        context: 'http_header'
      })
    }).then(r => r.json());
    
    language = detected.language;
  }
  
  // Validate supported
  if (!SUPPORTED_LANGUAGES.includes(language)) {
    language = 'en';
  }
  
  req.language = language;
  res.cookie('language', language, { maxAge: 365 * 24 * 60 * 60 * 1000 });
  
  next();
});

// Translation helper
async function translate(key, language, variables = {}) {
  // Check cache first
  const cacheKey = `translation:${language}:${key}`;
  let translation = await redis.get(cacheKey);
  
  if (!translation) {
    // Get source string
    const source = await db.translations.findUnique({
      where: { key, language: 'en' }
    });
    
    if (!source) return key; // Fallback to key if source missing
    
    // Translate
    const translated = await fetch('https://apphighway.com/api/v1/translate', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        text: source.value,
        targetLanguage: language,
        context: {
          industry: 'SaaS',
          productType: 'B2B software',
          preservePlaceholders: true,
          tone: 'professional-friendly'
        }
      })
    }).then(r => r.json());
    
    translation = translated.translatedText;
    
    // Store in database
    await db.translations.create({
      data: {
        key,
        language,
        value: translation,
        source: source.value
      }
    });
    
    // Cache for 90 days
    await redis.setex(cacheKey, 90 * 24 * 60 * 60, translation);
  }
  
  // Replace variables
  return translation.replace(/\{\{(\w+)\}\}/g, (match, variable) => {
    return variables[variable] || match;
  });
}

// API endpoint for frontend translations
app.get('/api/translations/:language', async (req, res) => {
  const { language } = req.params;
  
  // Check cache
  const cacheKey = `translations:${language}:full`;
  let translations = await redis.get(cacheKey);
  
  if (!translations) {
    // Fetch all translations for this language
    const records = await db.translations.findMany({
      where: { language },
      select: { key: true, value: true }
    });
    
    translations = {};
    for (const record of records) {
      translations[record.key] = record.value;
    }
    
    // If incomplete, translate missing keys
    const sourceKeys = await db.translations.findMany({
      where: { language: 'en' },
      select: { key: true }
    });
    
    const missingKeys = sourceKeys
      .map(s => s.key)
      .filter(key => !translations[key]);
    
    if (missingKeys.length > 0) {
      await translateMissingKeys(missingKeys, language);
      
      // Re-fetch
      const updatedRecords = await db.translations.findMany({
        where: { language, key: { in: missingKeys } },
        select: { key: true, value: true }
      });
      
      for (const record of updatedRecords) {
        translations[record.key] = record.value;
      }
    }
    
    // Cache for 24 hours
    await redis.setex(cacheKey, 24 * 60 * 60, JSON.stringify(translations));
  } else {
    translations = JSON.parse(translations);
  }
  
  res.json(translations);
});

async function translateMissingKeys(keys, language) {
  const sources = await db.translations.findMany({
    where: { language: 'en', key: { in: keys } }
  });
  
  // Batch translate (more efficient)
  const textToTranslate = sources.map(s => s.value).join('\n---\n');
  
  const translated = await fetch('https://apphighway.com/api/v1/translate', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.APPHIGHWAY_TOKEN}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: textToTranslate,
      targetLanguage: language,
      context: {
        industry: 'SaaS',
        preservePlaceholders: true,
        batchMode: true
      }
    })
  }).then(r => r.json());
  
  const translations = translated.translatedText.split('\n---\n');
  
  // Store in database
  for (let i = 0; i < sources.length; i++) {
    await db.translations.create({
      data: {
        key: sources[i].key,
        language,
        value: translations[i],
        source: sources[i].value
      }
    });
  }
}

// React: Language switcher
function LanguageSwitcher() {
  const { language, setLanguage } = useLanguage();
  
  return (
    <Select value={language} onValueChange={setLanguage}>
      <SelectTrigger className="w-[180px]">
        <Globe className="mr-2 h-4 w-4" />
        <SelectValue placeholder="Language" />
      </SelectTrigger>
      <SelectContent>
        {SUPPORTED_LANGUAGES.map(lang => (
          <SelectItem key={lang} value={lang}>
            {getLanguageName(lang)}
          </SelectItem>
        ))}
      </SelectContent>
    </Select>
  );
}

// React: Translation hook
function useTranslate() {
  const { language } = useLanguage();
  const { data: translations } = useSWR(
    `/api/translations/${language}`,
    { revalidateOnFocus: false }
  );
  
  const t = useCallback((key, variables = {}) => {
    let text = translations?.[key] || key;
    
    // Replace variables
    Object.entries(variables).forEach(([key, value]) => {
      text = text.replace(`{{${key}}}`, value);
    });
    
    return text;
  }, [translations]);
  
  return { t, translations, language };
}

// Usage in components
function PricingPage() {
  const { t } = useTranslate();
  
  return (
    <div>
      <h1>{t('pricing.title')}</h1>
      <p>{t('pricing.subtitle', { company: 'YourCompany' })}</p>
      <Button>{t('pricing.start_trial')}</Button>
    </div>
  );
}