lua-cli 2.5.8 → 3.0.0-alpha.10

package/template/package.json

@@ -18,8 +18,9 @@
     "@types/js-yaml": "^4.0.9",
     "axios": "^1.6.0",
     "inquirer": "^12.9.6",
+    "stripe": "^17.5.0",
     "js-yaml": "^4.1.0",
-    "lua-cli": "^2.5.8",
+    "lua-cli": "file:..",
     "openai": "^5.23.0",
     "uuid": "^13.0.0",
     "zod": "^3.24.1"

package/template/src/index.ts

@@ -1,4 +1,4 @@
-import { LuaSkill, User, Products, Orders, Data, Baskets } from "lua-cli";
+import { LuaSkill, User, Products, Orders, Data, Baskets, LuaJob, JobInstance, LuaWebhook, Jobs } from "lua-cli";
 import GetWeatherTool from "./tools/GetWeatherTool";
 import { GetUserDataTool, UpdateUserDataTool } from "./tools/UserDataTool";
 import CreatePostTool from "./tools/CreatePostTool";
@@ -7,6 +7,47 @@ import CreatePaymentLinkTool from "./tools/PaymentTool";
 import { CreateBasketTool, GetBasketsTool, AddItemToBasketTool, RemoveItemFromBasketTool, ClearBasketTool, UpdateBasketStatusTool, UpdateBasketMetadataTool, CheckoutBasketTool, GetBasketByIdTool } from "./tools/BasketTool";
 import { CreateOrderTool, UpdateOrderStatusTool, GetOrderByIdTool, GetUserOrdersTool } from "./tools/OrderTool";
 import { CreateMovieTool, GetMoviesTool, GetMovieByIdTool, UpdateMovieTool, SearchMoviesTool, DeleteMovieTool } from "./tools/CustomDataTool";
+import CreateInlineJobTool from "./tools/CreateInlineJob";
+import { v4 } from 'uuid';
+
+// ============================================================================
+// WEBHOOK EXAMPLES (Uncomment to enable)
+// ============================================================================
+// Webhooks receive HTTP requests from external systems
+// See: WEBHOOK_JOB_EXAMPLES.md for detailed explanations
+
+// import userEventWebhook from "./webhooks/UserEventWebhook";
+// import paymentWebhook from "./webhooks/PaymentWebhook";
+
+// ============================================================================
+// JOB EXAMPLES (Uncomment to enable)
+// ============================================================================
+// Jobs are scheduled tasks that run at specific times or intervals
+// See: WEBHOOK_JOB_EXAMPLES.md for detailed explanations
+
+import dailyCleanupJob from "./jobs/DailyCleanupJob";
+// import healthCheckJob from "./jobs/HealthCheckJob";
+// import dataMigrationJob from "./jobs/DataMigrationJob";
+// import abandonedBasketProcessorJob from "./jobs/AbandonedBasketProcessorJob";
+
+// ============================================================================
+// SMART BASKET TOOL (Uncomment to enable)
+// ============================================================================
+// This tool creates baskets with automatic abandoned cart reminders
+// Uses Jobs.create() to schedule one-time check 3 hours after creation
+
+// import { CreateSmartBasketTool, CheckAbandonedBasketsTool } from "./tools/SmartBasketTool";
+
+// ============================================================================
+// GAME SCORE TRACKER (Uncomment to enable) - ADVANCED EXAMPLE
+// ============================================================================
+// Complex example showing:
+// - Interval jobs that start at specific time
+// - Jobs that stop themselves when condition is met
+// - Real-time monitoring with external API integration
+// See: COMPLEX_JOB_EXAMPLES.md for detailed explanation
+
+// import { TrackGameScoresTool, GetGameScoresTool, StopGameTrackingTool } from "./tools/GameScoreTrackerTool";
 
 
 // Initialize skill with tools
@@ -17,7 +58,8 @@ const generalSkill = new LuaSkill({
     context: "This skill provides various utilities including weather information, user data retrieval, post creation, basic calculator operations, and advanced mathematical functions. Use get_weather to fetch current weather conditions for any city, get_user_data to retrieve user information, create_post to publish new posts, calculator for basic arithmetic operations, and advanced_math for complex mathematical computations like factorials, prime checking, fibonacci sequences, and greatest common divisor calculations.",
     tools: [
         new GetWeatherTool(),
-        new CreatePostTool()
+        new CreatePostTool(),
+        new CreateInlineJobTool()
     ]
 });
 
@@ -120,6 +162,65 @@ const testCases = [
     { tool: "get_weather", cityLong: "London", apiKey: "123" }
 ];
 
