AI Personal Chief of Staff

Comprehensive digital life management with intelligent automation

import { cronflow } from 'cronflow';
import { z } from 'zod';

// Types for better type safety
interface EmailAnalysis {
  priority: 'URGENT' | 'HIGH' | 'MEDIUM' | 'LOW';
  category: string;
  actionRequired: boolean;
  suggestedResponse: string | null;
  reasoning: string;
  confidence: number;
}

interface CalendarOptimization {
  suggestions: {
    type: 'RESCHEDULE' | 'BATCH' | 'BREAK' | 'PREP_TIME';
    description: string;
    originalTime: string;
    suggestedTime: string;
    reason: string;
    energyImpact: number;
  }[];
  productivityScore: number;
  recommendedFocus: string[];
}

interface RelationshipAnalysis {
  followUpNeeded: {
    contact: string;
    lastInteraction: string;
    daysSinceContact: number;
    relationship: string;
    suggestedAction: string;
    priority: number;
  }[];
  relationshipInsights: {
    strongConnections: string[];
    weakConnections: string[];
    networkingOpportunities: string[];
  };
}

interface TravelPlan {
  flightOptions: {
    option: string;
    price: number;
    duration: string;
    stops: number;
    recommendation: string;
  }[];
  hotelRecommendations: {
    name: string;
    price: number;
    rating: number;
    distance: string;
    businessFriendly: boolean;
  }[];
  itinerarySuggestions: {
    day: string;
    activities: string[];
    meetings: string[];
    optimizations: string[];
  }[];
  budgetAnalysis: {
    estimated: number;
    breakdown: { [category: string]: number };
    compared: string;
  };
}

interface UrgentItem {
  type: 'URGENT_EMAILS' | 'EXPENSIVE_TRAVEL';
  count?: number;
  amount?: number;
  description: string;
}

// Core AI Analysis Functions
async function analyzeEmailImportance(
  email: any,
  userProfile: any
): Promise<EmailAnalysis> {
  // Simulate advanced email analysis
  const isFromBoss = email.sender.includes(userProfile.bossEmail);
  const hasUrgentKeywords = ['urgent', 'asap', 'deadline', 'critical'].some(
    word => email.subject.toLowerCase().includes(word)
  );
  const isFromClient = userProfile.clients.includes(email.sender);

  let priority: 'URGENT' | 'HIGH' | 'MEDIUM' | 'LOW';
  if (isFromBoss && hasUrgentKeywords) priority = 'URGENT';
  else if (isFromClient || hasUrgentKeywords) priority = 'HIGH';
  else if (isFromBoss) priority = 'MEDIUM';
  else priority = 'LOW';

  return {
    priority,
    category: isFromClient
      ? 'Client Communication'
      : isFromBoss
        ? 'Management'
        : 'General',
    actionRequired: priority === 'URGENT' || priority === 'HIGH',
    suggestedResponse:
      priority === 'HIGH'
        ? "Thank you for your email. I'll review this and get back to you by [TIME]."
        : null,
    reasoning: `${isFromBoss ? 'From boss, ' : ''}${hasUrgentKeywords ? 'contains urgent keywords, ' : ''}${isFromClient ? 'from important client' : ''}`,
    confidence: 0.85,
  };
}

async function optimizeCalendar(
  events: any[],
  userPreferences: any
): Promise<CalendarOptimization> {
  // Simulate intelligent calendar optimization
  const suggestions = [
    {
      type: 'BATCH' as const,
      description: 'Batch similar meetings together',
      originalTime: '10:00 AM, 2:00 PM, 4:00 PM',
      suggestedTime: '10:00 AM, 10:30 AM, 11:00 AM',
      reason: 'Reduce context switching, create longer focus blocks',
      energyImpact: 0.3,
    },
    {
      type: 'BREAK' as const,
      description: 'Add recovery time after difficult meetings',
      originalTime: 'Back-to-back board meetings',
      suggestedTime: 'Add 15-min buffer between meetings',
      reason: 'High-stress meetings require mental recovery',
      energyImpact: 0.4,
    },
  ];

  return {
    suggestions,
    productivityScore: 78,
    recommendedFocus: [
      'Deep work block 9-11 AM',
      'Creative tasks after lunch',
      'Admin tasks end of day',
    ],
  };
}

