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

package/dist/utils/push-helpers.js

@@ -0,0 +1,84 @@
+/**
+ * Push Helper Utilities
+ * Helper functions for the push command
+ */
+import fs from 'fs';
+import path from 'path';
+import inquirer from 'inquirer';
+import { readSkillConfig } from './files.js';
+import { clearPromptLines } from './cli.js';
+/**
+ * Reads the version from skill configuration.
+ *
+ * @returns Version string or null if not found
+ */
+export function readConfigVersion() {
+    const config = readSkillConfig();
+    return config?.skill?.version || null;
+}
+/**
+ * Reads and parses deploy.json file.
+ *
+ * @returns Parsed deploy data or null if not found
+ */
+export function readDeployJson() {
+    const deployPath = path.join(process.cwd(), '.lua', 'deploy.json');
+    if (!fs.existsSync(deployPath)) {
+        return null;
+    }
+    const deployContent = fs.readFileSync(deployPath, 'utf8');
+    return JSON.parse(deployContent);
+}
+/**
+ * Prompts user to confirm version push.
+ *
+ * @param version - Version to push
+ * @returns True if confirmed, false otherwise
+ */
+export async function confirmVersionPush(version) {
+    const { confirmed } = await inquirer.prompt([
+        {
+            type: "confirm",
+            name: "confirmed",
+            message: `Are you sure you want to push version ${version}?`,
+            default: false
+        }
+    ]);
+    clearPromptLines(2);
+    return confirmed;
+}
+/**
+ * Validates that configuration has required fields for push.
+ *
+ * @param config - Skill configuration
+ * @throws Error if configuration is invalid
+ */
+export function validatePushConfig(config) {
+    if (!config) {
+        throw new Error("No lua.skill.yaml found. Please run this command from a skill directory.");
+    }
+    if (!config.skill?.version) {
+        throw new Error("No version found in skill configuration");
+    }
+    if (!config.agent?.agentId) {
+        throw new Error("Missing agentId in skill configuration");
+    }
+    if (!config.skill?.skillId) {
+        throw new Error("Missing skillId in skill configuration");
+    }
+}
+/**
+ * Validates that deploy data matches configuration.
+ *
+ * @param deployData - Deploy data from deploy.json
+ * @param configVersion - Version from configuration
+ * @throws Error if deploy data is invalid or version mismatch
+ */
+export function validateDeployData(deployData, configVersion) {
+    if (!deployData) {
+        throw new Error("No deploy.json found. Compilation may have failed.");
+    }
+    if (deployData.version !== configVersion) {
+        throw new Error(`Version mismatch: config has ${configVersion}, deploy.json has ${deployData.version}`);
+    }
+}

package/dist/utils/sandbox-storage.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Sandbox Storage Utilities
+ * Handles secure storage and retrieval of sandbox skill IDs using keytar
+ */
+import { SkillOverride } from '../interfaces/dev.js';
+/**
+ * Retrieves sandbox skill ID from secure storage.
+ *
+ * @param skillName - Optional skill name for multi-skill projects
+ * @returns The sandbox skill ID or null if not found
+ */
+export declare function getSandboxSkillId(skillName?: string): Promise<string | null>;
+/**
+ * Stores sandbox skill ID in secure storage.
+ *
+ * @param sandboxId - The sandbox skill ID to store
+ * @param skillName - Optional skill name for multi-skill projects
+ */
+export declare function setSandboxSkillId(sandboxId: string, skillName?: string): Promise<void>;
+/**
+ * Retrieves all sandbox skill IDs for all skills in the project.
+ * Reads the deploy.json file to discover all skills and their sandbox IDs.
+ *
+ * @param deployData - The deploy.json data containing skill information
+ * @returns Array of skill overrides with skillId and sandboxId pairs
+ */
+export declare function getAllSandboxSkillIds(deployData: any): Promise<SkillOverride[]>;

package/dist/utils/sandbox-storage.js

