# Install Cleo
npm install @cleotasks/core
 
# Or using yarn
yarn add @cleotasks/core

import { Cleo, TaskPriority, GroupProcessingStrategy } from "@cleotasks/core";
 
// Get Cleo instance
const cleo = Cleo.getInstance();
 
// Configure Redis connection and worker settings
cleo.configure({
  redis: {
    host: "localhost",
    port: 6379,
    password: "cleosecret",
  },
  worker: {
    concurrency: 4,
    queues: [
      {
        name: "notifications",
        priority: TaskPriority.HIGH,
      },
    ],
  },
});
 
// Get queue manager for task handling
const queueManager = cleo.getQueueManager();
 
// Configure group processing strategy
queueManager.setGroupProcessingStrategy(GroupProcessingStrategy.ROUND_ROBIN);

import { task, QueueClass } from "@cleotasks/core";
 
// Individual task with specific configuration
class EmailService {
  @task({
    id: "send-email",
    priority: TaskPriority.HIGH,
    queue: 'notifications',
    group: 'emails',
    timeout: 30000,
    maxRetries: 3,
    retryDelay: 3000,
  })
  async sendEmail(input: { email: string, template: string }): Promise<string> {
    // Your email sending logic here
    return `Sent to ${input.email} using ${input.template}`;
  }
}
 
// Class-level configuration for all methods
@QueueClass({
  defaultOptions: {
    maxRetries: 3,
    retryDelay: 1000,
    backoff: {
      type: "exponential",
      delay: 2000,
    },
    group: "notifications",
    timeout: 300000,
  },
  queue: "notifications",
})
class NotificationService {
  async sendPushNotification(data: { userId: string, message: string }) {
    // Push notification logic
    return `Push sent to ${data.userId}`;
  }
 
  async sendSMS(data: { phone: string, message: string }) {
    // SMS logic
    return `SMS sent to ${data.phone}`;
  }
}
 
// Create service instances
const emailService = new EmailService();
const notificationService = new NotificationService();

import { ObserverEvent } from "@cleotasks/core";
 
// Monitor task lifecycle events
queueManager.onTaskEvent(ObserverEvent.TASK_COMPLETED, (taskId, status, data) => {
  console.log(`✅ Task ${taskId} completed:`, {
    result: data?.result,
    group: data?.group
  });
});
 
// Monitor group operations
queueManager.onTaskEvent(ObserverEvent.GROUP_CHANGE, (taskId, status, data) => {
  console.log(`👥 Group operation:`, {
    taskId,
    operation: data.operation,
    group: data.group,
    history: data.history
  });
});
 
// Monitor task failures with retry information
queueManager.onTaskEvent(ObserverEvent.TASK_FAILED, (taskId, status, data) => {
  console.log(`❌ Task ${taskId} failed:`, {
    error: data?.error,
    retryCount: data?.retryCount,
    nextRetry: data?.nextRetry
  });
});

// Execute tasks with automatic group handling
await emailService.sendEmail({
  email: "user@example.com",
  template: "welcome"
});
 
await notificationService.sendPushNotification({
  userId: "user123",
  message: "Welcome aboard!"
});
 
// Get group statistics
const groupStats = await (await queueManager.getGroup("notifications")).getStats();
console.log("📊 Group Stats:", {
  total: groupStats.total,
  active: groupStats.active,
  completed: groupStats.completed,
  failed: groupStats.failed
});
 
// Get task history
const worker = cleo.getWorker("notifications");
const taskHistory = await worker.getTaskHistory();
console.log("📜 Task History:", taskHistory);

// Clean up event listeners when done
queueManager.offTaskEvent(ObserverEvent.TASK_COMPLETED);
queueManager.offTaskEvent(ObserverEvent.GROUP_CHANGE);
queueManager.offTaskEvent(ObserverEvent.TASK_FAILED);
 
// Close connections
await cleo.getQueueManager().close();