lua-cli 1.2.1 → 1.3.0

package/dist/commands/init.js

@@ -1,70 +1,305 @@
 import inquirer from "inquirer";
 import { fileURLToPath } from "url";
 import path from "path";
-import { loadApiKey, checkApiKey } from "../services/auth.js";
-import { copyTemplateFiles, createSkillToml } from "../utils/files.js";
+import { loadApiKey, checkApiKey, createSkill, getAgentTypes, createAgent, getAgentDetails } from "../services/auth.js";
+import { copyTemplateFiles, createSkillYaml } from "../utils/files.js";
+import { withErrorHandling, clearPromptLines, writeProgress, writeSuccess } from "../utils/cli.js";
+function getTemplateDir() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    return path.join(__dirname, "..", "..", "template");
+}
 export async function initCommand() {
-    const apiKey = await loadApiKey();
-    if (!apiKey) {
-        console.error("❌ No API key found. Run `lua configure` first.");
-        process.exit(1);
-    }
-    // Get user data from API
-    const userData = await checkApiKey(apiKey);
-    // Extract organizations and create choices for selection
-    const orgs = userData.admin.orgs;
-    const orgChoices = orgs.map((org) => ({
-        name: org.registeredName,
-        value: org
-    }));
-    // Select organization
-    const { selectedOrg } = await inquirer.prompt([
-        {
-            type: "list",
-            name: "selectedOrg",
-            message: "Select an organization:",
-            choices: orgChoices
+    return withErrorHandling(async () => {
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.error("❌ No API key found. Run `lua configure` first.");
+            process.exit(1);
         }
-    ]);
-    // Extract agents from selected organization
-    const agentChoices = selectedOrg.agents.map((agent) => ({
-        name: agent.name,
-        value: agent
-    }));
-    // Select agent
-    const { selectedAgent } = await inquirer.prompt([
-        {
-            type: "list",
-            name: "selectedAgent",
-            message: "Select an agent:",
-            choices: agentChoices
+        // Ask user if they want to create a new agent or select existing one
+        const { agentChoice } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "agentChoice",
+                message: "What would you like to do?",
+                choices: [
+                    { name: "Select existing agent", value: "existing" },
+                    { name: "Create new agent", value: "create" }
+                ]
+            }
+        ]);
+        // Clear the agent choice prompt lines
+        clearPromptLines(2);
+        let selectedAgent;
+        let selectedOrg;
+        let persona;
+        let welcomeMessage;
+        if (agentChoice === "existing") {
+            // Get user data from API only when selecting existing agent
+            const userData = await checkApiKey(apiKey);
+            writeProgress("✅ Authenticated");
+            // Extract organizations and create choices for selection
+            const orgs = userData.admin.orgs;
+            if (!orgs || orgs.length === 0) {
+                console.error("❌ No organizations found.");
+                process.exit(1);
+            }
+            const orgChoices = orgs.map((org) => ({
+                name: org.registeredName || org.name || 'Unknown Organization',
+                value: org
+            }));
+            // Select organization
+            const { selectedOrg: existingOrg } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "selectedOrg",
+                    message: "Select an organization:",
+                    choices: orgChoices
+                }
+            ]);
+            selectedOrg = existingOrg;
+            // Clear the organization selection prompt lines
+            clearPromptLines(2);
+            // Extract agents from selected organization
+            if (!selectedOrg.agents || selectedOrg.agents.length === 0) {
+                console.error("❌ No agents found in the selected organization.");
+                process.exit(1);
+            }
+            const agentChoices = selectedOrg.agents.map((agent) => ({
+                name: agent.name,
+                value: agent
+            }));
+            // Select agent
+            const { selectedAgent: existingAgent } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "selectedAgent",
+                    message: "Select an agent:",
+                    choices: agentChoices
+                }
+            ]);
+            selectedAgent = existingAgent;
+            // Clear the agent selection prompt lines
+            clearPromptLines(2);
         }