async function analyzeRelationships(
  contacts: any[],
  interactions: any[]
): Promise<RelationshipAnalysis> {
  // Simulate relationship analysis
  return {
    followUpNeeded: [
      {
        contact: 'John Smith (Former Colleague)',
        lastInteraction: '2024-06-15',
        daysSinceContact: 42,
        relationship: 'Professional Network',
        suggestedAction: 'Send catch-up message, mention your recent promotion',
        priority: 7,
      },
      {
        contact: 'Sarah Johnson (Client)',
        lastInteraction: '2024-07-10',
        daysSinceContact: 16,
        relationship: 'Key Client',
        suggestedAction:
          'Check in on project progress, offer additional support',
        priority: 9,
      },
    ],
    relationshipInsights: {
      strongConnections: [
        'Direct team members',
        'Key clients',
        'Industry mentors',
      ],
      weakConnections: [
        'Former colleagues',
        'Conference contacts',
        'LinkedIn connections',
      ],
      networkingOpportunities: [
        'Industry conference next month',
        'Alumni meetup',
        'Client introductions',
      ],
    },
  };
}

async function planTravel(
  destination: string,
  dates: any,
  preferences: any
): Promise<TravelPlan> {
  // Simulate intelligent travel planning
  return {
    flightOptions: [
      {
        option: 'Direct flight 8:00 AM',
        price: 450,
        duration: '3h 15m',
        stops: 0,
        recommendation:
          'Best for productivity - arrive fresh for afternoon meetings',
      },
      {
        option: 'Connecting flight 6:00 AM',
        price: 320,
        duration: '5h 30m',
        stops: 1,
        recommendation:
          'Budget option - but early departure may affect performance',
      },
    ],
    hotelRecommendations: [
      {
        name: 'Business Center Hotel',
        price: 180,
        rating: 4.2,
        distance: '0.3 miles from client office',
        businessFriendly: true,
      },
    ],
    itinerarySuggestions: [
      {
        day: 'Day 1',
        activities: ['Arrive 2 PM', 'Hotel check-in', 'Prep for tomorrow'],
        meetings: ['Client dinner 7 PM'],
        optimizations: ['Rest after flight', 'Review client materials'],
      },
    ],
    budgetAnalysis: {
      estimated: 1200,
      breakdown: { flights: 450, hotel: 540, meals: 150, transport: 60 },
      compared: '15% under typical business trip budget',
    },
  };
}

// Utility Functions
async function sendNotification(
  type: string,
  message: string,
  priority: 'HIGH' | 'MEDIUM' | 'LOW',
  data?: any
) {
  console.log(`📱 [${priority}] ${type}: ${message}`);
  if (data) console.log('📊 Details:', JSON.stringify(data, null, 2));
}

async function updateDigitalAssistant(insights: any) {
  console.log('🧠 AI Assistant learning updated with new insights');
}

async function scheduleTask(task: string, when: string, priority: number) {
  console.log(`📅 Scheduled: ${task} for ${when} (Priority: ${priority})`);
}

// Define the AI Personal Chief of Staff
const aiChiefOfStaff = cronflow.define({
  id: 'ai-chief-of-staff',
  name: 'AI Personal Chief of Staff',
  description:
    'Comprehensive digital life management with intelligent automation',
  hooks: {
    onSuccess: ctx => {
      console.log('✅ Digital life management cycle completed');
      console.log('📈 Performance:', {
        emailsProcessed: ctx.last?.emailAnalysis?.length || 0,
        calendarOptimizations: ctx.last?.calendarSuggestions?.length || 0,
        relationshipActions: ctx.last?.followUpActions?.length || 0,
        processingTime:
          Date.now() - (ctx.steps?.[0]?.output?.startTime || Date.now()),
      });
    },
    onFailure: ctx => {
      console.log('❌ AI Chief of Staff encountered an error:', ctx.error);
      sendNotification(
        'System Error',
        'Chief of Staff needs attention',
        'HIGH',
        { error: ctx.error }
      );
    },
  },
});

