lua-cli 2.3.2 → 2.4.1

package/dist/api/products.api.service.js

@@ -31,6 +31,7 @@ export default class ProductApi extends HttpClient {
         if (response.success) {
             return new ProductPaginationInstance(this, response);
         }
+        console.error(response);
         throw new Error(response.error?.message || 'Failed to get products');
     }
     /**

package/dist/cli/command-definitions.d.ts

@@ -17,14 +17,6 @@ export declare function setupAuthCommands(program: Command): void;
 /**
  * Sets up skill management commands.
  *
- * Commands:
- * - `lua init` - Initialize new project
- * - `lua compile` - Compile skill
- * - `lua test` - Test tools interactively
- * - `lua push` - Push to server
- * - `lua deploy` - Deploy to production
- * - `lua dev` - Development mode with live reload
- *
  * @param program - Commander program instance
  */
 export declare function setupSkillCommands(program: Command): void;

package/dist/cli/command-definitions.js

@@ -2,7 +2,7 @@
  * Command Definitions
  * Centralized command structure for the CLI
  */
-import { configureCommand, initCommand, destroyCommand, apiKeyCommand, compileCommand, testCommand, pushCommand, deployCommand, devCommand } from "../commands/index.js";
+import { configureCommand, initCommand, destroyCommand, apiKeyCommand, compileCommand, testCommand, pushCommand, deployCommand, chatCommand, chatClearCommand, envCommand, personaCommand, productionCommand, resourcesCommand } from "../commands/index.js";
 /**
  * Sets up authentication-related commands.
  *
@@ -16,7 +16,13 @@ import { configureCommand, initCommand, destroyCommand, apiKeyCommand, compileCo
 export function setupAuthCommands(program) {
     const authCommand = program
         .command("auth")
-        .description("Authentication management commands");
+        .description("🔐 Authentication management")
+        .addHelpText('after', `
+Examples:
+  $ lua auth configure    Set up your API key for the first time
+  $ lua auth key          View your current API key
+  $ lua auth logout       Remove stored credentials
+`);
     authCommand
         .command("configure")
         .description("Set up your API key")
@@ -33,39 +39,66 @@ export function setupAuthCommands(program) {
 /**
  * Sets up skill management commands.
  *
- * Commands:
- * - `lua init` - Initialize new project
- * - `lua compile` - Compile skill
- * - `lua test` - Test tools interactively
- * - `lua push` - Push to server
- * - `lua deploy` - Deploy to production
- * - `lua dev` - Development mode with live reload
- *
  * @param program - Commander program instance
  */
 export function setupSkillCommands(program) {
+    // Project Setup
     program
         .command("init")
-        .description("Initialize a new Lua skill project")
+        .description("🚀 Initialize a new Lua skill project")
         .action(initCommand);
+    // Development Commands
     program
         .command("compile")
-        .description("Compile Lua skill to generate deployable format")
+        .description("📦 Compile skill to deployable format")
         .action(compileCommand);
     program
         .command("test")
-        .description("Test Lua skill tools interactively")
+        .description("🧪 Test skill tools interactively")
         .action(testCommand);
+    // Deployment Commands
     program
         .command("push")
-        .description("Push compiled skill version to server")
+        .description("☁️  Push skill version to server")
         .action(pushCommand);
     program
         .command("deploy")
-        .description("Deploy a version to production")
+        .description("🚀 Deploy version to production")
         .action(deployCommand);
+    // Temporarily disabled - will be released later
+    // program
+    //   .command("dev")
+    //   .description("🔧 Development mode with live reload")
+    //   .action(devCommand);
+    // Chat Commands
+    const chatCmd = program
+        .command("chat")
+        .description("💬 Interactive chat with your agent")
+        .addHelpText('after', `
+Examples:
+  $ lua chat              Start interactive chat session
+  $ lua chat clear        Clear all conversation history
+`)
+        .action(chatCommand);
+    chatCmd
+        .command("clear")
+        .description("Clear conversation history")
+        .action(chatClearCommand);
+    // Configuration Commands
+    program
+        .command("env")
+        .description("⚙️  Manage environment variables")
+        .action(envCommand);
+    program
+        .command("persona")
+        .description("🤖 Manage agent persona")
+        .action(personaCommand);
+    program
+        .command("production")
+        .description("🚀 View and manage production environment")
+        .action(productionCommand);
     program
-        .command("dev")
-        .description("Push compiled skill version to sandbox for development")
-        .action(devCommand);
+        .command("resources")
+        .description("📚 Manage agent resources and knowledge base")
+        .action(resourcesCommand);
 }

