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

package/template/src/tools/UserDataTool.ts

@@ -1,6 +1,5 @@
-import { LuaTool } from "lua-cli/skill";
+import { LuaTool, User } from "lua-cli";
 import { z } from "zod";
-import { user } from 'lua-cli/user-data-api';
 
 
 export class GetUserDataTool implements LuaTool {
@@ -11,30 +10,7 @@ export class GetUserDataTool implements LuaTool {
     constructor() {}
 
     async execute(input: z.infer<typeof this.inputSchema>) {
-        return user.data.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 user.data.get();
-        if (userData.data) {
-            return user.data.update(input.data);
-        }
-        return user.data.create(input.data);
+        return User.get();
     }
 }
 
@@ -51,6 +27,7 @@ export class UpdateUserDataTool implements LuaTool {
     constructor() {}
 
     async execute(input: z.infer<typeof this.inputSchema>) {
-        return user.data.update(input.data);
+        const user = await User.get(); //get instance of user
+        return await user.update(input.data);
     }
 }

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

package/dist/product-api.d.ts

@@ -1,197 +0,0 @@
-export interface Product {
-    id: string;
-    [key: string]: any;
-}
-export interface ProductsResponse {
-    success: boolean;
-    data: Product[];
-    pagination: {
-        currentPage: number;
-        totalPages: number;
-        totalCount: number;
-        limit: number;
-        hasNextPage: boolean;
-        hasPrevPage: boolean;
-        nextPage: number | null;
-        prevPage: number | null;
-    };
-}
-export interface CreateProductResponse {
-    updated: boolean;
-    isNew: boolean;
-    product: Product;
-}
-export interface UpdateProductResponse {
-    updated: boolean;
-    isNew: boolean;
-    product: Product;
-}
-export interface DeleteProductResponse {
-    deleted: boolean;
-}
-export interface SearchProductsResponse {
-    success: boolean;
-    message: string;
-    data: Product[];
-}
-export interface BasketItem {
-    id: string;
-    price: number;
-    quantity: number;
-    SKU?: string;
-    addedAt?: string;
-    [key: string]: any;
-}
-export interface Basket {
-    id: string;
-    userId: string;
-    agentId: string;
-    data: {
-        currency: string;
-        metadata?: any;
-        items: BasketItem[];
-        createdAt: string;
-    };
-    common: {
-        status: 'active' | 'checked_out' | 'abandoned' | 'expired';
-        totalAmount: string | number;
-        itemCount: number;
-    };
-    createdAt: string;
-    updatedAt: string;
-    __v: number;
-}
-export interface CreateBasketRequest {
-    currency: string;
-    metadata?: any;
-}
-export interface CreateBasketResponse {
-    success: boolean;
-    message: string;
-    data: Basket;
-}
-export interface GetBasketsResponse {
-    success: boolean;
-    message: string;
-    data: Basket[];
-}
-export interface AddItemToBasketRequest {
-    id: string;
-    price: number;
-    quantity: number;
-    [key: string]: any;
-}
-export interface AddItemToBasketResponse {
-    success: boolean;
-    message: string;
-    data: Basket;
-}
-export interface RemoveItemFromBasketResponse {
-    success: boolean;
-    message: string;
-    data: Basket;
-}
-export interface ClearBasketResponse {
-    success: boolean;
-    message: string;
-    data: Basket;
-}
-export interface UpdateBasketStatusResponse {
-    success: boolean;
-    message: string;
-    data: Basket;
-}
-export interface Order {
-    id: string;
-    userId: string;
-    agentId: string;
-    orderId: string;
-    data: {
-        currency: string;
-        items: BasketItem[];
-        createdAt: string;
-        basketId: string;
-        orderDate: string;
-        orderId: string;
-        [key: string]: any;
-    };
-    common: {
-        status: 'pending' | 'confirmed' | 'fulfilled' | 'cancelled';
-        totalAmount: string | number;
-        currency: string;
-        itemCount: number;
-    };
-    createdAt: string;
-    updatedAt: string;
-    __v: number;
-}
-export interface CreateOrderRequest {
-    basketId: string;
-    data: {
-        [key: string]: any;
-    };
-}
-export interface CreateOrderResponse {
-    success: boolean;
-    message: string;
-    data: Order;
-}
-export interface UpdateOrderStatusResponse {
-    success: boolean;
-    message: string;
-    data: Order;
-}
-export interface GetUserOrdersResponse {
-    success: boolean;
-    message: string;
-    data: Order[];
-}
-export interface UpdateBasketMetadataResponse {
-    success: boolean;
-    message: string;
-}
-export type BasketStatus = 'active' | 'checked_out' | 'abandoned' | 'expired';
-export type OrderStatus = 'pending' | 'confirmed' | 'fulfilled' | 'cancelled';
-export declare class ProductAPI {
-    products: Product[];
-    baskets: Basket[];
-    orders: Order[];
-    constructor();
-    get(page?: number, limit?: number): Promise<ProductsResponse>;
-    create(data: Record<string, any>): Promise<CreateProductResponse>;
-    update(data: Record<string, any>, productId: string): Promise<UpdateProductResponse>;
-    delete(productId: string): Promise<DeleteProductResponse>;
-    search(searchQuery: string): Promise<SearchProductsResponse>;
-    createBasket(data: CreateBasketRequest): Promise<CreateBasketResponse>;
-    updateBasketMetadata(basketId: string, metadata: any): Promise<UpdateBasketMetadataResponse>;
-    getBaskets(status?: BasketStatus): Promise<GetBasketsResponse>;
-    addItemToBasket(basketId: string, data: AddItemToBasketRequest): Promise<AddItemToBasketResponse>;
-    removeItemFromBasket(basketId: string, itemId: string): Promise<RemoveItemFromBasketResponse>;
-    clearBasket(basketId: string): Promise<ClearBasketResponse>;
-    updateBasketStatus(basketId: string, status: BasketStatus): Promise<UpdateBasketStatusResponse>;
-    createOrder(data: CreateOrderRequest): Promise<CreateOrderResponse>;
-    updateOrderStatus(orderId: string, status: OrderStatus): Promise<UpdateOrderStatusResponse>;
-    getUserOrders(): Promise<GetUserOrdersResponse>;
-}
-export declare const product: {
-    create: (data: Record<string, any>) => Promise<CreateProductResponse>;
-    get: (page?: number, limit?: number) => Promise<ProductsResponse>;
-    update: (data: Record<string, any>, productId: string) => Promise<UpdateProductResponse>;
-    delete: (productId: string) => Promise<DeleteProductResponse>;
-    search: (searchQuery: string) => Promise<SearchProductsResponse>;
-    data: ProductAPI;
-    basket: {
-        create: (data: CreateBasketRequest) => Promise<CreateBasketResponse>;
-        get: (status?: BasketStatus) => Promise<GetBasketsResponse>;
-        addItem: (basketId: string, data: AddItemToBasketRequest) => Promise<AddItemToBasketResponse>;
-        removeItem: (basketId: string, itemId: string) => Promise<RemoveItemFromBasketResponse>;
-        clear: (basketId: string) => Promise<ClearBasketResponse>;
-        updateStatus: (basketId: string, status: BasketStatus) => Promise<UpdateBasketStatusResponse>;
-        updateMetadata: (basketId: string, metadata: any) => Promise<UpdateBasketMetadataResponse>;
-    };
-    order: {
-        create: (data: CreateOrderRequest) => Promise<CreateOrderResponse>;
-        updateStatus: (orderId: string, status: OrderStatus) => Promise<UpdateOrderStatusResponse>;
-        get: () => Promise<GetUserOrdersResponse>;
-    };
-};

package/dist/product-api.js

@@ -1,152 +0,0 @@
-export class ProductAPI {
-    constructor() {
-        this.products = [];
-        this.baskets = [];
-        this.orders = [];
-    }
-    async get(page = 1, limit = 10) {
-        return {
-            success: true,
-            data: this.products,
-            pagination: {
-                currentPage: page,
-                totalPages: 1,
-                totalCount: this.products.length,
-                limit: limit,
-                hasNextPage: false,
-                hasPrevPage: false,
-                nextPage: null,
-                prevPage: null
-            }
-        };
-    }
-    async create(data) {
-        const product = data;
-        const existingIndex = this.products.findIndex(p => p.id === product.id);
-        if (existingIndex >= 0) {
-            this.products[existingIndex] = product;
-            return { updated: true, isNew: false, product };
-        }
-        else {
-            this.products.push(product);
-            return { updated: false, isNew: true, product };
-        }
-    }
-    async update(data, productId) {
-        const product = data;
-        const existingIndex = this.products.findIndex(p => p.id === productId);
-        if (existingIndex >= 0) {
-            this.products[existingIndex] = { ...this.products[existingIndex], ...product };
-            return { updated: true, isNew: false, product: this.products[existingIndex] };
-        }
-        else {
-            this.products.push(product);
-            return { updated: false, isNew: true, product };
-        }
-    }
-    async delete(productId) {
-        const initialLength = this.products.length;
-        this.products = this.products.filter((product) => product.id !== productId);
-        return { deleted: this.products.length < initialLength };
-    }
-    async search(searchQuery) {
-        const results = this.products.filter(product => Object.values(product).some(value => String(value).toLowerCase().includes(searchQuery.toLowerCase())));
-        return {
-            success: true,
-            message: `Successfully found ${results.length} products for "${searchQuery}"`,
-            data: results
-        };
-    }
-    async createBasket(data) {
-        const basket = { ...data, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), __v: 0 };
-        this.baskets.push(basket);
-        return { success: true, message: 'Basket created successfully', data: basket };
-    }
-    async updateBasketMetadata(basketId, metadata) {
-        const basket = this.baskets.find((basket) => basket.id === basketId);
-        if (basket) {
-            basket.data.metadata = metadata;
-            return { success: true, message: 'Basket metadata updated successfully' };
-        }
-        else {
-            return { success: false, message: 'Basket not found' };
-        }
-    }
-    async getBaskets(status) {
-        if (status) {
-            return { success: true, message: 'Baskets fetched successfully', data: this.baskets.filter((basket) => basket.common.status === status) };
-        }
-        return { success: true, message: 'Baskets fetched successfully', data: this.baskets };
-    }
-    async addItemToBasket(basketId, data) {
-        const basket = this.baskets.find((basket) => basket.id === basketId);
-        if (basket) {
-            basket.data.items.push(data);
-            return { success: true, message: 'Item added to basket successfully', data: basket };
-        }
-        return { success: false, message: 'Basket not found', data: null };
-    }
-    async removeItemFromBasket(basketId, itemId) {
-        const basket = this.baskets.find((basket) => basket.id === basketId);
-        if (basket) {
-            basket.data.items = basket.data.items.filter((item) => item.id !== itemId);
-            return { success: true, message: 'Item removed from basket successfully', data: basket };
-        }
-        return { success: false, message: 'Basket not found', data: null };
-    }
-    async clearBasket(basketId) {
-        const basket = this.baskets.find((basket) => basket.id === basketId);
-        if (basket) {
-            basket.data.items = [];
-            return { success: true, message: 'Basket cleared successfully', data: basket };
-        }
-        return { success: false, message: 'Basket not found', data: null };
-    }
-    async updateBasketStatus(basketId, status) {
-        const basket = this.baskets.find((basket) => basket.id === basketId);
-        if (basket) {
-            basket.common.status = status;
-            return { success: true, message: 'Basket status updated successfully', data: basket };
-        }
-        return { success: false, message: 'Basket not found', data: null };
-    }
-    async createOrder(data) {
-        const order = { ...data, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), __v: 0 };
-        this.orders.push(order);
-        return { success: true, message: 'Order created successfully', data: order };
-    }
-    async updateOrderStatus(orderId, status) {
-        const order = this.orders.find((order) => order.id === orderId);
-        if (order) {
-            order.common.status = status;
-            return { success: true, message: 'Order status updated successfully', data: order };
-        }
-        return { success: false, message: 'Order not found', data: null };
-    }
-    async getUserOrders() {
-        return { success: true, message: 'User orders fetched successfully', data: this.orders };
-    }
-}
-const productAPI = new ProductAPI();
-export const product = {
-    create: productAPI.create,
-    get: productAPI.get,
-    update: productAPI.update,
-    delete: productAPI.delete,
-    search: productAPI.search,
-    data: productAPI,
-    basket: {
-        create: productAPI.createBasket,
-        get: productAPI.getBaskets,
-        addItem: productAPI.addItemToBasket,
-        removeItem: productAPI.removeItemFromBasket,
-        clear: productAPI.clearBasket,
-        updateStatus: productAPI.updateBasketStatus,
-        updateMetadata: productAPI.updateBasketMetadata
-    },
-    order: {
-        create: productAPI.createOrder,
-        updateStatus: productAPI.updateOrderStatus,
-        get: productAPI.getUserOrders
-    }
-};