lua-cli 1.3.2-alpha.2 → 1.3.2-alpha.3

package/dist/commands/compile.js

@@ -1,1066 +1,661 @@
 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 { Project, Node } from "ts-morph";
+import { build } from "esbuild";
 // 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;
-                }
-                // 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
+    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 (object.getText() === 'skill' && (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, '');
+                            }
                         }
+                        return {
+                            name: toolName,
+                            className,
+                            filePath: toolFilePath,
+                            description
+                        };
                     }
-                    return { type: 'string', enum: enumValues };
                 }
-                return { type: 'string' };
-            default:
-                return { type: 'string' };
+                catch (fileError) {
+                    console.warn(`Warning: Could not load tool file ${toolFilePath}:`, fileError);
+                }
+            }
         }
+        return null;
     }
-    // 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;
+    catch (error) {
+        console.warn(`Warning: Could not extract tool info for ${newExpr.getText()}:`, error);
+        return null;
     }
-    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;
+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');
     }
-    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);
+    else {
+        // Absolute import - assume it's in the project
+        return path.resolve(process.cwd(), 'src', moduleSpecifier + '.ts');
     }
-    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
-            });
-        }
+async function bundleTool(tool, distDir) {
+    writeProgress(`📦 Bundling ${tool.className}...`);
+    try {
+        const outputPath = path.join(distDir, 'tools', `${tool.className}.js`);
+        await build({
+            entryPoints: [tool.filePath],
+            bundle: true,
+            format: 'cjs',
+            platform: 'node',
+            target: 'node16',
+            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,
+            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']
+        });
+        // Add VM-compatible wrapper
+        await wrapToolForVM(outputPath, tool);
+    }
+    catch (error) {
+        console.warn(`Warning: Failed to bundle ${tool.className}:`, error);
     }
-    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);
-                }
-            }
-            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);
-            }
-        }
+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);
+      }
+      return process.env[key] || '';
     }
-    // 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);
-            }
-        }
+  };
+  
+  // 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
+      }
     }
-    // 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}`);
-        }
+  };
+  
+  // Mock zod module  
+  const zodModule = (() => {
+    try {
+      if (typeof require !== 'undefined') {
+        return require('zod');
+      }
+    } catch (e) {
+      // Fallback zod implementation
     }
-    // 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};`);
-        }
+    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) })
+        })
+      }
+    };
+  })();
+  
+  // Override require for external modules during execution
+  const originalRequire = require;
+  require = function(id) {
+    if (id === 'lua-cli/skill') {
+      return luaCliSkill;
     }
-    // 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}();`);
-        }
+    if (id === 'lua-cli/user-data-api') {
+      return luaCliUserDataApi;
     }
-    // 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()}
+    if (id === 'zod') {
+      return zodModule;
+    }
+    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);
 }`;
-    return selfContainedExecute;
+    fs.writeFileSync(outputPath, wrappedCode);
 }
-async function bundlePackageCode(packagePath, namedImports, defaultImport) {
+async function bundleMainIndex(indexPath, distDir) {
+    writeProgress("📦 Bundling main index...");
     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],
+        await build({
+            entryPoints: [indexPath],
             bundle: true,
-            format: 'cjs', // CommonJS format
+            format: 'cjs',
             platform: 'node',
             target: 'node16',
-            outfile: outputFile,
-            external: [], // Bundle everything
-            minify: false, // Keep readable for debugging
+            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,
-            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"'
+            },
+            packages: 'bundle',
+            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;
+    }
+    catch (error) {
+        console.warn("Warning: Failed to bundle main index:", error);
+    }
+}
+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 bundledContent = fs.readFileSync(outputFile, 'utf8');
-        // Clean up temporary files
-        try {
-            fs.unlinkSync(entryFile);
-            fs.unlinkSync(outputFile);
+        const classDecl = toolSourceFile.getClass(tool.className);
+        if (!classDecl) {
+            console.warn(`Warning: Could not find class ${tool.className} in ${tool.filePath}`);
+            return;
         }
-        catch (cleanupError) {
-            // Ignore cleanup errors
+        // Extract the execute method
+        const executeMethod = classDecl.getMethod('execute');
+        if (!executeMethod) {
+            console.warn(`Warning: Could not find execute method in ${tool.className}`);
+            return;
         }
-        // Create the final bundled code
-        let finalCode = '';
-        if (defaultImport) {
-            finalCode = `const ${defaultImport} = (function() {\n${bundledContent}\n  return module.exports;\n})();\n`;
+        // Get the execute method body
+        const executeBody = executeMethod.getBodyText();
+        if (!executeBody) {
+            console.warn(`Warning: Execute method has no body in ${tool.className}`);
+            return;
         }
-        else if (namedImports) {
-            const importsList = namedImports.split(',').map(imp => imp.trim());
-            finalCode = `(function() {\n${bundledContent}\n})();\n`;
-            finalCode += `const { ${importsList.join(', ')} } = module.exports;\n`;
+        // 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
+        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());
+            }
         }
-        else {
-            finalCode = `(function() {\n${bundledContent}\n})();\n`;
+        if (!tool.inputSchema) {
+            tool.inputSchema = { type: "object" };
         }
-        return finalCode;
     }
     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: Could not extract execute code for ${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
-      }
-    });
-    
-    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;
-    }
-    
-    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;
-    }
-    
-    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
-      }
-    });
-    
-    if (!response.ok) {
-      const error = new Error(\`Request failed with status \${response.status}\`);
-      error.response = { status: response.status, statusText: response.statusText };
-      throw error;
-    }
-    
-    const responseData = await response.json();
-    return { 
-      data: responseData, 
-      status: response.status, 
-      statusText: response.statusText,
-      headers: response.headers,
-      config: config
-    };
-  },
-  
-  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;
-    }
-    
-    const responseData = await response.json();
-    return { 
-      data: responseData, 
-      status: response.status, 
-      statusText: response.statusText,
-      headers: response.headers,
-      config: config
-    };
-  }
-};
-`;
+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 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;
-                    }
-                }
+function parseZodSchemaToJsonSchema(zodSchemaText) {
+    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);
             }
         }
