lean-claudient-core 0.1.0

package/src/automation/scheduler.ts

@@ -0,0 +1,254 @@
+/**
+ * Scheduled Background Jobs Scheduler
+ * In-memory cron-like task scheduling with audit logging
+ * No external dependencies (no Redis/Bull)
+ * Phase 8C Task 7
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+import { AuditLogger } from '../core/auditLogger.js';
+
+/**
+ * Job definition
+ */
+export interface ScheduledJob {
+  id: string;
+  name: string;
+  interval: number; // milliseconds
+  fn: () => Promise<void> | void;
+  lastRun?: number;
+  nextRun: number;
+  status: 'scheduled' | 'running' | 'failed' | 'idle';
+  lastError?: string;
+  executionCount: number;
+}
+
+/**
+ * Job status for reporting
+ */
+export interface JobStatus {
+  id: string;
+  name: string;
+  interval: number;
+  status: string;
+  lastRun?: string;
+  nextRun: string;
+  executionCount: number;
+  lastError?: string;
+}
+
+/**
+ * Scheduler: Manages background job execution
+ */
+export class Scheduler {
+  private jobs: Map<string, ScheduledJob> = new Map();
+  private timers: Map<string, NodeJS.Timeout> = new Map();
+  private auditLogger: AuditLogger;
+  private running: boolean = false;
+
+  constructor() {
+    this.auditLogger = new AuditLogger();
+  }
+
+  /**
+   * Schedule a new job
+   */
+  scheduleJob(
+    name: string,
+    interval: number,
+    fn: () => Promise<void> | void
+  ): string {
+    const jobId = uuidv4();
+    const job: ScheduledJob = {
+      id: jobId,
+      name,
+      interval,
+      fn,
+      nextRun: Date.now() + interval,
+      status: 'idle',
+      executionCount: 0,
+    };
+
+    this.jobs.set(jobId, job);
+
+    this.auditLogger.log({
+      event: 'job:scheduled',
+      jobId,
+      name,
+      interval,
+    });
+
+    return jobId;
+  }
+
+  /**
+   * Start scheduler and all jobs
+   */
+  async start(): Promise<void> {
+    if (this.running) return;
+    this.running = true;
+
+    this.auditLogger.log({
+      event: 'scheduler:started',
+      jobCount: this.jobs.size,
+    });
+
+    // Schedule all jobs
+    for (const [jobId, job] of this.jobs) {
+      this.scheduleJobExecution(jobId, job);
+    }
+  }
+
+  /**
+   * Stop scheduler gracefully
+   */
+  async stop(): Promise<void> {
+    if (!this.running) return;
+    this.running = false;
+
+    // Clear all timers
+    for (const [jobId, timer] of this.timers) {
+      clearTimeout(timer);
+      this.timers.delete(jobId);
+    }
+
+    this.auditLogger.log({
+      event: 'scheduler:stopped',
+      jobCount: this.jobs.size,
+    });
+  }
+
+  /**
+   * Schedule a job's next execution
+   */
+  private scheduleJobExecution(jobId: string, job: ScheduledJob): void {
+    if (!this.running) return;
+
+    const delay = Math.max(0, job.nextRun - Date.now());
+
+    const timer = setTimeout(async () => {
+      await this.executeJob(jobId);
+      // Reschedule
+      this.scheduleJobExecution(jobId, job);
+    }, delay);
+
+    this.timers.set(jobId, timer);
+  }
+
+  /**
+   * Execute a job immediately
+   */
+  async manualRun(jobName: string): Promise<void> {
+    const job = Array.from(this.jobs.values()).find((j) => j.name === jobName);
+    if (!job) {
+      throw new Error(`Job not found: ${jobName}`);
+    }
+
+    const jobId = job.id;
+    await this.executeJob(jobId);
+  }
+
+  /**
+   * Execute a job with error handling
+   */
+  private async executeJob(jobId: string): Promise<void> {
+    const job = this.jobs.get(jobId);
+    if (!job) return;
+
+    job.status = 'running';
+    const startTime = Date.now();
+
+    try {
+      this.auditLogger.log({
+        event: 'job:started',
+        jobId,
+        name: job.name,
+      });
+
+      // Execute the job function
+      await Promise.resolve(job.fn());
+
+      const duration = Date.now() - startTime;
+      job.lastRun = Date.now();
+      job.nextRun = Date.now() + job.interval;
+      job.status = 'scheduled';
+      job.executionCount++;
+      delete job.lastError;
+
+      this.auditLogger.log({
+        event: 'job:completed',
+        jobId,
+        name: job.name,
+        duration,
+        nextRun: new Date(job.nextRun).toISOString(),
+      });
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      job.status = 'failed';
+      job.lastError = errorMsg;
+      job.lastRun = Date.now();
+      job.nextRun = Date.now() + job.interval;
+      job.executionCount++;
+
+      this.auditLogger.log({
+        event: 'job:failed',
+        jobId,
+        name: job.name,
+        error: errorMsg,
+      });
+
+      // Log but don't re-throw - scheduler should continue
+    }
+  }
+
+  /**
+   * Get status of all jobs
+   */
+  getJobStatus(): JobStatus[] {
+    return Array.from(this.jobs.values()).map((job) => ({
+      id: job.id,
+      name: job.name,
+      interval: job.interval,
+      status: job.status,
+      lastRun: job.lastRun ? new Date(job.lastRun).toISOString() : undefined,
+      nextRun: new Date(job.nextRun).toISOString(),
+      executionCount: job.executionCount,
+      lastError: job.lastError,
+    }));
+  }
+
+  /**
+   * Get job status by name
+   */
+  getJobByName(jobName: string): JobStatus | undefined {
+    const job = Array.from(this.jobs.values()).find((j) => j.name === jobName);
+    if (!job) return undefined;
+
+    return {
+      id: job.id,
+      name: job.name,
+      interval: job.interval,
+      status: job.status,
+      lastRun: job.lastRun ? new Date(job.lastRun).toISOString() : undefined,
+      nextRun: new Date(job.nextRun).toISOString(),
+      executionCount: job.executionCount,
+      lastError: job.lastError,
+    };
+  }
+
+  /**
+   * Is scheduler running
+   */
+  isRunning(): boolean {
+    return this.running;
+  }
+
+  /**
+   * Get count of scheduled jobs
+   */
+  getJobCount(): number {
+    return this.jobs.size;
+  }
+}
+
+export default Scheduler;

