lua-cli 2.2.8-alpha.1 → 2.3.0-alpha.1

package/dist/utils/compile.js

@@ -0,0 +1,242 @@
+/**
+ * Utility functions for compile command
+ */
+import fs from "fs";
+import path from "path";
+import { gzipSync } from "zlib";
+import { Node } from "ts-morph";
+/**
+ * Compresses code using gzip and returns base64 encoded string
+ */
+export function compressCode(code) {
+    const compressed = gzipSync(code);
+    return compressed.toString('base64');
+}
+/**
+ * Finds the index.ts file in the project
+ */
+export function findIndexFile() {
+    // Check for index.ts in current directory
+    let indexPath = path.join(process.cwd(), "index.ts");
+    if (fs.existsSync(indexPath)) {
+        return indexPath;
+    }
+    // Check for index.ts in src directory
+    indexPath = path.join(process.cwd(), "src", "index.ts");
+    if (fs.existsSync(indexPath)) {
+        return indexPath;
+    }
+    throw new Error("index.ts not found in current directory or src/ directory");
+}
+/**
+ * Resolves import path from module specifier
+ */
+export function resolveImportPath(moduleSpecifier, currentFilePath) {
+    if (moduleSpecifier.startsWith('./') || moduleSpecifier.startsWith('../')) {
+        // Relative import - resolve relative to current file
+        const currentDir = path.dirname(currentFilePath);
+        return path.resolve(currentDir, moduleSpecifier + '.ts');
+    }
+    else {
+        // Absolute import - assume it's in the project
+        return path.resolve(process.cwd(), 'src', moduleSpecifier + '.ts');
+    }
+}
+/**
+ * Creates execute function wrapper from bundled code
+ */
+export function createExecuteFunction(bundledCode, tool) {
+    // The bundled code is already wrapped for VM execution by wrapToolForVM
+    // Just return it directly since it's already an async function
+    return bundledCode;
+}
+/**
+ * Evaluates Zod schema code and converts it to JSON Schema
+ */
+export async function evaluateZodSchemaToJsonSchema(zodSchemaCode) {
+    try {
+        // Import zod and zod-to-json-schema dynamically
+        const { z } = await import('zod');
+        const { zodToJsonSchema } = await import('zod-to-json-schema');
+        // Create a safe evaluation context using Function constructor
+        const evalFunction = new Function('z', `return ${zodSchemaCode}`);
+        const zodSchema = evalFunction(z);
+        // Convert to JSON Schema using the library
+        const jsonSchema = zodToJsonSchema(zodSchema, 'schema');
+        // Extract just the core schema, removing JSON Schema references and definitions
+        if (jsonSchema.$ref && jsonSchema.definitions && jsonSchema.definitions.schema) {
+            // Return just the schema definition without the wrapper
+            return jsonSchema.definitions.schema;
+        }
+        // Remove the top-level $schema and title properties that we don't need
+        const { $schema, title, definitions, $ref, ...cleanSchema } = jsonSchema;
+        return cleanSchema;
+    }
+    catch (error) {
+        console.warn('Warning: Could not evaluate Zod schema, falling back to basic parsing:', error);
+        // Fallback to basic parsing for simple cases
+        if (zodSchemaCode.includes('z.object({')) {
+            return { type: 'object' };
+        }
+        if (zodSchemaCode.includes('z.string()'))
+            return { type: 'string' };
+        if (zodSchemaCode.includes('z.number()'))
+            return { type: 'number' };
+        if (zodSchemaCode.includes('z.boolean()'))
+            return { type: 'boolean' };
+        return { type: 'object' };
+    }
+}
+/**
+ * Wraps bundled tool code for VM execution
+ */
+export async function wrapToolForVM(outputPath, tool) {
+    const bundledCode = fs.readFileSync(outputPath, 'utf8');
+    // Create a wrapper that's compatible with the existing sandbox.ts VM system
+    // The sandbox expects: const executeFunction = ${toolCode}; module.exports = async (input) => { return await executeFunction(input); };
+    const wrappedCode = `async (input) => {
+  
+  // Execute the bundled tool code
+  ${bundledCode}
+  
+  // Get the tool class from exports
+  const ToolClass = module.exports.default || module.exports.${tool.className} || module.exports;
+  
+  // Create and execute the tool
+  const toolInstance = new ToolClass();
+  return await toolInstance.execute(input);
+}`;
+    fs.writeFileSync(outputPath, wrappedCode);
+}
+/**
+ * Extracts tool information from a new expression in the AST
+ */
+export function extractToolFromNewExpressionSync(newExpr, project) {
+    try {
+        const expression = newExpr.getExpression();
+        const className = expression.getText();
+        // Find the import declaration for this class
+        const sourceFile = newExpr.getSourceFile();
+        const imports = sourceFile.getImportDeclarations();
+        for (const importDecl of imports) {
+            const namedImports = importDecl.getNamedImports();
+            const defaultImport = importDecl.getDefaultImport();
+            let toolFilePath = null;
+            // Check named imports
+            for (const namedImport of namedImports) {
+                if (namedImport.getName() === className) {
+                    toolFilePath = resolveImportPath(importDecl.getModuleSpecifierValue(), sourceFile.getFilePath());
+                    break;
+                }
+            }
+            // Check default import
+            if (!toolFilePath && defaultImport && defaultImport.getText() === className) {
+                toolFilePath = resolveImportPath(importDecl.getModuleSpecifierValue(), sourceFile.getFilePath());
+            }
+            if (toolFilePath && fs.existsSync(toolFilePath)) {
+                // Extract tool metadata from the class file
+                try {
+                    const toolSourceFile = project.addSourceFileAtPath(toolFilePath);
+                    const classDecl = toolSourceFile.getClass(className);
+                    if (classDecl) {
+                        const nameProperty = classDecl.getProperty('name');
+                        const descProperty = classDecl.getProperty('description');
+                        let toolName = className.replace(/Tool$/, '').toLowerCase();
+                        let description = '';
+                        // Extract name from property if available
+                        if (nameProperty && nameProperty.getInitializer()) {
+                            const nameValue = nameProperty.getInitializer()?.getText();
+                            if (nameValue) {
+                                toolName = nameValue.replace(/['"]/g, '');
+                            }
+                        }
+                        // Extract description from property if available
+                        if (descProperty && descProperty.getInitializer()) {
+                            const descValue = descProperty.getInitializer()?.getText();
+                            if (descValue) {
+                                description = descValue.replace(/['"]/g, '');
+                            }
+                        }
+                        const toolInfo = {
+                            name: toolName,
+                            className,
+                            filePath: toolFilePath,
+                            description
+                        };
+                        return toolInfo;
+                    }
+                }
+                catch (fileError) {
+                    console.warn(`Warning: Could not load tool file ${toolFilePath}:`, fileError);
+                }
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        console.warn(`Warning: Could not extract tool info for ${newExpr.getText()}:`, error);
+        return null;
+    }
+}
+/**
+ * Extracts skills metadata from index file
+ */
+export function extractSkillsMetadata(indexFile) {
+    const skills = [];
+    // Find all LuaSkill constructor calls
+    indexFile.forEachDescendant((node) => {
+        if (Node.isNewExpression(node)) {
+            const expression = node.getExpression();
+            if (expression.getText() === 'LuaSkill') {
+                const args = node.getArguments();
+                if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
+                    const configObj = args[0];
+                    let skillName = '';
+                    let skillVersion = '';
+                    let description = '';
+                    let context = '';
+                    let constructorTools = [];
+                    // Extract properties
+                    configObj.getProperties().forEach((prop) => {
+                        if (Node.isPropertyAssignment(prop)) {
+                            const name = prop.getName();
+                            const value = prop.getInitializer();
+                            if (name === 'name' && value) {
+                                skillName = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (name === 'version' && value) {
+                                skillVersion = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (name === 'description' && value) {
+                                description = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (name === 'context' && value) {
+                                context = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (name === 'tools' && value && Node.isArrayLiteralExpression(value)) {
+                                // Extract tools from constructor array
+                                const toolsArray = value;
+                                constructorTools = toolsArray.getElements().map((element) => {
+                                    if (Node.isNewExpression(element)) {
+                                        return element.getExpression().getText();
+                                    }
+                                    return '';
+                                }).filter(name => name);
+                            }
+                        }
+                    });
+                    if (skillName) {
+                        skills.push({
+                            name: skillName,
+                            version: skillVersion || '1.0.0',
+                            description,
+                            context,
+                            constructorTools
+                        });
+                    }
+                }
+            }
+        }
+    });
+    return skills;
+}

package/dist/utils/deploy-api.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Deploy API Utilities
+ * Handles API calls for deployment operations
+ */
+import { VersionsResponse, PublishResponse } from '../interfaces/deploy.js';
+/**
+ * Fetches available versions for a skill.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @returns Versions response containing array of versions
+ * @throws Error if API call fails
+ */
+export declare function fetchVersions(apiKey: string, agentId: string, skillId: string): Promise<VersionsResponse>;
+/**
+ * Publishes a specific version to production.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param version - Version to publish
+ * @returns Publish response with deployment details
+ * @throws Error if API call fails
+ */
+export declare function publishVersion(apiKey: string, agentId: string, skillId: string, version: string): Promise<PublishResponse>;

package/dist/utils/deploy-api.js

@@ -0,0 +1,53 @@
+/**
+ * Deploy API Utilities
+ * Handles API calls for deployment operations
+ */
+import SkillApi from '../api/skills.api.service.js';
+import { BASE_URLS } from '../config/constants.js';
+/**
+ * Fetches available versions for a skill.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @returns Versions response containing array of versions
+ * @throws Error if API call fails
+ */
+export async function fetchVersions(apiKey, agentId, skillId) {
+    try {
+        const skillApi = new SkillApi(BASE_URLS.API, apiKey, agentId);
+        const response = await skillApi.getSkillVersions(skillId);
+        if (!response.success) {
+            throw new Error(`Failed to fetch versions: ${response.error?.message || 'Unknown error'}`);
+        }
+        return response.data;
+    }
+    catch (error) {
+        console.error("❌ Error fetching versions:", error);
+        throw error;
+    }
+}
+/**
+ * Publishes a specific version to production.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param version - Version to publish
+ * @returns Publish response with deployment details
+ * @throws Error if API call fails
+ */
+export async function publishVersion(apiKey, agentId, skillId, version) {
+    try {
+        const skillApi = new SkillApi(BASE_URLS.API, apiKey, agentId);
+        const response = await skillApi.publishSkillVersion(skillId, version);
+        if (!response.success) {
+            throw new Error(`Failed to publish version: ${response.error?.message || 'Unknown error'}`);
+        }
+        return response.data;
+    }
+    catch (error) {
+        console.error("❌ Error publishing version:", error);
+        throw error;
+    }
+}

package/dist/utils/deploy-helpers.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Deploy Helper Utilities
+ * Helper functions for deployment operations
+ */
+import { VersionInfo } from '../interfaces/deploy.js';
+/**
+ * Formats a version for display in the selection list.
+ *
+ * @param version - Version information to format
+ * @returns Formatted string for display
+ */
+export declare function formatVersionChoice(version: VersionInfo): string;
+/**
+ * Sorts versions by creation date (newest first).
+ *
+ * @param versions - Array of versions to sort
+ * @returns Sorted array of versions
+ */
+export declare function sortVersionsByDate(versions: VersionInfo[]): VersionInfo[];
+/**
+ * Prompts user to select a version from available versions.
+ *
+ * @param versions - Array of available versions
+ * @returns Selected version string
+ */
+export declare function promptVersionSelection(versions: VersionInfo[]): Promise<string>;
+/**
+ * Prompts user to confirm deployment with warning.
+ *
+ * @returns True if confirmed, false otherwise
+ */
+export declare function confirmDeployment(): Promise<boolean>;
+/**
+ * Validates that configuration has required fields for deployment.
+ *
+ * @param config - Skill configuration
+ * @throws Error if configuration is invalid
+ */
+export declare function validateDeployConfig(config: any): void;
+/**
+ * Validates that versions are available for deployment.
+ *
+ * @param versions - Array of versions
+ * @throws Error if no versions are available
+ */
+export declare function validateVersionsAvailable(versions: VersionInfo[] | undefined): void;

package/dist/utils/deploy-helpers.js

@@ -0,0 +1,86 @@
+/**
+ * Deploy Helper Utilities
+ * Helper functions for deployment operations
+ */
+import inquirer from 'inquirer';
+import { clearPromptLines } from './cli.js';
+/**
+ * Formats a version for display in the selection list.
+ *
+ * @param version - Version information to format
+ * @returns Formatted string for display
+ */
+export function formatVersionChoice(version) {
+    const currentIndicator = version.isCurrent ? ' (CURRENT)' : '';
+    const date = new Date(version.createdDate).toLocaleDateString();
+    return `${version.version}${currentIndicator} - Created: ${date} by ${version.createdByEmail}`;
+}
+/**
+ * Sorts versions by creation date (newest first).
+ *
+ * @param versions - Array of versions to sort
+ * @returns Sorted array of versions
+ */
+export function sortVersionsByDate(versions) {
+    return versions.sort((a, b) => new Date(b.createdDate).getTime() - new Date(a.createdDate).getTime());
+}
+/**
+ * Prompts user to select a version from available versions.
+ *
+ * @param versions - Array of available versions
+ * @returns Selected version string
+ */
+export async function promptVersionSelection(versions) {
+    const { selectedVersion } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "selectedVersion",
+            message: "Select a version to deploy:",
+            choices: versions.map(version => ({
+                name: formatVersionChoice(version),
+                value: version.version
+            }))
+        }
+    ]);
+    clearPromptLines(2);
+    return selectedVersion;
+}
+/**
+ * Prompts user to confirm deployment with warning.
+ *
+ * @returns True if confirmed, false otherwise
+ */
+export async function confirmDeployment() {
+    const { confirmed } = await inquirer.prompt([
+        {
+            type: "confirm",
+            name: "confirmed",
+            message: "⚠️  Warning: This version will be deployed to all users. Do you want to proceed?",
+            default: false
+        }
+    ]);
+    clearPromptLines(2);
+    return confirmed;
+}
+/**
+ * Validates that configuration has required fields for deployment.
+ *
+ * @param config - Skill configuration
+ * @throws Error if configuration is invalid
+ */
+export function validateDeployConfig(config) {
+    if (!config || !config.agent?.agentId || !config.skill?.skillId) {
+        throw new Error("No lua.skill.yaml found or missing agentId/skillId. Please run this command from a skill directory.");
+    }
+}
+/**
+ * Validates that versions are available for deployment.
+ *
+ * @param versions - Array of versions
+ * @throws Error if no versions are available
+ */
+export function validateVersionsAvailable(versions) {
+    if (!versions || versions.length === 0) {
+        throw new Error("No versions found for this skill.");
+    }
+}

package/dist/utils/deployment.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Deployment Data Generation Utilities
+ * Handles creation of deployment files in both new and legacy formats
+ */
+import { ToolInfo } from '../interfaces/compile.js';
+import { TypeScriptSourceFile } from '../types/compile.types.js';
+/**
+ * Creates deployment data in the new format.
+ * This format includes skill metadata and tool references.
+ * Output: dist/deployment.json
+ *
+ * @param tools - Array of detected tools
+ * @param distDir - Distribution directory for output
+ */
+export declare function createDeploymentData(tools: ToolInfo[], distDir: string): Promise<void>;
+/**
+ * Creates deployment data in the legacy format.
+ * This format includes compressed tool code and is used for backwards compatibility.
+ * Output: .lua/deploy.json and individual tool files
+ *
+ * @param tools - Array of detected tools
+ * @param luaDir - Legacy .lua directory for output
+ * @param indexFile - The TypeScript source file for the index
+ */
+export declare function createLegacyDeploymentData(tools: ToolInfo[], luaDir: string, indexFile: TypeScriptSourceFile): Promise<void>;

package/dist/utils/deployment.js

@@ -0,0 +1,161 @@
+/**
+ * Deployment Data Generation Utilities
+ * Handles creation of deployment files in both new and legacy formats
+ */
+import fs from "fs";
+import path from "path";
+import { Node } from "ts-morph";
+import { readSkillConfig } from './files.js';
+import { COMPILE_DIRS, COMPILE_FILES, SKILL_DEFAULTS, DEFAULT_INPUT_SCHEMA, JSON_FORMAT, } from '../config/compile.constants.js';
+import { compressCode, extractSkillsMetadata, } from './compile.js';
+import { ensureSkillsExistInYaml } from './skill-management.js';
+/**
+ * Creates deployment data in the new format.
+ * This format includes skill metadata and tool references.
+ * Output: dist/deployment.json
+ *
+ * @param tools - Array of detected tools
+ * @param distDir - Distribution directory for output
+ */
+export async function createDeploymentData(tools, distDir) {
+    const config = readSkillConfig();
+    const packageJson = readPackageJson();
+    const deploymentData = {
+        name: config?.skill?.name || packageJson.name || SKILL_DEFAULTS.NAME,
+        version: config?.skill?.version || packageJson.version || SKILL_DEFAULTS.VERSION,
+        skillId: config?.skill?.skillId || '',
+        description: config?.skill?.description || packageJson.description || SKILL_DEFAULTS.DESCRIPTION,
+        context: config?.skill?.context || SKILL_DEFAULTS.CONTEXT,
+        tools: tools.map(tool => ({
+            name: tool.name,
+            className: tool.className,
+            description: tool.description || '',
+            filePath: `${COMPILE_DIRS.TOOLS}/${tool.className}.js`
+        }))
+    };
+    fs.writeFileSync(path.join(distDir, COMPILE_FILES.DEPLOYMENT_JSON), JSON.stringify(deploymentData, null, JSON_FORMAT.INDENT));
+}
+/**
+ * Reads and parses the package.json file.
+ *
+ * @returns The parsed package.json content
+ */
+function readPackageJson() {
+    const packageJsonPath = path.join(process.cwd(), COMPILE_FILES.PACKAGE_JSON);
+    return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+}
+/**
+ * Creates deployment data in the legacy format.
+ * This format includes compressed tool code and is used for backwards compatibility.
+ * Output: .lua/deploy.json and individual tool files
+ *
+ * @param tools - Array of detected tools
+ * @param luaDir - Legacy .lua directory for output
+ * @param indexFile - The TypeScript source file for the index
+ */
+export async function createLegacyDeploymentData(tools, luaDir, indexFile) {
+    const config = readSkillConfig();
+    const skillsMetadata = extractSkillsMetadata(indexFile);
+    // Map tools to their parent skills
+    const skillToTools = mapToolsToSkills(indexFile);
+    // Build skills array with their associated tools
+    const skillsArray = buildSkillsArray(skillsMetadata, skillToTools, tools);
+    // Ensure all skills exist in YAML config and have valid IDs
+    const updatedSkillsArray = await ensureSkillsExistInYaml(skillsArray, config);
+    // Write deployment data
+    const deployData = {
+        skills: updatedSkillsArray
+    };
+    fs.writeFileSync(path.join(luaDir, COMPILE_FILES.DEPLOY_JSON), JSON.stringify(deployData, null, JSON_FORMAT.INDENT));
+    // Write individual tool files (uncompressed for debugging)
+    writeIndividualToolFiles(tools, luaDir);
+}
+/**
+ * Maps tools to their parent skills by analyzing addTools calls in the source code.
+ *
+ * @param indexFile - The TypeScript source file to analyze
+ * @returns Map of skill variable names to their tool class names
+ */
+function mapToolsToSkills(indexFile) {
+    const skillToTools = new Map();
+    indexFile.forEachDescendant((node) => {
+        if (Node.isCallExpression(node)) {
+            const expression = node.getExpression();
+            if (Node.isPropertyAccessExpression(expression) && expression.getName() === 'addTools') {
+                const object = expression.getExpression();
+                const objectName = object.getText();
+                const args = node.getArguments();
+                if (args.length > 0 && Node.isArrayLiteralExpression(args[0])) {
+                    const toolsArray = args[0];
+                    const toolNames = toolsArray.getElements()
+                        .map((element) => {
+                        if (Node.isNewExpression(element)) {
+                            return element.getExpression().getText();
+                        }
+                        return '';
+                    })
+                        .filter(name => name);
+                    skillToTools.set(objectName, toolNames);
+                }
+            }
+        }
+    });
+    return skillToTools;
+}
+/**
+ * Builds the skills array with their associated tools.
+ * Associates tools with skills based on constructor tools or variable name matching.
+ *
+ * @param skillsMetadata - Extracted skill metadata from source code
+ * @param skillToTools - Map of skill variables to tool class names
+ * @param tools - Array of all detected tools
+ * @returns Array of skills with their tools embedded
+ */
+function buildSkillsArray(skillsMetadata, skillToTools, tools) {
+    return skillsMetadata.map(skillMeta => {
+        let skillTools = [];
+        // Strategy 1: Check for tools from constructor
+        if (skillMeta.constructorTools && skillMeta.constructorTools.length > 0) {
+            skillTools = tools.filter(tool => skillMeta.constructorTools.includes(tool.className) ||
+                skillMeta.constructorTools.includes(tool.name));
+        }
+        else {
+            // Strategy 2: Match tools by variable name heuristic
+            for (const [varName, toolNames] of skillToTools.entries()) {
+                const skillNameLower = skillMeta.name.toLowerCase().replace('-skill', '');
+                if (varName.toLowerCase().includes(skillNameLower) ||
+                    varName.toLowerCase().includes(skillMeta.name.toLowerCase())) {
+                    skillTools = tools.filter(tool => toolNames.includes(tool.className) || toolNames.includes(tool.name));
+                    break;
+                }
+            }
+        }
+        return {
+            name: skillMeta.name,
+            version: skillMeta.version,
+            description: skillMeta.description,
+            context: skillMeta.context,
+            tools: skillTools.map(tool => ({
+                name: tool.name,
+                description: tool.description || '',
+                inputSchema: tool.inputSchema || DEFAULT_INPUT_SCHEMA,
+                execute: compressCode(tool.executeCode || '')
+            }))
+        };
+    });
+}
+/**
+ * Writes individual tool files to the .lua directory for debugging.
+ * These are uncompressed versions of the tool code.
+ *
+ * @param tools - Array of tools to write
+ * @param luaDir - Directory to write tool files to
+ */
+function writeIndividualToolFiles(tools, luaDir) {
+    for (const tool of tools) {
+        if (tool.executeCode) {
+            const toolFilePath = path.join(luaDir, `${tool.name}.js`);
+            fs.writeFileSync(toolFilePath, tool.executeCode);
+        }
+    }
+}