lua-cli 2.5.6 → 2.5.8

package/dist/api/agent.api.service.d.ts

@@ -14,6 +14,9 @@ import { CreateSlackChannelRequest } from "../interfaces/agent.js";
 import { CreateSlackChannelResponse } from "../interfaces/agent.js";
 import { CreateEmailChannelRequest } from "../interfaces/agent.js";
 import { CreateEmailChannelResponse } from "../interfaces/agent.js";
+import { GetAgentFeaturesResponse } from "../interfaces/agent.js";
+import { UpdateAgentFeatureRequest } from "../interfaces/agent.js";
+import { UpdateAgentFeatureResponse } from "../interfaces/agent.js";
 /**
  * Agent API calls
  */
@@ -94,4 +97,46 @@ export default class AgentApi extends HttpClient {
      * @throws Error if the API request fails or the channel creation is unsuccessful
      */
     createEmailChannel(agentId: string, channelData: CreateEmailChannelRequest): Promise<ApiResponse<CreateEmailChannelResponse>>;
+    /**
+     * Retrieves all features configured for a specific agent
+     * @param agentId - The unique identifier of the agent
+     * @returns Promise resolving to an ApiResponse containing an array of agent features
+     * @throws Error if the API request fails or the agent is not found
+     * @example
+     * const features = await agentApi.getAgentFeatures('baseAgent_agent_123');
+     * features.data.features.forEach(feature => {
+     *   console.log(`${feature.title}: ${feature.active ? 'enabled' : 'disabled'}`);
+     * });
+     */
+    getAgentFeatures(agentId: string): Promise<ApiResponse<GetAgentFeaturesResponse>>;
+    /**
+     * Updates a specific feature for an agent
+     * @param agentId - The unique identifier of the agent
+     * @param featureData - The feature update configuration
+     * @param featureData.featureName - The name of the feature to update (required)
+     * @param featureData.active - Whether the feature should be enabled or disabled (optional)
+     * @param featureData.featureContext - Custom context/instructions for the feature (optional)
+     * @returns Promise resolving to an ApiResponse with success message
+     * @throws Error if the API request fails, the agent/feature is not found, or neither active nor featureContext is provided
+     * @example
+     * // Enable a feature
+     * await agentApi.updateAgentFeature('baseAgent_agent_123', {
+     *   featureName: 'inquiry',
+     *   active: true
+     * });
+     *
+     * // Update feature context
+     * await agentApi.updateAgentFeature('baseAgent_agent_123', {
+     *   featureName: 'tickets',
+     *   featureContext: 'Custom instructions for ticket handling'
+     * });
+     *
+     * // Update both
+     * await agentApi.updateAgentFeature('baseAgent_agent_123', {
+     *   featureName: 'rag',
+     *   active: true,
+     *   featureContext: 'Enhanced RAG search instructions'
+     * });
+     */
+    updateAgentFeature(agentId: string, featureData: UpdateAgentFeatureRequest): Promise<ApiResponse<UpdateAgentFeatureResponse>>;
 }

package/dist/api/agent.api.service.js

@@ -117,4 +117,58 @@ export default class AgentApi extends HttpClient {
             Authorization: `Bearer ${this.apiKey}`,
         });
     }