package/dist/commands/chat.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Chat Command
+ * Interactive CLI chat interface with sandbox or production environment
+ */
+/**
+ * Main chat command - starts interactive chat session
+ *
+ * Features:
+ * - Environment selection (sandbox or production)
+ * - Interactive chat loop
+ * - Skill and persona overrides for sandbox
+ * - Real-time conversation
+ * - Exit with Ctrl+C
+ *
+ * @returns Promise that resolves when chat session ends
+ */
+export declare function chatCommand(): Promise<void>;

package/dist/commands/chat.js

@@ -0,0 +1,236 @@
+/**
+ * Chat Command
+ * Interactive CLI chat interface with sandbox or production environment
+ */
+import * as readline from 'readline';
+import inquirer from 'inquirer';
+import { loadApiKey, checkApiKey } from '../services/auth.js';
+import { readSkillConfig } from '../utils/files.js';
+import { withErrorHandling, writeProgress, writeSuccess } from '../utils/cli.js';
+import { compileCommand } from './compile.js';
+import { pushSkillsToSandbox } from '../utils/dev-api.js';
+import { getAllSandboxSkillIds } from '../utils/sandbox-storage.js';
+import ChatApi from '../api/chat.api.service.js';
+import { BASE_URLS } from '../config/constants.js';
+import { readDeployJson, validateConfig, validateDeployData, validateAgentConfig, } from '../utils/dev-helpers.js';
+/**
+ * Main chat command - starts interactive chat session
+ *
+ * Features:
+ * - Environment selection (sandbox or production)
+ * - Interactive chat loop
+ * - Skill and persona overrides for sandbox
+ * - Real-time conversation
+ * - Exit with Ctrl+C
+ *
+ * @returns Promise that resolves when chat session ends
+ */
+export async function chatCommand() {
+    return withErrorHandling(async () => {
+        // Step 1: Authenticate
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
+            process.exit(1);
+        }
+        const userData = await checkApiKey(apiKey);
+        writeProgress("✅ Authenticated");
+        // Step 2: Load configuration
+        const config = readSkillConfig();
+        validateConfig(config);
+        validateAgentConfig(config);
+        const agentId = config.agent.agentId;
+        // Step 3: Select environment
+        const { environment } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'environment',
+                message: 'Select environment:',
+                choices: [
+                    { name: '🔧 Sandbox (with skill overrides)', value: 'sandbox' },
+                    { name: '🚀 Production', value: 'production' }
+                ]
+            }
+        ]);
+        let chatEnv = {
+            type: environment,
+            agentId,
+            apiKey,
+        };
+        // Step 4: Setup sandbox if selected
+        if (environment === 'sandbox') {
+            await setupSandboxEnvironment(chatEnv, config);
+        }
+        // Step 5: Start interactive chat
+        await startChatLoop(chatEnv);
+    }, "chat");
+}
+/**
+ * Sets up the sandbox environment by compiling and pushing skills
+ */
+async function setupSandboxEnvironment(chatEnv, config) {
+    writeProgress("🔄 Setting up sandbox environment...");
+    // Compile the skill
+    writeProgress("🔄 Compiling skill...");
+    await compileCommand();
+    // Read deploy data
+    const deployData = readDeployJson();
+    validateDeployData(deployData);
+    // Push skills to sandbox
+    writeProgress("🔄 Pushing skills to sandbox...");
+    const sandboxIds = await pushSkillsToSandbox(chatEnv.apiKey, chatEnv.agentId, deployData, true);
+    if (Object.keys(sandboxIds).length === 0) {
+        console.error("❌ Failed to push any skills to sandbox. Cannot start chat.");
+        process.exit(1);
+    }
+    writeSuccess(`✅ Pushed ${Object.keys(sandboxIds).length} skills to sandbox`);
+    // Store deploy data for skill overrides
+    chatEnv.deployData = deployData;
+    // Check for persona in config
+    if (config.agent?.persona) {
+        chatEnv.persona = config.agent.persona;
+    }
+}
+/**
+ * Starts the interactive chat loop
+ */
+async function startChatLoop(chatEnv) {
+    console.log("\n" + "=".repeat(60));
+    console.log("🌙 Lua Chat Interface");
+    console.log(`Environment: ${chatEnv.type === 'sandbox' ? '🔧 Sandbox' : '🚀 Production'}`);
+    console.log("Press Ctrl+C to exit");
+    console.log("=".repeat(60) + "\n");
+    // Welcome message
+    console.log("🌙 Assistant: Hi there! How can I help you today?\n");
+    // Create readline interface
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: '💬 You: '
+    });
+    // Handle Ctrl+C gracefully
+    rl.on('SIGINT', () => {
+        console.log("\n\n👋 Goodbye!");
+        rl.close();
+        process.exit(0);
+    });
+    // Show prompt
+    rl.prompt();
+    // Handle user input
+    rl.on('line', async (input) => {
+        const message = input.trim();
+        if (!message) {
+            rl.prompt();
+            return;
+        }
+        try {
+            // Show typing indicator with animated dots
+            const typingInterval = startTypingIndicator();
+            let response = null;
+            if (chatEnv.type === 'sandbox') {
+                // Send to sandbox with skill overrides
+                response = await sendSandboxMessage(chatEnv, message);
+            }
+            else {
+                // Send to production
+                response = await sendProductionMessage(chatEnv, message);
+            }
+            // Stop typing indicator
+            stopTypingIndicator(typingInterval);
+            if (response) {
+                console.log(`🌙 Assistant: ${response}\n`);
+            }
+            else {
+                console.log("🌙 Assistant: ❌ Failed to get response. Please try again.\n");
+            }
+        }
+        catch (error) {
+            console.error(`\n❌ Error: ${error instanceof Error ? error.message : 'Unknown error'}\n`);
+        }
+        rl.prompt();
+    });
+    rl.on('close', () => {
+        console.log("\n👋 Goodbye!");
+        process.exit(0);
+    });
+}
+/**
+ * Starts a typing indicator animation with dots
+ * @returns The interval ID to stop the animation later
+ */
+function startTypingIndicator() {
+    const frames = ['   ', '.  ', '.. ', '...'];
+    let frameIndex = 0;
+    // Initial frame
+    process.stdout.write(`\r🌙 Assistant: ${frames[frameIndex]}`);
+    const interval = setInterval(() => {
+        frameIndex = (frameIndex + 1) % frames.length;
+        process.stdout.write(`\r🌙 Assistant: ${frames[frameIndex]}`);
+    }, 500);
+    return interval;
+}
+/**
+ * Stops the typing indicator animation and clears the line
+ * @param interval The interval ID from startTypingIndicator
+ */
+function stopTypingIndicator(interval) {
+    clearInterval(interval);
+    // Clear the typing indicator line
+    process.stdout.write('\r\x1b[K');
+}
+/**
+ * Sends a message to the sandbox environment with skill overrides
+ */
+async function sendSandboxMessage(chatEnv, message) {
+    if (!chatEnv.deployData) {
+        return "❌ Sandbox environment not properly initialized.";
+    }
+    // Get all sandbox skill IDs for skill override
+    const allSkillOverrides = await getAllSandboxSkillIds(chatEnv.deployData);
+    if (allSkillOverrides.length === 0) {
+        return "❌ No sandbox skills found. Please try running the command again.";
+    }
+    const chatRequest = {
+        messages: [
+            {
+                type: "text",
+                text: message
+            }
+        ],
+        navigate: true,
+        skillOverride: allSkillOverrides
+    };
+    // Add persona override if available
+    if (chatEnv.persona) {
+        chatRequest.personaOverride = chatEnv.persona;
+    }
+    const chatApi = new ChatApi(BASE_URLS.CHAT, chatEnv.apiKey);
+    const response = await chatApi.sendMessage(chatEnv.agentId, chatRequest);
+    if (!response.success) {
+        console.error(`❌ Chat API error: ${response.error?.message || 'Unknown error'}`);
+        return null;
+    }
+    return response.data?.text || null;
+}
+/**
+ * Sends a message to the production environment
+ */
+async function sendProductionMessage(chatEnv, message) {
+    const chatRequest = {
+        messages: [
+            {
+                type: "text",
+                text: message
+            }
+        ],
+        navigate: true,
+        skillOverride: []
+    };
+    const chatApi = new ChatApi(BASE_URLS.CHAT, chatEnv.apiKey);
+    const response = await chatApi.sendMessage(chatEnv.agentId, chatRequest);
+    if (!response.success) {
+        console.error(`❌ Chat API error: ${response.error?.message || 'Unknown error'}`);
+        return null;
+    }
+    return response.data?.text || null;
+}

