lua-cli 3.0.0-alpha.1 → 3.0.0-alpha.10

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

@@ -18,4 +18,12 @@ export default class ChatApi extends HttpClient {
      * @throws Error if the agent is not found or the chat request fails
      */
     sendMessage(agentId: string, chatData: ChatRequest): Promise<ApiResponse<ChatResponse>>;
+    /**
+     * Streams a message to an agent and receives chunked responses
+     * @param agentId - The unique identifier of the agent to chat with
+     * @param chatData - The chat request data including message, conversation history, and context
+     * @param onChunk - Callback function to handle each text chunk as it arrives
+     * @returns Promise resolving when stream completes
+     */
+    sendMessageStream(agentId: string, chatData: ChatRequest, onChunk: (text: string) => void): Promise<void>;
 }

package/dist/api/chat.api.service.js

@@ -21,4 +21,54 @@ export default class ChatApi extends HttpClient {
             Authorization: `Bearer ${this.apiKey}`,
         });
     }
+    /**
+     * Streams a message to an agent and receives chunked responses
+     * @param agentId - The unique identifier of the agent to chat with
+     * @param chatData - The chat request data including message, conversation history, and context
+     * @param onChunk - Callback function to handle each text chunk as it arrives
+     * @returns Promise resolving when stream completes
+     */
+    async sendMessageStream(agentId, chatData, onChunk) {
+        const response = await fetch(`${this.baseUrl}/chat/stream/${agentId}?channel=dev`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(chatData)
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error('Response body is not readable');
+        }
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            // Decode the chunk and add to buffer
+            buffer += decoder.decode(value, { stream: true });
+            // Process complete lines (chunks are separated by newlines)
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || ''; // Keep incomplete line in buffer
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const chunk = JSON.parse(line);
+                    // Only process text-delta chunks
+                    if (chunk.type === 'text-delta' && chunk.textDelta) {
+                        onChunk(chunk.textDelta);
+                    }
+                }
+                catch (error) {
+                    // Skip invalid JSON lines
+                }
+            }
+        }
+    }
 }

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

@@ -69,8 +69,8 @@ export interface JobExecutionResponse {
  * Handles all job-related API calls
  */
 export default class JobApi extends HttpClient {
-    private apiKey;
-    private agentId;
+    apiKey: string;
+    agentId: string;
     /**
      * Creates an instance of JobApi
      * @param baseUrl - The base URL for the API
@@ -92,19 +92,28 @@ export default class JobApi extends HttpClient {
      */
     getJob(jobId: string): Promise<JobInstance>;
     /**
-     * Creates a new job for the agent
-     * @param jobData - The job data including name, description, and optional context
+     * Creates a new job for the agent.
+     * Optionally creates initial version and activates the job in one call.
+     *
+     * @param jobData - The job data including name, description, schedule, and optional version
+     * @param jobData.version - If provided, creates first version automatically
+     * @param jobData.activate - If true, activates the job immediately
      * @returns Promise resolving to an ApiResponse containing the created job details
      * @throws Error if the job creation fails or validation errors occur
      */
     createJob(jobData: CreateJobDTO): Promise<ApiResponse<CreateJobResponse>>;
     /**
-    * Creates a new job for the agent
-    * @param jobData - The job data including name, description, and optional context
-    * @returns Promise resolving to an JobInstance containing the created job details
+    * Creates a new job for the agent and returns a JobInstance.
+    * Supports automatic version creation and activation.
+    *
+    * @param jobData - The job data including name, description, schedule, and optional version
+    * @param jobData.version - If provided, creates first version automatically
+    * @param jobData.activate - If true, activates the job immediately
+    * @returns Promise resolving to a JobInstance containing the created job details
     * @throws Error if the job creation fails or validation errors occur
     */
     createJobInstance(jobData: CreateJobDTO): Promise<JobInstance>;
+    private compressCode;
     /**
      * Pushes a new version of a job to production
      * @param jobId - The unique identifier of the job

package/dist/api/job.api.service.js

@@ -1,5 +1,6 @@
 import { HttpClient } from "../common/http.client.js";
 import { JobInstance } from "../common/job.instance.js";
+import { gzipSync } from "zlib";
 /**
  * Job API Service
  * Handles all job-related API calls
@@ -42,8 +43,12 @@ export default class JobApi extends HttpClient {
         throw new Error(response.error?.message || 'Failed to get job');
     }
     /**
-     * Creates a new job for the agent
-     * @param jobData - The job data including name, description, and optional context
+     * Creates a new job for the agent.
+     * Optionally creates initial version and activates the job in one call.
+     *
+     * @param jobData - The job data including name, description, schedule, and optional version
+     * @param jobData.version - If provided, creates first version automatically
+     * @param jobData.activate - If true, activates the job immediately
      * @returns Promise resolving to an ApiResponse containing the created job details
      * @throws Error if the job creation fails or validation errors occur
      */
@@ -53,12 +58,19 @@ export default class JobApi extends HttpClient {
         });
     }
     /**
-    * Creates a new job for the agent
-    * @param jobData - The job data including name, description, and optional context
-    * @returns Promise resolving to an JobInstance containing the created job details
+    * Creates a new job for the agent and returns a JobInstance.
+    * Supports automatic version creation and activation.
+    *
+    * @param jobData - The job data including name, description, schedule, and optional version
+    * @param jobData.version - If provided, creates first version automatically
+    * @param jobData.activate - If true, activates the job immediately
+    * @returns Promise resolving to a JobInstance containing the created job details
     * @throws Error if the job creation fails or validation errors occur
     */
     async createJobInstance(jobData) {
+        if (jobData.version?.executeFunction && jobData.version?.executeFunction.length > 0) {
+            jobData.version.code = this.compressCode(jobData.version.executeFunction);
+        }
         const response = await this.httpPost(`/developer/jobs/${this.agentId}`, jobData, {
             Authorization: `Bearer ${this.apiKey}`,
         });
@@ -67,6 +79,10 @@ export default class JobApi extends HttpClient {
         }
         throw new Error(response.error?.message || 'Failed to create job');
     }
