lua-cli 1.3.0-alpha.1 → 1.3.0

package/dist/commands/compile.js

@@ -3,6 +3,8 @@ 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);
@@ -22,23 +24,29 @@ export async function compileCommand() {
         }
         const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
         const packageVersion = packageJson.version || "1.0.0";
-        const skillsName = packageJson.name || "lua-skill";
-        // Read index.ts file
-        const indexPath = path.join(process.cwd(), "index.ts");
+        // 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)) {
-            throw new Error("index.ts not found in current directory");
+            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);
-        // Extract skill metadata from LuaSkill constructor and TOML file
+        const skillInfo = await extractSkillInfo(indexContent, indexPath);
+        // Extract skill metadata from LuaSkill constructor and config file
         const skillMetadata = await extractSkillMetadata(indexContent);
-        // Use version from TOML file, fallback to package.json version
+        // 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,
-            skillsName,
+            name: skillName,
+            skillsName: skillName,
             skillId: skillMetadata.skillId,
             description: skillMetadata.description,
             context: skillMetadata.context,
@@ -63,50 +71,224 @@ export async function compileCommand() {
         writeSuccess("✅ Skill compiled successfully");
     }, "compilation");
 }
-async function extractSkillInfo(indexContent) {
+async function extractSkillInfo(indexContent, indexFilePath) {
     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);
+    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) {
@@ -558,7 +740,7 @@ const axios = {
 };
 `;
 }
-async function extractToolFromClass(className, indexContent) {
+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);
@@ -567,8 +749,17 @@ async function extractToolFromClass(className, indexContent) {
         return null;
     }
     const importPath = importMatch[1];
-    // Read the tool file
-    const toolFilePath = path.join(process.cwd(), importPath.replace('./', '') + '.ts');
+    // 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;
@@ -583,7 +774,7 @@ async function extractToolFromClass(className, indexContent) {
     }
     const toolName = nameMatch[1];
     const toolDescription = descriptionMatch[1];
-    // Extract schemas
+    // 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) {
@@ -604,7 +795,7 @@ async function extractToolFromClass(className, indexContent) {
     // 1. The service classes
     // 2. Class instantiation
     // 3. The execute logic
-    const selfContainedExecute = await createClassBasedExecute(executeBody, toolContent, className);
+    const selfContainedExecute = await createClassBasedExecute(executeBody, toolContent, className, toolFilePath);
     return {
         name: toolName,
         description: toolDescription,
@@ -613,7 +804,7 @@ async function extractToolFromClass(className, indexContent) {
         execute: selfContainedExecute
     };
 }
-async function createClassBasedExecute(executeBody, toolContent, className) {
+async function createClassBasedExecute(executeBody, toolContent, className, toolFilePath) {
     const dependencies = [];
     const bundledPackages = new Set();
     // 1. Parse imports from the tool file
@@ -654,11 +845,9 @@ async function createClassBasedExecute(executeBody, toolContent, className) {
         }
         // 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');
-            // Resolve the service file path correctly
-            // If the import is ../services/ApiService, resolve it relative to the tools directory
-            const serviceFilePath = path.resolve(process.cwd(), 'tools', packagePath + '.ts');
+            // 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
@@ -779,20 +968,13 @@ ${dependencyCode ? dependencyCode + '\n' : ''}${finalExecuteBody}
 }`;
 }
 async function extractSkillMetadata(indexContent) {
-    // Extract skillId and version from TOML file
+    // Extract skillId and version from config file
     let skillId = '';
     let version = '';
-    const tomlPath = path.join(process.cwd(), 'lua.skill.toml');
-    if (fs.existsSync(tomlPath)) {
-        const tomlContent = fs.readFileSync(tomlPath, 'utf8');
-        const skillIdMatch = tomlContent.match(/skillId\s*=\s*["']([^"']+)["']/);
-        if (skillIdMatch) {
-            skillId = skillIdMatch[1];
-        }
-        const versionMatch = tomlContent.match(/version\s*=\s*["']([^"']+)["']/);
-        if (versionMatch) {
-            version = versionMatch[1];
-        }
+    const config = readSkillConfig();
+    if (config) {
+        skillId = config.skill?.skillId || '';
+        version = config.skill?.version || '';
     }
     // Extract description and context from LuaSkill constructor
     let description = '';

package/dist/commands/deploy-new.d.ts

@@ -1,20 +0,0 @@
-export interface VersionInfo {
-    version: string;
-    createdDate: string;
-    createdBy: string;
-    isCurrent: boolean;
-    createdByEmail: string;
-    createdByFullName: string;
-}
-export interface VersionsResponse {
-    versions: VersionInfo[];
-}
-export interface PublishResponse {
-    message: string;
-    skillId: string;
-    activeVersionId: string;
-    publishedAt: string;
-}
-export declare function fetchVersions(apiKey: string, agentId: string, skillId: string): Promise<VersionsResponse>;
-export declare function publishVersion(apiKey: string, agentId: string, skillId: string, version: string): Promise<PublishResponse>;
-export declare function deployCommand(): Promise<void>;