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

package/dist/commands/compile.js

@@ -17,6 +17,11 @@ function decompressCode(compressedCode) {
 export async function compileCommand() {
     return withErrorHandling(async () => {
         writeProgress("🔨 Compiling Lua skill...");
+        // Clean up old .lua directory
+        const oldLuaDir = path.join(process.cwd(), ".lua");
+        if (fs.existsSync(oldLuaDir)) {
+            fs.rmSync(oldLuaDir, { recursive: true, force: true });
+        }
         // Read package.json to get version and name
         const packageJsonPath = path.join(process.cwd(), "package.json");
         if (!fs.existsSync(packageJsonPath)) {
@@ -79,21 +84,31 @@ async function extractSkillInfo(indexContent, indexFilePath) {
         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
+            // Check for skill.addTool() and skill.addTools() calls
             if (ts.isCallExpression(node) &&
                 ts.isPropertyAccessExpression(node.expression) &&
                 ts.isIdentifier(node.expression.expression) &&
                 node.expression.expression.text === 'skill' &&
                 ts.isIdentifier(node.expression.name) &&
-                node.expression.name.text === 'addTool') {
+                (node.expression.name.text === 'addTool' || node.expression.name.text === 'addTools')) {
                 // 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);
+                // Handle both addTool and addTools calls
+                if (node.expression.name.text === 'addTool') {
+                    // Single tool call
+                    if (node.arguments.length > 0) {
+                        toolArguments.push(node.arguments[0]);
+                    }
+                }
+                else if (node.expression.name.text === 'addTools') {
+                    // Multiple tools call - add each tool from the array
+                    if (node.arguments.length > 0 && ts.isArrayLiteralExpression(node.arguments[0])) {
+                        for (const element of node.arguments[0].elements) {
+                            toolArguments.push(element);
+                        }
+                    }
                 }
             }
             // Continue traversing
@@ -106,9 +121,8 @@ async function extractSkillInfo(indexContent, indexFilePath) {
         }
     }
     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);
+        console.warn('Warning: Could not parse TypeScript AST:', error);
+        return [];
     }
     return tools;
 }
@@ -152,9 +166,6 @@ async function processInlineTool(objectNode, sourceFile, indexContent, tools) {
             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)) {
@@ -168,16 +179,14 @@ async function processInlineTool(objectNode, sourceFile, indexContent, tools) {
     if (toolProperties.name &&
         toolProperties.description &&
         toolProperties.inputSchemaVar &&
-        toolProperties.outputSchemaVar &&
         toolProperties.executeBody) {
-        const inputSchema = convertSchemaToJSON(toolProperties.inputSchemaVar, indexContent);
-        const outputSchema = convertSchemaToJSON(toolProperties.outputSchemaVar, indexContent);
+        // For inline tools, we need to find the schema definitions in the index file
+        const inputSchema = extractSchemaFromIndex(toolProperties.inputSchemaVar, indexContent);
         const selfContainedExecute = await createSelfContainedExecute(toolProperties.executeBody, indexContent);
         tools.push({
             name: toolProperties.name,
             description: toolProperties.description,
-            inputSchema,
-            outputSchema,
+            inputSchema: inputSchema || { type: "object" },
             execute: selfContainedExecute
         });
     }
@@ -203,142 +212,149 @@ function extractFunctionBody(blockStatement, sourceFile) {
     }
     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);
+function convertZodTypeToJSONSchema(zodType) {
+    switch (zodType) {
+        case 'string':
+            return { type: 'string' };
+        case 'number':
+            return { type: 'number' };
+        case 'boolean':
+            return { type: 'boolean' };
+        default:
+            return { type: 'string' };
+    }
+}
+function extractZodSchemaFromAST(node) {
+    // Handle z.object({...}) calls
+    if (ts.isCallExpression(node) &&
+        ts.isPropertyAccessExpression(node.expression) &&
+        ts.isIdentifier(node.expression.expression) &&
+        node.expression.expression.text === 'z' &&
+        ts.isIdentifier(node.expression.name) &&
+        node.expression.name.text === 'object') {
+        const objectLiteral = node.arguments[0];
+        if (ts.isObjectLiteralExpression(objectLiteral)) {
+            const properties = {};
+            const required = [];
+            for (const property of objectLiteral.properties) {
+                if (ts.isPropertyAssignment(property) &&
+                    ts.isIdentifier(property.name) &&
+                    property.initializer) {
+                    const propertyName = property.name.text;
+                    const zodType = extractZodTypeFromAST(property.initializer);
+                    properties[propertyName] = zodType;
+                    // Only add to required if it's not optional
+                    if (!isOptionalZodType(property.initializer)) {
+                        required.push(propertyName);
+                    }
                 }
             }
+            return {
+                type: "object",
+                properties,
+                required
+            };
         }
-        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: {} };
+    return { type: "object" };
 }
-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) {
+function extractZodTypeFromAST(node) {
+    // Handle z.string(), z.number(), z.boolean(), etc.
+    if (ts.isCallExpression(node) &&
+        ts.isPropertyAccessExpression(node.expression) &&
+        ts.isIdentifier(node.expression.expression) &&
+        node.expression.expression.text === 'z') {
+        const zodType = node.expression.name.text;
+        switch (zodType) {
             case 'string':
-                properties[fieldName] = { type: 'string' };
-                break;
+                return { type: 'string' };
             case 'number':
-                properties[fieldName] = { type: 'number' };
-                break;
+                return { type: 'number' };
             case 'boolean':
-                properties[fieldName] = { type: 'boolean' };
-                break;
+                return { type: 'boolean' };
+            case 'array':
+                // Handle z.array(z.string()) etc.
+                if (node.arguments.length > 0) {
+                    const elementType = extractZodTypeFromAST(node.arguments[0]);
+                    return { type: 'array', items: elementType };
+                }
+                return { type: 'array' };
+            case 'object':
+                // Handle nested z.object({...}) calls
+                if (node.arguments.length > 0) {
+                    return extractZodSchemaFromAST(node);
+                }
+                return { type: 'object' };
+            case 'enum':
+                // Handle z.enum(['a', 'b', 'c'])
+                if (node.arguments.length > 0 && ts.isArrayLiteralExpression(node.arguments[0])) {
+                    const enumValues = [];
+                    for (const element of node.arguments[0].elements) {
+                        if (ts.isStringLiteral(element)) {
+                            enumValues.push(element.text);
+                        }
+                    }
+                    return { type: 'string', enum: enumValues };
+                }
+                return { type: 'string' };
             default:
-                properties[fieldName] = { type: 'string' };
+                return { type: 'string' };
+        }
+    }
+    // Handle method chaining like z.string().optional()
+    if (ts.isCallExpression(node) &&
+        ts.isPropertyAccessExpression(node.expression) &&
+        ts.isCallExpression(node.expression.expression)) {
+        const baseType = extractZodTypeFromAST(node.expression.expression);
+        const method = node.expression.name.text;
+        if (method === 'optional') {
+            // Optional fields are handled by not including them in required array
+            return baseType;
         }
+        return baseType;
     }
-    return properties;
+    return { type: 'string' };
 }
-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;
+function isOptionalZodType(node) {
+    // Check if this is a chained call ending with .optional()
+    if (ts.isCallExpression(node) &&
+        ts.isPropertyAccessExpression(node.expression) &&
+        ts.isIdentifier(node.expression.name) &&
+        node.expression.name.text === 'optional') {
+        return true;
+    }
+    return false;
+}
+function extractSchemaFromIndex(schemaVar, indexContent) {
+    // Create a source file from the index content to parse schemas using AST
+    const sourceFile = ts.createSourceFile('index.ts', indexContent, ts.ScriptTarget.Latest, true);
+    let schema = null;
+    function findSchema(node) {
+        // Look for const schemaVar = z.object({...}) declarations
+        if (ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            node.name.text === schemaVar &&
+            node.initializer) {
+            schema = extractZodSchemaFromAST(node.initializer);
+            return;
+        }
+        ts.forEachChild(node, findSchema);
+    }
+    findSchema(sourceFile);
+    return schema;
+}
+function extractEnvironmentVariables() {
+    const config = readSkillConfig();
+    const envVars = [];
+    if (config?.skill?.env) {
+        for (const [key, value] of Object.entries(config.skill.env)) {
+            envVars.push({
+                name: key,
+                value: value
+            });
+        }
+    }
+    return envVars;
 }
 async function createSelfContainedExecute(executeBody, indexContent) {
     const dependencies = [];
@@ -741,14 +757,34 @@ const axios = {
 `;
 }
 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) {
+    // Find the import statement for this class using AST
+    const sourceFile = ts.createSourceFile(indexFilePath, indexContent, ts.ScriptTarget.Latest, true);
+    let importPath = null;
+    function findImport(node) {
+        if (ts.isImportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+            const moduleSpecifier = node.moduleSpecifier;
+            // Check if this import has the class we're looking for
+            if (node.importClause && node.importClause.name && node.importClause.name.text === className) {
+                importPath = moduleSpecifier.text;
+                return;
+            }
+            // Check named imports
+            if (node.importClause && node.importClause.namedBindings && ts.isNamedImports(node.importClause.namedBindings)) {
+                for (const element of node.importClause.namedBindings.elements) {
+                    if (element.name.text === className) {
+                        importPath = moduleSpecifier.text;
+                        return;
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, findImport);
+    }
+    findImport(sourceFile);
+    if (!importPath) {
         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('../')) {
@@ -765,32 +801,59 @@ async function extractToolFromClass(className, indexContent, indexFilePath) {
         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) {
+    const toolSourceFile = ts.createSourceFile(toolFilePath, toolContent, ts.ScriptTarget.Latest, true);
+    // Extract tool properties using AST
+    let toolName = null;
+    let toolDescription = null;
+    let inputSchema = null;
+    let executeMethod = null;
+    function extractToolInfo(node) {
+        // Look for class declaration
+        if (ts.isClassDeclaration(node) && node.name && node.name.text === className) {
+            // Extract class members
+            for (const member of node.members) {
+                if (ts.isPropertyDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
+                    const propertyName = member.name.text;
+                    // Extract name property
+                    if (propertyName === 'name' && member.initializer && ts.isStringLiteral(member.initializer)) {
+                        toolName = member.initializer.text;
+                    }
+                    // Extract description property
+                    if (propertyName === 'description' && member.initializer && ts.isStringLiteral(member.initializer)) {
+                        toolDescription = member.initializer.text;
+                    }
+                    // Extract inputSchema property
+                    if (propertyName === 'inputSchema' && member.initializer) {
+                        inputSchema = extractZodSchemaFromAST(member.initializer);
+                    }
+                }
+                // Extract execute method
+                if (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name) && member.name.text === 'execute') {
+                    executeMethod = member;
+                }
+            }
+        }
+        ts.forEachChild(node, extractToolInfo);
+    }
+    extractToolInfo(toolSourceFile);
+    if (!toolName || !toolDescription) {
         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) {
+    if (!inputSchema) {
         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) {
+    if (!executeMethod) {
         console.warn(`Warning: Could not find execute method in ${className}`);
         return null;
     }
-    const executeBody = executeMatch[1];
+    // Extract execute method body
+    if (!executeMethod.body) {
+        console.warn(`Warning: Execute method has no body in ${className}`);
+        return null;
+    }
+    const executeBody = extractFunctionBody(executeMethod.body, toolSourceFile);
     // For class-based tools, we need to create a self-contained function that includes:
     // 1. The service classes
     // 2. Class instantiation
@@ -799,8 +862,7 @@ async function extractToolFromClass(className, indexContent, indexFilePath) {
     return {
         name: toolName,
         description: toolDescription,
-        inputSchema,
-        outputSchema,
+        inputSchema: inputSchema || { type: "object" },
         execute: selfContainedExecute
     };
 }