lean-claudient-core 0.1.0

package/src/automation/actionExecutor.ts

@@ -0,0 +1,399 @@
+/**
+ * Action Executor
+ * Orchestrates automated workflows:
+ * Market finding → Jira epic → Email draft → CRM lead → Human approval → Execution
+ */
+
+import GmailIntegration from './gmailIntegration.js';
+import CRMIntegration from './crmIntegration.js';
+import { CRMLead } from './crmIntegration.js';
+import JiraIntegration from './jiraIntegration.js';
+import { AuditLogger } from '../core/auditLogger.js';
+
+export interface MarketFinding {
+  id: string;
+  title: string;
+  description: string;
+  threat_level: 'critical' | 'high' | 'medium' | 'low';
+  findings: string;
+  sources: Array<{ url: string; title: string; type: string }>;
+  competitive_threat?: {
+    company: string;
+    feature: string;
+    impact: string;
+  };
+  market_opportunity?: {
+    pain_point: string;
+    target_segment: string;
+    demand_signal: string;
+  };
+}
+
+export interface AutomatedAction {
+  id: string;
+  type: 'email_draft' | 'crm_lead' | 'jira_epic';
+  finding_id: string;
+  payload: any;
+  status: 'pending_approval' | 'approved' | 'executed' | 'rejected';
+  created_at: string;
+  executed_at?: string;
+  details?: Record<string, any>;
+}
+
+export type ActionType = 'email_draft' | 'crm_lead' | 'jira_epic' | 'full_workflow';
+
+/**
+ * ActionExecutor: Orchestrates automated business workflows
+ */
+export class ActionExecutor {
+  private gmail: GmailIntegration;
+  private crm: CRMIntegration;
+  private jira: JiraIntegration;
+  private auditLogger: AuditLogger;
+  private actions: Map<string, AutomatedAction> = new Map();
+
+  constructor(
+    gmail: GmailIntegration,
+    crm: CRMIntegration,
+    jira: JiraIntegration,
+    auditLogger: AuditLogger
+  ) {
+    this.gmail = gmail;
+    this.crm = crm;
+    this.jira = jira;
+    this.auditLogger = auditLogger;
+  }
+
+  /**
+   * Execute full workflow for a market finding
+   * 1. Create Jira epic for counter-feature
+   * 2. Draft email to sales/product team
+   * 3. Create CRM lead (if opportunity)
+   * Returns array of pending actions awaiting human approval
+   */
+  async executeWorkflow(finding: MarketFinding): Promise<AutomatedAction[]> {
+    const actions: AutomatedAction[] = [];
+
+    try {
+      // Step 1: Create Jira epic for threat response or feature
+      const jiraAction = await this.createJiraEpicAction(finding);
+      if (jiraAction) {
+        actions.push(jiraAction);
+      }
+
+      // Step 2: Draft email to relevant team
+      const emailAction = await this.createEmailDraftAction(finding);
+      if (emailAction) {
+        actions.push(emailAction);
+      }
+
+      // Step 3: Create CRM lead (if market opportunity)
+      if (finding.market_opportunity) {
+        const leadAction = await this.createCRMLeadAction(finding);
+        if (leadAction) {
+          actions.push(leadAction);
+        }
+      }
+
+      // Log workflow initiation
+      this.auditLogger.log({
+        event: 'workflow_initiated',
+        finding_id: finding.id,
+        action_count: actions.length,
+        timestamp: new Date().toISOString()
+      });
+
+      return actions;
+    } catch (error) {
+      this.auditLogger.log({
+        event: 'workflow_error',
+        finding_id: finding.id,
+        error: (error as Error).message,
+        timestamp: new Date().toISOString()
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Create pending Jira epic action
+   */
+  private async createJiraEpicAction(finding: MarketFinding): Promise<AutomatedAction> {
+    const actionId = `jira_${finding.id}`;
+
+    const linkedResources = finding.sources.map(s => ({
+      url: s.url,
+      title: s.title,
+      type: s.type as any
+    }));
+
+    const action: AutomatedAction = {
+      id: actionId,
+      type: 'jira_epic',
+      finding_id: finding.id,
+      payload: {
+        title: finding.title,
+        description: finding.description,
+        threatLevel: finding.threat_level,
+        linkedResources
+      },
+      status: 'pending_approval',
+      created_at: new Date().toISOString(),
+      details: {
+        threat_level: finding.threat_level,
+        source_count: finding.sources.length
+      }
+    };
+
+    this.actions.set(actionId, action);
+    return action;
+  }
+
+  /**
+   * Create pending email draft action
+   */
+  private async createEmailDraftAction(finding: MarketFinding): Promise<AutomatedAction> {
+    const actionId = `email_${finding.id}`;
+
+    let templateName = 'marketIntel';
+    let recipientEmail = process.env.PRODUCT_TEAM_EMAIL || 'product@company.com';
+
+    if (finding.competitive_threat) {
+      templateName = 'featureRequest';
+      recipientEmail = process.env.PRODUCT_TEAM_EMAIL || 'product@company.com';
+    } else if (finding.market_opportunity) {
+      templateName = 'leadNotification';
+      recipientEmail = process.env.SALES_TEAM_EMAIL || 'sales@company.com';
+    }
+
+    const action: AutomatedAction = {
+      id: actionId,
+      type: 'email_draft',
+      finding_id: finding.id,
+      payload: {
+        to: recipientEmail,
+        template: templateName,
+        variables: {
+          companyName: finding.competitive_threat?.company || 'Unknown',
+          contactName: 'Team',
+          contactEmail: recipientEmail,
+          painPoint: finding.market_opportunity?.pain_point || finding.description,
+          strength: finding.threat_level,
+          featureTitle: finding.competitive_threat?.feature || finding.title,
+          demand: finding.market_opportunity?.demand_signal || 'High'
+        }
+      },
+      status: 'pending_approval',
+      created_at: new Date().toISOString()
+    };
+
+    this.actions.set(actionId, action);
+    return action;
+  }
+
+  /**
+   * Create pending CRM lead action
+   */
+  private async createCRMLeadAction(finding: MarketFinding): Promise<AutomatedAction> {
+    const actionId = `crm_${finding.id}`;
+
+    const lead: CRMLead = {
+      name: `Lead from ${finding.title}`,
+      email: process.env.CRM_LEAD_EMAIL || 'unknown@company.com',
+      company: finding.market_opportunity?.target_segment || 'Unknown',
+      industry: 'Technology',
+      painPoint: finding.market_opportunity?.pain_point || finding.description,
+      source: 'market_intelligence',
+      signalStrength: this.mapThreatLevelToScore(finding.threat_level)
+    };
+
+    const action: AutomatedAction = {
+      id: actionId,
+      type: 'crm_lead',
+      finding_id: finding.id,
+      payload: lead,
+      status: 'pending_approval',
+      created_at: new Date().toISOString()
+    };
+
+    this.actions.set(actionId, action);
+    return action;
+  }
+
+  /**
+   * Execute a previously approved action
+   */
+  async executeAction(actionId: string): Promise<AutomatedAction> {
+    const action = this.actions.get(actionId);
+    if (!action) {
+      throw new Error(`Action not found: ${actionId}`);
+    }
+
+    if (action.status !== 'approved') {
+      throw new Error(`Action not approved: ${actionId}`);
+    }
+
+    try {
+      switch (action.type) {
+        case 'email_draft':
+          await this.executeEmailAction(action);
+          break;
+        case 'crm_lead':
+          await this.executeCRMAction(action);
+          break;
+        case 'jira_epic':
+          await this.executeJiraAction(action);
+          break;
+      }
+
+      action.status = 'executed';
+      action.executed_at = new Date().toISOString();
+
+      this.auditLogger.log({
+        event: 'action_executed',
+        action_id: actionId,
+        action_type: action.type,
+        timestamp: new Date().toISOString()
+      });
+
+      return action;
+    } catch (error) {
+      this.auditLogger.log({
+        event: 'action_execution_failed',
+        action_id: actionId,
+        error: (error as Error).message,
+        timestamp: new Date().toISOString()
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Execute email draft action
+   */
+  private async executeEmailAction(action: AutomatedAction): Promise<void> {
+    const { to, template, variables } = action.payload;
+    const draftResponse = await this.gmail.draftFromTemplate(template, to, variables);
+    action.details = { draftId: draftResponse.draftId };
+  }
+
+  /**
+   * Execute CRM lead action
+   */
+  private async executeCRMAction(action: AutomatedAction): Promise<void> {
+    const lead = action.payload as CRMLead;
+    const leadResponse = await this.crm.createLead(lead);
+    action.details = { leadId: leadResponse.leadId, score: leadResponse.score };
+  }
+
+  /**
+   * Execute Jira epic action
+   */
+  private async executeJiraAction(action: AutomatedAction): Promise<void> {
+    const { title, description, threatLevel, linkedResources } = action.payload;
+    const epicResponse = await this.jira.createThreatResponseEpic(
+      title,
+      description,
+      threatLevel,
+      linkedResources
+    );
+    action.details = { epicId: epicResponse.key, url: epicResponse.url };
+  }
+
+  /**
+   * Approve an action
+   */
+  approveAction(actionId: string): void {
+    const action = this.actions.get(actionId);
+    if (!action) {
+      throw new Error(`Action not found: ${actionId}`);
+    }
+
+    action.status = 'approved';
+
+    this.auditLogger.log({
+      event: 'action_approved',
+      action_id: actionId,
+      action_type: action.type,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Reject an action
+   */
+  rejectAction(actionId: string, reason?: string): void {
+    const action = this.actions.get(actionId);
+    if (!action) {
+      throw new Error(`Action not found: ${actionId}`);
+    }
+
+    action.status = 'rejected';
+
+    this.auditLogger.log({
+      event: 'action_rejected',
+      action_id: actionId,
+      action_type: action.type,
+      reason: reason || 'No reason provided',
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Get pending actions awaiting approval
+   */
+  getPendingActions(): AutomatedAction[] {
+    return Array.from(this.actions.values()).filter(a => a.status === 'pending_approval');
+  }
+
+  /**
+   * Get action by ID
+   */
+  getAction(actionId: string): AutomatedAction | undefined {
+    return this.actions.get(actionId);
+  }
+
+  /**
+   * Get all actions (with optional filtering)
+   */
+  getAllActions(status?: string): AutomatedAction[] {
+    const allActions = Array.from(this.actions.values());
+    if (!status) return allActions;
+    return allActions.filter(a => a.status === status);
+  }
+
+  /**
+   * Map threat level to CRM lead score
+   */
+  private mapThreatLevelToScore(threatLevel: string): number {
+    const map: Record<string, number> = {
+      critical: 95,
+      high: 80,
+      medium: 60,
+      low: 40
+    };
+    return map[threatLevel] || 50;
+  }
+
+  /**
+   * Get action queue statistics
+   */
+  getQueueStats(): {
+    pending: number;
+    approved: number;
+    executed: number;
+    rejected: number;
+    total: number;
+  } {
+    const actions = Array.from(this.actions.values());
+    return {
+      pending: actions.filter(a => a.status === 'pending_approval').length,
+      approved: actions.filter(a => a.status === 'approved').length,
+      executed: actions.filter(a => a.status === 'executed').length,
+      rejected: actions.filter(a => a.status === 'rejected').length,
+      total: actions.length
+    };
+  }
+}
+
+export default ActionExecutor;

package/src/automation/alertRules.ts

@@ -0,0 +1,113 @@
+/**
+ * Alert Rules Configuration
+ * Configurable thresholds for alert triggering
+ * Phase 8B Task 5
+ */
+
+/**
+ * Alert rule thresholds
+ */
+export interface AlertThresholds {
+  // Lead quality
+  highQualityLeadThreshold: number; // 0-100, default: 80
+  highQualityMinSignals: number; // default: 2
+
+  // Threat escalation
+  threatEscalationLevels: {
+    NONE: number;
+    LOW: number;
+    MEDIUM: number;
+    HIGH: number;
+    CRITICAL: number;
+  };
+
+  // Revenue milestones
+  revenueMilestones: number[]; // e.g., [50000, 100000, 500000]
+
+  // Market trends
+  marketTrendVelocityThreshold: number; // mentions/week, default: 5
+  marketTrendConfidenceThreshold: number; // 0-100, default: 70
+}
+
+/**
+ * Default thresholds
+ */
+export const DEFAULT_THRESHOLDS: AlertThresholds = {
+  highQualityLeadThreshold: 80,
+  highQualityMinSignals: 2,
+
+  threatEscalationLevels: {
+    NONE: 0,
+    LOW: 25,
+    MEDIUM: 50,
+    HIGH: 75,
+    CRITICAL: 90,
+  },
+
+  revenueMilestones: [50000, 100000, 500000],
+
+  marketTrendVelocityThreshold: 5,
+  marketTrendConfidenceThreshold: 70,
+};
+
+/**
+ * Alert rule validator
+ */
+export function validateThresholds(thresholds: Partial<AlertThresholds>): AlertThresholds {
+  const merged = { ...DEFAULT_THRESHOLDS, ...thresholds };
+
+  if (merged.highQualityLeadThreshold < 0 || merged.highQualityLeadThreshold > 100) {
+    throw new Error('highQualityLeadThreshold must be 0-100');
+  }
+
+  if (merged.highQualityMinSignals < 1) {
+    throw new Error('highQualityMinSignals must be >= 1');
+  }
+
+  if (merged.revenueMilestones.length === 0) {
+    throw new Error('revenueMilestones must have at least one value');
+  }
+
+  if (merged.marketTrendVelocityThreshold < 0) {
+    throw new Error('marketTrendVelocityThreshold must be >= 0');
+  }
+
+  if (merged.marketTrendConfidenceThreshold < 0 || merged.marketTrendConfidenceThreshold > 100) {
+    throw new Error('marketTrendConfidenceThreshold must be 0-100');
+  }
+
+  return merged;
+}
+
+/**
+ * Alert severity levels
+ */
+export type AlertSeverity = 'info' | 'warning' | 'critical';
+
+/**
+ * Alert type mappings
+ */
+export const ALERT_SEVERITY_MAP: Record<string, AlertSeverity> = {
+  'high-quality-lead': 'info',
+  'threat-escalation': 'critical',
+  'revenue-milestone': 'info',
+  'market-trend-urgent': 'warning',
+};
+
+/**
+ * Composio action templates
+ */
+export const COMPOSIO_ACTIONS = {
+  'slack-notification': {
+    tool: 'slack',
+    action: 'send_message',
+    required: ['channel', 'text'],
+  },
+  'email-notification': {
+    tool: 'gmail',
+    action: 'draft_email',
+    required: ['to', 'subject', 'body'],
+  },
+};
+
+export default DEFAULT_THRESHOLDS;