lua-cli 1.1.2 → 1.1.4-beta.0

package/dist/commands/agents.d.ts

@@ -0,0 +1 @@
+export declare function agentsCommand(): Promise<void>;

package/dist/commands/apiKey.d.ts

@@ -0,0 +1 @@
+export declare function apiKeyCommand(): Promise<void>;

package/dist/commands/configure.d.ts

@@ -0,0 +1 @@
+export declare function configureCommand(): Promise<void>;

package/dist/commands/deploy.d.ts

@@ -0,0 +1 @@
+export declare function deployCommand(): Promise<void>;

package/dist/commands/deploy.js

@@ -0,0 +1,720 @@
+import fs from "fs";
+import path from "path";
+export async function deployCommand() {
+    try {
+        console.log("🔨 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 version = packageJson.version || "1.0.0";
+        const skillsName = packageJson.name || "lua-skill";
+        // Read index.ts file
+        const indexPath = path.join(process.cwd(), "index.ts");
+        if (!fs.existsSync(indexPath)) {
+            throw new Error("index.ts not found in current directory");
+        }
+        const indexContent = fs.readFileSync(indexPath, "utf8");
+        // Extract skill information
+        const skillInfo = await extractSkillInfo(indexContent);
+        // Create deployment data
+        const deployData = {
+            version,
+            skillsName,
+            tools: skillInfo
+        };
+        // 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);
+        }
+        console.log(`📁 Compiled files written to: ${luaDir}`);
+        console.log(`📄 JSON output: ${jsonOutputPath}`);
+        console.log(`🔧 Tool files: ${skillInfo.map(t => `${t.name}.js`).join(', ')}`);
+        console.log("✅ Skill compilation completed successfully!");
+    }
+    catch (error) {
+        console.error("❌ Compilation failed:", error.message);
+        process.exit(1);
+    }
+}
+async function extractSkillInfo(indexContent) {
+    const tools = [];
+    // Find inline addTool calls: skill.addTool({...})
+    const inlineAddToolRegex = /skill\.addTool\(\s*\{([\s\S]*?)\}\s*\)/g;
+    let match;
+    while ((match = inlineAddToolRegex.exec(indexContent)) !== null) {
+        const toolContent = match[1];
+        // Extract tool properties
+        const nameMatch = toolContent.match(/name:\s*["']([^"']+)["']/);
+        const descriptionMatch = toolContent.match(/description:\s*["']([^"']+)["']/);
+        const inputSchemaMatch = toolContent.match(/inputSchema:\s*(\w+)/);
+        const outputSchemaMatch = toolContent.match(/outputSchema:\s*(\w+)/);
+        const executeMatch = toolContent.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
+            });
+        }
+    }
+    // Find class-based addTool calls: skill.addTool(new SomeTool())
+    const classAddToolRegex = /skill\.addTool\(\s*new\s+(\w+)\(\)\s*\)/g;
+    let classMatch;
+    while ((classMatch = classAddToolRegex.exec(indexContent)) !== null) {
+        const className = classMatch[1];
+        // Find the tool class definition
+        const toolInfo = await extractToolFromClass(className, indexContent);
+        if (toolInfo) {
+            tools.push(toolInfo);
+        }
+    }
+    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.js`);
+        const outputFile = path.join(luaDir, `${packagePath}-bundle.js`);
+        // 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) {
+    // 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
+    const toolFilePath = path.join(process.cwd(), importPath.replace('./', '') + '.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
+    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);
+    return {
+        name: toolName,
+        description: toolDescription,
+        inputSchema,
+        outputSchema,
+        execute: selfContainedExecute
+    };
+}
+async function createClassBasedExecute(executeBody, toolContent, className) {
+    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
+        if (packagePath === 'axios') {
+            bundledPackages.add(`const axios = require('axios');`);
+            continue;
+        }
+        // Handle local service imports
+        if (packagePath.startsWith('./') || packagePath.startsWith('../')) {
+            // The tool files are in tools/ subdirectory, so we need to resolve from there
+            const toolDir = path.join(process.cwd(), 'tools');
+            const serviceFilePath = path.resolve(toolDir, packagePath + '.ts');
+            if (fs.existsSync(serviceFilePath)) {
+                const serviceContent = fs.readFileSync(serviceFilePath, 'utf8');
+                // Check for axios import in service file
+                if (serviceContent.includes("import axios from \"axios\"")) {
+                    bundledPackages.add(`const axios = require('axios');`);
+                }
+                // 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}
+}`;
+}

package/dist/commands/destroy.d.ts

@@ -0,0 +1 @@
+export declare function destroyCommand(): Promise<void>;

package/dist/commands/index.d.ts

