lua-cli 2.5.4 → 2.5.5

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

@@ -0,0 +1,54 @@
+import { HttpClient } from "../common/http.client.js";
+import { ApiResponse } from "../interfaces/common.js";
+/**
+ * Environment variables response structure from the API
+ * The actual environment variables are nested in the 'data' property
+ */
+interface EnvironmentVariablesResponse {
+    data: Record<string, string>;
+    _id?: string;
+    agentId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    __v?: number;
+}
+/**
+ * Developer API calls for agent management and configuration
+ */
+export default class DeveloperApi extends HttpClient {
+    private apiKey;
+    private agentId;
+    /**
+     * Creates an instance of DeveloperApi
+     * @param baseUrl - The base URL for the API
+     * @param apiKey - The API key for authentication
+     * @param agentId - The unique identifier of the agent
+     */
+    constructor(baseUrl: string, apiKey: string, agentId: string);
+    /**
+     * Retrieves all environment variables for the agent in production
+     * The response includes metadata (_id, agentId, timestamps) and the actual env vars in the 'data' property
+     * @returns Promise resolving to an ApiResponse containing environment variables and metadata
+     * @throws Error if the API request fails or the agent is not found
+     */
+    getEnvironmentVariables(): Promise<ApiResponse<EnvironmentVariablesResponse>>;
+    /**
+     * Updates all environment variables for the agent in production
+     * This operation replaces all existing environment variables with the provided set
+     * @param envData - Object containing environment variable key-value pairs
+     * @returns Promise resolving to an ApiResponse with the updated environment variables and metadata
+     * @throws Error if the API request fails or the agent is not found
+     */
+    updateEnvironmentVariables(envData: Record<string, string>): Promise<ApiResponse<EnvironmentVariablesResponse>>;
+    /**
+     * Deletes a specific environment variable by key
+     * @param key - The environment variable key to delete
+     * @returns Promise resolving to an ApiResponse with confirmation
+     * @throws Error if the API request fails, the agent is not found, or the key doesn't exist
+     */
+    deleteEnvironmentVariable(key: string): Promise<ApiResponse<{
+        message: string;
+        key: string;
+    }>>;
+}
+export {};

package/dist/api/developer.api.service.js