package/dist/commands/chatClear.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Chat Clear Command
+ * Clears conversation history for the agent
+ */
+/**
+ * Chat clear command - clears conversation history
+ *
+ * Features:
+ * - Warning message about data loss
+ * - Confirmation prompt
+ * - Calls DELETE endpoint to clear history
+ *
+ * @returns Promise that resolves when history is cleared
+ */
+export declare function chatClearCommand(): Promise<void>;

package/dist/commands/chatClear.js

@@ -0,0 +1,75 @@
+/**
+ * Chat Clear Command
+ * Clears conversation history for the agent
+ */
+import { loadApiKey, checkApiKey } from '../services/auth.js';
+import { readSkillConfig } from '../utils/files.js';
+import { withErrorHandling, writeProgress, writeSuccess } from '../utils/cli.js';
+import { BASE_URLS } from '../config/constants.js';
+import { safePrompt } from '../utils/prompt-handler.js';
+import { validateConfig, validateAgentConfig, } from '../utils/dev-helpers.js';
+/**
+ * Chat clear command - clears conversation history
+ *
+ * Features:
+ * - Warning message about data loss
+ * - Confirmation prompt
+ * - Calls DELETE endpoint to clear history
+ *
+ * @returns Promise that resolves when history is cleared
+ */
+export async function chatClearCommand() {
+    return withErrorHandling(async () => {
+        // Step 1: Load configuration
+        const config = readSkillConfig();
+        validateConfig(config);
+        validateAgentConfig(config);
+        const agentId = config.agent.agentId;
+        // Step 2: Authenticate
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
+            process.exit(1);
+        }
+        await checkApiKey(apiKey);
+        writeProgress("✅ Authenticated");
+        // Step 3: Show warning and confirm
+        console.log("\n⚠️  WARNING: This will clear ALL conversation history!");
+        console.log("⚠️  This action cannot be undone.\n");
+        const confirmAnswer = await safePrompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Are you sure you want to clear the conversation history?',
+                default: false
+            }
+        ]);
+        if (!confirmAnswer || !confirmAnswer.confirm) {
+            console.log("\n❌ Operation cancelled. History not cleared.\n");
+            return;
+        }
+        // Step 4: Clear history via API
+        writeProgress("🔄 Clearing conversation history...");
+        try {
+            const response = await fetch(`${BASE_URLS.API}/chat/history/${agentId}`, {
+                method: 'DELETE',
+                headers: {
+                    'accept': '*/*',
+                    'Authorization': `Bearer ${apiKey}`
+                }
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`HTTP error! status: ${response.status} - ${errorText}`);
+            }
+            writeSuccess("✅ Conversation history cleared successfully");
+            console.log("💡 The chat history has been completely removed.\n");
+        }
+        catch (error) {
+            console.error('❌ Error clearing conversation history:', error);
+            if (error instanceof Error) {
+                console.error(`   ${error.message}\n`);
+            }
+        }
+    }, "chat clear");
+}

package/dist/commands/env.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Environment Variables Command
+ * Manages environment variables for sandbox and production environments
+ */
+/**
+ * Main env command - manages environment variables
+ *
+ * Features:
+ * - Environment selection (sandbox or production)
+ * - List all environment variables
+ * - Add new variables
+ * - Update existing variables
+ * - Delete variables
+ * - Sandbox: manages .env file
+ * - Production: uses API endpoints
+ *
+ * @returns Promise that resolves when command completes
+ */
+export declare function envCommand(): Promise<void>;