@@ -0,0 +1,7 @@
+export { configureCommand } from "./configure.js";
+export { initCommand } from "./init.js";
+export { destroyCommand } from "./destroy.js";
+export { apiKeyCommand } from "./apiKey.js";
+export { agentsCommand } from "./agents.js";
+export { deployCommand } from "./deploy.js";
+export { testCommand } from "./test.js";

package/dist/commands/index.js

@@ -3,3 +3,5 @@ export { initCommand } from "./init.js";
 export { destroyCommand } from "./destroy.js";
 export { apiKeyCommand } from "./apiKey.js";
 export { agentsCommand } from "./agents.js";
+export { deployCommand } from "./deploy.js";
+export { testCommand } from "./test.js";

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function initCommand(): Promise<void>;

package/dist/commands/init.js

@@ -66,4 +66,5 @@ export async function initCommand() {
     copyTemplateFiles(templateDir, currentDir);
     console.log("✅ Copied template files");
     console.log("🎉 Lua skill project initialized successfully!");
+    console.log("📦 Run `npm install` to install dependencies");
 }

package/dist/commands/test.d.ts

@@ -0,0 +1 @@
+export declare function testCommand(): Promise<void>;

package/dist/commands/test.js

@@ -0,0 +1,141 @@
+import fs from "fs";
+import path from "path";
+import inquirer from "inquirer";
+import { deployCommand } from "./deploy.js";
+export async function testCommand() {
+    try {
+        console.log("🧪 Testing Lua skill...");
+        // First, compile the code
+        console.log("📦 Compiling code first...");
+        await deployCommand();
+        // Check if .lua directory exists
+        const luaDir = path.join(process.cwd(), ".lua");
+        if (!fs.existsSync(luaDir)) {
+            throw new Error(".lua directory not found. Run 'lua compile' first.");
+        }
+        // Read deploy.json
+        const deployJsonPath = path.join(luaDir, "deploy.json");
+        if (!fs.existsSync(deployJsonPath)) {
+            throw new Error("deploy.json not found. Run 'lua compile' first.");
+        }
+        const deployData = JSON.parse(fs.readFileSync(deployJsonPath, "utf8"));
+        if (!deployData.tools || deployData.tools.length === 0) {
+            throw new Error("No tools found in deploy.json");
+        }
+        // Let user select a tool using picker
+        const toolChoices = deployData.tools.map((tool) => ({
+            name: `${tool.name} - ${tool.description}`,
+            value: tool
+        }));
+        const { selectedTool } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'selectedTool',
+                message: '🔧 Select a tool to test:',
+                choices: toolChoices,
+                pageSize: 10
+            }
+        ]);
+        console.log(`\n✅ Selected tool: ${selectedTool.name}`);
+        // Get input values for each required parameter using inquirer
+        const inputValues = {};
+        const inputSchema = selectedTool.inputSchema;
+        if (inputSchema.properties) {
+            console.log("\n📝 Enter input values:");
+            const inputPrompts = [];
+            for (const [key, value] of Object.entries(inputSchema.properties)) {
+                const property = value;
+                const isRequired = inputSchema.required?.includes(key) || false;
+                let promptType = 'input';
+                let validate = undefined;
+                // Set up validation and input type based on schema
+                switch (property.type) {
+                    case "string":
+                        if (isRequired) {
+                            validate = (input) => input.trim() !== "" || `${key} is required`;
+                        }
+                        break;
+                    case "number":
+                        promptType = 'number';
+                        if (isRequired) {
+                            validate = (input) => !isNaN(input) || `${key} must be a valid number`;
+                        }
+                        break;
+                    case "boolean":
+                        promptType = 'confirm';
+                        break;
+                    default:
+                        if (isRequired) {
+                            validate = (input) => input.trim() !== "" || `${key} is required`;
+                        }
+                }
+                inputPrompts.push({
+                    type: promptType,
+                    name: key,
+                    message: `${key}${isRequired ? " (required)" : " (optional)"}:`,
+                    validate: validate,
+                    when: isRequired ? true : (answers) => {
+                        // For optional fields, ask if user wants to provide a value
+                        return true;
+                    }
+                });
+            }
+            const answers = await inquirer.prompt(inputPrompts);
+            // Convert answers to proper types
+            for (const [key, value] of Object.entries(answers)) {
+                const property = inputSchema.properties[key];
+                switch (property.type) {
+                    case "string":
+                        inputValues[key] = value;
+                        break;
+                    case "number":
+                        inputValues[key] = parseFloat(value);
+                        break;
+                    case "boolean":
+                        inputValues[key] = value;
+                        break;
+                    default:
+                        inputValues[key] = value;
+                }
+            }
+        }
+        console.log("\n🚀 Executing tool...");
+        console.log(`Input: ${JSON.stringify(inputValues, null, 2)}`);
+        // Get the execute function string directly from the selected tool
+        const toolCode = selectedTool.execute;
+        // Execute the tool
+        try {
+            // Create a temporary CommonJS file to run the tool
+            const tempFile = path.join(luaDir, `temp-${selectedTool.name}.cjs`);
+            const commonJsWrapper = `
+const executeFunction = ${toolCode};
+
+// Export the function for testing
+module.exports = async (input) => {
+  return await executeFunction(input);
+};
+`;
+            fs.writeFileSync(tempFile, commonJsWrapper);
+            // Import and execute the CommonJS module
+            const { createRequire } = await import('module');
+            const require = createRequire(import.meta.url);
+            const executeFunction = require(tempFile);
+            const result = await executeFunction(inputValues);
+            // Clean up temp file
+            fs.unlinkSync(tempFile);
+            console.log("\n✅ Tool execution successful!");
+            console.log(`Output: ${JSON.stringify(result, null, 2)}`);
+        }
+        catch (executionError) {
+            console.error("\n❌ Tool execution failed:");
+            console.error(executionError.message);
+            if (executionError.stack) {
+                console.error(executionError.stack);
+            }
+        }
+    }
+    catch (error) {
+        console.error("❌ Test failed:", error.message);
+        process.exit(1);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { Command } from "commander";
-import { configureCommand, initCommand, destroyCommand, apiKeyCommand, agentsCommand } from "./commands/index.js";
+import { configureCommand, initCommand, destroyCommand, apiKeyCommand, agentsCommand, deployCommand, testCommand } from "./commands/index.js";
 const program = new Command();
 program
     .command("init")
@@ -22,4 +22,12 @@ program
     .command("agents")
     .description("Fetch agents from HeyLua API")
     .action(agentsCommand);
+program
+    .command("compile")
+    .description("Compile Lua skill to generate deployable format")
+    .action(deployCommand);
+program
+    .command("test")
+    .description("Test Lua skill tools interactively")
+    .action(testCommand);
 program.parse(process.argv);

package/dist/services/auth.d.ts

@@ -0,0 +1,8 @@
+import { UserData } from "../types/index.js";
+export declare function saveApiKey(apiKey: string): Promise<void>;
+export declare function loadApiKey(): Promise<string | null>;
+export declare function deleteApiKey(): Promise<boolean>;
+export declare function checkApiKey(apiKey: string): Promise<UserData>;
+export declare function requestEmailOTP(email: string): Promise<boolean>;
+export declare function verifyOTPAndGetToken(email: string, pin: string): Promise<string | null>;
+export declare function generateApiKey(signInToken: string): Promise<string | null>;

package/dist/skill.d.ts

@@ -0,0 +1,10 @@
+import { ZodType } from "zod";
+import { LuaTool } from "./types/index.js";
+export { LuaTool };
+export declare class LuaSkill {
+    private readonly apiKey;
+    private readonly tools;
+    constructor(apiKey: string);
+    addTool<TInput extends ZodType, TOutput extends ZodType>(tool: LuaTool<TInput, TOutput>): void;
+    run(input: Record<string, any>): Promise<any>;
+}

package/dist/skill.js

@@ -0,0 +1,18 @@
+export class LuaSkill {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+        this.tools = [];
+    }
+    addTool(tool) {
+        this.tools.push(tool);
+    }
+    async run(input) {
+        const tool = this.tools.find(tool => tool.name === input.tool);
+        if (!tool) {
+            throw new Error(`Tool ${input.tool} not found`);
+        }
+        // Validate input against the tool's schema
+        const validatedInput = tool.inputSchema.parse(input);
+        return tool.execute(validatedInput);
+    }
+}

