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

package/dist/utils/test-helpers.js

@@ -0,0 +1,92 @@
+/**
+ * Test Command Helper Utilities
+ * Handles tool extraction, decompression, and schema processing
+ */
+import fs from "fs";
+import path from "path";
+import { gunzipSync } from "zlib";
+import { Buffer } from "buffer";
+/**
+ * Decompresses gzip-compressed base64 encoded code.
+ *
+ * @param compressedCode - Base64 encoded compressed code
+ * @returns Decompressed code string
+ */
+export function decompressCode(compressedCode) {
+    const buffer = Buffer.from(compressedCode, 'base64');
+    return gunzipSync(buffer).toString('utf8');
+}
+/**
+ * Reads and parses deploy.json file.
+ *
+ * @returns Parsed deploy data
+ * @throws Error if deploy.json is not found
+ */
+export function readDeployJson() {
+    const luaDir = path.join(process.cwd(), ".lua");
+    if (!fs.existsSync(luaDir)) {
+        throw new Error(".lua directory not found. Run 'lua compile' first.");
+    }
+    const deployJsonPath = path.join(luaDir, "deploy.json");
+    if (!fs.existsSync(deployJsonPath)) {
+        throw new Error("deploy.json not found. Run 'lua compile' first.");
+    }
+    return JSON.parse(fs.readFileSync(deployJsonPath, "utf8"));
+}
+/**
+ * Extracts all tools from deploy.json (handles both new and legacy formats).
+ *
+ * @param deployData - Parsed deploy.json data
+ * @returns Array of tools with their metadata
+ * @throws Error if no tools are found
+ */
+export function extractToolsFromDeployData(deployData) {
+    let allTools = [];
+    if (deployData.skills && Array.isArray(deployData.skills)) {
+        // New format: extract tools from skills array
+        deployData.skills.forEach((skill) => {
+            if (skill.tools && Array.isArray(skill.tools)) {
+                skill.tools.forEach((tool) => {
+                    allTools.push({
+                        ...tool,
+                        skillName: skill.name // Add skill context
+                    });
+                });
+            }
+        });
+    }
+    else if (deployData.tools) {
+        // Legacy format: tools as object or array
+        if (Array.isArray(deployData.tools)) {
+            allTools = deployData.tools;
+        }
+        else {
+            // Convert tools object to array
+            allTools = Object.entries(deployData.tools).map(([name, tool]) => ({
+                name,
+                ...tool
+            }));
+        }
+    }
+    if (allTools.length === 0) {
+        throw new Error("No tools found in deploy.json");
+    }
+    return allTools;
+}
+/**
+ * Checks if .env file exists.
+ *
+ * @returns True if .env file exists
+ */
+export function hasEnvFile() {
+    return fs.existsSync(path.join(process.cwd(), '.env'));
+}
+/**
+ * Checks if config has environment variables defined.
+ *
+ * @param config - Skill configuration
+ * @returns True if config has environment variables
+ */
+export function hasConfigEnvVars(config) {
+    return config?.skill?.env && Object.keys(config.skill.env).length > 0;
+}

package/dist/utils/test-prompts.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Test Command Prompt Utilities
+ * Handles interactive prompts for tool selection and input collection
+ */
+import { ToolData, InputSchema } from '../interfaces/test.js';
+/**
+ * Prompts user to select a tool from the list.
+ *
+ * @param tools - Array of available tools
+ * @returns Selected tool data
+ */
+export declare function promptToolSelection(tools: ToolData[]): Promise<ToolData>;
+/**
+ * Recursively generates prompts for schema properties and collects input values.
+ * Handles nested objects and various property types.
+ *
+ * @param schema - Input schema to generate prompts from
+ * @param prefix - Prefix for nested property names
+ * @param required - Array of required property names
+ * @param rootSchema - Root schema for nested property lookups
+ * @returns Object containing collected input values
+ */
+export declare function generatePromptsForObject(schema: InputSchema, prefix?: string, required?: string[], rootSchema?: InputSchema): Promise<any>;

package/dist/utils/test-prompts.js

