lua-cli 1.3.0-alpha.1 → 1.3.0

package/dist/commands/init.js

@@ -1,8 +1,8 @@
 import inquirer from "inquirer";
 import { fileURLToPath } from "url";
 import path from "path";
-import { loadApiKey, checkApiKey, createSkill } 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);
@@ -16,50 +16,237 @@ export async function initCommand() {
             console.error("❌ No API key found. Run `lua configure` first.");
             process.exit(1);
         }
-        // Get user data from API
-        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,
-            value: org
-        }));
-        // Select organization
-        const { selectedOrg } = await inquirer.prompt([
+        // Ask user if they want to create a new agent or select existing one
+        const { agentChoice } = await inquirer.prompt([
             {
                 type: "list",
-                name: "selectedOrg",
-                message: "Select an organization:",
-                choices: orgChoices
+                name: "agentChoice",
+                message: "What would you like to do?",
+                choices: [
+                    { name: "Select existing agent", value: "existing" },
+                    { name: "Create new agent", value: "create" }
+                ]
             }
         ]);
-        // Clear the organization selection prompt lines
+        // Clear the agent choice 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);
+        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);
         }
-        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
+        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);
+                }
             }
-        ]);
-        // Clear the agent selection 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");
+        }
         // Get skill name and handle retries
         let skillName = "";
         let skillData = null;
@@ -104,13 +291,14 @@ export async function initCommand() {
                 process.exit(1);
             }
         }
-        // Create lua.skill.toml file with skill ID
-        createSkillToml(selectedAgent.agentId, selectedOrg.id, skillName, skillData?.id);
-        writeProgress("✅ Created lua.skill.toml");
+        // 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.js

@@ -3,29 +3,26 @@ 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 fetch(`https://api.lua.dev/developer/skills/${agentId}/${skillId}/version`, {
-            method: "POST",
-            headers: {
-                "accept": "application/json",
-                "Authorization": `Bearer ${apiKey}`,
-                "Content-Type": "application/json"
-            },
-            body: JSON.stringify(versionData)
-        });
-        const data = await response.json();
-        if (response.ok) {
+        const response = await ApiService.Skill.pushSkill(apiKey, agentId, skillId, versionData);
+        if (response.success) {
             return {
                 success: true,
-                data: data
+                data: response.data
             };
         }
         else {
             return {
                 success: false,
-                error: data
+                error: {
+                    message: response.error?.message || 'Unknown error',
+                    error: response.error?.message || 'Unknown error',
+                    statusCode: response.error?.statusCode || 500
+                }
             };
         }
     }
@@ -41,14 +38,9 @@ export async function pushVersion(apiKey, agentId, skillId, versionData) {
         };
     }
 }
