lua-cli 3.12.2 → 3.14.0

package/template/examples/skills/tools/ProductsTool.ts

@@ -1,94 +1,93 @@
-import { LuaTool, Products } from "lua-cli";
-import { z } from "zod";
+import { LuaTool, Products } from 'lua-cli';
+import { z } from 'zod';
 import { BasketStatus, OrderStatus } from 'lua-cli';
 import { v4 as uuidv4 } from 'uuid';
 export class SearchProductsTool implements LuaTool {
-    name = "search_products";
-    description = "Search for products";
-    inputSchema = z.object({
-        query: z.string()
-    });
+  name = 'search_products';
+  description = 'Search for products';
+  inputSchema = z.object({
+    query: z.string(),
+  });
 
-    constructor() { }
+  constructor() {}
 
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return await Products.search(input.query);
-    }
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    return await Products.search(input.query);
+  }
 }
 
 export class GetAllProductsTool implements LuaTool {
-    name = "get_all_products";
-    description = "Get all products";
-    inputSchema = z.object({
-        page: z.number().optional(),
-        limit: z.number().optional()
-    });
-
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return await Products.get(input.page, input.limit);
-    }
+  name = 'get_all_products';
+  description = 'Get all products';
+  inputSchema = z.object({
+    page: z.number().optional(),
+    limit: z.number().optional(),
+  });
+
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    return await Products.get(input.page, input.limit);
+  }
 }
 
 export class CreateProductTool implements LuaTool {
-    name = "create_product";
-    description = "Create a new product";
-    inputSchema = z.object({
-        product: z.object({
-            name: z.string(),
-            description: z.string(),
-            price: z.number()
-        })
-    });
-
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return Products.create({ ...input.product, id: uuidv4() });
-    }
+  name = 'create_product';
+  description = 'Create a new product';
+  inputSchema = z.object({
+    product: z.object({
+      name: z.string(),
+      description: z.string(),
+      price: z.number(),
+    }),
+  });
+
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    return Products.create({ ...input.product, id: uuidv4() });
+  }
 }
 
 export class UpdateProductTool implements LuaTool {
-    name = "update_product";
-    description = "Update an existing product";
-    inputSchema = z.object({
-        product: z.object({
-            id: z.string(),
-            name: z.string(),
-            description: z.string(),
-            price: z.number()
-        })
-    });
-
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        const product = await Products.getById(input.product.id);
-        return product.update({ ...input.product });
-    }
+  name = 'update_product';
+  description = 'Update an existing product';
+  inputSchema = z.object({
+    product: z.object({
+      id: z.string(),
+      name: z.string(),
+      description: z.string(),
+      price: z.number(),
+    }),
+  });
+
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    const product = await Products.getById(input.product.id);
+    return product.update({ ...input.product });
+  }
 }
 
 export class GetProductByIdTool implements LuaTool {
-    name = "get_product_by_id";
-    description = "Get a product by its unique identifier";
-    inputSchema = z.object({
-        id: z.string()
-    });
-
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return Products.getById(input.id);
-    }
+  name = 'get_product_by_id';
+  description = 'Get a product by its unique identifier';
+  inputSchema = z.object({
+    id: z.string(),
+  });
+
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    return Products.getById(input.id);
+  }
 }
 
 export class DeleteProductTool implements LuaTool {
-    name = "delete_product";
-    description = "Delete an existing product";
-    inputSchema = z.object({
-        id: z.string()
-    });
-
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        const product = await Products.getById(input.id);
-        return product.delete();
-    }
+  name = 'delete_product';
+  description = 'Delete an existing product';
+  inputSchema = z.object({
+    id: z.string(),
+  });
+
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    const product = await Products.getById(input.id);
+    return product.delete();
+  }
 }
 
-
 // export class CreateOrderTool implements LuaTool {
 //     name = "create_order";
 //     description = "Create a new order";

package/template/examples/skills/tools/SmartBasketTool.ts

@@ -1,21 +1,21 @@
 /**
  * Smart Basket Tool Example
- * 
+ *
  * This tool creates a basket AND schedules a follow-up job to check if it was abandoned.
  * Demonstrates: Dynamic job creation, basket management, and automated follow-ups.
- * 
+ *
  * Use case: E-commerce abandoned cart recovery
  */
 