@@ -0,0 +1,51 @@
+import { HttpClient } from "../common/http.client.js";
+/**
+ * Developer API calls for agent management and configuration
+ */
+export default class DeveloperApi extends HttpClient {
+    /**
+     * Creates an instance of DeveloperApi
+     * @param baseUrl - The base URL for the API
+     * @param apiKey - The API key for authentication
+     * @param agentId - The unique identifier of the agent
+     */
+    constructor(baseUrl, apiKey, agentId) {
+        super(baseUrl);
+        this.apiKey = apiKey;
+        this.agentId = agentId;
+    }
+    /**
+     * Retrieves all environment variables for the agent in production
+     * The response includes metadata (_id, agentId, timestamps) and the actual env vars in the 'data' property
+     * @returns Promise resolving to an ApiResponse containing environment variables and metadata
+     * @throws Error if the API request fails or the agent is not found
+     */
+    async getEnvironmentVariables() {
+        return this.httpGet(`/developer/agents/${this.agentId}/env`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Updates all environment variables for the agent in production
+     * This operation replaces all existing environment variables with the provided set
+     * @param envData - Object containing environment variable key-value pairs
+     * @returns Promise resolving to an ApiResponse with the updated environment variables and metadata
+     * @throws Error if the API request fails or the agent is not found
+     */
+    async updateEnvironmentVariables(envData) {
+        return this.httpPost(`/developer/agents/${this.agentId}/env`, envData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Deletes a specific environment variable by key
+     * @param key - The environment variable key to delete
+     * @returns Promise resolving to an ApiResponse with confirmation
+     * @throws Error if the API request fails, the agent is not found, or the key doesn't exist
+     */
+    async deleteEnvironmentVariable(key) {
+        return this.httpDelete(`/developer/agents/${this.agentId}/env/${key}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+}

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

@@ -1,6 +1,7 @@
 import { DevVersionResponse, UpdateDevVersionResponse } from "../interfaces/dev.js";
 import { HttpClient } from "../common/http.client.js";
 import { ApiResponse } from "../interfaces/common.js";
+import { GetSkillsResponse, DeleteSkillResponse } from "../interfaces/skills.js";
 /**
  * Skill API calls
  */
@@ -14,6 +15,12 @@ export default class SkillApi extends HttpClient {
      * @param agentId - The unique identifier of the agent
      */
     constructor(baseUrl: string, apiKey: string, agentId: string);
+    /**
+     * Retrieves all skills for the agent
+     * @returns Promise resolving to an ApiResponse containing an array of skills with their versions and tools
+     * @throws Error if the API request fails or the agent is not found
+     */
+    getSkills(): Promise<ApiResponse<GetSkillsResponse>>;
     /**
      * Creates a new skill for the agent
      * @param skillData - The skill data including name, description, and optional context
@@ -74,4 +81,13 @@ export default class SkillApi extends HttpClient {
         activeVersionId: string;
         publishedAt: string;
     }>>;
+    /**
+     * Deletes a skill and all its versions, or deactivates it if it has versions
+     * @param skillId - The unique identifier of the skill to delete
+     * @returns Promise resolving to an ApiResponse with deletion status
+     *   - If deleted is true: skill was successfully deleted
+     *   - If deleted is false and deactivated is true: skill has versions and was deactivated instead
+     * @throws Error if the skill is not found or the delete operation fails
+     */
+    deleteSkill(skillId: string): Promise<ApiResponse<DeleteSkillResponse>>;
 }

package/dist/api/skills.api.service.js

@@ -14,6 +14,16 @@ export default class SkillApi extends HttpClient {
         this.apiKey = apiKey;
         this.agentId = agentId;
     }
+    /**
+     * Retrieves all skills for the agent
+     * @returns Promise resolving to an ApiResponse containing an array of skills with their versions and tools
+     * @throws Error if the API request fails or the agent is not found
+     */
+    async getSkills() {
+        return this.httpGet(`/developer/skills/${this.agentId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
     /**
      * Creates a new skill for the agent
      * @param skillData - The skill data including name, description, and optional context
@@ -85,4 +95,17 @@ export default class SkillApi extends HttpClient {
             Authorization: `Bearer ${this.apiKey}`,
         });
     }
+    /**
+     * Deletes a skill and all its versions, or deactivates it if it has versions
+     * @param skillId - The unique identifier of the skill to delete
+     * @returns Promise resolving to an ApiResponse with deletion status
+     *   - If deleted is true: skill was successfully deleted
+     *   - If deleted is false and deactivated is true: skill has versions and was deactivated instead
+     * @throws Error if the skill is not found or the delete operation fails
+     */
+    async deleteSkill(skillId) {
+        return this.httpDelete(`/developer/skills/${this.agentId}/${skillId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
 }

package/dist/commands/compile.d.ts

@@ -12,6 +12,8 @@
  * 4. Extracts execute code and schemas from bundled tools
  * 5. Bundles the main index file
  * 6. Creates deployment data in both new and legacy formats
+ * 7. Syncs lua.skill.yaml with deploy.json (removes deleted skills from YAML)
+ * 8. Syncs server with YAML (deletes/deactivates skills not in YAML)
  *
  * Output:
  * - dist/deployment.json - New deployment format with tool references
@@ -19,6 +21,11 @@
  * - dist/index.js - Main skill entry point
  * - .lua/deploy.json - Legacy deployment format with compressed tools
  * - .lua/*.js - Individual uncompressed tool files for debugging
+ * - lua.skill.yaml - Updated to match compiled skills
+ *
+ * Server Sync:
+ * - Skills deleted from code are removed from YAML
+ * - Skills not in YAML are deleted from server (or deactivated if they have versions)
  *
  * @returns Promise that resolves when compilation is complete
  */

package/dist/commands/compile.js

@@ -10,6 +10,8 @@ import { findIndexFile } from '../utils/compile.js';
 import { detectTools } from '../utils/tool-detection.js';
 import { bundleTool, bundleMainIndex, extractExecuteCode } from '../utils/bundling.js';
 import { createDeploymentData, createLegacyDeploymentData } from '../utils/deployment.js';
+import { syncYamlWithDeployJson, syncServerSkillsWithYaml } from '../utils/skill-management.js';
+import { readSkillConfig } from '../utils/files.js';
 import { COMPILE_DIRS, COMPILE_FILES } from '../config/compile.constants.js';
 /**
  * Main compile command - orchestrates the entire skill compilation process.
@@ -21,6 +23,8 @@ import { COMPILE_DIRS, COMPILE_FILES } from '../config/compile.constants.js';
  * 4. Extracts execute code and schemas from bundled tools
  * 5. Bundles the main index file
  * 6. Creates deployment data in both new and legacy formats
+ * 7. Syncs lua.skill.yaml with deploy.json (removes deleted skills from YAML)
+ * 8. Syncs server with YAML (deletes/deactivates skills not in YAML)
  *
  * Output:
  * - dist/deployment.json - New deployment format with tool references
@@ -28,6 +32,11 @@ import { COMPILE_DIRS, COMPILE_FILES } from '../config/compile.constants.js';
  * - dist/index.js - Main skill entry point
  * - .lua/deploy.json - Legacy deployment format with compressed tools
  * - .lua/*.js - Individual uncompressed tool files for debugging
+ * - lua.skill.yaml - Updated to match compiled skills
+ *
+ * Server Sync:
+ * - Skills deleted from code are removed from YAML
+ * - Skills not in YAML are deleted from server (or deactivated if they have versions)
  *
  * @returns Promise that resolves when compilation is complete
  */
@@ -52,6 +61,15 @@ export async function compileCommand() {
         // Step 5: Create deployment data in both formats
         await createDeploymentData(tools, distDir);
         await createLegacyDeploymentData(tools, luaDir, indexFile);
+        // Step 6: Sync YAML with deploy.json
+        writeProgress("🔄 Syncing YAML with deploy.json...");
+        const deployJsonPath = path.join(luaDir, COMPILE_FILES.DEPLOY_JSON);
+        const config = readSkillConfig();
+        await syncYamlWithDeployJson(deployJsonPath, config);
+        // Step 7: Sync server with YAML (delete skills not in YAML)
+        writeProgress("🔄 Syncing server with YAML...");
+        const updatedConfig = readSkillConfig(); // Re-read config after YAML sync
+        await syncServerSkillsWithYaml(updatedConfig);
         writeSuccess(`✅ Skill compiled successfully - ${tools.length} tools bundled`);
     }, "compilation");
 }

package/dist/commands/env.js

@@ -10,6 +10,7 @@ import { readSkillConfig } from '../utils/files.js';
 import { withErrorHandling, writeProgress, writeSuccess } from '../utils/cli.js';
 import { BASE_URLS } from '../config/constants.js';
 import { validateConfig, validateAgentConfig, } from '../utils/dev-helpers.js';
+import DeveloperApi from '../api/developer.api.service.js';
 /**
  * Main env command - manages environment variables
  *
@@ -57,6 +58,7 @@ export async function envCommand() {
             }
             await checkApiKey(apiKey);
             context.apiKey = apiKey;
+            context.developerApi = new DeveloperApi(BASE_URLS.API, apiKey, agentId);
             writeProgress("✅ Authenticated");
         }
         // Step 4: Start management loop
@@ -160,19 +162,22 @@ function loadSandboxEnvVariables() {
  */
 async function loadProductionEnvVariables(context) {
     try {
-        const response = await fetch(`${BASE_URLS.API}/developer/agents/${context.agentId}/env`, {
-            method: 'GET',
-            headers: {
-                'accept': 'application/json',
-                'Authorization': `Bearer ${context.apiKey}`
-            }
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
+        if (!context.developerApi) {
+            throw new Error('Developer API not initialized');
+        }
+        const response = await context.developerApi.getEnvironmentVariables();
+        if (!response.success) {
+            throw new Error(response.error?.message || 'Failed to load environment variables');
         }
-        const data = await response.json();
-        if (data.data && typeof data.data === 'object') {
-            return Object.entries(data.data).map(([key, value]) => ({
+        // The API returns environment variables nested in a 'data' property
+        // Response structure: { success: true, data: { data: { KEY: "value", ... }, _id: "...", ... } }
+        const envData = response.data?.data || response.data;
+        if (envData && typeof envData === 'object') {
+            // Filter out metadata fields like _id, agentId, createdAt, updatedAt, __v
+            const metadataKeys = ['_id', 'agentId', 'data', 'createdAt', 'updatedAt', '__v'];
+            return Object.entries(envData)
+                .filter(([key]) => !metadataKeys.includes(key))
+                .map(([key, value]) => ({
                 key,
                 value: String(value)
             }));
@@ -231,23 +236,18 @@ function saveSandboxEnvVariables(variables) {
  */
 async function saveProductionEnvVariables(context, variables) {
     try {
+        if (!context.developerApi) {
+            throw new Error('Developer API not initialized');
+        }
         const envData = {};
         variables.forEach(v => {
             if (v.key.trim()) {
                 envData[v.key.trim()] = v.value;
             }
         });
-        const response = await fetch(`${BASE_URLS.API}/developer/agents/${context.agentId}/env`, {
-            method: 'POST',
-            headers: {
-                'accept': 'application/json',
-                'Authorization': `Bearer ${context.apiKey}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify(envData)
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
+        const response = await context.developerApi.updateEnvironmentVariables(envData);
+        if (!response.success) {
+            throw new Error(response.error?.message || 'Failed to save environment variables');
         }
         return true;
     }
@@ -383,14 +383,30 @@ async function deleteVariable(context, currentVariables) {
         console.log("\nℹ️  Deletion cancelled.\n");
         return;
     }
-    const updatedVariables = currentVariables.filter(v => v.key !== selectedKey);
-    writeProgress("🔄 Saving...");
+    writeProgress("🔄 Deleting...");
     let success = false;
     if (context.environment === 'sandbox') {
+        const updatedVariables = currentVariables.filter(v => v.key !== selectedKey);
         success = saveSandboxEnvVariables(updatedVariables);
     }
     else {
-        success = await saveProductionEnvVariables(context, updatedVariables);
+        // Use the dedicated delete API endpoint for production
+        if (!context.developerApi) {
+            console.error("❌ Developer API not initialized");
+            return;
+        }
+        try {
+            const response = await context.developerApi.deleteEnvironmentVariable(selectedKey);
+            if (response.success) {
+                success = true;
+            }
+            else {
+                console.error(`❌ ${response.error?.message || 'Failed to delete variable'}`);
+            }
+        }
+        catch (error) {
+            console.error('❌ Error deleting production env variable:', error);
+        }
     }
     if (success) {
         writeSuccess(`✅ Variable "${selectedKey}" deleted successfully`);

package/dist/interfaces/skills.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Skills Interfaces
+ * Structures for skill management
+ */
+/**
+ * Tool definition within a skill version
+ */
+export interface SkillTool {
+    name: string;
+    description: string;
+}
+/**
+ * Skill version information
+ */
+export interface SkillVersion {
+    id: string;
+    version: string;
+    description: string;
+    active: boolean;
+    context: string;
+    tools: SkillTool[];
+}
+/**
+ * Skill information
+ */
+export interface Skill {
+    id: string;
+    name: string;
+    description: string;
+    public: boolean;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+    versions: SkillVersion[];
+}
+/**
+ * Response from get all skills API endpoint
+ */
+export interface GetSkillsResponse {
+    skills: Skill[];
+}
+/**
+ * Response from delete skill API endpoint
+ * If deleted is false and deactivated is true, the skill has versions
+ * and cannot be deleted, so it was deactivated instead
+ */
+export interface DeleteSkillResponse {
+    message: string;
+    deleted: boolean;
+    deactivated: boolean;
+}

package/dist/interfaces/skills.js

@@ -0,0 +1,5 @@
+/**
+ * Skills Interfaces
+ * Structures for skill management
+ */
+export {};

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

@@ -12,3 +12,23 @@ import { SkillConfig } from '../types/compile.types.js';
  * @returns Updated skills array with valid skill IDs
  */
 export declare function ensureSkillsExistInYaml(skillsArray: any[], config: SkillConfig): Promise<any[]>;
+/**
+ * Updates the YAML file with skills from the deploy.json file.
+ * This ensures the YAML reflects what's actually in the compiled code.
+ * Only updates skill entries that already exist in YAML (preserves skillId).
+ * Removes skills from YAML that are no longer in deploy.json.
+ *
+ * @param deployJsonPath - Path to the deploy.json file
+ * @param config - Current skill configuration
+ */
+export declare function syncYamlWithDeployJson(deployJsonPath: string, config: SkillConfig): Promise<void>;
+/**
+ * Syncs the server skills with the YAML configuration.
+ * Performs a two-way sync:
+ * 1. Deletes/deactivates skills from server that aren't in YAML
+ * 2. Updates YAML with active version numbers from server
+ *
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Array of messages about sync operations
+ */
+export declare function syncServerSkillsWithYaml(config: SkillConfig): Promise<string[]>;

package/dist/utils/skill-management.js

@@ -146,3 +146,162 @@ async function updateYamlWithSkills(skills, config) {
     });
     fs.writeFileSync(yamlPath, yamlContent);
 }
+/**
+ * Updates the YAML file with skills from the deploy.json file.
+ * This ensures the YAML reflects what's actually in the compiled code.
+ * Only updates skill entries that already exist in YAML (preserves skillId).
+ * Removes skills from YAML that are no longer in deploy.json.
+ *
+ * @param deployJsonPath - Path to the deploy.json file
+ * @param config - Current skill configuration
+ */
+export async function syncYamlWithDeployJson(deployJsonPath, config) {
+    try {
+        // Read deploy.json
+        if (!fs.existsSync(deployJsonPath)) {
+            console.warn("⚠️  deploy.json not found. Skipping YAML sync.");
+            return;
+        }
+        const deployData = JSON.parse(fs.readFileSync(deployJsonPath, 'utf8'));
+        const deploySkills = deployData.skills || [];
+        // Create map of deploy skills by name
+        const deploySkillsMap = new Map();
+        deploySkills.forEach((skill) => {
+            deploySkillsMap.set(skill.name, skill);
+        });
+        // Get existing YAML skills
+        const existingYamlSkills = config?.skills || [];
+        // Update YAML skills to match deploy.json
+        const updatedSkills = existingYamlSkills
+            .filter((yamlSkill) => {
+            // Keep only skills that exist in deploy.json
+            return deploySkillsMap.has(yamlSkill.name);
+        })
+            .map((yamlSkill) => {
+            // Update version and description from deploy.json if available
+            const deploySkill = deploySkillsMap.get(yamlSkill.name);
+            return {
+                name: yamlSkill.name,
+                version: deploySkill?.version || yamlSkill.version || SKILL_DEFAULTS.VERSION,
+                skillId: yamlSkill.skillId || ''
+            };
+        });
+        // Add new skills from deploy.json that aren't in YAML yet
+        deploySkills.forEach((deploySkill) => {
+            const existsInYaml = updatedSkills.some((s) => s.name === deploySkill.name);
+            if (!existsInYaml) {
+                updatedSkills.push({
+                    name: deploySkill.name,
+                    version: deploySkill.version || SKILL_DEFAULTS.VERSION,
+                    skillId: '' // Will be created via API later
+                });
+            }
+        });
+        // Update YAML file
+        await updateYamlWithSkills(updatedSkills, config);
+        console.log("✅ YAML synced with deploy.json");
+    }
+    catch (error) {
+        console.error("❌ Error syncing YAML with deploy.json:", error);
+    }
+}
+/**
+ * Syncs the server skills with the YAML configuration.
+ * Performs a two-way sync:
+ * 1. Deletes/deactivates skills from server that aren't in YAML
+ * 2. Updates YAML with active version numbers from server
+ *
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Array of messages about sync operations
+ */
+export async function syncServerSkillsWithYaml(config) {
+    const messages = [];
+    let yamlNeedsUpdate = false;
+    try {
+        // Validate prerequisites
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.warn("⚠️  No API key found. Skipping server sync.");
+            return messages;
+        }
+        const agentId = config?.agent?.agentId;
+        if (!agentId) {
+            console.warn("⚠️  No agent ID found in lua.skill.yaml. Skipping server sync.");
+            return messages;
+        }
+        // Get skills from server
+        const skillApi = new SkillApi(BASE_URLS.API, apiKey, agentId);
+        const serverSkillsResponse = await skillApi.getSkills();
+        if (!serverSkillsResponse.success || !serverSkillsResponse.data?.skills) {
+            console.warn("⚠️  Could not retrieve server skills. Skipping server sync.");
+            return messages;
+        }
+        const serverSkills = serverSkillsResponse.data.skills;
+        const yamlSkills = config?.skills || [];
+        // Create maps for efficient lookup
+        const yamlSkillsMap = new Map(yamlSkills
+            .filter((skill) => skill.skillId)
+            .map((skill) => [skill.skillId, skill]));
+        const serverSkillsMap = new Map(serverSkills.map(skill => [skill.id, skill]));
+        // Part 1: Delete skills from server that aren't in YAML
+        const skillsToDelete = serverSkills.filter(serverSkill => !yamlSkillsMap.has(serverSkill.id));
+        for (const skill of skillsToDelete) {
+            try {
+                const deleteResponse = await skillApi.deleteSkill(skill.id);
+                if (deleteResponse.success && deleteResponse.data) {
+                    if (deleteResponse.data.deleted) {
+                        const msg = `✅ Deleted skill "${skill.name}" from server`;
+                        messages.push(msg);
+                        console.log(msg);
+                    }
+                    else if (deleteResponse.data.deactivated) {
+                        const msg = `⚠️  Skill "${skill.name}" has versions and cannot be deleted. It has been deactivated instead.`;
+                        messages.push(msg);
+                        console.warn(msg);
+                    }
+                }
+                else {
+                    const msg = `❌ Failed to delete skill "${skill.name}": ${deleteResponse.error?.message || 'Unknown error'}`;
+                    messages.push(msg);
+                    console.error(msg);
+                }
+            }
+            catch (error) {
+                const msg = `❌ Error deleting skill "${skill.name}": ${error}`;
+                messages.push(msg);
+                console.error(msg);
+            }
+        }
+        // Part 2: Sync version numbers from server to YAML
+        const updatedYamlSkills = yamlSkills.map((yamlSkill) => {
+            const serverSkill = serverSkillsMap.get(yamlSkill.skillId);
+            if (serverSkill && serverSkill.versions && serverSkill.versions.length > 0) {
+                // Find the active version on the server
+                const activeVersion = serverSkill.versions.find((v) => v.active);
+                if (activeVersion && activeVersion.version !== yamlSkill.version) {
+                    const msg = `📝 Updated "${yamlSkill.name}" version in YAML: ${yamlSkill.version} → ${activeVersion.version}`;
+                    messages.push(msg);
+                    console.log(msg);
+                    yamlNeedsUpdate = true;
+                    return {
+                        ...yamlSkill,
+                        version: activeVersion.version
+                    };
+                }
+            }
+            return yamlSkill;
+        });
+        // Update YAML file if versions changed
+        if (yamlNeedsUpdate) {
+            await updateYamlWithSkills(updatedYamlSkills, config);
+            console.log("✅ YAML versions synced with server");
+        }
+        if (skillsToDelete.length === 0 && !yamlNeedsUpdate) {
+            console.log("✅ Server and YAML are fully in sync");
+        }
+    }
+    catch (error) {
+        console.error("❌ Error syncing server skills:", error);
+    }
+    return messages;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lua-cli",
-  "version": "2.5.4",
+  "version": "2.5.5",
   "description": "Command-line interface for Lua AI platform - develop, test, and deploy LuaSkills with custom tools",
   "readmeFilename": "README.md",
   "main": "dist/api-exports.js",

package/template/package.json

@@ -19,7 +19,7 @@
     "axios": "^1.6.0",
     "inquirer": "^12.9.6",
     "js-yaml": "^4.1.0",
-    "lua-cli": "^2.5.3",
+    "lua-cli": "^2.5.5",
     "openai": "^5.23.0",
     "uuid": "^13.0.0",
     "zod": "^3.24.1"