fraim-framework 2.0.35 → 2.0.36

package/registry/scripts/prep-issue.sh

@@ -134,7 +134,6 @@ try {
     
     // Support both 'repository' (new) and 'git' (legacy/current) schemas
     let repo = config.repository;
-    let defaultBranch = 'master'; // Default fallback
     
     if (!repo) {
         if (config.git) {
@@ -143,18 +142,13 @@ try {
                 name: config.git.repoName,
                 url: config.git.repoUrl || \`https://github.com/\${config.git.repoOwner}/\${config.git.repoName}.git\`
             };
-            // Extract defaultBranch from git config
-            defaultBranch = config.git.defaultBranch || 'master';
         }
-    } else {
-        // Extract defaultBranch from repository config
-        defaultBranch = repo.defaultBranch || 'master';
     }
 
     if (!repo || !repo.owner || !repo.name || !repo.url) {
         process.exit(1);
     }
-    console.log(\`\${repo.owner}|\${repo.name}|\${repo.url}|\${defaultBranch}\`);
+    console.log(\`\${repo.owner}:\${repo.name}:\${repo.url}\`);
 } catch (e) {
     process.exit(1);
 }
@@ -167,14 +161,13 @@ if [ $? -ne 0 ]; then
     exit 1
 fi
 
-# Split the result into variables using pipe delimiter
-IFS='|' read -r REPO_OWNER REPO_NAME REPO_URL CONFIG_DEFAULT_BRANCH <<< "$REPO_INFO"
+# Split the result into variables
+IFS=':' read -r REPO_OWNER REPO_NAME REPO_URL <<< "$REPO_INFO"
 
 echo "Repository Configuration:"
 echo "  Owner: $REPO_OWNER"
 echo "  Name:  $REPO_NAME"
 echo "  URL:   $REPO_URL"
-echo "  Default Branch: $CONFIG_DEFAULT_BRANCH"
 echo
 
 echo "=== $REPO_NAME - Issue Preparation ==="
@@ -202,69 +195,45 @@ echo "Step 1: Determining base branch from current repository..."
 
 # Determine base branch from the ORIGINAL repository (before cloning)
 if [ "$USE_DEFAULT_BRANCH" = true ]; then
-    # Use the default branch from FRAIM config
-    DEFAULT_BRANCH="$CONFIG_DEFAULT_BRANCH"
-    echo "✓ Using default branch from FRAIM config: $DEFAULT_BRANCH"
+    # Detect the default branch
+    DEFAULT_BRANCH=""
+    for candidate in main master develop; do
+        if git ls-remote --exit-code --heads "$REPO_URL" "$candidate" >/dev/null 2>&1; then
+            DEFAULT_BRANCH="$candidate"
+            echo "✓ Detected default branch: $DEFAULT_BRANCH"
+            break
+        fi
+    done
     
-    # Verify the branch exists on remote
-    if git ls-remote --exit-code --heads "$REPO_URL" "$DEFAULT_BRANCH" >/dev/null 2>&1; then
-        echo "✓ Confirmed branch '$DEFAULT_BRANCH' exists on remote"
-    else
-        echo "⚠️  Warning: Configured default branch '$DEFAULT_BRANCH' not found on remote"
-        echo "   Falling back to branch detection..."
+    # Fallback to master if nothing else worked
+    if [ -z "$DEFAULT_BRANCH" ]; then
+        DEFAULT_BRANCH="master"
+        echo "⚠️  Could not detect default branch, defaulting to: $DEFAULT_BRANCH"
+    fi
+    
+    BASE_BRANCH="$DEFAULT_BRANCH"
+    echo "Using detected default branch as base: $BASE_BRANCH (--use-default flag)"
+else
+    # Get current branch from the original repo
+    ORIGINAL_BRANCH=$(git branch --show-current 2>/dev/null || echo "")
+    
+    if [ -z "$ORIGINAL_BRANCH" ]; then
+        echo "Warning: Detached HEAD detected in original repo, falling back to default branch detection"
         
-        # Fallback to detection if configured branch doesn't exist
+        # Detect the default branch
         DEFAULT_BRANCH=""
         for candidate in main master develop; do
             if git ls-remote --exit-code --heads "$REPO_URL" "$candidate" >/dev/null 2>&1; then
                 DEFAULT_BRANCH="$candidate"
-                echo "✓ Detected fallback branch: $DEFAULT_BRANCH"
+                echo "✓ Detected default branch: $DEFAULT_BRANCH"
                 break
             fi
         done
         
-        # Final fallback to master
+        # Fallback to master if nothing else worked
         if [ -z "$DEFAULT_BRANCH" ]; then
             DEFAULT_BRANCH="master"
-            echo "⚠️  Could not detect any branch, defaulting to: $DEFAULT_BRANCH"
-        fi
-    fi
-    
-    BASE_BRANCH="$DEFAULT_BRANCH"
-    echo "Using default branch as base: $BASE_BRANCH (--use-default flag)"
-else
-    # Get current branch from the original repo
-    ORIGINAL_BRANCH=$(git branch --show-current 2>/dev/null || echo "")
-    
-    if [ -z "$ORIGINAL_BRANCH" ]; then
-        echo "Warning: Detached HEAD detected in original repo, falling back to configured default branch"
-        
-        # Use the default branch from FRAIM config
-        DEFAULT_BRANCH="$CONFIG_DEFAULT_BRANCH"
-        echo "✓ Using default branch from FRAIM config: $DEFAULT_BRANCH"
-        
-        # Verify the branch exists on remote
-        if git ls-remote --exit-code --heads "$REPO_URL" "$DEFAULT_BRANCH" >/dev/null 2>&1; then
-            echo "✓ Confirmed branch '$DEFAULT_BRANCH' exists on remote"
-        else
-            echo "⚠️  Warning: Configured default branch '$DEFAULT_BRANCH' not found on remote"
-            echo "   Falling back to branch detection..."
-            
-            # Fallback to detection if configured branch doesn't exist
-            DEFAULT_BRANCH=""
-            for candidate in main master develop; do
-                if git ls-remote --exit-code --heads "$REPO_URL" "$candidate" >/dev/null 2>&1; then
-                    DEFAULT_BRANCH="$candidate"
-                    echo "✓ Detected fallback branch: $DEFAULT_BRANCH"
-                    break
-                fi
-            done
-            
-            # Final fallback to master
-            if [ -z "$DEFAULT_BRANCH" ]; then
-                DEFAULT_BRANCH="master"
-                echo "⚠️  Could not detect any branch, defaulting to: $DEFAULT_BRANCH"
-            fi
+            echo "⚠️  Could not detect default branch, defaulting to: $DEFAULT_BRANCH"
         fi
         
         BASE_BRANCH="$DEFAULT_BRANCH"

package/registry/scripts/profile-server.ts

@@ -0,0 +1,424 @@
+#!/usr/bin/env npx tsx
+
+import { execSync } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Production Server Profiler
+ * Automates the analysis of Azure App Service performance for coding agents.
+ * 
+ * Usage: npx tsx profile-server.ts [--prod|--preprod|--local] [--logs]
+ * 
+ * Self-contained script - reads configuration from .fraim/config.json
+ * Requires: Azure CLI (az) installed and authenticated
+ */
+
+// Self-contained configuration loading
+interface FraimConfig {
+  persona: { name: string };
+  azure?: {
+    prodAppName?: string;
+    prodResourceGroup?: string;
+    preprodAppName?: string;
+    preprodResourceGroup?: string;
+    localAppName?: string;
+    localResourceGroup?: string;
+  };
+}
+
+function loadClientConfig(): FraimConfig {
+  const configPath = join(process.cwd(), '.fraim', 'config.json');
+  if (!existsSync(configPath)) {
+    throw new Error('.fraim/config.json not found. Run fraim init first.');
+  }
+  return JSON.parse(readFileSync(configPath, 'utf-8'));
+}
+
+function getEnvOr(keys: string[], fallback: string): string {
+  for (const key of keys) {
+    const value = process.env[key];
+    if (value && value.length) return value;
+  }
+  return fallback;
+}
+
+interface ProfilingConfig {
+    env: 'prod' | 'preprod' | 'local';
+    appName: string;
+    resourceGroup: string;
+}
+
+function checkAzureCLI(): boolean {
+  try {
+    execSync('az --version', { stdio: 'pipe' });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+function checkAzureAuth(): boolean {
+  try {
+    execSync('az account show', { stdio: 'pipe' });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+async function getAppServicePlanMetrics(appName: string, resourceGroup: string): Promise<void> {
+  try {
+    console.log('\n--- ☁️ App Service Plan Metrics ---');
+    
+    // Get App Service Plan ID
+    const planIdCmd = `az webapp show --name ${appName} --resource-group ${resourceGroup} --query "appServicePlanId" -o tsv`;
+    const planId = execSync(planIdCmd, { encoding: 'utf8' }).trim();
+    const planName = planId.split('/').pop();
+    console.log(`📋 Plan: ${planName}`);
+
+    // Get CPU and Memory metrics for last 5 minutes
+    console.log('📊 Fetching CPU and Memory metrics (last 5 minutes)...');
+    const metricsCmd = `az monitor metrics list --resource "${planId}" --metrics CpuPercentage MemoryPercentage --interval PT1M --query "value[].{name:name.value, data:timeseries[0].data}" -o json`;
+    
+    const metricsOutput = execSync(metricsCmd, { encoding: 'utf8' });
+    const metrics = JSON.parse(metricsOutput);
+    
+    for (const metric of metrics) {
+      const latestData = metric.data[metric.data.length - 1];
+      const value = latestData?.average || latestData?.total || 'N/A';
+      console.log(`  ${metric.name}: ${typeof value === 'number' ? value.toFixed(2) + '%' : value}`);
+    }
+  } catch (error: any) {
+    console.log(`⚠️  Could not fetch App Service Plan metrics: ${error.message.split('\n')[0]}`);
+  }
+}
+
+async function getAppServiceMetrics(appName: string, resourceGroup: string): Promise<void> {
+  try {
+    console.log('\n--- 🖥️ App Service Metrics ---');
+    
+    // Get subscription ID
+    const subscriptionId = execSync('az account show --query id -o tsv', { encoding: 'utf8' }).trim();
+    
+    // Get app-level metrics using Azure CLI
+    console.log('📊 Fetching App Service metrics (last 5 minutes)...');
+    const appResourceId = `/subscriptions/${subscriptionId}/resourceGroups/${resourceGroup}/providers/Microsoft.Web/sites/${appName}`;
+    
+    const appMetricsCmd = `az monitor metrics list --resource "${appResourceId}" --metrics CpuTime Requests Http2xx Http4xx Http5xx --interval PT1M --query "value[].{name:name.value, data:timeseries[0].data}" -o json`;
+    
+    const appMetricsOutput = execSync(appMetricsCmd, { encoding: 'utf8' });
+    const appMetrics = JSON.parse(appMetricsOutput);
+    
+    for (const metric of appMetrics) {
+      const latestData = metric.data[metric.data.length - 1];
+      const value = latestData?.total || latestData?.average || 'N/A';
+      let displayValue = value;
+      
+      if (typeof value === 'number') {
+        if (metric.name === 'CpuTime') {
+          displayValue = `${value.toFixed(2)}s`;
+        } else {
+          displayValue = value.toString();
+        }
+      }
+      
+      console.log(`  ${metric.name}: ${displayValue}`);
+    }
+  } catch (error: any) {
+    console.log(`⚠️  Could not fetch App Service metrics: ${error.message.split('\n')[0]}`);
+  }
+}
+
+async function getProcessInformation(appName: string): Promise<void> {
+  try {
+    console.log('\n--- ⚙️ Process Information (Kudu API) ---');
+    
+    // Get access token for Kudu API
+    const token = execSync('az account get-access-token --resource https://management.azure.com/ --query accessToken -o tsv', { encoding: 'utf8' }).trim();
+    
+    // Import axios dynamically
+    const axios = (await import('axios')).default;
+    
+    // Get process list from Kudu
+    console.log('📋 Fetching running processes...');
+    const processResponse = await axios.get(`https://${appName}.scm.azurewebsites.net/api/processes`, {
+      headers: { Authorization: `Bearer ${token}` },
+      timeout: 10000
+    });
+    
+    const processes = processResponse.data;
+    
+    // Sort by CPU usage and show top processes
+    const sortedProcesses = processes
+      .filter((p: any) => p.cpu_usage !== undefined)
+      .sort((a: any, b: any) => (b.cpu_usage || 0) - (a.cpu_usage || 0))
+      .slice(0, 10);
+    
+    console.log('\n🔥 Top 10 Processes by CPU Usage:');
+    console.log('PID\tCPU%\tMemory(MB)\tName');
+    console.log('---\t----\t---------\t----');
+    
+    for (const process of sortedProcesses) {
+      const pid = process.id || 'N/A';
+      const cpu = process.cpu_usage ? process.cpu_usage.toFixed(2) : '0.00';
+      const memory = process.working_set ? (process.working_set / 1024 / 1024).toFixed(1) : 'N/A';
+      const name = process.name || 'Unknown';
+      
+      console.log(`${pid}\t${cpu}\t${memory}\t\t${name.substring(0, 30)}`);
+    }
+    
+  } catch (error: any) {
+    console.log(`⚠️  Could not fetch process information: ${error.message.split('\n')[0]}`);
+    console.log('   This might be due to authentication issues or Kudu API being unavailable.');
+  }
+}
+
+async function getSystemInformation(appName: string): Promise<void> {
+  try {
+    console.log('\n--- 🖥️ System Information ---');
+    
+    const token = execSync('az account get-access-token --resource https://management.azure.com/ --query accessToken -o tsv', { encoding: 'utf8' }).trim();
+    const axios = (await import('axios')).default;
+    
+    // Get system info using Kudu command API
+    console.log('📊 Fetching system information...');
+    
+    const commands = [
+      { name: 'Memory Info', cmd: 'cat /proc/meminfo | head -10' },
+      { name: 'CPU Info', cmd: 'cat /proc/cpuinfo | grep "model name" | head -1' },
+      { name: 'Disk Usage', cmd: 'df -h | head -5' },
+      { name: 'Load Average', cmd: 'uptime' }
+    ];
+    
+    for (const command of commands) {
+      try {
+        const response = await axios.post(`https://${appName}.scm.azurewebsites.net/api/command`, {
+          command: command.cmd,
+          dir: '/home'
+        }, {
+          headers: { Authorization: `Bearer ${token}` },
+          timeout: 5000
+        });
+        
+        console.log(`\n${command.name}:`);
+        const output = response.data.Output || response.data.Error || 'No output';
+        console.log(output.split('\n').map((line: string) => `  ${line}`).join('\n'));
+        
+      } catch (cmdError: any) {
+        console.log(`\n${command.name}: Could not retrieve (${cmdError.message.split('\n')[0]})`);
+      }
+    }
+    
+  } catch (error: any) {
+    console.log(`⚠️  Could not fetch system information: ${error.message.split('\n')[0]}`);
+  }
+}
+
+async function getApplicationLogs(appName: string, resourceGroup: string): Promise<void> {
+  try {
+    console.log('\n--- 📋 Recent Application Logs ---');
+    
+    // Get recent logs using Azure CLI
+    console.log('📄 Fetching recent application logs...');
+    const logsCmd = `az webapp log tail --name ${appName} --resource-group ${resourceGroup} --provider application --timeout 5`;
+    
+    try {
+      const logs = execSync(logsCmd, { encoding: 'utf8', timeout: 10000 });
+      console.log('Recent logs:');
+      console.log(logs.split('\n').slice(-20).map(line => `  ${line}`).join('\n'));
+    } catch (logError) {
+      console.log('⚠️  Could not fetch logs - they may not be enabled or available');
+      console.log('   Enable application logging in Azure portal for better diagnostics');
+    }
+    
+  } catch (error: any) {
+    console.log(`⚠️  Could not fetch application logs: ${error.message.split('\n')[0]}`);
+  }
+}
+
+async function profileLocalEnvironment(): Promise<void> {
+  console.log('\n--- 🏠 Local Environment Profiling ---');
+  
+  try {
+    // Basic system information
+    console.log('💻 System Information:');
+    
+    if (process.platform === 'win32') {
+      try {
+        const systemInfo = execSync('systeminfo | findstr /C:"Total Physical Memory" /C:"Available Physical Memory" /C:"Processor"', { encoding: 'utf8' });
+        console.log(systemInfo.split('\n').map(line => `  ${line.trim()}`).filter(line => line).join('\n'));
+      } catch {
+        console.log('  Could not retrieve Windows system info');
+      }
+    } else {
+      try {
+        const memInfo = execSync('free -h', { encoding: 'utf8' });
+        const cpuInfo = execSync('cat /proc/cpuinfo | grep "model name" | head -1', { encoding: 'utf8' });
+        console.log('  Memory:');
+        console.log(memInfo.split('\n').map(line => `    ${line}`).join('\n'));
+        console.log('  CPU:');
+        console.log(`    ${cpuInfo.trim()}`);
+      } catch {
+        console.log('  Could not retrieve Linux system info');
+      }
+    }
+    
+    // Node.js process information
+    console.log('\n🟢 Node.js Process Information:');
+    console.log(`  Node Version: ${process.version}`);
+    console.log(`  Platform: ${process.platform}`);
+    console.log(`  Architecture: ${process.arch}`);
+    console.log(`  Memory Usage:`);
+    const memUsage = process.memoryUsage();
+    console.log(`    RSS: ${(memUsage.rss / 1024 / 1024).toFixed(2)} MB`);
+    console.log(`    Heap Used: ${(memUsage.heapUsed / 1024 / 1024).toFixed(2)} MB`);
+    console.log(`    Heap Total: ${(memUsage.heapTotal / 1024 / 1024).toFixed(2)} MB`);
+    console.log(`    External: ${(memUsage.external / 1024 / 1024).toFixed(2)} MB`);
+    
+  } catch (error: any) {
+    console.log(`⚠️  Error profiling local environment: ${error.message}`);
+  }
+}
+
+async function main() {
+    const config = loadClientConfig();
+    
+    // Azure configuration with environment variable fallbacks
+    const azureConfig = {
+        prodAppName: config.azure?.prodAppName || getEnvOr(['FRAIM_AZURE_PROD_APP_NAME'], 'fraim-app-prod'),
+        prodResourceGroup: config.azure?.prodResourceGroup || getEnvOr(['FRAIM_AZURE_PROD_RESOURCE_GROUP'], 'fraim-prod-rg'),
+        preprodAppName: config.azure?.preprodAppName || getEnvOr(['FRAIM_AZURE_PREPROD_APP_NAME'], 'fraim-app-pre-prod'),
+        preprodResourceGroup: config.azure?.preprodResourceGroup || getEnvOr(['FRAIM_AZURE_PREPROD_RESOURCE_GROUP'], 'fraim-pre-prod-rg'),
+        localAppName: config.azure?.localAppName || getEnvOr(['FRAIM_AZURE_LOCAL_APP_NAME'], 'local'),
+        localResourceGroup: config.azure?.localResourceGroup || getEnvOr(['FRAIM_AZURE_LOCAL_RESOURCE_GROUP'], 'local')
+    };
+
+    const CONFIGS: Record<string, ProfilingConfig> = {
+        prod: {
+            env: 'prod',
+            appName: azureConfig.prodAppName,
+            resourceGroup: azureConfig.prodResourceGroup
+        },
+        preprod: {
+            env: 'preprod',
+            appName: azureConfig.preprodAppName,
+            resourceGroup: azureConfig.preprodResourceGroup
+        },
+        local: {
+            env: 'local',
+            appName: azureConfig.localAppName,
+            resourceGroup: azureConfig.localResourceGroup
+        }
+    };
+
+    const args = process.argv.slice(2);
+    let profileConfig: ProfilingConfig = CONFIGS.local;
+    const includeLogs = args.includes('--logs');
+
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(`
+🔍 Azure App Service Profiler
+
+Usage:
+  npx tsx profile-server.ts [options]
+
+Options:
+  --prod                           Profile production environment
+  --preprod                        Profile pre-production environment  
+  --local                          Profile local environment (default)
+  --logs                           Include application logs in analysis
+  --help, -h                       Show this help message
+
+Examples:
+  # Profile production server
+  npx tsx profile-server.ts --prod
+
+  # Profile with logs
+  npx tsx profile-server.ts --prod --logs
+
+  # Profile local environment
+  npx tsx profile-server.ts --local
+
+Requirements:
+  - Azure CLI (az) installed and authenticated
+  - Proper permissions to access App Service resources
+  - For Kudu API access: Contributor role on the App Service
+
+Configuration:
+  Reads Azure settings from .fraim/config.json or environment variables:
+  - FRAIM_AZURE_PROD_APP_NAME
+  - FRAIM_AZURE_PROD_RESOURCE_GROUP
+  - FRAIM_AZURE_PREPROD_APP_NAME
+  - FRAIM_AZURE_PREPROD_RESOURCE_GROUP
+        `);
+        return;
+    }
+
+    if (args.includes('--prod')) profileConfig = CONFIGS.prod;
+    else if (args.includes('--preprod')) profileConfig = CONFIGS.preprod;
+    else if (args.includes('--local')) profileConfig = CONFIGS.local;
+
+    console.log(`\n🚀 Starting Server Profiling`);
+    console.log(`📊 Environment: ${profileConfig.env.toUpperCase()}`);
+    console.log(`🏷️  App: ${profileConfig.appName}`);
+    console.log(`📁 Resource Group: ${profileConfig.resourceGroup}`);
+
+    if (profileConfig.env === 'local') {
+        await profileLocalEnvironment();
+        console.log('\n✅ Local profiling completed');
+        return;
+    }
+
+    // Check prerequisites for Azure profiling
+    console.log('\n🔍 Checking prerequisites...');
+    
+    if (!checkAzureCLI()) {
+        console.error('❌ Azure CLI not found. Please install Azure CLI first.');
+        console.error('   Download from: https://docs.microsoft.com/en-us/cli/azure/install-azure-cli');
+        process.exit(1);
+    }
+    console.log('✅ Azure CLI found');
+
+    if (!checkAzureAuth()) {
+        console.error('❌ Not authenticated with Azure. Please run: az login');
+        process.exit(1);
+    }
+    console.log('✅ Azure authentication verified');
+
+    try {
+        // Verify app exists
+        console.log(`\n🔍 Verifying App Service: ${profileConfig.appName}`);
+        execSync(`az webapp show --name ${profileConfig.appName} --resource-group ${profileConfig.resourceGroup} --query name -o tsv`, { stdio: 'pipe' });
+        console.log('✅ App Service found');
+
+        // Run profiling analysis
+        await getAppServicePlanMetrics(profileConfig.appName, profileConfig.resourceGroup);
+        await getAppServiceMetrics(profileConfig.appName, profileConfig.resourceGroup);
+        await getProcessInformation(profileConfig.appName);
+        await getSystemInformation(profileConfig.appName);
+        
+        if (includeLogs) {
+            await getApplicationLogs(profileConfig.appName, profileConfig.resourceGroup);
+        }
+
+        console.log('\n✅ Server profiling completed successfully');
+        console.log('\n💡 Tips:');
+        console.log('   - Use --logs flag to include application logs');
+        console.log('   - High CPU usage may indicate performance bottlenecks');
+        console.log('   - High memory usage may indicate memory leaks');
+        console.log('   - Check process list for unexpected or resource-heavy processes');
+
+    } catch (error: any) {
+        console.error(`\n❌ Profiling failed: ${error.message}`);
+        console.error('\nTroubleshooting:');
+        console.error('   - Verify app name and resource group are correct');
+        console.error('   - Ensure you have proper permissions (Contributor role)');
+        console.error('   - Check if the App Service is running');
+        console.error('   - Try: az webapp list --query "[].{name:name, resourceGroup:resourceGroup}"');
+        process.exit(1);
+    }
+}
+
+// Run the main function
+main().catch(console.error);

