lua-cli 1.1.3 → 1.1.4-beta.0

package/dist/commands/deploy.js

@@ -50,10 +50,10 @@ export async function deployCommand() {
 }
 async function extractSkillInfo(indexContent) {
     const tools = [];
-    // Find all addTool calls
-    const addToolRegex = /skill\.addTool\(\s*\{([\s\S]*?)\}\s*\)/g;
+    // Find inline addTool calls: skill.addTool({...})
+    const inlineAddToolRegex = /skill\.addTool\(\s*\{([\s\S]*?)\}\s*\)/g;
     let match;
-    while ((match = addToolRegex.exec(indexContent)) !== null) {
+    while ((match = inlineAddToolRegex.exec(indexContent)) !== null) {
         const toolContent = match[1];
         // Extract tool properties
         const nameMatch = toolContent.match(/name:\s*["']([^"']+)["']/);
@@ -81,6 +81,17 @@ async function extractSkillInfo(indexContent) {
             });
         }
     }
+    // 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) {
@@ -532,3 +543,178 @@ const axios = {
 };
 `;
 }
+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/skill.d.ts

@@ -1,5 +1,6 @@
 import { ZodType } from "zod";
 import { LuaTool } from "./types/index.js";
+export { LuaTool };
 export declare class LuaSkill {
     private readonly apiKey;
     private readonly tools;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lua-cli",
-  "version": "1.1.3",
+  "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",