lua-cli 2.2.8-alpha.2 → 2.3.0-alpha.1

package/template/src/tools/ProductsTool.ts

@@ -1,6 +1,6 @@
-import { env, LuaTool } from "lua-cli/skill";
+import { LuaTool, Products } from "lua-cli";
 import { z } from "zod";
-import { product, BasketStatus, OrderStatus, CreateOrderRequest } from 'lua-cli/product-api';
+import { BasketStatus, OrderStatus } from 'lua-cli';
 import { v4 as uuidv4 } from 'uuid';
 export class SearchProductsTool implements LuaTool {
     name = "search_products";
@@ -12,7 +12,7 @@ export class SearchProductsTool implements LuaTool {
     constructor() {}
 
     async execute(input: z.infer<typeof this.inputSchema>) {
-        return await product.data.search(input.query);
+        return await Products.search(input.query);
     }
 }
 
@@ -25,7 +25,7 @@ export class GetAllProductsTool implements LuaTool {
     });
 
     async execute(input: z.infer<typeof this.inputSchema>) {
-        return product.data.get(input.page, input.limit);
+        return await Products.get(input.page, input.limit);
     }
 }
 
@@ -41,7 +41,7 @@ export class CreateProductTool implements LuaTool {
     });
 
     async execute(input: z.infer<typeof this.inputSchema>) {
-        return product.data.create({...input.product, id: uuidv4()});
+        return Products.create({...input.product, id: uuidv4()});
     }   
 }
 
@@ -58,133 +58,71 @@ export class UpdateProductTool implements LuaTool {
     });
 
     async execute(input: z.infer<typeof this.inputSchema>) {
-        return product.data.update({...input.product, id: uuidv4()}, input.product.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>) {
-        return product.data.delete(input.id);
+        return Products.update({...input.product, id: uuidv4()}, input.product.id);
     }
 }
 
-export class CreateBasketTool implements LuaTool {
-    name = "create_basket";
-    description = "Create a new basket";
+export class GetProductByIdTool implements LuaTool {
+    name = "get_product_by_id";
+    description = "Get a product by its unique identifier";
     inputSchema = z.object({
-        basket: z.object({
-            currency: z.string()
-        })
-    });
-
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return product.basket.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>) {
-        return product.basket.get(input.status as BasketStatus);
-    }
-}
-
-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>) {
-        return product.basket.addItem(input.basketId, 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()
+        id: z.string()
     });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return product.basket.removeItem(input.basketId, 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>) {
-        return product.basket.clear(input.basketId);
+        return Products.getById(input.id);
     }
 }
-
-export class UpdateBasketStatusTool implements LuaTool {
-    name = "update_basket_status";
-    description = "Update the status of a basket";
+    
+export class DeleteProductTool implements LuaTool {
+    name = "delete_product";
+    description = "Delete an existing product";
     inputSchema = z.object({
-        basketId: z.string(),
-        status: z.enum(['active', 'checked_out', 'abandoned', 'expired'])
+        id: z.string()
     });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return product.basket.updateStatus(input.basketId, input.status as BasketStatus);
-    }
-}
 
-export class CreateOrderTool implements LuaTool {
-    name = "create_order";
-    description = "Create a new order";
-    inputSchema = z.object({
-        order: z.object({
-            basketId: z.string(),
-            data: z.object({
-                storeId: z.string(),
-            }).optional()
-        })
-    });
     async execute(input: z.infer<typeof this.inputSchema>) {
-        return product.order.create(input.order as CreateOrderRequest);
+        const product = await Products.getById(input.id);
+        return product.delete();
     }
 }
 
