lean-claudient-core 0.1.0

package/src/automation/crmExport.ts

@@ -0,0 +1,407 @@
+/**
+ * CRM Export Integration
+ * Export sales-ready leads to Salesforce/HubSpot via Composio
+ * Queues actions with human approval gates (Phase 7C)
+ * Phase 8C Task 9
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+import { AuditLogger } from '../core/auditLogger.js';
+import { EnrichedLead } from '../intelligence/leadEnrichmentTypes.js';
+import { RevenueProjection } from '../metrics/revenueTypes.js';
+import ComposioClient from './composioClient.js';
+
+/**
+ * CRM opportunity record
+ */
+export interface CRMOpportunity {
+  id: string;
+  name: string;
+  accountName: string;
+  value: number;
+  probability: number;
+  stage: string;
+  closeDate: string;
+  description: string;
+  metadata: {
+    leadScore: number;
+    signalCount: number;
+    threatLevel: string;
+    sources: string[];
+    enrichedAt: string;
+  };
+}
+
+/**
+ * Export history entry
+ */
+export interface ExportHistoryEntry {
+  id: string;
+  leadId: string;
+  crmSystem: 'salesforce' | 'hubspot';
+  recordId?: string;
+  status: 'queued' | 'approved' | 'executed' | 'failed';
+  exportedAt: string;
+  approvedAt?: string;
+  executedAt?: string;
+  error?: string;
+}
+
+/**
+ * CRM Configuration
+ */
+export interface CRMConfig {
+  system: 'salesforce' | 'hubspot';
+  workspaceId: string;
+  accountMapping?: Record<string, string>;
+}
+
+/**
+ * CRM Exporter: Manages lead export to CRM systems
+ */
+export class CRMExporter {
+  private auditLogger: AuditLogger;
+  private composioClient?: ComposioClient;
+  private exportHistory: Map<string, ExportHistoryEntry> = new Map();
+  private crmConfig?: CRMConfig;
+
+  constructor(composioApiKey?: string, crmConfig?: CRMConfig) {
+    this.auditLogger = new AuditLogger();
+    this.crmConfig = crmConfig;
+
+    if (composioApiKey) {
+      this.composioClient = new ComposioClient({
+        apiKey: composioApiKey,
+        baseUrl: 'https://api.composio.dev/api/v1',
+      });
+    }
+  }
+
+  /**
+   * Set CRM configuration
+   */
+  setCRMConfig(config: CRMConfig): void {
+    this.crmConfig = config;
+  }
+
+  /**
+   * Export a single lead to CRM
+   */
+  async exportLead(
+    enrichedLead: EnrichedLead,
+    projection?: RevenueProjection,
+    crmConfig?: CRMConfig
+  ): Promise<ExportHistoryEntry> {
+    const config = crmConfig || this.crmConfig;
+    if (!config) {
+      throw new Error('CRM configuration not set');
+    }
+
+    const exportId = uuidv4();
+
+    // Validate lead is sales-ready (score >= 75 required)
+    if (enrichedLead.score < 75) {
+      this.auditLogger.log({
+        event: 'export:validation_failed',
+        leadId: enrichedLead.id,
+        reason: 'Lead not sales-ready (score < 75)',
+      });
+
+      throw new Error(`Lead ${enrichedLead.id} is not sales-ready`);
+    }
+
+    // Format opportunity based on CRM system
+    let opportunity: any;
+    if (config.system === 'salesforce') {
+      opportunity = this.formatForSalesforce(enrichedLead, projection);
+    } else if (config.system === 'hubspot') {
+      opportunity = this.formatForHubSpot(enrichedLead, projection);
+    } else {
+      throw new Error(`Unsupported CRM system: ${config.system}`);
+    }
+
+    // Redact sensitive data
+    this.redactSensitiveData(opportunity);
+
+    const historyEntry: ExportHistoryEntry = {
+      id: exportId,
+      leadId: enrichedLead.id,
+      crmSystem: config.system,
+      status: 'queued',
+      exportedAt: new Date().toISOString(),
+    };
+
+    this.exportHistory.set(exportId, historyEntry);
+
+    this.auditLogger.log({
+      event: 'export:queued',
+      exportId,
+      leadId: enrichedLead.id,
+      crmSystem: config.system,
+    });
+
+    // Queue action via Composio (no autonomous execution)
+    if (this.composioClient) {
+      try {
+        const actionResult = await this.queueComposioAction(
+          config.system,
+          config.workspaceId,
+          opportunity
+        );
+
+        historyEntry.recordId = actionResult.recordId;
+        historyEntry.status = 'approved';
+        historyEntry.approvedAt = new Date().toISOString();
+
+        this.auditLogger.log({
+          event: 'export:approved',
+          exportId,
+          leadId: enrichedLead.id,
+          recordId: actionResult.recordId,
+        });
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        historyEntry.status = 'failed';
+        historyEntry.error = errorMsg;
+
+        this.auditLogger.log({
+          event: 'export:failed',
+          exportId,
+          leadId: enrichedLead.id,
+          error: errorMsg,
+        });
+
+        throw error;
+      }
+    } else {
+      this.auditLogger.log({
+        event: 'export:no_composio',
+        exportId,
+        leadId: enrichedLead.id,
+        message: 'Composio client not configured - action queued for manual execution',
+      });
+    }
+
+    return historyEntry;
+  }
+
+  /**
+   * Export multiple sales-ready leads
+   */
+  async exportSalesReadyLeads(
+    enrichedLeads: EnrichedLead[],
+    projections?: Map<string, RevenueProjection>,
+    crmConfig?: CRMConfig
+  ): Promise<ExportHistoryEntry[]> {
+    const results: ExportHistoryEntry[] = [];
+
+    for (const lead of enrichedLeads) {
+      try {
+        const projection = projections?.get(lead.id);
+        const entry = await this.exportLead(lead, projection, crmConfig);
+        results.push(entry);
+      } catch (error) {
+        this.auditLogger.log({
+          event: 'export:batch_error',
+          leadId: lead.id,
+          error: String(error),
+        });
+        // Continue with next lead
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Format lead as Salesforce Opportunity
+   */
+  formatForSalesforce(
+    enrichedLead: EnrichedLead,
+    projection?: RevenueProjection
+  ): CRMOpportunity {
+    const opportunity: CRMOpportunity = {
+      id: uuidv4(),
+      name: `${enrichedLead.name} - ${enrichedLead.company || 'Prospect'}`,
+      accountName: enrichedLead.company || enrichedLead.name,
+      value: projection?.projectedRevenue || enrichedLead.score * 500,
+      probability: (enrichedLead.score / 100) * 0.8, // 80% max confidence
+      stage: 'Prospecting',
+      closeDate: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString().split('T')[0],
+      description: `Lead from market intelligence pipeline.\nIndustry: ${enrichedLead.industry || 'Unknown'}\nPain Point: ${enrichedLead.pain_point || 'TBD'}\nQuality Score: ${enrichedLead.score}%`,
+      metadata: {
+        leadScore: enrichedLead.score,
+        signalCount: enrichedLead.signalCount,
+        threatLevel: enrichedLead.threatLevel,
+        sources: enrichedLead.source ? [enrichedLead.source] : [],
+        enrichedAt: enrichedLead.enrichedAt || new Date().toISOString(),
+      },
+    };
+
+    return opportunity;
+  }
+
+  /**
+   * Format lead as HubSpot Deal
+   */
+  formatForHubSpot(
+    enrichedLead: EnrichedLead,
+    projection?: RevenueProjection
+  ): CRMOpportunity {
+    const opportunity: CRMOpportunity = {
+      id: uuidv4(),
+      name: `${enrichedLead.name} - ${enrichedLead.company || 'Prospect'}`,
+      accountName: enrichedLead.company || enrichedLead.name,
+      value: projection?.projectedRevenue || enrichedLead.score * 500,
+      probability: (enrichedLead.score / 100) * 0.75, // 75% max confidence
+      stage: 'Negotiation/Review',
+      closeDate: new Date(Date.now() + 21 * 24 * 60 * 60 * 1000).toISOString().split('T')[0],
+      description: `Lead from market intelligence pipeline.\nIndustry: ${enrichedLead.industry || 'Unknown'}\nPain Point: ${enrichedLead.pain_point || 'TBD'}\nQuality Score: ${enrichedLead.score}%`,
+      metadata: {
+        leadScore: enrichedLead.score,
+        signalCount: enrichedLead.signalCount,
+        threatLevel: enrichedLead.threatLevel,
+        sources: enrichedLead.source ? [enrichedLead.source] : [],
+        enrichedAt: enrichedLead.enrichedAt || new Date().toISOString(),
+      },
+    };
+
+    return opportunity;
+  }
+
+  /**
+   * Redact sensitive data before export
+   */
+  private redactSensitiveData(opportunity: any): void {
+    // Remove internal metadata that shouldn't go to CRM
+    if (opportunity.metadata) {
+      delete opportunity.metadata.internalRiskFlags;
+      delete opportunity.metadata.internalConfidenceDetails;
+    }
+
+    // Ensure PII is minimal
+    if (opportunity.description) {
+      // Remove email patterns
+      opportunity.description = opportunity.description.replace(
+        /[\w\.-]+@[\w\.-]+\.\w+/g,
+        '[EMAIL_REDACTED]'
+      );
+    }
+  }
+
+  /**
+   * Queue a Composio action
+   */
+  private async queueComposioAction(
+    crmSystem: string,
+    workspaceId: string,
+    opportunity: CRMOpportunity
+  ): Promise<{ recordId: string }> {
+    if (!this.composioClient) {
+      throw new Error('Composio client not configured');
+    }
+
+    // Map CRM system to Composio actions
+    const actionMap: Record<string, string> = {
+      salesforce: 'salesforce.create_opportunity',
+      hubspot: 'hubspot.create_deal',
+    };
+
+    const action = actionMap[crmSystem];
+    if (!action) {
+      throw new Error(`No Composio action mapping for ${crmSystem}`);
+    }
+
+    // Queue action via Composio (returns immediately, no execution)
+    const result = await this.composioClient.execute(
+      action,
+      {
+        workspace_id: workspaceId,
+        name: opportunity.name,
+        value: opportunity.value,
+        probability: opportunity.probability,
+        stage: opportunity.stage,
+        close_date: opportunity.closeDate,
+        description: opportunity.description,
+        metadata: JSON.stringify(opportunity.metadata),
+      },
+      { require_approval: true } // Human gate enforced
+    );
+
+    return {
+      recordId: result.id || uuidv4(),
+    };
+  }
+
+  /**
+   * Get export history
+   */
+  getExportHistory(filter?: {
+    leadId?: string;
+    crmSystem?: string;
+    status?: string;
+  }): ExportHistoryEntry[] {
+    let entries = Array.from(this.exportHistory.values());
+
+    if (filter?.leadId) {
+      entries = entries.filter((e) => e.leadId === filter.leadId);
+    }
+    if (filter?.crmSystem) {
+      entries = entries.filter((e) => e.crmSystem === filter.crmSystem);
+    }
+    if (filter?.status) {
+      entries = entries.filter((e) => e.status === filter.status);
+    }
+
+    return entries.sort((a, b) => new Date(b.exportedAt).getTime() - new Date(a.exportedAt).getTime());
+  }
+
+  /**
+   * Get export status by ID
+   */
+  getExportStatus(exportId: string): ExportHistoryEntry | undefined {
+    return this.exportHistory.get(exportId);
+  }
+
+  /**
+   * Mark export as executed
+   */
+  async markExecuted(exportId: string): Promise<void> {
+    const entry = this.exportHistory.get(exportId);
+    if (!entry) {
+      throw new Error(`Export not found: ${exportId}`);
+    }
+
+    entry.status = 'executed';
+    entry.executedAt = new Date().toISOString();
+
+    this.auditLogger.log({
+      event: 'export:executed',
+      exportId,
+      leadId: entry.leadId,
+      recordId: entry.recordId,
+    });
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats(): {
+    total: number;
+    queued: number;
+    approved: number;
+    executed: number;
+    failed: number;
+  } {
+    const entries = Array.from(this.exportHistory.values());
+    return {
+      total: entries.length,
+      queued: entries.filter((e) => e.status === 'queued').length,
+      approved: entries.filter((e) => e.status === 'approved').length,
+      executed: entries.filter((e) => e.status === 'executed').length,
+      failed: entries.filter((e) => e.status === 'failed').length,
+    };
+  }
+}
+
+export default CRMExporter;

package/src/automation/crmIntegration.ts

@@ -0,0 +1,268 @@
+/**
+ * CRM Integration via Composio
+ * Support for Salesforce and HubSpot.
+ * Auto-create and score leads based on market intelligence findings.
+ */
+
+import ComposioClient from './composioClient.js';
+
+export type CRMPlatform = 'salesforce' | 'hubspot';
+
+export interface CRMLead {
+  name: string;
+  email: string;
+  company: string;
+  industry?: string;
+  painPoint: string;
+  source: string; // e.g., "reddit_analysis", "hackernews_scan", "competitor_tracking"
+  signalStrength: number; // 0-100 score
+  customFields?: Record<string, any>;
+}
+
+interface CRMLeadResponse {
+  leadId: string;
+  name: string;
+  company: string;
+  score: number;
+  status: 'created' | 'updated';
+  timestamp: string;
+}
+
+interface LeadScoring {
+  baseScore: number;
+  signals: Record<string, number>;
+  totalScore: number;
+}
+
+/**
+ * CRM integration for automated lead creation and management
+ */
+export class CRMIntegration {
+  private composio: ComposioClient;
+  private platform: CRMPlatform;
+
+  // Signal weights for auto-scoring (0-100)
+  private scoreWeights = {
+    signalStrength: 0.4, // 40% weight on provided signal strength
+    companySize: 0.2, // 20% for company scale
+    industryFit: 0.2, // 20% for industry relevance
+    urgency: 0.2 // 20% for urgency indicators
+  };
+
+  constructor(composio: ComposioClient, platform: CRMPlatform = 'salesforce') {
+    this.composio = composio;
+    this.platform = platform;
+  }
+
+  /**
+   * Create a new lead in CRM
+   * Auto-scores based on signal strength and context
+   */
+  async createLead(lead: CRMLead): Promise<CRMLeadResponse> {
+    const score = this.calculateScore(lead);
+
+    const endpoint = `/integrations/${this.platform}/leads`;
+    const payload = this.formatLeadPayload(lead, score);
+
+    try {
+      const response = await this.composio.request(endpoint, 'POST', payload);
+
+      return {
+        leadId: response.id || response.leadId,
+        name: lead.name,
+        company: lead.company,
+        score: score.totalScore,
+        status: response.isNew ? 'created' : 'updated',
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      throw new Error(`Failed to create lead in ${this.platform}: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Calculate lead score based on signals and context
+   */
+  private calculateScore(lead: CRMLead): LeadScoring {
+    const signals: Record<string, number> = {};
+
+    // Signal strength (0-100)
+    signals.signalStrength = lead.signalStrength;
+
+    // Company size multiplier (rough estimation from company name patterns)
+    signals.companySize = this.estimateCompanySize(lead.company);
+
+    // Industry relevance (if known)
+    signals.industryFit = lead.industry ? 75 : 50;
+
+    // Urgency from pain point keywords
+    signals.urgency = this.extractUrgency(lead.painPoint);
+
+    // Calculate weighted total
+    const baseScore = 50; // Start at 50
+    let totalScore = baseScore;
+
+    for (const [key, weight] of Object.entries(this.scoreWeights)) {
+      const signalKey = key.replace(/([A-Z])/g, '_$1').toLowerCase().substring(1); // camelCase to snake_case
+      if (signalKey in signals) {
+        totalScore += (signals[signalKey] * weight) - 50 * weight;
+      }
+    }
+
+    return {
+      baseScore,
+      signals,
+      totalScore: Math.min(100, Math.max(0, Math.round(totalScore)))
+    };
+  }
+
+  /**
+   * Estimate company size from company name (rough heuristic)
+   */
+  private estimateCompanySize(companyName: string): number {
+    const enterprise = ['Inc', 'Corp', 'Inc.', 'Corp.', 'Ltd'];
+    const startup = ['Startup', 'Labs', 'AI', 'io'];
+
+    const isEnterprise = enterprise.some(e => companyName.includes(e));
+    const isStartup = startup.some(s => companyName.includes(s));
+
+    if (isEnterprise) return 80;
+    if (isStartup) return 60;
+    return 50;
+  }
+
+  /**
+   * Extract urgency score from pain point text
+   */
+  private extractUrgency(painPoint: string): number {
+    const urgentKeywords = [
+      'critical', 'urgent', 'breaking', 'crisis', 'emergency',
+      'costly', 'revenue', 'security', 'compliance', 'legal'
+    ];
+
+    const matchCount = urgentKeywords.filter(kw =>
+      painPoint.toLowerCase().includes(kw)
+    ).length;
+
+    return Math.min(100, 50 + matchCount * 10);
+  }
+
+  /**
+   * Format lead data for specific CRM platform
+   */
+  private formatLeadPayload(lead: CRMLead, score: LeadScoring): any {
+    if (this.platform === 'salesforce') {
+      return {
+        FirstName: lead.name.split(' ')[0],
+        LastName: lead.name.split(' ').slice(1).join(' ') || 'Lead',
+        Email: lead.email,
+        Company: lead.company,
+        Industry: lead.industry || 'Technology',
+        Description: lead.painPoint,
+        LeadSource: lead.source,
+        Rating: this.scoreToRating(score.totalScore),
+        Lean_Claudient_Score__c: score.totalScore,
+        Custom_Fields__c: JSON.stringify(lead.customFields || {}),
+        ...lead.customFields
+      };
+    } else if (this.platform === 'hubspot') {
+      return {
+        properties: [
+          { name: 'firstname', value: lead.name.split(' ')[0] },
+          { name: 'lastname', value: lead.name.split(' ').slice(1).join(' ') || 'Lead' },
+          { name: 'email', value: lead.email },
+          { name: 'company', value: lead.company },
+          { name: 'industry', value: lead.industry || 'Technology' },
+          { name: 'hs_lead_status', value: 'NEW' },
+          { name: 'notes', value: lead.painPoint },
+          { name: 'source', value: lead.source },
+          { name: 'lean_claudient_score', value: score.totalScore.toString() }
+        ]
+      };
+    }
+
+    throw new Error(`Unsupported CRM platform: ${this.platform}`);
+  }
+
+  /**
+   * Convert numeric score to HubSpot/Salesforce rating
+   */
+  private scoreToRating(score: number): string {
+    if (score >= 80) return 'Hot';
+    if (score >= 60) return 'Warm';
+    if (score >= 40) return 'Cold';
+    return 'Unqualified';
+  }
+
+  /**
+   * Batch create multiple leads
+   */
+  async createLeadsBatch(leads: CRMLead[]): Promise<CRMLeadResponse[]> {
+    const results: CRMLeadResponse[] = [];
+
+    for (const lead of leads) {
+      try {
+        const result = await this.createLead(lead);
+        results.push(result);
+      } catch (error) {
+        console.error(`Failed to create lead for ${lead.name}:`, (error as Error).message);
+        results.push({
+          leadId: 'ERROR',
+          name: lead.name,
+          company: lead.company,
+          score: 0,
+          status: 'created',
+          timestamp: new Date().toISOString()
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Get lead details
+   */
+  async getLead(leadId: string): Promise<any> {
+    try {
+      const response = await this.composio.request(
+        `/integrations/${this.platform}/leads/${leadId}`
+      );
+      return response;
+    } catch (error) {
+      throw new Error(`Failed to retrieve lead: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Update lead status
+   */
+  async updateLeadStatus(leadId: string, status: string): Promise<{ success: boolean }> {
+    try {
+      await this.composio.request(
+        `/integrations/${this.platform}/leads/${leadId}`,
+        'PATCH',
+        { status }
+      );
+      return { success: true };
+    } catch (error) {
+      throw new Error(`Failed to update lead: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Switch CRM platform
+   */
+  switchPlatform(platform: CRMPlatform): void {
+    this.platform = platform;
+  }
+
+  /**
+   * Get current platform
+   */
+  getPlatform(): CRMPlatform {
+    return this.platform;
+  }
+}
+
+export default CRMIntegration;