lua-cli 1.2.1 → 1.3.0

package/dist/commands/compile.js

@@ -0,0 +1,1004 @@
+import fs from "fs";
+import path from "path";
+import { gzipSync, gunzipSync } from "zlib";
+import { Buffer } from "buffer";
+import { withErrorHandling, writeProgress, writeSuccess } from "../utils/cli.js";
+import { readSkillConfig } from '../utils/files.js';
+import * as ts from "typescript";
+// 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...");
+        // 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
+        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");
+    }, "compilation");
+}
+async function extractSkillInfo(indexContent, indexFilePath) {
+    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() 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') {
+                // Check if this call is commented out
+                if (isNodeCommentedOut(node, sourceFile)) {
+                    return;
+                }
+                // Collect the tool argument for later processing
+                if (node.arguments.length > 0) {
+                    const toolArgument = node.arguments[0];
+                    toolArguments.push(toolArgument);
+                }
+            }
+            // 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, falling back to regex approach:', error);
+        // Fallback to the old regex approach if AST parsing fails
+        return await extractSkillInfoRegex(indexContent, indexFilePath);
+    }
+    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 === 'outputSchema' && ts.isIdentifier(value)) {
+                toolProperties.outputSchemaVar = 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;
+                }
+            }
+        }
+    }
+    // Create the tool if all required properties are present
+    if (toolProperties.name &&
+        toolProperties.description &&
+        toolProperties.inputSchemaVar &&
+        toolProperties.outputSchemaVar &&
+        toolProperties.executeBody) {
+        const inputSchema = convertSchemaToJSON(toolProperties.inputSchemaVar, indexContent);
+        const outputSchema = convertSchemaToJSON(toolProperties.outputSchemaVar, indexContent);
+        const selfContainedExecute = await createSelfContainedExecute(toolProperties.executeBody, indexContent);
+        tools.push({
+            name: toolProperties.name,
+            description: toolProperties.description,
+            inputSchema,
+            outputSchema,
+            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;
+}
+// Fallback regex-based extraction (renamed from the original function)
+async function extractSkillInfoRegex(indexContent, indexFilePath) {
+    const tools = [];
+    // Find all addTool calls by searching for the pattern and manually parsing
+    let searchIndex = 0;
+    while (true) {
+        const addToolIndex = indexContent.indexOf('skill.addTool(', searchIndex);
+        if (addToolIndex === -1)
+            break;
+        // Check if this line is commented out
+        const lineStart = indexContent.lastIndexOf('\n', addToolIndex) + 1;
+        const lineContent = indexContent.substring(lineStart, addToolIndex).trim();
+        if (lineContent.startsWith('//') || lineContent.startsWith('*') || lineContent.startsWith('#')) {
+            searchIndex = addToolIndex + 1;
+            continue;
+        }
+        // Find the matching closing parenthesis
+        let parenCount = 0;
+        let braceCount = 0;
+        let callStart = addToolIndex + 'skill.addTool('.length;
+        let callEnd = callStart;
+        let found = false;
+        for (let i = callStart; i < indexContent.length; i++) {
+            const char = indexContent[i];
+            if (char === '(')
+                parenCount++;
+            else if (char === ')') {
+                if (parenCount === 0) {
+                    callEnd = i;
+                    found = true;
+                    break;
+                }
+                parenCount--;
+            }
+            else if (char === '{')
+                braceCount++;
+            else if (char === '}')
+                braceCount--;
+        }
+        if (!found) {
+            searchIndex = addToolIndex + 1;
+            continue;
+        }
+        const toolArgument = indexContent.substring(callStart, callEnd).trim();
+        // Check if it's an inline tool definition: skill.addTool({...})
+        if (toolArgument.startsWith('{')) {
+            // Extract tool properties
+            const nameMatch = toolArgument.match(/name:\s*["']([^"']+)["']/);
+            const descriptionMatch = toolArgument.match(/description:\s*["']([^"']+)["']/);
+            const inputSchemaMatch = toolArgument.match(/inputSchema:\s*(\w+)/);
+            const outputSchemaMatch = toolArgument.match(/outputSchema:\s*(\w+)/);
+            const executeMatch = toolArgument.match(/execute:\s*async\s*\([^)]*\)\s*=>\s*\{([\s\S]*?)\}/);
+            if (nameMatch && descriptionMatch && inputSchemaMatch && outputSchemaMatch && executeMatch) {
+                const toolName = nameMatch[1];
+                const toolDescription = descriptionMatch[1];
+                const inputSchemaVar = inputSchemaMatch[1];
+                const outputSchemaVar = outputSchemaMatch[1];
+                const executeBody = executeMatch[1];
+                // Convert schemas to JSON Schema format
+                const inputSchema = convertSchemaToJSON(inputSchemaVar, indexContent);
+                const outputSchema = convertSchemaToJSON(outputSchemaVar, indexContent);
+                // Create self-contained execute function
+                const selfContainedExecute = await createSelfContainedExecute(executeBody, indexContent);
+                tools.push({
+                    name: toolName,
+                    description: toolDescription,
+                    inputSchema,
+                    outputSchema,
+                    execute: selfContainedExecute
+                });
+            }
+        }
+        // Check if it's a class-based tool: skill.addTool(new SomeTool())
+        else if (toolArgument.startsWith('new ')) {
+            const classMatch = toolArgument.match(/new\s+(\w+)\(\)/);
+            if (classMatch) {
+                const className = classMatch[1];
+                // Find the tool class definition
+                const toolInfo = await extractToolFromClass(className, indexContent, indexFilePath);
+                if (toolInfo) {
+                    tools.push(toolInfo);
+                }
+            }
+        }
+        searchIndex = callEnd + 1;
+    }
+    return tools;
+}
+function convertSchemaToJSON(schemaVar, indexContent) {
+    // Find the schema definition
+    const schemaRegex = new RegExp(`const\\s+${schemaVar}\\s*=\\s*z\\.object\\(\\{([\\s\\S]*?)\\}\\\);`, 'g');
+    const match = schemaRegex.exec(indexContent);
+    if (match) {
+        const schemaContent = match[1];
+        // Convert Zod schema to JSON Schema format
+        return {
+            type: "object",
+            properties: parseZodProperties(schemaContent),
+            required: extractRequiredFields(schemaContent)
+        };
+    }
+    // If no match found, return empty schema
+    return { type: "object", properties: {} };
+}
+function parseZodProperties(schemaContent) {
+    const properties = {};
+    // Simple regex to find z.string(), z.number(), etc.
+    const fieldRegex = /(\w+):\s*z\.(\w+)\(\)/g;
+    let match;
+    while ((match = fieldRegex.exec(schemaContent)) !== null) {
+        const fieldName = match[1];
+        const fieldType = match[2];
+        switch (fieldType) {
+            case 'string':
+                properties[fieldName] = { type: 'string' };
+                break;
+            case 'number':
+                properties[fieldName] = { type: 'number' };
+                break;
+            case 'boolean':
+                properties[fieldName] = { type: 'boolean' };
+                break;
+            default:
+                properties[fieldName] = { type: 'string' };
+        }
+    }
+    return properties;
+}
+function extractRequiredFields(schemaContent) {
+    const required = [];
+    const fieldRegex = /(\w+):\s*z\.(\w+)\(\)/g;
+    let match;
+    while ((match = fieldRegex.exec(schemaContent)) !== null) {
+        required.push(match[1]);
+    }
+    return required;
+}
+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);
+            }
+        }
+    }
+    // 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);
+            }
+        }
+    }
+    // 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}`);
+        }
+    }
+    // 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};`);
+        }
+    }
+    // 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}();`);
+        }
+    }
+    // 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) {
+    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],
+            bundle: true,
+            format: 'cjs', // CommonJS format
+            platform: 'node',
+            target: 'node16',
+            outfile: outputFile,
+            external: [], // Bundle everything
+            minify: false, // Keep readable for debugging
+            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(),
+        });
+        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;
+    }
+    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;
+    }
+}
+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
+    };
+  }
+};
+`;
+}
+async function extractToolFromClass(className, indexContent, indexFilePath) {
+    // Find the import statement for this class
+    const importRegex = new RegExp(`import\\s+${className}\\s+from\\s+["']([^"']+)["']`, 'g');
+    const importMatch = importRegex.exec(indexContent);
+    if (!importMatch) {
+        console.warn(`Warning: Could not find import for class ${className}`);
+        return null;
+    }
+    const importPath = importMatch[1];
+    // 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;
+    }
+    const toolContent = fs.readFileSync(toolFilePath, 'utf8');
+    // Extract tool properties from the class
+    const nameMatch = toolContent.match(/this\.name\s*=\s*["']([^"']+)["']/);
+    const descriptionMatch = toolContent.match(/this\.description\s*=\s*["']([^"']+)["']/);
+    if (!nameMatch || !descriptionMatch) {
+        console.warn(`Warning: Could not extract name or description from ${className}`);
+        return null;
+    }
+    const toolName = nameMatch[1];
+    const toolDescription = descriptionMatch[1];
+    // Extract schemas - look for multiple schema definitions
+    const inputSchemaMatch = toolContent.match(/const\s+(\w+)\s*=\s*z\.object\(/);
+    const outputSchemaMatch = toolContent.match(/const\s+(\w+)\s*=\s*z\.object\(/);
+    if (!inputSchemaMatch) {
+        console.warn(`Warning: Could not find input schema in ${className}`);
+        return null;
+    }
+    // Convert schemas to JSON Schema format
+    const inputSchema = convertSchemaToJSON(inputSchemaMatch[1], toolContent);
+    const outputSchema = outputSchemaMatch ? convertSchemaToJSON(outputSchemaMatch[1], toolContent) : { type: "object" };
+    // Extract execute method
+    const executeMatch = toolContent.match(/async\s+execute\s*\([^)]*\)\s*\{([\s\S]*?)\}/);
+    if (!executeMatch) {
+        console.warn(`Warning: Could not find execute method in ${className}`);
+        return null;
+    }
+    const executeBody = executeMatch[1];
+    // 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,
+        outputSchema,
+        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;
+        }
+        // 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);
+                }
+            }
+            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);
+                        }
+                    }
+                }
+                // 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);
+                    }
+                }
+            }
+            continue;
+        }
+        // Bundle other external packages
+        if (namedImports || defaultImport) {
+            const packageCode = await bundlePackageCode(packagePath, namedImports, defaultImport);
+            if (packageCode) {
+                bundledPackages.add(packageCode);
+            }
+        }
+    }
+    // 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}();`);
+        }
+    }
+    // 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 = '';
+    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
+    };
+}