lua-cli 2.5.6 → 2.5.8

package/dist/commands/features.js

@@ -0,0 +1,352 @@
+/**
+ * Features Command
+ * Manages agent features (tickets, RAG, webSearch, etc.)
+ */
+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';
+import AgentApi from '../api/agent.api.service.js';
+/**
+ * Main features command - manages agent features
+ *
+ * Features:
+ * - List all available features
+ * - View feature details (active status and context)
+ * - Enable/disable features
+ * - Update feature context
+ *
+ * @returns Promise that resolves when command completes
+ */
+export async function featuresCommand() {
+    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: Create API instance
+        const agentApi = new AgentApi(BASE_URLS.API, apiKey);
+        const context = {
+            agentId,
+            apiKey,
+            agentApi,
+        };
+        // Step 4: Start feature management
+        await manageFeatures(context);
+    }, "features");
+}
+/**
+ * Main management loop for features
+ */
+async function manageFeatures(context) {
+    let continueManaging = true;
+    while (continueManaging) {
+        // Load current features
+        writeProgress("🔄 Loading features...");
+        let features;
+        try {
+            const response = await context.agentApi.getAgentFeatures(context.agentId);
+            if (!response.data) {
+                throw new Error("No data returned from API");
+            }
+            features = response.data.features;
+        }
+        catch (error) {
+            console.error("❌ Error loading features:", error);
+            await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to try again...' }]);
+            continue;
+        }
+        // Show current state
+        console.log("\n" + "=".repeat(60));
+        console.log("🎯 Agent Features");
+        console.log("=".repeat(60) + "\n");
+        if (features.length === 0) {
+            console.log("ℹ️  No features available for this agent.\n");
+        }
+        else {
+            console.log("Available features:\n");
+            features.forEach((feature, index) => {
+                const status = feature.active ? "✅" : "❌";
+                console.log(`${index + 1}. ${status} ${feature.title}`);
+                console.log(`   Name: ${feature.name}`);
+                console.log(`   Status: ${feature.active ? "Active" : "Inactive"}`);
+                console.log();
+            });
+        }
+        // Show menu
+        const actionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: '👁️  View feature details', value: 'view' },
+                    { name: '✏️  Manage a feature', value: 'manage' },
+                    { name: '🔄 Refresh list', value: 'refresh' },
+                    { name: '❌ Exit', value: 'exit' }
+                ]
+            }
+        ]);
+        if (!actionAnswer)
+            return;
+        const { action } = actionAnswer;
+        switch (action) {
+            case 'view':
+                await viewFeatureDetails(context, features);
+                break;
+            case 'manage':
+                await manageFeature(context, features);
+                break;
+            case 'refresh':
+                // Just loop again to refresh
+                break;
+            case 'exit':
+                continueManaging = false;
+                console.log("\n👋 Goodbye!\n");
+                break;
+        }
+    }
+}
+/**
+ * View detailed information about a feature
+ */
+async function viewFeatureDetails(context, features) {
+    if (features.length === 0) {
+        console.log("\nℹ️  No features available.\n");
+        return;
+    }
+    // Prompt to select a feature
+    const featureAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedFeature',
+            message: 'Select a feature to view:',
+            choices: features.map(feature => ({
+                name: `${feature.active ? '✅' : '❌'} ${feature.title}`,
+                value: feature
+            }))
+        }
+    ]);
+    if (!featureAnswer)
+        return;
+    const feature = featureAnswer.selectedFeature;
+    // Display feature details
+    console.log("\n" + "=".repeat(60));
+    console.log(`🎯 ${feature.title}`);
+    console.log("=".repeat(60));
+    console.log(`Name: ${feature.name}`);
+    console.log(`Status: ${feature.active ? '✅ Active' : '❌ Inactive'}`);
+    console.log("\nContext/Instructions:");
+    console.log("─".repeat(60));
+    console.log(feature.context);
+    console.log("=".repeat(60) + "\n");
+    await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+}
+/**
+ * Manage a specific feature (activate/deactivate or update context)
+ */
+async function manageFeature(context, features) {
+    if (features.length === 0) {
+        console.log("\nℹ️  No features available.\n");
+        return;
+    }
+    // Step 1: Select feature
+    const featureAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedFeature',
+            message: 'Select a feature to manage:',
+            choices: features.map(feature => ({
+                name: `${feature.active ? '✅' : '❌'} ${feature.title}`,
+                value: feature
+            }))
+        }
+    ]);
+    if (!featureAnswer)
+        return;
+    const feature = featureAnswer.selectedFeature;
+    // Step 2: Show current status
+    console.log("\n" + "─".repeat(60));
+    console.log(`Feature: ${feature.title}`);
+    console.log(`Current Status: ${feature.active ? '✅ Active' : '❌ Inactive'}`);
+    console.log("─".repeat(60) + "\n");
+    // Step 3: Select action
+    const actionAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: 'What would you like to do?',
+            choices: [
+                {
+                    name: feature.active ? '❌ Deactivate feature' : '✅ Activate feature',
+                    value: 'toggle'
+                },
+                { name: '✏️  Update context/instructions', value: 'context' },
+                { name: '🔄 Update both status and context', value: 'both' },
+                { name: '⬅️  Back', value: 'back' }
+            ]
+        }
+    ]);
+    if (!actionAnswer || actionAnswer.action === 'back')
+        return;
+    try {
+        switch (actionAnswer.action) {
+            case 'toggle':
+                await toggleFeature(context, feature);
+                break;
+            case 'context':
+                await updateFeatureContext(context, feature);
+                break;
+            case 'both':
+                await updateBoth(context, feature);
+                break;
+        }
+    }
+    catch (error) {
+        console.error("\n❌ Error updating feature:", error);
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+}
+/**
+ * Toggle feature active status
+ */
+async function toggleFeature(context, feature) {
+    const newStatus = !feature.active;
+    const action = newStatus ? 'activate' : 'deactivate';
+    const confirmAnswer = await safePrompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Are you sure you want to ${action} "${feature.title}"?`,
+            default: true
+        }
+    ]);
+    if (!confirmAnswer || !confirmAnswer.confirm) {
+        console.log("\n❌ Operation cancelled.\n");
+        return;
+    }
+    writeProgress(`🔄 ${newStatus ? 'Activating' : 'Deactivating'} feature...`);
+    const response = await context.agentApi.updateAgentFeature(context.agentId, {
+        featureName: feature.name,
+        active: newStatus
+    });
+    writeSuccess(`✅ Feature "${feature.title}" ${newStatus ? 'activated' : 'deactivated'} successfully`);
+    await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+}
+/**
+ * Update feature context
+ */
+async function updateFeatureContext(context, feature) {
+    console.log("\n📝 Current context:");
+    console.log("─".repeat(60));
+    console.log(feature.context);
+    console.log("─".repeat(60) + "\n");
+    const contextAnswer = await safePrompt([
+        {
+            type: 'editor',
+            name: 'newContext',
+            message: 'Edit feature context (will open in your default editor):',
+            default: feature.context,
+            validate: (input) => {
+                if (!input || !input.trim()) {
+                    return 'Context cannot be empty';
+                }
+                return true;
+            }
+        }
+    ]);
+    if (!contextAnswer)
+        return;
+    const confirmAnswer = await safePrompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Save updated context?',
+            default: true
+        }
+    ]);
+    if (!confirmAnswer || !confirmAnswer.confirm) {
+        console.log("\n❌ Update cancelled.\n");
+        return;
+    }
+    writeProgress("🔄 Updating feature context...");
+    const response = await context.agentApi.updateAgentFeature(context.agentId, {
+        featureName: feature.name,
+        featureContext: contextAnswer.newContext.trim()
+    });
+    writeSuccess(`✅ Context for "${feature.title}" updated successfully`);
+    await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+}
+/**
+ * Update both status and context
+ */
+async function updateBoth(context, feature) {
+    // Step 1: Select new status
+    const statusAnswer = await safePrompt([
+        {
+            type: 'confirm',
+            name: 'active',
+            message: 'Should this feature be active?',
+            default: feature.active
+        }
+    ]);
+    if (!statusAnswer)
+        return;
+    // Step 2: Edit context
+    console.log("\n📝 Current context:");
+    console.log("─".repeat(60));
+    console.log(feature.context);
+    console.log("─".repeat(60) + "\n");
+    const contextAnswer = await safePrompt([
+        {
+            type: 'editor',
+            name: 'newContext',
+            message: 'Edit feature context (will open in your default editor):',
+            default: feature.context,
+            validate: (input) => {
+                if (!input || !input.trim()) {
+                    return 'Context cannot be empty';
+                }
+                return true;
+            }
+        }
+    ]);
+    if (!contextAnswer)
+        return;
+    // Step 3: Confirm
+    console.log("\n📋 Summary of changes:");
+    console.log(`Status: ${feature.active ? '✅ Active' : '❌ Inactive'} → ${statusAnswer.active ? '✅ Active' : '❌ Inactive'}`);
+    console.log(`Context: ${contextAnswer.newContext === feature.context ? 'No change' : 'Updated'}`);
+    console.log();
+    const confirmAnswer = await safePrompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Save all changes?',
+            default: true
+        }
+    ]);
+    if (!confirmAnswer || !confirmAnswer.confirm) {
+        console.log("\n❌ Update cancelled.\n");
+        return;
+    }
+    writeProgress("🔄 Updating feature...");
+    const response = await context.agentApi.updateAgentFeature(context.agentId, {
+        featureName: feature.name,
+        active: statusAnswer.active,
+        featureContext: contextAnswer.newContext.trim()
+    });
+    writeSuccess(`✅ Feature "${feature.title}" updated successfully`);
+    await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+}

package/dist/commands/index.d.ts

@@ -17,3 +17,6 @@ export { adminCommand } from "./admin.js";
 export { docsCommand } from "./docs.js";
 export { channelsCommand } from "./channels.js";
 export { logsCommand } from "./logs.js";
+export { completionCommand } from "./completion.js";
+export { skillsCommand } from "./skills.js";
+export { featuresCommand } from "./features.js";

package/dist/commands/index.js

@@ -17,3 +17,6 @@ export { adminCommand } from "./admin.js";
 export { docsCommand } from "./docs.js";
 export { channelsCommand } from "./channels.js";
 export { logsCommand } from "./logs.js";
+export { completionCommand } from "./completion.js";
+export { skillsCommand } from "./skills.js";
+export { featuresCommand } from "./features.js";

package/dist/commands/persona.d.ts

@@ -6,10 +6,11 @@
  * Main persona command - manages agent persona
  *
  * Features:
- * - Environment selection (sandbox or production)
+ * - Environment selection (sandbox/staging or production)
  * - Sandbox: view, edit, save persona + create versions
  * - Production: list versions, view details, deploy versions
  *
+ * @param env - Optional environment argument ('sandbox', 'staging', or 'production')
  * @returns Promise that resolves when command completes
  */
-export declare function personaCommand(): Promise<void>;
+export declare function personaCommand(env?: string): Promise<void>;

package/dist/commands/persona.js

@@ -16,13 +16,14 @@ import { validateConfig, validateAgentConfig, } from '../utils/dev-helpers.js';
  * Main persona command - manages agent persona
  *
  * Features:
- * - Environment selection (sandbox or production)
+ * - Environment selection (sandbox/staging or production)
  * - Sandbox: view, edit, save persona + create versions
  * - Production: list versions, view details, deploy versions
  *
+ * @param env - Optional environment argument ('sandbox', 'staging', or 'production')
  * @returns Promise that resolves when command completes
  */
-export async function personaCommand() {
+export async function personaCommand(env) {
     return withErrorHandling(async () => {
         // Step 1: Load configuration first (to get agentId)
         const config = readSkillConfig();
@@ -37,27 +38,51 @@ export async function personaCommand() {
         }
         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' }
-                ]
+        let selectedEnvironment;
+        // Step 3: Check if environment was provided as argument
+        if (env) {
+            // Normalize the environment (staging is an alias for sandbox)
+            const normalizedEnv = env.toLowerCase();
+            if (normalizedEnv === 'sandbox' || normalizedEnv === 'staging') {
+                selectedEnvironment = 'sandbox';
             }
-        ]);
-        if (!envAnswer)
-            return;
+            else if (normalizedEnv === 'production') {
+                selectedEnvironment = 'production';
+            }
+            else {
+                console.error(`❌ Invalid environment: "${env}". Must be "sandbox", "staging", or "production".`);
+                console.log('\nUsage:');
+                console.log('  lua persona                  - Interactive selection');
+                console.log('  lua persona sandbox          - Manage sandbox persona directly');
+                console.log('  lua persona staging          - Manage staging persona (alias for sandbox)');
+                console.log('  lua persona production       - Manage production persona directly');
+                process.exit(1);
+            }
+        }
+        else {
+            // Step 4: Prompt for environment selection
+            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;
+            selectedEnvironment = envAnswer.environment;
+        }
         const context = {
-            environment: envAnswer.environment,
+            environment: selectedEnvironment,
             agentId,
             apiKey,
         };
-        // Step 4: Start management based on environment
-        if (envAnswer.environment === 'sandbox') {
+        // Step 5: Start management based on environment
+        if (selectedEnvironment === 'sandbox') {
             await manageSandboxPersona(context);
         }
         else {

package/dist/commands/push.d.ts

@@ -3,25 +3,21 @@
  * Orchestrates pushing skill versions to the server
  */
 /**
- * Main push command - pushes a skill version to the server.
+ * Main push command - pushes a skill or persona version to the server.
  *
  * This command performs the following steps:
- * 1. Validates configuration has required fields
- * 2. Prompts user to select a skill (if multiple skills exist)
- * 3. Prompts to confirm or update version
- * 4. Authenticates the user
- * 5. Compiles the skill (always, to ensure deploy.json is current)
- * 6. Validates deploy.json matches configuration for selected skill
- * 7. Extracts the specific skill's deploy data
- * 8. Pushes version to server
+ * 1. If type argument provided, uses it directly
+ * 2. Otherwise, prompts user to select 'skill' or 'persona'
+ * 3. Routes to appropriate push flow
  *
  * Use this command to:
- * - Upload a new version of your skill
- * - Make your skill available for testing in dev mode
- * - Prepare your skill for deployment
+ * - Upload a new version of your skill or persona
+ * - Make your skill/persona available for testing in dev mode
+ * - Prepare your skill/persona for deployment
  *
  * Note: This does NOT deploy to production. Use `lua deploy` for that.
  *
+ * @param type - Optional type argument ('skill' or 'persona')
  * @returns Promise that resolves when push completes
  */
-export declare function pushCommand(): Promise<void>;
+export declare function pushCommand(type?: string): Promise<void>;