lua-cli 1.3.2-alpha.2 → 2.0.0

package/dist/commands/compile.js

@@ -1,1066 +1,725 @@
 import fs from "fs";
 import path from "path";
-import { gzipSync, gunzipSync } from "zlib";
-import { Buffer } from "buffer";
+import { gzipSync } from "zlib";
 import { withErrorHandling, writeProgress, writeSuccess } from "../utils/cli.js";
 import { readSkillConfig } from '../utils/files.js';
-import * as ts from "typescript";
+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);
     return compressed.toString('base64');
 }
-function decompressCode(compressedCode) {
-    const buffer = Buffer.from(compressedCode, 'base64');
-    return gunzipSync(buffer).toString('utf8');
-}
 export async function compileCommand() {
     return withErrorHandling(async () => {
         writeProgress("🔨 Compiling Lua skill...");
-        // Clean up old .lua directory
-        const oldLuaDir = path.join(process.cwd(), ".lua");
-        if (fs.existsSync(oldLuaDir)) {
-            fs.rmSync(oldLuaDir, { recursive: true, force: true });
-        }
-        // Read package.json to get version and name
-        const packageJsonPath = path.join(process.cwd(), "package.json");
-        if (!fs.existsSync(packageJsonPath)) {
-            throw new Error("package.json not found in current directory");
-        }
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-        const packageVersion = packageJson.version || "1.0.0";
-        // Get skill name from config file, fallback to package.json name
-        const config = readSkillConfig();
-        const skillName = config?.skill?.name || packageJson.name || "lua-skill";
-        // Read index.ts file (check both root and src directory)
-        let indexPath = path.join(process.cwd(), "index.ts");
-        if (!fs.existsSync(indexPath)) {
-            indexPath = path.join(process.cwd(), "src", "index.ts");
-            if (!fs.existsSync(indexPath)) {
-                throw new Error("index.ts not found in current directory or src/ directory");
-            }
-        }
-        const indexContent = fs.readFileSync(indexPath, "utf8");
-        // Extract skill information
-        const skillInfo = await extractSkillInfo(indexContent, indexPath);
-        // Extract skill metadata from LuaSkill constructor and config file
-        const skillMetadata = await extractSkillMetadata(indexContent);
-        // Use version from config file, fallback to package.json version
-        const version = skillMetadata.version || packageVersion || "1.0.0";
-        // Create deployment data with compressed execute code
-        const deployData = {
-            version,
-            name: skillName,
-            skillsName: skillName,
-            skillId: skillMetadata.skillId,
-            description: skillMetadata.description,
-            context: skillMetadata.context,
-            tools: skillInfo.map(tool => ({
-                ...tool,
-                execute: compressCode(tool.execute)
-            }))
-        };
-        // Create .lua directory
+        // Clean up old directories
+        const distDir = path.join(process.cwd(), "dist");
         const luaDir = path.join(process.cwd(), ".lua");
-        if (!fs.existsSync(luaDir)) {
-            fs.mkdirSync(luaDir, { recursive: true });
-        }
-        // Write JSON output to .lua directory
-        const jsonOutputPath = path.join(luaDir, "deploy.json");
-        fs.writeFileSync(jsonOutputPath, JSON.stringify(deployData, null, 2));
-        // Write individual tool files to .lua directory
-        for (const tool of skillInfo) {
-            const toolFilePath = path.join(luaDir, `${tool.name}.js`);
-            fs.writeFileSync(toolFilePath, tool.execute);
-        }
-        writeSuccess("✅ Skill compiled successfully");
+        if (fs.existsSync(distDir)) {
+            fs.rmSync(distDir, { recursive: true, force: true });
+        }
+        if (fs.existsSync(luaDir)) {
+            fs.rmSync(luaDir, { recursive: true, force: true });
+        }
+        // Create directory structures
+        fs.mkdirSync(distDir, { recursive: true });
+        fs.mkdirSync(path.join(distDir, "tools"), { recursive: true });
+        fs.mkdirSync(luaDir, { recursive: true });
+        // Find index.ts file
+        const indexPath = findIndexFile();
+        // Use ts-morph to analyze the TypeScript project
+        const project = new Project({
+            tsConfigFilePath: path.join(process.cwd(), "tsconfig.json"),
+        });
+        // Add the index file to the project
+        const indexFile = project.addSourceFileAtPath(indexPath);
+        // Detect tools from skill.addTools calls
+        const tools = await detectTools(indexFile, project);
+        writeProgress(`📦 Found ${tools.length} tools to bundle...`);
+        // Bundle each tool individually and extract execute code
+        for (const tool of tools) {
+            await bundleTool(tool, distDir);
+            await extractExecuteCode(tool, project);
+        }
+        // Bundle the main index file
+        await bundleMainIndex(indexPath, distDir);
+        // Create both deployment formats
+        await createDeploymentData(tools, distDir);
+        await createLegacyDeploymentData(tools, luaDir, indexFile);
+        writeSuccess(`✅ Skill compiled successfully - ${tools.length} tools bundled`);
     }, "compilation");
 }
-async function extractSkillInfo(indexContent, indexFilePath) {
+function findIndexFile() {
+    // Check for index.ts in current directory
+    let indexPath = path.join(process.cwd(), "index.ts");
+    if (fs.existsSync(indexPath)) {
+        return indexPath;
+    }
+    // Check for index.ts in src directory
+    indexPath = path.join(process.cwd(), "src", "index.ts");
+    if (fs.existsSync(indexPath)) {
+        return indexPath;
+    }
+    throw new Error("index.ts not found in current directory or src/ directory");
+}
+async function detectTools(indexFile, project) {
     const tools = [];
-    const toolArguments = [];
-    try {
-        // Create a TypeScript source file
-        const sourceFile = ts.createSourceFile(indexFilePath, indexContent, ts.ScriptTarget.Latest, true);
-        // Traverse the AST to find skill.addTool() calls
-        function visit(node) {
-            // Check for skill.addTool() and skill.addTools() calls
-            if (ts.isCallExpression(node) &&
-                ts.isPropertyAccessExpression(node.expression) &&
-                ts.isIdentifier(node.expression.expression) &&
-                node.expression.expression.text === 'skill' &&
-                ts.isIdentifier(node.expression.name) &&
-                (node.expression.name.text === 'addTool' || node.expression.name.text === 'addTools')) {
-                // Check if this call is commented out
-                if (isNodeCommentedOut(node, sourceFile)) {
-                    return;
+    // 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);
+                                        }
+                                    }
+                                });
+                            }
+                        }
+                    });
                 }