@@ -0,0 +1,71 @@
+/**
+ * Sandbox Storage Utilities
+ * Handles secure storage and retrieval of sandbox skill IDs using keytar
+ */
+import keytar from 'keytar';
+import { SANDBOX_STORAGE } from '../config/dev.constants.js';
+/**
+ * Retrieves sandbox skill ID from secure storage.
+ *
+ * @param skillName - Optional skill name for multi-skill projects
+ * @returns The sandbox skill ID or null if not found
+ */
+export async function getSandboxSkillId(skillName) {
+    try {
+        const account = skillName
+            ? `${SANDBOX_STORAGE.ACCOUNT}_${skillName}`
+            : SANDBOX_STORAGE.ACCOUNT;
+        return await keytar.getPassword(SANDBOX_STORAGE.SERVICE, account);
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Stores sandbox skill ID in secure storage.
+ *
+ * @param sandboxId - The sandbox skill ID to store
+ * @param skillName - Optional skill name for multi-skill projects
+ */
+export async function setSandboxSkillId(sandboxId, skillName) {
+    try {
+        const account = skillName
+            ? `${SANDBOX_STORAGE.ACCOUNT}_${skillName}`
+            : SANDBOX_STORAGE.ACCOUNT;
+        await keytar.setPassword(SANDBOX_STORAGE.SERVICE, account, sandboxId);
+    }
+    catch (error) {
+        // Ignore storage errors
+    }
+}
+/**
+ * Retrieves all sandbox skill IDs for all skills in the project.
+ * Reads the deploy.json file to discover all skills and their sandbox IDs.
+ *
+ * @param deployData - The deploy.json data containing skill information
+ * @returns Array of skill overrides with skillId and sandboxId pairs
+ */
+export async function getAllSandboxSkillIds(deployData) {
+    const skillOverrides = [];
+    try {
+        if (!deployData || !deployData.skills || !Array.isArray(deployData.skills)) {
+            return skillOverrides;
+        }
+        // For each skill, get its sandbox ID
+        for (const skill of deployData.skills) {
+            if (skill.skillId && skill.name) {
+                const sandboxId = await getSandboxSkillId(skill.name);
+                if (sandboxId) {
+                    skillOverrides.push({
+                        skillId: skill.skillId,
+                        sandboxId: sandboxId
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error('Error getting sandbox skill IDs:', error);
+    }
+    return skillOverrides;
+}

package/dist/utils/sandbox.js

@@ -2,8 +2,13 @@ import { createRequire } from "module";
 import vm from "vm";
 import path from "path";
 import fs from "fs";
-import { UserDataApi, ProductApi, CustomDataApi } from "../services/api.js";
 import { readSkillConfig } from "./files.js";
+import UserDataApiService from "../api/user.data.api.service.js";
+import { BASE_URLS } from "../config/constants.js";
+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 CustomDataApiService from "../api/custom.data.api.service.js";
 /**
  * Loads environment variables from multiple sources in priority order:
  * 1. process.env (lowest priority)
@@ -57,80 +62,73 @@ export function createSandbox(options) {
     const envVars = loadEnvironmentVariables();
     // Create a CommonJS context for execution
     const require = createRequire(process.cwd() + '/package.json');
-    const updateUserData = async (data) => {
-        return await UserDataApi.updateUserData(apiKey, agentId, data);
-    };
-    const getUserData = async () => {
-        return await UserDataApi.getUserData(apiKey, agentId);
-    };
-    const linkUserData = async (data) => {
-        return await UserDataApi.createUserData(apiKey, agentId, data);
-    };
-    const createProduct = async (data) => {
-        return await ProductApi.createProduct(apiKey, agentId, data);
-    };
-    const getProducts = async (page = 1, limit = 10) => {
-        return await ProductApi.getProducts(apiKey, agentId, page, limit);
-    };
-    const updateProduct = async (data, productId) => {
-        return await ProductApi.updateProduct(apiKey, agentId, { ...data, id: productId });
-    };
-    const deleteProduct = async (productId) => {
-        return await ProductApi.deleteProduct(apiKey, agentId, productId);
-    };
-    const searchProducts = async (searchQuery) => {
-        console.log('searchProducts', searchQuery);
-        return await ProductApi.searchProducts(apiKey, agentId, searchQuery);
-    };
-    const createBasket = async (data) => {
-        return await ProductApi.createBasket(apiKey, agentId, data);
-    };
-    const getBaskets = async (status) => {
-        return await ProductApi.getUserBaskets(apiKey, agentId, status);
-    };
-    const addItemToBasket = async (basketId, data) => {
-        return await ProductApi.addItemToBasket(apiKey, agentId, basketId, data);
-    };
-    const removeItemFromBasket = async (basketId, itemId) => {
-        return await ProductApi.removeItemFromBasket(apiKey, agentId, basketId, itemId);
-    };
-    const clearBasket = async (basketId) => {
-        return await ProductApi.clearBasket(apiKey, agentId, basketId);
-    };
-    const updateBasketStatus = async (basketId, status) => {
-        return await ProductApi.updateBasketStatus(apiKey, agentId, basketId, status);
-    };
-    const updateBasketMetadata = async (basketId, metadata) => {
-        return await ProductApi.updateBasketMetadata(apiKey, agentId, basketId, metadata);
-    };
-    const createOrder = async (data) => {
-        return await ProductApi.createOrder(apiKey, agentId, data);
-    };
-    const updateOrderStatus = async (orderId, status) => {
-        return await ProductApi.updateOrderStatus(apiKey, agentId, orderId, status);
-    };
-    const getUserOrders = async () => {
-        return await ProductApi.getUserOrders(apiKey, agentId);
-    };
-    // Custom Data API functions
-    const createCustomData = async (collectionName, data) => {
-        return await CustomDataApi.createCustomData(apiKey, agentId, collectionName, data);
-    };
-    const getCustomData = async (collectionName, filter, page = 1, limit = 10) => {
-        return await CustomDataApi.getCustomData(apiKey, agentId, collectionName, filter, page, limit);
-    };
-    const getCustomDataEntry = async (collectionName, entryId) => {
-        return await CustomDataApi.getCustomDataEntry(apiKey, agentId, collectionName, entryId);
-    };
-    const updateCustomData = async (collectionName, entryId, data) => {
-        return await CustomDataApi.updateCustomData(apiKey, agentId, collectionName, entryId, data);
-    };
-    const searchCustomData = async (collectionName, searchText, limit = 10, scoreThreshold = 0.6) => {
-        return await CustomDataApi.searchCustomData(apiKey, agentId, collectionName, searchText, limit, scoreThreshold);
-    };
-    const deleteCustomData = async (collectionName, entryId) => {
-        return await CustomDataApi.deleteCustomData(apiKey, agentId, collectionName, entryId);
-    };
+    // const updateUserData = async (data: any) => {
+    //   return await UserDataApi.updateUserData(apiKey, agentId, data);
+    // };
+    // const getUserData = async () => {
+    //   return await UserDataApi.getUserData(apiKey, agentId);
+    // };
+    // const linkUserData = async (data: any) => {
+    //   return await UserDataApi.createUserData(apiKey, agentId, data);
+    // };
+    // const createProduct = async (data: any) => {
+    //   return await ProductApi.createProduct(apiKey, agentId, data);
+    // };
+    // const getProducts = async (page: number = 1, limit: number = 10) => {
+    //   return await ProductApi.getProducts(apiKey, agentId, page, limit);
+    // };
+    // const updateProduct = async (data: any, productId: string) => {
+    //   return await ProductApi.updateProduct(apiKey, agentId, { ...data, id: productId });
+    // };
+    // const deleteProduct = async (productId: string) => {
+    //   return await ProductApi.deleteProduct(apiKey, agentId, productId);
+    // };
+    // const createBasket = async (data: any) => {
+    //   return await ProductApi.createBasket(apiKey, agentId, data);
+    // };
+    // const getBaskets = async (status?: BasketStatus) => {
+    //   return await ProductApi.getUserBaskets(apiKey, agentId, status);
+    // };
+    // const addItemToBasket = async (basketId: string, data: any) => {
+    //   return await ProductApi.addItemToBasket(apiKey, agentId, basketId, data);
+    // };
+    // const removeItemFromBasket = async (basketId: string, itemId: string) => {
+    //   return await ProductApi.removeItemFromBasket(apiKey, agentId, basketId, itemId);
+    // };
+    // const clearBasket = async (basketId: string) => {
+    //   return await ProductApi.clearBasket(apiKey, agentId, basketId);
+    // };
+    // const updateBasketStatus = async (basketId: string, status: BasketStatus) => {
+    //   return await ProductApi.updateBasketStatus(apiKey, agentId, basketId, status);
+    // };
+    // const createOrder = async (data: any) => {
+    //   return await ProductApi.createOrder(apiKey, agentId, data);
+    // };
+    // const updateOrderStatus = async (orderId: string, status: OrderStatus) => {
+    //   return await ProductApi.updateOrderStatus(apiKey, agentId, orderId, status);
+    // };
+    // const getUserOrders = async (userId: string) => {
+    //   return await ProductApi.getUserOrders(apiKey, agentId, userId);
+    // };
+    // // Custom Data API functions
+    // const createCustomData = async (collectionName: string, data: any) => {
+    //   return await CustomDataApi.createCustomData(apiKey, agentId, collectionName, data);
+    // };
+    // const getCustomData = async (collectionName: string, filter?: any, page: number = 1, limit: number = 10) => {
+    //   return await CustomDataApi.getCustomData(apiKey, agentId, collectionName, filter, page, limit);
+    // };
+    // const getCustomDataEntry = async (collectionName: string, entryId: string) => {
+    //   return await CustomDataApi.getCustomDataEntry(apiKey, agentId, collectionName, entryId);
+    // };
+    // const updateCustomData = async (collectionName: string, entryId: string, data: any) => {
+    //   return await CustomDataApi.updateCustomData(apiKey, agentId, collectionName, entryId, data);
+    // };
+    // const searchCustomData = async (collectionName: string, searchText: string, limit: number = 10, scoreThreshold: number = 0.6) => {
+    //   return await CustomDataApi.searchCustomData(apiKey, agentId, collectionName, searchText, limit, scoreThreshold);
+    // };
+    // const deleteCustomData = async (collectionName: string, entryId: string) => {
+    //   return await CustomDataApi.deleteCustomData(apiKey, agentId, collectionName, entryId);
+    // };
     // Create console object (use custom console if provided, otherwise default)
     const consoleObj = customConsole || console;
     // Create comprehensive polyfills for browser/Node.js APIs
@@ -259,49 +257,11 @@ export function createSandbox(options) {
         null: null,
         Infinity: Infinity,
         NaN: NaN,
-        user: {
-            data: {
-                update: updateUserData,
-                get: getUserData,
-                create: linkUserData
-            }
-        },
-        product: {
-            data: {
-                create: createProduct, // DEPRECATED
-                get: getProducts, // DEPRECATED
-                update: updateProduct, // DEPRECATED
-                delete: deleteProduct, // DEPRECATED
-                search: searchProducts // DEPRECATED
-            },
-            create: createProduct,
-            get: getProducts,
-            update: updateProduct,
-            delete: deleteProduct,
-            search: searchProducts,
-            basket: {
-                create: createBasket,
-                get: getBaskets,
-                addItem: addItemToBasket,
-                removeItem: removeItemFromBasket,
-                clear: clearBasket,
-                updateStatus: updateBasketStatus,
-                updateMetadata: updateBasketMetadata
-            },
-            order: {
-                create: createOrder,
-                updateStatus: updateOrderStatus,
-                get: getUserOrders
-            }
-        },
-        customData: {
-            create: createCustomData,
-            get: getCustomData,
-            getEntry: getCustomDataEntry,
-            update: updateCustomData,
-            search: searchCustomData,
-            delete: deleteCustomData
-        },
+        User: new UserDataApiService(BASE_URLS.API, apiKey, agentId),
+        Product: new ProductApiService(BASE_URLS.API, apiKey, agentId),
+        CustomData: new CustomDataApiService(BASE_URLS.API, apiKey, agentId),
+        Basket: new BasketApiService(BASE_URLS.API, apiKey, agentId),
+        Order: new OrderApiService(BASE_URLS.API, apiKey, agentId),
         // Environment variables function
         env: (key) => envVars[key]
     };

package/dist/utils/skill-management.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Skill Management Utilities
+ * Handles skill creation via API and YAML configuration management
+ */
+import { SkillConfig } from '../types/compile.types.js';
+/**
+ * Ensures all detected skills exist in the YAML config with valid skill IDs.
+ * If a skill doesn't exist or has no ID, creates it via the API.
+ *
+ * @param skillsArray - Array of skills detected from source code
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Updated skills array with valid skill IDs
+ */
+export declare function ensureSkillsExistInYaml(skillsArray: any[], config: SkillConfig): Promise<any[]>;

package/dist/utils/skill-management.js

@@ -0,0 +1,148 @@
+/**
+ * Skill Management Utilities
+ * Handles skill creation via API and YAML configuration management
+ */
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+import SkillApi from '../api/skills.api.service.js';
+import { BASE_URLS } from '../config/constants.js';
+import { loadApiKey } from '../services/auth.js';
+import { COMPILE_FILES, SKILL_DEFAULTS, YAML_FORMAT, } from '../config/compile.constants.js';
+/**
+ * Ensures all detected skills exist in the YAML config with valid skill IDs.
+ * If a skill doesn't exist or has no ID, creates it via the API.
+ *
+ * @param skillsArray - Array of skills detected from source code
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Updated skills array with valid skill IDs
+ */
+export async function ensureSkillsExistInYaml(skillsArray, config) {
+    const updatedSkillsArray = [];
+    let yamlUpdated = false;
+    const existingSkills = config?.skills || [];
+    const existingSkillsMap = createSkillsMap(existingSkills);
+    // Process each detected skill
+    for (const skill of skillsArray) {
+        const existingSkill = existingSkillsMap.get(skill.name);
+        if (existingSkill && existingSkill.skillId && existingSkill.skillId !== '') {
+            // Skill exists with valid skillId - reuse it
+            updatedSkillsArray.push({
+                ...skill,
+                skillId: existingSkill.skillId
+            });
+        }
+        else {
+            // Skill doesn't exist or missing skillId - create via API
+            const createdSkill = await createSkillViaApi(skill, config, existingSkills, existingSkill);
+            updatedSkillsArray.push(createdSkill);
+            yamlUpdated = true;
+        }
+    }
+    // Update YAML file if any changes were made
+    if (yamlUpdated) {
+        await updateYamlWithSkills(existingSkills, config);
+    }
+    return updatedSkillsArray;
+}
+/**
+ * Creates a map of existing skills for quick lookup by name.
+ *
+ * @param existingSkills - Array of skills from YAML config
+ * @returns Map of skill names to skill objects
+ */
+function createSkillsMap(existingSkills) {
+    const map = new Map();
+    existingSkills.forEach((skill) => {
+        map.set(skill.name, skill);
+    });
+    return map;
+}
+/**
+ * Creates a new skill via the Lua API and updates the config.
+ *
+ * @param skill - The skill to create
+ * @param config - The skill configuration
+ * @param existingSkills - Array of existing skills (mutated)
+ * @param existingSkill - The existing skill entry if one exists (may be without ID)
+ * @returns The skill with its new ID
+ */
+async function createSkillViaApi(skill, config, existingSkills, existingSkill) {
+    try {
+        // Validate prerequisites
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            throw new Error("No API key found. Run 'lua auth configure' first.");
+        }
+        const agentId = config?.agent?.agentId;
+        if (!agentId) {
+            throw new Error("No agent ID found in lua.skill.yaml. Run 'lua init' first.");
+        }
+        // Create skill via API
+        const skillPayload = {
+            name: skill.name,
+            description: skill.description || `A Lua skill for ${skill.name}`,
+            context: skill.context || ''
+        };
+        const skillApi = new SkillApi(BASE_URLS.API, apiKey, agentId);
+        const result = await skillApi.createSkill(skillPayload);
+        if (result.success && result.data && result.data.id) {
+            const newSkillId = result.data.id;
+            // Update YAML config with new skill ID
+            if (!existingSkill) {
+                existingSkills.push({
+                    name: skill.name || '',
+                    version: skill.version || SKILL_DEFAULTS.VERSION,
+                    skillId: newSkillId
+                });
+            }
+            else {
+                existingSkill.skillId = newSkillId;
+            }
+            return {
+                ...skill,
+                skillId: newSkillId
+            };
+        }
+        else {
+            console.error(`❌ Failed to create skill ${skill.name}:`, result.error);
+            throw new Error(result.error?.message || 'Failed to create skill - no ID returned from API');
+        }
+    }
+    catch (error) {
+        console.error(`❌ Failed to create skill ${skill.name}:`, error);
+        throw error;
+    }
+}
+/**
+ * Updates the lua.skill.yaml file with the current skills array.
+ * Ensures no undefined values are written to the YAML file.
+ *
+ * @param skills - Array of skills to write
+ * @param config - Current skill configuration to merge with
+ */
+async function updateYamlWithSkills(skills, config) {
+    // Clean skills array to ensure no undefined values
+    const cleanedSkills = skills.map(skill => ({
+        name: skill.name || '',
+        version: skill.version || SKILL_DEFAULTS.VERSION,
+        skillId: skill.skillId || ''
+    }));
+    // Update config with cleaned skills array
+    const updatedConfig = {
+        ...config,
+        skills: cleanedSkills
+    };
+    // Write updated YAML with consistent formatting
+    const yamlPath = path.join(process.cwd(), COMPILE_FILES.LUA_SKILL_YAML);
+    const yamlContent = yaml.dump(updatedConfig, {
+        indent: YAML_FORMAT.INDENT,
+        lineWidth: YAML_FORMAT.LINE_WIDTH,
+        noRefs: YAML_FORMAT.NO_REFS,
+        replacer: (key, value) => {
+            // Replace undefined values with empty strings
+            return value === undefined ? '' : value;
+        }
+    });
+    fs.writeFileSync(yamlPath, yamlContent);
+}

package/dist/utils/test-helpers.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Test Command Helper Utilities
+ * Handles tool extraction, decompression, and schema processing
+ */
+import { ToolData } from '../interfaces/test.js';
+/**
+ * Decompresses gzip-compressed base64 encoded code.
+ *
+ * @param compressedCode - Base64 encoded compressed code
+ * @returns Decompressed code string
+ */
+export declare function decompressCode(compressedCode: string): string;
+/**
+ * Reads and parses deploy.json file.
+ *
+ * @returns Parsed deploy data
+ * @throws Error if deploy.json is not found
+ */
+export declare function readDeployJson(): any;
+/**
+ * Extracts all tools from deploy.json (handles both new and legacy formats).
+ *
+ * @param deployData - Parsed deploy.json data
+ * @returns Array of tools with their metadata
+ * @throws Error if no tools are found
+ */
+export declare function extractToolsFromDeployData(deployData: any): ToolData[];
+/**
+ * Checks if .env file exists.
+ *
+ * @returns True if .env file exists
+ */
+export declare function hasEnvFile(): boolean;
+/**
+ * Checks if config has environment variables defined.
+ *
+ * @param config - Skill configuration
+ * @returns True if config has environment variables
+ */
+export declare function hasConfigEnvVars(config: any): boolean;