lua-cli 2.5.7 → 3.0.0-alpha.1

package/dist/commands/completion.js

@@ -0,0 +1,209 @@
+/**
+ * Completion Command
+ * Generates shell completion scripts for the Lua CLI
+ */
+import { withErrorHandling } from '../utils/cli.js';
+/**
+ * Bash completion script
+ */
+const BASH_COMPLETION = `# Bash completion for lua CLI
+_lua_completion() {
+    local cur prev commands
+    COMPREPLY=()
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    
+    # Main commands
+    commands="auth init compile test push deploy chat env persona production resources admin docs channels logs skills features completion"
+    
+    # Subcommands
+    case "\${prev}" in
+        lua)
+            COMPREPLY=( $(compgen -W "\${commands}" -- \${cur}) )
+            return 0
+            ;;
+        auth)
+            COMPREPLY=( $(compgen -W "configure logout key" -- \${cur}) )
+            return 0
+            ;;
+        push)
+            COMPREPLY=( $(compgen -W "skill persona" -- \${cur}) )
+            return 0
+            ;;
+        env)
+            COMPREPLY=( $(compgen -W "sandbox staging production" -- \${cur}) )
+            return 0
+            ;;
+        persona)
+            COMPREPLY=( $(compgen -W "sandbox staging production" -- \${cur}) )
+            return 0
+            ;;
+        skills)
+            COMPREPLY=( $(compgen -W "sandbox staging production" -- \${cur}) )
+            return 0
+            ;;
+        chat)
+            COMPREPLY=( $(compgen -W "clear" -- \${cur}) )
+            return 0
+            ;;
+        completion)
+            COMPREPLY=( $(compgen -W "bash zsh fish" -- \${cur}) )
+            return 0
+            ;;
+    esac
+}
+
+complete -F _lua_completion lua
+`;
+/**
+ * Zsh completion script
+ */
+const ZSH_COMPLETION = `#compdef lua
+
+# Zsh completion for lua CLI
+_lua() {
+    local line state
+
+    _arguments -C \\
+        "1: :(auth init compile test push deploy chat env persona production resources admin docs channels logs skills features completion)" \\
+        "*::arg:->args"
+
+    case $line[1] in
+        auth)
+            _arguments "1: :(configure logout key)"
+            ;;
+        push)
+            _arguments "1: :(skill persona)"
+            ;;
+        env)
+            _arguments "1: :(sandbox staging production)"
+            ;;
+        persona)
+            _arguments "1: :(sandbox staging production)"
+            ;;
+        skills)
+            _arguments "1: :(sandbox staging production)"
+            ;;
+        chat)
+            _arguments "1: :(clear)"
+            ;;
+        completion)
+            _arguments "1: :(bash zsh fish)"
+            ;;
+    esac
+}
+
+_lua
+`;
+/**
+ * Fish completion script
+ */
+const FISH_COMPLETION = `# Fish completion for lua CLI
+
+# Main commands
+complete -c lua -f -n "__fish_use_subcommand" -a "auth" -d "Authentication management"
+complete -c lua -f -n "__fish_use_subcommand" -a "init" -d "Initialize a new project"
+complete -c lua -f -n "__fish_use_subcommand" -a "compile" -d "Compile skill"
+complete -c lua -f -n "__fish_use_subcommand" -a "test" -d "Test skill tools"
+complete -c lua -f -n "__fish_use_subcommand" -a "push" -d "Push skill or persona"
+complete -c lua -f -n "__fish_use_subcommand" -a "deploy" -d "Deploy to production"
+complete -c lua -f -n "__fish_use_subcommand" -a "chat" -d "Interactive chat"
+complete -c lua -f -n "__fish_use_subcommand" -a "env" -d "Manage environment"
+complete -c lua -f -n "__fish_use_subcommand" -a "persona" -d "Manage persona"
+complete -c lua -f -n "__fish_use_subcommand" -a "production" -d "View production"
+complete -c lua -f -n "__fish_use_subcommand" -a "resources" -d "Manage resources"
+complete -c lua -f -n "__fish_use_subcommand" -a "admin" -d "Open admin dashboard"
+complete -c lua -f -n "__fish_use_subcommand" -a "docs" -d "Open documentation"
+complete -c lua -f -n "__fish_use_subcommand" -a "channels" -d "Manage channels"
+complete -c lua -f -n "__fish_use_subcommand" -a "logs" -d "View logs"
+complete -c lua -f -n "__fish_use_subcommand" -a "skills" -d "Manage skills"
+complete -c lua -f -n "__fish_use_subcommand" -a "features" -d "Manage agent features"
+complete -c lua -f -n "__fish_use_subcommand" -a "completion" -d "Generate completion script"
+
+# Auth subcommands
+complete -c lua -f -n "__fish_seen_subcommand_from auth" -a "configure" -d "Set up API key"
+complete -c lua -f -n "__fish_seen_subcommand_from auth" -a "logout" -d "Delete API key"
+complete -c lua -f -n "__fish_seen_subcommand_from auth" -a "key" -d "Display API key"
+
+# Push subcommands
+complete -c lua -f -n "__fish_seen_subcommand_from push" -a "skill" -d "Push a skill"
+complete -c lua -f -n "__fish_seen_subcommand_from push" -a "persona" -d "Push a persona"
+
+# Env subcommands
+complete -c lua -f -n "__fish_seen_subcommand_from env" -a "sandbox" -d "Manage sandbox env vars"
+complete -c lua -f -n "__fish_seen_subcommand_from env" -a "staging" -d "Manage staging env vars"
+complete -c lua -f -n "__fish_seen_subcommand_from env" -a "production" -d "Manage production env vars"
+
+# Persona subcommands
+complete -c lua -f -n "__fish_seen_subcommand_from persona" -a "sandbox" -d "Manage sandbox persona"
+complete -c lua -f -n "__fish_seen_subcommand_from persona" -a "staging" -d "Manage staging persona"
+complete -c lua -f -n "__fish_seen_subcommand_from persona" -a "production" -d "Manage production persona"
+
+# Skills subcommands
+complete -c lua -f -n "__fish_seen_subcommand_from skills" -a "sandbox" -d "View sandbox skills"
+complete -c lua -f -n "__fish_seen_subcommand_from skills" -a "staging" -d "View staging skills"
+complete -c lua -f -n "__fish_seen_subcommand_from skills" -a "production" -d "Manage production skills"
+
+# Chat subcommands
+complete -c lua -f -n "__fish_seen_subcommand_from chat" -a "clear" -d "Clear history"
+
+# Completion subcommands
+complete -c lua -f -n "__fish_seen_subcommand_from completion" -a "bash" -d "Generate bash completion"
+complete -c lua -f -n "__fish_seen_subcommand_from completion" -a "zsh" -d "Generate zsh completion"
+complete -c lua -f -n "__fish_seen_subcommand_from completion" -a "fish" -d "Generate fish completion"
+`;
+/**
+ * Main completion command - generates shell completion scripts
+ *
+ * @param shell - Shell type (bash, zsh, fish)
+ * @returns Promise that resolves when command completes
+ */
+export async function completionCommand(shell) {
+    return withErrorHandling(async () => {
+        // If no shell specified, show instructions
+        if (!shell) {
+            console.log(`
+🎯 Lua CLI Shell Completion
+
+To enable autocomplete, run one of the following commands based on your shell:
+
+Bash:
+  $ lua completion bash >> ~/.bashrc
+  $ source ~/.bashrc
+
+Zsh:
+  $ lua completion zsh >> ~/.zshrc
+  $ source ~/.zshrc
+
+Fish:
+  $ lua completion fish > ~/.config/fish/completions/lua.fish
+
+Or manually:
+  $ lua completion bash    # Output bash completion script
+  $ lua completion zsh     # Output zsh completion script
+  $ lua completion fish    # Output fish completion script
+
+Then follow the instructions above to add it to your shell configuration.
+`);
+            return;
+        }
+        // Validate shell type
+        const validShells = ['bash', 'zsh', 'fish'];
+        if (!validShells.includes(shell.toLowerCase())) {
+            console.error(`❌ Invalid shell: "${shell}". Must be one of: ${validShells.join(', ')}`);
+            process.exit(1);
+        }
+        // Output the appropriate completion script
+        switch (shell.toLowerCase()) {
+            case 'bash':
+                console.log(BASH_COMPLETION);
+                break;
+            case 'zsh':
+                console.log(ZSH_COMPLETION);
+                break;
+            case 'fish':
+                console.log(FISH_COMPLETION);
+                break;
+        }
+    }, "completion");
+}