+const job = new LuaJob({
+    description: "Test job",
+    context: "Test job context",
+    name: "test-job",
+    schedule: {
+        type: "once",
+        executeAt: new Date(Date.now() + 1000).toISOString()
+    },
+    metadata: {
+        test: "test"
+    },
+    execute: async (job: JobInstance) => {
+        console.log("Job executed");
+        return { success: true, message: "Job executed successfully" };
+    }
+});
+
+//create webhook
+const webhook = new LuaWebhook({
+    description: "Test webhook",
+    context: "Test webhook context",
+    name: "test-webhook",
+    execute: async (query: any, headers: any, body: any) => {
+        console.log("Webhook executed");
+        return { success: true, message: "Webhook executed successfully" };
+    }
+});
+
+const newJob = new LuaJob({
+    description: "Test job",
+    context: "Test job context",
+    name: "test-job",
+    schedule: {
+        type: "once",
+        executeAt: new Date(Date.now() + 1000).toISOString()
+    },
+    execute: async (job: JobInstance) => {
+        console.log("Job executed", job);
+        const realtimeJob = await Jobs.create({
+            name: `realtime-job-new-this-again`,
+            description: "Realtime job",
+            schedule: {
+                type: "once",
+                executeAt: new Date(Date.now() + 1000).toISOString()
+            },
+            execute: async (job: JobInstance) => {
+                // console.log("Executing realtime job", job.data);
+                console.log("Realtime job metadata", job.metadata);
+                console.log("Realtime job user", job.user);
+                return { success: true, message: "Realtime job executed successfully" };
+            }
+        });
+        return { success: true, message: "Job executed successfully" };
+    }
+});
+
+
+console.log("Job created:", job);
+
 async function runTests() {
     // await seedProducts();
     console.log("🧪 Running tool tests...\n");

package/template/src/jobs/AbandonedBasketProcessorJob.ts

@@ -0,0 +1,139 @@
+/**
+ * Abandoned Basket Processor Job
+ * 
+ * This job runs every 15 minutes to process basket checkout reminders.
+ * Works together with CreateSmartBasketTool to send abandoned cart notifications.
+ * 
+ * Flow:
+ * 1. User creates basket → Tool schedules reminder in custom data
+ * 2. This job runs every 15 minutes
+ * 3. Checks which reminders are due
+ * 4. Checks if baskets were checked out
+ * 5. Sends reminders for abandoned baskets
+ */
+
+import { LuaJob, Data, Baskets } from "lua-cli";
+
+const abandonedBasketProcessorJob = new LuaJob({
+  name: "process-basket-reminders",
+  version: "1.0.0",
+  description: "Processes abandoned basket reminders",
+  context: "Runs every 15 minutes to check for abandoned baskets and send recovery emails. " +
+           "Works with basket creation tools that schedule reminders.",
+
+  // Run every 15 minutes
+  schedule: {
+    type: 'interval',
+    seconds: 900  // 15 minutes = 900 seconds
+  },
+
+  timeout: 120,  // 2 minutes
+
+  execute: async () => {
+    console.log('🔍 Processing basket reminders...');
+
+    // Get all pending reminders
+    const remindersResponse = await Data.get('basket-reminders', {}, 1, 500);
+    const reminders = remindersResponse.data || [];
+    const now = new Date();
+
+    let processedCount = 0;
+    let abandonedCount = 0;
+    let checkedOutCount = 0;
+
+    for (const reminder of reminders) {
+      // Skip if not yet time
+      const scheduledTime = new Date(reminder.data.scheduledFor);
+      if (scheduledTime > now) continue;
+
+      // Skip if already processed
+      if (reminder.data.status !== 'pending') continue;
+
+      try {
+        // Get the basket
+        const basketInstance = await Baskets.getById(reminder.data.basketId);
+        const basket = await basketInstance.getData();
+
+        // Check basket status
+        const isAbandoned = basket.status === 'active';
+
+        if (isAbandoned) {
+          // Basket is abandoned - send reminder
+          console.log(`🛒 Abandoned basket found: ${basket.id}`);
+          abandonedCount++;
+
+          // Calculate basket value
+          const totalValue = basket.items?.reduce((sum: number, item: any) => {
+            return sum + (item.price * item.quantity);
+          }, 0) || 0;
+
+          // Log abandoned basket
+          await Data.create('abandoned-baskets', {
+            basketId: basket.id,
+            currency: basket.currency,
+            itemCount: basket.items?.length || 0,
+            totalValue,
+            items: basket.items,
+            abandonedAt: new Date().toISOString(),
+            reminderSent: true
+          });
+
+          // Update reminder status
+          await Data.update('basket-reminders', reminder.id, {
+            ...reminder.data,
+            status: 'completed',
+            result: 'abandoned',
+            processedAt: new Date().toISOString()
+          });
+
+          // TODO: Send actual reminder email/SMS
+          console.log(`📧 Would send reminder: "You left ${basket.items?.length || 0} items in your cart!"`);
+
+        } else {
+          // Basket was checked out
+          console.log(`✅ Basket ${basket.id} was checked out (${basket.status})`);
+          checkedOutCount++;
+
+          // Update reminder status
+          await Data.update('basket-reminders', reminder.id, {
+            ...reminder.data,
+            status: 'completed',
+            result: 'checked-out',
+            processedAt: new Date().toISOString()
+          });
+        }
+
+        processedCount++;
+
+      } catch (error) {
+        console.error(`❌ Error processing basket ${reminder.data.basketId}:`, error);
+        
+        // Mark as error
+        try {
+          await Data.update('basket-reminders', reminder.id, {
+            ...reminder.data,
+            status: 'error',
+            error: String(error),
+            processedAt: new Date().toISOString()
+          });
+        } catch (updateError) {
+          console.error('Failed to update reminder status:', updateError);
+        }
+      }
+    }
+
+    console.log('✅ Reminder processing complete');
+    console.log(`📊 Processed: ${processedCount}, Abandoned: ${abandonedCount}, Checked out: ${checkedOutCount}`);
+
+    return {
+      success: true,
+      processedCount,
+      abandonedCount,
+      checkedOutCount,
+      timestamp: new Date().toISOString()
+    };
+  }
+});
+
+export default abandonedBasketProcessorJob;
+

package/template/src/jobs/DailyCleanupJob.ts

@@ -0,0 +1,100 @@
+/**
+ * Daily Cleanup Job Example
+ * 
+ * This job runs daily at 2 AM to clean up old data and maintain database performance.
+ * Demonstrates: Cron scheduling, data cleanup, and error handling.
+ */
+
+import { LuaJob, Data } from "lua-cli";
+
+const dailyCleanupJob = new LuaJob({
+  name: "daily-cleanup",
+  version: "1.0.0",
+  description: "Daily database cleanup and maintenance",
+  context: "Runs at 2 AM EST daily to remove old logs, expired sessions, and optimize data collections. " +
+           "This job helps maintain database performance and storage costs.",
+
+  // Cron schedule: Every day at 2 AM EST
+  schedule: {
+    type: 'cron',
+    expression: '0 2 * * *',  // minute hour day month day-of-week
+    timezone: 'America/New_York'
+  },
+
+  // Give it 10 minutes to complete
+  timeout: 600,
+
+  // Retry up to 3 times if it fails
+  retry: {
+    maxAttempts: 3,
+    backoffSeconds: 60  // Wait 60s between retries
+  },
+
+  execute: async () => {
+    console.log('🧹 Starting daily cleanup...');
+    const startTime = Date.now();
+
+    let totalRecordsDeleted = 0;
+
+    // 1. Clean up old user events (older than 90 days)
+    const ninetyDaysAgo = new Date(Date.now() - 90 * 24 * 60 * 60 * 1000);
+    
+    try {
+      const oldEventsResponse = await Data.get('user-events', {}, 1, 1000);
+      const oldEvents = oldEventsResponse.data || [];
+      
+      for (const event of oldEvents) {
+        const eventDate = new Date(event.data.receivedAt);
+        if (eventDate < ninetyDaysAgo) {
+          await Data.delete('user-events', event.id);
+          totalRecordsDeleted++;
+        }
+      }
+      
+      console.log(`✅ Deleted ${totalRecordsDeleted} old user events`);
+    } catch (error) {
+      console.error('❌ Error cleaning user events:', error);
+    }
+
+    // 2. Clean up old payment logs (older than 180 days)
+    const oneEightyDaysAgo = new Date(Date.now() - 180 * 24 * 60 * 60 * 1000);
+    
+    try {
+      const oldLogsResponse = await Data.get('payment-logs', {}, 1, 1000);
+      const oldLogs = oldLogsResponse.data || [];
+      let logsDeleted = 0;
+      
+      for (const log of oldLogs) {
+        const logDate = new Date(log.data.receivedAt);
+        if (logDate < oneEightyDaysAgo) {
+          await Data.delete('payment-logs', log.id);
+          logsDeleted++;
+          totalRecordsDeleted++;
+        }
+      }
+      
+      console.log(`✅ Deleted ${logsDeleted} old payment logs`);
+    } catch (error) {
+      console.error('❌ Error cleaning payment logs:', error);
+    }
+
+    // 3. Clean up abandoned baskets (older than 7 days)
+    // Note: This would require basket API support for deletion
+    // For now, we'll just log the count
+    
+    const duration = Date.now() - startTime;
+    
+    console.log(`✅ Cleanup complete in ${duration}ms`);
+
+    return {
+      success: true,
+      recordsDeleted: totalRecordsDeleted,
+      duration: `${duration}ms`,
+      completedAt: new Date().toISOString(),
+      collections: ['user-events', 'payment-logs']
+    };
+  }
+});
+
+export default dailyCleanupJob;
+

package/template/src/jobs/DataMigrationJob.ts

@@ -0,0 +1,133 @@
+/**
+ * Data Migration Job Example
+ * 
+ * This is a one-time job that runs at a specific date/time to migrate data.
+ * Demonstrates: One-time scheduling, data migration, and batch processing.
+ */
+
+import { LuaJob, Data } from "lua-cli";
+
+const dataMigrationJob = new LuaJob({
+  name: "migrate-user-schema",
+  version: "1.0.0",
+  description: "One-time migration to new user event schema",
+  context: "Scheduled one-time task to migrate user events from old schema to new schema. " +
+           "Runs once at the specified time and then automatically deactivates.",
+
+  // One-time schedule: Run at specific date/time
+  schedule: {
+    type: 'once',
+    executeAt: new Date('2025-12-31T02:00:00Z')  // December 31, 2025 at 2 AM UTC
+  },
+
+  // Give it 30 minutes for large migration
+  timeout: 1800,
+
+  // Retry important migrations
+  retry: {
+    maxAttempts: 3,
+    backoffSeconds: 300  // 5 minutes between retries
+  },
+
+  execute: async () => {
+    console.log('🔄 Starting data migration...');
+    const startTime = Date.now();
+
+    let totalMigrated = 0;
+    let totalErrors = 0;
+
+    try {
+      // Get all user events with old schema
+      const oldEventsResponse = await Data.get('user-events', {}, 1, 1000);
+      const oldEvents = oldEventsResponse.data || [];
+      
+      console.log(`📊 Found ${oldEvents.length} events to migrate`);
+
+      // Migrate each event
+      for (const event of oldEvents) {
+        try {
+          // Transform old schema to new schema
+          const migratedEvent = {
+            // New fields
+            eventId: event.id,
+            eventType: event.data.type || 'unknown',
+            userId: event.data.userId || event.data.user_id,  // Handle both formats
+            email: event.data.email,
+            name: event.data.name,
+            
+            // Preserve metadata
+            metadata: {
+              ...event.data.metadata,
+              migratedFrom: 'old-schema',
+              migratedAt: new Date().toISOString()
+            },
+            
+            // Copy timestamps
+            originalTimestamp: event.data.timestamp,
+            receivedAt: event.data.receivedAt
+          };
+
+          // Create in new collection
+          await Data.create('user-events-v2', migratedEvent, 
+            `${migratedEvent.eventType} ${migratedEvent.email}`
+          );
+
+          totalMigrated++;
+
+          // Log progress every 100 records
+          if (totalMigrated % 100 === 0) {
+            console.log(`✅ Migrated ${totalMigrated} records...`);
+          }
+
+        } catch (error) {
+          console.error(`❌ Failed to migrate event ${event.id}:`, error);
+          totalErrors++;
+        }
+      }
+
+      const duration = Date.now() - startTime;
+      const successRate = ((totalMigrated / oldEvents.length) * 100).toFixed(2);
+
+      console.log(`✅ Migration complete!`);
+      console.log(`📊 Stats:`);
+      console.log(`   - Total records: ${oldEvents.length}`);
+      console.log(`   - Migrated: ${totalMigrated}`);
+      console.log(`   - Errors: ${totalErrors}`);
+      console.log(`   - Success rate: ${successRate}%`);
+      console.log(`   - Duration: ${duration}ms`);
+
+      // Store migration report
+      await Data.create('migration-reports', {
+        jobName: 'migrate-user-schema',
+        totalRecords: oldEvents.length,
+        migrated: totalMigrated,
+        errors: totalErrors,
+        successRate: parseFloat(successRate),
+        duration,
+        completedAt: new Date().toISOString()
+      });
+
+      return {
+        success: true,
+        totalRecords: oldEvents.length,
+        migrated: totalMigrated,
+        errors: totalErrors,
+        successRate: `${successRate}%`,
+        duration: `${duration}ms`
+      };
+
+    } catch (error) {
+      console.error('💥 Migration failed:', error);
+      
+      return {
+        success: false,
+        error: String(error),
+        totalMigrated,
+        totalErrors
+      };
+    }
+  }
+});
+
+export default dataMigrationJob;
+

package/template/src/jobs/HealthCheckJob.ts

@@ -0,0 +1,87 @@
+/**
+ * Health Check Job Example
+ * 
+ * This job runs every 5 minutes to check system health and alert on issues.
+ * Demonstrates: Interval scheduling, monitoring, and alerting.
+ */
+
+import { LuaJob, Data, Products } from "lua-cli";
+
+const healthCheckJob = new LuaJob({
+  name: "health-check",
+  version: "1.0.0",
+  description: "System health monitoring",
+  context: "Runs every 5 minutes to check API health, database connectivity, and service availability. " +
+           "Logs health metrics and can trigger alerts if issues are detected.",
+
+  // Interval schedule: Every 5 minutes
+  schedule: {
+    type: 'interval',
+    seconds: 300  // 5 minutes = 300 seconds
+  },
+
+  // Quick timeout for health checks
+  timeout: 30,
+
+  execute: async () => {
+    console.log('❤️ Running health check...');
+    const checks: any = {};
+
+    // Check 1: Database connectivity
+    try {
+      const testQuery = await Data.get('health-checks', {}, 1, 1);
+      checks.database = {
+        status: 'healthy',
+        responseTime: Date.now()
+      };
+    } catch (error) {
+      checks.database = {
+        status: 'unhealthy',
+        error: String(error)
+      };
+    }
+
+    // Check 2: Products API
+    try {
+      const startTime = Date.now();
+      await Products.get(1, 1);
+      const responseTime = Date.now() - startTime;
+      
+      checks.productsApi = {
+        status: 'healthy',
+        responseTime: `${responseTime}ms`
+      };
+    } catch (error) {
+      checks.productsApi = {
+        status: 'unhealthy',
+        error: String(error)
+      };
+    }
+
+    // Determine overall health
+    const allHealthy = Object.values(checks).every((check: any) => check.status === 'healthy');
+    const overallStatus = allHealthy ? 'healthy' : 'degraded';
+
+    // Log health check result
+    await Data.create('health-checks', {
+      status: overallStatus,
+      checks,
+      timestamp: new Date().toISOString()
+    });
+
+    // Alert if unhealthy (in production, send to monitoring service)
+    if (!allHealthy) {
+      console.warn('⚠️ System health degraded:', checks);
+      // TODO: Send alert to monitoring service
+    }
+
+    return {
+      status: overallStatus,
+      checks,
+      timestamp: new Date().toISOString()
+    };
+  }
+});
+
+export default healthCheckJob;
+

package/template/src/tools/CreateInlineJob.ts

@@ -0,0 +1,42 @@
+import { LuaTool } from "lua-cli/skill";
+import { z } from "zod";
+import { AI, JobInstance, Jobs } from "../../../dist/api-exports";
+import ApiService from "../services/ApiService";
+import { v4 as uuidv4 } from 'uuid';
+
+export default class CreateInlineJobTool implements LuaTool {
+    name = "create_inline_job";
+    description = "Create a new inline job";
+    inputSchema = z.object({});
+
+    async execute(input: z.infer<typeof this.inputSchema>) {
+        const jobId = uuidv4();
+        const job = await Jobs.create({
+            name: `inline-job-${jobId}`,
+            description: "Inline job",
+            schedule: {
+                type: "once",
+                executeAt: new Date(Date.now() + 1000)
+            },
+            metadata: {
+                test: "test"
+            },
+            execute: async (job: JobInstance) => {
+                // console.log("Executing inline job", job);
+                console.log("Inline job metadata", job.metadata);
+                console.log("Inline job user", job.user());
+                console.log("Inline job data", job.data);
+                const response = await AI.generate("You are a poet. Write a poem about the following topic:", [{ type: "text", text: "A sheep in the field" }]);
+                console.log("AI response", response);
+                const apiService = new ApiService();
+                const data = await apiService.fetchUserData("123");
+                await job.updateMetadata({ test: "test2" });
+                const disabled = await job.delete();
+                console.log("Inline job deleted", disabled);
+                return { success: true, data: response, user: data };
+            }
+        });
+
+        return { success: true, job: job };
+    }
+}