+    /**
+     * Retrieves all features configured for a specific agent
+     * @param agentId - The unique identifier of the agent
+     * @returns Promise resolving to an ApiResponse containing an array of agent features
+     * @throws Error if the API request fails or the agent is not found
+     * @example
+     * const features = await agentApi.getAgentFeatures('baseAgent_agent_123');
+     * features.data.features.forEach(feature => {
+     *   console.log(`${feature.title}: ${feature.active ? 'enabled' : 'disabled'}`);
+     * });
+     */
+    async getAgentFeatures(agentId) {
+        return this.httpGet(`/admin/agents/${agentId}/features`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Updates a specific feature for an agent
+     * @param agentId - The unique identifier of the agent
+     * @param featureData - The feature update configuration
+     * @param featureData.featureName - The name of the feature to update (required)
+     * @param featureData.active - Whether the feature should be enabled or disabled (optional)
+     * @param featureData.featureContext - Custom context/instructions for the feature (optional)
+     * @returns Promise resolving to an ApiResponse with success message
+     * @throws Error if the API request fails, the agent/feature is not found, or neither active nor featureContext is provided
+     * @example
+     * // Enable a feature
+     * await agentApi.updateAgentFeature('baseAgent_agent_123', {
+     *   featureName: 'inquiry',
+     *   active: true
+     * });
+     *
+     * // Update feature context
+     * await agentApi.updateAgentFeature('baseAgent_agent_123', {
+     *   featureName: 'tickets',
+     *   featureContext: 'Custom instructions for ticket handling'
+     * });
+     *
+     * // Update both
+     * await agentApi.updateAgentFeature('baseAgent_agent_123', {
+     *   featureName: 'rag',
+     *   active: true,
+     *   featureContext: 'Enhanced RAG search instructions'
+     * });
+     */
+    async updateAgentFeature(agentId, featureData) {
+        // Validate that at least one optional field is provided
+        if (featureData.active === undefined && featureData.featureContext === undefined) {
+            throw new Error('At least one of "active" or "featureContext" must be provided');
+        }
+        return this.httpPut(`/admin/agents/${agentId}/features`, featureData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
 }

package/dist/api/user.data.api.service.d.ts

@@ -1,5 +1,6 @@
 import { HttpClient } from "../common/http.client.js";
 import UserDataInstance from "../common/user.instance.js";
+import { Message } from "../interfaces/message.js";
 import { UserDataAPI } from "../types/index.js";
 export default class UserDataApi extends HttpClient implements UserDataAPI {
     private apiKey;
@@ -30,4 +31,18 @@ export default class UserDataApi extends HttpClient implements UserDataAPI {
      * @throws Error if the clear operation fails or the request is unsuccessful
      */
     clear(): Promise<any>;
+    /**
+     * Sends a message to a specific user conversation for the agent
+     * @param userId - The unique identifier of the user to send the message to
+     * @param messages - An array of messages to send (can be text, image, or file types)
+     * @returns Promise resolving to the response data from the server
+     * @throws Error if the message sending fails or the request is unsuccessful
+     */
+    sendMessage(messages: Message[]): Promise<any>;
+    /**
+     * Gets the admin user for the specific agent
+     * @returns Promise resolving to the admin user data
+     * @throws Error if the admin user cannot be retrieved or the request is unsuccessful
+     */
+    getAdminUser(): Promise<any>;
 }

package/dist/api/user.data.api.service.js

@@ -56,4 +56,35 @@ export default class UserDataApi extends HttpClient {
         }
         return {};
     }
+    /**
+     * Sends a message to a specific user conversation for the agent
+     * @param userId - The unique identifier of the user to send the message to
+     * @param messages - An array of messages to send (can be text, image, or file types)
+     * @returns Promise resolving to the response data from the server
+     * @throws Error if the message sending fails or the request is unsuccessful
+     */
+    async sendMessage(messages) {
+        const user = await this.getAdminUser();
+        const response = await this.httpPost(`/admin/agents/${this.agentId}/conversations/${user.uid}`, { messages }, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (!response.success) {
+            throw new Error(response.error?.message || 'Failed to send message');
+        }
+        return response.data;
+    }
+    /**
+     * Gets the admin user for the specific agent
+     * @returns Promise resolving to the admin user data
+     * @throws Error if the admin user cannot be retrieved or the request is unsuccessful
+     */
+    async getAdminUser() {
+        const response = await this.httpGet(`/admin`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (!response.success) {
+            throw new Error(response.error?.message || 'Failed to get admin user');
+        }
+        return response.data;
+    }
 }

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, chatCommand, chatClearCommand, envCommand, personaCommand, productionCommand, resourcesCommand, adminCommand, docsCommand, channelsCommand, logsCommand } from "../commands/index.js";
+import { configureCommand, initCommand, destroyCommand, apiKeyCommand, compileCommand, testCommand, pushCommand, deployCommand, chatCommand, chatClearCommand, envCommand, personaCommand, productionCommand, resourcesCommand, adminCommand, docsCommand, channelsCommand, logsCommand, completionCommand, skillsCommand, featuresCommand } from "../commands/index.js";
 /**
  * Sets up authentication-related commands.
  *
@@ -58,8 +58,17 @@ export function setupSkillCommands(program) {
         .action(testCommand);
     // Deployment Commands
     program
-        .command("push")
-        .description("☁️  Push skill version to server")
+        .command("push [type]")
+        .description("☁️  Push skill or persona version to server")
+        .addHelpText('after', `
+Arguments:
+  type                   Optional: 'skill' or 'persona' (prompts if not provided)
+
+Examples:
+  $ lua push             Interactive selection
+  $ lua push skill       Push a skill directly
+  $ lua push persona     Push a persona directly
+`)
         .action(pushCommand);
     program
         .command("deploy")
@@ -86,12 +95,32 @@ Examples:
         .action(chatClearCommand);
     // Configuration Commands
     program
-        .command("env")
+        .command("env [environment]")
         .description("⚙️  Manage environment variables")
+        .addHelpText('after', `
+Arguments:
+  environment            Optional: 'sandbox', 'staging', or 'production' (prompts if not provided)
+
+Examples:
+  $ lua env                    Interactive selection
+  $ lua env sandbox            Manage sandbox env vars directly
+  $ lua env staging            Manage staging env vars (alias for sandbox)
+  $ lua env production         Manage production env vars directly
+`)
         .action(envCommand);
     program
-        .command("persona")
+        .command("persona [env]")
         .description("🤖 Manage agent persona")
+        .addHelpText('after', `
+Arguments:
+  env                    Optional: 'sandbox', 'staging', or 'production' (prompts if not provided)
+
+Examples:
+  $ lua persona                Interactive selection
+  $ lua persona sandbox        Manage sandbox persona directly
+  $ lua persona staging        Manage staging persona (alias for sandbox)
+  $ lua persona production     Manage production persona directly
+`)
         .action(personaCommand);
     program
         .command("production")
@@ -117,4 +146,47 @@ Examples:
         .command("logs")
         .description("📊 View agent and skill logs")
         .action(logsCommand);
+    program
+        .command("skills [env]")
+        .description("⚙️  Manage and view skills")
+        .addHelpText('after', `
+Arguments:
+  env                    Optional: 'sandbox', 'staging', or 'production' (prompts if not provided)
+
+Examples:
+  $ lua skills                 Interactive selection
+  $ lua skills sandbox         View sandbox skills directly
+  $ lua skills staging         View staging skills (alias for sandbox)
+  $ lua skills production      Manage production skills directly
+`)
+        .action(skillsCommand);
+    program
+        .command("features")
+        .description("🎯 Manage agent features (tickets, RAG, etc.)")
+        .addHelpText('after', `
+Features:
+  • View all available features
+  • Enable/disable features
+  • Update feature context and instructions
+  • Manage capabilities like tickets, RAG search, web search, and more
+
+Examples:
+  $ lua features               View and manage all agent features
+`)
+        .action(featuresCommand);
+    program
+        .command("completion [shell]")
+        .description("🎯 Generate shell completion script")
+        .addHelpText('after', `
+Arguments:
+  shell                  Optional: 'bash', 'zsh', or 'fish' (shows instructions if not provided)
+
+Examples:
+  $ lua completion              Show installation instructions
+  $ lua completion bash         Generate bash completion script
+  $ lua completion bash >> ~/.bashrc
+  $ lua completion zsh >> ~/.zshrc
+  $ lua completion fish > ~/.config/fish/completions/lua.fish
+`)
+        .action(completionCommand);
 }

package/dist/commands/completion.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Completion Command
+ * Generates shell completion scripts for the Lua CLI
+ */
+/**
+ * Main completion command - generates shell completion scripts
+ *
+ * @param shell - Shell type (bash, zsh, fish)
+ * @returns Promise that resolves when command completes
+ */
+export declare function completionCommand(shell?: string): Promise<void>;

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>;