-                // Handle both addTool and addTools calls
-                if (node.expression.name.text === 'addTool') {
-                    // Single tool call
-                    if (node.arguments.length > 0) {
-                        toolArguments.push(node.arguments[0]);
+            }
+        }
+    });
+    // Find all call expressions in the file (addTools method calls)
+    indexFile.forEachDescendant((node) => {
+        if (Node.isCallExpression(node)) {
+            const expression = node.getExpression();
+            // Check if this is skill.addTools or skill.addTool
+            if (Node.isPropertyAccessExpression(expression)) {
+                const object = expression.getExpression();
+                const property = expression.getName();
+                if (property === 'addTools' || property === 'addTool') {
+                    const args = node.getArguments();
+                    if (property === 'addTools' && args.length > 0) {
+                        // Handle skill.addTools([...]) - array of tools
+                        const arrayArg = args[0];
+                        if (Node.isArrayLiteralExpression(arrayArg)) {
+                            const elements = arrayArg.getElements();
+                            for (const element of elements) {
+                                if (Node.isNewExpression(element)) {
+                                    const toolInfo = extractToolFromNewExpressionSync(element, project);
+                                    if (toolInfo) {
+                                        tools.push(toolInfo);
+                                    }
+                                }
+                            }
+                        }
                     }
-                }
-                else if (node.expression.name.text === 'addTools') {
-                    // Multiple tools call - add each tool from the array
-                    if (node.arguments.length > 0 && ts.isArrayLiteralExpression(node.arguments[0])) {
-                        for (const element of node.arguments[0].elements) {
-                            toolArguments.push(element);
+                    else if (property === 'addTool' && args.length > 0) {
+                        // Handle skill.addTool(new ToolClass()) - single tool
+                        const arg = args[0];
+                        if (Node.isNewExpression(arg)) {
+                            const toolInfo = extractToolFromNewExpressionSync(arg, project);
+                            if (toolInfo) {
+                                tools.push(toolInfo);
+                            }
                         }
                     }
                 }
             }
-            // Continue traversing
-            ts.forEachChild(node, visit);
         }
-        visit(sourceFile);
-        // Process all collected tool arguments
-        for (const toolArgument of toolArguments) {
-            await processToolArgument(toolArgument, sourceFile, indexContent, tools);
-        }
-    }
-    catch (error) {
-        console.warn('Warning: Could not parse TypeScript AST:', error);
-        return [];
-    }
+    });
     return tools;
 }