+    compressCode(code) {
+        const compressed = gzipSync(code);
+        return compressed.toString('base64');
+    }
     /**
      * Pushes a new version of a job to production
      * @param jobId - The unique identifier of the job

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

@@ -59,8 +59,26 @@ export default class PostProcessorApi extends HttpClient {
     }): Promise<ApiResponse<CreatePostProcessorResponse>>;
     /**
      * Pushes a new version of a postprocessor
+     *
+     * @param postprocessorId - The postprocessor ID
+     * @param versionData - Version data including code, description, context, and async flag
+     * @param versionData.version - Version number
+     * @param versionData.code - Compressed execute function code
+     * @param versionData.executeFunction - Raw execute function code
+     * @param versionData.description - Postprocessor description
+     * @param versionData.context - Postprocessor context
+     * @param versionData.async - Async execution flag (true = background, false = blocking)
      */
-    pushPostProcessor(postprocessorId: string, versionData: any): Promise<ApiResponse<PostProcessorVersionResponse>>;
+    pushPostProcessor(postprocessorId: string, versionData: {
+        name: string;
+        version: string;
+        description?: string;
+        context?: string;
+        postprocessorId: string;
+        code: string;
+        executeFunction: string;
+        async?: boolean;
+    }): Promise<ApiResponse<PostProcessorVersionResponse>>;
     /**
      * Retrieves all versions of a specific postprocessor
      */
@@ -95,4 +113,46 @@ export default class PostProcessorApi extends HttpClient {
      * Deletes a postprocessor
      */
     deletePostProcessor(postprocessorId: string): Promise<ApiResponse<DeletePostProcessorResponse>>;
+    /**
+     * Pushes a new sandbox (dev) version of a postprocessor
+     * Creates a new sandbox version for testing without affecting production
+     *
+     * @param postprocessorId - The postprocessor ID
+     * @param versionData - Version data including code and async flag
+     * @returns Sandbox version response with sandboxId
+     */
+    pushDevPostProcessor(postprocessorId: string, versionData: {
+        name: string;
+        version?: string;
+        description?: string;
+        context?: string;
+        code: string;
+        executeFunction: string;
+        async?: boolean;
+    }): Promise<ApiResponse<{
+        versionId: string;
+        postprocessorId: string;
+        version: string;
+        createdAt: string;
+    }>>;
+    /**
+     * Updates an existing sandbox version of a postprocessor
+     *
+     * @param postprocessorId - The postprocessor ID
+     * @param sandboxVersionId - The sandbox version ID to update
+     * @param versionData - Updated version data
+     * @returns Update response
+     */
+    updateDevPostProcessor(postprocessorId: string, sandboxVersionId: string, versionData: {
+        name: string;
+        version?: string;
+        description?: string;
+        context?: string;
+        code: string;
+        executeFunction: string;
+        async?: boolean;
+    }): Promise<ApiResponse<{
+        message: string;
+        versionId: string;
+    }>>;
 }