-        ts.forEachChild(node, findImport);
-    }
-    findImport(sourceFile);
-    if (!importPath) {
-        console.warn(`Warning: Could not find import for class ${className}`);
-        return null;
+        // Fallback to direct parsing if AST approach fails
+        return parseZodTextToJsonSchema(zodSchemaText);
     }
-    // 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');
-    }
-    else {
-        // Absolute path or just filename
-        toolFilePath = path.join(process.cwd(), importPath + '.ts');
-    }
-    if (!fs.existsSync(toolFilePath)) {
-        console.warn(`Warning: Tool file not found: ${toolFilePath}`);
-        return null;
+    catch (error) {
+        console.warn('Warning: Could not parse Zod schema with AST, falling back to text parsing:', error);
+        return parseZodTextToJsonSchema(zodSchemaText);
     }
-    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;
+}
+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
+                        };
                     }
-                    // Extract inputSchema property
-                    if (propertyName === 'inputSchema' && member.initializer) {
-                        inputSchema = extractZodSchemaFromAST(member.initializer);
+                }
+                // 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' };
                     }
                 }
-                // Extract execute method
-                if (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name) && member.name.text === 'execute') {
-                    executeMethod = member;
+            }
+            // 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);
                 }
             }
         }
-        ts.forEachChild(node, extractToolInfo);
-    }
-    extractToolInfo(toolSourceFile);
-    if (!toolName || !toolDescription) {
-        console.warn(`Warning: Could not extract name or description from ${className}`);
-        return null;
+        // Fallback
+        return { type: 'object' };
     }
-    if (!inputSchema) {
-        console.warn(`Warning: Could not find input schema in ${className}`);
-        return null;
-    }
-    if (!executeMethod) {
-        console.warn(`Warning: Could not find execute method in ${className}`);
-        return null;
-    }
-    // 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 parse Zod AST node:', error);
+        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 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;
+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';
         }
-        // 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);
+    }
+    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);
                 }
             }
-            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;
-        }
-        // 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);
-                            }
-                        }
-                        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);
-                        }
-                    }
+            // 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;
                 }
-                // 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++;
-                    }
-                    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);
-                    }
+                properties[propName] = { type: 'array', items: itemSchema };
+                if (!zodSchemaText.includes(`${propName}: z.array(z.${itemType}()).optional()`)) {
+                    required.push(propName);
                 }
             }
-            continue;
-        }
-        // Bundle other external packages
-        if (namedImports || defaultImport) {
-            const packageCode = await bundlePackageCode(packagePath, namedImports, defaultImport);
-            if (packageCode) {
-                bundledPackages.add(packageCode);
-            }
+            return {
+                type: 'object',
+                properties,
+                required
+            };
         }
+        // Handle simple types
+        if (zodSchemaText.includes('z.string()'))
+            return { type: 'string' };
+        if (zodSchemaText.includes('z.number()'))
+            return { type: 'number' };
+        if (zodSchemaText.includes('z.boolean()'))
+            return { type: 'boolean' };
+        if (zodSchemaText.includes('z.array('))
+            return { type: 'array' };
+        // Fallback
+        return { type: 'object' };
     }
-    // 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}();`);
-        }
+    catch (error) {
+        console.warn('Warning: Could not parse Zod schema text:', error);
+        return { type: 'object' };
     }
-    // 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}
-}`;
 }
-async function extractSkillMetadata(indexContent) {
-    // Extract skillId and version from config file
-    let skillId = '';
-    let version = '';
+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 createLegacyDeploymentData(tools, luaDir, indexFile) {
     const config = readSkillConfig();
-    if (config) {
-        skillId = config.skill?.skillId || '';
-        version = config.skill?.version || '';
+    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);
+    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 || "")
+        }))
+    };
+    // 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);
+        }
     }
-    // Extract description and context from LuaSkill constructor
+}
+function extractSkillMetadata(indexFile) {
+    let skillId = '';
     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];
+    // Find LuaSkill constructor call
+    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];
+                    // 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, '');
+                            }
+                            else if (name === 'context' && value) {
+                                context = value.replace(/['"]/g, '');
+                            }
+                        }
+                    });
+                }
+            }
         }
-    }
-    return {
-        skillId,
-        version,
-        description,
-        context
-    };
+    });
+    return { skillId, description, context };
 }