-function isNodeCommentedOut(node, sourceFile) {
-    const nodeStart = node.getStart(sourceFile);
-    const nodeLine = sourceFile.getLineAndCharacterOfPosition(nodeStart).line;
-    // Get the text of the line up to the node
-    const lineStart = sourceFile.getPositionOfLineAndCharacter(nodeLine, 0);
-    const lineText = sourceFile.text.substring(lineStart, nodeStart);
-    // Check if the line starts with a comment
-    const trimmedLine = lineText.trim();
-    return trimmedLine.startsWith('//') ||
-        trimmedLine.startsWith('*') ||
-        trimmedLine.startsWith('#');
-}
-async function processToolArgument(toolArgument, sourceFile, indexContent, tools) {
-    if (ts.isObjectLiteralExpression(toolArgument)) {
-        // Inline tool definition: skill.addTool({...})
-        await processInlineTool(toolArgument, sourceFile, indexContent, tools);
-    }
-    else if (ts.isNewExpression(toolArgument)) {
-        // Class-based tool: skill.addTool(new SomeTool())
-        await processClassBasedTool(toolArgument, sourceFile, indexContent, tools);
-    }
-}
-async function processInlineTool(objectNode, sourceFile, indexContent, tools) {
-    const toolProperties = {};
-    // Extract properties from the object
-    for (const property of objectNode.properties) {
-        if (ts.isPropertyAssignment(property) &&
-            ts.isIdentifier(property.name) &&
-            property.initializer) {
-            const key = property.name.text;
-            const value = property.initializer;
-            if (key === 'name' && ts.isStringLiteral(value)) {
-                toolProperties.name = value.text;
-            }
-            else if (key === 'description' && ts.isStringLiteral(value)) {
-                toolProperties.description = value.text;
-            }
-            else if (key === 'inputSchema' && ts.isIdentifier(value)) {
-                toolProperties.inputSchemaVar = value.text;
-            }
-            else if (key === 'execute' && ts.isArrowFunction(value)) {
-                // Extract the function body
-                if (ts.isBlock(value.body)) {
-                    const bodyText = extractFunctionBody(value.body, sourceFile);
-                    toolProperties.executeBody = bodyText;
+function extractToolFromNewExpressionSync(newExpr, project) {
+    try {
+        const expression = newExpr.getExpression();
+        const className = expression.getText();
+        // Find the import declaration for this class
+        const sourceFile = newExpr.getSourceFile();
+        const imports = sourceFile.getImportDeclarations();
+        for (const importDecl of imports) {
+            const namedImports = importDecl.getNamedImports();
+            const defaultImport = importDecl.getDefaultImport();
+            let toolFilePath = null;
+            // Check named imports
+            for (const namedImport of namedImports) {
+                if (namedImport.getName() === className) {
+                    toolFilePath = resolveImportPath(importDecl.getModuleSpecifierValue(), sourceFile.getFilePath());
+                    break;
                 }
             }
-        }
-    }
-    // Create the tool if all required properties are present
-    if (toolProperties.name &&
-        toolProperties.description &&
-        toolProperties.inputSchemaVar &&
-        toolProperties.executeBody) {
-        // For inline tools, we need to find the schema definitions in the index file
-        const inputSchema = extractSchemaFromIndex(toolProperties.inputSchemaVar, indexContent);
-        const selfContainedExecute = await createSelfContainedExecute(toolProperties.executeBody, indexContent);
-        tools.push({
-            name: toolProperties.name,
-            description: toolProperties.description,
-            inputSchema: inputSchema || { type: "object" },
-            execute: selfContainedExecute
-        });
-    }
-}
-async function processClassBasedTool(newNode, sourceFile, indexContent, tools) {
-    if (ts.isIdentifier(newNode.expression)) {
-        const className = newNode.expression.text;
-        const toolInfo = await extractToolFromClass(className, indexContent, sourceFile.fileName);
-        if (toolInfo) {
-            tools.push(toolInfo);
-        }
-    }
-}
-function extractFunctionBody(blockStatement, sourceFile) {
-    // Extract the function body text from the AST
-    const start = blockStatement.getStart(sourceFile);
-    const end = blockStatement.getEnd();
-    // Get the text between the braces
-    const fullText = sourceFile.text.substring(start, end);
-    // Remove the outer braces and return the inner content
-    if (fullText.startsWith('{') && fullText.endsWith('}')) {
-        return fullText.slice(1, -1).trim();
-    }
-    return fullText;
-}
-function convertZodTypeToJSONSchema(zodType) {
-    switch (zodType) {
-        case 'string':
-            return { type: 'string' };
-        case 'number':
-            return { type: 'number' };
-        case 'boolean':
-            return { type: 'boolean' };
-        default:
-            return { type: 'string' };
-    }
-}
-function extractZodSchemaFromAST(node) {
-    // Handle z.object({...}) calls
-    if (ts.isCallExpression(node) &&
-        ts.isPropertyAccessExpression(node.expression) &&
-        ts.isIdentifier(node.expression.expression) &&
-        node.expression.expression.text === 'z' &&
-        ts.isIdentifier(node.expression.name) &&
-        node.expression.name.text === 'object') {
-        const objectLiteral = node.arguments[0];
-        if (ts.isObjectLiteralExpression(objectLiteral)) {
-            const properties = {};
-            const required = [];
-            for (const property of objectLiteral.properties) {
-                if (ts.isPropertyAssignment(property) &&
-                    ts.isIdentifier(property.name) &&
-                    property.initializer) {
-                    const propertyName = property.name.text;
-                    const zodType = extractZodTypeFromAST(property.initializer);
-                    properties[propertyName] = zodType;
-                    // Only add to required if it's not optional
-                    if (!isOptionalZodType(property.initializer)) {
-                        required.push(propertyName);
-                    }
-                }
+            // Check default import
+            if (!toolFilePath && defaultImport && defaultImport.getText() === className) {
+                toolFilePath = resolveImportPath(importDecl.getModuleSpecifierValue(), sourceFile.getFilePath());
             }
-            return {
-                type: "object",
-                properties,
-                required
-            };
-        }
-    }
-    return { type: "object" };
-}
-function extractZodTypeFromAST(node) {
-    // Handle z.string(), z.number(), z.boolean(), etc.
-    if (ts.isCallExpression(node) &&
-        ts.isPropertyAccessExpression(node.expression) &&
-        ts.isIdentifier(node.expression.expression) &&
-        node.expression.expression.text === 'z') {
-        const zodType = node.expression.name.text;
-        switch (zodType) {
-            case 'string':
-                return { type: 'string' };
-            case 'number':
-                return { type: 'number' };
-            case 'boolean':
-                return { type: 'boolean' };
-            case 'array':
-                // Handle z.array(z.string()) etc.
-                if (node.arguments.length > 0) {
-                    const elementType = extractZodTypeFromAST(node.arguments[0]);
-                    return { type: 'array', items: elementType };
-                }
-                return { type: 'array' };
-            case 'object':
-                // Handle nested z.object({...}) calls
-                if (node.arguments.length > 0) {
-                    return extractZodSchemaFromAST(node);
-                }
-                return { type: 'object' };
-            case 'enum':
-                // Handle z.enum(['a', 'b', 'c'])
-                if (node.arguments.length > 0 && ts.isArrayLiteralExpression(node.arguments[0])) {
-                    const enumValues = [];
-                    for (const element of node.arguments[0].elements) {
-                        if (ts.isStringLiteral(element)) {
-                            enumValues.push(element.text);
+            if (toolFilePath && fs.existsSync(toolFilePath)) {
+                // Extract tool metadata from the class file
+                try {
+                    const toolSourceFile = project.addSourceFileAtPath(toolFilePath);
+                    const classDecl = toolSourceFile.getClass(className);
+                    if (classDecl) {
+                        const nameProperty = classDecl.getProperty('name');
+                        const descProperty = classDecl.getProperty('description');
+                        let toolName = className.replace(/Tool$/, '').toLowerCase();
+                        let description = '';
+                        // Extract name from property if available
+                        if (nameProperty && nameProperty.getInitializer()) {
+                            const nameValue = nameProperty.getInitializer()?.getText();
+                            if (nameValue) {
+                                toolName = nameValue.replace(/['"]/g, '');
+                            }
                         }
+                        // Extract description from property if available
+                        if (descProperty && descProperty.getInitializer()) {
+                            const descValue = descProperty.getInitializer()?.getText();
+                            if (descValue) {
+                                description = descValue.replace(/['"]/g, '');
+                            }
+                        }
+                        const toolInfo = {
+                            name: toolName,
+                            className,
+                            filePath: toolFilePath,
+                            description
+                        };
+                        return toolInfo;
                     }
-                    return { type: 'string', enum: enumValues };
                 }
-                return { type: 'string' };
-            default:
-                return { type: 'string' };
-        }
-    }
-    // Handle method chaining like z.string().optional()
-    if (ts.isCallExpression(node) &&
-        ts.isPropertyAccessExpression(node.expression) &&
-        ts.isCallExpression(node.expression.expression)) {
-        const baseType = extractZodTypeFromAST(node.expression.expression);
-        const method = node.expression.name.text;
-        if (method === 'optional') {
-            // Optional fields are handled by not including them in required array
-            return baseType;
-        }
-        return baseType;
-    }
-    return { type: 'string' };
-}
-function isOptionalZodType(node) {
-    // Check if this is a chained call ending with .optional()
-    if (ts.isCallExpression(node) &&
-        ts.isPropertyAccessExpression(node.expression) &&
-        ts.isIdentifier(node.expression.name) &&
-        node.expression.name.text === 'optional') {
-        return true;
-    }
-    return false;
-}
-function extractSchemaFromIndex(schemaVar, indexContent) {
-    // Create a source file from the index content to parse schemas using AST
-    const sourceFile = ts.createSourceFile('index.ts', indexContent, ts.ScriptTarget.Latest, true);
-    let schema = null;
-    function findSchema(node) {
-        // Look for const schemaVar = z.object({...}) declarations
-        if (ts.isVariableDeclaration(node) &&
-            ts.isIdentifier(node.name) &&
-            node.name.text === schemaVar &&
-            node.initializer) {
-            schema = extractZodSchemaFromAST(node.initializer);
-            return;
-        }
-        ts.forEachChild(node, findSchema);
-    }
-    findSchema(sourceFile);
-    return schema;
-}
-function extractEnvironmentVariables() {
-    const config = readSkillConfig();
-    const envVars = [];
-    if (config?.skill?.env) {
-        for (const [key, value] of Object.entries(config.skill.env)) {
-            envVars.push({
-                name: key,
-                value: value
-            });
-        }
-    }
-    return envVars;
-}
-async function createSelfContainedExecute(executeBody, indexContent) {
-    const dependencies = [];
-    const bundledPackages = new Set();
-    // 1. Parse external package imports and bundle their code
-    const allImportRegex = /import\s+(?:(?:\{([^}]+)\})|(\w+))\s+from\s+["']([^"']+)["']/g;
-    let importMatch;
-    while ((importMatch = allImportRegex.exec(indexContent)) !== null) {
-        const namedImports = importMatch[1]; // Named imports like { z }
-        const defaultImport = importMatch[2]; // Default import like axios
-        const packagePath = importMatch[3];
-        // Skip local imports (relative paths)
-        if (packagePath.startsWith('./') || packagePath.startsWith('../')) {
-            continue;
-        }
-        // Skip lua-cli imports (these are handled separately)
-        if (packagePath.startsWith('lua-cli')) {
-            continue;
-        }
-        // Skip zod - assume it's always available on target machine
-        if (packagePath === 'zod') {
-            // Add require statement for zod instead of bundling
-            if (namedImports) {
-                const importsList = namedImports.split(',').map(imp => imp.trim());
-                const usedImports = importsList.filter(imp => executeBody.includes(imp) || indexContent.includes(`${imp}.`));
-                if (usedImports.length > 0) {
-                    const requireStatement = usedImports.length === 1
-                        ? `const { ${usedImports[0]} } = require('zod');`
-                        : `const { ${usedImports.join(', ')} } = require('zod');`;
-                    bundledPackages.add(requireStatement);
+                catch (fileError) {
+                    console.warn(`Warning: Could not load tool file ${toolFilePath}:`, fileError);
                 }
             }
-            else if (defaultImport) {
-                bundledPackages.add(`const ${defaultImport} = require('zod');`);
-            }
-            continue;
-        }
-        // Bundle other external packages
-        if (namedImports || defaultImport) {
-            const packageCode = await bundlePackageCode(packagePath, namedImports, defaultImport);
-            if (packageCode) {
-                bundledPackages.add(packageCode);
-            }
-        }
-    }
-    // 2. Extract class definitions with proper brace matching
-    const classRegex = /class\s+(\w+)(?:\s+extends\s+\w+)?\s*\{/g;
-    let classMatch;
-    while ((classMatch = classRegex.exec(indexContent)) !== null) {
-        const className = classMatch[1];
-        const classStart = classMatch.index;
-        // Find the matching closing brace
-        let braceCount = 0;
-        let classEnd = classStart;
-        let found = false;
-        for (let i = classStart; i < indexContent.length; i++) {
-            if (indexContent[i] === '{') {
-                braceCount++;
-            }
-            else if (indexContent[i] === '}') {
-                braceCount--;
-                if (braceCount === 0) {
-                    classEnd = i;
-                    found = true;
-                    break;
-                }
-            }
-        }
-        if (found) {
-            const fullClass = indexContent.substring(classStart, classEnd + 1);
-            // Check if this class is used in the execute function
-            let isUsed = false;
-            // Direct usage in execute body
-            if (executeBody.includes(`new ${className}`) ||
-                executeBody.includes(`${className}.`) ||
-                executeBody.includes(`${className}(`)) {
-                isUsed = true;
-            }
-            // Check if any variable that uses this class is referenced in execute body
-            const variableRegex = new RegExp(`(?:const|let|var)\\s+(\\w+)\\s*=\\s*new\\s+${className}\\s*\\([^)]*\\);`, 'g');
-            let varMatch;
-            while ((varMatch = variableRegex.exec(indexContent)) !== null) {
-                const varName = varMatch[1];
-                if (executeBody.includes(varName)) {
-                    isUsed = true;
-                    break;
-                }
-            }
-            if (isUsed) {
-                dependencies.push(fullClass);
-            }
         }
+        return null;
     }
-    // 3. Extract function definitions
-    const functionRegex = /(?:async\s+)?function\s+(\w+)\s*\([^)]*\)\s*\{([\s\S]*?)\n\}/g;
-    let functionMatch;
-    while ((functionMatch = functionRegex.exec(indexContent)) !== null) {
-        const functionName = functionMatch[1];
-        const functionBody = functionMatch[2];
-        if (executeBody.includes(functionName)) {
-            dependencies.push(`function ${functionName}() {\n${functionBody}\n}`);
-        }
+    catch (error) {
+        console.warn(`Warning: Could not extract tool info for ${newExpr.getText()}:`, error);
+        return null;
     }
-    // 4. Extract const/let/var declarations (avoid duplicates)
-    const varRegex = /(?:const|let|var)\s+(\w+)\s*=\s*([^;]+);/g;
-    const declaredVars = new Set();
-    let varMatch;
-    while ((varMatch = varRegex.exec(indexContent)) !== null) {
-        const varName = varMatch[1];
-        const varValue = varMatch[2];
-        // Skip if it's a class instantiation (we'll handle that separately)
-        if (varValue.includes('new ') && varValue.includes('()')) {
-            continue;
-        }
-        // Skip if already declared
-        if (declaredVars.has(varName)) {
-            continue;
-        }
-        if (executeBody.includes(varName)) {
-            declaredVars.add(varName);
-            dependencies.push(`const ${varName} = ${varValue};`);
-        }
+}
+function resolveImportPath(moduleSpecifier, currentFilePath) {
+    if (moduleSpecifier.startsWith('./') || moduleSpecifier.startsWith('../')) {
+        // Relative import - resolve relative to current file
+        const currentDir = path.dirname(currentFilePath);
+        return path.resolve(currentDir, moduleSpecifier + '.ts');
     }
-    // 5. Extract class instantiations (avoid duplicates)
-    const instantiationRegex = /(?:const|let|var)\s+(\w+)\s*=\s*new\s+(\w+)\([^)]*\);/g;
-    let instantiationMatch;
-    while ((instantiationMatch = instantiationRegex.exec(indexContent)) !== null) {
-        const instanceName = instantiationMatch[1];
-        const className = instantiationMatch[2];
-        // Skip if already declared
-        if (declaredVars.has(instanceName)) {
-            continue;
-        }
-        if (executeBody.includes(instanceName)) {
-            declaredVars.add(instanceName);
-            dependencies.push(`const ${instanceName} = new ${className}();`);
-        }
+    else {
+        // Absolute import - assume it's in the project
+        return path.resolve(process.cwd(), 'src', moduleSpecifier + '.ts');
     }
-    // 6. Create the self-contained execute function
-    const allDependencies = [...Array.from(bundledPackages), ...dependencies];
-    const dependencyCode = allDependencies.join('\n');
-    // Strip TypeScript type annotations for JavaScript compatibility (only for local code)
-    const cleanDependencyCode = allDependencies.map(dep => {
-        // Only strip TypeScript from local dependencies, not bundled packages
-        if (dep.includes('require(') || dep.includes('import ')) {
-            return dep; // Skip bundled packages
-        }
-        return dep
-            .replace(/:\s*string/g, '') // Remove : string
-            .replace(/:\s*number/g, '') // Remove : number
-            .replace(/:\s*boolean/g, '') // Remove : boolean
-            .replace(/:\s*any/g, '') // Remove : any
-            .replace(/:\s*void/g, '') // Remove : void
-            .replace(/:\s*object/g, '') // Remove : object
-            .replace(/:\s*Array<[^>]+>/g, '') // Remove : Array<Type>
-            .replace(/:\s*Promise<[^>]+>/g, '') // Remove : Promise<Type>
-            .replace(/:\s*Record<[^>]+>/g, ''); // Remove : Record<Type>
-    }).join('\n');
-    const cleanExecuteBody = executeBody
-        .replace(/:\s*string/g, '') // Remove : string
-        .replace(/:\s*number/g, '') // Remove : number
-        .replace(/:\s*boolean/g, '') // Remove : boolean
-        .replace(/:\s*any/g, '') // Remove : any
-        .replace(/:\s*void/g, '') // Remove : void
-        .replace(/:\s*object/g, '') // Remove : object
-        .replace(/:\s*Array<[^>]+>/g, '') // Remove : Array<Type>
-        .replace(/:\s*Promise<[^>]+>/g, '') // Remove : Promise<Type>
-        .replace(/:\s*Record<[^>]+>/g, ''); // Remove : Record<Type>
-    const selfContainedExecute = `async (input) => {
-${cleanDependencyCode ? `  ${cleanDependencyCode.split('\n').join('\n  ')}\n` : ''}  ${cleanExecuteBody.trim()}
-}`;
-    return selfContainedExecute;
 }
-async function bundlePackageCode(packagePath, namedImports, defaultImport) {
+async function bundleTool(tool, distDir) {
+    writeProgress(`📦 Bundling ${tool.className}...`);
     try {
-        const { build } = await import('esbuild');
-        // Create a temporary entry file for esbuild in .lua directory
-        const luaDir = path.join(process.cwd(), '.lua');
-        if (!fs.existsSync(luaDir)) {
-            fs.mkdirSync(luaDir, { recursive: true });
-        }
-        const entryFile = path.join(luaDir, `${packagePath}-entry.cjs`);
-        const outputFile = path.join(luaDir, `${packagePath}-bundle.cjs`);
-        // Create entry file based on import type
-        let entryContent = '';
-        if (defaultImport) {
-            // For default imports like `import axios from 'axios'`
-            entryContent = `import ${defaultImport} from '${packagePath}';\nmodule.exports = ${defaultImport};`;
-        }
-        else if (namedImports) {
-            // For named imports like `import { z } from 'zod'`
-            const importsList = namedImports.split(',').map(imp => imp.trim());
-            entryContent = `import { ${importsList.join(', ')} } from '${packagePath}';\nmodule.exports = { ${importsList.join(', ')} };`;
-        }
-        else {
-            // Fallback - import everything
-            entryContent = `import * as ${packagePath.replace(/[^a-zA-Z0-9]/g, '_')} from '${packagePath}';\nmodule.exports = ${packagePath.replace(/[^a-zA-Z0-9]/g, '_')};`;
-        }
-        // Write entry file
-        fs.writeFileSync(entryFile, entryContent);
-        // Bundle with esbuild
-        const result = await build({
-            entryPoints: [entryFile],
+        const outputPath = path.join(distDir, 'tools', `${tool.className}.js`);
+        await build({
+            entryPoints: [tool.filePath],
             bundle: true,
-            format: 'cjs', // CommonJS format
+            format: 'cjs',
             platform: 'node',
             target: 'node16',
-            outfile: outputFile,
-            external: [], // Bundle everything
-            minify: false, // Keep readable for debugging
+            outfile: outputPath,
+            external: ['lua-cli/skill', 'lua-cli/user-data-api', 'zod'], // Exclude lua-cli modules and zod - injected into VM
+            minify: true, // Minify for smaller file sizes
             sourcemap: false,
-            write: true,
-            resolveExtensions: ['.js', '.ts', '.json'],
-            mainFields: ['main', 'module', 'browser'],
-            conditions: ['node'],
-            nodePaths: [
-                path.join(process.cwd(), 'node_modules'),
-                path.join(process.cwd(), '..', 'node_modules'),
-                path.join(process.cwd(), '..', '..', 'node_modules')
-            ],
-            absWorkingDir: process.cwd(),
+            resolveExtensions: ['.ts', '.js', '.json'],
+            define: {
+                'process.env.NODE_ENV': '"production"'
+            },
+            // Ensure all other dependencies are bundled
+            packages: 'bundle',
+            // Handle different module formats
+            mainFields: ['main', 'module'],
+            conditions: ['node']
         });
-        if (result.errors.length > 0) {
-            console.warn(`Warning: esbuild errors for package ${packagePath}:`, result.errors);
-            return null;
-        }
-        // Read the bundled output
-        if (!fs.existsSync(outputFile)) {
-            console.warn(`Warning: Bundle output not found for package ${packagePath}`);
-            return null;
-        }
-        const bundledContent = fs.readFileSync(outputFile, 'utf8');
-        // Clean up temporary files
-        try {
-            fs.unlinkSync(entryFile);
-            fs.unlinkSync(outputFile);
-        }
-        catch (cleanupError) {
-            // Ignore cleanup errors
-        }
-        // Create the final bundled code
-        let finalCode = '';
-        if (defaultImport) {
-            finalCode = `const ${defaultImport} = (function() {\n${bundledContent}\n  return module.exports;\n})();\n`;
-        }
-        else if (namedImports) {
-            const importsList = namedImports.split(',').map(imp => imp.trim());
-            finalCode = `(function() {\n${bundledContent}\n})();\n`;
-            finalCode += `const { ${importsList.join(', ')} } = module.exports;\n`;
-        }
-        else {
-            finalCode = `(function() {\n${bundledContent}\n})();\n`;
-        }
-        return finalCode;
+        // Add VM-compatible wrapper
+        await wrapToolForVM(outputPath, tool);
     }
     catch (error) {
-        console.warn(`Warning: Could not bundle package ${packagePath} with esbuild:`, error);
-        // For test environments or when esbuild fails, provide a fallback
-        if (packagePath === 'axios') {
-            return createWorkingAxiosImplementation();
-        }
-        return null;
+        console.warn(`Warning: Failed to bundle ${tool.className}:`, error);
     }
 }
-function createWorkingAxiosImplementation() {
-    return `
-// Working axios implementation using native fetch (for test environments)
-const axios = {
-  get: async (url, config = {}) => {
-    const searchParams = new URLSearchParams(config.params || {});
-    const fullUrl = searchParams.toString() ? \`\${url}?\${searchParams}\` : url;
-    
-    const response = await fetch(fullUrl, {
-      method: 'GET',
-      headers: {
-        'Content-Type': 'application/json',
-        ...config.headers
+async function wrapToolForVM(outputPath, tool) {
+    const bundledCode = fs.readFileSync(outputPath, 'utf8');
+    // Create a wrapper that's compatible with the existing sandbox.ts VM system
+    // The sandbox expects: const executeFunction = ${toolCode}; module.exports = async (input) => { return await executeFunction(input); };
+    const wrappedCode = `async (input) => {
+  // Mock lua-cli/skill module for external dependencies
+  const luaCliSkill = {
+    env: function(key) {
+      if (typeof env !== 'undefined') {
+        return env(key);
       }
-    });
-    
-    if (!response.ok) {
-      const error = new Error(\`Request failed with status \${response.status}\`);
-      error.response = { status: response.status, statusText: response.statusText };
-      throw error;
-    }
-    
-    const data = await response.json();
-    return { 
-      data, 
-      status: response.status, 
-      statusText: response.statusText,
-      headers: response.headers,
-      config: config
-    };
-  },
-  
-  post: async (url, data, config = {}) => {
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        ...config.headers
-      },
-      body: JSON.stringify(data)
-    });
-    
-    if (!response.ok) {
-      const error = new Error(\`Request failed with status \${response.status}\`);
-      error.response = { status: response.status, statusText: response.statusText };
-      throw error;
+      return process.env[key] || '';
     }
-    
-    const responseData = await response.json();
-    return { 
-      data: responseData, 
-      status: response.status, 
-      statusText: response.statusText,
-      headers: response.headers,
-      config: config
-    };
-  },
+  };
   
-  put: async (url, data, config = {}) => {
-    const response = await fetch(url, {
-      method: 'PUT',
-      headers: {
-        'Content-Type': 'application/json',
-        ...config.headers
-      },
-      body: JSON.stringify(data)
-    });
-    
-    if (!response.ok) {
-      const error = new Error(\`Request failed with status \${response.status}\`);
-      error.response = { status: response.status, statusText: response.statusText };
-      throw error;
+  // Mock lua-cli/user-data-api module
+  const luaCliUserDataApi = {
+    user: typeof user !== 'undefined' ? user : {
+      data: {
+        get: async () => ({}),
+        update: async (data) => data,
+        create: async (data) => data
+      }
     }
-    
-    const responseData = await response.json();
-    return { 
-      data: responseData, 
-      status: response.status, 
-      statusText: response.statusText,
-      headers: response.headers,
-      config: config
-    };
-  },
+  };
   
-  delete: async (url, config = {}) => {
-    const response = await fetch(url, {
-      method: 'DELETE',
-      headers: {
-        'Content-Type': 'application/json',
-        ...config.headers
+  // Mock zod module  
+  const zodModule = (() => {
+    try {
+      if (typeof require !== 'undefined') {
+        return require('zod');
       }
-    });
-    
-    if (!response.ok) {
-      const error = new Error(\`Request failed with status \${response.status}\`);
-      error.response = { status: response.status, statusText: response.statusText };
-      throw error;
+    } catch (e) {
+      // Fallback zod implementation
     }
-    
-    const responseData = await response.json();
-    return { 
-      data: responseData, 
-      status: response.status, 
-      statusText: response.statusText,
-      headers: response.headers,
-      config: config
+    return {
+      z: {
+        object: (schema) => ({
+          parse: (data) => data,
+          safeParse: (data) => ({ success: true, data })
+        }),
+        string: () => ({
+          parse: (data) => String(data),
+          safeParse: (data) => ({ success: true, data: String(data) })
+        }),
+        number: () => ({
+          parse: (data) => Number(data),
+          safeParse: (data) => ({ success: true, data: Number(data) })
+        }),
+        boolean: () => ({
+          parse: (data) => Boolean(data),
+          safeParse: (data) => ({ success: true, data: Boolean(data) })
+        })
+      }
     };
-  },
+  })();
   
-  patch: async (url, data, config = {}) => {
-    const response = await fetch(url, {
-      method: 'PATCH',
-      headers: {
-        'Content-Type': 'application/json',
-        ...config.headers
-      },
-      body: JSON.stringify(data)
-    });
-    
-    if (!response.ok) {
-      const error = new Error(\`Request failed with status \${response.status}\`);
-      error.response = { status: response.status, statusText: response.statusText };
-      throw error;
+  // Override require for external modules during execution
+  const originalRequire = require;
+  require = function(id) {
+    if (id === 'lua-cli/skill') {
+      return luaCliSkill;
     }
-    
-    const responseData = await response.json();
-    return { 
-      data: responseData, 
-      status: response.status, 
-      statusText: response.statusText,
-      headers: response.headers,
-      config: config
-    };
-  }
-};
-`;
-}
-async function extractToolFromClass(className, indexContent, indexFilePath) {
-    // Find the import statement for this class using AST
-    const sourceFile = ts.createSourceFile(indexFilePath, indexContent, ts.ScriptTarget.Latest, true);
-    let importPath = null;
-    function findImport(node) {
-        if (ts.isImportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
-            const moduleSpecifier = node.moduleSpecifier;
-            // Check if this import has the class we're looking for
-            if (node.importClause && node.importClause.name && node.importClause.name.text === className) {
-                importPath = moduleSpecifier.text;
-                return;
-            }
-            // Check named imports
-            if (node.importClause && node.importClause.namedBindings && ts.isNamedImports(node.importClause.namedBindings)) {
-                for (const element of node.importClause.namedBindings.elements) {
-                    if (element.name.text === className) {
-                        importPath = moduleSpecifier.text;
-                        return;
-                    }
-                }
-            }
-        }
-        ts.forEachChild(node, findImport);
+    if (id === 'lua-cli/user-data-api') {
+      return luaCliUserDataApi;
     }
-    findImport(sourceFile);
-    if (!importPath) {
-        console.warn(`Warning: Could not find import for class ${className}`);
-        return null;
-    }
-    // Read the tool file - handle both relative and absolute paths
-    let toolFilePath;
-    if (importPath.startsWith('./') || importPath.startsWith('../')) {
-        // Relative path - resolve from the index file directory
-        const indexDir = path.dirname(indexFilePath);
-        toolFilePath = path.join(indexDir, importPath + '.ts');
+    if (id === 'zod') {
+      return zodModule;
     }
-    else {
-        // Absolute path or just filename
-        toolFilePath = path.join(process.cwd(), importPath + '.ts');
+    return originalRequire(id);
+  };
+  
+  // Execute the bundled tool code
+  ${bundledCode}
+  
+  // Restore original require
+  require = originalRequire;
+  
+  // Get the tool class from exports
+  const ToolClass = module.exports.default || module.exports.${tool.className} || module.exports;
+  
+  // Create and execute the tool
+  const toolInstance = new ToolClass();
+  return await toolInstance.execute(input);
+}`;
+    fs.writeFileSync(outputPath, wrappedCode);
+}
+async function bundleMainIndex(indexPath, distDir) {
+    writeProgress("📦 Bundling main index...");
+    try {
+        await build({
+            entryPoints: [indexPath],
+            bundle: true,
+            format: 'cjs',
+            platform: 'node',
+            target: 'node16',
+            outfile: path.join(distDir, 'index.js'),
+            external: ['lua-cli/skill', 'lua-cli/user-data-api', 'zod'], // Exclude lua-cli modules and zod
+            minify: true, // Minify for smaller file sizes
+            sourcemap: false,
+            resolveExtensions: ['.ts', '.js', '.json'],
+            define: {
+                'process.env.NODE_ENV': '"production"'
+            },
+            packages: 'bundle',
+            mainFields: ['main', 'module'],
+            conditions: ['node']
+        });
     }
-    if (!fs.existsSync(toolFilePath)) {
-        console.warn(`Warning: Tool file not found: ${toolFilePath}`);
-        return null;
+    catch (error) {
+        console.warn("Warning: Failed to bundle main index:", error);
     }
-    const toolContent = fs.readFileSync(toolFilePath, 'utf8');
-    const toolSourceFile = ts.createSourceFile(toolFilePath, toolContent, ts.ScriptTarget.Latest, true);
-    // Extract tool properties using AST
-    let toolName = null;
-    let toolDescription = null;
-    let inputSchema = null;
-    let executeMethod = null;
-    function extractToolInfo(node) {
-        // Look for class declaration
-        if (ts.isClassDeclaration(node) && node.name && node.name.text === className) {
-            // Extract class members
-            for (const member of node.members) {
-                if (ts.isPropertyDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
-                    const propertyName = member.name.text;
-                    // Extract name property
-                    if (propertyName === 'name' && member.initializer && ts.isStringLiteral(member.initializer)) {
-                        toolName = member.initializer.text;
-                    }
-                    // Extract description property
-                    if (propertyName === 'description' && member.initializer && ts.isStringLiteral(member.initializer)) {
-                        toolDescription = member.initializer.text;
-                    }
-                    // Extract inputSchema property
-                    if (propertyName === 'inputSchema' && member.initializer) {
-                        inputSchema = extractZodSchemaFromAST(member.initializer);
-                    }
+}
+async function extractExecuteCode(tool, project) {
+    try {
+        const toolSourceFile = project.getSourceFile(tool.filePath);
+        if (!toolSourceFile) {
+            console.warn(`Warning: Could not find source file for ${tool.className}`);
+            return;
+        }
+        const classDecl = toolSourceFile.getClass(tool.className);
+        if (!classDecl) {
+            console.warn(`Warning: Could not find class ${tool.className} in ${tool.filePath}`);
+            return;
+        }
+        // Extract the execute method
+        const executeMethod = classDecl.getMethod('execute');
+        if (!executeMethod) {
+            console.warn(`Warning: Could not find execute method in ${tool.className}`);
+            return;
+        }
+        // Get the execute method body
+        const executeBody = executeMethod.getBodyText();
+        if (!executeBody) {
+            console.warn(`Warning: Execute method has no body in ${tool.className}`);
+            return;
+        }
+        // Read the bundled tool file to get the self-contained code
+        const bundledPath = path.join(process.cwd(), 'dist', 'tools', `${tool.className}.js`);
+        if (fs.existsSync(bundledPath)) {
+            const bundledCode = fs.readFileSync(bundledPath, 'utf8');
+            // Extract just the tool execution function from the bundled code
+            // The bundled code contains the VM wrapper, we need to extract the core functionality
+            const executeFunction = createExecuteFunction(bundledCode, tool);
+            tool.executeCode = executeFunction;
+        }
+        // Extract input schema from zod definition using proper library
+        const inputSchemaProperty = classDecl.getProperty('inputSchema');
+        if (inputSchemaProperty && inputSchemaProperty.getInitializer()) {
+            const initializer = inputSchemaProperty.getInitializer();
+            if (initializer) {
+                try {
+                    // Evaluate the Zod schema to get the actual schema object
+                    const zodSchemaCode = initializer.getText();
+                    tool.inputSchema = await evaluateZodSchemaToJsonSchema(zodSchemaCode);
                 }
-                // Extract execute method
-                if (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name) && member.name.text === 'execute') {
-                    executeMethod = member;
+                catch (error) {
+                    console.warn(`Warning: Could not parse Zod schema for ${tool.className}:`, error);
+                    tool.inputSchema = { type: "object" };
                 }
             }
         }
-        ts.forEachChild(node, extractToolInfo);
-    }
-    extractToolInfo(toolSourceFile);
-    if (!toolName || !toolDescription) {
-        console.warn(`Warning: Could not extract name or description from ${className}`);
-        return null;
+        if (!tool.inputSchema) {
+            tool.inputSchema = { type: "object" };
+        }
     }
-    if (!inputSchema) {
-        console.warn(`Warning: Could not find input schema in ${className}`);
-        return null;
+    catch (error) {
+        console.warn(`Warning: Could not extract execute code for ${tool.className}:`, error);
     }
-    if (!executeMethod) {
-        console.warn(`Warning: Could not find execute method in ${className}`);
-        return null;
+}
+function createExecuteFunction(bundledCode, tool) {
+    // The bundled code is already wrapped for VM execution by wrapToolForVM
+    // Just return it directly since it's already an async function
+    return bundledCode;
+}
+async function evaluateZodSchemaToJsonSchema(zodSchemaCode) {
+    try {
+        // 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;
+        }
+        // Remove the top-level $schema and title properties that we don't need
+        const { $schema, title, definitions, $ref, ...cleanSchema } = jsonSchema;
+        return cleanSchema;
     }
-    // Extract execute method body
-    if (!executeMethod.body) {
-        console.warn(`Warning: Execute method has no body in ${className}`);
-        return null;
+    catch (error) {
+        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' };
+        }
+        if (zodSchemaCode.includes('z.string()'))
+            return { type: 'string' };
+        if (zodSchemaCode.includes('z.number()'))
+            return { type: 'number' };
+        if (zodSchemaCode.includes('z.boolean()'))
+            return { type: 'boolean' };
+        return { type: 'object' };
     }
-    const executeBody = extractFunctionBody(executeMethod.body, toolSourceFile);
-    // For class-based tools, we need to create a self-contained function that includes:
-    // 1. The service classes
-    // 2. Class instantiation
-    // 3. The execute logic
-    const selfContainedExecute = await createClassBasedExecute(executeBody, toolContent, className, toolFilePath);
-    return {
-        name: toolName,
-        description: toolDescription,
-        inputSchema: inputSchema || { type: "object" },
-        execute: selfContainedExecute
+}
+async function createDeploymentData(tools, distDir) {
+    const config = readSkillConfig();
+    const packageJsonPath = path.join(process.cwd(), "package.json");
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    const deploymentData = {
+        name: config?.skill?.name || packageJson.name || "lua-skill",
+        version: config?.skill?.version || packageJson.version || "1.0.0",
+        skillId: config?.skill?.skillId || "",
+        description: config?.skill?.description || packageJson.description || "",
+        context: config?.skill?.context || "",
+        tools: tools.map(tool => ({
+            name: tool.name,
+            className: tool.className,
+            description: tool.description || "",
+            filePath: `tools/${tool.className}.js`
+        }))
     };
+    fs.writeFileSync(path.join(distDir, 'deployment.json'), JSON.stringify(deploymentData, null, 2));
 }
-async function createClassBasedExecute(executeBody, toolContent, className, toolFilePath) {
-    const dependencies = [];
-    const bundledPackages = new Set();
-    // 1. Parse imports from the tool file
-    const importRegex = /import\s+(?:(?:\{([^}]+)\})|(\w+))\s+from\s+["']([^"']+)["']/g;
-    let importMatch;
-    while ((importMatch = importRegex.exec(toolContent)) !== null) {
-        const namedImports = importMatch[1];
-        const defaultImport = importMatch[2];
-        const packagePath = importMatch[3];
-        // Skip lua-cli imports
-        if (packagePath.startsWith('lua-cli')) {
-            continue;
-        }
-        // Handle zod
-        if (packagePath === 'zod') {
-            if (namedImports) {
-                const importsList = namedImports.split(',').map(imp => imp.trim());
-                const usedImports = importsList.filter(imp => executeBody.includes(imp) || toolContent.includes(`${imp}.`));
-                if (usedImports.length > 0) {
-                    const requireStatement = usedImports.length === 1
-                        ? `const { ${usedImports[0]} } = require('zod');`
-                        : `const { ${usedImports.join(', ')} } = require('zod');`;
-                    bundledPackages.add(requireStatement);
+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 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);
                 }
             }
-            else if (defaultImport) {
-                bundledPackages.add(`const ${defaultImport} = require('zod');`);
-            }
-            continue;
         }
-        // Handle axios - bundle it properly
-        if (packagePath === 'axios') {
-            const packageCode = await bundlePackageCode(packagePath, namedImports, defaultImport);
-            if (packageCode) {
-                bundledPackages.add(packageCode);
+    });
+    // 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;
+                }
             }
-            continue;
         }
-        // Handle local service imports
-        if (packagePath.startsWith('./') || packagePath.startsWith('../')) {
-            // Resolve the service file path relative to the tool file location
-            const toolDir = path.dirname(toolFilePath);
-            const serviceFilePath = path.resolve(toolDir, packagePath + '.ts');
-            if (fs.existsSync(serviceFilePath)) {
-                const serviceContent = fs.readFileSync(serviceFilePath, 'utf8');
-                // Process all imports in the service file
-                const serviceImportRegex = /import\s+(?:(?:\{([^}]+)\})|(\w+))\s+from\s+["']([^"']+)["']/g;
-                let serviceImportMatch;
-                while ((serviceImportMatch = serviceImportRegex.exec(serviceContent)) !== null) {
-                    const namedImports = serviceImportMatch[1];
-                    const defaultImport = serviceImportMatch[2];
-                    const packagePath = serviceImportMatch[3];
-                    // Skip lua-cli imports
-                    if (packagePath.startsWith('lua-cli')) {
-                        continue;
-                    }
-                    // Handle zod
-                    if (packagePath === 'zod') {
-                        if (namedImports) {
-                            const importsList = namedImports.split(',').map(imp => imp.trim());
-                            const usedImports = importsList.filter(imp => serviceContent.includes(`${imp}.`));
-                            if (usedImports.length > 0) {
-                                const requireStatement = usedImports.length === 1
-                                    ? `const { ${usedImports[0]} } = require('zod');`
-                                    : `const { ${usedImports.join(', ')} } = require('zod');`;
-                                bundledPackages.add(requireStatement);
+        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 = {
+        skills: updatedSkillsArray
+    };
+    // Write legacy deploy.json to .lua directory
+    fs.writeFileSync(path.join(luaDir, "deploy.json"), JSON.stringify(deployData, null, 2));
+    // Write individual tool files to .lua directory (uncompressed)
+    for (const tool of tools) {
+        if (tool.executeCode) {
+            const toolFilePath = path.join(luaDir, `${tool.name}.js`);
+            fs.writeFileSync(toolFilePath, tool.executeCode);
+        }
+    }
+}
+function extractSkillsMetadata(indexFile) {
+    const skills = [];
+    // Find all LuaSkill constructor calls
+    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];
+                    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();
+                            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.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);
                             }
                         }
-                        else if (defaultImport) {
-                            bundledPackages.add(`const ${defaultImport} = require('zod');`);
-                        }
-                        continue;
-                    }
-                    // Handle axios - bundle it properly
-                    if (packagePath === 'axios') {
-                        const packageCode = await bundlePackageCode(packagePath, namedImports, defaultImport);
-                        if (packageCode) {
-                            bundledPackages.add(packageCode);
-                        }
-                        continue;
-                    }
-                    // Bundle other external packages
-                    if (namedImports || defaultImport) {
-                        const packageCode = await bundlePackageCode(packagePath, namedImports, defaultImport);
-                        if (packageCode) {
-                            bundledPackages.add(packageCode);
-                        }
+                    });
+                    if (skillName) {
+                        skills.push({
+                            name: skillName,
+                            version: skillVersion || '1.0.0',
+                            description,
+                            context,
+                            constructorTools
+                        });
                     }
                 }
-                // Extract the service class with proper brace matching
-                const classRegex = /class\s+(\w+)(?:\s+extends\s+\w+)?\s*\{/g;
-                let classMatch = classRegex.exec(serviceContent);
-                if (classMatch) {
-                    const serviceClassName = classMatch[1];
-                    const startIndex = classMatch.index + classMatch[0].length - 1; // Position of opening brace
-                    // Find matching closing brace
-                    let braceCount = 1;
-                    let endIndex = startIndex + 1;
-                    while (endIndex < serviceContent.length && braceCount > 0) {
-                        if (serviceContent[endIndex] === '{')
-                            braceCount++;
-                        else if (serviceContent[endIndex] === '}')
-                            braceCount--;
-                        endIndex++;
+            }
+        }
+    });
+    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;
                     }
-                    if (braceCount === 0) {
-                        const serviceClassBody = serviceContent.substring(startIndex + 1, endIndex - 1);
-                        // Clean up the class body (remove TypeScript types)
-                        const cleanClassBody = serviceClassBody
-                            .replace(/:\s*string/g, '')
-                            .replace(/:\s*number/g, '')
-                            .replace(/:\s*boolean/g, '')
-                            .replace(/:\s*any/g, '')
-                            .replace(/:\s*void/g, '')
-                            .replace(/:\s*Promise<[^>]+>/g, '')
-                            .replace(/:\s*Record<[^>]+>/g, '');
-                        // Create the service class
-                        const serviceClass = `class ${serviceClassName} {\n${cleanClassBody}\n}`;
-                        dependencies.push(serviceClass);
+                    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');
+                }
             }
-            continue;
-        }
-        // Bundle other external packages
-        if (namedImports || defaultImport) {
-            const packageCode = await bundlePackageCode(packagePath, namedImports, defaultImport);
-            if (packageCode) {
-                bundledPackages.add(packageCode);
+            catch (error) {
+                console.error(`❌ Failed to create skill ${skill.name}:`, error);
+                throw error; // Don't use temp IDs, let the process fail properly
             }
         }
     }
-    // 2. Extract class instantiation from constructor
-    const constructorMatch = toolContent.match(/constructor\s*\([^)]*\)\s*\{([\s\S]*?)\}/);
-    if (constructorMatch) {
-        const constructorBody = constructorMatch[1];
-        // Extract service instantiation
-        const serviceInstantiationMatch = constructorBody.match(/this\.(\w+)\s*=\s*new\s+(\w+)\([^)]*\);/);
-        if (serviceInstantiationMatch) {
-            const serviceProperty = serviceInstantiationMatch[1];
-            const serviceClass = serviceInstantiationMatch[2];
-            dependencies.push(`const ${serviceProperty} = new ${serviceClass}();`);
-        }
+    // Update YAML file if needed
+    if (yamlUpdated) {
+        await updateYamlWithSkills(existingSkills, config);
     }
-    // 3. Create the self-contained execute function
-    const allDependencies = [...Array.from(bundledPackages), ...dependencies];
-    const dependencyCode = allDependencies.join('\n');
-    // Clean the execute body (remove TypeScript types)
-    const cleanExecuteBody = executeBody
-        .replace(/:\s*string/g, '')
-        .replace(/:\s*number/g, '')
-        .replace(/:\s*boolean/g, '')
-        .replace(/:\s*any/g, '')
-        .replace(/:\s*void/g, '')
-        .replace(/:\s*Promise<[^>]+>/g, '')
-        .replace(/:\s*Record<[^>]+>/g, '');
-    // Replace this.serviceProperty with the instantiated service
-    const finalExecuteBody = cleanExecuteBody.replace(/this\.(\w+)/g, '$1');
-    return `async (input) => {
-${dependencyCode ? dependencyCode + '\n' : ''}${finalExecuteBody}
-}`;
+    return updatedSkillsArray;
 }
-async function extractSkillMetadata(indexContent) {
-    // Extract skillId and version from config file
-    let skillId = '';
-    let version = '';
-    const config = readSkillConfig();
-    if (config) {
-        skillId = config.skill?.skillId || '';
-        version = config.skill?.version || '';
-    }
-    // Extract description and context from LuaSkill constructor
-    let description = '';
-    let context = '';
-    // Look for LuaSkill constructor with object configuration
-    const luaSkillRegex = /new\s+LuaSkill\s*\(\s*\{([\s\S]*?)\}\s*\)/;
-    const match = luaSkillRegex.exec(indexContent);
-    if (match) {
-        const configContent = match[1];
-        // Extract description
-        const descriptionMatch = configContent.match(/description:\s*["']([^"']+)["']/);
-        if (descriptionMatch) {
-            description = descriptionMatch[1];
-        }
-        // Extract context
-        const contextMatch = configContent.match(/context:\s*["']([^"']+)["']/);
-        if (contextMatch) {
-            context = contextMatch[1];
-        }
-    }
-    return {
-        skillId,
-        version,
-        description,
-        context
+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');
 }