aiChiefOfStaff
  .onWebhook('/webhooks/manage-digital-life', {
    schema: z.object({
      userId: z.string(),
      trigger: z.enum([
        'MORNING_BRIEF',
        'EMAIL_BATCH',
        'CALENDAR_SYNC',
        'TRAVEL_REQUEST',
        'WEEKLY_REVIEW',
      ]),
      data: z.object({
        // Email data
        newEmails: z
          .array(
            z.object({
              id: z.string(),
              sender: z.string(),
              subject: z.string(),
              body: z.string(),
              timestamp: z.string(),
              attachments: z.array(z.string()).optional(),
            })
          )
          .optional(),

        // Calendar data
        calendarEvents: z
          .array(
            z.object({
              id: z.string(),
              title: z.string(),
              start: z.string(),
              end: z.string(),
              attendees: z.array(z.string()),
              type: z.string(),
              importance: z.number().optional(),
            })
          )
          .optional(),

        // Travel request
        travelRequest: z
          .object({
            destination: z.string(),
            dates: z.object({
              departure: z.string(),
              return: z.string(),
            }),
            purpose: z.string(),
            budget: z.number().optional(),
          })
          .optional(),

        // User preferences and profile
        userProfile: z
          .object({
            workingHours: z.object({
              start: z.string(),
              end: z.string(),
            }),
            priorities: z.array(z.string()),
            communicationStyle: z.enum(['FORMAL', 'CASUAL', 'DIRECT']),
            bossEmail: z.string(),
            clients: z.array(z.string()),
            travelPreferences: z
              .object({
                preferredAirlines: z.array(z.string()),
                seatPreference: z.string(),
                hotelChain: z.string().optional(),
              })
              .optional(),
          })
          .optional(),
      }),
    }),
  })

  // Step 1: Initialize and assess current situation
  .step('assess-digital-landscape', async ctx => {
    console.log('🔍 Assessing current digital landscape...');
    const { trigger, data, userId } = ctx.payload;

    const startTime = Date.now();
    const context = {
      userId,
      trigger,
      timestamp: new Date().toISOString(),
      dataPoints: {
        emailCount: data.newEmails?.length || 0,
        calendarEvents: data.calendarEvents?.length || 0,
        hasTravelRequest: !!data.travelRequest,
        userProfileComplete: !!data.userProfile,
      },
    };

    console.log(
      `📊 Context: ${trigger} triggered with ${context.dataPoints.emailCount} emails, ${context.dataPoints.calendarEvents} calendar events`
    );

    return {
      context,
      startTime,
      assessmentComplete: true,
    };
  })

  // Step 2: Parallel processing of different life areas
  .parallel([
    // Email intelligence and prioritization
    async ctx => {
      if (!ctx.payload.data.newEmails?.length) {
        return { emailAnalysis: null };
      }

      console.log('📧 Analyzing email intelligence...');
      const emailAnalyses = await Promise.all(
        ctx.payload.data.newEmails.map(email =>
          analyzeEmailImportance(email, ctx.payload.data.userProfile)
        )
      );

      const urgentEmails = emailAnalyses.filter(
        analysis => analysis.priority === 'URGENT'
      );
      const actionRequiredEmails = emailAnalyses.filter(
        analysis => analysis.actionRequired
      );

      return {
        emailAnalysis: emailAnalyses,
        urgentCount: urgentEmails.length,
        actionRequiredCount: actionRequiredEmails.length,
        priorityBreakdown: {
          urgent: emailAnalyses.filter(e => e.priority === 'URGENT').length,
          high: emailAnalyses.filter(e => e.priority === 'HIGH').length,
          medium: emailAnalyses.filter(e => e.priority === 'MEDIUM').length,
          low: emailAnalyses.filter(e => e.priority === 'LOW').length,
        },
      };
    },

    // Calendar optimization and meeting intelligence
    async ctx => {
      if (!ctx.payload.data.calendarEvents?.length) {
        return { calendarAnalysis: null };
      }

      console.log('📅 Optimizing calendar and analyzing meetings...');
      const calendarOptimization = await optimizeCalendar(
        ctx.payload.data.calendarEvents,
        ctx.payload.data.userProfile
      );

      return {
        calendarAnalysis: calendarOptimization,
        optimizationCount: calendarOptimization.suggestions.length,
        productivityScore: calendarOptimization.productivityScore,
      };
    },

    // Relationship management and networking
    async ctx => {
      console.log('🤝 Analyzing relationships and networking opportunities...');

      // Simulate getting contacts and interactions from various sources
      const contacts = [
        {
          name: 'John Smith',
          email: 'john@company.com',
          role: 'Former Colleague',
        },
        {
          name: 'Sarah Johnson',
          email: 'sarah@client.com',
          role: 'Key Client',
        },
      ];
      const interactions = [
        { contact: 'john@company.com', date: '2024-06-15', type: 'email' },
        { contact: 'sarah@client.com', date: '2024-07-10', type: 'meeting' },
      ];

      const relationshipAnalysis = await analyzeRelationships(
        contacts,
        interactions
      );

      return {
        relationshipAnalysis,
        followUpCount: relationshipAnalysis.followUpNeeded.length,
        networkingOpportunities:
          relationshipAnalysis.relationshipInsights.networkingOpportunities
            .length,
      };
    },
  ])

  // Step 3: Process travel requests if present
  .if('has-travel-request', ctx => !!ctx.payload.data.travelRequest)

  .step('plan-travel-intelligently', async ctx => {
    console.log('✈️ Planning intelligent travel itinerary...');

    const travelRequest = ctx.payload.data.travelRequest!;
    const userPreferences = ctx.payload.data.userProfile?.travelPreferences;

    const travelPlan = await planTravel(
      travelRequest.destination,
      travelRequest.dates,
      userPreferences
    );

    return {
      travelPlan,
      budgetStatus: travelRequest.budget
        ? travelPlan.budgetAnalysis.estimated <= travelRequest.budget
          ? 'WITHIN_BUDGET'
          : 'OVER_BUDGET'
        : 'NO_BUDGET_SET',
      planGenerated: true,
    };
  })

  .endIf()

  // Step 4: Generate intelligent insights and recommendations
  .step('generate-actionable-insights', async ctx => {
    console.log('🧠 Generating actionable insights and recommendations...');

    const [emailResult, calendarResult, relationshipResult] = ctx.last;
    const travelResult = ctx.steps['plan-travel-intelligently']?.output;

    // Generate comprehensive insights
    const insights = {
      emailInsights: emailResult?.emailAnalysis
        ? {
            summary: `${emailResult.urgentCount} urgent emails need immediate attention`,
            actions: emailResult.emailAnalysis
              .filter(e => e.actionRequired)
              .map(
                e =>
                  `Respond to ${e.category} email: ${e.suggestedResponse || 'Manual review needed'}`
              ),
          }
        : null,

      calendarInsights: calendarResult?.calendarAnalysis
        ? {
            summary: `Calendar productivity score: ${calendarResult.productivityScore}/100`,
            suggestions: calendarResult.calendarAnalysis.suggestions.map(
              s => s.description
            ),
            focusBlocks: calendarResult.calendarAnalysis.recommendedFocus,
          }
        : null,

      relationshipInsights: relationshipResult?.relationshipAnalysis
        ? {
            summary: `${relationshipResult.followUpCount} relationships need attention`,
            actions: relationshipResult.relationshipAnalysis.followUpNeeded
              .sort((a, b) => b.priority - a.priority)
              .slice(0, 3)
              .map(r => r.suggestedAction),
          }
        : null,

      travelInsights: travelResult?.travelPlan
        ? {
            summary: `Travel plan generated - ${travelResult.budgetStatus}`,
            recommendations:
              travelResult.travelPlan.flightOptions[0].recommendation,
            totalBudget: travelResult.travelPlan.budgetAnalysis.estimated,
          }
        : null,
    };

    return {
      insights,
      insightsGenerated: true,
      totalActions:
        (insights.emailInsights?.actions.length || 0) +
        (insights.relationshipInsights?.actions.length || 0) +
        (insights.calendarInsights?.suggestions.length || 0),
    };
  })

  // Step 5: Determine if high-priority actions need user approval
  .if('needs-user-approval', ctx => {
    const emailResult = ctx.steps['assess-digital-landscape']?.output;
    const urgentEmails = emailResult?.urgentCount || 0;
    const travelBudget =
      ctx.steps['plan-travel-intelligently']?.output?.travelPlan?.budgetAnalysis
        .estimated || 0;

    // Require approval for urgent emails or expensive travel
    return urgentEmails > 0 || travelBudget > 2000;
  })

  .step('prepare-approval-request', async ctx => {
    console.log('👤 Preparing high-priority decisions for approval...');

    const urgentItems: UrgentItem[] = [];

    // Collect urgent emails
    const emailResult = ctx.steps['assess-digital-landscape']?.output;
    if (emailResult?.urgentCount > 0) {
      urgentItems.push({
        type: 'URGENT_EMAILS',
        count: emailResult.urgentCount,
        description: 'Urgent emails requiring immediate attention',
      });
    }

    // Collect expensive travel
    const travelResult = ctx.steps['plan-travel-intelligently']?.output;
    if (travelResult?.travelPlan?.budgetAnalysis.estimated > 2000) {
      urgentItems.push({
        type: 'EXPENSIVE_TRAVEL',
        amount: travelResult.travelPlan.budgetAnalysis.estimated,
        description: 'High-cost travel requires approval',
      });
    }

    return {
      approvalData: {
        urgentItems,
        insights: ctx.last.insights,
        recommendations: urgentItems.map(item =>
          item.type === 'URGENT_EMAILS'
            ? 'Review and respond to urgent emails'
            : 'Approve travel budget and proceed with booking'
        ),
      },
      preparedAt: Date.now(),
    };
  })

  .humanInTheLoop({
    timeout: '2h',
    description: 'High-priority decisions require your attention',
    onPause: async (ctx, token) => {
      console.log('🛑 Your attention needed for high-priority decisions');

      await sendNotification(
        'Chief of Staff Alert',
        `${ctx.last.approvalData.urgentItems.length} high-priority items need your decision`,
        'HIGH',
        {
          token,
          items: ctx.last.approvalData.urgentItems,
          approvalUrl: `https://assistant.yoursite.com/approve/${token}`,
        }
      );
    },
  })

  .step('process-user-decisions', async ctx => {
    if (ctx.last.timedOut) {
      return {
        approved: false,
        reason: 'Approval timeout - proceeding with safe defaults',
        actions: [
          'Flagged urgent items for later review',
          'Postponed high-cost decisions',
        ],
      };
    }

    return {
      approved: ctx.last.approved,
      reason: ctx.last.reason,
      actions: ctx.last.approvedActions || [],
      userFeedback: ctx.last.feedback,
    };
  })

  .else()

  .step('auto-execute-routine-actions', async ctx => {
    console.log('⚡ Auto-executing routine actions...');

    const actions: string[] = [];

    // Auto-schedule follow-ups for medium-priority relationships
    const relationshipResult = ctx.steps['assess-digital-landscape']?.output;
    if (relationshipResult) {
      const mediumPriorityFollowUps =
        relationshipResult.relationshipAnalysis.followUpNeeded.filter(
          r => r.priority >= 5 && r.priority < 8
        );

      for (const followUp of mediumPriorityFollowUps) {
        actions.push(`Scheduled follow-up with ${followUp.contact}`);
      }
    }

    // Auto-implement low-impact calendar optimizations
    const calendarResult = ctx.steps['assess-digital-landscape']?.output;
    if (calendarResult) {
      const lowImpactSuggestions =
        calendarResult.calendarAnalysis.suggestions.filter(
          s => s.energyImpact < 0.3
        );

      for (const suggestion of lowImpactSuggestions) {
        actions.push(`Calendar optimization: ${suggestion.description}`);
      }
    }

    return {
      approved: true,
      reason: 'Routine actions auto-executed',
      actions,
    };
  })

  .endIf()

  // Step 6: Execute approved actions and send summary
  .step('execute-and-summarize', async ctx => {
    console.log('📋 Executing actions and preparing summary...');

    const processingTime =
      Date.now() - ctx.steps['assess-digital-landscape'].output.startTime;
    const executedActions = ctx.last.actions || [];

    // Generate daily brief
    const brief = {
      timestamp: new Date().toISOString(),
      processingTime,
      trigger: ctx.payload.trigger,
      summary: {
        emailsProcessed:
          ctx.steps['assess-digital-landscape']?.output?.emailAnalysis
            ?.length || 0,
        calendarOptimizations:
          ctx.steps['assess-digital-landscape']?.output?.optimizationCount || 0,
        relationshipActions:
          ctx.steps['assess-digital-landscape']?.output?.followUpCount || 0,
        travelPlanned: !!ctx.steps['plan-travel-intelligently']?.output,
      },
      insights: ctx.steps['generate-actionable-insights']?.output?.insights,
      actionsExecuted: executedActions,
      nextSteps: [
        'Monitor email responses',
        'Track calendar optimization effectiveness',
        'Follow up on relationship building',
      ],
    };

    return {
      brief,
      executed: true,
      performance: {
        efficiency:
          processingTime < 5000
            ? 'EXCELLENT'
            : processingTime < 10000
              ? 'GOOD'
              : 'NEEDS_IMPROVEMENT',
        actionCount: executedActions.length,
      },
    };
  })

  // Background actions that don't block the main workflow
  .action('update-ai-learning', async ctx => {
    console.log('🧠 Updating AI learning models...');

    // This would update the AI models based on user interactions and outcomes
    const learningData = {
      emailPriorityAccuracy:
        'Track how often user agrees with email prioritization',
      calendarOptimizationEffectiveness: 'Measure productivity improvements',
      relationshipActionSuccess: 'Track follow-up response rates',
      userPreferenceLearning: 'Adapt to user behavior patterns',
    };

    await updateDigitalAssistant(learningData);
  })

  .action('schedule-proactive-tasks', async ctx => {
    console.log('📅 Scheduling proactive tasks...');

    // Schedule follow-up tasks based on the analysis
    const brief = ctx.last.brief;

    if (brief.summary.emailsProcessed > 10) {
      await scheduleTask(
        'Email batch processing optimization review',
        'tomorrow 9 AM',
        6
      );
    }

    if (brief.summary.relationshipActions > 5) {
      await scheduleTask(
        'Relationship management effectiveness review',
        'end of week',
        4
      );
    }

    // Always schedule next check-in
    await scheduleTask('Daily digital life assessment', 'tomorrow morning', 8);
  });

