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

package/dist/services/api.js

@@ -1,596 +0,0 @@
-/**
- * Centralized API service for all Lua CLI API calls
- * This service handles all HTTP requests to various Lua endpoints
- */
-// Base URLs for different environments
-const BASE_URLS = {
-    LOCAL: 'https://api.heylua.ai',
-    API: 'https://api.heylua.ai',
-    AUTH: 'https://auth.heylua.ai',
-    CHAT: 'https://api.heylua.ai'
-};
-/**
- * Generic HTTP client with common error handling
- */
-class HttpClient {
-    async request(url, options = {}) {
-        try {
-            const response = await fetch(url, {
-                ...options,
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...options.headers,
-                },
-            });
-            const data = await response.json();
-            if (!response.ok) {
-                return {
-                    success: false,
-                    error: {
-                        message: data.message || data.error || `HTTP ${response.status}`,
-                        statusCode: response.status,
-                    },
-                };
-            }
-            return {
-                success: true,
-                data,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: {
-                    message: error instanceof Error ? error.message : 'Network error',
-                    statusCode: 500,
-                },
-            };
-        }
-    }
-    async get(url, headers) {
-        return this.request(url, { method: 'GET', headers });
-    }
-    async post(url, data, headers) {
-        return this.request(url, {
-            method: 'POST',
-            body: data ? JSON.stringify(data) : undefined,
-            headers,
-        });
-    }
-    async put(url, data, headers) {
-        return this.request(url, {
-            method: 'PUT',
-            body: data ? JSON.stringify(data) : undefined,
-            headers,
-        });
-    }
-    async delete(url, headers) {
-        return this.request(url, { method: 'DELETE', headers });
-    }
-    async patch(url, data, headers) {
-        return this.request(url, {
-            method: 'PATCH',
-            body: data ? JSON.stringify(data) : undefined,
-            headers,
-        });
-    }
-}
-const httpClient = new HttpClient();
-/**
- * Authentication API calls
- */
-export class AuthApi {
-    static async checkApiKey(apiKey) {
-        return httpClient.get(`${BASE_URLS.LOCAL}/admin`, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-    }
-    static async sendOtp(email) {
-        return httpClient.post(`${BASE_URLS.AUTH}/otp`, { email, type: 'email' });
-    }
-    static async verifyOtp(email, otp) {
-        return httpClient.post(`${BASE_URLS.AUTH}/otp/verify`, { email, pin: otp, type: 'email' });
-    }
-    static async getApiKey(signInToken) {
-        return httpClient.post(`${BASE_URLS.AUTH}/profile/apiKey`, undefined, {
-            Authorization: `Bearer ${signInToken}`,
-        });
-    }
-}
-/**
- * Agent API calls
- */
-export class AgentApi {
-    static async getOrganizations(apiKey) {
-        return httpClient.get(`${BASE_URLS.LOCAL}/admin`, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-    }
-    static async getAgentTypes(apiKey) {
-        return httpClient.get(`${BASE_URLS.API}/agents/self-serve/types`, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-    }
-    static async createAgent(apiKey, agentData) {
-        return httpClient.post(`${BASE_URLS.API}/agents/self-serve/create`, agentData, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-    }
-    static async getAgent(apiKey, agentId) {
-        return httpClient.get(`${BASE_URLS.API}/admin/agents/${agentId}`, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-    }
-}
-/**
- * Skill API calls
- */
-export class SkillApi {
-    static async createSkill(apiKey, agentId, skillData) {
-        // console.log(`Skill data:`, skillData);
-        return httpClient.post(`${BASE_URLS.LOCAL}/developer/skills/${agentId}`, skillData, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-    }
-    static async pushSkill(apiKey, agentId, skillId, versionData) {
-        return httpClient.post(`${BASE_URLS.LOCAL}/developer/skills/${agentId}/${skillId}/version`, versionData, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-    }
-    static async pushDevSkill(apiKey, agentId, skillId, versionData) {
-        return httpClient.post(`${BASE_URLS.LOCAL}/developer/skills/${agentId}/${skillId}/version/sandbox`, versionData, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-    }
-    static async updateDevSkill(apiKey, agentId, skillId, sandboxVersionId, versionData) {
-        return httpClient.put(`${BASE_URLS.LOCAL}/developer/skills/${agentId}/${skillId}/version/sandbox/${sandboxVersionId}`, versionData, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-    }
-    static async getSkillVersions(apiKey, agentId, skillId) {
-        return httpClient.get(`${BASE_URLS.LOCAL}/developer/skills/${agentId}/${skillId}/versions`, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-    }
-    static async publishSkillVersion(apiKey, agentId, skillId, version) {
-        return httpClient.put(`${BASE_URLS.LOCAL}/developer/skills/${agentId}/${skillId}/${version}/publish`, undefined, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-    }
-}
-/**
- * Chat API calls
- */
-export class ChatApi {
-    static async sendMessage(agentId, chatData, apiKey) {
-        return httpClient.post(`${BASE_URLS.CHAT}/chat/generate/${agentId}?channel=dev`, chatData, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-    }
-}
-/**
- * Product API calls
- */
-export class ProductApi {
-    /**
-     * Get all products for an agent with pagination
-     */
-    static async getProducts(apiKey, agentId, page = 1, limit = 10) {
-        const response = await httpClient.get(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/products?page=${page}&limit=${limit}`, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to get products'
-            };
-        }
-    }
-    /**
-     * Create a new product
-     */
-    static async createProduct(apiKey, agentId, productData) {
-        const response = await httpClient.post(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/products`, productData, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to create product'
-            };
-        }
-    }
-    /**
-     * Update an existing product
-     */
-    static async updateProduct(apiKey, agentId, productData) {
-        const response = await httpClient.put(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/products`, productData, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to update product'
-            };
-        }
-    }
-    /**
-     * Delete a product
-     */
-    static async deleteProduct(apiKey, agentId, productId) {
-        const response = await httpClient.delete(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/products/${productId}`, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to delete product'
-            };
-        }
-    }
-    /**
-     * Search products by text query
-     */
-    static async searchProducts(apiKey, agentId, searchQuery) {
-        const response = await httpClient.get(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/products/search?searchQuery=${encodeURIComponent(searchQuery)}`, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to search products'
-            };
-        }
-    }
-    /**
-     * Create a new user basket
-     */
-    static async createBasket(apiKey, agentId, basketData) {
-        const response = await httpClient.post(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/basket`, basketData, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to create basket'
-            };
-        }
-    }
-    /**
-     * Get all user baskets with optional status filter
-     */
-    static async getUserBaskets(apiKey, agentId, status) {
-        const statusParam = status ? `?status=${status}` : '';
-        const response = await httpClient.get(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/basket/user${statusParam}`, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to get user baskets'
-            };
-        }
-    }
-    /**
-     * Add item to basket
-     */
-    static async addItemToBasket(apiKey, agentId, basketId, itemData) {
-        const response = await httpClient.post(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/basket/${basketId}/item`, itemData, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to add item to basket'
-            };
-        }
-    }
-    /**
-     * Remove item from basket
-     */
-    static async removeItemFromBasket(apiKey, agentId, basketId, itemId) {
-        const response = await httpClient.delete(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/basket/${basketId}/item/${itemId}`, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to remove item from basket'
-            };
-        }
-    }
-    /**
-     * Clear basket (remove all items)
-     */
-    static async clearBasket(apiKey, agentId, basketId) {
-        const response = await httpClient.delete(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/basket/${basketId}/clear`, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to clear basket'
-            };
-        }
-    }
-    /**
-     * Update basket status
-     */
-    static async updateBasketStatus(apiKey, agentId, basketId, status) {
-        const response = await httpClient.put(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/basket/${basketId}/${status}`, undefined, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to update basket status'
-            };
-        }
-    }
-    /**
-     * Create order from basket
-     */
-    static async createOrder(apiKey, agentId, orderData) {
-        const response = await httpClient.post(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/order`, orderData, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to create order'
-            };
-        }
-    }
-    /**
-     * Update order status
-     */
-    static async updateOrderStatus(apiKey, agentId, orderId, status) {
-        const response = await httpClient.put(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/order/${orderId}/${status}`, undefined, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to update order status'
-            };
-        }
-    }
-    /**
-     * Get user orders with optional status filter
-     */
-    static async getUserOrders(apiKey, agentId, userId, status) {
-        const statusParam = status ? `?status=${status}` : '';
-        const response = await httpClient.get(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/order/user/${userId}${statusParam}`, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to get user orders'
-            };
-        }
-    }
-}
-/**
- * Tool API calls (for compile command)
- */
-export class ToolApi {
-    static async getTool(url, apiKey) {
-        return httpClient.get(url, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-    }
-    static async postTool(url, data, apiKey) {
-        return httpClient.post(url, data, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-    }
-    static async putTool(url, data, apiKey) {
-        return httpClient.put(url, data, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-    }
-    static async deleteTool(url, apiKey) {
-        return httpClient.delete(url, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-    }
-    static async patchTool(url, data, apiKey) {
-        return httpClient.patch(url, data, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-    }
-}
-// User Data API calls
-export class UserDataApi {
-    static async getUserData(apiKey, agentId) {
-        const response = await httpClient.get(`${BASE_URLS.LOCAL}/developer/user/data/agent/${agentId}`, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        return response;
-    }
-    static async createUserData(apiKey, agentId, data) {
-        const response = await httpClient.put(`${BASE_URLS.LOCAL}/developer/user/data/agent/${agentId}`, data, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        return response.data.data;
-    }
-    static async updateUserData(apiKey, agentId, data) {
-        const response = await httpClient.put(`${BASE_URLS.LOCAL}/developer/user/data/agent/${agentId}`, data, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        return response.data.data;
-    }
-    static async deleteUserData(apiKey, agentId) {
-        const response = await httpClient.delete(`${BASE_URLS.LOCAL}/developer/user/data/agent/${agentId}`, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        return response;
-    }
-}
-// Custom Data API calls
-export class CustomDataApi {
-    /**
-     * Create a new custom data entry
-     */
-    static async createCustomData(apiKey, agentId, collectionName, data) {
-        const response = await httpClient.post(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/custom-data/${collectionName}`, data, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to create custom data entry'
-            };
-        }
-    }
-    /**
-     * Get custom data entries with optional filtering and pagination
-     */
-    static async getCustomData(apiKey, agentId, collectionName, filter, page = 1, limit = 10) {
-        let url = `${BASE_URLS.LOCAL}/developer/agents/${agentId}/custom-data/${collectionName}?page=${page}&limit=${limit}`;
-        if (filter) {
-            const encodedFilter = encodeURIComponent(JSON.stringify(filter));
-            url += `&filter=${encodedFilter}`;
-        }
-        const response = await httpClient.get(url, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to get custom data entries'
-            };
-        }
-    }
-    /**
-     * Get a single custom data entry by ID
-     */
-    static async getCustomDataEntry(apiKey, agentId, collectionName, entryId) {
-        const response = await httpClient.get(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/custom-data/${collectionName}/${entryId}`, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to get custom data entry'
-            };
-        }
-    }
-    /**
-     * Update a custom data entry
-     */
-    static async updateCustomData(apiKey, agentId, collectionName, entryId, data) {
-        const response = await httpClient.put(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/custom-data/${collectionName}/${entryId}`, data, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to update custom data entry'
-            };
-        }
-    }
-    /**
-     * Search custom data entries by text
-     */
-    static async searchCustomData(apiKey, agentId, collectionName, searchText, limit = 10, scoreThreshold = 0.6) {
-        const url = `${BASE_URLS.LOCAL}/developer/agents/${agentId}/custom-data/${collectionName}/search?searchText=${encodeURIComponent(searchText)}&limit=${limit}&scoreThreshold=${scoreThreshold}`;
-        const response = await httpClient.get(url, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to search custom data entries'
-            };
-        }
-    }
-    /**
-     * Delete a custom data entry
-     */
-    static async deleteCustomData(apiKey, agentId, collectionName, entryId) {
-        const response = await httpClient.delete(`${BASE_URLS.LOCAL}/developer/agents/${agentId}/custom-data/${collectionName}/${entryId}`, {
-            Authorization: `Bearer ${apiKey}`,
-        });
-        if (response.success) {
-            return response.data;
-        }
-        else {
-            return {
-                success: false,
-                message: response.error?.message || 'Failed to delete custom data entry'
-            };
-        }
-    }
-}
-/**
- * Main API service that exports all API classes
- */
-export const ApiService = {
-    Auth: AuthApi,
-    Agent: AgentApi,
-    Skill: SkillApi,
-    Chat: ChatApi,
-    Product: ProductApi,
-    Tool: ToolApi,
-    UserData: UserDataApi,
-    CustomData: CustomDataApi,
-};

package/dist/skill.d.ts

@@ -1,50 +0,0 @@
-import { ZodType } from "zod";
-import { LuaTool } from "./types/index.js";
-export { LuaTool };
-/**
- * Safe environment variable access function
- * Gets injected at runtime with skill-specific environment variables
- *
- * @param key - The environment variable key to retrieve
- * @returns The environment variable value or undefined if not found
- *
- * @example
- * ```typescript
- * const baseUrl = env('BASE_URL');
- * const apiKey = env('API_KEY');
- * ```
- */
-export declare const env: (key: string) => string | undefined;
-export interface LuaSkillConfig {
-    name?: string;
-    version?: string;
-    description: string;
-    context: string;
-    tools?: LuaTool<any>[];
-}
-export declare class LuaSkill {
-    private readonly tools;
-    private readonly name;
-    private readonly version;
-    private readonly description;
-    private readonly context;
-    /**
-     * Creates a new LuaSkill instance
-     *
-     * @param config - Configuration object containing skill metadata
-     * @param config.description - Short description of what the skill does (1-2 sentences)
-     * @param config.context - Detailed explanation of how the agent should use the tools
-     *
-     * @example
-     * ```typescript
-     * const skill = new LuaSkill({
-     *   description: "Weather and calculator utilities",
-     *   context: "This skill provides weather information for any city and basic mathematical operations. Use get_weather for current conditions and calculator for arithmetic operations."
-     * });
-     * ```
-     */
-    constructor(config: LuaSkillConfig);
-    addTool<TInput extends ZodType>(tool: LuaTool<TInput>): void;
-    addTools(tools: LuaTool<any>[]): void;
-    run(input: Record<string, any>): Promise<any>;
-}

package/dist/types.d.ts

@@ -1 +0,0 @@
-export * from "./types/index.js";

package/dist/types.js

@@ -1,2 +0,0 @@
-// Re-export types for external use
-export * from "./types/index.js";

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

@@ -1,39 +0,0 @@
-/**
- * User Data API for Lua CLI projects
- * Provides methods to interact with user data stored in the Lua system
- */
-export declare class UserDataAPI {
-    userData: any;
-    constructor();
-    /**
-     * Get user data for the current agent
-     * @returns Promise<UserDataResponse>
-     */
-    get(): Promise<any>;
-    /**
-     * Create or update user data for the current agent
-     * @param data - The user data to store
-     * @returns Promise<UserDataResponse>
-     */
-    create(data: Record<string, any>): Promise<any>;
-    /**
-     * Update existing user data for the current agent
-     * @param data - The user data to update
-     * @returns Promise<UserDataResponse>
-     */
-    update(data: Record<string, any>): Promise<any>;
-    /**
-     * Clear all user data for the current agent
-     * @returns Promise<{success: boolean}>
-     */
-    clear(): Promise<{
-        success: boolean;
-    }>;
-}
-/**
- * Convenience object for user data operations
- * Usage: user.data.get(), user.data.create(data), user.data.update(data), user.data.clear()
- */
-export declare const user: {
-    data: UserDataAPI;
-};