-function readTomlVersion() {
-    const tomlPath = path.join(process.cwd(), 'lua.skill.toml');
-    if (!fs.existsSync(tomlPath)) {
-        return null;
-    }
-    const tomlContent = fs.readFileSync(tomlPath, 'utf8');
-    const versionMatch = tomlContent.match(/version\s*=\s*["']([^"']+)["']/);
-    return versionMatch ? versionMatch[1] : null;
+function readConfigVersion() {
+    const config = readSkillConfig();
+    return config?.skill?.version || null;
 }
 function readDeployJson() {
     const deployPath = path.join(process.cwd(), '.lua', 'deploy.json');
@@ -61,15 +53,15 @@ function readDeployJson() {
 export async function pushCommand() {
     return withErrorHandling(async () => {
         // Check if we're in a skill directory
-        const tomlPath = path.join(process.cwd(), 'lua.skill.toml');
-        if (!fs.existsSync(tomlPath)) {
-            console.error("❌ No lua.skill.toml found. Please run this command from 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 TOML
-        const version = readTomlVersion();
+        // Read version from config
+        const version = config.skill?.version;
         if (!version) {
-            console.error("❌ No version found in lua.skill.toml");
+            console.error("❌ No version found in skill configuration");
             process.exit(1);
         }
         // Confirm with user
@@ -107,19 +99,16 @@ export async function pushCommand() {
         }
         // Verify version matches
         if (deployData.version !== version) {
-            console.error(`❌ Version mismatch: TOML has ${version}, deploy.json has ${deployData.version}`);
+            console.error(`❌ Version mismatch: config has ${version}, deploy.json has ${deployData.version}`);
             process.exit(1);
         }
-        // Extract agentId and skillId from TOML
-        const tomlContent = fs.readFileSync(tomlPath, 'utf8');
-        const agentIdMatch = tomlContent.match(/agentId\s*=\s*["']([^"']+)["']/);
-        const skillIdMatch = tomlContent.match(/skillId\s*=\s*["']([^"']+)["']/);
-        if (!agentIdMatch || !skillIdMatch) {
-            console.error("❌ Missing agentId or skillId in lua.skill.toml");
+        // 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);
         }
-        const agentId = agentIdMatch[1];
-        const skillId = skillIdMatch[1];
         // Push version
         writeProgress("🔄 Pushing version to server...");
         const result = await pushVersion(apiKey, agentId, skillId, deployData);

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,6 +1,6 @@
 #!/usr/bin/env node
 import { Command } from "commander";
-import { configureCommand, initCommand, destroyCommand, apiKeyCommand, compileCommand, testCommand, pushCommand, deployCommand } from "./commands/index.js";
+import { configureCommand, initCommand, destroyCommand, apiKeyCommand, compileCommand, testCommand, pushCommand, deployCommand, devCommand } from "./commands/index.js";
 const program = new Command();
 const authCommand = program
     .command("auth")
@@ -40,4 +40,10 @@ 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';

package/dist/services/api.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Centralized API service for all Lua CLI API calls
+ * This service handles all HTTP requests to various Lua endpoints
+ */
+export interface ApiResponse<T = any> {
+    success: boolean;
+    data?: T;
+    error?: {
+        message: string;
+        statusCode?: number;
+    };
+}
+export interface UserData {
+    uid: string;
+    email: string;
+    emailVerified: boolean;
+    fullName: string;
+    mobileNumbers: any[];
+    emailAddresses: any[];
+    country: any;
+    admin: any;
+    channels: Record<string, any>;
+    rights: Record<string, any>;
+    setupPersona: Record<string, any>;
+    notifications: Record<string, any>;
+}
+export interface Organization {
+    id: string;
+    name: string;
+    agents: string[];
+}
+export interface Agent {
+    id: string;
+    name: string;
+    persona?: string;
+    welcomeMessage?: string;
+    featuresOverride?: Record<string, any>;
+}
+export interface SkillVersion {
+    version: string;
+    createdAt: string;
+    status: string;
+}
+export interface DevVersionResponse {
+    success: boolean;
+    data?: {
+        message: string;
+        skillId: string;
+        version: string;
+    };
+    error?: {
+        message: string;
+        statusCode: number;
+    };
+}
+export interface UpdateDevVersionResponse {
+    success: boolean;
+    data?: {
+        message: string;
+        version: string;
+    };
+    error?: {
+        message: string;
+        statusCode: number;
+    };
+}
+export interface AgentType {
+    id: string;
+    name: string;
+    features: Record<string, any>;
+    requiredSubAgentMetadata?: string[];
+}
+export interface CreateAgentRequest {
+    id: string;
+    type: string;
+    metadata: Record<string, any>;
+    persona: {
+        agentName: string;
+        businessType: string;
+        brandPersonality: string;
+        brandTraits: string;
+    };
+    features: Record<string, boolean>;
+    channels: any[];
+    org: {
+        registeredName: string;
+    };
+}
+export interface CreateAgentResponse {
+    agentId: string;
+    name: string;
+    baseAgentId: string;
+    persona: string;
+    createdAt: string;
+    welcomeMessage: string;
+    featuresOverride: Record<string, any>;
+    org: {
+        registeredName: string;
+        type: string;
+        agents: string[];
+        paymentMethods: any[];
+        _id: string;
+        id: string;
+        createdAt: number;
+        __v: number;
+    };
+}
+export interface ChatMessage {
+    type: 'text';
+    text: string;
+}
+export interface ChatRequest {
+    messages: ChatMessage[];
+    navigate: boolean;
+    skillOverride: Array<{
+        skillId: string;
+        sandboxId: string;
+    }>;
+}
+export interface ChatResponse {
+    success: boolean;
+    text?: string;
+    error?: string;
+}
+/**
+ * Authentication API calls
+ */
+export declare class AuthApi {
+    static checkApiKey(apiKey: string): Promise<ApiResponse<UserData>>;
+    static sendOtp(email: string): Promise<ApiResponse<{
+        message: string;
+    }>>;
+    static verifyOtp(email: string, otp: string): Promise<ApiResponse<{
+        signInToken: string;
+    }>>;
+    static getApiKey(signInToken: string): Promise<ApiResponse<{
+        apiKey: string;
+    }>>;
+}
+/**
+ * Agent API calls
+ */
+export declare class AgentApi {
+    static getOrganizations(apiKey: string): Promise<ApiResponse<Organization[]>>;
+    static getAgentTypes(apiKey: string): Promise<ApiResponse<AgentType[]>>;
+    static createAgent(apiKey: string, agentData: CreateAgentRequest): Promise<ApiResponse<CreateAgentResponse>>;
+    static getAgent(apiKey: string, agentId: string): Promise<ApiResponse<Agent>>;
+}
+/**
+ * Skill API calls
+ */
+export declare class SkillApi {
+    static createSkill(apiKey: string, agentId: string, skillData: any): Promise<ApiResponse<{
+        skillId: string;
+        name: 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>>;
+    static updateDevSkill(apiKey: string, agentId: string, skillId: string, sandboxVersionId: string, versionData: any): Promise<ApiResponse<UpdateDevVersionResponse>>;
+    static getSkillVersions(apiKey: string, agentId: string, skillId: string): Promise<ApiResponse<{
+        versions: any[];
+    }>>;
+    static publishSkillVersion(apiKey: string, agentId: string, skillId: string, version: string): Promise<ApiResponse<{
+        message: string;
+        skillId: string;
+        activeVersionId: string;
+        publishedAt: string;
+    }>>;
+}
+/**
+ * Chat API calls
+ */
+export declare class ChatApi {
+    static sendMessage(agentId: string, chatData: ChatRequest, apiKey: string): Promise<ApiResponse<ChatResponse>>;
+}
+/**
+ * Tool API calls (for compile command)
+ */
+export declare class ToolApi {
+    static getTool(url: string, apiKey: string): Promise<ApiResponse<any>>;
+    static postTool(url: string, data: any, apiKey: string): Promise<ApiResponse<any>>;
+    static putTool(url: string, data: any, apiKey: string): Promise<ApiResponse<any>>;
+    static deleteTool(url: string, apiKey: string): Promise<ApiResponse<any>>;
+    static patchTool(url: string, data: any, apiKey: string): Promise<ApiResponse<any>>;
+}
+/**
+ * Main API service that exports all API classes
+ */
+export declare const ApiService: {
+    Auth: typeof AuthApi;
+    Agent: typeof AgentApi;
+    Skill: typeof SkillApi;
+    Chat: typeof ChatApi;
+    Tool: typeof ToolApi;
+};