lean-claudient-core 0.1.0

package/src/automation/gmailIntegration.ts

@@ -0,0 +1,244 @@
+/**
+ * Gmail Integration via Composio
+ * Draft and send emails with professional templates.
+ * All sends require human approval before execution.
+ */
+
+import ComposioClient from './composioClient.js';
+
+interface EmailTemplate {
+  name: string;
+  subject: string;
+  body: string;
+  isHtml: boolean;
+}
+
+interface DraftEmailResponse {
+  draftId: string;
+  to: string;
+  subject: string;
+  preview: string;
+  threadId?: string;
+}
+
+interface SendEmailResponse {
+  messageId: string;
+  status: 'sent';
+  timestamp: string;
+}
+
+/**
+ * Gmail integration for drafting and sending professional emails
+ */
+export class GmailIntegration {
+  private composio: ComposioClient;
+  private senderEmail: string;
+
+  private templates: Record<string, EmailTemplate> = {
+    marketIntel: {
+      name: 'Market Intelligence Update',
+      subject: 'Market Intelligence: New Competitive Threat Detected',
+      body: `Hi Team,
+
+We've detected a new market opportunity based on competitor activity analysis. See details below.
+
+This email was auto-generated by Lean Claudient's market intelligence engine.
+
+Best regards,
+Lean Claudient Bot`,
+      isHtml: false
+    },
+    leadNotification: {
+      name: 'New Lead Created',
+      subject: 'New Lead: {companyName}',
+      body: `Hi Sales Team,
+
+A new lead has been auto-created based on market signals:
+
+Company: {companyName}
+Contact: {contactName} ({contactEmail})
+Pain Point: {painPoint}
+Signal Strength: {strength}
+
+Please review and follow up accordingly.
+
+Best regards,
+Lean Claudient Bot`,
+      isHtml: false
+    },
+    featureRequest: {
+      name: 'Feature Request Summary',
+      subject: 'Feature Request: {featureTitle}',
+      body: `Hi Product Team,
+
+Based on market analysis, we recommend prioritizing the following feature:
+
+Feature: {featureTitle}
+User Pain Point: {painPoint}
+Market Demand: {demand}
+Priority: {priority}
+
+Please review and consider for the next sprint.
+
+Best regards,
+Lean Claudient Bot`,
+      isHtml: false
+    }
+  };
+
+  constructor(composio: ComposioClient, senderEmail: string) {
+    this.composio = composio;
+    this.senderEmail = senderEmail;
+  }
+
+  /**
+   * Draft an email (saved locally, not sent)
+   * Returns draft ID for human review before sending
+   */
+  async draftEmail(
+    to: string,
+    subject: string,
+    body: string,
+    isHtml: boolean = false
+  ): Promise<DraftEmailResponse> {
+    try {
+      const response = await this.composio.request('/integrations/gmail/draft', 'POST', {
+        to,
+        subject,
+        body,
+        isHtml,
+        from: this.senderEmail
+      });
+
+      return {
+        draftId: response.id,
+        to,
+        subject,
+        preview: body.substring(0, 150).trim() + '...',
+        threadId: response.threadId
+      };
+    } catch (error) {
+      throw new Error(`Failed to draft email: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Draft email from template with variable substitution
+   */
+  async draftFromTemplate(
+    templateName: string,
+    to: string,
+    variables: Record<string, string>
+  ): Promise<DraftEmailResponse> {
+    const template = this.templates[templateName];
+    if (!template) {
+      throw new Error(`Template not found: ${templateName}`);
+    }
+
+    let subject = template.subject;
+    let body = template.body;
+
+    // Substitute variables
+    for (const [key, value] of Object.entries(variables)) {
+      subject = subject.replace(`{${key}}`, value);
+      body = body.replace(`{${key}}`, value);
+    }
+
+    return this.draftEmail(to, subject, body, template.isHtml);
+  }
+
+  /**
+   * Send a previously drafted email
+   * Requires human approval before execution
+   */
+  async sendEmail(draftId: string): Promise<SendEmailResponse> {
+    try {
+      const response = await this.composio.request(
+        `/integrations/gmail/draft/${draftId}/send`,
+        'POST',
+        {}
+      );
+
+      return {
+        messageId: response.id,
+        status: 'sent',
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      throw new Error(`Failed to send email: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Get draft details for review
+   */
+  async getDraftDetails(draftId: string): Promise<{
+    to: string;
+    subject: string;
+    body: string;
+    isHtml: boolean;
+  }> {
+    try {
+      const response = await this.composio.request(`/integrations/gmail/draft/${draftId}`);
+      return {
+        to: response.to,
+        subject: response.subject,
+        body: response.body,
+        isHtml: response.isHtml || false
+      };
+    } catch (error) {
+      throw new Error(`Failed to retrieve draft: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Send custom email with professional formatting
+   */
+  async sendCustomEmail(
+    to: string,
+    subject: string,
+    body: string,
+    isHtml: boolean = false
+  ): Promise<SendEmailResponse> {
+    try {
+      const response = await this.composio.request('/integrations/gmail/send', 'POST', {
+        to,
+        subject,
+        body,
+        isHtml,
+        from: this.senderEmail
+      });
+
+      return {
+        messageId: response.id,
+        status: 'sent',
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      throw new Error(`Failed to send email: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Get available templates
+   */
+  getTemplates(): Record<string, { subject: string; preview: string }> {
+    const result: Record<string, { subject: string; preview: string }> = {};
+    for (const [key, template] of Object.entries(this.templates)) {
+      result[key] = {
+        subject: template.subject,
+        preview: template.body.substring(0, 100) + '...'
+      };
+    }
+    return result;
+  }
+
+  /**
+   * Register custom template
+   */
+  registerTemplate(name: string, template: EmailTemplate): void {
+    this.templates[name] = template;
+  }
+}
+
+export default GmailIntegration;

package/src/automation/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Composio Automation Module
+ * Unified exports for business automation integrations
+ */
+
+export { ComposioClient, default as ComposioClientDefault } from './composioClient.js';
+export { GmailIntegration, default as GmailIntegrationDefault } from './gmailIntegration.js';
+export { CRMIntegration, CRMPlatform, default as CRMIntegrationDefault } from './crmIntegration.js';
+export { JiraIntegration, IssueType, JiraPriority, default as JiraIntegrationDefault } from './jiraIntegration.js';
+export { ActionExecutor, MarketFinding, AutomatedAction, ActionType, default as ActionExecutorDefault } from './actionExecutor.js';
+export { ActionApprover, default as ActionApproverDefault } from './actionApprover.js';
+export { LeadQualifier, getLeadQualifier, resetLeadQualifier, default as LeadQualifierDefault } from './leadQualification.js';
+export { AlertSystem, createAlertSystem, type Alert, default as AlertSystemDefault } from './alertSystem.js';
+export { DEFAULT_THRESHOLDS, validateThresholds, type AlertThresholds, type AlertSeverity } from './alertRules.js';
+export { Scheduler, type ScheduledJob, type JobStatus, default as SchedulerDefault } from './scheduler.js';
+export { JobQueue, type QueuedJob, type QueueStats, default as JobQueueDefault } from './jobQueue.js';
+export { CRMExporter, type CRMOpportunity, type ExportHistoryEntry, type CRMConfig, default as CRMExporterDefault } from './crmExport.js';

package/src/automation/jiraIntegration.ts

@@ -0,0 +1,310 @@
+/**
+ * Jira Integration via Composio
+ * Auto-create epics and issues based on market intelligence findings.
+ * Link to GitHub discussions and Reddit threads for context.
+ */
+
+import ComposioClient from './composioClient.js';
+
+export type JiraPriority = 'lowest' | 'low' | 'medium' | 'high' | 'highest';
+export type IssueType = 'epic' | 'story' | 'bug' | 'task';
+
+interface JiraEpicConfig {
+  title: string;
+  description: string;
+  priority: JiraPriority;
+  labels?: string[];
+  externalLinks?: Array<{
+    url: string;
+    title: string;
+    type: 'github' | 'reddit' | 'hackernews';
+  }>;
+  customFields?: Record<string, any>;
+}
+
+interface JiraIssueResponse {
+  issueId: string;
+  key: string;
+  title: string;
+  url: string;
+  status: string;
+  timestamp: string;
+}
+
+interface LinkedResource {
+  type: 'github_discussion' | 'reddit_thread' | 'hackernews_comment';
+  url: string;
+  title: string;
+  relevanceScore: number;
+}
+
+/**
+ * Jira integration for automated issue and epic creation
+ */
+export class JiraIntegration {
+  private composio: ComposioClient;
+  private projectKey: string;
+  private jiraBaseUrl: string;
+
+  private priorityMapping: Record<JiraPriority, number> = {
+    lowest: 5,
+    low: 4,
+    medium: 3,
+    high: 2,
+    highest: 1
+  };
+
+  constructor(composio: ComposioClient, projectKey: string, jiraBaseUrl: string) {
+    this.composio = composio;
+    this.projectKey = projectKey;
+    this.jiraBaseUrl = jiraBaseUrl;
+  }
+
+  /**
+   * Create a new epic based on market intelligence findings
+   */
+  async createEpic(config: JiraEpicConfig): Promise<JiraIssueResponse> {
+    try {
+      const payload = {
+        fields: {
+          project: { key: this.projectKey },
+          issuetype: { name: 'Epic' },
+          summary: config.title,
+          description: this.formatDescription(config.description, config.externalLinks),
+          priority: { name: this.priorityToJiraName(config.priority) },
+          labels: config.labels || ['market-intelligence', 'auto-generated'],
+          ...config.customFields
+        }
+      };
+
+      const response = await this.composio.request('/integrations/jira/issues', 'POST', payload);
+
+      const issueId = response.id || response.key;
+      const issueUrl = `${this.jiraBaseUrl}/browse/${response.key}`;
+
+      // Link external resources if provided
+      if (config.externalLinks && config.externalLinks.length > 0) {
+        await this.linkResources(response.key, config.externalLinks);
+      }
+
+      return {
+        issueId,
+        key: response.key,
+        title: config.title,
+        url: issueUrl,
+        status: response.fields.status?.name || 'To Do',
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      throw new Error(`Failed to create Jira epic: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Create a story linked to an epic
+   */
+  async createStory(
+    epicKey: string,
+    title: string,
+    description: string,
+    priority: JiraPriority = 'medium'
+  ): Promise<JiraIssueResponse> {
+    try {
+      const payload = {
+        fields: {
+          project: { key: this.projectKey },
+          issuetype: { name: 'Story' },
+          summary: title,
+          description,
+          priority: { name: this.priorityToJiraName(priority) },
+          parent: { key: epicKey },
+          labels: ['market-intelligence', 'auto-generated']
+        }
+      };
+
+      const response = await this.composio.request('/integrations/jira/issues', 'POST', payload);
+
+      return {
+        issueId: response.id || response.key,
+        key: response.key,
+        title,
+        url: `${this.jiraBaseUrl}/browse/${response.key}`,
+        status: response.fields.status?.name || 'To Do',
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      throw new Error(`Failed to create story: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Link external resources (GitHub discussions, Reddit threads) to Jira epic
+   */
+  private async linkResources(
+    epicKey: string,
+    links: Array<{ url: string; title: string; type: string }>
+  ): Promise<void> {
+    try {
+      for (const link of links) {
+        await this.composio.request(
+          `/integrations/jira/issues/${epicKey}/links`,
+          'POST',
+          {
+            body: `Related to: [${link.title}|${link.url}]`,
+            type: link.type
+          }
+        );
+      }
+    } catch (error) {
+      console.warn('Failed to link resources:', (error as Error).message);
+    }
+  }
+
+  /**
+   * Format epic description with linked resources
+   */
+  private formatDescription(
+    baseDescription: string,
+    externalLinks?: Array<{ url: string; title: string; type: string }>
+  ): string {
+    let formatted = baseDescription;
+
+    if (externalLinks && externalLinks.length > 0) {
+      formatted += '\n\n*Related Discussions:*\n';
+      for (const link of externalLinks) {
+        formatted += `* [${link.title}|${link.url}]\n`;
+      }
+    }
+
+    formatted += '\n\n_Auto-generated by Lean Claudient market intelligence engine_';
+
+    return formatted;
+  }
+
+  /**
+   * Convert priority level to Jira priority name
+   */
+  private priorityToJiraName(priority: JiraPriority): string {
+    const map: Record<JiraPriority, string> = {
+      lowest: 'Lowest',
+      low: 'Low',
+      medium: 'Medium',
+      high: 'High',
+      highest: 'Highest'
+    };
+    return map[priority];
+  }
+
+  /**
+   * Get issue details
+   */
+  async getIssue(issueKey: string): Promise<any> {
+    try {
+      const response = await this.composio.request(`/integrations/jira/issues/${issueKey}`);
+      return response;
+    } catch (error) {
+      throw new Error(`Failed to retrieve issue: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Update issue status
+   */
+  async updateStatus(issueKey: string, statusName: string): Promise<{ success: boolean }> {
+    try {
+      await this.composio.request(
+        `/integrations/jira/issues/${issueKey}/transitions`,
+        'POST',
+        {
+          transition: { name: statusName }
+        }
+      );
+      return { success: true };
+    } catch (error) {
+      throw new Error(`Failed to update status: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Add comment to issue
+   */
+  async addComment(issueKey: string, comment: string): Promise<{ success: boolean }> {
+    try {
+      await this.composio.request(
+        `/integrations/jira/issues/${issueKey}/comments`,
+        'POST',
+        {
+          body: comment
+        }
+      );
+      return { success: true };
+    } catch (error) {
+      throw new Error(`Failed to add comment: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Create threat response epic from market findings
+   * Combines title, description, and links into Jira epic
+   */
+  async createThreatResponseEpic(
+    threatTitle: string,
+    threatDescription: string,
+    threatLevel: 'critical' | 'high' | 'medium' | 'low',
+    linkedResources: LinkedResource[]
+  ): Promise<JiraIssueResponse> {
+    const priorityMap: Record<string, JiraPriority> = {
+      critical: 'highest',
+      high: 'high',
+      medium: 'medium',
+      low: 'low'
+    };
+    const priority: JiraPriority = priorityMap[threatLevel];
+
+    const externalLinks: Array<{ url: string; title: string; type: 'github' | 'reddit' | 'hackernews' }> = linkedResources.map(r => ({
+      url: r.url,
+      title: r.title,
+      type: this.resourceTypeToLinkType(r.type) as 'github' | 'reddit' | 'hackernews'
+    }));
+
+    return this.createEpic({
+      title: `Threat Response: ${threatTitle}`,
+      description: `*Threat Level:* ${threatLevel.toUpperCase()}\n\n${threatDescription}`,
+      priority,
+      labels: ['threat-response', 'market-intelligence', 'auto-generated'],
+      externalLinks
+    });
+  }
+
+  /**
+   * Convert resource type to Jira link type
+   */
+  private resourceTypeToLinkType(
+    type: 'github_discussion' | 'reddit_thread' | 'hackernews_comment'
+  ): string {
+    return type;
+  }
+
+  /**
+   * Get epic URL
+   */
+  getEpicUrl(epicKey: string): string {
+    return `${this.jiraBaseUrl}/browse/${epicKey}`;
+  }
+
+  /**
+   * Update project key (for multi-project support)
+   */
+  setProjectKey(projectKey: string): void {
+    this.projectKey = projectKey;
+  }
+
+  /**
+   * Get current project key
+   */
+  getProjectKey(): string {
+    return this.projectKey;
+  }
+}
+
+export default JiraIntegration;