lua-cli 1.3.2-alpha.3 → 2.0.1

package/CHANGELOG.md

@@ -5,6 +5,31 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.2-alpha.3] - 2025-09-25
+
+### 🚀 Major Rewrite
+- **Complete compiler rewrite** using TypeScript AST (ts-morph) instead of regex
+- **Self-contained tool bundling** with esbuild and minification
+- **85% file size reduction** (4MB → 612KB total bundle size)
+- **Zero regex usage** - pure AST-based parsing for reliability
+
+### ✨ New Features
+- **Enhanced Zod schema parsing** for nested objects and arrays
+- **Comprehensive polyfills** for browser/Node.js APIs (AbortController, FormData, TextEncoder, crypto, etc.)
+- **Optimized bundling** excludes lua-cli modules (injected by VM) for smaller sizes
+- **Dual output format** - both new (dist/) and legacy (.lua/) formats
+
+### 🔧 Improvements  
+- **Proper environment variable injection** from lua.skill.yaml into VM
+- **Minified output** for production deployment
+- **Better error handling** with proper TypeScript AST validation
+- **Full backward compatibility** with existing deployment workflow
+
+### 📦 Bundle Size Optimizations
+- Simple tools (Weather, UserData): 545KB → 4KB (99% reduction)
+- HTTP tools (CreatePost): 863KB → 232KB (73% reduction)  
+- AI tools (SearchMovies): 1.4MB → 364KB (74% reduction)
+
 ## [1.3.0-alpha.1] - 2024-12-19
 
 ### Added

package/README.md

@@ -195,7 +195,7 @@ This command will:
   - Available at `http://localhost:3000` (opens automatically)
 - **Live Log Panel**:
   - Real-time log feed showing execution details
-  - WebSocket connection to `wss://api.lua.dev/feed`
+  - WebSocket connection to `wss://api.heylua.ai/feed`
   - Console-style interface with color-coded log levels
   - Shows tool calls, errors, metrics, and execution metadata
   - Displays detailed information in expandable sections
