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

package/dist/api/tool.api.service.d.ts

@@ -0,0 +1,14 @@
+import { HttpClient } from "../common/http.client.js";
+import { ApiResponse } from "../interfaces/admin";
+/**
+ * Tool API calls (for compile command)
+ */
+export default class ToolApi extends HttpClient {
+    private apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    getTool(url: string): Promise<ApiResponse<any>>;
+    postTool(url: string, data: any): Promise<ApiResponse<any>>;
+    putTool(url: string, data: any): Promise<ApiResponse<any>>;
+    deleteTool(url: string): Promise<ApiResponse<any>>;
+    patchTool(url: string, data: any): Promise<ApiResponse<any>>;
+}

package/dist/api/tool.api.service.js

@@ -0,0 +1,35 @@
+import { HttpClient } from "../common/http.client.js";
+/**
+ * Tool API calls (for compile command)
+ */
+export default class ToolApi extends HttpClient {
+    constructor(baseUrl, apiKey) {
+        super(baseUrl);
+        this.apiKey = apiKey;
+    }
+    async getTool(url) {
+        return this.httpGet(url, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    async postTool(url, data) {
+        return this.httpPost(url, data, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    async putTool(url, data) {
+        return this.httpPut(url, data, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    async deleteTool(url) {
+        return this.httpDelete(url, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    async patchTool(url, data) {
+        return this.httpPatch(url, data, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+}

package/dist/api/user.data.api.service.d.ts

@@ -0,0 +1,11 @@
+import { HttpClient } from "../common/http.client.js";
+import UserDataInstance from "../common/user.instance.js";
+import { UserDataAPI } from "../types";
+export default class UserDataApi extends HttpClient implements UserDataAPI {
+    private apiKey;
+    private agentId;
+    constructor(baseUrl: string, apiKey: string, agentId: string);
+    get(): Promise<UserDataInstance>;
+    update(data: Record<string, any>): Promise<any>;
+    clear(): Promise<any>;
+}

package/dist/api/user.data.api.service.js

@@ -0,0 +1,37 @@
+import { HttpClient } from "../common/http.client.js";
+import UserDataInstance from "../common/user.instance.js";
+// User Data API calls
+export default class UserDataApi extends HttpClient {
+    constructor(baseUrl, apiKey, agentId) {
+        super(baseUrl);
+        this.apiKey = apiKey;
+        this.agentId = agentId;
+    }
+    async get() {
+        const response = await this.httpGet(`/developer/user/data/agent/${this.agentId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (!response.success) {
+            throw new Error(response.error?.message || 'Failed to get user data');
+        }
+        return new UserDataInstance(this, response.data);
+    }
+    async update(data) {
+        const response = await this.httpPut(`/developer/user/data/agent/${this.agentId}`, data, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (!response.success) {
+            throw new Error(response.error?.message || 'Failed to update user data');
+        }
+        return response.data;
+    }
+    async clear() {
+        const response = await this.httpDelete(`/developer/user/data/agent/${this.agentId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (!response.success) {
+            throw new Error(response.error?.message || 'Failed to clear user data');
+        }
+        return {};
+    }
+}

package/dist/api-exports.d.ts

@@ -0,0 +1,40 @@
+import { LuaSkill, LuaTool } from "./skill.js";
+import { BasketStatus } from "./interfaces/baskets.js";
+import { OrderStatus } from "./interfaces/orders.js";
+export declare const User: {
+    get(): Promise<import("./common/user.instance.js").default>;
+    update(data: Record<string, any>): Promise<any>;
+    clear(): Promise<any>;
+};
+export declare const Data: {
+    create(collectionName: string, data: any, searchText?: string): Promise<import("./common/data.entry.instance.js").default>;
+    get(collectionName: string, filter?: any, page?: number, limit?: number): Promise<import("./interfaces/custom.data.js").GetCustomDataResponse>;
+    getEntry(collectionName: string, entryId: string): Promise<import("./common/data.entry.instance.js").default>;
+    update(collectionName: string, entryId: string, data: any): Promise<import("./interfaces/custom.data.js").UpdateCustomDataResponse>;
+    search(collectionName: string, searchText: string, limit?: number, scoreThreshold?: number): Promise<import("./common/data.entry.instance.js").default[]>;
+    delete(collectionName: string, entryId: string): Promise<import("./interfaces/custom.data.js").DeleteCustomDataResponse>;
+};
+export declare const Products: {
+    get(limit?: number, page?: number): Promise<import("./common/product.pagination.instance.js").default>;
+    create(product: any): Promise<import("./common/product.instance.js").default>;
+    update(data: any, id: string): Promise<import("./interfaces/product.js").UpdateProductResponse>;
+    delete(id: string): Promise<import("./interfaces/product.js").DeleteProductResponse>;
+    search(query: string): Promise<import("./common/product.search.instance.js").default>;
+};
+export declare const Baskets: {
+    create(basketData: any): Promise<import("./common/basket.instance.js").default>;
+    get(status?: any): Promise<import("./common/basket.instance.js").default[]>;
+    addItem(basketId: string, itemData: any): Promise<import("./interfaces/baskets.js").Basket>;
+    removeItem(basketId: string, itemId: string): Promise<import("./interfaces/baskets.js").Basket>;
+    clear(basketId: string): Promise<import("./interfaces/baskets.js").Basket>;
+    updateStatus(basketId: string, status: any): Promise<BasketStatus>;
+    updateMetadata(basketId: string, metadata: any): Promise<import("./interfaces/custom.data.js").UpdateBasketMetadataResponse>;
+    placeOrder(data: Record<string, any>, basketId: string): Promise<import("./common/order.instance.js").default>;
+};
+export declare const Orders: {
+    create(orderData: any): Promise<import("./common/order.instance.js").default>;
+    updateStatus(status: any, orderId: string): Promise<import("./interfaces/orders.js").OrderResponse>;
+    updateData(data: Record<string, any>, orderId: string): Promise<import("./interfaces/orders.js").OrderResponse>;
+    get(status?: any): Promise<import("./common/order.instance.js").default[]>;
+};
+export { LuaSkill, LuaTool, BasketStatus, OrderStatus };

package/dist/api-exports.js

@@ -0,0 +1,189 @@
+// API exports for use in LuaSkills - separate from CLI
+import { LuaSkill } from "./skill.js";
+import { BasketStatus } from "./interfaces/baskets.js";
+import { OrderStatus } from "./interfaces/orders.js";
+import { loadApiKey } from "./services/auth.js";
+import { readSkillConfig } from "./utils/files.js";
+import { BASE_URLS } from "./common/config.js";
+// Import the actual API service classes for proper instantiation
+import ProductApiService from "./api/products.api.service.js";
+import BasketApiService from "./api/basket.api.service.js";
+import OrderApiService from "./api/order.api.service.js";
+import UserDataApiService from "./api/user.data.api.service.js";
+import CustomDataApiService from "./api/custom.data.api.service.js";
+async function getCredentials() {
+    // Load API key from keystore
+    const apiKey = await loadApiKey();
+    if (!apiKey) {
+        throw new Error('No API key found. Please run "lua auth configure" first.');
+    }
+    // Load agent ID from YAML file
+    const config = readSkillConfig();
+    if (!config?.agent?.agentId) {
+        throw new Error('No agent ID found in lua.skill.yaml. Please run "lua init" first.');
+    }
+    return {
+        apiKey,
+        agentId: config.agent.agentId
+    };
+}
+// Lazy-loaded API instances to avoid top-level await
+let _userInstance = null;
+let _dataInstance = null;
+let _productsInstance = null;
+let _basketsInstance = null;
+let _orderInstance = null;
+async function getUserInstance() {
+    if (!_userInstance) {
+        const creds = await getCredentials();
+        _userInstance = new UserDataApiService(BASE_URLS.API, creds.apiKey, creds.agentId);
+    }
+    return _userInstance;
+}
+async function getDataInstance() {
+    if (!_dataInstance) {
+        const creds = await getCredentials();
+        _dataInstance = new CustomDataApiService(BASE_URLS.API, creds.apiKey, creds.agentId);
+    }
+    return _dataInstance;
+}
+async function getProductsInstance() {
+    if (!_productsInstance) {
+        const creds = await getCredentials();
+        _productsInstance = new ProductApiService(BASE_URLS.API, creds.apiKey, creds.agentId);
+    }
+    return _productsInstance;
+}
+async function getBasketsInstance() {
+    if (!_basketsInstance) {
+        const creds = await getCredentials();
+        _basketsInstance = new BasketApiService(BASE_URLS.API, creds.apiKey, creds.agentId);
+    }
+    return _basketsInstance;
+}
+async function getOrderInstance() {
+    if (!_orderInstance) {
+        const creds = await getCredentials();
+        _orderInstance = new OrderApiService(BASE_URLS.API, creds.apiKey, creds.agentId);
+    }
+    return _orderInstance;
+}
+export const User = {
+    async get() {
+        const instance = await getUserInstance();
+        return instance.get();
+    },
+    async update(data) {
+        const instance = await getUserInstance();
+        return instance.update(data);
+    },
+    async clear() {
+        const instance = await getUserInstance();
+        return instance.clear();
+    }
+};
+export const Data = {
+    async create(collectionName, data, searchText) {
+        const instance = await getDataInstance();
+        console.log('collectionName', collectionName);
+        console.log('data', data);
+        console.log('searchText', searchText);
+        return instance.create(collectionName, data, searchText);
+    },
+    async get(collectionName, filter, page, limit) {
+        const instance = await getDataInstance();
+        return instance.get(collectionName, filter, page, limit);
+    },
+    async getEntry(collectionName, entryId) {
+        const instance = await getDataInstance();
+        return instance.getEntry(collectionName, entryId);
+    },
+    async update(collectionName, entryId, data) {
+        const instance = await getDataInstance();
+        return instance.update(collectionName, entryId, data);
+    },
+    async search(collectionName, searchText, limit, scoreThreshold) {
+        const instance = await getDataInstance();
+        return instance.search(collectionName, searchText, limit, scoreThreshold);
+    },
+    async delete(collectionName, entryId) {
+        const instance = await getDataInstance();
+        return instance.delete(collectionName, entryId);
+    }
+};
+export const Products = {
+    async get(limit, page) {
+        const instance = await getProductsInstance();
+        return instance.get(limit, page);
+    },
+    async create(product) {
+        const instance = await getProductsInstance();
+        return instance.create(product);
+    },
+    async update(data, id) {
+        const instance = await getProductsInstance();
+        return instance.update(data, id);
+    },
+    async delete(id) {
+        const instance = await getProductsInstance();
+        return instance.delete(id);
+    },
+    async search(query) {
+        const instance = await getProductsInstance();
+        return instance.search(query);
+    }
+};
+export const Baskets = {
+    async create(basketData) {
+        const instance = await getBasketsInstance();
+        return instance.create(basketData);
+    },
+    async get(status) {
+        const instance = await getBasketsInstance();
+        return instance.get(status);
+    },
+    async addItem(basketId, itemData) {
+        const instance = await getBasketsInstance();
+        return instance.addItem(basketId, itemData);
+    },
+    async removeItem(basketId, itemId) {
+        const instance = await getBasketsInstance();
+        return instance.removeItem(basketId, itemId);
+    },
+    async clear(basketId) {
+        const instance = await getBasketsInstance();
+        return instance.clear(basketId);
+    },
+    async updateStatus(basketId, status) {
+        const instance = await getBasketsInstance();
+        return instance.updateStatus(basketId, status);
+    },
+    async updateMetadata(basketId, metadata) {
+        const instance = await getBasketsInstance();
+        return instance.updateMetadata(basketId, metadata);
+    },
+    async placeOrder(data, basketId) {
+        const instance = await getBasketsInstance();
+        return instance.placeOrder(data, basketId);
+    }
+};
+export const Orders = {
+    async create(orderData) {
+        const instance = await getOrderInstance();
+        return instance.create(orderData);
+    },
+    async updateStatus(status, orderId) {
+        const instance = await getOrderInstance();
+        return instance.updateStatus(status, orderId);
+    },
+    async updateData(data, orderId) {
+        const instance = await getOrderInstance();
+        return instance.updateData(data, orderId);
+    },
+    async get(status) {
+        const instance = await getOrderInstance();
+        return instance.get(status);
+    }
+};
+// Export classes and utilities
+export { LuaSkill, BasketStatus, OrderStatus };

package/dist/commands/dev.js

@@ -708,12 +708,15 @@ async function pushSingleSkillToSandbox(apiKey, agentId, skillId, skillData, isI
             return true;
         }
         else if (updateResult.error) {
-            if (!isInitial) {
-                writeProgress("⚠️  Failed to update existing sandbox, creating new one...");
-                console.error(`❌ Sandbox update failed: ${updateResult.error.message}`);
-                if (updateResult.error.error) {
-                    console.error(`   Details: ${updateResult.error.error}`);
-                }
+            writeProgress("⚠️  Failed to update existing sandbox, creating new one...");
+            console.error(`❌ Sandbox update failed: ${updateResult.error.message}`);
+            if (updateResult.error.error) {
+                console.error(`   Details: ${updateResult.error.error}`);
+            }
+            // If skill not found during update, give helpful guidance before trying to create
+            if (updateResult.error.message.includes('Skill not found') || updateResult.error.statusCode === 400 || updateResult.error.statusCode === 404) {
+                console.error('\n💡 The skill doesn\'t exist on the server.');
+                console.error('   Please run "lua push" first to deploy your skill, then try "lua dev" again.\n');
             }
             // Fall through to create new sandbox
         }
@@ -733,21 +736,22 @@ async function pushSingleSkillToSandbox(apiKey, agentId, skillId, skillData, isI
         return true;
     }
     else if (result.error) {
-        if (!isInitial) {
-            console.error(`❌ Sandbox creation failed: ${result.error.message}`);
-            if (result.error.error) {
-                console.error(`   Details: ${result.error.error}`);
-            }
-            if (result.error.statusCode) {
-                console.error(`   Status Code: ${result.error.statusCode}`);
-            }
+        console.error(`❌ Sandbox creation failed: ${result.error.message}`);
+        if (result.error.error) {
+            console.error(`   Details: ${result.error.error}`);
+        }
+        if (result.error.statusCode) {
+            console.error(`   Status Code: ${result.error.statusCode}`);
+        }
+        // If skill not found, give helpful guidance
+        if (result.error.message.includes('Skill not found') || result.error.statusCode === 400 || result.error.statusCode === 404) {
+            console.error('\n💡 The skill hasn\'t been deployed to the server yet.');
+            console.error('   Please run "lua push" first to deploy your skill, then try "lua dev" again.');
         }
         return false;
     }
     else {
-        if (!isInitial) {
-            console.error("❌ Failed to push version to sandbox. Please try again.");
-        }
+        console.error("❌ Failed to push version to sandbox. Please try again.");
         return false;
     }
 }
@@ -814,6 +818,7 @@ export async function devCommand() {
         }
         // Initial push to sandbox
         writeProgress("🔄 Pushing skills to sandbox...");
+        console.log('deployData', deployData);
         const sandboxIds = await pushSkillsToSandbox(apiKey, agentId, deployData, true);
         // console.log(sandboxIds);
         if (Object.keys(sandboxIds).length === 0) {

package/dist/common/basket.instance.d.ts

@@ -0,0 +1,27 @@
+import { Basket, BasketItem, BasketStatus } from "../interfaces/baskets";
+import { BasketAPI } from "../types";
+import OrderInstance from "./order.instance";
+export default class BasketInstance {
+    private id;
+    private userId;
+    private agentId;
+    private data;
+    private common;
+    metadata: any;
+    totalAmount: string | number;
+    itemCount: number;
+    status: BasketStatus;
+    private basketAPI;
+    constructor(api: BasketAPI, basket: Basket);
+    /**
+     * Custom toJSON method to control what gets serialized when logging
+     */
+    toJSON(): Record<string, any>;
+    updateMetadata(metadata: any): Promise<any>;
+    updateStatus(status: BasketStatus): Promise<any>;
+    private updateBasket;
+    addItem(item: BasketItem): Promise<any>;
+    removeItem(itemId: string): Promise<any>;
+    clear(): Promise<any>;
+    placeOrder(data: Record<string, any>): Promise<OrderInstance>;
+}

package/dist/common/basket.instance.js

@@ -0,0 +1,79 @@
+import { BasketStatus } from "../interfaces/baskets";
+export default class BasketInstance {
+    constructor(api, basket) {
+        this.data = basket.data;
+        this.common = basket.common;
+        this.id = basket.id;
+        this.userId = basket.userId;
+        this.agentId = basket.agentId;
+        this.metadata = basket.data.metadata;
+        this.totalAmount = basket.common.totalAmount;
+        this.itemCount = basket.common.itemCount;
+        this.status = basket.common.status;
+        // Make basketAPI non-enumerable so it doesn't show up in console.log
+        Object.defineProperty(this, 'basketAPI', {
+            value: api,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    /**
+     * Custom toJSON method to control what gets serialized when logging
+     */
+    toJSON() {
+        return {
+            ...this.data,
+            ...this.common
+        };
+    }
+    /**
+     * Custom inspect method for Node.js console.log
+     */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return {
+            ...this.data,
+            ...this.common,
+        };
+    }
+    async updateMetadata(metadata) {
+        await this.basketAPI.updateMetadata(this.id, metadata);
+        this.data.metadata = { ...this.data.metadata, ...metadata };
+        return { ...this.data, ...this.common };
+    }
+    async updateStatus(status) {
+        await this.basketAPI.updateStatus(this.id, status);
+        this.common.status = status;
+        return { ...this.data, ...this.common };
+    }
+    updateBasket(basket) {
+        this.data = basket.data;
+        this.common = basket.common;
+        this.id = basket.id;
+        this.userId = basket.userId;
+        this.agentId = basket.agentId;
+        this.metadata = basket.data.metadata;
+        this.totalAmount = basket.common.totalAmount;
+        this.itemCount = basket.common.itemCount;
+        this.status = basket.common.status;
+        return { ...this.data, ...this.common };
+    }
+    async addItem(item) {
+        const basket = await this.basketAPI.addItem(this.id, item);
+        return this.updateBasket(basket);
+    }
+    async removeItem(itemId) {
+        const basket = await this.basketAPI.removeItem(this.id, itemId);
+        return this.updateBasket(basket);
+    }
+    async clear() {
+        const basket = await this.basketAPI.clear(this.id);
+        return this.updateBasket(basket);
+    }
+    async placeOrder(data) {
+        const order = await this.basketAPI.placeOrder(data, this.id);
+        console.log('order', order);
+        await this.updateStatus(BasketStatus.CHECKED_OUT);
+        return order;
+    }
+}

package/dist/common/config.d.ts

@@ -0,0 +1,5 @@
+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

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

package/dist/common/data.entry.instance.d.ts

@@ -0,0 +1,16 @@
+import { CustomDataAPI } from "../types";
+import { CreateCustomDataResponse } from "../interfaces/custom.data";
+export default class DataEntryInstance {
+    data: Record<string, any>;
+    id: string;
+    collectionName: string;
+    score?: number;
+    private customDataAPI;
+    constructor(api: CustomDataAPI, entry: CreateCustomDataResponse, collectionName: string);
+    /**
+     * Custom toJSON method to control what gets serialized when logging
+     */
+    toJSON(): Record<string, any>;
+    update(data: Record<string, any>, searchText?: string): Promise<any>;
+    delete(): Promise<boolean>;
+}

package/dist/common/data.entry.instance.js

@@ -0,0 +1,52 @@
+export default class DataEntryInstance {
+    constructor(api, entry, collectionName) {
+        this.data = entry.data;
+        this.id = entry.id;
+        this.collectionName = collectionName;
+        this.score = entry.score;
+        // Make userAPI non-enumerable so it doesn't show up in console.log
+        Object.defineProperty(this, 'customDataAPI', {
+            value: api,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    /**
+     * Custom toJSON method to control what gets serialized when logging
+     */
+    toJSON() {
+        return {
+            ...this.data,
+            score: this.score
+        };
+    }
+    /**
+     * Custom inspect method for Node.js console.log
+     */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return {
+            ...this.data,
+            score: this.score
+        };
+    }
+    async update(data, searchText) {
+        try {
+            const response = await this.customDataAPI.update(this.collectionName, this.id, { data, searchText });
+            this.data = { ...this.data, ...data };
+            return this.data;
+        }
+        catch (error) {
+            throw new Error('Failed to update user data');
+        }
+    }
+    async delete() {
+        try {
+            await this.customDataAPI.delete(this.collectionName, this.id);
+            return true;
+        }
+        catch (error) {
+            throw new Error('Failed to clear user data');
+        }
+    }
+}

package/dist/common/http.client.d.ts

@@ -0,0 +1,14 @@
+import { ApiResponse } from "../interfaces/admin";
+/**
+ * Generic HTTP client with common error handling
+ */
+export declare abstract class HttpClient {
+    protected baseUrl: string;
+    constructor(baseUrl: string);
+    private request;
+    protected httpGet<T>(url: string, headers?: Record<string, string>): Promise<ApiResponse<T>>;
+    protected httpPost<T>(url: string, data?: any, headers?: Record<string, string>): Promise<ApiResponse<T>>;
+    protected httpPut<T>(url: string, data?: any, headers?: Record<string, string>): Promise<ApiResponse<T>>;
+    protected httpDelete<T>(url: string, headers?: Record<string, string>): Promise<ApiResponse<T>>;
+    protected httpPatch<T>(url: string, data?: any, headers?: Record<string, string>): Promise<ApiResponse<T>>;
+}