package/registry/scripts/run-thank-you-workflow.ts

@@ -0,0 +1,122 @@
+#!/usr/bin/env tsx
+
+/**
+ * Runner script for thank-you email workflow
+ * Called by AI agents to generate thank-you emails
+ */
+
+import { getResolvedIssues, findExecutiveByEmail, getPersonaEmailForExecutive } from './generate-engagement-emails';
+import { writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+interface CustomerData {
+  email: string;
+  name: string;
+  issues: Array<{
+    number: number;
+    title: string;
+    body: string;
+  }>;
+  executiveId?: string;
+  executiveName?: string;
+  personaEmail?: string;
+}
+
+async function main() {
+  console.log('🎯 Starting thank-you email generation workflow...\n');
+
+  // Step 1: Get resolved issues
+  console.log('📋 Step 1: Retrieving resolved issues...');
+  const issues = await getResolvedIssues();
+
+  console.log(`\n✅ Found ${issues.length} resolved issues\n`);
+
+  // Step 2: Extract customer information
+  console.log('📧 Step 2: Extracting customer information...\n');
+
+  const customerMap = new Map<string, CustomerData>();
+
+  for (const issue of issues) {
+    // Extract email and name from issue body or title
+    let customerEmail: string | null = null;
+    let customerName: string | null = null;
+
+    // Try to extract from body first
+    const bodyEmailMatch = issue.body?.match(/\*\*Reported by:\*\*\s+(.+?)\s+\((.+?)\)/);
+    if (bodyEmailMatch) {
+      customerName = bodyEmailMatch[1].trim();
+      customerEmail = bodyEmailMatch[2].trim();
+    }
+
+    // Try to extract from title (format: "email: summary")
+    if (!customerEmail) {
+      const titleEmailMatch = issue.title.match(/^([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}):/);
+      if (titleEmailMatch) {
+        customerEmail = titleEmailMatch[1];
+      }
+    }
+
+    if (!customerEmail) {
+      console.log(`⚠️  Issue #${issue.number}: Could not extract customer email, skipping`);
+      continue;
+    }
+
+    // Normalize email to lowercase for consistent matching
+    const normalizedEmail = customerEmail.toLowerCase();
+
+    // Add or update customer data
+    if (!customerMap.has(normalizedEmail)) {
+      customerMap.set(normalizedEmail, {
+        email: normalizedEmail,
+        name: customerName || 'Valued Customer',
+        issues: []
+      });
+    }
+
+    const customerData = customerMap.get(normalizedEmail)!;
+    customerData.issues.push({
+      number: issue.number,
+      title: issue.title,
+      body: issue.body || ''
+    });
+  }
+
+  console.log(`📊 Found ${customerMap.size} unique customers\n`);
+
+  // Step 3: Lookup executive data for each customer
+  console.log('🔍 Step 3: Looking up executive data...\n');
+
+  const entries = Array.from(customerMap.entries());
+  for (const [email, customerData] of entries) {
+    try {
+      const executive = await findExecutiveByEmail(email);
+
+      if (executive) {
+        customerData.executiveId = executive.id;
+        customerData.executiveName = executive.name;
+
+        if (executive.id) {
+          const personaEmail = await getPersonaEmailForExecutive(executive.id);
+          customerData.personaEmail = personaEmail;
+          console.log(`✅ ${email}: Found executive ${executive.name} (${executive.id}), Persona email: ${personaEmail}`);
+        } else {
+          console.log(`⚠️  ${email}: Found executive ${executive.name} but no ID`);
+        }
+      } else {
+        console.log(`⚠️  ${email}: No executive record found in database`);
+      }
+    } catch (error) {
+      console.error(`❌ ${email}: Error looking up executive:`, error);
+    }
+  }
+
+  console.log('\n📝 Customer Data Summary:\n');
+  console.log(JSON.stringify(Array.from(customerMap.values()), null, 2));
+
+  // Save to temp file for AI agent to process
+  const outputPath = join(process.cwd(), 'temp-customer-data.json');
+  writeFileSync(outputPath, JSON.stringify(Array.from(customerMap.values()), null, 2));
+  console.log(`\n💾 Customer data saved to: ${outputPath}`);
+}
+
+main().catch(console.error);