package/dist/api/postprocessor.api.service.js

@@ -27,6 +27,15 @@ export default class PostProcessorApi extends HttpClient {
     }
     /**
      * Pushes a new version of a postprocessor
+     *
+     * @param postprocessorId - The postprocessor ID
+     * @param versionData - Version data including code, description, context, and async flag
+     * @param versionData.version - Version number
+     * @param versionData.code - Compressed execute function code
+     * @param versionData.executeFunction - Raw execute function code
+     * @param versionData.description - Postprocessor description
+     * @param versionData.context - Postprocessor context
+     * @param versionData.async - Async execution flag (true = background, false = blocking)
      */
     async pushPostProcessor(postprocessorId, versionData) {
         return this.httpPost(`/developer/postprocessors/${this.agentId}/${postprocessorId}/version`, versionData, {
@@ -73,4 +82,30 @@ export default class PostProcessorApi extends HttpClient {
             Authorization: `Bearer ${this.apiKey}`,
         });
     }
+    /**
+     * Pushes a new sandbox (dev) version of a postprocessor
+     * Creates a new sandbox version for testing without affecting production
+     *
+     * @param postprocessorId - The postprocessor ID
+     * @param versionData - Version data including code and async flag
+     * @returns Sandbox version response with sandboxId
+     */
+    async pushDevPostProcessor(postprocessorId, versionData) {
+        return this.httpPost(`/developer/postprocessors/${this.agentId}/${postprocessorId}/version/sandbox`, versionData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Updates an existing sandbox version of a postprocessor
+     *
+     * @param postprocessorId - The postprocessor ID
+     * @param sandboxVersionId - The sandbox version ID to update
+     * @param versionData - Updated version data
+     * @returns Update response
+     */
+    async updateDevPostProcessor(postprocessorId, sandboxVersionId, versionData) {
+        return this.httpPut(`/developer/postprocessors/${this.agentId}/${postprocessorId}/version/sandbox/${sandboxVersionId}`, versionData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
 }

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

@@ -59,8 +59,26 @@ export default class PreProcessorApi extends HttpClient {
     }): Promise<ApiResponse<CreatePreProcessorResponse>>;
     /**
      * Pushes a new version of a preprocessor
+     *
+     * @param preprocessorId - The preprocessor ID
+     * @param versionData - Version data including code, description, context, and async flag
+     * @param versionData.version - Version number
+     * @param versionData.code - Compressed execute function code
+     * @param versionData.executeFunction - Raw execute function code
+     * @param versionData.description - Preprocessor description
+     * @param versionData.context - Preprocessor context
+     * @param versionData.async - Async execution flag (true = background, false = blocking)
      */
-    pushPreProcessor(preprocessorId: string, versionData: any): Promise<ApiResponse<PreProcessorVersionResponse>>;
+    pushPreProcessor(preprocessorId: string, versionData: {
+        name: string;
+        version: string;
+        description?: string;
+        context?: string;
+        preprocessorId: string;
+        code: string;
+        executeFunction: string;
+        async?: boolean;
+    }): Promise<ApiResponse<PreProcessorVersionResponse>>;
     /**
      * Retrieves all versions of a specific preprocessor
      */
@@ -95,4 +113,46 @@ export default class PreProcessorApi extends HttpClient {
      * Deletes a preprocessor
      */
     deletePreProcessor(preprocessorId: string): Promise<ApiResponse<DeletePreProcessorResponse>>;
+    /**
+     * Pushes a new sandbox (dev) version of a preprocessor
+     * Creates a new sandbox version for testing without affecting production
+     *
+     * @param preprocessorId - The preprocessor ID
+     * @param versionData - Version data including code and async flag
+     * @returns Sandbox version response with sandboxId
+     */
+    pushDevPreProcessor(preprocessorId: string, versionData: {
+        name: string;
+        version?: string;
+        description?: string;
+        context?: string;
+        code: string;
+        executeFunction: string;
+        async?: boolean;
+    }): Promise<ApiResponse<{
+        versionId: string;
+        preprocessorId: string;
+        version: string;
+        createdAt: string;
+    }>>;
+    /**
+     * Updates an existing sandbox version of a preprocessor
+     *
+     * @param preprocessorId - The preprocessor ID
+     * @param sandboxVersionId - The sandbox version ID to update
+     * @param versionData - Updated version data
+     * @returns Update response
+     */
+    updateDevPreProcessor(preprocessorId: string, sandboxVersionId: string, versionData: {
+        name: string;
+        version?: string;
+        description?: string;
+        context?: string;
+        code: string;
+        executeFunction: string;
+        async?: boolean;
+    }): Promise<ApiResponse<{
+        message: string;
+        versionId: string;
+    }>>;
 }

package/dist/api/preprocessor.api.service.js

@@ -27,6 +27,15 @@ export default class PreProcessorApi extends HttpClient {
     }
     /**
      * Pushes a new version of a preprocessor
+     *
+     * @param preprocessorId - The preprocessor ID
+     * @param versionData - Version data including code, description, context, and async flag
+     * @param versionData.version - Version number
+     * @param versionData.code - Compressed execute function code
+     * @param versionData.executeFunction - Raw execute function code
+     * @param versionData.description - Preprocessor description
+     * @param versionData.context - Preprocessor context
+     * @param versionData.async - Async execution flag (true = background, false = blocking)
      */
     async pushPreProcessor(preprocessorId, versionData) {
         return this.httpPost(`/developer/preprocessors/${this.agentId}/${preprocessorId}/version`, versionData, {
@@ -73,4 +82,30 @@ export default class PreProcessorApi extends HttpClient {
             Authorization: `Bearer ${this.apiKey}`,
         });
     }
+    /**
+     * Pushes a new sandbox (dev) version of a preprocessor
+     * Creates a new sandbox version for testing without affecting production
+     *
+     * @param preprocessorId - The preprocessor ID
+     * @param versionData - Version data including code and async flag
+     * @returns Sandbox version response with sandboxId
+     */
+    async pushDevPreProcessor(preprocessorId, versionData) {
+        return this.httpPost(`/developer/preprocessors/${this.agentId}/${preprocessorId}/version/sandbox`, versionData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Updates an existing sandbox version of a preprocessor
+     *
+     * @param preprocessorId - The preprocessor ID
+     * @param sandboxVersionId - The sandbox version ID to update
+     * @param versionData - Updated version data
+     * @returns Update response
+     */
+    async updateDevPreProcessor(preprocessorId, sandboxVersionId, versionData) {
+        return this.httpPut(`/developer/preprocessors/${this.agentId}/${preprocessorId}/version/sandbox/${sandboxVersionId}`, versionData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
 }

package/dist/api-exports.d.ts

@@ -29,7 +29,7 @@
 import { LuaSkill, LuaTool, LuaWebhook, LuaWebhookConfig, LuaJob, LuaJobConfig, JobSchedule, PreProcessor, PreProcessorConfig, PostProcessor, PostProcessorConfig, LuaAgent, LuaAgentConfig, env } from "./types/skill.js";
 import { Basket, BasketStatus, UpdateBasketMetadataResponse } from "./interfaces/baskets.js";
 import { OrderResponse, OrderStatus } from "./interfaces/orders.js";
-import { ChatHistoryMessage, ChatHistoryContent } from "./interfaces/chat.js";
+import { ChatHistoryMessage, ChatHistoryContent, ChatMessage, TextMessage, ImageMessage, FileMessage, PreProcessorOverride, PostProcessorOverride } from "./interfaces/chat.js";
 import { JobInstance } from "./common/job.instance.js";
 import { DeleteProductResponse, Product } from "./interfaces/product.js";
 import ProductInstance from "./common/product.instance.js";
@@ -291,6 +291,13 @@ export declare const Jobs: {
      * Creates a new job dynamically from within a tool.
      * This allows tools to schedule one-time or recurring jobs programmatically.
      *
+     * **What this does:**
+     * The server handles everything in ONE API call:
+     * 1. Creates the job
+     * 2. Creates version 1.0.0 with your execute function
+     * 3. Optionally activates the job (if activate: true)
+     * 4. Returns a JobInstance for manipulation
+     *
      * @param config - Job configuration
      * @param config.name - Unique job name
      * @param config.description - Job description
@@ -298,26 +305,37 @@ export declare const Jobs: {
      * @param config.execute - Async function to execute
      * @param config.timeout - Optional timeout in seconds
      * @param config.retry - Optional retry configuration
-     * @returns Promise resolving to created job details
+     * @param config.metadata - Optional metadata
+     * @returns Promise resolving to JobInstance (already created, versioned, and activated)
      *
      * @example
      * ```typescript
      * // Create a one-time job to check basket in 3 hours
-     * await Jobs.create({
+     * const job = await Jobs.create({
      *   name: `check-basket-${basketId}`,
      *   description: 'Check if basket was abandoned',
      *   schedule: {
      *     type: 'once',
      *     executeAt: new Date(Date.now() + 3 * 60 * 60 * 1000)
      *   },
-     *   execute: async () => {
-     *     const basket = await Baskets.getById(basketId);
+     *   metadata: {
+     *     basketId: basketId,
+     *     checkType: 'abandoned-cart'
+     *   },
+     *   execute: async (job, user) => {
+     *     // Access user context and metadata
+     *     console.log('Checking basket for user:', user.name);
+     *     console.log('Basket ID from metadata:', metadata?.basketId);
+     *
+     *     const basket = await Baskets.getById(metadata.basketId);
      *     if (basket.status === 'active') {
      *       // Send reminder
      *     }
      *     return { checked: true };
      *   }
      * });
+     * // Job is now created, versioned as 1.0.0, and activated!
+     * console.log(`Job ${job.jobId} is active: ${job.active}`);
      * ```
      */
     create(config: {
@@ -331,6 +349,8 @@ export declare const Jobs: {
             backoffSeconds?: number;
         };
         metadata?: Record<string, any>;
+        /** Auto-activate the job after creation (default: true) */
+        activate?: boolean;
     }): Promise<JobInstance>;
     /**
      * Retrieves a job by its unique identifier
@@ -383,4 +403,4 @@ export declare const AI: {
 };
 export { LuaSkill, LuaTool, LuaWebhook, LuaWebhookConfig, LuaJob, LuaJobConfig, JobSchedule, PreProcessor, PreProcessorConfig, PostProcessor, PostProcessorConfig, LuaAgent, LuaAgentConfig, BasketStatus, OrderStatus, env };
 export { JobInstance };
-export { ChatHistoryMessage, ChatHistoryContent };
+export { ChatHistoryMessage, ChatHistoryContent, ChatMessage, TextMessage, ImageMessage, FileMessage, PreProcessorOverride, PostProcessorOverride };

package/dist/api-exports.js

@@ -378,6 +378,13 @@ export const Jobs = {
      * Creates a new job dynamically from within a tool.
      * This allows tools to schedule one-time or recurring jobs programmatically.
      *
+     * **What this does:**
+     * The server handles everything in ONE API call:
+     * 1. Creates the job
+     * 2. Creates version 1.0.0 with your execute function
+     * 3. Optionally activates the job (if activate: true)
+     * 4. Returns a JobInstance for manipulation
+     *
      * @param config - Job configuration
      * @param config.name - Unique job name
      * @param config.description - Job description
@@ -385,72 +392,78 @@ export const Jobs = {
      * @param config.execute - Async function to execute
      * @param config.timeout - Optional timeout in seconds
      * @param config.retry - Optional retry configuration
-     * @returns Promise resolving to created job details
+     * @param config.metadata - Optional metadata
+     * @returns Promise resolving to JobInstance (already created, versioned, and activated)
      *
      * @example
      * ```typescript
      * // Create a one-time job to check basket in 3 hours
-     * await Jobs.create({
+     * const job = await Jobs.create({
      *   name: `check-basket-${basketId}`,
      *   description: 'Check if basket was abandoned',
      *   schedule: {
      *     type: 'once',
      *     executeAt: new Date(Date.now() + 3 * 60 * 60 * 1000)
      *   },
-     *   execute: async () => {
-     *     const basket = await Baskets.getById(basketId);
+     *   metadata: {
+     *     basketId: basketId,
+     *     checkType: 'abandoned-cart'
+     *   },
+     *   execute: async (job, user) => {
+     *     // Access user context and metadata
+     *     console.log('Checking basket for user:', user.name);
+     *     console.log('Basket ID from metadata:', metadata?.basketId);
+     *
+     *     const basket = await Baskets.getById(metadata.basketId);
      *     if (basket.status === 'active') {
      *       // Send reminder
      *     }
      *     return { checked: true };
      *   }
      * });
+     * // Job is now created, versioned as 1.0.0, and activated!
+     * console.log(`Job ${job.jobId} is active: ${job.active}`);
      * ```
      */
     async create(config) {
         const instance = await getJobInstance();
         // Convert the execute function to a string
         const executeString = config.execute.toString();
-        // Step 1: Create the job
+        console.log('Creating Job');
+        // Create the job with initial version and activation in one call
         const createResult = await instance.createJobInstance({
+            dynamic: true,
             name: config.name,
             description: config.description,
             context: config.description || '',
             schedule: config.schedule,
             timeout: config.timeout,
             retry: config.retry,
-            metadata: config.metadata
+            metadata: config.metadata,
+            // Include initial version data for automatic version creation
+            version: {
+                version: '1.0.0',
+                description: config.description,
+                context: config.description || '',
+                code: '', // Will be set by server
+                executeFunction: executeString,
+                timeout: config.timeout,
+                retry: config.retry,
+                metadata: config.metadata
+            },
+            // Activate immediately
+            activate: config.activate ?? true
         });
         const jobId = createResult.jobId;
-        // Step 2: Push the initial version with execute function
-        const pushResult = await instance.pushJob(jobId, {
-            name: config.name,
-            version: '1.0.0',
-            description: config.description,
-            context: config.description || '',
-            jobId: jobId,
-            schedule: config.schedule,
-            timeout: config.timeout,
-            retry: config.retry,
-            executeFunction: executeString,
-            metadata: config.metadata
-        });
-        if (!pushResult.success) {
-            throw new Error(`Failed to push job version: ${pushResult.error?.message}`);
-        }
-        // Step 3: Activate the job so it starts running
-        const activateResult = await instance.activateJob(jobId);
-        if (!activateResult.success) {
-            console.warn(`Job created but activation failed: ${activateResult.error?.message}`);
-        }
-        // Step 4: Return a JobInstance for easy manipulation
+        // Server has created the job, version, and activated it
+        // Return a JobInstance for easy manipulation
         return new JobInstance(instance, {
             id: jobId,
             jobId: jobId,
             name: config.name,
             schedule: config.schedule,
             metadata: config.metadata || {},
-            active: activateResult.success
+            active: config.activate ?? true
         });
     },
     /**

package/dist/cli/command-definitions.js

@@ -70,16 +70,23 @@ Examples:
     program
         .command("push [type]")
         .description("☁️  Push skill, webhook, job, or persona version to server")
+        .option('--force', 'Skip all confirmation prompts (auto-confirm)')
+        .option('--auto-deploy', 'Automatically deploy to production after push')
         .addHelpText('after', `
 Arguments:
-  type                   Optional: 'skill', 'webhook', 'job', or 'persona' (prompts if not provided)
+  type                   Optional: 'skill', 'webhook', 'job', 'preprocessor', 'postprocessor', 'persona', or 'all' (prompts if not provided)
+
+Options:
+  --force                Skip all confirmation prompts
+  --auto-deploy          Automatically deploy to production after push
 
 Examples:
-  $ lua push             Interactive selection
-  $ lua push skill       Push a skill directly
-  $ lua push webhook     Push a webhook directly
-  $ lua push job         Push a job directly
-  $ lua push persona     Push a persona directly
+  $ lua push                        Interactive selection
+  $ lua push skill                  Push a skill directly
+  $ lua push webhook                Push a webhook directly
+  $ lua push job                    Push a job directly
+  $ lua push all --force            Push all components from YAML without prompts
+  $ lua push all --force --auto-deploy   Push and deploy all to production
 `)
         .action(pushCommand);
     program