package/dist/commands/env.d.ts

@@ -6,7 +6,7 @@
  * Main env command - manages environment variables
  *
  * Features:
- * - Environment selection (sandbox or production)
+ * - Environment selection (sandbox/staging or production)
  * - List all environment variables
  * - Add new variables
  * - Update existing variables
@@ -14,6 +14,7 @@
  * - Sandbox: manages .env file
  * - Production: uses API endpoints
  *
+ * @param env - Optional environment argument ('sandbox', 'staging', or 'production')
  * @returns Promise that resolves when command completes
  */
-export declare function envCommand(): Promise<void>;
+export declare function envCommand(env?: string): Promise<void>;

package/dist/commands/env.js

@@ -15,7 +15,7 @@ import DeveloperApi from '../api/developer.api.service.js';
  * Main env command - manages environment variables
  *
  * Features:
- * - Environment selection (sandbox or production)
+ * - Environment selection (sandbox/staging or production)
  * - List all environment variables
  * - Add new variables
  * - Update existing variables
@@ -23,34 +23,59 @@ import DeveloperApi from '../api/developer.api.service.js';
  * - Sandbox: manages .env file
  * - Production: uses API endpoints
  *
+ * @param env - Optional environment argument ('sandbox', 'staging', or 'production')
  * @returns Promise that resolves when command completes
  */
