lua-cli 3.12.2 → 3.14.0

package/template/examples/services/ApiService.ts

@@ -1,71 +1,75 @@
-import axios from "axios";
+import axios from 'axios';
 
 export default class ApiService {
-    baseUrl: string;
-    timeout: number;
-    
-    constructor() {
-        this.baseUrl = "https://httpbin.org";
-        this.timeout = 5000;
-    }
+  baseUrl: string;
+  timeout: number;
 
-    async fetchUserData(userId: string) {
-        try {
-            const response = await axios.get(`${this.baseUrl}/get`, {
-                params: { userId },
-                timeout: this.timeout,
-                headers: {
-                    'Content-Type': 'application/json',
-                    'User-Agent': 'Lua-Skill/1.0'
-                }
-            });
-            
-            return {
-                id: userId,
-                name: response.data.args.userId || 'Unknown',
-                url: response.data.url,
-                status: 'success',
-                timestamp: new Date().toISOString()
-            };
-        } catch (error: any) {
-            return {
-                id: userId,
-                name: 'Unknown',
-                url: null,
-                status: 'error',
-                error: error.message,
-                timestamp: new Date().toISOString()
-            };
-        }
+  constructor() {
+    this.baseUrl = 'https://httpbin.org';
+    this.timeout = 5000;
+  }
+
+  async fetchUserData(userId: string) {
+    try {
+      const response = await axios.get(`${this.baseUrl}/get`, {
+        params: { userId },
+        timeout: this.timeout,
+        headers: {
+          'Content-Type': 'application/json',
+          'User-Agent': 'Lua-Skill/1.0',
+        },
+      });
+
+      return {
+        id: userId,
+        name: response.data.args.userId || 'Unknown',
+        url: response.data.url,
+        status: 'success',
+        timestamp: new Date().toISOString(),
+      };
+    } catch (error: any) {
+      return {
+        id: userId,
+        name: 'Unknown',
+        url: null,
+        status: 'error',
+        error: error.message,
+        timestamp: new Date().toISOString(),
+      };
     }
+  }
 
-    async createPost(title: string, content: string) {
-        try {
-            const response = await axios.post(`${this.baseUrl}/post`, {
-                title,
-                content,
-                publishedAt: new Date().toISOString()
-            }, {
-                timeout: this.timeout,
-                headers: {
-                    'Content-Type': 'application/json'
-                }
-            });
-            
-            return {
-                id: response.data.json.title || 'generated-id',
-                title: response.data.json.title,
-                status: 'created',
-                url: response.data.url
-            };
-        } catch (error: any) {
-            return {
-                id: null,
-                title,
-                status: 'error',
-                error: error.message,
-                url: null
-            };
+  async createPost(title: string, content: string) {
+    try {
+      const response = await axios.post(
+        `${this.baseUrl}/post`,
+        {
+          title,
+          content,
+          publishedAt: new Date().toISOString(),
+        },
+        {
+          timeout: this.timeout,
+          headers: {
+            'Content-Type': 'application/json',
+          },
         }
+      );
+
+      return {
+        id: response.data.json.title || 'generated-id',
+        title: response.data.json.title,
+        status: 'created',
+        url: response.data.url,
+      };
+    } catch (error: any) {
+      return {
+        id: null,
+        title,
+        status: 'error',
+        error: error.message,
+        url: null,
+      };
     }
-}
+  }
+}

package/template/examples/services/GetWeather.ts

@@ -1,40 +1,46 @@
 export interface WeatherData {
-    weather: string;
-    city: string;
-    temperature?: number;
-    humidity?: number;
-    description?: string;
+  weather: string;
+  city: string;
+  temperature?: number;
+  humidity?: number;
+  description?: string;
 }
 
 export default class GetWeatherService {
-    // Mock weather data - in a real app, this would call a weather API
-    weatherData: Record<string, WeatherData>;
+  // Mock weather data - in a real app, this would call a weather API
+  weatherData: Record<string, WeatherData>;
 
-    constructor() {
-        this.weatherData = {
-            "london": { weather: "cloudy", city: "London", temperature: 15, humidity: 80, description: "Overcast with light rain" },
-            "paris": { weather: "sunny", city: "Paris", temperature: 22, humidity: 60, description: "Clear skies" },
-            "tokyo": { weather: "rainy", city: "Tokyo", temperature: 18, humidity: 85, description: "Heavy rainfall" },
-            "new york": { weather: "sunny", city: "New York", temperature: 25, humidity: 55, description: "Partly cloudy" },
-            "sydney": { weather: "sunny", city: "Sydney", temperature: 28, humidity: 45, description: "Clear and warm" }
-        };
-    }
+  constructor() {
+    this.weatherData = {
+      london: {
+        weather: 'cloudy',
+        city: 'London',
+        temperature: 15,
+        humidity: 80,
+        description: 'Overcast with light rain',
+      },
+      paris: { weather: 'sunny', city: 'Paris', temperature: 22, humidity: 60, description: 'Clear skies' },
+      tokyo: { weather: 'rainy', city: 'Tokyo', temperature: 18, humidity: 85, description: 'Heavy rainfall' },
+      'new york': { weather: 'sunny', city: 'New York', temperature: 25, humidity: 55, description: 'Partly cloudy' },
+      sydney: { weather: 'sunny', city: 'Sydney', temperature: 28, humidity: 45, description: 'Clear and warm' },
+    };
+  }
 
-    async getWeather(city: string): Promise<WeatherData> {
-        const normalizedCity = city.toLowerCase().trim();
-        
-        // Return cached data if available, otherwise return generic response
-        const weatherInfo = this.weatherData[normalizedCity] || {
-            weather: "unknown",
-            city: city,
-            temperature: 20,
-            humidity: 50,
-            description: "Weather data not available"
-        };
+  async getWeather(city: string): Promise<WeatherData> {
+    const normalizedCity = city.toLowerCase().trim();
 
-        // Simulate API delay
-        await new Promise(resolve => setTimeout(resolve, 100));
-        
-        return weatherInfo;
-    }
-}
+    // Return cached data if available, otherwise return generic response
+    const weatherInfo = this.weatherData[normalizedCity] || {
+      weather: 'unknown',
+      city: city,
+      temperature: 20,
+      humidity: 50,
+      description: 'Weather data not available',
+    };
+
+    // Simulate API delay
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    return weatherInfo;
+  }
+}

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

@@ -1,11 +1,31 @@
-import { LuaSkill } from "lua-cli";
-import { CreateBasketTool, GetBasketByIdTool, UpdateBasketStatusTool, UpdateBasketMetadataTool, CheckoutBasketTool, GetBasketsTool, ClearBasketTool, RemoveItemFromBasketTool, AddItemToBasketTool } from "./tools/BasketTool";
+import { LuaSkill } from 'lua-cli';
+import {
+  CreateBasketTool,
+  GetBasketByIdTool,
+  UpdateBasketStatusTool,
+  UpdateBasketMetadataTool,
+  CheckoutBasketTool,
+  GetBasketsTool,
+  ClearBasketTool,
+  RemoveItemFromBasketTool,
+  AddItemToBasketTool,
+} from './tools/BasketTool';
 
 const basketSkill = new LuaSkill({
-    name: "basket-skill",
-    description: "Basket management skill",
-    context: "Basket management skill",
-    tools: [new CreateBasketTool(), new GetBasketByIdTool(), new UpdateBasketStatusTool(), new UpdateBasketMetadataTool(), new CheckoutBasketTool(), new GetBasketsTool(), new AddItemToBasketTool(), new RemoveItemFromBasketTool(), new ClearBasketTool()],
+  name: 'basket-skill',
+  description: 'Basket management skill',
+  context: 'Basket management skill',
+  tools: [
+    new CreateBasketTool(),
+    new GetBasketByIdTool(),
+    new UpdateBasketStatusTool(),
+    new UpdateBasketMetadataTool(),
+    new CheckoutBasketTool(),
+    new GetBasketsTool(),
+    new AddItemToBasketTool(),
+    new RemoveItemFromBasketTool(),
+    new ClearBasketTool(),
+  ],
 });
 
-export default basketSkill;
+export default basketSkill;

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

@@ -1,12 +1,25 @@
-import { LuaSkill } from "lua-cli";
-import { SearchProductsTool, CreateProductTool, UpdateProductTool, GetAllProductsTool, GetProductByIdTool, DeleteProductTool } from "./tools/ProductsTool";
-
+import { LuaSkill } from 'lua-cli';
+import {
+  SearchProductsTool,
+  CreateProductTool,
+  UpdateProductTool,
+  GetAllProductsTool,
+  GetProductByIdTool,
+  DeleteProductTool,
+} from './tools/ProductsTool';
 
 const productSkill = new LuaSkill({
-    name: "product-skill",
-    description: "Product management skill",
-    context: "Product management skill",
-    tools: [new SearchProductsTool(), new CreateProductTool(), new UpdateProductTool(), new GetAllProductsTool(), new GetProductByIdTool(), new DeleteProductTool()],
+  name: 'product-skill',
+  description: 'Product management skill',
+  context: 'Product management skill',
+  tools: [
+    new SearchProductsTool(),
+    new CreateProductTool(),
+    new UpdateProductTool(),
+    new GetAllProductsTool(),
+    new GetProductByIdTool(),
+    new DeleteProductTool(),
+  ],
 });
 
-export default productSkill;
+export default productSkill;

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

@@ -1,131 +1,130 @@
-import { LuaTool, Baskets } from "lua-cli";
-import { z } from "zod";
+import { LuaTool, Baskets } from 'lua-cli';
+import { z } from 'zod';
 import { BasketStatus } from 'lua-cli';
 import { v4 as uuidv4 } from 'uuid';
 
-
 export class CreateBasketTool implements LuaTool {
-    name = "create_basket";
-    description = "Create a new basket";
-    inputSchema = z.object({
-        basket: z.object({
-            currency: z.string()
-        })
-    });
+  name = 'create_basket';
+  description = 'Create a new basket';
+  inputSchema = z.object({
+    basket: z.object({
+      currency: z.string(),
+    }),
+  });
 
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return Baskets.create(input.basket);
-    }
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    return Baskets.create(input.basket);
+  }
 }
 
 export class GetBasketsTool implements LuaTool {
-    name = "get_baskets";
-    description = "Get all baskets";
-    inputSchema = z.object({
-        status: z.enum(['active', 'checked_out', 'abandoned', 'expired']).optional()
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        const baskets = await Baskets.get(input.status as BasketStatus);
-        return {
-            baskets: baskets
-        };
-    }
+  name = 'get_baskets';
+  description = 'Get all baskets';
+  inputSchema = z.object({
+    status: z.enum(['active', 'checked_out', 'abandoned', 'expired']).optional(),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    const baskets = await Baskets.get(input.status as BasketStatus);
+    return {
+      baskets: baskets,
+    };
+  }
 }
 
 export class AddItemToBasketTool implements LuaTool {
-    name = "add_item_to_basket";
-    description = "Add an item to a basket";
-    inputSchema = z.object({
-        basketId: z.string(),
-        item: z.object({
-            id: z.string(),
-            price: z.number(),
-            quantity: z.number()
-        })
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        //Get user basket
-        const userBasket = await Baskets.getById(input.basketId);
-        return userBasket.addItem(input.item);
-    }
+  name = 'add_item_to_basket';
+  description = 'Add an item to a basket';
+  inputSchema = z.object({
+    basketId: z.string(),
+    item: z.object({
+      id: z.string(),
+      price: z.number(),
+      quantity: z.number(),
+    }),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    //Get user basket
+    const userBasket = await Baskets.getById(input.basketId);
+    return userBasket.addItem(input.item);
+  }
 }
 
 export class RemoveItemFromBasketTool implements LuaTool {
-    name = "remove_item_from_basket";
-    description = "Remove an item from a basket";
-    inputSchema = z.object({
-        basketId: z.string(),
-        itemId: z.string()
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        const userBasket = await Baskets.getById(input.basketId);
-        return userBasket.removeItem(input.itemId);
-    }
+  name = 'remove_item_from_basket';
+  description = 'Remove an item from a basket';
+  inputSchema = z.object({
+    basketId: z.string(),
+    itemId: z.string(),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    const userBasket = await Baskets.getById(input.basketId);
+    return userBasket.removeItem(input.itemId);
+  }
 }
 
 export class ClearBasketTool implements LuaTool {
-    name = "clear_basket";
-    description = "Clear a basket";
-    inputSchema = z.object({
-        basketId: z.string()
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        const userBasket = await Baskets.getById(input.basketId);
-        return userBasket.clear();
-    }
+  name = 'clear_basket';
+  description = 'Clear a basket';
+  inputSchema = z.object({
+    basketId: z.string(),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    const userBasket = await Baskets.getById(input.basketId);
+    return userBasket.clear();
+  }
 }
 
 export class UpdateBasketStatusTool implements LuaTool {
-    name = "update_basket_status";
-    description = "Update the status of a basket";
-    inputSchema = z.object({
-        basketId: z.string(),
-        status: z.enum(['active', 'checked_out', 'abandoned', 'expired'])
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        const userBasket = await Baskets.getById(input.basketId);
-        return userBasket.updateStatus(input.status as BasketStatus);
-    }
+  name = 'update_basket_status';
+  description = 'Update the status of a basket';
+  inputSchema = z.object({
+    basketId: z.string(),
+    status: z.enum(['active', 'checked_out', 'abandoned', 'expired']),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    const userBasket = await Baskets.getById(input.basketId);
+    return userBasket.updateStatus(input.status as BasketStatus);
+  }
 }
 
 //update basket metadata
 export class UpdateBasketMetadataTool implements LuaTool {
-    name = "update_basket_metadata";
-    description = "Update the metadata of a basket";
-    inputSchema = z.object({
-        basketId: z.string(),
-        metadata: z.object({
-            key: z.string(),
-            value: z.string()
-        })
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        const userBasket = await Baskets.getById(input.basketId);
-        return userBasket.updateMetadata(input.metadata);
-    }
+  name = 'update_basket_metadata';
+  description = 'Update the metadata of a basket';
+  inputSchema = z.object({
+    basketId: z.string(),
+    metadata: z.object({
+      key: z.string(),
+      value: z.string(),
+    }),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    const userBasket = await Baskets.getById(input.basketId);
+    return userBasket.updateMetadata(input.metadata);
+  }
 }
 
 //check out basket
 export class CheckoutBasketTool implements LuaTool {
-    name = "checkout_basket";
-    description = "Check out a basket";
-    inputSchema = z.object({
-        basketId: z.string()
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        const userBasket = await Baskets.getById(input.basketId);
-        return userBasket.placeOrder({});
-    }
+  name = 'checkout_basket';
+  description = 'Check out a basket';
+  inputSchema = z.object({
+    basketId: z.string(),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    const userBasket = await Baskets.getById(input.basketId);
+    return userBasket.placeOrder({});
+  }
 }
 
 //get basket by id
 export class GetBasketByIdTool implements LuaTool {
-    name = "get_basket_by_id";
-    description = "Get a basket by id";
-    inputSchema = z.object({
-        basketId: z.string()
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return Baskets.getById(input.basketId);
-    }
+  name = 'get_basket_by_id';
+  description = 'Get a basket by id';
+  inputSchema = z.object({
+    basketId: z.string(),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    return Baskets.getById(input.basketId);
+  }
 }

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

@@ -1,42 +1,44 @@
-import { LuaTool } from "lua-cli";
-import { z } from "zod";
-import { AI, JobInstance, Jobs } from "../../../dist/api-exports";
-import ApiService from "../services/ApiService";
+import { LuaTool } from 'lua-cli';
+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({});
+  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 };
-            }
-        });
+  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 };
-    }
+    return { success: true, job: job };
+  }
 }