lua-cli 3.13.0 → 3.14.1

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

@@ -1,51 +1,51 @@
-import { LuaTool, env } from "lua-cli";
-import { z } from "zod";
+import { LuaTool, env } from 'lua-cli';
+import { z } from 'zod';
 
 export default class CreatePaymentLinkTool implements LuaTool {
-    name = "create_payment_link";
-    description = "Create a Stripe payment link for a one-time payment";
-    inputSchema = z.object({
-        amount: z.number().int().positive(), // in cents
-        currency: z.string().default("usd")
-    });
-    outputSchema = z.object({
-        url: z.string(),
-        id: z.string(),
-    });
+  name = 'create_payment_link';
+  description = 'Create a Stripe payment link for a one-time payment';
+  inputSchema = z.object({
+    amount: z.number().int().positive(), // in cents
+    currency: z.string().default('usd'),
+  });
+  outputSchema = z.object({
+    url: z.string(),
+    id: z.string(),
+  });
 
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        const apiKey = env("STRIPE_SECRET_KEY");
-        if (!apiKey) {
-            throw new Error("STRIPE_SECRET_KEY is not set in environment variables");
-        }
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    const apiKey = env('STRIPE_SECRET_KEY');
+    if (!apiKey) {
+      throw new Error('STRIPE_SECRET_KEY is not set in environment variables');
+    }
 
-        // Create a one-time Checkout Session with dummy redirect URLs
-        const sessionRes = await fetch("https://api.stripe.com/v1/checkout/sessions", {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-                "Content-Type": "application/x-www-form-urlencoded",
-            },
-            body: new URLSearchParams({
-                mode: "payment",
-                "line_items[0][price_data][currency]": input.currency,
-                "line_items[0][price_data][product_data][name]": "One-time Payment",
-                "line_items[0][price_data][unit_amount]": input.amount.toString(),
-                "line_items[0][quantity]": "1",
-                success_url: "https://example.com/success",
-                cancel_url: "https://example.com/cancel",
-            }),
-        });
+    // Create a one-time Checkout Session with dummy redirect URLs
+    const sessionRes = await fetch('https://api.stripe.com/v1/checkout/sessions', {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: new URLSearchParams({
+        mode: 'payment',
+        'line_items[0][price_data][currency]': input.currency,
+        'line_items[0][price_data][product_data][name]': 'One-time Payment',
+        'line_items[0][price_data][unit_amount]': input.amount.toString(),
+        'line_items[0][quantity]': '1',
+        success_url: 'https://example.com/success',
+        cancel_url: 'https://example.com/cancel',
+      }),
+    });
 
-        if (!sessionRes.ok) {
-            throw new Error(`Failed to create checkout session: ${await sessionRes.text()}`);
-        }
+    if (!sessionRes.ok) {
+      throw new Error(`Failed to create checkout session: ${await sessionRes.text()}`);
+    }
 
-        const session = await sessionRes.json();
+    const session = await sessionRes.json();
 
-        return {
-            url: session.url,
-            id: session.id,
-        };
-    }
+    return {
+      url: session.url,
+      id: session.id,
+    };
+  }
 }

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