// Start the AI Chief of Staff
console.log('🚀 Starting AI Personal Chief of Staff...');
cronflow.start();

console.log('📋 Available endpoints:');
console.log(
  '  POST /webhooks/manage-digital-life - Comprehensive digital life management'
);
console.log('');
console.log('📖 Example usage - Morning Brief:');
console.log(`curl -X POST http://localhost:3000/webhooks/manage-digital-life \\
  -H "Content-Type: application/json" \\
  -d '{
    "userId": "user_123",
    "trigger": "MORNING_BRIEF",
    "data": {
      "newEmails": [
        {
          "id": "email_1",
          "sender": "boss@company.com",
          "subject": "Urgent: Q3 Review Meeting",
          "body": "Need to discuss Q3 numbers ASAP",
          "timestamp": "2024-07-26T08:00:00Z"
        }
      ],
      "calendarEvents": [
        {
          "id": "meeting_1",
          "title": "Team Standup",
          "start": "2024-07-26T09:00:00Z",
          "end": "2024-07-26T09:30:00Z",
          "attendees": ["team@company.com"],
          "type": "recurring"
        }
      ],
      "userProfile": {
        "workingHours": { "start": "09:00", "end": "17:00" },
        "priorities": ["Client work", "Team development", "Strategic planning"],
        "communicationStyle": "DIRECT",
        "bossEmail": "boss@company.com",
        "clients": ["client1@company.com", "client2@company.com"]
      }
    }
  }'`);

console.log('');
console.log('🔧 Advanced capabilities:');
console.log('  - Intelligent email prioritization and response suggestions');
console.log('  - Calendar optimization with productivity scoring');
console.log('  - Relationship management and networking insights');
console.log('  - Travel planning with budget optimization');
console.log('  - Human-in-the-loop for high-impact decisions');
console.log('  - Continuous learning from user interactions');
console.log('  - Proactive task scheduling and life optimization');

// Export for external use
export { cronflow, aiChiefOfStaff };