-    ]);
-    // Get skill details
-    const { skillName, skillDescription } = await inquirer.prompt([
-        {
-            type: "input",
-            name: "skillName",
-            message: "Enter a name for your skill:",
-            default: "My Lua Skill"
-        },
-        {
-            type: "input",
-            name: "skillDescription",
-            message: "Describe your skill:",
-            default: "A Lua skill for automation"
+        else {
+            // Create new agent flow
+            writeProgress("🔄 Fetching agent types...");
+            const agentTypes = await getAgentTypes(apiKey);
+            writeProgress("✅ Agent types loaded");
+            // Select agent type
+            const agentTypeChoices = agentTypes.map((type) => ({
+                name: type.name,
+                value: type
+            }));
+            const { selectedAgentType } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "selectedAgentType",
+                    message: "Select an agent type:",
+                    choices: agentTypeChoices
+                }
+            ]);
+            // Clear the agent type selection prompt lines
+            clearPromptLines(2);
+            // Collect required metadata
+            const metadata = {};
+            if (selectedAgentType.requiredSubAgentMetadata && selectedAgentType.requiredSubAgentMetadata.length > 0) {
+                for (const field of selectedAgentType.requiredSubAgentMetadata) {
+                    const { [field]: value } = await inquirer.prompt([
+                        {
+                            type: "input",
+                            name: field,
+                            message: `Enter ${field}:`,
+                            validate: (input) => input.trim().length > 0 || `${field} is required`
+                        }
+                    ]);
+                    metadata[field] = value;
+                    // Clear the metadata prompt lines
+                    clearPromptLines(2);
+                }
+            }
+            // Configure features
+            const features = {};
+            const availableFeatures = Object.keys(selectedAgentType.features);
+            if (availableFeatures.length > 0) {
+                for (const feature of availableFeatures) {
+                    const { [feature]: enabled } = await inquirer.prompt([
+                        {
+                            type: "confirm",
+                            name: feature,
+                            message: `Enable ${feature} feature?`,
+                            default: selectedAgentType.features[feature]?.active || false
+                        }
+                    ]);
+                    features[feature] = enabled;
+                    // Clear the feature prompt lines
+                    clearPromptLines(2);
+                }
+            }
+            // Collect persona information
+            const businessTypes = [
+                "Retail & Consumer Goods (e.g. clothing store, bookstore)",
+                "Food & Beverage (e.g. restaurant, bakery)",
+                "Hospitality (e.g. hotel, resort)",
+                "Personal services (e.g. hair salon, spa)",
+                "Education (e.g. language school, online courses)",
+                "Health (e.g. gym, yoga studio, clinic)"
+            ];
+            const brandPersonalities = [
+                "Energetic & fun",
+                "Refined & elegant",
+                "Chatty",
+                "Casual",
+                "Funny",
+                "Friendly"
+            ];
+            const { businessName } = await inquirer.prompt([
+                {
+                    type: "input",
+                    name: "businessName",
+                    message: "Enter business name:",
+                    default: "Private"
+                }
+            ]);
+            clearPromptLines(2);
+            const { agentName } = await inquirer.prompt([
+                {
+                    type: "input",
+                    name: "agentName",
+                    message: "Enter agent name:",
+                    validate: (input) => input.trim().length > 0 || "Agent name is required"
+                }
+            ]);
+            clearPromptLines(2);
+            const { businessType } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "businessType",
+                    message: "Select business type:",
+                    choices: businessTypes
+                }
+            ]);
+            clearPromptLines(2);
+            const { brandPersonality } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "brandPersonality",
+                    message: "Select brand personality:",
+                    choices: brandPersonalities
+                }
+            ]);
+            clearPromptLines(2);
+            const { brandTraits } = await inquirer.prompt([
+                {
+                    type: "input",
+                    name: "brandTraits",
+                    message: "Enter brand traits (any traits the agent might have):",
+                    default: ""
+                }
+            ]);
+            clearPromptLines(2);
+            // For new agents, we need to handle organization selection
+            // For now, we'll create a new organization with the business name
+            // In the future, we could add organization selection here too
+            // Create agent
+            writeProgress("🔄 Creating agent...");
+            const agentData = {
+                id: `agent_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                type: selectedAgentType.id,
+                metadata,
+                persona: {
+                    agentName,
+                    businessType,
+                    brandPersonality,
+                    brandTraits
+                },
+                features,
+                channels: [],
+                org: {
+                    registeredName: businessName
+                }
+            };
+            const createAgentResult = await createAgent(apiKey, agentData);
+            if (!createAgentResult.success || !createAgentResult.data) {
+                console.error("❌ Failed to create agent:", createAgentResult.error?.message || "Unknown error");
+                process.exit(1);
+            }
+            writeProgress("✅ Agent created successfully!");
+            // Wait 30 seconds and get agent details
+            writeProgress("⏳ Waiting for agent to be ready...");
+            await new Promise(resolve => setTimeout(resolve, 30000));
+            writeProgress("🔄 Fetching agent details...");
+            const agentDetailsResult = await getAgentDetails(apiKey, createAgentResult.data.agentId);
+            if (!agentDetailsResult.success || !agentDetailsResult.data) {
+                console.error("❌ Failed to fetch agent details:", agentDetailsResult.error?.message || "Unknown error");
+                process.exit(1);
+            }
+            selectedAgent = {
+                agentId: createAgentResult.data.agentId,
+                name: createAgentResult.data.name
+            };
+            persona = agentDetailsResult.data.persona;
+            welcomeMessage = agentDetailsResult.data.welcomeMessage;
+            // For new agents, get the organization ID from the created agent response
+            selectedOrg = {
+                id: createAgentResult.data.org.id
+            };
+            writeProgress("✅ Agent details loaded");
         }
-    ]);
-    // Create lua.skill.toml file
-    createSkillToml(selectedAgent.agentId, selectedOrg.id, skillName, skillDescription);
-    console.log("✅ Created lua.skill.toml");
-    // Copy template files
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    const templateDir = path.join(__dirname, "..", "..", "template");
-    const currentDir = process.cwd();
-    copyTemplateFiles(templateDir, currentDir);
-    console.log("✅ Copied template files");
-    console.log("🎉 Lua skill project initialized successfully!");
-    console.log("📦 Run `npm install` to install dependencies");
+        // Get skill name and handle retries
+        let skillName = "";
+        let skillData = null;
+        let retry = true;
+        while (retry) {
+            const { skillName: inputSkillName } = await inquirer.prompt([
+                {
+                    type: "input",
+                    name: "skillName",
+                    message: "Enter a name for your skill:",
+                    default: "My Lua Skill"
+                }
+            ]);
+            skillName = inputSkillName;
+            // Create skill via API
+            writeProgress("🔄 Creating skill...");
+            const result = await createSkill(apiKey, selectedAgent.agentId, skillName);
+            if (result.success && result.data) {
+                skillData = result.data;
+                writeProgress("✅ Skill created successfully!");
+                retry = false;
+            }
+            else if (result.error) {
+                console.error(`❌ ${result.error.message}`);
+                const { shouldRetry } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "shouldRetry",
+                        message: "Would you like to try with a different name?",
+                        default: true
+                    }
+                ]);
+                // Clear the retry prompt lines
+                clearPromptLines(2);
+                if (!shouldRetry) {
+                    writeProgress("❌ Skill creation cancelled.");
+                    process.exit(1);
+                }
+            }
+            else {
+                console.error("❌ Failed to create skill. Please try again.");
+                process.exit(1);
+            }
+        }
+        // Create lua.skill.yaml file with skill ID, actual skill name, persona and welcome message from backend
+        const actualSkillName = skillData?.name || skillName;
+        // Copy template files
+        const templateDir = getTemplateDir();
+        const currentDir = process.cwd();
+        copyTemplateFiles(templateDir, currentDir);
+        createSkillYaml(selectedAgent.agentId, selectedOrg.id, actualSkillName, skillData?.id, persona, welcomeMessage);
+        writeProgress("✅ Created lua.skill.yaml");
+        writeProgress("✅ Copied template files");
+        writeSuccess("✅ Lua skill project initialized successfully!");
+    }, "initialization");
 }

package/dist/commands/push.d.ts

@@ -0,0 +1,22 @@
+export interface PushVersionResponse {
+    success: boolean;
+    data?: {
+        skillsId: string;
+        version: string;
+        context: string;
+        description: string;
+        tools: any[];
+        _id: string;
+        id: string;
+        createdAt: string;
+        updatedAt: string;
+        __v: number;
+    };
+    error?: {
+        message: string;
+        error: string;
+        statusCode: number;
+    };
+}
+export declare function pushVersion(apiKey: string, agentId: string, skillId: string, versionData: any): Promise<PushVersionResponse>;
+export declare function pushCommand(): Promise<void>;

package/dist/commands/push.js

@@ -0,0 +1,127 @@
+import fs from 'fs';
+import path from 'path';
+import inquirer from 'inquirer';
+import { compileCommand } from './compile.js';
+import { checkApiKey, loadApiKey } from '../services/auth.js';
+import { ApiService } from '../services/api.js';
+import { readSkillConfig } from '../utils/files.js';
+import { withErrorHandling, clearPromptLines, writeProgress, writeSuccess } from '../utils/cli.js';
+export async function pushVersion(apiKey, agentId, skillId, versionData) {
+    try {
+        const response = await ApiService.Skill.pushSkill(apiKey, agentId, skillId, versionData);
+        if (response.success) {
+            return {
+                success: true,
+                data: response.data
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: {
+                    message: response.error?.message || 'Unknown error',
+                    error: response.error?.message || 'Unknown error',
+                    statusCode: response.error?.statusCode || 500
+                }
+            };
+        }
+    }
+    catch (error) {
+        console.error("❌ Error pushing version:", error);
+        return {
+            success: false,
+            error: {
+                message: "Network error",
+                error: "Failed to connect to server",
+                statusCode: 500
+            }
+        };
+    }
+}
+function readConfigVersion() {
+    const config = readSkillConfig();
+    return config?.skill?.version || null;
+}
+function readDeployJson() {
+    const deployPath = path.join(process.cwd(), '.lua', 'deploy.json');
+    if (!fs.existsSync(deployPath)) {
+        return null;
+    }
+    const deployContent = fs.readFileSync(deployPath, 'utf8');
+    return JSON.parse(deployContent);
+}
+export async function pushCommand() {
+    return withErrorHandling(async () => {
+        // Check if we're in a skill directory
+        const config = readSkillConfig();
+        if (!config) {
+            console.error("❌ No lua.skill.yaml found. Please run this command from a skill directory.");
+            process.exit(1);
+        }
+        // Read version from config
+        const version = config.skill?.version;
+        if (!version) {
+            console.error("❌ No version found in skill configuration");
+            process.exit(1);
+        }
+        // Confirm with user
+        const { confirmed } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "confirmed",
+                message: `Are you sure you want to push version ${version}?`,
+                default: false
+            }
+        ]);
+        // Clear the confirmation prompt lines
+        clearPromptLines(2);
+        if (!confirmed) {
+            console.log("❌ Push cancelled.");
+            process.exit(0);
+        }
+        // Load API key
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.error("❌ No API key found. Please run 'lua configure' to set up your API key.");
+            process.exit(1);
+        }
+        // Validate API key
+        const userData = await checkApiKey(apiKey);
+        writeProgress("✅ Authenticated");
+        // Compile the skill first
+        writeProgress("🔄 Compiling skill...");
+        await compileCommand();
+        // Read deploy.json
+        const deployData = readDeployJson();
+        if (!deployData) {
+            console.error("❌ No deploy.json found. Compilation may have failed.");
+            process.exit(1);
+        }
+        // Verify version matches
+        if (deployData.version !== version) {
+            console.error(`❌ Version mismatch: config has ${version}, deploy.json has ${deployData.version}`);
+            process.exit(1);
+        }
+        // Extract agentId and skillId from config
+        const agentId = config.agent?.agentId;
+        const skillId = config.skill?.skillId;
+        if (!agentId || !skillId) {
+            console.error("❌ Missing agentId or skillId in skill configuration");
+            process.exit(1);
+        }
+        // Push version
+        writeProgress("🔄 Pushing version to server...");
+        const result = await pushVersion(apiKey, agentId, skillId, deployData);
+        if (result.success && result.data) {
+            writeSuccess(`✅ Version ${result.data.version} pushed successfully`);
+        }
+        else if (result.error) {
+            console.error(`❌ ${result.error.message}`);
+            process.exit(1);
+        }
+        else {
+            console.error("❌ Failed to push version. Please try again.");
+            process.exit(1);
+        }
+    }, "push");
+}

package/dist/commands/test.js

@@ -1,22 +1,23 @@
 import fs from "fs";
 import path from "path";
 import inquirer from "inquirer";
-import { deployCommand } from "./deploy.js";
+import { compileCommand } from "./compile.js";
 import { gunzipSync } from "zlib";
 import { Buffer } from "buffer";
 import { createRequire } from "module";
 import vm from "vm";
+import { withErrorHandling, clearPromptLines, writeProgress, writeSuccess } from "../utils/cli.js";
 // Decompression utility
 function decompressCode(compressedCode) {
     const buffer = Buffer.from(compressedCode, 'base64');
     return gunzipSync(buffer).toString('utf8');
 }
 export async function testCommand() {
-    try {
-        console.log("🧪 Testing Lua skill...");
+    return withErrorHandling(async () => {
+        writeProgress("🧪 Testing Lua skill...");
         // First, compile the code
-        console.log("📦 Compiling code first...");
-        await deployCommand();
+        writeProgress("📦 Compiling code first...");
+        await compileCommand();
         // Check if .lua directory exists
         const luaDir = path.join(process.cwd(), ".lua");
         if (!fs.existsSync(luaDir)) {
@@ -45,12 +46,14 @@ export async function testCommand() {
                 pageSize: 10
             }
         ]);
-        console.log(`\n✅ Selected tool: ${selectedTool.name}`);
+        // Clear the tool selection prompt lines
+        clearPromptLines(2);
+        writeProgress(`✅ Selected tool: ${selectedTool.name}`);
         // Get input values for each required parameter using inquirer
         const inputValues = {};
         const inputSchema = selectedTool.inputSchema;
         if (inputSchema.properties) {
-            console.log("\n📝 Enter input values:");
+            writeProgress("\n📝 Enter input values:");
             const inputPrompts = [];
             for (const [key, value] of Object.entries(inputSchema.properties)) {
                 const property = value;
@@ -108,8 +111,8 @@ export async function testCommand() {
                 }
             }
         }
-        console.log("\n🚀 Executing tool...");
-        console.log(`Input: ${JSON.stringify(inputValues, null, 2)}`);
+        writeProgress("\n🚀 Executing tool...");
+        writeProgress(`Input: ${JSON.stringify(inputValues, null, 2)}`);
         // Get the execute function string directly from the selected tool and decompress it
         const toolCode = decompressCode(selectedTool.execute);
         // Execute the tool
@@ -174,7 +177,7 @@ module.exports = async (input) => {
             // Get the exported function
             const executeFunction = context.module.exports;
             const result = await executeFunction(inputValues);
-            console.log("\n✅ Tool execution successful!");
+            writeSuccess("✅ Tool execution successful!");
             console.log(`Output: ${JSON.stringify(result, null, 2)}`);
         }
         catch (executionError) {
@@ -184,9 +187,5 @@ module.exports = async (input) => {
                 console.error(executionError.stack);
             }
         }
-    }
-    catch (error) {
-        console.error("❌ Test failed:", error.message);
-        process.exit(1);
-    }
+    }, "testing");
 }

package/dist/index.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+export { user, createUserDataAPI, UserDataAPI } from './user-data-api.js';

package/dist/index.js

@@ -1,33 +1,49 @@
 #!/usr/bin/env node
 import { Command } from "commander";
-import { configureCommand, initCommand, destroyCommand, apiKeyCommand, agentsCommand, deployCommand, testCommand } from "./commands/index.js";
+import { configureCommand, initCommand, destroyCommand, apiKeyCommand, compileCommand, testCommand, pushCommand, deployCommand, devCommand } from "./commands/index.js";
 const program = new Command();
-program
-    .command("init")
-    .description("Initialize a new Lua skill project")
-    .action(initCommand);
-program
-    .command("destroy")
-    .description("Delete your stored API key")
-    .action(destroyCommand);
-program
+const authCommand = program
+    .command("auth")
+    .description("Authentication management commands");
+authCommand
     .command("configure")
     .description("Set up your API key")
     .action(configureCommand);
-program
-    .command("apiKey")
+authCommand
+    .command("logout")
+    .description("Delete your stored API key")
+    .action(destroyCommand);
+authCommand
+    .command("key")
     .description("Display your stored API key")
     .action(apiKeyCommand);
-program
-    .command("agents")
-    .description("Fetch agents from HeyLua API")
-    .action(agentsCommand);
-program
+const skillCommand = program
+    .command("skill")
+    .description("Lua skill management commands");
+skillCommand
+    .command("init")
+    .description("Initialize a new Lua skill project")
+    .action(initCommand);
+skillCommand
     .command("compile")
     .description("Compile Lua skill to generate deployable format")
-    .action(deployCommand);
-program
+    .action(compileCommand);
+skillCommand
     .command("test")
     .description("Test Lua skill tools interactively")
     .action(testCommand);
+skillCommand
+    .command("push")
+    .description("Push compiled skill version to server")
+    .action(pushCommand);
+skillCommand
+    .command("deploy")
+    .description("Deploy a version to production")
+    .action(deployCommand);
+skillCommand
+    .command("dev")
+    .description("Push compiled skill version to sandbox for development")
+    .action(devCommand);
 program.parse(process.argv);
+// Export user data API for use in projects
+export { user, createUserDataAPI, UserDataAPI } from './user-data-api.js';