package/dist/types/index.d.ts

@@ -0,0 +1,69 @@
+export interface UserData {
+    uid: string;
+    email: string;
+    emailVerified: boolean;
+    fullName: string;
+    mobileNumbers: any[];
+    emailAddresses: EmailAddress[];
+    country: Country;
+    admin: Admin;
+    channels: Record<string, any>;
+    rights: Record<string, any>;
+    setupPersona: Record<string, any>;
+    notifications: Record<string, any>;
+}
+export interface EmailAddress {
+    address: string;
+    validated: boolean;
+    validatedAt: number;
+    _id: string;
+}
+export interface Country {
+    code: string;
+    name: string;
+}
+export interface Admin {
+    userId: string;
+    orgs: Organization[];
+    id: string;
+    createdAt: number;
+    __v: number;
+}
+export interface Organization {
+    id: string;
+    rights?: string[];
+    agents: Agent[];
+    registeredName: string;
+    country: string;
+    phoneNumber?: string | null;
+    type: string;
+}
+export interface Agent {
+    agentId: string;
+    rights: string[];
+    name: string;
+}
+export interface OTPResponse {
+    signInToken: string;
+}
+export interface ApiKeyResponse {
+    message: string;
+    userId: string;
+    apiKey: string;
+    apiId: string;
+}
+import { ZodType } from "zod";
+export interface LuaTool<TInput extends ZodType = ZodType, TOutput extends ZodType = ZodType> {
+    name: string;
+    description: string;
+    inputSchema: TInput;
+    outputSchema: TOutput;
+    execute: (input: any) => Promise<any>;
+}
+export declare class LuaSkill {
+    private readonly apiKey;
+    private readonly tools;
+    constructor(apiKey: string);
+    addTool<TInput extends ZodType, TOutput extends ZodType>(tool: LuaTool<TInput, TOutput>): void;
+    run(input: Record<string, any>): Promise<any>;
+}