-export async function envCommand() {
+export async function envCommand(env) {
     return withErrorHandling(async () => {
         // Step 1: Load configuration
         const config = readSkillConfig();
         validateConfig(config);
         validateAgentConfig(config);
         const agentId = config.agent.agentId;
-        // Step 2: Select environment
-        const { environment } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'environment',
-                message: 'Select environment:',
-                choices: [
-                    { name: '🔧 Sandbox (.env file)', value: 'sandbox' },
-                    { name: '🚀 Production (API)', value: 'production' }
-                ]
+        let selectedEnvironment;
+        // Step 2: 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';
             }
-        ]);
+            else if (normalizedEnv === 'production') {
+                selectedEnvironment = 'production';
+            }
+            else {
+                console.error(`❌ Invalid environment: "${env}". Must be "sandbox", "staging", or "production".`);
+                console.log('\nUsage:');
+                console.log('  lua env                      - Interactive selection');
+                console.log('  lua env sandbox              - Manage sandbox env vars directly');
+                console.log('  lua env staging              - Manage staging env vars (alias for sandbox)');
+                console.log('  lua env production           - Manage production env vars directly');
+                process.exit(1);
+            }
+        }
+        else {
+            // Step 3: Prompt for environment selection
+            const { environment } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'environment',
+                    message: 'Select environment:',
+                    choices: [
+                        { name: '🔧 Sandbox (.env file)', value: 'sandbox' },
+                        { name: '🚀 Production (API)', value: 'production' }
+                    ]
+                }
+            ]);
+            selectedEnvironment = environment;
+        }
         let context = {
-            environment,
+            environment: selectedEnvironment,
             agentId,
             apiKey: '',
         };
-        // Step 3: Authenticate (needed for production)
-        if (environment === 'production') {
+        // Step 4: Authenticate (needed for production)
+        if (selectedEnvironment === 'production') {
             const apiKey = await loadApiKey();
             if (!apiKey) {
                 console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
@@ -61,7 +86,7 @@ export async function envCommand() {
             context.developerApi = new DeveloperApi(BASE_URLS.API, apiKey, agentId);
             writeProgress("✅ Authenticated");
         }
-        // Step 4: Start management loop
+        // Step 5: Start management loop
         await manageEnvironmentVariables(context);
     }, "env");
 }

package/dist/commands/features.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Features Command
+ * Manages agent features (tickets, RAG, webSearch, etc.)
+ */
+/**
+ * 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 declare function featuresCommand(): Promise<void>;

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...' }]);
+}