lua-cli 3.13.0 → 3.14.0

package/template/examples/preprocessors/messageMatching.ts

@@ -1,35 +1,34 @@
-import { ChatMessage, PreProcessor, PreProcessorResult, UserDataInstance } from "lua-cli";
-
+import { ChatMessage, PreProcessor, PreProcessorResult, UserDataInstance } from 'lua-cli';
 
 const messageMatchingPreProcessor = new PreProcessor({
-    name: "message-matching",
-    description: "Matches the message to the appropriate skill",
-    execute: async (user: UserDataInstance, messages: ChatMessage[], channel: string): Promise<PreProcessorResult> => {
-        console.log("Message matching pre processor", user, messages, channel);
-        console.log("User data", await user.data);
-        console.log("Messages", messages);
-        console.log("Channel", channel);
-        
-        //check if message type text contains test and return the message
-        const testMessage = messages.find((message) => message.type === "text" && message.text.includes("test"));
-        if (testMessage) {
-            return {
-                action: 'proceed',
-                modifiedMessage: [{ type: "text", text: "Tell the user that you got their test message and nothing else" }]
-            };
-        }
-        
-        // Example blocking logic
-        const shouldBlock = messages.some((message) => message.type === "text" && message.text.includes("block"));
-        if (shouldBlock) {
-            return {
-                action: 'block',
-                response: "Message blocked by preprocessor"
-            };
-        }
+  name: 'message-matching',
+  description: 'Matches the message to the appropriate skill',
+  execute: async (user: UserDataInstance, messages: ChatMessage[], channel: string): Promise<PreProcessorResult> => {
+    console.log('Message matching pre processor', user, messages, channel);
+    console.log('User data', await user.data);
+    console.log('Messages', messages);
+    console.log('Channel', channel);
+
+    //check if message type text contains test and return the message
+    const testMessage = messages.find((message) => message.type === 'text' && message.text.includes('test'));
+    if (testMessage) {
+      return {
+        action: 'proceed',
+        modifiedMessage: [{ type: 'text', text: 'Tell the user that you got their test message and nothing else' }],
+      };
+    }
 
-        return { action: 'proceed' };
+    // Example blocking logic
+    const shouldBlock = messages.some((message) => message.type === 'text' && message.text.includes('block'));
+    if (shouldBlock) {
+      return {
+        action: 'block',
+        response: 'Message blocked by preprocessor',
+      };
     }
+
+    return { action: 'proceed' };
+  },
 });
 
-export default messageMatchingPreProcessor;
+export default messageMatchingPreProcessor;

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);
+  }
 }