package/dist/types.d.ts

@@ -0,0 +1 @@
+export * from "./types/index.js";

package/dist/types.js

@@ -0,0 +1,2 @@
+// Re-export types for external use
+export * from "./types/index.js";

package/dist/utils/files.d.ts

@@ -0,0 +1,2 @@
+export declare function copyTemplateFiles(templateDir: string, targetDir: string): void;
+export declare function createSkillToml(agentId: string, orgId: string, skillName: string, skillDescription: string): void;

package/dist/utils/files.js

@@ -1,19 +1,44 @@
 import fs from "fs";
 import path from "path";
+import { fileURLToPath } from "url";
 export function copyTemplateFiles(templateDir, targetDir) {
     const files = fs.readdirSync(templateDir);
     for (const file of files) {
+        // Skip node_modules and package-lock.json to avoid circular dependencies
+        if (file === 'node_modules' || file === 'package-lock.json') {
+            continue;
+        }
         const srcPath = path.join(templateDir, file);
         const destPath = path.join(targetDir, file);
         if (fs.statSync(srcPath).isDirectory()) {
             fs.mkdirSync(destPath, { recursive: true });
             copyTemplateFiles(srcPath, destPath);
         }
+        else if (file === 'package.json') {
+            // Special handling for package.json to update lua-cli version
+            updatePackageJson(srcPath, destPath);
+        }
         else {
             fs.copyFileSync(srcPath, destPath);
         }
     }
 }
+function updatePackageJson(srcPath, destPath) {
+    // Read the template package.json
+    const templatePackageJson = JSON.parse(fs.readFileSync(srcPath, 'utf8'));
+    // Get the current CLI version from the main package.json
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const mainPackageJsonPath = path.join(__dirname, '..', '..', 'package.json');
+    const mainPackageJson = JSON.parse(fs.readFileSync(mainPackageJsonPath, 'utf8'));
+    const currentCliVersion = mainPackageJson.version;
+    // Update the lua-cli dependency version
+    if (templatePackageJson.dependencies && templatePackageJson.dependencies['lua-cli']) {
+        templatePackageJson.dependencies['lua-cli'] = `^${currentCliVersion}`;
+    }
+    // Write the updated package.json
+    fs.writeFileSync(destPath, JSON.stringify(templatePackageJson, null, 2) + '\n');
+}
 export function createSkillToml(agentId, orgId, skillName, skillDescription) {
     const tomlContent = `[agent]
 agentId = "${agentId}"

package/package.json

@@ -1,13 +1,21 @@
 {
   "name": "lua-cli",
-  "version": "1.1.2",
+  "version": "1.1.4-beta.0",
   "description": "Command-line interface for Lua AI platform - manage agents, organizations, and skills",
   "readmeFilename": "README.md",
   "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./types": "./dist/types.js",
+    "./skill": "./dist/skill.js"
+  },
   "scripts": {
-    "build": "tsc",
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc",
     "prepublishOnly": "npm run build",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
   },
   "keywords": [
     "lua",
@@ -36,7 +44,6 @@
   },
   "files": [
     "dist/**/*",
-    "template/**/*",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"
@@ -45,16 +52,21 @@
     "commander": "^14.0.1",
     "inquirer": "^12.9.6",
     "keytar": "^7.9.0",
-    "node-fetch": "^3.3.2"
+    "node-fetch": "^3.3.2",
+    "zod": "^4.1.9"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.9",
+    "@types/jest": "^29.5.8",
     "@types/node": "^24.5.1",
     "@types/node-fetch": "^2.6.13",
+    "esbuild": "^0.25.10",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.2"
   },
   "bin": {
     "lua": "dist/index.js"
   }
-}
+}

package/template/package.json

@@ -1,12 +0,0 @@
-{
-  "name": "lua-skill",
-  "version": "1.0.0",
-  "description": "",
-  "license": "ISC",
-  "author": "",
-  "type": "commonjs",
-  "main": "index.ts",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  }
-}