lua-cli 1.3.2-alpha.3 → 2.0.0

package/dist/commands/init.js

@@ -1,7 +1,8 @@
 import inquirer from "inquirer";
 import { fileURLToPath } from "url";
 import path from "path";
-import { loadApiKey, checkApiKey, createSkill, getAgentTypes, createAgent, getAgentDetails } from "../services/auth.js";
+import { loadApiKey, checkApiKey } from "../services/auth.js";
+import { ApiService } from "../services/api.js";
 import { copyTemplateFiles, createSkillYaml } from "../utils/files.js";
 import { withErrorHandling, clearPromptLines, writeProgress, writeSuccess } from "../utils/cli.js";
 function getTemplateDir() {
@@ -13,7 +14,7 @@ export async function initCommand() {
     return withErrorHandling(async () => {
         const apiKey = await loadApiKey();
         if (!apiKey) {
-            console.error("❌ No API key found. Run `lua configure` first.");
+            console.error("❌ No API key found. Run `lua auth configure` first.");
             process.exit(1);
         }
         // Ask user if they want to create a new agent or select existing one
@@ -29,7 +30,7 @@ export async function initCommand() {
             }
         ]);
         // Clear the agent choice prompt lines
-        clearPromptLines(2);
+        // clearPromptLines(2);
         let selectedAgent;
         let selectedOrg;
         let persona;
@@ -59,7 +60,7 @@ export async function initCommand() {
             ]);
             selectedOrg = existingOrg;
             // Clear the organization selection prompt lines
-            clearPromptLines(2);
+            // clearPromptLines(2);
             // Extract agents from selected organization
             if (!selectedOrg.agents || selectedOrg.agents.length === 0) {
                 console.error("❌ No agents found in the selected organization.");
@@ -80,28 +81,27 @@ export async function initCommand() {
             ]);
             selectedAgent = existingAgent;
             // Clear the agent selection prompt lines
-            clearPromptLines(2);
+            // clearPromptLines(2);
         }
         else {
-            // Create new agent flow
+            // Create new agent flow - always use baseAgent
             writeProgress("🔄 Fetching agent types...");
-            const agentTypes = await getAgentTypes(apiKey);
+            const agentTypesResult = await ApiService.Agent.getAgentTypes(apiKey);
+            const agentTypes = agentTypesResult.success ? agentTypesResult.data || [] : [];
             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);
+            // Always select Base Agent (skip user selection)
+            let selectedAgentType = agentTypes.find((type) => type.name === 'Base Agent' ||
+                type.name === 'baseAgent' ||
+                type.name.toLowerCase().includes('base'));
+            // If still not found, use the first available type
+            if (!selectedAgentType && agentTypes.length > 0) {
+                selectedAgentType = agentTypes[0];
+                writeProgress(`⚠️  baseAgent not found, using ${selectedAgentType.name} instead`);
+            }
+            if (!selectedAgentType) {
+                throw new Error("No agent types available. Please contact support.");
+            }
+            writeProgress(`✅ Using agent type: ${selectedAgentType.name}`);
             // Collect required metadata
             const metadata = {};
             if (selectedAgentType.requiredSubAgentMetadata && selectedAgentType.requiredSubAgentMetadata.length > 0) {
@@ -116,12 +116,13 @@ export async function initCommand() {
                     ]);
                     metadata[field] = value;
                     // Clear the metadata prompt lines
-                    clearPromptLines(2);
+                    // clearPromptLines(2);
                 }
             }
             // Configure features
             const features = {};
             const availableFeatures = Object.keys(selectedAgentType.features);
+            let linesToClear = 1;
             if (availableFeatures.length > 0) {
                 for (const feature of availableFeatures) {
                     const { [feature]: enabled } = await inquirer.prompt([
@@ -133,8 +134,9 @@ export async function initCommand() {
                         }
                     ]);
                     features[feature] = enabled;
+                    linesToClear++;
                     // Clear the feature prompt lines
-                    clearPromptLines(2);
+                    // clearPromptLines(2);
                 }
             }
             // Collect persona information