@@ -0,0 +1,186 @@
+/**
+ * Test Command Prompt Utilities
+ * Handles interactive prompts for tool selection and input collection
+ */
+import inquirer from "inquirer";
+import { writeProgress } from './cli.js';
+/**
+ * Prompts user to select a tool from the list.
+ *
+ * @param tools - Array of available tools
+ * @returns Selected tool data
+ */
+export async function promptToolSelection(tools) {
+    const toolChoices = tools.map((tool) => ({
+        name: tool.skillName
+            ? `${tool.name} (${tool.skillName}) - ${tool.description}`
+            : `${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
+        }
+    ]);
+    return selectedTool;
+}
+/**
+ * Recursively generates prompts for schema properties and collects input values.
+ * Handles nested objects and various property types.
+ *
+ * @param schema - Input schema to generate prompts from
+ * @param prefix - Prefix for nested property names
+ * @param required - Array of required property names
+ * @param rootSchema - Root schema for nested property lookups
+ * @returns Object containing collected input values
+ */
+export async function generatePromptsForObject(schema, prefix = '', required = [], rootSchema) {
+    const prompts = [];
+    const result = {};
+    const inputSchema = rootSchema || schema;
+    for (const [key, value] of Object.entries(schema.properties || {})) {
+        const property = value;
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        const isRequired = required.includes(key);
+        if (property.type === "object" && property.properties) {
+            // Handle nested object
+            writeProgress(`\n📋 Entering values for ${key}:`);
+            const nestedResult = await generatePromptsForObject(property, fullKey, property.required || [], inputSchema);
+            result[key] = nestedResult[key] || nestedResult;
+        }
+        else {
+            // Handle primitive types
+            const prompt = createPromptForProperty(key, property, fullKey, isRequired);
+            prompts.push(prompt);
+        }
+    }
+    if (prompts.length > 0) {
+        const answers = await inquirer.prompt(prompts);
+        processAnswers(answers, result, inputSchema, schema, required);
+    }
+    return result;
+}
+/**
+ * Creates an inquirer prompt for a schema property.
+ *
+ * @param key - Property name
+ * @param property - Property schema
+ * @param fullKey - Full property key including nested path
+ * @param isRequired - Whether the property is required
+ * @returns Inquirer prompt configuration
+ */
+function createPromptForProperty(key, property, fullKey, isRequired) {
+    let promptType = 'input';
+    let validate = undefined;
+    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`;
+            }
+    }
+    return {
+        type: promptType,
+        name: fullKey,
+        message: `${key}${isRequired ? " (required)" : " (optional)"}:`,
+        validate: validate,
+    };
+}
+/**
+ * Processes prompt answers and converts them to proper types.
+ * Handles nested structures and optional fields.
+ *
+ * @param answers - Raw answers from inquirer
+ * @param result - Result object to populate
+ * @param inputSchema - Root input schema
+ * @param schema - Current schema level
+ * @param required - Required property names at current level
+ */
+function processAnswers(answers, result, inputSchema, schema, required) {
+    for (const [key, value] of Object.entries(answers)) {
+        const keyParts = key.split('.');
+        const propertyKey = keyParts[keyParts.length - 1];
+        // Navigate through nested schemas to find the property
+        let currentSchema = inputSchema;
+        let currentProperty = null;
+        for (let i = 0; i < keyParts.length; i++) {
+            const part = keyParts[i];
+            if (currentSchema.properties && currentSchema.properties[part]) {
+                currentProperty = currentSchema.properties[part];
+                if (i < keyParts.length - 1) {
+                    currentSchema = currentProperty;
+                }
+            }
+        }
+        if (currentProperty) {
+            const convertedValue = convertValueByType(value, currentProperty);
+            // Check if field is optional and value is empty - skip if so
+            const parentSchema = keyParts.length > 1 ? currentSchema : schema;
+            const isOptional = !parentSchema.required || !parentSchema.required.includes(propertyKey);
+            const isEmpty = convertedValue === '' || convertedValue === null || convertedValue === undefined;
+            if (isOptional && isEmpty) {
+                continue; // Skip optional empty fields
+            }
+            // Build nested structure
+            if (keyParts.length === 1) {
+                result[propertyKey] = convertedValue;
+            }
+            else {
+                buildNestedStructure(result, keyParts, propertyKey, convertedValue);
+            }
+        }
+    }
+}
+/**
+ * Converts a value to the appropriate type based on schema property.
+ *
+ * @param value - Raw value from prompt
+ * @param property - Schema property definition
+ * @returns Converted value
+ */
+function convertValueByType(value, property) {
+    switch (property.type) {
+        case "number":
+            return parseFloat(value);
+        case "boolean":
+            return value;
+        default:
+            return value;
+    }
+}
+/**
+ * Builds nested object structure from key parts and value.
+ *
+ * @param result - Result object to populate
+ * @param keyParts - Array of nested key parts
+ * @param propertyKey - Final property key
+ * @param value - Value to set
+ */
+function buildNestedStructure(result, keyParts, propertyKey, value) {
+    let current = result;
+    for (let i = 0; i < keyParts.length - 1; i++) {
+        const part = keyParts[i];
+        if (!current[part]) {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    current[propertyKey] = value;
+}

package/dist/utils/tool-detection.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Tool Detection Utilities
+ * Handles detection and extraction of tools from TypeScript source code
+ */
+import { Project } from "ts-morph";
+import { ToolInfo } from '../interfaces/compile.js';
+import { TypeScriptSourceFile } from '../types/compile.types.js';
+/**
+ * Detects all tools in the project by analyzing the index file.
+ * Searches for tools in two places:
+ * 1. LuaSkill constructor's tools array
+ * 2. skill.addTools() or skill.addTool() method calls
+ *
+ * @param indexFile - The main index TypeScript source file
+ * @param project - The ts-morph Project instance
+ * @returns Promise resolving to array of detected tool information
+ */
+export declare function detectTools(indexFile: TypeScriptSourceFile, project: Project): Promise<ToolInfo[]>;

package/dist/utils/tool-detection.js

@@ -0,0 +1,110 @@
+/**
+ * Tool Detection Utilities
+ * Handles detection and extraction of tools from TypeScript source code
+ */
+import { Node } from "ts-morph";
+import { extractToolFromNewExpressionSync, } from './compile.js';
+/**
+ * Detects all tools in the project by analyzing the index file.
+ * Searches for tools in two places:
+ * 1. LuaSkill constructor's tools array
+ * 2. skill.addTools() or skill.addTool() method calls
+ *
+ * @param indexFile - The main index TypeScript source file
+ * @param project - The ts-morph Project instance
+ * @returns Promise resolving to array of detected tool information
+ */
+export async function detectTools(indexFile, project) {
+    const tools = [];
+    // Search strategy 1: Find tools in LuaSkill constructor's tools array
+    detectToolsFromConstructor(indexFile, project, tools);
+    // Search strategy 2: Find tools from skill.addTools() or skill.addTool() method calls
+    detectToolsFromMethodCalls(indexFile, project, tools);
+    return tools;
+}
+/**
+ * Detects tools from LuaSkill constructor configuration.
+ * Example: new LuaSkill({ tools: [new MyTool(), ...] })
+ *
+ * @param indexFile - The TypeScript source file to analyze
+ * @param project - The ts-morph Project instance
+ * @param tools - Array to push detected tools into (mutated)
+ */
+function detectToolsFromConstructor(indexFile, project, tools) {
+    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];
+                    // Look for tools property in constructor config
+                    configObj.getProperties().forEach((prop) => {
+                        if (Node.isPropertyAssignment(prop) && prop.getName() === 'tools') {
+                            const value = prop.getInitializer();
+                            if (value && Node.isArrayLiteralExpression(value)) {
+                                const toolsArray = value;
+                                toolsArray.getElements().forEach((element) => {
+                                    if (Node.isNewExpression(element)) {
+                                        const toolInfo = extractToolFromNewExpressionSync(element, project);
+                                        if (toolInfo) {
+                                            tools.push(toolInfo);
+                                        }
+                                    }
+                                });
+                            }
+                        }
+                    });
+                }
+            }
+        }
+    });
+}
+/**
+ * Detects tools from skill.addTools() or skill.addTool() method calls.
+ * Examples:
+ * - skill.addTools([new Tool1(), new Tool2()])
+ * - skill.addTool(new MyTool())
+ *
+ * @param indexFile - The TypeScript source file to analyze
+ * @param project - The ts-morph Project instance
+ * @param tools - Array to push detected tools into (mutated)
+ */
+function detectToolsFromMethodCalls(indexFile, project, tools) {
+    indexFile.forEachDescendant((node) => {
+        if (Node.isCallExpression(node)) {
+            const expression = node.getExpression();
+            if (Node.isPropertyAccessExpression(expression)) {
+                const property = expression.getName();
+                if (property === 'addTools' || property === 'addTool') {
+                    const args = node.getArguments();
+                    if (property === 'addTools' && args.length > 0) {
+                        // Handle skill.addTools([...]) - array of tools
+                        const arrayArg = args[0];
+                        if (Node.isArrayLiteralExpression(arrayArg)) {
+                            const elements = arrayArg.getElements();
+                            for (const element of elements) {
+                                if (Node.isNewExpression(element)) {
+                                    const toolInfo = extractToolFromNewExpressionSync(element, project);
+                                    if (toolInfo) {
+                                        tools.push(toolInfo);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    else if (property === 'addTool' && args.length > 0) {
+                        // Handle skill.addTool(new ToolClass()) - single tool
+                        const arg = args[0];
+                        if (Node.isNewExpression(arg)) {
+                            const toolInfo = extractToolFromNewExpressionSync(arg, project);
+                            if (toolInfo) {
+                                tools.push(toolInfo);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    });
+}