-import { LuaTool, Baskets, Jobs, Data } from "lua-cli";
-import { z } from "zod";
+import { LuaTool, Baskets, Jobs, Data } from 'lua-cli';
+import { z } from 'zod';
 
 export class CreateSmartBasketTool implements LuaTool {
-  name = "create_smart_basket";
-  description = "Creates a basket with automatic abandoned cart reminder";
-  
+  name = 'create_smart_basket';
+  description = 'Creates a basket with automatic abandoned cart reminder';
+
   inputSchema = z.object({
-    currency: z.string().default('USD')
+    currency: z.string().default('USD'),
   });
 
   async execute(input: { currency: string }) {
@@ -27,8 +27,8 @@ export class CreateSmartBasketTool implements LuaTool {
       metadata: {
         createdBy: 'smart-basket-tool',
         reminderScheduled: true,
-        createdAt: new Date().toISOString()
-      }
+        createdAt: new Date().toISOString(),
+      },
     };
 
     const basketInstance = await Baskets.create(basketData);
@@ -43,38 +43,38 @@ export class CreateSmartBasketTool implements LuaTool {
     const basketId = basketInfo.id;
 
     // Create a dynamic one-time job using the Jobs API!
-    
+
     const job = await Jobs.create({
       name: `check-basket-${basketId}`,
       description: `Check if basket ${basketId} was checked out`,
-      
+
       // One-time job that runs in 3 hours
       schedule: {
         type: 'once',
-        executeAt: checkTime
+        executeAt: checkTime,
       },
-      
-      timeout: 60,  // 1 minute timeout
-      
+
+      timeout: 60, // 1 minute timeout
+
       // Write normal TypeScript code! It will be compiled automatically
       execute: async () => {
         console.log(`⏰ Checking basket ${basketId}...`);
-        
+
         const basketInstance = await Baskets.getById(basketId);
         const basket = await basketInstance.getData();
-        
+
         if (basket.status === 'active' || basket.status === 'pending') {
           // Basket is still active - it was abandoned!
           console.log(`🛒 Basket ${basketId} was abandoned`);
-          
+
           await Data.create('abandoned-baskets', {
             basketId: basketId,
             currency: basket.currency,
             itemCount: basket.items?.length || 0,
             totalValue: basket.total || 0,
-            abandonedAt: new Date().toISOString()
+            abandonedAt: new Date().toISOString(),
           });
-          
+
           console.log('📧 Sending abandoned cart reminder email...');
           // TODO: Integrate with email service
           // await sendEmail({
@@ -82,21 +82,21 @@ export class CreateSmartBasketTool implements LuaTool {
           //   template: 'abandoned-cart',
           //   data: { basket }
           // });
-          
-          return { 
-            abandoned: true, 
+
+          return {
+            abandoned: true,
             basketId: basketId,
-            reminderSent: true 
+            reminderSent: true,
           };
         }
-        
+
         console.log(`✅ Basket ${basketId} was checked out`);
-        return { 
-          abandoned: false, 
+        return {
+          abandoned: false,
           basketId: basketId,
-          status: basket.status 
+          status: basket.status,
         };
-      }
+      },
     });
 
     console.log(`⏰ One-time job created: ${job.jobId}`);
@@ -108,29 +108,29 @@ export class CreateSmartBasketTool implements LuaTool {
       basket: {
         id: basketInfo.id,
         currency: basketInfo.currency,
-        status: basketInfo.status
+        status: basketInfo.status,
       },
       scheduledJob: {
         jobId: job.jobId,
         name: job.name,
         scheduledFor: checkTime.toISOString(),
-        message: 'One-time job will check basket in 3 hours'
-      }
+        message: 'One-time job will check basket in 3 hours',
+      },
     };
   }
 }
 
 /**
  * Check Abandoned Baskets Tool
- * 
+ *
  * This tool can be called manually or by a recurring job to check for abandoned baskets.
  */
 export class CheckAbandonedBasketsTool implements LuaTool {
-  name = "check_abandoned_baskets";
-  description = "Checks for abandoned baskets and sends reminders";
-  
+  name = 'check_abandoned_baskets';
+  description = 'Checks for abandoned baskets and sends reminders';
+
   inputSchema = z.object({
-    basketId: z.string().optional()
+    basketId: z.string().optional(),
   });
 
   async execute(input: { basketId?: string }) {
@@ -143,14 +143,14 @@ export class CheckAbandonedBasketsTool implements LuaTool {
     if (input.basketId) {
       // Check specific basket
       const specific = abandonedBaskets.find((ab: any) => ab.data.basketId === input.basketId);
-      
+
       if (specific) {
         return {
           basketId: input.basketId,
           abandoned: true,
           abandonedAt: specific.data.abandonedAt,
           itemCount: specific.data.itemCount,
-          totalValue: specific.data.totalValue
+          totalValue: specific.data.totalValue,
         };
       }
 
@@ -162,7 +162,7 @@ export class CheckAbandonedBasketsTool implements LuaTool {
         basketId: input.basketId,
         abandoned: false,
         status: basket.status,
-        itemCount: basket.items?.length || 0
+        itemCount: basket.items?.length || 0,
       };
     }
 
@@ -172,7 +172,7 @@ export class CheckAbandonedBasketsTool implements LuaTool {
       currency: ab.data.currency,
       itemCount: ab.data.itemCount,
       totalValue: ab.data.totalValue,
-      abandonedAt: ab.data.abandonedAt
+      abandonedAt: ab.data.abandonedAt,
     }));
 
     console.log(`🛒 Found ${abandonedBaskets.length} abandoned baskets`);
@@ -181,8 +181,7 @@ export class CheckAbandonedBasketsTool implements LuaTool {
       success: true,
       abandonedCount: abandonedBaskets.length,
       abandonedBaskets: summary,
-      timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     };
   }
 }