package/src/automation/types.ts

@@ -0,0 +1,270 @@
+/**
+ * Type Definitions for Composio Automation Module
+ */
+
+// Composio Client Types
+export interface ComposioConfig {
+  apiKey: string;
+  baseUrl?: string;
+  encryptionKey?: string;
+}
+
+export interface ComposioTokens {
+  accessToken: string;
+  refreshToken: string;
+  expiresAt: number;
+  scope: string;
+}
+
+export interface ComposioStatus {
+  authenticated: boolean;
+  expiresIn?: number;
+  scope?: string;
+}
+
+// Gmail Integration Types
+export interface EmailTemplate {
+  name: string;
+  subject: string;
+  body: string;
+  isHtml: boolean;
+}
+
+export interface DraftEmailResponse {
+  draftId: string;
+  to: string;
+  subject: string;
+  preview: string;
+  threadId?: string;
+}
+
+export interface SendEmailResponse {
+  messageId: string;
+  status: 'sent';
+  timestamp: string;
+}
+
+// CRM Integration Types
+export type CRMPlatform = 'salesforce' | 'hubspot';
+
+export interface CRMLead {
+  name: string;
+  email: string;
+  company: string;
+  industry?: string;
+  painPoint: string;
+  source: string;
+  signalStrength: number;
+  customFields?: Record<string, any>;
+}
+
+export interface CRMLeadResponse {
+  leadId: string;
+  name: string;
+  company: string;
+  score: number;
+  status: 'created' | 'updated';
+  timestamp: string;
+}
+
+export interface LeadScoring {
+  baseScore: number;
+  signals: Record<string, number>;
+  totalScore: number;
+}
+
+// Jira Integration Types
+export type JiraPriority = 'lowest' | 'low' | 'medium' | 'high' | 'highest';
+export type JiraIssueType = 'epic' | 'story' | 'bug' | 'task';
+
+export interface JiraEpicConfig {
+  title: string;
+  description: string;
+  priority: JiraPriority;
+  labels?: string[];
+  externalLinks?: Array<{
+    url: string;
+    title: string;
+    type: 'github' | 'reddit' | 'hackernews';
+  }>;
+  customFields?: Record<string, any>;
+}
+
+export interface JiraIssueResponse {
+  issueId: string;
+  key: string;
+  title: string;
+  url: string;
+  status: string;
+  timestamp: string;
+}
+
+export interface LinkedResource {
+  type: 'github_discussion' | 'reddit_thread' | 'hackernews_comment';
+  url: string;
+  title: string;
+  relevanceScore: number;
+}
+
+// Action Executor Types
+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';
+
+// Action Approver Types
+export interface ApprovalRecord {
+  id: string;
+  actionId: string;
+  actionType: string;
+  status: 'approved' | 'rejected';
+  reason?: string;
+  approvedBy: string;
+  approvedAt: string;
+}
+
+export interface ApprovalStats {
+  totalRequests: number;
+  approvedCount: number;
+  rejectedCount: number;
+  approvalRate: number;
+  averageResponseTime: number;
+}
+
+// Workflow Types
+export interface WorkflowContext {
+  marketFinding: MarketFinding;
+  createdActions: AutomatedAction[];
+  approvedActions: AutomatedAction[];
+  executedActions: AutomatedAction[];
+  failedActions: Array<{
+    action: AutomatedAction;
+    error: string;
+  }>;
+}
+
+export interface WorkflowResult {
+  success: boolean;
+  finding: MarketFinding;
+  actionCount: number;
+  approvedCount: number;
+  executedCount: number;
+  failedCount: number;
+  duration: number;
+}
+
+// Configuration Types
+export interface AutomationConfig {
+  composio: {
+    apiKey: string;
+    baseUrl?: string;
+    masterSecret?: string;
+  };
+  gmail?: {
+    address: string;
+    oauthClientId?: string;
+    oauthClientSecret?: string;
+  };
+  salesforce?: {
+    instance: string;
+    clientId?: string;
+    clientSecret?: string;
+    username?: string;
+  };
+  hubspot?: {
+    apiKey?: string;
+    privateAppToken?: string;
+  };
+  jira?: {
+    instance: string;
+    apiToken?: string;
+    projectKey: string;
+    userEmail: string;
+  };
+  approval?: {
+    required: boolean;
+    autoExecuteAfterHours?: boolean;
+    batchSize?: number;
+  };
+  notification?: {
+    productTeamEmail?: string;
+    salesTeamEmail?: string;
+    engineeringTeamEmail?: string;
+  };
+  storage?: {
+    auditLogDirectory?: string;
+    tokenPath?: string;
+    approvalsPath?: string;
+  };
+  features?: {
+    enableGmail?: boolean;
+    enableCRM?: boolean;
+    enableJira?: boolean;
+    enableHumanInLoop?: boolean;
+    enableAuditLogging?: boolean;
+  };
+}
+
+// Error Types
+export class AutomationError extends Error {
+  constructor(
+    message: string,
+    public code: string,
+    public details?: Record<string, any>
+  ) {
+    super(message);
+    this.name = 'AutomationError';
+  }
+}
+
+export class OAuth2Error extends AutomationError {
+  constructor(message: string, details?: Record<string, any>) {
+    super(message, 'OAUTH2_ERROR', details);
+    this.name = 'OAuth2Error';
+  }
+}
+
+export class APIError extends AutomationError {
+  constructor(
+    message: string,
+    public statusCode: number,
+    details?: Record<string, any>
+  ) {
+    super(message, 'API_ERROR', details);
+    this.name = 'APIError';
+  }
+}
+
+export class ApprovalError extends AutomationError {
+  constructor(message: string, details?: Record<string, any>) {
+    super(message, 'APPROVAL_ERROR', details);
+    this.name = 'ApprovalError';
+  }
+}