fraim-framework 2.0.27 → 2.0.30

package/dist/registry/scripts/generate-engagement-emails.js

@@ -0,0 +1,630 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Engagement Email Functions for AI Agents
+ *
+ * Helper functions for AI agents to use in customer engagement workflows.
+ * Provides deterministic functions for issue retrieval, database lookup, and email sending.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLatestThankYouDate = getLatestThankYouDate;
+exports.getResolvedIssues = getResolvedIssues;
+exports.findExecutiveByEmail = findExecutiveByEmail;
+exports.getPersonaEmailForExecutive = getPersonaEmailForExecutive;
+exports.sendCustomerMail = sendCustomerMail;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const mongodb_1 = require("mongodb");
+const path_1 = require("path");
+const git_utils_js_1 = require("../../src/utils/git-utils.js");
+const fraim_config_1 = require("./fraim-config");
+// Get template path (relative to script location)
+function getTemplatePath() {
+    // Script is at <this-path>
+    // Template is at templates/customer-development/thank-you-email-template.html (Retrieve via get_fraim_file)
+    // Or generic path? Let's keep existing path logic but relative to process.cwd() as before
+    return (0, path_1.join)(process.cwd(), 'registry', 'templates', 'customer-development', 'thank-you-email-template.html');
+}
+/**
+ * Get the latest date from existing thank-you candidates files
+ * Returns the most recent date when thank-you emails were sent, or null if no files exist
+ */
+function getLatestThankYouDate() {
+    const notesDir = 'docs/customer-development/thank-you-notes';
+    if (!(0, fs_1.existsSync)(notesDir)) {
+        return null;
+    }
+    const files = (0, fs_1.readdirSync)(notesDir).filter(f => f.startsWith('thank-you-candidates-') && f.endsWith('.json'));
+    if (files.length === 0) {
+        return null;
+    }
+    // Extract dates from filenames (e.g., thank-you-candidates-2025-10-29.json)
+    const dates = [];
+    for (const file of files) {
+        const dateMatch = file.match(/thank-you-candidates-(\d{4}-\d{2}-\d{2})\.json/);
+        if (dateMatch) {
+            const filePath = (0, path_1.join)(notesDir, file);
+            try {
+                const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+                const json = JSON.parse(content);
+                // Check if any candidates have status "sent"
+                const hasSentEmails = json.candidates?.some((c) => c.status === 'sent');
+                if (hasSentEmails) {
+                    dates.push(dateMatch[1]);
+                }
+            }
+            catch (error) {
+                // Skip invalid JSON files
+                console.warn(`⚠️  Could not parse ${file}:`, error);
+            }
+        }
+    }
+    if (dates.length === 0) {
+        return null;
+    }
+    // Return the most recent date
+    dates.sort();
+    const latestDate = dates[dates.length - 1];
+    console.log(`📅 Latest thank-you date found: ${latestDate}`);
+    return latestDate;
+}
+/**
+ * Get resolved issues since a specified date (or latest thank-you date if not provided)
+ * AI agents call this to retrieve issues that were resolved
+ * @param date Optional date string (YYYY-MM-DD). If not provided, uses latest thank-you date. If no thank-you files exist, uses last 14 days.
+ */
+async function getResolvedIssues(date) {
+    if (!date) {
+        // Try to get the latest thank-you date
+        const latestThankYouDate = getLatestThankYouDate();
+        if (latestThankYouDate) {
+            date = latestThankYouDate;
+            console.log(`📋 Using latest thank-you date as starting point: ${date}`);
+        }
+        else {
+            // Fallback to last 14 days if no thank-you files exist
+            const fallbackDate = new Date(Date.now() - 14 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+            date = fallbackDate;
+            console.log(`📋 No previous thank-you files found, using last 14 days: ${date}`);
+        }
+    }
+    // Use ">YYYY-MM-DD" format to get issues updated AFTER the date (not on the date)
+    // GitHub CLI requires quotes around the comparison operator
+    const command = `gh search issues --repo=${fraim_config_1.fraimConfig.repoOwner}/${fraim_config_1.fraimConfig.repoName} --state=closed --updated=">${date}" --label=user-reported --json number,title,body,labels,closedAt,author`;
+    const output = (0, child_process_1.execSync)(command, { encoding: 'utf-8' });
+    return JSON.parse(output);
+}
+function getProductionDatabase() {
+    const mongoUrl = process.env.PROD_MONGO_DATABASE_URL || process.env.MONGO_DATABASE_URL;
+    if (!mongoUrl) {
+        throw new Error('PROD_MONGO_DATABASE_URL or MONGO_DATABASE_URL environment variable is required');
+    }
+    return new mongodb_1.MongoClient(mongoUrl);
+}
+/**
+ * Get database name, defaulting to production
+ */
+function getDatabaseName() {
+    const env = process.env.NODE_ENV || process.env.ENVIRONMENT;
+    // If explicitly set to ppe/staging, use that; otherwise default to prod
+    if (env === 'ppe' || env === 'staging') {
+        return (0, git_utils_js_1.determineDatabaseName)();
+    }
+    // Default to production
+    return process.env.MONGO_DB_NAME || 'fraim_prod';
+}
+/**
+ * Get collection name with schema prefix (defaults to prod schema)
+ */
+function getCollectionName(baseName) {
+    const env = process.env.NODE_ENV || process.env.ENVIRONMENT;
+    // If explicitly set to ppe/staging, use that schema; otherwise default to prod
+    if (env === 'ppe' || env === 'staging') {
+        const schema = (0, git_utils_js_1.determineSchema)((0, git_utils_js_1.getCurrentGitBranch)());
+        return `${schema}_${baseName}`;
+    }
+    // Default to prod schema
+    return `prod_${baseName}`;
+}
+/**
+ * Find executive by email in database (defaults to production)
+ * AI agents call this to get executive info for database lookups
+ */
+async function findExecutiveByEmail(email) {
+    const client = getProductionDatabase();
+    try {
+        await client.connect();
+        const dbName = getDatabaseName();
+        const db = client.db(dbName);
+        const executive = await db.collection(getCollectionName('Executive')).findOne({ email: email.toLowerCase() });
+        return executive;
+    }
+    finally {
+        await client.close();
+    }
+}
+/**
+ * Get the persona email for an executive from the identity collection
+ * AI agents call this to get tokens or contact info for the executive's assistant
+ */
+async function getPersonaEmailForExecutive(executiveId) {
+    const { MongoClient } = await Promise.resolve().then(() => __importStar(require('mongodb')));
+    const mongoUrl = process.env.PROD_MONGO_DATABASE_URL || process.env.MONGO_DATABASE_URL;
+    if (!mongoUrl) {
+        console.warn(`⚠️  PROD_MONGO_DATABASE_URL not set, using default ${fraim_config_1.fraimConfig.personaName} email`);
+        return fraim_config_1.fraimConfig.defaultEmail;
+    }
+    const client = new MongoClient(mongoUrl);
+    try {
+        await client.connect();
+        const dbName = getDatabaseName();
+        const db = client.db(dbName);
+        const collectionName = getCollectionName(fraim_config_1.fraimConfig.identityCollection);
+        // Query the identity collection (defaults to prod)
+        let identity = await db.collection(collectionName).findOne({
+            executive_id: executiveId,
+            status: 'active'
+        });
+        if (!identity) {
+            identity = await db.collection(collectionName).findOne({
+                executive_id: executiveId
+            });
+        }
+        if (identity && identity.email) {
+            return identity.email;
+        }
+        return fraim_config_1.fraimConfig.defaultEmail;
+    }
+    catch (error) {
+        console.warn(`⚠️  Could not get ${fraim_config_1.fraimConfig.personaName} email for executive ${executiveId}:`, error);
+        return fraim_config_1.fraimConfig.defaultEmail;
+    }
+    finally {
+        await client.close();
+    }
+}
+/**
+ * Send emails from candidates file (JSON format)
+ * AI agents call this after user review to send all emails
+ * @param candidatesFilePath Path to the JSON candidates file
+ * @param executiveId Optional executive ID to filter emails to specific executive only
+ */
+async function sendCustomerMail(candidatesFilePath, executiveId) {
+    if (!(0, fs_1.existsSync)(candidatesFilePath)) {
+        throw new Error(`Candidates file not found: ${candidatesFilePath}`);
+    }
+    console.log(`📧 Sending emails from candidates file: ${candidatesFilePath}`);
+    if (executiveId) {
+        console.log(`🎯 Filtering to executive ID: ${executiveId}`);
+    }
+    const content = (0, fs_1.readFileSync)(candidatesFilePath, 'utf-8');
+    const candidatesFile = JSON.parse(content);
+    console.log(`📊 Found ${candidatesFile.candidates.length} candidates (${candidatesFile.metadata.totalCustomers} customers)`);
+    // Filter candidates if executiveId is provided
+    let candidatesToSend = candidatesFile.candidates;
+    if (executiveId) {
+        candidatesToSend = candidatesFile.candidates.filter(candidate => candidate.executive.id === executiveId);
+        console.log(`🔍 Filtered to ${candidatesToSend.length} candidate(s) for executive ${executiveId}`);
+        if (candidatesToSend.length === 0) {
+            console.log(`⚠️  No candidates found for executive ID: ${executiveId}`);
+            return;
+        }
+    }
+    // Update file with results as we send
+    const updatedCandidates = [...candidatesFile.candidates];
+    for (let i = 0; i < updatedCandidates.length; i++) {
+        const candidate = updatedCandidates[i];
+        // Skip if filtering by executive ID and this candidate doesn't match
+        if (executiveId && candidate.executive.id !== executiveId) {
+            continue;
+        }
+        if (candidate.status !== 'pending') {
+            console.log(`⏭️  Skipping ${candidate.customer.email} (status: ${candidate.status})`);
+            continue;
+        }
+        try {
+            console.log(`📧 Sending email to ${candidate.customer.email}...`);
+            // Get executive from database if we have their email
+            const executive = await findExecutiveByEmail(candidate.customer.email);
+            // Get persona tokens from identity collection if the executive is known
+            let personaTokens = null;
+            if (candidate.executive.id) {
+                try {
+                    const client = getProductionDatabase();
+                    try {
+                        await client.connect();
+                        const dbName = getDatabaseName();
+                        const db = client.db(dbName);
+                        const collectionName = getCollectionName(fraim_config_1.fraimConfig.identityCollection);
+                        const identity = await db.collection(collectionName).findOne({
+                            executive_id: candidate.executive.id,
+                            status: 'active'
+                        }) || await db.collection(collectionName).findOne({
+                            executive_id: candidate.executive.id
+                        });
+                        if (identity && identity.access_token && identity.refresh_token) {
+                            personaTokens = {
+                                access_token: identity.access_token,
+                                refresh_token: identity.refresh_token
+                            };
+                            console.log(`Found ${fraim_config_1.fraimConfig.personaName} tokens in ${dbName} database for ${candidate.from.email}`);
+                        }
+                        else {
+                            console.warn(`No ${fraim_config_1.fraimConfig.personaName} tokens found in ${dbName} database for executive ${candidate.executive.id}`);
+                        }
+                    }
+                    finally {
+                        await client.close();
+                    }
+                }
+                catch (error) {
+                    console.warn(`Could not get ${fraim_config_1.fraimConfig.personaName} tokens from database for executive ${candidate.executive.id}:`, error);
+                }
+            }
+            // Generate plain text body for fallback (from structured format if available)
+            const plainTextBody = generatePlainTextBody(candidate);
+            await sendSingleEmail({
+                to: candidate.to,
+                subject: candidate.subject,
+                body: plainTextBody,
+                fromEmail: candidate.from.email,
+                fromDisplayName: candidate.from.displayName,
+                candidate // Pass full candidate for HTML generation
+            }, executive, personaTokens);
+            console.log(`✅ Email sent to ${candidate.customer.email}`);
+            updatedCandidates[i].status = 'sent';
+            // Update file after each successful send
+            const updatedFile = {
+                ...candidatesFile,
+                candidates: updatedCandidates
+            };
+            (0, fs_1.writeFileSync)(candidatesFilePath, JSON.stringify(updatedFile, null, 2));
+        }
+        catch (error) {
+            console.error(`❌ Failed to send email to ${candidate.customer.email}:`, error);
+            updatedCandidates[i].status = 'failed';
+            // Update file with failure status
+            const updatedFile = {
+                ...candidatesFile,
+                candidates: updatedCandidates
+            };
+            (0, fs_1.writeFileSync)(candidatesFilePath, JSON.stringify(updatedFile, null, 2));
+        }
+    }
+    console.log(`\n✅ Email sending complete. Status updated in ${candidatesFilePath}`);
+    // Exit cleanly to prevent hanging
+    process.exit(0);
+}
+async function sendSingleEmail(params, executive, personaTokens) {
+    const { to, subject, body, fromEmail, fromDisplayName } = params;
+    // Get Persona's tokens - prioritize identity tokens, then executive tokens, then default
+    let accessToken;
+    let refreshToken;
+    if (personaTokens?.access_token && personaTokens?.refresh_token) {
+        // Use persona identity tokens (preferred - ensures correct From address)
+        console.log(`🔑 Using ${fraim_config_1.fraimConfig.personaName} identity tokens for ${fromEmail}`);
+        accessToken = personaTokens.access_token;
+        refreshToken = personaTokens.refresh_token;
+    }
+    else if (executive?.personaAccessToken && executive?.personaRefreshToken) {
+        // Fallback to executive-specific tokens
+        console.log(`🔑 Using executive persona tokens as fallback`);
+        accessToken = executive.personaAccessToken;
+        refreshToken = executive.personaRefreshToken;
+    }
+    else {
+        // Use default persona tokens as last resort
+        console.log(`🔑 Using default ${fraim_config_1.fraimConfig.personaName} tokens as fallback`);
+        accessToken = fraim_config_1.fraimConfig.defaultAccessToken;
+        refreshToken = fraim_config_1.fraimConfig.defaultRefreshToken;
+        if (!accessToken || !refreshToken) {
+            throw new Error(`${fraim_config_1.fraimConfig.personaName} Gmail tokens not found. Need either identity tokens, executive tokens, or default tokens in environment variables.`);
+        }
+    }
+    // Verify the From email matches the authenticated account (Gmail requirement)
+    // For plus addressing, the base email should match
+    const fromBaseEmail = fromEmail.includes('+')
+        ? fromEmail.split('+')[0] + '@' + fromEmail.split('@')[1]
+        : fromEmail;
+    console.log(`📧 Sending from: "${fromDisplayName}" <${fromEmail}>`);
+    // Generate HTML email from template (use structured format if available)
+    const greeting = params.candidate?.greeting || 'Hi there,';
+    const htmlBody = generateHtmlEmail({
+        displayName: extractFirstName(greeting) || extractFirstName(body) || extractFirstName(fromDisplayName) || 'there',
+        greeting: greeting,
+        opening: params.candidate?.opening
+            ? convertTextToHtml(params.candidate.opening)
+            : convertBodyToHtml(body), // Fallback to legacy body
+        improvements: params.candidate?.improvements || [],
+        closing: params.candidate?.closing || '',
+        executiveName: extractExecutiveName(fromDisplayName),
+        fromEmail
+    });
+    // Create multipart email message (plain text + HTML)
+    const boundary = `boundary_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const emailMessage = [
+        `To: ${to}`,
+        `From: ${fromDisplayName} <${fromEmail}>`,
+        `Subject: ${subject}`,
+        `Content-Type: multipart/alternative; boundary="${boundary}"`,
+        `MIME-Version: 1.0`,
+        ``,
+        `--${boundary}`,
+        `Content-Type: text/plain; charset=utf-8`,
+        `Content-Transfer-Encoding: 7bit`,
+        ``,
+        body,
+        ``,
+        `--${boundary}`,
+        `Content-Type: text/html; charset=utf-8`,
+        `Content-Transfer-Encoding: 7bit`,
+        ``,
+        htmlBody,
+        ``,
+        `--${boundary}--`
+    ].join('\r\n');
+    // Send email using Gmail API
+    const url = 'https://gmail.googleapis.com/gmail/v1/users/me/messages/send';
+    const requestBody = {
+        raw: Buffer.from(emailMessage).toString('base64')
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/, '')
+    };
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            console.log('🔄 Access token expired, refreshing...');
+            // Refresh the access token
+            const clientId = fraim_config_1.fraimConfig.defaultOAuthClientId || process.env.FRAIM_DEFAULT_OAUTH_CLIENT_ID || process.env.PERSONA_DEFAULT_OAUTH_CLIENT_ID;
+            const clientSecret = fraim_config_1.fraimConfig.defaultOAuthClientSecret || process.env.FRAIM_DEFAULT_OAUTH_CLIENT_SECRET || process.env.PERSONA_DEFAULT_OAUTH_CLIENT_SECRET;
+            if (!clientId || !clientSecret) {
+                throw new Error('FRAIM_DEFAULT_OAUTH_CLIENT_ID and FRAIM_DEFAULT_OAUTH_CLIENT_SECRET environment variables are required for token refresh');
+            }
+            console.log('🔄 Refreshing token...');
+            const refreshResponse = await fetch('https://oauth2.googleapis.com/token', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: new URLSearchParams({
+                    client_id: clientId,
+                    client_secret: clientSecret,
+                    refresh_token: refreshToken,
+                    grant_type: 'refresh_token'
+                })
+            });
+            if (!refreshResponse.ok) {
+                const errorText = await refreshResponse.text();
+                console.error('❌ Token refresh failed:', refreshResponse.status, errorText);
+                throw new Error(`Failed to refresh access token: ${refreshResponse.status} - ${errorText}`);
+            }
+            const tokenData = await refreshResponse.json();
+            const newAccessToken = tokenData.access_token;
+            console.log('✅ Token refreshed, retrying email send...');
+            // Retry with new token
+            const retryResponse = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${newAccessToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(requestBody)
+            });
+            if (!retryResponse.ok) {
+                const errorText = await retryResponse.text();
+                throw new Error(`Gmail API error after refresh: ${retryResponse.status} - ${errorText}`);
+            }
+            const result = await retryResponse.json();
+            console.log(`✅ Email sent successfully to ${to}`);
+            console.log(`📧 Email ID: ${result.id}`);
+            return;
+        }
+        const errorText = await response.text();
+        throw new Error(`Gmail API error: ${response.status} - ${errorText}`);
+    }
+    const result = await response.json();
+    console.log(`✅ Email sent successfully to ${to}`);
+    console.log(`📧 Email ID: ${result.id}`);
+}
+/**
+ * Generate HTML email from template
+ */
+function generateHtmlEmail(params) {
+    const templatePath = getTemplatePath();
+    let template = (0, fs_1.readFileSync)(templatePath, 'utf-8');
+    // Replace simple template variables
+    template = template.replace(/\{\{displayName\}\}/g, escapeHtml(params.displayName));
+    template = template.replace(/\{\{executiveName\}\}/g, escapeHtml(params.executiveName));
+    template = template.replace(/\{\{personaName\}\}/g, escapeHtml(fraim_config_1.fraimConfig.personaName));
+    template = template.replace(/\{\{chatUrl\}\}/g, escapeHtml(fraim_config_1.fraimConfig.chatUrl || '#'));
+    template = template.replace(/\{\{webAppUrl\}\}/g, escapeHtml(fraim_config_1.fraimConfig.webAppUrl || '#'));
+    template = template.replace(/\{\{fromEmail\}\}/g, escapeHtml(params.fromEmail));
+    template = template.replace(/\{\{greeting\}\}/g, escapeHtml(params.greeting));
+    template = template.replace(/\{\{opening\}\}/g, params.opening);
+    // Generate improvements list HTML
+    const hasImprovements = params.improvements && params.improvements.length > 0;
+    if (hasImprovements) {
+        const improvementsHtml = params.improvements.map((improvement, index) => {
+            let html = `<div style="margin-bottom: ${index < params.improvements.length - 1 ? '20px' : '0'}; padding-bottom: ${index < params.improvements.length - 1 ? '20px' : '0'}; border-bottom: ${index < params.improvements.length - 1 ? '1px solid #e9ecef' : 'none'};">`;
+            html += `<div style="font-size: 16px; font-weight: 600; color: #333333; margin-bottom: 8px;">${escapeHtml(improvement.title)}</div>`;
+            html += `<div style="font-size: 15px; color: #555555; line-height: 1.7; margin-bottom: ${improvement.verification ? '10px' : '0'};">${convertTextToHtml(improvement.description)}</div>`;
+            if (improvement.verification) {
+                html += `<div style="font-size: 14px; color: #667eea; font-style: italic; padding-top: 8px; border-top: 1px solid #e9ecef; margin-top: 8px;">💡 <strong>How to verify:</strong> ${convertTextToHtml(improvement.verification)}</div>`;
+            }
+            html += `</div>`;
+            return html;
+        }).join('');
+        const improvementsSection = `
+                    <tr>
+                        <td style="padding: 0 30px 20px 30px;">
+                            <div style="background-color: #f8f9fa; border-left: 4px solid #667eea; border-radius: 6px; padding: 20px; margin: 20px 0;">
+                                <div style="font-size: 18px; font-weight: 600; color: #333333; margin-bottom: 16px;">
+                                    ✨ What's Fixed
+                                </div>
+                                ${improvementsHtml}
+                            </div>
+                        </td>
+                    </tr>`;
+        template = template.replace(/\{\{#if hasImprovements\}\}[\s\S]*?\{\{\/if\}\}/, improvementsSection);
+    }
+    else {
+        // Remove conditional block if no improvements
+        template = template.replace(/\{\{#if hasImprovements\}\}[\s\S]*?\{\{\/if\}\}/, '');
+    }
+    // Replace closing paragraph
+    if (params.closing) {
+        template = template.replace(/\{\{#if closing\}\}[\s\S]*?\{\{\/if\}\}/, `
+                    <tr>
+                        <td style="padding: 0 30px 20px 30px;">
+                            <div style="font-size: 16px; color: #555555; line-height: 1.8;">
+                                ${convertTextToHtml(params.closing)}
+                            </div>
+                        </td>
+                    </tr>`);
+    }
+    else {
+        template = template.replace(/\{\{#if closing\}\}[\s\S]*?\{\{\/if\}\}/, '');
+    }
+    return template;
+}
+/**
+ * Generate plain text body from candidate (supports both structured and legacy formats)
+ */
+function generatePlainTextBody(candidate) {
+    // If structured format exists, use it
+    if (candidate.greeting && candidate.opening) {
+        let body = `${candidate.greeting}\n\n${candidate.opening}\n\n`;
+        if (candidate.improvements && candidate.improvements.length > 0) {
+            body += `**What was improved:**\n\n`;
+            candidate.improvements.forEach((improvement, index) => {
+                body += `${index + 1}. ${improvement.title}: ${improvement.description}`;
+                if (improvement.verification) {
+                    body += `\n   **How to verify:** ${improvement.verification}`;
+                }
+                body += `\n\n`;
+            });
+        }
+        if (candidate.closing) {
+            body += `${candidate.closing}\n\n`;
+        }
+        body += (0, fraim_config_1.formatPersonaSignature)();
+        return body;
+    }
+    // Fallback to legacy body format
+    return candidate.body || '';
+}
+/**
+ * Extract first name from text
+ */
+function extractFirstName(text) {
+    // Try to find "Hi [Name]" pattern
+    const hiMatch = text.match(/\b[Hh]i\s+([A-Z][a-z]+)/);
+    if (hiMatch) {
+        return hiMatch[1];
+    }
+    // Try to find comma after greeting
+    const commaMatch = text.match(/^[Hh]i\s+([^,]+),/);
+    if (commaMatch) {
+        return commaMatch[1].trim().split(' ')[0];
+    }
+    return null;
+}
+/**
+ * Extract executive name from display name
+ */
+function extractExecutiveName(displayName) {
+    // "{Persona} - [Name]'s AI Executive Assistant"
+    // We need to match based on the configured pattern
+    const pattern = fraim_config_1.fraimConfig.personaDisplayNamePattern.replace('{executiveName}', '(.+?)');
+    try {
+        // If pattern contains regex characters, they need expanding or escaping?
+        // This is simple pattern matching.
+        // Example: "Persona - {executiveName}'s AI Executive Assistant"
+        // Regex: /Persona - (.+?)'s AI Executive Assistant/
+        // We escape special chars except the group we added
+        const escapedPattern = pattern
+            .replace(/[.*+?^${}()|[\]\\]/g, '\\$&') // Escape regex chars
+            .replace('\\(\\.+\\?\\)', '(.+?)'); // Restore capture group
+        const match = displayName.match(new RegExp(escapedPattern));
+        return match ? match[1] : 'Your';
+    }
+    catch (e) {
+        return 'Your';
+    }
+}
+/**
+ * Convert plain text to HTML (for legacy body format)
+ */
+function convertBodyToHtml(body) {
+    return convertTextToHtml(body);
+}
+/**
+ * Convert text to HTML (preserves markdown-style formatting)
+ */
+function convertTextToHtml(text) {
+    if (!text)
+        return '';
+    let html = text;
+    // Convert markdown-style bold **text** to <strong>text</strong>
+    html = html.replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>');
+    // Convert line breaks to paragraphs
+    html = html.replace(/\n\n+/g, '</p><p style="margin: 12px 0;">');
+    html = html.replace(/\n/g, '<br>');
+    // Wrap in paragraph tags
+    html = `<p style="margin: 0 0 12px 0;">${html}</p>`;
+    // Clean up empty paragraphs
+    html = html.replace(/<p[^>]*><\/p>/g, '');
+    return html;
+}
+/**
+ * Escape HTML special characters
+ */
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+}