lua-cli 2.3.2 → 2.4.1

package/dist/commands/persona.js

@@ -0,0 +1,503 @@
+/**
+ * Persona Command
+ * Manages agent persona for sandbox and production environments
+ */
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import inquirer from 'inquirer';
+import { loadApiKey, checkApiKey } from '../services/auth.js';
+import { readSkillConfig } from '../utils/files.js';
+import { withErrorHandling, writeProgress, writeSuccess, writeInfo } 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';
+/**
+ * Main persona command - manages agent persona
+ *
+ * Features:
+ * - Environment selection (sandbox or production)
+ * - Sandbox: view, edit, save persona + create versions
+ * - Production: list versions, view details, deploy versions
+ *
+ * @returns Promise that resolves when command completes
+ */
+export async function personaCommand() {
+    return withErrorHandling(async () => {
+        // Step 1: Load configuration first (to get agentId)
+        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: Select environment
+        const envAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'environment',
+                message: 'Select environment:',
+                choices: [
+                    { name: '🔧 Sandbox (edit and test)', value: 'sandbox' },
+                    { name: '🚀 Production (view and deploy versions)', value: 'production' }
+                ]
+            }
+        ]);
+        if (!envAnswer)
+            return;
+        const context = {
+            environment: envAnswer.environment,
+            agentId,
+            apiKey,
+        };
+        // Step 4: Start management based on environment
+        if (envAnswer.environment === 'sandbox') {
+            await manageSandboxPersona(context);
+        }
+        else {
+            await manageProductionPersona(context);
+        }
+    }, "persona");
+}
+/**
+ * Manage sandbox persona - edit and save
+ */
+async function manageSandboxPersona(context) {
+    let continueManaging = true;
+    while (continueManaging) {
+        // Load current persona
+        const currentPersona = loadSandboxPersona();
+        // Show menu
+        console.log("\n" + "=".repeat(60));
+        console.log("🌙 Sandbox Persona Management");
+        console.log("=".repeat(60) + "\n");
+        if (currentPersona && currentPersona.trim()) {
+            const preview = currentPersona.length > 100
+                ? currentPersona.substring(0, 100) + '...'
+                : currentPersona;
+            console.log("Current persona:");
+            console.log(preview);
+            console.log();
+        }
+        else {
+            console.log("ℹ️  No persona configured.\n");
+        }
+        const actionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: '👁️  View full persona', value: 'view' },
+                    { name: '✏️  Edit persona', value: 'edit' },
+                    { name: '📦 Create version (push to production)', value: 'create_version' },
+                    { name: '📋 List versions', value: 'list_versions' },
+                    { name: '❌ Exit', value: 'exit' }
+                ]
+            }
+        ]);
+        if (!actionAnswer)
+            return;
+        const { action } = actionAnswer;
+        switch (action) {
+            case 'view':
+                await viewPersona(currentPersona);
+                break;
+            case 'edit':
+                await editSandboxPersona(context, currentPersona);
+                break;
+            case 'create_version':
+                await createPersonaVersion(context, currentPersona);
+                break;
+            case 'list_versions':
+                await listPersonaVersions(context);
+                break;
+            case 'exit':
+                continueManaging = false;
+                console.log("\n👋 Goodbye!\n");
+                break;
+        }
+    }
+}
+/**
+ * Manage production persona - view and deploy versions
+ */
+async function manageProductionPersona(context) {
+    let continueManaging = true;
+    while (continueManaging) {
+        console.log("\n" + "=".repeat(60));
+        console.log("🌙 Production Persona Management");
+        console.log("=".repeat(60) + "\n");
+        const actionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: '👁️  View persona versions', value: 'view' },
+                    { name: '🚀 Deploy persona version', value: 'deploy' },
+                    { name: '❌ Exit', value: 'exit' }
+                ]
+            }
+        ]);
+        if (!actionAnswer)
+            return;
+        const { action } = actionAnswer;
+        switch (action) {
+            case 'view':
+                await listPersonaVersions(context);
+                break;
+            case 'deploy':
+                await deployPersonaVersion(context);
+                break;
+            case 'exit':
+                continueManaging = false;
+                console.log("\n👋 Goodbye!\n");
+                break;
+        }
+    }
+}
+/**
+ * Load sandbox persona from lua.skill.yaml
+ */
+function loadSandboxPersona() {
+    try {
+        const config = readSkillConfig();
+        return config.agent?.persona || '';
+    }
+    catch (error) {
+        return '';
+    }
+}
+/**
+ * Save sandbox persona to lua.skill.yaml
+ */
+function saveSandboxPersona(persona) {
+    try {
+        const configPath = path.join(process.cwd(), 'lua.skill.yaml');
+        // Read current config
+        const fileContent = fs.readFileSync(configPath, 'utf8');
+        const config = yaml.load(fileContent);
+        // Ensure agent object exists
+        if (!config.agent) {
+            config.agent = {};
+        }
+        // Update persona
+        config.agent.persona = persona;
+        // Write back to file
+        const newContent = yaml.dump(config, {
+            lineWidth: -1,
+            noRefs: true
+        });
+        fs.writeFileSync(configPath, newContent, 'utf8');
+        return true;
+    }
+    catch (error) {
+        console.error('❌ Error saving persona to lua.skill.yaml:', error);
+        return false;
+    }
+}
+/**
+ * View full persona content
+ */
+async function viewPersona(persona) {
+    console.log("\n" + "=".repeat(60));
+    console.log("Agent Persona");
+    console.log("=".repeat(60));
+    if (persona && persona.trim()) {
+        console.log(persona);
+    }
+    else {
+        console.log("No persona configured.");
+    }
+    console.log("=".repeat(60) + "\n");
+    await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'continue',
+            message: 'Press Enter to continue...'
+        }
+    ]);
+}
+/**
+ * Edit sandbox persona
+ */
+async function editSandboxPersona(context, currentPersona) {
+    // Provide helpful default if empty
+    const defaultPersona = currentPersona || `# Write your agent persona here
+# 
+# Example:
+# You are a helpful customer service assistant for [Your Company].
+# You help users with product inquiries and order management.
+# You are friendly, professional, and knowledgeable.`;
+    const personaAnswer = await safePrompt([
+        {
+            type: 'editor',
+            name: 'newPersona',
+            message: 'Edit persona (will open in your default editor):',
+            default: defaultPersona,
+            validate: (input) => {
+                if (!input.trim()) {
+                    return 'Persona cannot be empty';
+                }
+                // Remove comment lines for validation
+                const withoutComments = input.split('\n')
+                    .filter((line) => !line.trim().startsWith('#'))
+                    .join('\n')
+                    .trim();
+                if (!withoutComments) {
+                    return 'Persona cannot be empty (only comments found)';
+                }
+                return true;
+            }
+        }
+    ]);
+    if (!personaAnswer)
+        return;
+    const { newPersona } = personaAnswer;
+    const trimmedPersona = newPersona.trim();
+    writeProgress("🔄 Saving persona to lua.skill.yaml...");
+    const success = saveSandboxPersona(trimmedPersona);
+    if (success) {
+        writeSuccess("✅ Persona saved to lua.skill.yaml successfully");
+    }
+    else {
+        console.error("❌ Failed to save persona to lua.skill.yaml");
+    }
+}
+/**
+ * Create a new persona version
+ */
+async function createPersonaVersion(context, currentPersona) {
+    if (!currentPersona || !currentPersona.trim()) {
+        console.log("\n❌ No persona to create version from. Please edit and save a persona first.\n");
+        return;
+    }
+    console.log("\n⚠️  This will create a new persona version that can be deployed to production.");
+    const confirmAnswer = await safePrompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Create new persona version?',
+            default: true
+        }
+    ]);
+    if (!confirmAnswer || !confirmAnswer.confirm) {
+        console.log("\nℹ️  Version creation cancelled.\n");
+        return;
+    }
+    writeProgress("🔄 Creating persona version...");
+    try {
+        const response = await fetch(`${BASE_URLS.API}/developer/agents/${context.agentId}/persona/version`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${context.apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ persona: currentPersona })
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`HTTP error! status: ${response.status}, ${errorText}`);
+        }
+        const data = await response.json();
+        const versionNum = data.version || data.data?.version || 'N/A';
+        writeSuccess(`✅ Persona version created successfully (version: ${versionNum})`);
+        writeInfo("💡 You can deploy this version from the production environment.");
+    }
+    catch (error) {
+        console.error('❌ Error creating persona version:', error);
+    }
+}
+/**
+ * List persona versions
+ */
+async function listPersonaVersions(context) {
+    writeProgress("🔄 Loading persona versions...");
+    try {
+        const response = await fetch(`${BASE_URLS.API}/developer/agents/${context.agentId}/persona/versions`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${context.apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`\n❌ API Error: ${response.status} - ${errorText}\n`);
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = await response.json();
+        // Handle different response formats
+        let versions = [];
+        if (Array.isArray(data)) {
+            versions = data;
+        }
+        else if (data.data && Array.isArray(data.data)) {
+            versions = data.data;
+        }
+        else if (data.versions && Array.isArray(data.versions)) {
+            versions = data.versions;
+        }
+        if (versions.length === 0) {
+            console.log("\nℹ️  No persona versions found.\n");
+            console.log("💡 Create a version first from sandbox mode.\n");
+            return;
+        }
+        // Sort versions by date (newest first)
+        const sortedVersions = versions.sort((a, b) => {
+            return b.createdDate - a.createdDate;
+        });
+        // Let user select a version to view
+        const versionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'selectedVersionIndex',
+                message: 'Select a persona version to view:',
+                choices: sortedVersions.map((version, index) => {
+                    const date = new Date(version.createdDate);
+                    const dateStr = date.toLocaleDateString();
+                    const deployedMark = version.isCurrent ? ' ⭐ CURRENT' : '';
+                    return {
+                        name: `Version ${version.version} (${dateStr})${deployedMark}`,
+                        value: index
+                    };
+                })
+            }
+        ]);
+        if (!versionAnswer)
+            return;
+        // Show the selected version's full persona
+        await viewVersionDetails([sortedVersions[versionAnswer.selectedVersionIndex]]);
+    }
+    catch (error) {
+        console.error('❌ Error loading persona versions:', error);
+    }
+}
+/**
+ * View details of a specific version
+ */
+async function viewVersionDetails(versions) {
+    const version = versions[0]; // Already pre-selected
+    const date = new Date(version.createdDate);
+    console.log("\n" + "=".repeat(60));
+    console.log(`Persona Version ${version.version}`);
+    console.log("=".repeat(60));
+    console.log(`Created: ${date.toLocaleString()}`);
+    console.log(`Status: ${version.isCurrent ? '⭐ CURRENT' : 'Available'}`);
+    if (version.createdBy) {
+        console.log(`Created by: ${version.createdBy}`);
+    }
+    console.log("=".repeat(60) + "\n");
+    console.log(version.persona);
+    console.log("\n" + "=".repeat(60) + "\n");
+    await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'continue',
+            message: 'Press Enter to continue...'
+        }
+    ]);
+}
+/**
+ * Deploy a persona version to production
+ */
+async function deployPersonaVersion(context) {
+    writeProgress("🔄 Loading persona versions...");
+    try {
+        const response = await fetch(`${BASE_URLS.API}/developer/agents/${context.agentId}/persona/versions`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${context.apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`\n❌ API Error: ${response.status} - ${errorText}\n`);
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = await response.json();
+        // Handle different response formats
+        let versions = [];
+        if (Array.isArray(data)) {
+            versions = data;
+        }
+        else if (data.data && Array.isArray(data.data)) {
+            versions = data.data;
+        }
+        else if (data.versions && Array.isArray(data.versions)) {
+            versions = data.versions;
+        }
+        if (versions.length === 0) {
+            console.log("\nℹ️  No persona versions available to deploy.\n");
+            console.log("💡 Create a version first from sandbox mode.\n");
+            return;
+        }
+        // Sort versions by date (newest first)
+        const sortedVersions = versions.sort((a, b) => b.createdDate - a.createdDate);
+        console.log("\n" + "=".repeat(60));
+        console.log("🌙 Select Persona Version to Deploy");
+        console.log("=".repeat(60) + "\n");
+        const versionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'selectedVersion',
+                message: 'Select version to deploy:',
+                choices: sortedVersions.map((v) => {
+                    const date = new Date(v.createdDate);
+                    const dateStr = date.toLocaleDateString();
+                    const timeStr = date.toLocaleTimeString();
+                    const currentMark = v.isCurrent ? ' ⭐ CURRENTLY DEPLOYED' : '';
+                    return {
+                        name: `Version ${v.version} - ${dateStr} ${timeStr}${currentMark}`,
+                        value: v.version
+                    };
+                })
+            }
+        ]);
+        if (!versionAnswer)
+            return;
+        const { selectedVersion } = versionAnswer;
+        // Show confirmation
+        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+        console.log("⚠️  This will affect ALL users immediately.\n");
+        const confirmAnswer = await safePrompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Are you absolutely sure you want to deploy this persona version?',
+                default: false
+            }
+        ]);
+        if (!confirmAnswer || !confirmAnswer.confirm) {
+            console.log("\n❌ Deployment cancelled.\n");
+            return;
+        }
+        writeProgress("🔄 Deploying persona version...");
+        const deployResponse = await fetch(`${BASE_URLS.API}/developer/agents/${context.agentId}/persona/version/${selectedVersion}`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${context.apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({})
+        });
+        if (!deployResponse.ok) {
+            const errorText = await deployResponse.text();
+            console.error(`\n❌ Deploy Error: ${deployResponse.status} - ${errorText}\n`);
+            throw new Error(`HTTP error! status: ${deployResponse.status}`);
+        }
+        writeSuccess(`✅ Persona version ${selectedVersion} deployed successfully to production`);
+        writeInfo("💡 The new persona is now active for all users.");
+    }
+    catch (error) {
+        console.error('❌ Error deploying persona version:', error);
+    }
+}

package/dist/commands/production.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Production Command
+ * Overview and management of production environment
+ */
+/**
+ * Main production command - overview of production environment
+ *
+ * Features:
+ * - View current persona and versions
+ * - View deployed skills and versions
+ * - Manage environment variables
+ *
+ * @returns Promise that resolves when command completes
+ */
+export declare function productionCommand(): Promise<void>;