@@ -1,98 +1,100 @@
-import { LuaTool, Products, User } from "lua-cli";
-import { z } from "zod";
+import { LuaTool, Products, User } from 'lua-cli';
+import { z } from 'zod';
 
 /**
  * Example tool with a condition.
- * 
+ *
  * The `condition` function determines if this tool should be available to the LLM.
  * It runs BEFORE the tool is offered, so the LLM won't see this tool if condition returns false.
- * 
+ *
  * Use cases:
  * - Premium/paid features only for subscribed users
  * - Features based on user verification status
  * - Region-specific tools
  * - A/B testing tool availability
  * - Time-based feature access
- * 
+ *
  * The condition has access to all Platform APIs: User, Data, Products, Baskets, Orders, etc.
  */
 export default class PremiumFeatureTool implements LuaTool {
-    name = "premium_advanced_search";
-    description = "Advanced search with filters and sorting - available to premium users only";
-    
-    inputSchema = z.object({
-        query: z.string().describe("Search query"),
-        filters: z.object({
-            category: z.string().optional().describe("Filter by category"),
-            minPrice: z.number().optional().describe("Minimum price filter"),
-            maxPrice: z.number().optional().describe("Maximum price filter"),
-        }).optional().describe("Optional filters"),
-        sortBy: z.enum(["relevance", "price_asc", "price_desc"]).optional().describe("Sort order")
-    });
+  name = 'premium_advanced_search';
+  description = 'Advanced search with filters and sorting - available to premium users only';
 
-    /**
-     * Condition function - determines if this tool should be available.
-     * 
-     * This runs once per request when tools are being built.
-     * Return true to enable the tool, false to hide it from the LLM.
-     * 
-     * If condition throws an error, the tool is disabled (fail-closed behavior).
-     */
-    condition = async () => {
-        // Get the current user's data (returns null when called outside a conversation)
-        const user = await User.get();
-        if (!user) return false;
-        
-        // Check if user has premium subscription
-        // The 'data' field contains custom user data stored via User.update()
-        const isPremium = user.data?.subscription === "premium" || user.data?.isPremium === true;
-        
-        // You can also check other conditions:
-        // - user.data?.trialEndsAt > Date.now() (trial period)
-        // - user.country?.code === "US" (region-based)
-        // - user.data?.featureFlags?.advancedSearch (feature flags)
-        
-        return isPremium;
-    };
+  inputSchema = z.object({
+    query: z.string().describe('Search query'),
+    filters: z
+      .object({
+        category: z.string().optional().describe('Filter by category'),
+        minPrice: z.number().optional().describe('Minimum price filter'),
+        maxPrice: z.number().optional().describe('Maximum price filter'),
+      })
+      .optional()
+      .describe('Optional filters'),
+    sortBy: z.enum(['relevance', 'price_asc', 'price_desc']).optional().describe('Sort order'),
+  });
+
+  /**
+   * Condition function - determines if this tool should be available.
+   *
+   * This runs once per request when tools are being built.
+   * Return true to enable the tool, false to hide it from the LLM.
+   *
+   * If condition throws an error, the tool is disabled (fail-closed behavior).
+   */
+  condition = async () => {
+    // Get the current user's data (returns null when called outside a conversation)
+    const user = await User.get();
+    if (!user) return false;
+
+    // Check if user has premium subscription
+    // The 'data' field contains custom user data stored via User.update()
+    const isPremium = user.data?.subscription === 'premium' || user.data?.isPremium === true;
 
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        // This only runs if condition returned true
-        const { query, filters, sortBy } = input;
-        
-        // Products.search(query) — returns ProductSearchInstance (iterable, has .products)
-        const searchResult = await Products.search(query);
-        const products = searchResult.products;
-        
-        // Apply filters client-side
-        let filteredResults = products;
+    // You can also check other conditions:
+    // - user.data?.trialEndsAt > Date.now() (trial period)
+    // - user.country?.code === "US" (region-based)
+    // - user.data?.featureFlags?.advancedSearch (feature flags)
 
-        if (filters?.category) {
-            filteredResults = filteredResults.filter(p => p.category === filters.category);
-        }
+    return isPremium;
+  };
 
-        if (filters?.minPrice !== undefined || filters?.maxPrice !== undefined) {
-            filteredResults = filteredResults.filter((product) => {
-                const price = product.price || 0;
-                if (filters.minPrice !== undefined && price < filters.minPrice) return false;
-                if (filters.maxPrice !== undefined && price > filters.maxPrice) return false;
-                return true;
-            });
-        }
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    // This only runs if condition returned true
+    const { query, filters, sortBy } = input;
 
-        // Sort client-side when requested
-        if (sortBy === "price_asc") {
-            filteredResults = [...filteredResults].sort((a, b) => (a.price || 0) - (b.price || 0));
-        } else if (sortBy === "price_desc") {
-            filteredResults = [...filteredResults].sort((a, b) => (b.price || 0) - (a.price || 0));
-        }
-        
-        return {
-            query,
-            totalResults: filteredResults.length,
-            results: filteredResults.slice(0, 10), // Return top 10
-            appliedFilters: filters,
-            sortedBy: sortBy || "relevance"
-        };
+    // Products.search(query) — returns ProductSearchInstance (iterable, has .products)
+    const searchResult = await Products.search(query);
+    const products = searchResult.products;
+
+    // Apply filters client-side
+    let filteredResults = products;
+
+    if (filters?.category) {
+      filteredResults = filteredResults.filter((p) => p.category === filters.category);
     }
-}
 
+    if (filters?.minPrice !== undefined || filters?.maxPrice !== undefined) {
+      filteredResults = filteredResults.filter((product) => {
+        const price = product.price || 0;
+        if (filters.minPrice !== undefined && price < filters.minPrice) return false;
+        if (filters.maxPrice !== undefined && price > filters.maxPrice) return false;
+        return true;
+      });
+    }
+
+    // Sort client-side when requested
+    if (sortBy === 'price_asc') {
+      filteredResults = [...filteredResults].sort((a, b) => (a.price || 0) - (b.price || 0));
+    } else if (sortBy === 'price_desc') {
+      filteredResults = [...filteredResults].sort((a, b) => (b.price || 0) - (a.price || 0));
+    }
+
+    return {
+      query,
+      totalResults: filteredResults.length,
+      results: filteredResults.slice(0, 10), // Return top 10
+      appliedFilters: filters,
+      sortedBy: sortBy || 'relevance',
+    };
+  }
+}

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(),
     };
   }
 }
-