-

package/template/examples/skills/tools/UserDataTool.ts

@@ -1,49 +1,48 @@
-import { AI, LuaTool, User, Jobs, JobInstance } from "lua-cli";
-import { z } from "zod";
-
+import { AI, LuaTool, User, Jobs, JobInstance } from 'lua-cli';
+import { z } from 'zod';
 
 export class GetUserDataTool implements LuaTool {
-    name = "get_user_data";
-    description = "Get the user data for a given user id";
-    inputSchema = z.object({ });
+  name = 'get_user_data';
+  description = 'Get the user data for a given user id';
+  inputSchema = z.object({});
 
-    constructor() {}
+  constructor() {}
 
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        const user = await User.get();
-        return {
-            success: true,
-            message: "User data retrieved",
-            data: user.data,
-            name: user.name,
-            age: user.age
-        };
-    }
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    const user = await User.get();
+    return {
+      success: true,
+      message: 'User data retrieved',
+      data: user.data,
+      name: user.name,
+      age: user.age,
+    };
+  }
 }
 
 export class UpdateUserDataTool implements LuaTool {
-    name = "update_user_data";
-    description = "Update the user data for a given user id";
-    inputSchema = z.object({ 
-        data: z.object({
-            name: z.string().optional(),
-            age: z.number().optional()
-        })
-    });
+  name = 'update_user_data';
+  description = 'Update the user data for a given user id';
+  inputSchema = z.object({
+    data: z.object({
+      name: z.string().optional(),
+      age: z.number().optional(),
+    }),
+  });
 
-    constructor() {}
+  constructor() {}
 
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        const user = await User.get(); //get instance of user
-        user.name = input.data.name;
-        user.age = input.data.age;
-        await user.save();
-        // await user.send([{ type: "text", text: "Hello, how are you?" }]);
-        return {
-            success: true,
-            message: "User data updated"
-        };
-    }
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    const user = await User.get(); //get instance of user
+    user.name = input.data.name;
+    user.age = input.data.age;
+    await user.save();
+    // await user.send([{ type: "text", text: "Hello, how are you?" }]);
+    return {
+      success: true,
+      message: 'User data updated',
+    };
+  }
 }
 
 /**
@@ -51,72 +50,72 @@ export class UpdateUserDataTool implements LuaTool {
  * Useful for analyzing past interactions or providing context.
  */
 export class GetChatHistoryTool implements LuaTool {
-    name = "get_chat_history";
-    description = "Get the conversation history for the current user";
-    inputSchema = z.object({
-        limit: z.number().optional().describe("Maximum number of messages to retrieve")
-    });
+  name = 'get_chat_history';
+  description = 'Get the conversation history for the current user';
+  inputSchema = z.object({
+    limit: z.number().optional().describe('Maximum number of messages to retrieve'),
+  });
+
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    const history = await User.getChatHistory();
 
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        const history = await User.getChatHistory();
-        
-        // Optionally limit the results
-        const messages = input.limit ? history.slice(-input.limit) : history;
-        
-        // Format the history for easier reading
-        const formattedHistory = messages.map(msg => ({
-            role: msg.role,
-            content: msg.content,
-            createdAt: msg.createdAt,
-            id: msg.id
-        }));
-        
-        return {
-            success: true,
-            totalMessages: history.length,
-            returnedMessages: messages.length,
-            history: formattedHistory
-        };
-    }
+    // Optionally limit the results
+    const messages = input.limit ? history.slice(-input.limit) : history;
+
+    // Format the history for easier reading
+    const formattedHistory = messages.map((msg) => ({
+      role: msg.role,
+      content: msg.content,
+      createdAt: msg.createdAt,
+      id: msg.id,
+    }));
+
+    return {
+      success: true,
+      totalMessages: history.length,
+      returnedMessages: messages.length,
+      history: formattedHistory,
+    };
+  }
 }
 
 export class WritePoemTool implements LuaTool {
-    name = "write_poem";
-    description = "Write a poem about a given topic";
-    inputSchema = z.object({
-        topic: z.string()
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return await AI.generate("Write a poem about the following topic:", [{ type: "text", text: input.topic }]);
-    }
+  name = 'write_poem';
+  description = 'Write a poem about a given topic';
+  inputSchema = z.object({
+    topic: z.string(),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    return await AI.generate('Write a poem about the following topic:', [{ type: 'text', text: input.topic }]);
+  }
 }
 
 export class CreateInlineJobTool implements LuaTool {
-    name = "create-job-to-notify-user";
-    description = "Create a new job to notify the user";
-    inputSchema = z.object({
-        message: z.string()
+  name = 'create-job-to-notify-user';
+  description = 'Create a new job to notify the user';
+  inputSchema = z.object({
+    message: z.string(),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    //create a job to notify the user in exactly 20 seconds
+    const job = await Jobs.create({
+      name: 'notify-user-new',
+      description: 'Notify the user',
+      schedule: {
+        type: 'once',
+        executeAt: new Date(Date.now() + 0),
+      },
+      metadata: {
+        message: input.message,
+      },
+      execute: async (jobInstance: JobInstance) => {
+        const user = await jobInstance.user();
+        const metadata = jobInstance.metadata; //we do this to access runtime variables in the job when the job is executed
+        console.log('Metadata', metadata);
+        await user.send([{ type: 'text', text: metadata.message }]);
+        return { success: true, message: 'User notified' };
+      },
     });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        //create a job to notify the user in exactly 20 seconds
-        const job = await Jobs.create({
-            name: "notify-user-new",
-            description: "Notify the user",
-            schedule: {
-                type: "once",
-                executeAt: new Date(Date.now() + 0)
-            },
-            metadata: {
-                message: input.message
-            },
-            execute: async (jobInstance: JobInstance) => {
-                const user = await jobInstance.user();
-                const metadata = jobInstance.metadata; //we do this to access runtime variables in the job when the job is executed
-                console.log("Metadata", metadata);
-                await user.send([{ type: "text", text: metadata.message }]);
-                return { success: true, message: "User notified" };
-            }
-        });
-        return { success: true, job: job };
-    }
-}
+    return { success: true, job: job };
+  }
+}

package/template/examples/skills/user.skill.ts

@@ -1,12 +1,11 @@
-import { LuaSkill } from "lua-cli";
-import { CreateInlineJobTool, GetUserDataTool, UpdateUserDataTool, WritePoemTool } from "../skills/tools/UserDataTool";
-
+import { LuaSkill } from 'lua-cli';
+import { CreateInlineJobTool, GetUserDataTool, UpdateUserDataTool, WritePoemTool } from '../skills/tools/UserDataTool';
 
 const userSkill = new LuaSkill({
-    name: "user-skill",
-    description: "User management skill",
-    context: "User management skill",
-    tools: [new GetUserDataTool(), new UpdateUserDataTool(), new WritePoemTool(), new CreateInlineJobTool()],
+  name: 'user-skill',
+  description: 'User management skill',
+  context: 'User management skill',
+  tools: [new GetUserDataTool(), new UpdateUserDataTool(), new WritePoemTool(), new CreateInlineJobTool()],
 });
 
-export default userSkill;
+export default userSkill;