fraim-framework 2.0.27 → 2.0.33

package/dist/registry/scripts/run-thank-you-workflow.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Runner script for thank-you email workflow
+ * Called by AI agents to generate thank-you emails
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const generate_engagement_emails_1 = require("./generate-engagement-emails");
+const fs_1 = require("fs");
+const path_1 = require("path");
+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 (0, generate_engagement_emails_1.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();
+    for (const issue of issues) {
+        // Extract email and name from issue body or title
+        let customerEmail = null;
+        let customerName = 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 (0, generate_engagement_emails_1.findExecutiveByEmail)(email);
+            if (executive) {
+                customerData.executiveId = executive.id;
+                customerData.executiveName = executive.name;
+                if (executive.id) {
+                    const personaEmail = await (0, generate_engagement_emails_1.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 = (0, path_1.join)(process.cwd(), 'temp-customer-data.json');
+    (0, fs_1.writeFileSync)(outputPath, JSON.stringify(Array.from(customerMap.values()), null, 2));
+    console.log(`\n💾 Customer data saved to: ${outputPath}`);
+}
+main().catch(console.error);

package/dist/registry/scripts/send-newsletter-simple.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Send Newsletter - Deterministic Script
+ *
+ * Simple script that users run after approving newsletter JSON.
+ * No decisions, just sends the newsletter.
+ *
+ * Usage:
+ *   npm run send-newsletter                                    # Send to all executives and potential customers
+ *   npm run send-newsletter -- --showonly                      # List recipients without sending
+ *   npm run send-newsletter -- --no-potential-customers        # Send only to active executives
+ *   npm run send-newsletter -- --only-potential-customers      # Send only to potential customers
+ *   npm run send-newsletter -- --email=user@example.com        # Send to specific email
+ *   npm run send-newsletter -- exec-XXX exec-YYY               # Send to specific executive IDs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const newsletter_helpers_1 = require("./newsletter-helpers");
+const fs_1 = require("fs");
+const path_1 = require("path");
+async function main() {
+    console.log('📧 Weekly Newsletter Sender\n');
+    // Parse command line arguments
+    const args = process.argv.slice(2);
+    const showOnly = args.includes('--showonly');
+    const excludePotentialCustomers = args.includes('--no-potential-customers');
+    const onlyPotentialCustomers = args.includes('--only-potential-customers');
+    const filterEmails = [];
+    const filterExecIds = [];
+    // Parse email filters (--email=address)
+    args.forEach(arg => {
+        if (arg.startsWith('--email=')) {
+            filterEmails.push(arg.substring(8));
+        }
+        else if (arg.startsWith('exec-')) {
+            filterExecIds.push(arg);
+        }
+    });
+    // Find the most recent newsletter
+    const newslettersDir = (0, path_1.join)(process.cwd(), 'docs', 'customer-development', 'newsletters');
+    if (!(0, fs_1.existsSync)(newslettersDir)) {
+        console.error('❌ Error: No newsletters directory found');
+        console.error('   Expected: docs/customer-development/newsletters/');
+        console.error('   Generate a newsletter first using the AI agent workflow');
+        process.exit(1);
+    }
+    const files = (0, fs_1.readdirSync)(newslettersDir)
+        .filter(f => f.startsWith('newsletter-') && f.endsWith('.json'))
+        .sort()
+        .reverse(); // Most recent first
+    if (files.length === 0) {
+        console.error('❌ Error: No newsletter files found');
+        console.error('   Generate a newsletter first using the AI agent workflow');
+        process.exit(1);
+    }
+    const latestNewsletter = files[0];
+    const newsletterPath = (0, path_1.join)(newslettersDir, latestNewsletter);
+    console.log(`📄 Found newsletter: ${latestNewsletter}`);
+    if (showOnly) {
+        console.log(`📋 Listing recipients (--showonly mode - no emails will be sent)...\n`);
+    }
+    else if (filterEmails.length > 0 || filterExecIds.length > 0) {
+        console.log(`📧 Sending to filtered recipients...\n`);
+        console.log(`⚠️  This will send real emails. Make sure the newsletter is approved!`);
+    }
+    else {
+        if (onlyPotentialCustomers) {
+            console.log(`📧 Sending to potential customers only...\n`);
+        }
+        else {
+            console.log(`📧 Sending to all active executives${excludePotentialCustomers ? '' : ' and potential customers'}...\n`);
+        }
+        console.log(`⚠️  This will send real emails. Make sure the newsletter is approved!`);
+    }
+    console.log(`   Preview: ${newsletterPath.replace('.json', '.html')}\n`);
+    // Determine what to include based on flags
+    const includePotentialCustomers = onlyPotentialCustomers || !excludePotentialCustomers;
+    const includeExecutives = !onlyPotentialCustomers;
+    // Send newsletter (or show only)
+    await (0, newsletter_helpers_1.sendNewsletterToExecutives)(newsletterPath, filterEmails.length > 0 ? filterEmails : undefined, filterExecIds.length > 0 ? filterExecIds : undefined, includePotentialCustomers, showOnly, includeExecutives);
+}
+main().catch(error => {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+});

package/dist/registry/scripts/send-thank-you-emails.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Send Thank-You Emails from Candidates JSON File
+ *
+ * Usage:
+ *   npm run send-thank-you -- <filename> [exec-id-1] [exec-id-2] ...
+ *
+ * Examples:
+ *   npm run send-thank-you -- docs/customer-development/thank-you-notes/thank-you-candidates-2025-10-29.json
+ *   npm run send-thank-you -- docs/customer-development/thank-you-notes/thank-you-candidates-2025-10-29.json exec-123 exec-456
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const generate_engagement_emails_1 = require("./generate-engagement-emails");
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0) {
+        console.error('❌ Error: Missing required argument: filename');
+        console.error('');
+        console.error('Usage: npm run send-thank-you -- <filename> [exec-id-1] [exec-id-2] ...');
+        console.error('');
+        console.error('Examples:');
+        console.error('  npm run send-thank-you -- docs/customer-development/thank-you-notes/thank-you-candidates-2025-10-29.json');
+        console.error('  npm run send-thank-you -- docs/customer-development/thank-you-notes/thank-you-candidates-2025-10-29.json exec-1760627251980-31qmjy5y4');
+        process.exit(1);
+    }
+    const filename = args[0];
+    const execIds = args.slice(1).filter(arg => arg.startsWith('exec-'));
+    if (execIds.length === 0) {
+        // Send to all pending candidates
+        console.log(`📧 Sending emails from: ${filename}`);
+        console.log(`🎯 Sending to ALL pending candidates`);
+        await (0, generate_engagement_emails_1.sendCustomerMail)(filename);
+    }
+    else if (execIds.length === 1) {
+        // Send to specific executive
+        console.log(`📧 Sending emails from: ${filename}`);
+        console.log(`🎯 Sending to executive: ${execIds[0]}`);
+        await (0, generate_engagement_emails_1.sendCustomerMail)(filename, execIds[0]);
+    }
+    else {
+        // Multiple executives - send to each one
+        console.log(`📧 Sending emails from: ${filename}`);
+        console.log(`🎯 Sending to ${execIds.length} executives: ${execIds.join(', ')}`);
+        for (const execId of execIds) {
+            console.log(`\n📧 Processing executive: ${execId}`);
+            await (0, generate_engagement_emails_1.sendCustomerMail)(filename, execId);
+        }
+    }
+}
+main().catch(error => {
+    console.error('❌ Error:', error);
+    process.exit(1);
+});

package/dist/registry/scripts/validate-openapi-limits.js

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * FRAIM Generic OpenAPI Limits Validator
+ * This script validates OpenAPI file sizes against specified limits.
+ *
+ * Validates ChatGPT limitations for any project:
+ * - instructions.txt: 8,000 character limit
+ * - OpenAPI endpoints: 35 endpoint limit
+ * - OpenAPI descriptions: 300 character limit per operation
+ * - Missing operationIds
+ * - Missing schema definitions
+ * - x-openai-isConsequential on non-GET endpoints
+ *
+ * Usage:
+ *   npx tsx scripts/validate-openapi-limits.ts [instructions-file] [openapi-file]
+ *
+ * Defaults:
+ *   instructions-file: src/openapi/instructions.txt
+ *   openapi-file: src/openapi/openapi.json
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAll = validateAll;
+const fs_1 = require("fs");
+const INSTRUCTIONS_LIMIT = 8000;
+const OPENAPI_ENDPOINT_LIMIT = 35;
+const OPENAPI_DESC_LIMIT = 300;
+/**
+ * Collect all schema references from an object recursively
+ */
+function collectSchemaRefs(obj, refs = new Set()) {
+    if (typeof obj !== 'object' || obj === null) {
+        return refs;
+    }
+    if (Array.isArray(obj)) {
+        obj.forEach(item => collectSchemaRefs(item, refs));
+        return refs;
+    }
+    if (obj.$ref && typeof obj.$ref === 'string') {
+        // Extract schema name from #/components/schemas/SchemaName
+        const match = obj.$ref.match(/#\/components\/schemas\/(.+)$/);
+        if (match) {
+            refs.add(match[1]);
+        }
+    }
+    Object.values(obj).forEach(value => collectSchemaRefs(value, refs));
+    return refs;
+}
+/**
+ * Validate instructions.txt length
+ */
+function validateInstructions(instructionsPath) {
+    const result = {
+        passed: true,
+        errors: [],
+        warnings: []
+    };
+    if (!(0, fs_1.existsSync)(instructionsPath)) {
+        result.warnings.push(`instructions.txt not found at ${instructionsPath}`);
+        return result;
+    }
+    try {
+        const instructionsContent = (0, fs_1.readFileSync)(instructionsPath, 'utf-8');
+        const instructionsLength = instructionsContent.length;
+        console.log(`📄 instructions.txt: ${instructionsLength} characters (limit: ${INSTRUCTIONS_LIMIT})`);
+        if (instructionsLength > INSTRUCTIONS_LIMIT) {
+            result.passed = false;
+            result.errors.push(`instructions.txt exceeds ${INSTRUCTIONS_LIMIT} character limit (${instructionsLength} chars). Move detailed content to KB files.`);
+            console.log(`   ❌ FAILED: Exceeds limit`);
+        }
+        else {
+            console.log(`   ✅ PASSED: Within limit\n`);
+        }
+    }
+    catch (error) {
+        result.passed = false;
+        result.errors.push(`Failed to read instructions.txt: ${error.message}`);
+    }
+    return result;
+}
+/**
+ * Validate OpenAPI specification
+ */
+function validateOpenAPI(openapiPath) {
+    const result = {
+        passed: true,
+        errors: [],
+        warnings: []
+    };
+    if (!(0, fs_1.existsSync)(openapiPath)) {
+        result.warnings.push(`OpenAPI file not found at ${openapiPath}`);
+        return result;
+    }
+    try {
+        const openapiContent = (0, fs_1.readFileSync)(openapiPath, 'utf-8');
+        const openapiSpec = JSON.parse(openapiContent);
+        // Count endpoints (operations) and validate
+        let endpointCount = 0;
+        const endpointList = [];
+        const longDescriptions = [];
+        const missingOperationIds = [];
+        const allSchemaRefs = new Set();
+        const missingConsequential = [];
+        const wrongConsequential = [];
+        if (openapiSpec.paths) {
+            for (const [path, methods] of Object.entries(openapiSpec.paths)) {
+                for (const [method, details] of Object.entries(methods)) {
+                    if (typeof details === 'object' && details !== null) {
+                        // Skip if it's a parameter definition or response definition
+                        if (['parameters', 'responses', 'requestBody'].includes(method)) {
+                            continue;
+                        }
+                        endpointCount++;
+                        endpointList.push(`${method.toUpperCase()} ${path}`);
+                        // Check for operationId
+                        if (!details.operationId) {
+                            missingOperationIds.push({
+                                path,
+                                method: method.toUpperCase()
+                            });
+                        }
+                        // Check description length
+                        if (details.description) {
+                            const descLength = details.description.length;
+                            if (descLength > OPENAPI_DESC_LIMIT) {
+                                longDescriptions.push({
+                                    path,
+                                    method: method.toUpperCase(),
+                                    length: descLength
+                                });
+                            }
+                        }
+                        // Collect all schema references from this operation
+                        collectSchemaRefs(details, allSchemaRefs);
+                        // Check for x-openai-isConsequential on non-GET endpoints
+                        const nonGetMethods = ['post', 'put', 'patch', 'delete'];
+                        if (nonGetMethods.includes(method.toLowerCase())) {
+                            const hasConsequential = details.hasOwnProperty('x-openai-isConsequential');
+                            const consequentialValue = details['x-openai-isConsequential'];
+                            // ALL non-GET endpoints should have x-openai-isConsequential: false
+                            if (!hasConsequential) {
+                                missingConsequential.push({
+                                    path,
+                                    method: method.toUpperCase()
+                                });
+                            }
+                            else if (consequentialValue !== false) {
+                                wrongConsequential.push({
+                                    path,
+                                    method: method.toUpperCase(),
+                                    value: consequentialValue
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Also collect schema refs from components/responses and components/parameters if they exist
+        if (openapiSpec.components) {
+            if (openapiSpec.components.responses) {
+                Object.values(openapiSpec.components.responses).forEach((response) => {
+                    collectSchemaRefs(response, allSchemaRefs);
+                });
+            }
+            if (openapiSpec.components.parameters) {
+                Object.values(openapiSpec.components.parameters).forEach((param) => {
+                    collectSchemaRefs(param, allSchemaRefs);
+                });
+            }
+        }
+        // Check for missing schema definitions
+        const definedSchemas = new Set();
+        if (openapiSpec.components && openapiSpec.components.schemas) {
+            Object.keys(openapiSpec.components.schemas).forEach(schemaName => {
+                definedSchemas.add(schemaName);
+            });
+        }
+        const missingSchemas = [];
+        allSchemaRefs.forEach(refName => {
+            if (!definedSchemas.has(refName)) {
+                missingSchemas.push(refName);
+            }
+        });
+        // Validate endpoint count
+        console.log(`📋 OpenAPI endpoints: ${endpointCount} (limit: ${OPENAPI_ENDPOINT_LIMIT})`);
+        if (endpointCount > OPENAPI_ENDPOINT_LIMIT) {
+            result.passed = false;
+            result.errors.push(`OpenAPI spec exceeds ${OPENAPI_ENDPOINT_LIMIT} endpoint limit (${endpointCount} endpoints). ChatGPT cannot handle more than ${OPENAPI_ENDPOINT_LIMIT} endpoints.`);
+            console.log(`   ❌ FAILED: Too many endpoints`);
+            console.log(`   Endpoints:`);
+            endpointList.slice(0, 10).forEach(ep => console.log(`     - ${ep}`));
+            if (endpointCount > 10) {
+                console.log(`     ... and ${endpointCount - 10} more`);
+            }
+        }
+        else {
+            console.log(`   ✅ PASSED: Within limit`);
+        }
+        // Check description lengths
+        if (longDescriptions.length > 0) {
+            console.log(`\n📝 OpenAPI descriptions: ${longDescriptions.length} exceed ${OPENAPI_DESC_LIMIT} char limit`);
+            longDescriptions.forEach(({ path, method, length }) => {
+                result.passed = false;
+                result.errors.push(`OpenAPI operation ${method} ${path} description exceeds ${OPENAPI_DESC_LIMIT} character limit (${length} chars). Shorten description or move details to KB files.`);
+                console.log(`   ❌ ${method} ${path}: ${length} chars`);
+            });
+        }
+        else {
+            console.log(`\n📝 OpenAPI descriptions: All within ${OPENAPI_DESC_LIMIT} char limit`);
+            console.log(`   ✅ PASSED: All descriptions within limit`);
+        }
+        // Check for missing operationIds
+        if (missingOperationIds.length > 0) {
+            console.log(`\n🔑 OpenAPI operationIds: ${missingOperationIds.length} missing`);
+            missingOperationIds.forEach(({ path, method }) => {
+                result.passed = false;
+                result.errors.push(`OpenAPI operation ${method} ${path} is missing required 'operationId' field. Add a unique operationId (e.g., "getTask", "createTask").`);
+                console.log(`   ❌ ${method} ${path}: Missing operationId`);
+            });
+        }
+        else {
+            console.log(`\n🔑 OpenAPI operationIds: All operations have operationId`);
+            console.log(`   ✅ PASSED: All operations have operationId`);
+        }
+        // Check for missing schema definitions
+        if (missingSchemas.length > 0) {
+            console.log(`\n📚 OpenAPI schemas: ${missingSchemas.length} referenced but not defined`);
+            missingSchemas.forEach(schemaName => {
+                result.passed = false;
+                result.errors.push(`OpenAPI schema '${schemaName}' is referenced but not defined in components.schemas. Add the schema definition to components.schemas.`);
+                console.log(`   ❌ Missing schema: ${schemaName}`);
+            });
+        }
+        else {
+            console.log(`\n📚 OpenAPI schemas: All referenced schemas are defined`);
+            console.log(`   ✅ PASSED: All schema references resolve`);
+        }
+        // Check for missing or incorrect x-openai-isConsequential on non-GET endpoints
+        const allConsequentialIssues = [...missingConsequential, ...wrongConsequential];
+        if (allConsequentialIssues.length > 0) {
+            console.log(`\n🔐 OpenAPI x-openai-isConsequential: ${allConsequentialIssues.length} non-GET endpoint(s) missing or incorrectly set`);
+            missingConsequential.forEach(({ path, method }) => {
+                result.passed = false;
+                result.errors.push(`OpenAPI operation ${method} ${path} is missing required 'x-openai-isConsequential: false' field. Add this field to bypass ChatGPT confirmation prompts.`);
+                console.log(`   ❌ ${method} ${path}: Missing x-openai-isConsequential`);
+            });
+            wrongConsequential.forEach(({ path, method, value }) => {
+                result.passed = false;
+                result.errors.push(`OpenAPI operation ${method} ${path} has x-openai-isConsequential set to ${JSON.stringify(value)} but should be false. Non-GET endpoints should have x-openai-isConsequential: false to bypass ChatGPT confirmation prompts.`);
+                console.log(`   ❌ ${method} ${path}: x-openai-isConsequential is ${JSON.stringify(value)}, should be false`);
+            });
+        }
+        else {
+            console.log(`\n🔐 OpenAPI x-openai-isConsequential: All non-GET endpoints have x-openai-isConsequential: false`);
+            console.log(`   ✅ PASSED: All non-GET endpoints configured to bypass confirmation`);
+        }
+    }
+    catch (error) {
+        result.passed = false;
+        result.errors.push(`Failed to parse OpenAPI JSON: ${error.message}`);
+        console.log(`   ❌ ERROR: ${error.message}`);
+    }
+    return result;
+}
+/**
+ * Main validation function
+ */
+function validateAll(instructionsPath = 'src/openapi/instructions.txt', openapiPath = 'src/openapi/openapi.json') {
+    console.log('🔍 Validating OpenAPI and instructions limits...\n');
+    const instructionsResult = validateInstructions(instructionsPath);
+    const openapiResult = validateOpenAPI(openapiPath);
+    // Combine results
+    const allErrors = [...instructionsResult.errors, ...openapiResult.errors];
+    const allWarnings = [...instructionsResult.warnings, ...openapiResult.warnings];
+    const passed = instructionsResult.passed && openapiResult.passed;
+    // Summary
+    console.log('\n' + '='.repeat(50));
+    console.log('📊 VALIDATION SUMMARY');
+    console.log('='.repeat(50));
+    if (allWarnings.length > 0) {
+        console.log('\n⚠️  WARNINGS:');
+        allWarnings.forEach(w => console.log(`   - ${w}`));
+    }
+    if (allErrors.length > 0) {
+        console.log('\n❌ ERRORS:');
+        allErrors.forEach(e => console.log(`   - ${e}`));
+        console.log('\n💡 Solutions:');
+        console.log('   - Move detailed content from instructions.txt to KB files (KB-*.txt)');
+        console.log('   - Reduce number of OpenAPI endpoints (merge or remove unused endpoints)');
+        console.log('   - Shorten OpenAPI operation descriptions, reference KB files for details');
+        console.log('   - Add missing operationId fields to all operations (e.g., "getTask", "createTask")');
+        console.log('   - Define missing schemas in components.schemas section');
+        console.log('   - Add x-openai-isConsequential: false to all non-GET endpoints (POST, PUT, PATCH, DELETE)');
+        console.log('\n❌ BUILD FAILED: Fix errors above before proceeding\n');
+        return false;
+    }
+    else {
+        console.log('\n✅ ALL CHECKS PASSED');
+        console.log('   Instructions and OpenAPI spec are within ChatGPT limits\n');
+        return true;
+    }
+}
+// Run if executed directly
+// @ts-ignore
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const instructionsPath = process.argv[2] || 'src/openapi/instructions.txt';
+    const openapiPath = process.argv[3] || 'src/openapi/openapi.json';
+    const passed = validateAll(instructionsPath, openapiPath);
+    process.exit(passed ? 0 : 1);
+}