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

package/dist/commands/test.js

@@ -1,230 +1,83 @@
-import fs from "fs";
-import path from "path";
-import inquirer from "inquirer";
+/**
+ * Test Command
+ * Orchestrates the testing of individual tools in a local sandbox environment
+ */
 import { compileCommand } from "./compile.js";
-import { gunzipSync } from "zlib";
-import { Buffer } from "buffer";
 import { withErrorHandling, clearPromptLines, writeProgress, writeSuccess } from "../utils/cli.js";
 import { loadApiKey } from "../services/auth.js";
 import { executeTool, loadEnvironmentVariables } from "../utils/sandbox.js";
 import { readSkillConfig } from "../utils/files.js";
-// Decompression utility
-function decompressCode(compressedCode) {
-    const buffer = Buffer.from(compressedCode, 'base64');
-    return gunzipSync(buffer).toString('utf8');
-}
+import { decompressCode, readDeployJson, extractToolsFromDeployData, hasEnvFile, hasConfigEnvVars, } from "../utils/test-helpers.js";
+import { promptToolSelection, generatePromptsForObject } from "../utils/test-prompts.js";
+/**
+ * Main test command - tests a tool in a local sandbox environment.
+ *
+ * This command performs the following steps:
+ * 1. Compiles the skill to ensure latest code
+ * 2. Loads deploy.json with tool definitions
+ * 3. Extracts all available tools
+ * 4. Prompts user to select a tool
+ * 5. Collects input values based on tool's input schema
+ * 6. Executes the tool in a sandboxed environment
+ * 7. Displays the results
+ *
+ * Features:
+ * - Interactive tool selection from compiled tools
+ * - Dynamic input prompts based on tool schemas
+ * - Support for nested object inputs
+ * - Environment variable injection
+ * - Secure sandbox execution
+ * - Detailed error reporting
+ *
+ * @returns Promise that resolves when test completes
+ */
 export async function testCommand() {
     return withErrorHandling(async () => {
         writeProgress("🧪 Testing Lua skill...");
-        // First, compile the code
+        // Step 1: Compile the code
         writeProgress("📦 Compiling code first...");
         await compileCommand();
-        // Check if .lua directory exists
-        const luaDir = path.join(process.cwd(), ".lua");
-        if (!fs.existsSync(luaDir)) {
-            throw new Error(".lua directory not found. Run 'lua compile' first.");
-        }
-        // Read deploy.json
-        const deployJsonPath = path.join(luaDir, "deploy.json");
-        if (!fs.existsSync(deployJsonPath)) {
-            throw new Error("deploy.json not found. Run 'lua compile' first.");
-        }
-        const deployData = JSON.parse(fs.readFileSync(deployJsonPath, "utf8"));
-        // Extract all tools from deploy.json (handle both new and legacy formats)
-        let allTools = [];
-        if (deployData.skills && Array.isArray(deployData.skills)) {
-            // New format: extract tools from skills array
-            deployData.skills.forEach((skill) => {
-                if (skill.tools && Array.isArray(skill.tools)) {
-                    skill.tools.forEach((tool) => {
-                        allTools.push({
-                            ...tool,
-                            skillName: skill.name // Add skill context
-                        });
-                    });
-                }
-            });
-        }
-        else if (deployData.tools) {
-            // Legacy format: tools as object or array
-            if (Array.isArray(deployData.tools)) {
-                allTools = deployData.tools;
-            }
-            else {
-                // Convert tools object to array
-                allTools = Object.entries(deployData.tools).map(([name, tool]) => ({
-                    name,
-                    ...tool
-                }));
-            }
-        }
-        if (allTools.length === 0) {
-            throw new Error("No tools found in deploy.json");
-        }
-        // Get API key from keystore and agent ID from YAML
+        // Step 2: Load deploy data and extract tools
+        const deployData = readDeployJson();
+        const allTools = extractToolsFromDeployData(deployData);
+        // Step 3: Load authentication and configuration
         const apiKey = await loadApiKey();
         if (!apiKey) {
             throw new Error("No API key found. Please run 'lua auth configure' first.");
         }
-        // Extract environment variables from YAML config
         const config = readSkillConfig();
         const agentId = config?.agent?.agentId;
         if (!agentId) {
             throw new Error("No agent ID found in lua.skill.yaml. Please run 'lua init' first.");
         }
-        // Load environment variables from multiple sources (.env + yaml)
+        // Step 4: Load environment variables
         const envVars = loadEnvironmentVariables();
-        if (fs.existsSync(path.join(process.cwd(), '.env'))) {
+        if (hasEnvFile()) {
             writeProgress(`📄 Loaded environment variables from .env file`);
         }
-        if (config?.skill?.env && Object.keys(config.skill.env).length > 0) {
+        if (hasConfigEnvVars(config)) {
             writeProgress(`📄 Loaded environment variables from lua.skill.yaml`);
         }
-        // Let user select a tool using picker
-        const toolChoices = allTools.map((tool) => ({
-            name: tool.skillName ? `${tool.name} (${tool.skillName}) - ${tool.description}` : `${tool.name} - ${tool.description}`,
-            value: tool
-        }));
-        const { selectedTool } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'selectedTool',
-                message: '🔧 Select a tool to test:',
-                choices: toolChoices,
-                pageSize: 10
-            }
-        ]);
-        // Clear the tool selection prompt lines
+        // Step 5: Let user select a tool
+        const selectedTool = await promptToolSelection(allTools);
         clearPromptLines(2);
         writeProgress(`✅ Selected tool: ${selectedTool.name}`);
-        // Get input values for each required parameter using inquirer
+        // Step 6: Collect input values based on schema
         let inputValues = {};
         const inputSchema = selectedTool.inputSchema;
         if (inputSchema.properties) {
             writeProgress("\n📝 Enter input values:");
-            // Recursive function to generate prompts for nested objects
-            async function generatePromptsForObject(schema, prefix = '', required = []) {
-                const prompts = [];
-                const result = {};
-                for (const [key, value] of Object.entries(schema.properties || {})) {
-                    const property = value;
-                    const fullKey = prefix ? `${prefix}.${key}` : key;
-                    const isRequired = required.includes(key);
-                    if (property.type === "object" && property.properties) {
-                        // Handle nested object - use fullKey to maintain proper prompt names
-                        writeProgress(`\n📋 Entering values for ${key}:`);
-                        const nestedResult = await generatePromptsForObject(property, fullKey, property.required || []);
-                        // Extract the nested values from the nested result
-                        result[key] = nestedResult[key] || nestedResult;
-                    }
-                    else {
-                        // Handle primitive types
-                        let promptType = 'input';
-                        let validate = undefined;
-                        switch (property.type) {
-                            case "string":
-                                if (isRequired) {
-                                    validate = (input) => input.trim() !== "" || `${key} is required`;
-                                }
-                                break;
-                            case "number":
-                                promptType = 'number';
-                                if (isRequired) {
-                                    validate = (input) => !isNaN(input) || `${key} must be a valid number`;
-                                }
-                                break;
-                            case "boolean":
-                                promptType = 'confirm';
-                                break;
-                            default:
-                                if (isRequired) {
-                                    validate = (input) => input.trim() !== "" || `${key} is required`;
-                                }
-                        }
-                        const prompt = {
-                            type: promptType,
-                            name: fullKey,
-                            message: `${key}${isRequired ? " (required)" : " (optional)"}:`,
-                            validate: validate,
-                        };
-                        prompts.push(prompt);
-                    }
-                }
-                if (prompts.length > 0) {
-                    const answers = await inquirer.prompt(prompts);
-                    // Convert answers to proper types and structure
-                    for (const [key, value] of Object.entries(answers)) {
-                        const keyParts = key.split('.');
-                        const propertyKey = keyParts[keyParts.length - 1];
-                        // For nested properties, we need to find the property in the original schema
-                        let currentSchema = inputSchema; // Use the original inputSchema
-                        let currentProperty = null;
-                        // Navigate through nested schemas to find the property
-                        for (let i = 0; i < keyParts.length; i++) {
-                            const part = keyParts[i];
-                            if (currentSchema.properties && currentSchema.properties[part]) {
-                                currentProperty = currentSchema.properties[part];
-                                if (i < keyParts.length - 1) {
-                                    // Move to nested schema
-                                    currentSchema = currentProperty;
-                                }
-                            }
-                        }
-                        if (currentProperty) {
-                            let convertedValue = value;
-                            switch (currentProperty.type) {
-                                case "number":
-                                    convertedValue = parseFloat(value);
-                                    break;
-                                case "boolean":
-                                    convertedValue = value;
-                                    break;
-                                default:
-                                    convertedValue = value;
-                            }
-                            // Check if field is optional and value is empty - skip if so
-                            // For nested properties, check the parent schema's required fields
-                            const parentSchema = keyParts.length > 1 ? currentSchema : schema;
-                            const isOptional = !parentSchema.required || !parentSchema.required.includes(propertyKey);
-                            const isEmpty = convertedValue === '' || convertedValue === null || convertedValue === undefined;
-                            if (isOptional && isEmpty) {
-                                // Skip optional empty fields
-                                continue;
-                            }
-                            // Build nested structure
-                            if (keyParts.length === 1) {
-                                // Top-level property
-                                result[propertyKey] = convertedValue;
-                            }
-                            else {
-                                // Nested property - build the nested structure
-                                let current = result;
-                                for (let i = 0; i < keyParts.length - 1; i++) {
-                                    const part = keyParts[i];
-                                    if (!current[part]) {
-                                        current[part] = {};
-                                    }
-                                    current = current[part];
-                                }
-                                current[propertyKey] = convertedValue;
-                            }
-                        }
-                    }
-                }
-                return result;
-            }
             inputValues = await generatePromptsForObject(inputSchema, '', inputSchema.required || []);
         }
+        // Step 7: Execute the tool
         writeProgress("\n🚀 Executing tool...");
         writeProgress(`Input: ${JSON.stringify(inputValues, null, 2)}`);
-        // Get the execute function string directly from the selected tool and decompress it
         const toolCode = decompressCode(selectedTool.execute);
-        // Set environment variables in process.env for the sandbox to pick up
+        // Set environment variables for sandbox
         const originalEnv = { ...process.env };
         for (const [key, value] of Object.entries(envVars)) {
             process.env[key] = value;
         }
-        // Execute the tool
         try {
             const result = await executeTool({
                 toolCode,

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

@@ -1,6 +1,10 @@
-import { Basket, BasketItem, BasketStatus } from "../interfaces/baskets";
-import { BasketAPI } from "../types";
-import OrderInstance from "./order.instance";
+import { Basket, BasketItem, BasketStatus } from "../interfaces/baskets.js";
+import { BasketAPI } from "../types/index.js";
+import OrderInstance from "./order.instance.js";
+/**
+ * Basket instance class providing a fluent API for managing user baskets
+ * Provides methods for adding/removing items, updating metadata, and placing orders
+ */
 export default class BasketInstance {
     private id;
     private userId;
@@ -12,16 +16,63 @@ export default class BasketInstance {
     itemCount: number;
     status: BasketStatus;
     private basketAPI;
+    /**
+     * Creates a new BasketInstance
+     * @param api - The BasketAPI instance for making API calls
+     * @param basket - The basket data from the API
+     */
     constructor(api: BasketAPI, basket: Basket);
     /**
      * Custom toJSON method to control what gets serialized when logging
+     * @returns Serialized basket data combining data and common fields
      */
     toJSON(): Record<string, any>;
+    /**
+     * Updates the basket's metadata
+     * @param metadata - The metadata object to merge with existing metadata
+     * @returns Promise resolving to the updated basket data
+     * @throws Error if the metadata update fails
+     */
     updateMetadata(metadata: any): Promise<any>;
+    /**
+     * Updates the basket's status
+     * @param status - The new basket status to set
+     * @returns Promise resolving to the updated basket data
+     * @throws Error if the status update fails
+     */
     updateStatus(status: BasketStatus): Promise<any>;
+    /**
+     * Updates the basket instance with new data from the API
+     * @param basket - The updated basket data from the API
+     * @returns The combined basket data and common fields
+     * @private
+     */
     private updateBasket;
+    /**
+     * Adds an item to the basket
+     * @param item - The basket item to add (must include productId and quantity)
+     * @returns Promise resolving to the updated basket data
+     * @throws Error if the item cannot be added
+     */
     addItem(item: BasketItem): Promise<any>;
+    /**
+     * Removes an item from the basket
+     * @param itemId - The unique identifier of the item to remove
+     * @returns Promise resolving to the updated basket data
+     * @throws Error if the item cannot be removed or is not found
+     */
     removeItem(itemId: string): Promise<any>;
+    /**
+     * Clears all items from the basket
+     * @returns Promise resolving to the updated empty basket data
+     * @throws Error if the clear operation fails
+     */
     clear(): Promise<any>;
+    /**
+     * Places an order from the basket contents
+     * @param data - Additional order data (shipping info, payment details, etc.)
+     * @returns Promise resolving to an OrderInstance representing the created order
+     * @throws Error if the order creation fails
+     */
     placeOrder(data: Record<string, any>): Promise<OrderInstance>;
 }

package/dist/common/basket.instance.js

@@ -1,5 +1,14 @@
-import { BasketStatus } from "../interfaces/baskets";
+import { BasketStatus } from "../interfaces/baskets.js";
+/**
+ * Basket instance class providing a fluent API for managing user baskets
+ * Provides methods for adding/removing items, updating metadata, and placing orders
+ */
 export default class BasketInstance {
+    /**
+     * Creates a new BasketInstance
+     * @param api - The BasketAPI instance for making API calls
+     * @param basket - The basket data from the API
+     */
     constructor(api, basket) {
         this.data = basket.data;
         this.common = basket.common;
@@ -20,32 +29,54 @@ export default class BasketInstance {
     }
     /**
      * Custom toJSON method to control what gets serialized when logging
+     * @returns Serialized basket data combining data and common fields
      */
     toJSON() {
         return {
             ...this.data,
-            ...this.common
+            ...this.common,
+            id: this.id
         };
     }
     /**
      * Custom inspect method for Node.js console.log
+     * @returns Formatted basket data for console output
      */
     [Symbol.for('nodejs.util.inspect.custom')]() {
         return {
             ...this.data,
             ...this.common,
+            id: this.id
         };
     }
+    /**
+     * Updates the basket's metadata
+     * @param metadata - The metadata object to merge with existing metadata
+     * @returns Promise resolving to the updated basket data
+     * @throws Error if the metadata update fails
+     */
     async updateMetadata(metadata) {
         await this.basketAPI.updateMetadata(this.id, metadata);
         this.data.metadata = { ...this.data.metadata, ...metadata };
         return { ...this.data, ...this.common };
     }
+    /**
+     * Updates the basket's status
+     * @param status - The new basket status to set
+     * @returns Promise resolving to the updated basket data
+     * @throws Error if the status update fails
+     */
     async updateStatus(status) {
         await this.basketAPI.updateStatus(this.id, status);
         this.common.status = status;
         return { ...this.data, ...this.common };
     }
+    /**
+     * Updates the basket instance with new data from the API
+     * @param basket - The updated basket data from the API
+     * @returns The combined basket data and common fields
+     * @private
+     */
     updateBasket(basket) {
         this.data = basket.data;
         this.common = basket.common;
@@ -58,21 +89,43 @@ export default class BasketInstance {
         this.status = basket.common.status;
         return { ...this.data, ...this.common };
     }
+    /**
+     * Adds an item to the basket
+     * @param item - The basket item to add (must include productId and quantity)
+     * @returns Promise resolving to the updated basket data
+     * @throws Error if the item cannot be added
+     */
     async addItem(item) {
         const basket = await this.basketAPI.addItem(this.id, item);
         return this.updateBasket(basket);
     }
+    /**
+     * Removes an item from the basket
+     * @param itemId - The unique identifier of the item to remove
+     * @returns Promise resolving to the updated basket data
+     * @throws Error if the item cannot be removed or is not found
+     */
     async removeItem(itemId) {
         const basket = await this.basketAPI.removeItem(this.id, itemId);
         return this.updateBasket(basket);
     }
+    /**
+     * Clears all items from the basket
+     * @returns Promise resolving to the updated empty basket data
+     * @throws Error if the clear operation fails
+     */
     async clear() {
         const basket = await this.basketAPI.clear(this.id);
         return this.updateBasket(basket);
     }
+    /**
+     * Places an order from the basket contents
+     * @param data - Additional order data (shipping info, payment details, etc.)
+     * @returns Promise resolving to an OrderInstance representing the created order
+     * @throws Error if the order creation fails
+     */
     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/data.entry.instance.d.ts

@@ -1,16 +1,39 @@
-import { CustomDataAPI } from "../types";
-import { CreateCustomDataResponse } from "../interfaces/custom.data";
+import { CustomDataAPI } from "../types/index.js";
+import { CreateCustomDataResponse } from "../interfaces/custom.data.js";
+/**
+ * Data entry instance class providing a fluent API for managing custom data entries
+ * Provides methods for updating and deleting individual data entries
+ */
 export default class DataEntryInstance {
     data: Record<string, any>;
     id: string;
     collectionName: string;
     score?: number;
     private customDataAPI;
+    /**
+     * Creates a new DataEntryInstance
+     * @param api - The CustomDataAPI instance for making API calls
+     * @param entry - The custom data entry response from the API
+     * @param collectionName - The name of the collection this entry belongs to
+     */
     constructor(api: CustomDataAPI, entry: CreateCustomDataResponse, collectionName: string);
     /**
      * Custom toJSON method to control what gets serialized when logging
+     * @returns Serialized data entry including score if available
      */
     toJSON(): Record<string, any>;
+    /**
+     * Updates the custom data entry
+     * @param data - The data fields to update (partial update supported)
+     * @param searchText - Optional new search text for semantic search indexing
+     * @returns Promise resolving to the updated data
+     * @throws Error if the update fails
+     */
     update(data: Record<string, any>, searchText?: string): Promise<any>;
+    /**
+     * Deletes the custom data entry
+     * @returns Promise resolving to true if deletion was successful
+     * @throws Error if the deletion fails
+     */
     delete(): Promise<boolean>;
 }

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

@@ -1,4 +1,14 @@
+/**
+ * Data entry instance class providing a fluent API for managing custom data entries
+ * Provides methods for updating and deleting individual data entries
+ */
 export default class DataEntryInstance {
+    /**
+     * Creates a new DataEntryInstance
+     * @param api - The CustomDataAPI instance for making API calls
+     * @param entry - The custom data entry response from the API
+     * @param collectionName - The name of the collection this entry belongs to
+     */
     constructor(api, entry, collectionName) {
         this.data = entry.data;
         this.id = entry.id;
@@ -14,6 +24,7 @@ export default class DataEntryInstance {
     }
     /**
      * Custom toJSON method to control what gets serialized when logging
+     * @returns Serialized data entry including score if available
      */
     toJSON() {
         return {
@@ -23,6 +34,7 @@ export default class DataEntryInstance {
     }
     /**
      * Custom inspect method for Node.js console.log
+     * @returns Formatted data entry for console output
      */
     [Symbol.for('nodejs.util.inspect.custom')]() {
         return {
@@ -30,6 +42,13 @@ export default class DataEntryInstance {
             score: this.score
         };
     }
+    /**
+     * Updates the custom data entry
+     * @param data - The data fields to update (partial update supported)
+     * @param searchText - Optional new search text for semantic search indexing
+     * @returns Promise resolving to the updated data
+     * @throws Error if the update fails
+     */
     async update(data, searchText) {
         try {
             const response = await this.customDataAPI.update(this.collectionName, this.id, { data, searchText });
@@ -40,6 +59,11 @@ export default class DataEntryInstance {
             throw new Error('Failed to update user data');
         }
     }
+    /**
+     * Deletes the custom data entry
+     * @returns Promise resolving to true if deletion was successful
+     * @throws Error if the deletion fails
+     */
     async delete() {
         try {
             await this.customDataAPI.delete(this.collectionName, this.id);

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

@@ -1,14 +1,64 @@
-import { ApiResponse } from "../interfaces/admin";
+import { ApiResponse } from "../interfaces/common.js";
 /**
  * Generic HTTP client with common error handling
+ * Provides a base class for all API service classes with standardized HTTP methods
  */
 export declare abstract class HttpClient {
     protected baseUrl: string;
+    /**
+     * Creates an instance of HttpClient
+     * @param baseUrl - The base URL for all API requests
+     */
     constructor(baseUrl: string);
+    /**
+     * Makes an HTTP request with standardized error handling
+     * @param url - The full URL to request
+     * @param options - Fetch API request options
+     * @returns Promise resolving to an ApiResponse with typed data
+     * @private
+     */
     private request;
+    /**
+     * Performs an HTTP GET request
+     * @param url - The relative URL path to request (will be appended to baseUrl)
+     * @param headers - Optional HTTP headers to include in the request
+     * @returns Promise resolving to an ApiResponse with typed data
+     * @protected
+     */
     protected httpGet<T>(url: string, headers?: Record<string, string>): Promise<ApiResponse<T>>;
+    /**
+     * Performs an HTTP POST request
+     * @param url - The relative URL path to request (will be appended to baseUrl)
+     * @param data - Optional request body data (will be JSON stringified)
+     * @param headers - Optional HTTP headers to include in the request
+     * @returns Promise resolving to an ApiResponse with typed data
+     * @protected
+     */
     protected httpPost<T>(url: string, data?: any, headers?: Record<string, string>): Promise<ApiResponse<T>>;
+    /**
+     * Performs an HTTP PUT request
+     * @param url - The relative URL path to request (will be appended to baseUrl)
+     * @param data - Optional request body data (will be JSON stringified)
+     * @param headers - Optional HTTP headers to include in the request
+     * @returns Promise resolving to an ApiResponse with typed data
+     * @protected
+     */
     protected httpPut<T>(url: string, data?: any, headers?: Record<string, string>): Promise<ApiResponse<T>>;
+    /**
+     * Performs an HTTP DELETE request
+     * @param url - The relative URL path to request (will be appended to baseUrl)
+     * @param headers - Optional HTTP headers to include in the request
+     * @returns Promise resolving to an ApiResponse with typed data
+     * @protected
+     */
     protected httpDelete<T>(url: string, headers?: Record<string, string>): Promise<ApiResponse<T>>;
+    /**
+     * Performs an HTTP PATCH request
+     * @param url - The relative URL path to request (will be appended to baseUrl)
+     * @param data - Optional request body data (will be JSON stringified)
+     * @param headers - Optional HTTP headers to include in the request
+     * @returns Promise resolving to an ApiResponse with typed data
+     * @protected
+     */
     protected httpPatch<T>(url: string, data?: any, headers?: Record<string, string>): Promise<ApiResponse<T>>;
 }