@@ -498,7 +498,7 @@ For more details, see [USER_DATA_API.md](./USER_DATA_API.md).
 
 For support and questions:
 - Create an issue on [GitHub](https://github.com/lua-ai-global/lua-cli/issues)
-- Contact: stefan@lua.dev
+- Contact: stefan@heylua.ai
 
 ## Changelog
 

package/dist/commands/agents.js

@@ -5,7 +5,7 @@ export async function agentsCommand() {
     return withErrorHandling(async () => {
         const apiKey = await loadApiKey();
         if (!apiKey) {
-            console.error("❌ No API key found. Run `lua configure` first.");
+            console.error("❌ No API key found. Run `lua auth configure` first.");
             process.exit(1);
         }
         const response = await ApiService.Agent.getOrganizations(apiKey);

package/dist/commands/apiKey.js

@@ -1,11 +1,11 @@
 import inquirer from "inquirer";
 import { loadApiKey } from "../services/auth.js";
-import { withErrorHandling, clearPromptLines, writeProgress, writeSuccess } from "../utils/cli.js";
+import { withErrorHandling, writeProgress, writeSuccess } from "../utils/cli.js";
 export async function apiKeyCommand() {
     return withErrorHandling(async () => {
         const apiKey = await loadApiKey();
         if (!apiKey) {
-            writeProgress("ℹ️  No API key found. Run `lua configure` first.");
+            writeProgress("ℹ️  No API key found. Run `lua auth configure` first.");
             return;
         }
         const { confirm } = await inquirer.prompt([
@@ -16,8 +16,6 @@ export async function apiKeyCommand() {
                 default: false
             }
         ]);
-        // Clear the confirmation prompt lines
-        clearPromptLines(2);
         if (confirm) {
             writeSuccess("🔑 Your API key:");
             console.log(apiKey);

package/dist/commands/compile.js

@@ -3,8 +3,11 @@ import path from "path";
 import { gzipSync } from "zlib";
 import { withErrorHandling, writeProgress, writeSuccess } from "../utils/cli.js";
 import { readSkillConfig } from '../utils/files.js';
+import { loadApiKey } from '../services/auth.js';
+import { ApiService } from '../services/api.js';
 import { Project, Node } from "ts-morph";
 import { build } from "esbuild";
+import yaml from "js-yaml";
 // Compression utilities
 function compressCode(code) {
     const compressed = gzipSync(code);
@@ -65,7 +68,36 @@ function findIndexFile() {
 }
 async function detectTools(indexFile, project) {
     const tools = [];
-    // Find all call expressions in the file
+    // Find tools in LuaSkill constructors
+    indexFile.forEachDescendant((node) => {
+        if (Node.isNewExpression(node)) {
+            const expression = node.getExpression();
+            if (expression.getText() === 'LuaSkill') {
+                const args = node.getArguments();
+                if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
+                    const configObj = args[0];
+                    // Look for tools property in constructor
+                    configObj.getProperties().forEach((prop) => {
+                        if (Node.isPropertyAssignment(prop) && prop.getName() === 'tools') {
+                            const value = prop.getInitializer();
+                            if (value && Node.isArrayLiteralExpression(value)) {
+                                const toolsArray = value;
+                                toolsArray.getElements().forEach((element) => {
+                                    if (Node.isNewExpression(element)) {
+                                        const toolInfo = extractToolFromNewExpressionSync(element, project);
+                                        if (toolInfo) {
+                                            tools.push(toolInfo);
+                                        }
+                                    }
+                                });
+                            }
+                        }
+                    });
+                }
+            }
+        }
+    });
+    // Find all call expressions in the file (addTools method calls)
     indexFile.forEachDescendant((node) => {
         if (Node.isCallExpression(node)) {
             const expression = node.getExpression();
@@ -73,7 +105,7 @@ async function detectTools(indexFile, project) {
             if (Node.isPropertyAccessExpression(expression)) {
                 const object = expression.getExpression();
                 const property = expression.getName();
-                if (object.getText() === 'skill' && (property === 'addTools' || property === 'addTool')) {
+                if (property === 'addTools' || property === 'addTool') {
                     const args = node.getArguments();
                     if (property === 'addTools' && args.length > 0) {
                         // Handle skill.addTools([...]) - array of tools
@@ -152,12 +184,13 @@ function extractToolFromNewExpressionSync(newExpr, project) {
                                 description = descValue.replace(/['"]/g, '');
                             }
                         }
-                        return {
+                        const toolInfo = {
                             name: toolName,
                             className,
                             filePath: toolFilePath,
                             description
                         };
+                        return toolInfo;
                     }
                 }
                 catch (fileError) {
@@ -360,13 +393,20 @@ async function extractExecuteCode(tool, project) {
             const executeFunction = createExecuteFunction(bundledCode, tool);
             tool.executeCode = executeFunction;
         }
-        // Extract input schema from zod definition
+        // Extract input schema from zod definition using proper library
         const inputSchemaProperty = classDecl.getProperty('inputSchema');
         if (inputSchemaProperty && inputSchemaProperty.getInitializer()) {
             const initializer = inputSchemaProperty.getInitializer();
             if (initializer) {
-                // Parse the zod schema to extract JSON schema
-                tool.inputSchema = parseZodSchemaToJsonSchema(initializer.getText());
+                try {
+                    // Evaluate the Zod schema to get the actual schema object
+                    const zodSchemaCode = initializer.getText();
+                    tool.inputSchema = await evaluateZodSchemaToJsonSchema(zodSchemaCode);
+                }
+                catch (error) {
+                    console.warn(`Warning: Could not parse Zod schema for ${tool.className}:`, error);
+                    tool.inputSchema = { type: "object" };
+                }
             }
         }
         if (!tool.inputSchema) {
@@ -382,200 +422,37 @@ function createExecuteFunction(bundledCode, tool) {
     // Just return it directly since it's already an async function
     return bundledCode;
 }
-function parseZodSchemaToJsonSchema(zodSchemaText) {
+async function evaluateZodSchemaToJsonSchema(zodSchemaCode) {
     try {
-        // Use ts-morph to properly parse the Zod schema
-        const tempProject = new Project();
-        const tempFile = tempProject.createSourceFile('temp.ts', `
-      import { z } from 'zod';
-      const schema = ${zodSchemaText};
-    `);
-        // Find the schema variable declaration
-        const schemaDeclaration = tempFile.getVariableDeclaration('schema');
-        if (schemaDeclaration && schemaDeclaration.getInitializer()) {
-            const initializer = schemaDeclaration.getInitializer();
-            if (initializer) {
-                return parseZodASTToJsonSchema(initializer);
-            }
+        // Import zod and zod-to-json-schema dynamically
+        const { z } = await import('zod');
+        const { zodToJsonSchema } = await import('zod-to-json-schema');
+        // Create a safe evaluation context using Function constructor
+        const evalFunction = new Function('z', `return ${zodSchemaCode}`);
+        const zodSchema = evalFunction(z);
+        // Convert to JSON Schema using the library
+        const jsonSchema = zodToJsonSchema(zodSchema, 'schema');
+        // Extract just the core schema, removing JSON Schema references and definitions
+        if (jsonSchema.$ref && jsonSchema.definitions && jsonSchema.definitions.schema) {
+            // Return just the schema definition without the wrapper
+            return jsonSchema.definitions.schema;
         }
-        // Fallback to direct parsing if AST approach fails
-        return parseZodTextToJsonSchema(zodSchemaText);
+        // Remove the top-level $schema and title properties that we don't need
+        const { $schema, title, definitions, $ref, ...cleanSchema } = jsonSchema;
+        return cleanSchema;
     }
     catch (error) {
-        console.warn('Warning: Could not parse Zod schema with AST, falling back to text parsing:', error);
-        return parseZodTextToJsonSchema(zodSchemaText);
-    }
-}
-function parseZodASTToJsonSchema(node) {
-    try {
-        // Handle z.object({ ... })
-        if (Node.isCallExpression(node)) {
-            const expression = node.getExpression();
-            if (Node.isPropertyAccessExpression(expression)) {
-                const object = expression.getExpression();
-                const property = expression.getName();
-                if (object.getText() === 'z' && property === 'object') {
-                    const args = node.getArguments();
-                    if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
-                        const objectLiteral = args[0];
-                        const properties = {};
-                        const required = [];
-                        objectLiteral.getProperties().forEach((prop) => {
-                            if (Node.isPropertyAssignment(prop)) {
-                                const name = prop.getName();
-                                const value = prop.getInitializer();
-                                if (value) {
-                                    const propSchema = parseZodASTToJsonSchema(value);
-                                    properties[name] = propSchema;
-                                    // Check if it's required (not optional)
-                                    if (!isOptionalZodType(value)) {
-                                        required.push(name);
-                                    }
-                                }
-                            }
-                        });
-                        return {
-                            type: 'object',
-                            properties,
-                            required
-                        };
-                    }
-                }
-                // Handle other z.* types
-                if (object.getText() === 'z') {
-                    switch (property) {
-                        case 'string':
-                            return { type: 'string' };
-                        case 'number':
-                            return { type: 'number' };
-                        case 'boolean':
-                            return { type: 'boolean' };
-                        case 'any':
-                            return { type: 'object' };
-                        case 'array':
-                            const arrayArgs = node.getArguments();
-                            if (arrayArgs.length > 0) {
-                                const itemSchema = parseZodASTToJsonSchema(arrayArgs[0]);
-                                return { type: 'array', items: itemSchema };
-                            }
-                            return { type: 'array' };
-                        case 'enum':
-                            const enumArgs = node.getArguments();
-                            if (enumArgs.length > 0 && Node.isArrayLiteralExpression(enumArgs[0])) {
-                                const enumValues = enumArgs[0].getElements().map((element) => {
-                                    if (Node.isStringLiteral(element)) {
-                                        return element.getLiteralValue();
-                                    }
-                                    return element.getText().replace(/['"]/g, '');
-                                });
-                                return { type: 'string', enum: enumValues };
-                            }
-                            return { type: 'string' };
-                    }
-                }
-            }
-            // Handle method chaining like z.string().optional()
-            if (Node.isPropertyAccessExpression(expression)) {
-                const baseExpression = expression.getExpression();
-                const method = expression.getName();
-                if (method === 'optional' && Node.isCallExpression(baseExpression)) {
-                    // This is an optional field, parse the base type
-                    return parseZodASTToJsonSchema(baseExpression);
-                }
-            }
-        }
-        // Fallback
-        return { type: 'object' };
-    }
-    catch (error) {
-        console.warn('Warning: Could not parse Zod AST node:', error);
-        return { type: 'object' };
-    }
-}
-function isOptionalZodType(node) {
-    // Check if this is a method call ending with .optional()
-    if (Node.isCallExpression(node)) {
-        const expression = node.getExpression();
-        if (Node.isPropertyAccessExpression(expression)) {
-            const method = expression.getName();
-            return method === 'optional';
+        console.warn('Warning: Could not evaluate Zod schema, falling back to basic parsing:', error);
+        // Fallback to basic parsing for simple cases
+        if (zodSchemaCode.includes('z.object({')) {
+            return { type: 'object' };
         }
-    }
-    return false;
-}
-function parseZodTextToJsonSchema(zodSchemaText) {
-    try {
-        // Fallback text-based parsing for when AST parsing fails
-        if (zodSchemaText.includes('z.object({')) {
-            const properties = {};
-            const required = [];
-            // Extract object properties - enhanced pattern matching
-            const propertyPattern = /(\w+):\s*z\.(\w+)\(\)/g;
-            let match;
-            while ((match = propertyPattern.exec(zodSchemaText)) !== null) {
-                const [, propName, zodType] = match;
-                switch (zodType) {
-                    case 'string':
-                        properties[propName] = { type: 'string' };
-                        break;
-                    case 'number':
-                        properties[propName] = { type: 'number' };
-                        break;
-                    case 'boolean':
-                        properties[propName] = { type: 'boolean' };
-                        break;
-                    case 'any':
-                        properties[propName] = { type: 'object' };
-                        break;
-                    default:
-                        properties[propName] = { type: 'string' };
-                }
-                // Check if it's optional
-                if (!zodSchemaText.includes(`${propName}: z.${zodType}().optional()`)) {
-                    required.push(propName);
-                }
-            }
-            // Handle arrays
-            const arrayPattern = /(\w+):\s*z\.array\(z\.(\w+)\(\)\)/g;
-            while ((match = arrayPattern.exec(zodSchemaText)) !== null) {
-                const [, propName, itemType] = match;
-                let itemSchema = { type: 'string' };
-                switch (itemType) {
-                    case 'string':
-                        itemSchema = { type: 'string' };
-                        break;
-                    case 'number':
-                        itemSchema = { type: 'number' };
-                        break;
-                    case 'boolean':
-                        itemSchema = { type: 'boolean' };
-                        break;
-                }
-                properties[propName] = { type: 'array', items: itemSchema };
-                if (!zodSchemaText.includes(`${propName}: z.array(z.${itemType}()).optional()`)) {
-                    required.push(propName);
-                }
-            }
-            return {
-                type: 'object',
-                properties,
-                required
-            };
-        }
-        // Handle simple types
-        if (zodSchemaText.includes('z.string()'))
+        if (zodSchemaCode.includes('z.string()'))
             return { type: 'string' };
-        if (zodSchemaText.includes('z.number()'))
+        if (zodSchemaCode.includes('z.number()'))
             return { type: 'number' };
-        if (zodSchemaText.includes('z.boolean()'))
+        if (zodSchemaCode.includes('z.boolean()'))
             return { type: 'boolean' };
-        if (zodSchemaText.includes('z.array('))
-            return { type: 'array' };
-        // Fallback
-        return { type: 'object' };
-    }
-    catch (error) {
-        console.warn('Warning: Could not parse Zod schema text:', error);
         return { type: 'object' };
     }
 }
@@ -602,21 +479,72 @@ async function createLegacyDeploymentData(tools, luaDir, indexFile) {
     const config = readSkillConfig();
     const packageJsonPath = path.join(process.cwd(), "package.json");
     const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-    // Extract skill metadata from index.ts
-    const skillMetadata = extractSkillMetadata(indexFile);
+    // Extract skills metadata from index.ts
+    const skillsMetadata = extractSkillsMetadata(indexFile);
+    // Group tools by skill based on addTools calls
+    const skillToTools = new Map();
+    // Find addTools calls to associate tools with skills
+    indexFile.forEachDescendant((node) => {
+        if (Node.isCallExpression(node)) {
+            const expression = node.getExpression();
+            if (Node.isPropertyAccessExpression(expression) && expression.getName() === 'addTools') {
+                const object = expression.getExpression();
+                const objectName = object.getText();
+                // Get the tools array
+                const args = node.getArguments();
+                if (args.length > 0 && Node.isArrayLiteralExpression(args[0])) {
+                    const toolsArray = args[0];
+                    const toolNames = toolsArray.getElements().map((element) => {
+                        if (Node.isNewExpression(element)) {
+                            return element.getExpression().getText();
+                        }
+                        return '';
+                    }).filter(name => name);
+                    skillToTools.set(objectName, toolNames);
+                }
+            }
+        }
+    });
+    // Create skills array with their associated tools
+    const skillsArray = skillsMetadata.map(skillMeta => {
+        let skillTools = [];
+        // First, check for tools from constructor
+        if (skillMeta.constructorTools && skillMeta.constructorTools.length > 0) {
+            skillTools = tools.filter(tool => {
+                return skillMeta.constructorTools.includes(tool.className) ||
+                    skillMeta.constructorTools.includes(tool.name);
+            });
+        }
+        else {
+            // Find tools for this skill by matching variable names from addTools calls
+            for (const [varName, toolNames] of skillToTools.entries()) {
+                // Simple heuristic: if variable name contains skill name, associate tools
+                if (varName.toLowerCase().includes(skillMeta.name.toLowerCase().replace('-skill', '')) ||
+                    varName.toLowerCase().includes(skillMeta.name.toLowerCase())) {
+                    skillTools = tools.filter(tool => {
+                        return toolNames.includes(tool.className) || toolNames.includes(tool.name);
+                    });
+                    break;
+                }
+            }
+        }
+        return {
+            name: skillMeta.name,
+            version: skillMeta.version,
+            description: skillMeta.description,
+            context: skillMeta.context,
+            tools: skillTools.map(tool => ({
+                name: tool.name,
+                description: tool.description || "",
+                inputSchema: tool.inputSchema || { type: "object" },
+                execute: compressCode(tool.executeCode || "")
+            }))
+        };
+    });
+    // Match skills from code with skills in YAML and create missing ones
+    const updatedSkillsArray = await ensureSkillsExistInYaml(skillsArray, config);
     const deployData = {
-        version: config?.skill?.version || packageJson.version || "1.0.0",
-        name: config?.skill?.name || packageJson.name || "lua-skill",
-        skillsName: config?.skill?.name || packageJson.name || "lua-skill",
-        skillId: config?.skill?.skillId || skillMetadata.skillId || "",
-        description: config?.skill?.description || skillMetadata.description || "",
-        context: config?.skill?.context || skillMetadata.context || "",
-        tools: tools.map(tool => ({
-            name: tool.name,
-            description: tool.description || "",
-            inputSchema: tool.inputSchema || { type: "object" },
-            execute: compressCode(tool.executeCode || "")
-        }))
+        skills: updatedSkillsArray
     };
     // Write legacy deploy.json to .lua directory
     fs.writeFileSync(path.join(luaDir, "deploy.json"), JSON.stringify(deployData, null, 2));
@@ -628,11 +556,9 @@ async function createLegacyDeploymentData(tools, luaDir, indexFile) {
         }
     }
 }
-function extractSkillMetadata(indexFile) {
-    let skillId = '';
-    let description = '';
-    let context = '';
-    // Find LuaSkill constructor call
+function extractSkillsMetadata(indexFile) {
+    const skills = [];
+    // Find all LuaSkill constructor calls
     indexFile.forEachDescendant((node) => {
         if (Node.isNewExpression(node)) {
             const expression = node.getExpression();
@@ -640,22 +566,160 @@ function extractSkillMetadata(indexFile) {
                 const args = node.getArguments();
                 if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
                     const configObj = args[0];
+                    let skillName = '';
+                    let skillVersion = '';
+                    let description = '';
+                    let context = '';
+                    let constructorTools = [];
                     // Extract properties
                     configObj.getProperties().forEach((prop) => {
                         if (Node.isPropertyAssignment(prop)) {
                             const name = prop.getName();
-                            const value = prop.getInitializer()?.getText();
-                            if (name === 'description' && value) {
-                                description = value.replace(/['"]/g, '');
+                            const value = prop.getInitializer();
+                            if (name === 'name' && value) {
+                                skillName = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (name === 'version' && value) {
+                                skillVersion = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (name === 'description' && value) {
+                                description = value.getText().replace(/['"]/g, '');
                             }
                             else if (name === 'context' && value) {
-                                context = value.replace(/['"]/g, '');
+                                context = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (name === 'tools' && value && Node.isArrayLiteralExpression(value)) {
+                                // Extract tools from constructor array
+                                const toolsArray = value;
+                                constructorTools = toolsArray.getElements().map((element) => {
+                                    if (Node.isNewExpression(element)) {
+                                        return element.getExpression().getText();
+                                    }
+                                    return '';
+                                }).filter(name => name);
                             }
                         }
                     });
+                    if (skillName) {
+                        skills.push({
+                            name: skillName,
+                            version: skillVersion || '1.0.0',
+                            description,
+                            context,
+                            constructorTools
+                        });
+                    }
                 }
             }
         }
     });
-    return { skillId, description, context };
+    return skills;
+}
+async function ensureSkillsExistInYaml(skillsArray, config) {
+    const updatedSkillsArray = [];
+    let yamlUpdated = false;
+    // Get existing skills from YAML
+    const existingSkills = config?.skills || [];
+    const existingSkillsMap = new Map();
+    // Create map of existing skills
+    existingSkills.forEach((skill) => {
+        existingSkillsMap.set(skill.name, skill);
+    });
+    // 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 - use it
+            // console.log(`Using existing skillId for ${skill.name}: ${existingSkill.skillId}`);
+            updatedSkillsArray.push({
+                ...skill,
+                skillId: existingSkill.skillId
+            });
+        }
+        else {
+            // Skill doesn't exist or missing skillId - create it via API
+            // console.log(`Creating new skill: ${skill.name}`);
+            try {
+                // Get API key and agent ID for skill creation
+                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.");
+                }
+                // Call create skill API
+                console.log(`Calling create skill API for: ${skill.name}`);
+                const skillPayload = {
+                    name: skill.name,
+                    description: skill.description || `A Lua skill for ${skill.name}`,
+                    context: skill.context || ''
+                };
+                const result = await ApiService.Skill.createSkill(apiKey, agentId, skillPayload);
+                // console.log(`Create skill API response:`, result);
+                if (result.success && result.data && result.data.id) {
+                    const newSkillId = result.data.id; // API returns 'id', not 'skillId'
+                    // console.log(`✅ Created skill ${skill.name} with ID: ${newSkillId}`);
+                    updatedSkillsArray.push({
+                        ...skill,
+                        skillId: newSkillId
+                    });
+                    // Update YAML with new skill
+                    if (!existingSkill) {
+                        existingSkills.push({
+                            name: skill.name || '',
+                            version: skill.version || '1.0.0',
+                            skillId: newSkillId
+                        });
+                        yamlUpdated = true;
+                    }
+                    else {
+                        // Update existing skill with new skillId
+                        existingSkill.skillId = newSkillId;
+                        yamlUpdated = true;
+                    }
+                }
+                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; // Don't use temp IDs, let the process fail properly
+            }
+        }
+    }
+    // Update YAML file if needed
+    if (yamlUpdated) {
+        await updateYamlWithSkills(existingSkills, config);
+    }
+    return updatedSkillsArray;
+}
+async function updateYamlWithSkills(skills, config) {
+    // Clean skills array to ensure no undefined values
+    const cleanedSkills = skills.map(skill => ({
+        name: skill.name || '',
+        version: skill.version || '1.0.0',
+        skillId: skill.skillId || '' // Ensure skillId is never undefined
+    }));
+    // Update config with cleaned skills array
+    const updatedConfig = {
+        ...config,
+        skills: cleanedSkills
+    };
+    // Write updated YAML
+    const yamlPath = path.join(process.cwd(), 'lua.skill.yaml');
+    const yamlContent = yaml.dump(updatedConfig, {
+        indent: 2,
+        lineWidth: -1,
+        noRefs: true,
+        replacer: (key, value) => {
+            // Replace undefined values with empty strings
+            return value === undefined ? '' : value;
+        }
+    });
+    fs.writeFileSync(yamlPath, yamlContent);
+    console.log('Updated lua.skill.yaml with new skills');
 }