-export class UpdateOrderStatusTool implements LuaTool {
-    name = "update_order_status";
-    description = "Update the status of an order";
-    inputSchema = z.object({
-        orderId: z.string(),
-        status: z.enum(['pending', 'confirmed', 'fulfilled', 'cancelled'])
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return product.order.updateStatus(input.orderId, input.status as OrderStatus);
-    }
-}
 
-export class GetUserOrdersTool implements LuaTool {
-    name = "get_user_orders";
-    description = "Get all orders for a user";
-    inputSchema = z.object({
-        userId: z.string()
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return product.order.get(input.userId);
-    }
-}
+// export class CreateOrderTool implements LuaTool {
+//     name = "create_order";
+//     description = "Create a new order";
+//     inputSchema = z.object({
+//         order: z.object({
+//             basketId: z.string(),
+//             data: z.object({
+//                 storeId: z.string(),
+//             }).optional()
+//         })
+//     });
+//     async execute(input: z.infer<typeof this.inputSchema>) {
+//         return product.order.create(input.order as CreateOrderRequest);
+//     }
+// }
+
+// export class UpdateOrderStatusTool implements LuaTool {
+//     name = "update_order_status";
+//     description = "Update the status of an order";
+//     inputSchema = z.object({
+//         orderId: z.string(),
+//         status: z.enum(['pending', 'confirmed', 'fulfilled', 'cancelled'])
+//     });
+//     async execute(input: z.infer<typeof this.inputSchema>) {
+//         return product.order.updateStatus(input.orderId, input.status as OrderStatus);
+//     }
+// }
+
+// export class GetUserOrdersTool implements LuaTool {
+//     name = "get_user_orders";
+//     description = "Get all orders for a user";
+//     inputSchema = z.object({
+//         userId: z.string()
+//     });
+//     async execute(input: z.infer<typeof this.inputSchema>) {
+//         return product.order.get(input.userId);
+//     }
+// }

package/template/src/tools/UserDataTool.ts

@@ -1,4 +1,4 @@
-import { Lua, LuaTool } from "lua-cli";
+import { LuaTool, User } from "lua-cli";
 import { z } from "zod";
 
 
@@ -10,30 +10,7 @@ export class GetUserDataTool implements LuaTool {
     constructor() {}
 
     async execute(input: z.infer<typeof this.inputSchema>) {
-        return new Lua.User().get();
-    }
-}
-
-
-export class CreateUserDataTool implements LuaTool {
-    name = "create_user_data";
-    description = "Get the user data for a given user id";
-    inputSchema = z.object({ 
-        data: z.object({
-            name: z.string(),
-            age: z.number()
-        })
-    });
-
-    constructor() {}
-
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        console.log('createUserData tool', input);
-        const userData = await new Lua.User().get();
-        if (userData.data) {
-            return new Lua.User().update(input.data);
-        }
-        return new Lua.User().create(input.data);
+        return User.get();
     }
 }
 
@@ -50,6 +27,7 @@ export class UpdateUserDataTool implements LuaTool {
     constructor() {}
 
     async execute(input: z.infer<typeof this.inputSchema>) {
-        return new Lua.User().update(input.data);
+        const user = await User.get(); //get instance of user
+        return await user.update(input.data);
     }
 }

package/dist/common/config.d.ts

@@ -1,5 +0,0 @@
-export declare const BASE_URLS: {
-    readonly API: "http://localhost:3022";
-    readonly AUTH: "https://auth.heylua.ai";
-    readonly CHAT: "http://localhost:3022";
-};

package/dist/common/config.js

@@ -1,5 +0,0 @@
-export const BASE_URLS = {
-    API: 'http://localhost:3022',
-    AUTH: 'https://auth.heylua.ai',
-    CHAT: 'http://localhost:3022'
-};

package/dist/custom-data-api.d.ts

@@ -1,72 +0,0 @@
-export interface CustomDataEntry {
-    id: string;
-    data: any;
-    createdAt: number;
-    updatedAt: number;
-    searchText?: string;
-}
-export interface CreateCustomDataRequest {
-    data: any;
-    searchText?: string;
-}
-export interface CreateCustomDataResponse {
-    id: string;
-    data: any;
-    createdAt: number;
-    updatedAt: number;
-    searchText?: string;
-}
-export interface GetCustomDataResponse {
-    data: CustomDataEntry[];
-    pagination: {
-        currentPage: number;
-        totalPages: number;
-        totalCount: number;
-        limit: number;
-        hasNextPage: boolean;
-        hasPrevPage: boolean;
-    };
-}
-export interface UpdateCustomDataRequest {
-    data: any;
-    searchText?: string;
-}
-export interface UpdateCustomDataResponse {
-    status: string;
-    message: string;
-}
-export interface SearchCustomDataResponse {
-    data: Array<CustomDataEntry & {
-        score: number;
-    }>;
-    count: number;
-}
-export interface DeleteCustomDataResponse {
-    status: string;
-    message: string;
-}
-export declare class CustomDataAPI {
-    private collections;
-    constructor();
-    private generateId;
-    private getCollection;
-    create(collectionName: string, data: CreateCustomDataRequest): Promise<CreateCustomDataResponse>;
-    get(collectionName: string, filter?: any, page?: number, limit?: number): Promise<GetCustomDataResponse>;
-    getEntry(collectionName: string, entryId: string): Promise<CustomDataEntry | null>;
-    update(collectionName: string, entryId: string, data: UpdateCustomDataRequest): Promise<UpdateCustomDataResponse>;
-    search(collectionName: string, searchText: string, limit?: number, scoreThreshold?: number): Promise<SearchCustomDataResponse>;
-    delete(collectionName: string, entryId: string): Promise<DeleteCustomDataResponse>;
-    private matchesFilter;
-    private calculateSimilarity;
-    getAllCollections(): Map<string, CustomDataEntry[]>;
-    clearCollection(collectionName: string): void;
-    clearAllCollections(): void;
-}
-export declare const customData: {
-    create: (collectionName: string, data: CreateCustomDataRequest) => Promise<CreateCustomDataResponse>;
-    get: (collectionName: string, filter?: any, page?: number, limit?: number) => Promise<GetCustomDataResponse>;
-    getEntry: (collectionName: string, entryId: string) => Promise<CustomDataEntry | null>;
-    update: (collectionName: string, entryId: string, data: UpdateCustomDataRequest) => Promise<UpdateCustomDataResponse>;
-    search: (collectionName: string, searchText: string, limit?: number, scoreThreshold?: number) => Promise<SearchCustomDataResponse>;
-    delete: (collectionName: string, entryId: string) => Promise<DeleteCustomDataResponse>;
-};

package/dist/custom-data-api.js

@@ -1,174 +0,0 @@
-export class CustomDataAPI {
-    constructor() {
-        // Store data by collection name
-        this.collections = new Map();
-    }
-    generateId() {
-        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-            const r = Math.random() * 16 | 0;
-            const v = c == 'x' ? r : (r & 0x3 | 0x8);
-            return v.toString(16);
-        });
-    }
-    getCollection(collectionName) {
-        if (!this.collections.has(collectionName)) {
-            this.collections.set(collectionName, []);
-        }
-        return this.collections.get(collectionName);
-    }
-    async create(collectionName, data) {
-        const collection = this.getCollection(collectionName);
-        const now = Date.now();
-        const entry = {
-            id: this.generateId(),
-            data: data.data,
-            createdAt: now,
-            updatedAt: now,
-            searchText: data.searchText
-        };
-        collection.push(entry);
-        return {
-            id: entry.id,
-            data: entry.data,
-            createdAt: entry.createdAt,
-            updatedAt: entry.updatedAt,
-            searchText: entry.searchText
-        };
-    }
-    async get(collectionName, filter, page = 1, limit = 10) {
-        const collection = this.getCollection(collectionName);
-        let filteredData = [...collection];
-        // Apply filter if provided
-        if (filter) {
-            filteredData = collection.filter(entry => {
-                return this.matchesFilter(entry.data, filter);
-            });
-        }
-        // Apply pagination
-        const startIndex = (page - 1) * limit;
-        const endIndex = startIndex + limit;
-        const paginatedData = filteredData.slice(startIndex, endIndex);
-        const totalCount = filteredData.length;
-        const totalPages = Math.ceil(totalCount / limit);
-        return {
-            data: paginatedData,
-            pagination: {
-                currentPage: page,
-                totalPages: totalPages,
-                totalCount: totalCount,
-                limit: limit,
-                hasNextPage: page < totalPages,
-                hasPrevPage: page > 1
-            }
-        };
-    }
-    async getEntry(collectionName, entryId) {
-        const collection = this.getCollection(collectionName);
-        return collection.find(entry => entry.id === entryId) || null;
-    }
-    async update(collectionName, entryId, data) {
-        const collection = this.getCollection(collectionName);
-        const entryIndex = collection.findIndex(entry => entry.id === entryId);
-        if (entryIndex === -1) {
-            return {
-                status: 'error',
-                message: 'Custom data entry not found'
-            };
-        }
-        const entry = collection[entryIndex];
-        entry.data = { ...entry.data, ...data.data };
-        entry.updatedAt = Date.now();
-        if (data.searchText !== undefined) {
-            entry.searchText = data.searchText;
-        }
-        return {
-            status: 'success',
-            message: 'Custom data entry updated'
-        };
-    }
-    async search(collectionName, searchText, limit = 10, scoreThreshold = 0.6) {
-        const collection = this.getCollection(collectionName);
-        const results = [];
-        for (const entry of collection) {
-            if (entry.searchText) {
-                const score = this.calculateSimilarity(searchText.toLowerCase(), entry.searchText.toLowerCase());
-                if (score >= scoreThreshold) {
-                    results.push({ ...entry, score });
-                }
-            }
-        }
-        // Sort by score descending
-        results.sort((a, b) => b.score - a.score);
-        // Apply limit
-        const limitedResults = results.slice(0, limit);
-        return {
-            data: limitedResults,
-            count: limitedResults.length
-        };
-    }
-    async delete(collectionName, entryId) {
-        const collection = this.getCollection(collectionName);
-        const initialLength = collection.length;
-        const updatedCollection = collection.filter(entry => entry.id !== entryId);
-        this.collections.set(collectionName, updatedCollection);
-        if (updatedCollection.length < initialLength) {
-            return {
-                status: 'success',
-                message: 'Custom data entry deleted'
-            };
-        }
-        else {
-            return {
-                status: 'error',
-                message: 'Custom data entry not found'
-            };
-        }
-    }
-    // Helper method to check if an object matches a filter
-    matchesFilter(obj, filter) {
-        for (const key in filter) {
-            if (filter.hasOwnProperty(key)) {
-                if (typeof filter[key] === 'object' && filter[key] !== null) {
-                    if (typeof obj[key] !== 'object' || !this.matchesFilter(obj[key], filter[key])) {
-                        return false;
-                    }
-                }
-                else {
-                    if (obj[key] !== filter[key]) {
-                        return false;
-                    }
-                }
-            }
-        }
-        return true;
-    }
-    // Simple similarity calculation (Jaccard similarity for words)
-    calculateSimilarity(str1, str2) {
-        const words1 = new Set(str1.split(/\s+/));
-        const words2 = new Set(str2.split(/\s+/));
-        const intersection = new Set([...words1].filter(x => words2.has(x)));
-        const union = new Set([...words1, ...words2]);
-        return intersection.size / union.size;
-    }
-    // Method to get all collections (for debugging/testing)
-    getAllCollections() {
-        return this.collections;
-    }
-    // Method to clear a collection (for testing)
-    clearCollection(collectionName) {
-        this.collections.set(collectionName, []);
-    }
-    // Method to clear all collections (for testing)
-    clearAllCollections() {
-        this.collections.clear();
-    }
-}
-const customDataAPI = new CustomDataAPI();
-export const customData = {
-    create: (collectionName, data) => customDataAPI.create(collectionName, data),
-    get: (collectionName, filter, page, limit) => customDataAPI.get(collectionName, filter, page, limit),
-    getEntry: (collectionName, entryId) => customDataAPI.getEntry(collectionName, entryId),
-    update: (collectionName, entryId, data) => customDataAPI.update(collectionName, entryId, data),
-    search: (collectionName, searchText, limit, scoreThreshold) => customDataAPI.search(collectionName, searchText, limit, scoreThreshold),
-    delete: (collectionName, entryId) => customDataAPI.delete(collectionName, entryId),
-};