@@ -162,7 +164,8 @@ export async function initCommand() {
                     default: "Private"
                 }
             ]);
-            clearPromptLines(2);
+            // clearPromptLines(2);
+            linesToClear++;
             const { agentName } = await inquirer.prompt([
                 {
                     type: "input",
@@ -171,7 +174,8 @@ export async function initCommand() {
                     validate: (input) => input.trim().length > 0 || "Agent name is required"
                 }
             ]);
-            clearPromptLines(2);
+            // clearPromptLines(2);
+            linesToClear++;
             const { businessType } = await inquirer.prompt([
                 {
                     type: "list",
@@ -180,7 +184,8 @@ export async function initCommand() {
                     choices: businessTypes
                 }
             ]);
-            clearPromptLines(2);
+            // clearPromptLines(2);
+            linesToClear++;
             const { brandPersonality } = await inquirer.prompt([
                 {
                     type: "list",
@@ -189,7 +194,8 @@ export async function initCommand() {
                     choices: brandPersonalities
                 }
             ]);
-            clearPromptLines(2);
+            // clearPromptLines(2);
+            linesToClear++;
             const { brandTraits } = await inquirer.prompt([
                 {
                     type: "input",
@@ -198,10 +204,13 @@ export async function initCommand() {
                     default: ""
                 }
             ]);
-            clearPromptLines(2);
+            // clearPromptLines(2);
+            linesToClear++;
             // 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
+            clearPromptLines(linesToClear);
+            linesToClear = 0;
             // Create agent
             writeProgress("🔄 Creating agent...");
             const agentData = {
@@ -220,7 +229,7 @@ export async function initCommand() {
                     registeredName: businessName
                 }
             };
-            const createAgentResult = await createAgent(apiKey, agentData);
+            const createAgentResult = await ApiService.Agent.createAgent(apiKey, agentData);
             if (!createAgentResult.success || !createAgentResult.data) {
                 console.error("❌ Failed to create agent:", createAgentResult.error?.message || "Unknown error");
                 process.exit(1);
@@ -230,7 +239,7 @@ export async function initCommand() {
             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);
+            const agentDetailsResult = await ApiService.Agent.getAgent(apiKey, createAgentResult.data?.agentId);
             if (!agentDetailsResult.success || !agentDetailsResult.data) {
                 console.error("❌ Failed to fetch agent details:", agentDetailsResult.error?.message || "Unknown error");
                 process.exit(1);
@@ -247,64 +256,19 @@ export async function initCommand() {
             };
             writeProgress("✅ Agent details loaded");
         }
-        // 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;
+        // Skills will be created automatically during compilation
         // Copy template files
         const templateDir = getTemplateDir();
         const currentDir = process.cwd();
         copyTemplateFiles(templateDir, currentDir);
-        createSkillYaml(selectedAgent.agentId, selectedOrg.id, actualSkillName, skillData?.id, persona, welcomeMessage);
+        createSkillYaml(selectedAgent.agentId, selectedOrg.id, undefined, undefined, persona, welcomeMessage);
         writeProgress("✅ Created lua.skill.yaml");
         writeProgress("✅ Copied template files");
         // Install dependencies
         writeProgress("📦 Installing dependencies...");
         const { execSync } = await import('child_process');
         try {
-            execSync('npm install', { stdio: 'inherit', cwd: currentDir });
+            execSync('npm install --force', { stdio: 'inherit', cwd: currentDir });
             writeProgress("✅ Dependencies installed successfully");
         }
         catch (error) {

package/dist/commands/push.js

@@ -82,7 +82,7 @@ export async function pushCommand() {
         // 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.");
+            console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
             process.exit(1);
         }
         // Validate API key

package/dist/commands/test.js

@@ -6,7 +6,7 @@ import { gunzipSync } from "zlib";
 import { Buffer } from "buffer";
 import { withErrorHandling, clearPromptLines, writeProgress, writeSuccess } from "../utils/cli.js";
 import { loadApiKey } from "../services/auth.js";
-import { executeTool } from "../utils/sandbox.js";
+import { executeTool, loadEnvironmentVariables } from "../utils/sandbox.js";
 import { readSkillConfig } from "../utils/files.js";
 // Decompression utility
 function decompressCode(compressedCode) {
@@ -30,7 +30,35 @@ export async function testCommand() {
             throw new Error("deploy.json not found. Run 'lua compile' first.");
         }
         const deployData = JSON.parse(fs.readFileSync(deployJsonPath, "utf8"));
-        if (!deployData.tools || deployData.tools.length === 0) {
+        // Extract all tools from deploy.json (handle both new and legacy formats)
+        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");
         }
         // Get API key from keystore and agent ID from YAML
@@ -42,18 +70,19 @@ export async function testCommand() {
         const config = readSkillConfig();
         const agentId = config?.agent?.agentId;
         if (!agentId) {
-            throw new Error("No agent ID found in lua.skill.yaml. Please run 'lua skill init' first.");
+            throw new Error("No agent ID found in lua.skill.yaml. Please run 'lua init' first.");
         }
-        // Extract environment variables from YAML config
-        const envVars = {};
-        if (config?.skill?.env) {
-            for (const [key, value] of Object.entries(config.skill.env)) {
-                envVars[key] = value;
-            }
+        // Load environment variables from multiple sources (.env + yaml)
+        const envVars = loadEnvironmentVariables();
+        if (fs.existsSync(path.join(process.cwd(), '.env'))) {
+            writeProgress(`📄 Loaded environment variables from .env file`);
+        }
+        if (config?.skill?.env && Object.keys(config.skill.env).length > 0) {
+            writeProgress(`📄 Loaded environment variables from lua.skill.yaml`);
         }
         // Let user select a tool using picker
-        const toolChoices = deployData.tools.map((tool) => ({
-            name: `${tool.name} - ${tool.description}`,
+        const toolChoices = allTools.map((tool) => ({
+            name: tool.skillName ? `${tool.name} (${tool.skillName}) - ${tool.description}` : `${tool.name} - ${tool.description}`,
             value: tool
         }));
         const { selectedTool } = await inquirer.prompt([
@@ -190,6 +219,11 @@ export async function testCommand() {
         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);
+        // Set environment variables in process.env for the sandbox to pick up
+        const originalEnv = { ...process.env };
+        for (const [key, value] of Object.entries(envVars)) {
+            process.env[key] = value;
+        }
         // Execute the tool
         try {
             const result = await executeTool({
@@ -208,5 +242,9 @@ export async function testCommand() {
                 console.error(executionError.stack);
             }
         }
+        finally {
+            // Restore original environment variables
+            process.env = originalEnv;
+        }
     }, "testing");
 }

package/dist/index.js

@@ -17,30 +17,28 @@ authCommand
     .command("key")
     .description("Display your stored API key")
     .action(apiKeyCommand);
-const skillCommand = program
-    .command("skill")
-    .description("Lua skill management commands");
-skillCommand
+// Skill management commands (moved to top level)
+program
     .command("init")
     .description("Initialize a new Lua skill project")
     .action(initCommand);
-skillCommand
+program
     .command("compile")
     .description("Compile Lua skill to generate deployable format")
     .action(compileCommand);
-skillCommand
+program
     .command("test")
     .description("Test Lua skill tools interactively")
     .action(testCommand);
-skillCommand
+program
     .command("push")
     .description("Push compiled skill version to server")
     .action(pushCommand);
-skillCommand
+program
     .command("deploy")
     .description("Deploy a version to production")
     .action(deployCommand);
-skillCommand
+program
     .command("dev")
     .description("Push compiled skill version to sandbox for development")
     .action(devCommand);

package/dist/services/api.d.ts

@@ -151,8 +151,11 @@ export declare class AgentApi {
  */
 export declare class SkillApi {
     static createSkill(apiKey: string, agentId: string, skillData: any): Promise<ApiResponse<{
-        skillId: string;
+        id: string;
         name: string;
+        description?: string;
+        agentId: string;
+        context?: string;
     }>>;
     static pushSkill(apiKey: string, agentId: string, skillId: string, versionData: any): Promise<ApiResponse<DevVersionResponse>>;
     static pushDevSkill(apiKey: string, agentId: string, skillId: string, versionData: any): Promise<ApiResponse<DevVersionResponse>>;

package/dist/services/api.js

@@ -4,10 +4,10 @@
  */
 // Base URLs for different environments
 const BASE_URLS = {
-    LOCAL: 'http://localhost:3022',
-    API: 'https://api.lua.dev',
-    AUTH: 'https://auth.lua.dev',
-    CHAT: 'http://localhost:3001'
+    LOCAL: 'https://api.heylua.ai',
+    API: 'https://api.heylua.ai',
+    AUTH: 'https://auth.heylua.ai',
+    CHAT: 'https://api.heylua.ai'
 };
 /**
  * Generic HTTP client with common error handling
@@ -86,10 +86,10 @@ export class AuthApi {
         });
     }
     static async sendOtp(email) {
-        return httpClient.post(`${BASE_URLS.AUTH}/otp`, { email });
+        return httpClient.post(`${BASE_URLS.AUTH}/otp`, { email, type: 'email' });
     }
     static async verifyOtp(email, otp) {
-        return httpClient.post(`${BASE_URLS.AUTH}/otp/verify`, { email, otp });
+        return httpClient.post(`${BASE_URLS.AUTH}/otp/verify`, { email, pin: otp, type: 'email' });
     }
     static async getApiKey(signInToken) {
         return httpClient.post(`${BASE_URLS.AUTH}/profile/apiKey`, undefined, {
@@ -127,6 +127,7 @@ export class AgentApi {
  */
 export class SkillApi {
     static async createSkill(apiKey, agentId, skillData) {
+        // console.log(`Skill data:`, skillData);
         return httpClient.post(`${BASE_URLS.LOCAL}/developer/skills/${agentId}`, skillData, {
             Authorization: `Bearer ${apiKey}`,
         });

package/dist/services/auth.d.ts

@@ -25,7 +25,6 @@ export interface CreateSkillResponse {
         statusCode: number;
     };
 }
-export declare function createSkill(apiKey: string, agentId: string, skillName: string): Promise<CreateSkillResponse>;
 export interface AgentType {
     id: string;
     name: string;
@@ -105,6 +104,3 @@ export interface AgentDetailsResponse {
         statusCode: number;
     };
 }
-export declare function getAgentTypes(apiKey: string): Promise<AgentType[]>;
-export declare function createAgent(apiKey: string, agentData: CreateAgentRequest): Promise<CreateAgentResponse>;
-export declare function getAgentDetails(apiKey: string, agentId: string): Promise<AgentDetailsResponse>;

package/dist/services/auth.js

@@ -49,132 +49,5 @@ export async function generateApiKey(signInToken) {
         return null;
     }
 }
-export async function createSkill(apiKey, agentId, skillName) {
-    try {
-        const response = await fetch(`http://localhost:3022/developer/skills/${agentId}`, {
-            method: "POST",
-            headers: {
-                "accept": "application/json",
-                "Authorization": `Bearer ${apiKey}`,
-                "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-                name: skillName
-            })
-        });
-        const data = await response.json();
-        if (response.ok) {
-            return {
-                success: true,
-                data: data
-            };
-        }
-        else {
-            return {
-                success: false,
-                error: data
-            };
-        }
-    }
-    catch (error) {
-        console.error("❌ Error creating skill:", error);
-        return {
-            success: false,
-            error: {
-                message: "Network error",
-                error: "Failed to connect to server",
-                statusCode: 500
-            }
-        };
-    }
-}
-export async function getAgentTypes(apiKey) {
-    try {
-        const response = await fetch('https://api.lua.dev/agents/self-serve/types', {
-            method: 'GET',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-                'Content-Type': 'application/json'
-            }
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
-        }
-        return await response.json();
-    }
-    catch (error) {
-        console.error('❌ Error fetching agent types:', error);
-        throw error;
-    }
-}
-export async function createAgent(apiKey, agentData) {
-    try {
-        const response = await fetch('https://api.lua.dev/agents/self-serve/create', {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify(agentData)
-        });
-        const data = await response.json();
-        if (response.ok) {
-            return {
-                success: true,
-                data: data
-            };
-        }
-        else {
-            return {
-                success: false,
-                error: data
-            };
-        }
-    }
-    catch (error) {
-        console.error('❌ Error creating agent:', error);
-        return {
-            success: false,
-            error: {
-                message: 'Network error',
-                error: 'Failed to connect to server',
-                statusCode: 500
-            }
-        };
-    }
-}
-export async function getAgentDetails(apiKey, agentId) {
-    try {
-        const response = await fetch(`https://api.lua.dev/admin/agents/${agentId}`, {
-            method: 'GET',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-                'Content-Type': 'application/json'
-            }
-        });
-        const data = await response.json();
-        if (response.ok) {
-            return {
-                success: true,
-                data: data
-            };
-        }
-        else {
-            return {
-                success: false,
-                error: data
-            };
-        }
-    }
-    catch (error) {
-        console.error('❌ Error fetching agent details:', error);
-        return {
-            success: false,
-            error: {
-                message: 'Network error',
-                error: 'Failed to connect to server',
-                statusCode: 500
-            }
-        };
-    }
-}
+// API functions moved to centralized ApiService and api.ts
+// Use ApiService.getAgentTypes(), ApiService.createAgent(), ApiService.getAgentDetails() instead

package/dist/skill.d.ts

@@ -16,11 +16,16 @@ export { LuaTool };
  */
 export declare const env: (key: string) => string | undefined;
 export interface LuaSkillConfig {
+    name?: string;
+    version?: string;
     description: string;
     context: string;
+    tools?: LuaTool<any>[];
 }
 export declare class LuaSkill {
     private readonly tools;
+    private readonly name;
+    private readonly version;
     private readonly description;
     private readonly context;
     /**

package/dist/skill.js

@@ -59,8 +59,14 @@ export class LuaSkill {
      */
     constructor(config) {
         this.tools = [];
+        this.name = config.name || 'unnamed-skill';
+        this.version = config.version || '1.0.0';
         this.description = config.description;
         this.context = config.context;
+        // Add tools from constructor if provided
+        if (config.tools) {
+            this.addTools(config.tools);
+        }
     }
     addTool(tool) {
         // Validate the tool name before adding it

package/dist/types/index.d.ts

@@ -69,11 +69,15 @@ export interface LuaTool<TInput extends ZodType = ZodType> {
     execute: (input: any) => Promise<any>;
 }
 export interface LuaSkillConfig {
+    name: string;
+    version: string;
     description: string;
     context: string;
 }
 export declare class LuaSkill {
     private readonly tools;
+    private readonly name;
+    private readonly version;
     private readonly description;
     private readonly context;
     constructor(config: LuaSkillConfig);

package/dist/utils/files.d.ts

@@ -1,5 +1,5 @@
 export declare function copyTemplateFiles(templateDir: string, targetDir: string): void;
-export declare function createSkillYaml(agentId: string, orgId: string, skillName: string, skillId?: string, persona?: string, welcomeMessage?: string): void;
+export declare function createSkillYaml(agentId: string, orgId: string, skillName?: string, skillId?: string, persona?: string, welcomeMessage?: string): void;
 export declare function readSkillYaml(): any;
 export declare function readSkillConfig(): any;
 export declare function updateSkillYamlPersona(persona: string, welcomeMessage?: string): void;