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

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

package/dist/commands/chat.js

@@ -8,8 +8,8 @@ import { loadApiKey, checkApiKey } from '../services/auth.js';
 import { readSkillConfig } from '../utils/files.js';
 import { withErrorHandling, writeProgress, writeSuccess } from '../utils/cli.js';
 import { compileCommand } from './compile.js';
-import { pushSkillsToSandbox } from '../utils/dev-api.js';
-import { getAllSandboxSkillIds } from '../utils/sandbox-storage.js';
+import { pushSkillsToSandbox, pushProcessorsToSandbox } from '../utils/dev-api.js';
+import { getAllSandboxSkillIds, getAllSandboxPreProcessorIds, getAllSandboxPostProcessorIds } from '../utils/sandbox-storage.js';
 import ChatApi from '../api/chat.api.service.js';
 import { BASE_URLS } from '../config/constants.js';
 import { readDeployJson, validateConfig, validateDeployData, validateAgentConfig, } from '../utils/dev-helpers.js';
@@ -66,7 +66,7 @@ export async function chatCommand() {
     }, "chat");
 }
 /**
- * Sets up the sandbox environment by compiling and pushing skills
+ * Sets up the sandbox environment by compiling and pushing skills, preprocessors, and postprocessors
  */
 async function setupSandboxEnvironment(chatEnv, config) {
     writeProgress("🔄 Setting up sandbox environment...");
@@ -84,8 +84,31 @@ async function setupSandboxEnvironment(chatEnv, config) {
         process.exit(1);
     }
     writeSuccess(`✅ Pushed ${Object.keys(sandboxIds).length} skills to sandbox`);
+    // Push preprocessors and postprocessors to sandbox
+    const fs = await import('fs');
+    const path = await import('path');
+    const preprocessorsPath = path.join(process.cwd(), 'dist', 'preprocessors.json');
+    const postprocessorsPath = path.join(process.cwd(), 'dist', 'postprocessors.json');
+    let bundledPreProcessors = [];
+    let bundledPostProcessors = [];
+    if (fs.existsSync(preprocessorsPath)) {
+        bundledPreProcessors = JSON.parse(fs.readFileSync(preprocessorsPath, 'utf8'));
+    }
+    if (fs.existsSync(postprocessorsPath)) {
+        bundledPostProcessors = JSON.parse(fs.readFileSync(postprocessorsPath, 'utf8'));
+    }
+    if (bundledPreProcessors.length > 0 || bundledPostProcessors.length > 0) {
+        writeProgress("🔄 Pushing processors to sandbox...");
+        const processorCounts = await pushProcessorsToSandbox(chatEnv.apiKey, chatEnv.agentId, config, bundledPreProcessors, bundledPostProcessors, true);
+        if (processorCounts.preprocessors > 0 || processorCounts.postprocessors > 0) {
+            writeSuccess(`✅ Pushed ${processorCounts.preprocessors} preprocessor(s) and ${processorCounts.postprocessors} postprocessor(s) to sandbox`);
+        }
+    }
     // Store deploy data for skill overrides
     chatEnv.deployData = deployData;
+    // Get processor overrides for sandbox
+    chatEnv.preprocessorOverrides = await getAllSandboxPreProcessorIds(config);
+    chatEnv.postprocessorOverrides = await getAllSandboxPostProcessorIds(config);
     // Check for persona in config
     if (config.agent?.persona) {
         chatEnv.persona = config.agent.persona;
@@ -100,8 +123,10 @@ async function startChatLoop(chatEnv) {
     console.log(`Environment: ${chatEnv.type === 'sandbox' ? '🔧 Sandbox' : '🚀 Production'}`);
     console.log("Press Ctrl+C to exit");
     console.log("=".repeat(60) + "\n");
-    // Welcome message
-    console.log("🌙 Assistant: Hi there! How can I help you today?\n");
+    // Welcome message from config or default
+    const config = readSkillConfig();
+    const welcomeMessage = config?.agent?.welcomeMessage || "Hi there! How can I help you today?";
+    console.log(`🌙 Assistant: ${welcomeMessage}\n`);
     // Create readline interface
     const rl = readline.createInterface({
         input: process.stdin,
@@ -123,28 +148,41 @@ async function startChatLoop(chatEnv) {
             rl.prompt();
             return;
         }
+        // Start typing indicator
+        const typingInterval = startTypingIndicator();
+        let firstChunk = true;
         try {
-            // Show typing indicator with animated dots
-            const typingInterval = startTypingIndicator();
-            let response = null;
+            // Create a callback that stops typing on first chunk
+            const handleChunk = (chunk) => {
+                if (firstChunk) {
+                    // Stop typing indicator and show assistant label
+                    stopTypingIndicator(typingInterval);
+                    process.stdout.write('🌙 Assistant: ');
+                    firstChunk = false;
+                }
+                // Write the chunk immediately
+                process.stdout.write(chunk);
+            };
             if (chatEnv.type === 'sandbox') {
-                // Send to sandbox with skill overrides
-                response = await sendSandboxMessage(chatEnv, message);
+                // Send to sandbox with skill overrides (streaming)
+                await sendSandboxMessageStream(chatEnv, message, handleChunk);
             }
             else {
-                // Send to production
-                response = await sendProductionMessage(chatEnv, message);
+                // Send to production (streaming)
+                await sendProductionMessageStream(chatEnv, message, handleChunk);
             }
-            // Stop typing indicator
-            stopTypingIndicator(typingInterval);
-            if (response) {
-                console.log(`🌙 Assistant: ${response}\n`);
-            }
-            else {
-                console.log("🌙 Assistant: ❌ Failed to get response. Please try again.\n");
+            // If no chunks arrived, stop the typing indicator
+            if (firstChunk) {
+                stopTypingIndicator(typingInterval);
             }
+            // Add newline after response
+            console.log('\n');
         }
         catch (error) {
+            // Make sure typing indicator is stopped on error
+            if (firstChunk) {
+                stopTypingIndicator(typingInterval);
+            }
             console.error(`\n❌ Error: ${error instanceof Error ? error.message : 'Unknown error'}\n`);
         }
         rl.prompt();
@@ -179,16 +217,16 @@ function stopTypingIndicator(interval) {
     process.stdout.write('\r\x1b[K');
 }
 /**
- * Sends a message to the sandbox environment with skill overrides
+ * Sends a message to the sandbox environment with skill overrides (streaming)
  */
-async function sendSandboxMessage(chatEnv, message) {
+async function sendSandboxMessageStream(chatEnv, message, onChunk) {
     if (!chatEnv.deployData) {
-        return "❌ Sandbox environment not properly initialized.";
+        throw new Error("Sandbox environment not properly initialized.");
     }
     // Get all sandbox skill IDs for skill override
     const allSkillOverrides = await getAllSandboxSkillIds(chatEnv.deployData);
     if (allSkillOverrides.length === 0) {
-        return "❌ No sandbox skills found. Please try running the command again.";
+        throw new Error("No sandbox skills found. Please try running the command again.");
     }
     const chatRequest = {
         messages: [
@@ -198,24 +236,21 @@ async function sendSandboxMessage(chatEnv, message) {
             }
         ],
         navigate: true,
-        skillOverride: allSkillOverrides
+        skillOverride: allSkillOverrides,
+        preprocessorOverride: chatEnv.preprocessorOverrides || [],
+        postprocessorOverride: chatEnv.postprocessorOverrides || []
     };
     // Add persona override if available
     if (chatEnv.persona) {
         chatRequest.personaOverride = chatEnv.persona;
     }
     const chatApi = new ChatApi(BASE_URLS.CHAT, chatEnv.apiKey);
-    const response = await chatApi.sendMessage(chatEnv.agentId, chatRequest);
-    if (!response.success) {
-        console.error(`❌ Chat API error: ${response.error?.message || 'Unknown error'}`);
-        return null;
-    }
-    return response.data?.text || null;
+    await chatApi.sendMessageStream(chatEnv.agentId, chatRequest, onChunk);
 }
 /**
- * Sends a message to the production environment
+ * Sends a message to the production environment (streaming)
  */
-async function sendProductionMessage(chatEnv, message) {
+async function sendProductionMessageStream(chatEnv, message, onChunk) {
     const chatRequest = {
         messages: [
             {
@@ -224,13 +259,10 @@ async function sendProductionMessage(chatEnv, message) {
             }
         ],
         navigate: true,
-        skillOverride: []
+        skillOverride: [],
+        preprocessorOverride: [],
+        postprocessorOverride: []
     };
     const chatApi = new ChatApi(BASE_URLS.CHAT, chatEnv.apiKey);
-    const response = await chatApi.sendMessage(chatEnv.agentId, chatRequest);
-    if (!response.success) {
-        console.error(`❌ Chat API error: ${response.error?.message || 'Unknown error'}`);
-        return null;
-    }
-    return response.data?.text || null;
+    await chatApi.sendMessageStream(chatEnv.agentId, chatRequest, onChunk);
 }

package/dist/commands/compile.js

@@ -78,9 +78,23 @@ export async function compileCommand() {
         const tools = await detectTools(indexFile, project, skillFilePaths);
         writeProgress(`📦 Found ${tools.length} tools to bundle...`);
         // Step 3: Bundle each tool and extract metadata
+        const { preBundleJobsInSource, replaceJobPlaceholders } = await import('../utils/pre-bundle-jobs.js');
         for (const tool of tools) {
-            await bundleTool(tool, distDir);
-            await extractExecuteCode(tool, project);
+            // Step 3a: Pre-bundle any Jobs.create() in the tool source
+            const { modifiedSource, jobBundles } = await preBundleJobsInSource(tool.filePath, project, distDir);
+            // Step 3b: Bundle the tool (with placeholders for job execute functions)
+            await bundleTool(tool, distDir, modifiedSource);
+            // Step 3c: Replace placeholders in the bundled tool file
+            if (jobBundles.size > 0) {
+                const toolBundlePath = path.join(distDir, 'tools', `${tool.className}.js`);
+                if (fs.existsSync(toolBundlePath)) {
+                    let bundledToolCode = fs.readFileSync(toolBundlePath, 'utf8');
+                    bundledToolCode = replaceJobPlaceholders(bundledToolCode, jobBundles);
+                    fs.writeFileSync(toolBundlePath, bundledToolCode);
+                }
+            }
+            // Step 3d: Extract execute code
+            await extractExecuteCode(tool, project, distDir);
         }
         // Step 4: Bundle the main index file
         await bundleMainIndex(indexPath, distDir);

package/dist/commands/dev.js

@@ -7,7 +7,7 @@ import { compileCommand } from './compile.js';
 import { checkApiKey, loadApiKey } from '../services/auth.js';
 import { readSkillConfig } from '../utils/files.js';
 import { withErrorHandling, writeProgress, writeSuccess } from '../utils/cli.js';
-import { pushSkillsToSandbox } from '../utils/dev-api.js';
+import { pushSkillsToSandbox, pushProcessorsToSandbox } from '../utils/dev-api.js';
 import { createChatServer } from '../utils/dev-server.js';
 import { createFileWatcher } from '../utils/dev-watcher.js';
 import { readConfigVersion, readDeployJson, extractSkillId, validateConfig, validateDeployData, validateAgentConfig, } from '../utils/dev-helpers.js';
@@ -75,6 +75,26 @@ export async function devCommand() {
             process.exit(1);
         }
         writeSuccess(`✅ Pushed ${Object.keys(sandboxIds).length} skills to sandbox`);
+        // Step 6b: Push preprocessors and postprocessors to sandbox
+        const fs = await import('fs');
+        const path = await import('path');
+        const preprocessorsPath = path.join(process.cwd(), 'dist', 'preprocessors.json');
+        const postprocessorsPath = path.join(process.cwd(), 'dist', 'postprocessors.json');
+        let bundledPreProcessors = [];
+        let bundledPostProcessors = [];
+        if (fs.existsSync(preprocessorsPath)) {
+            bundledPreProcessors = JSON.parse(fs.readFileSync(preprocessorsPath, 'utf8'));
+        }
+        if (fs.existsSync(postprocessorsPath)) {
+            bundledPostProcessors = JSON.parse(fs.readFileSync(postprocessorsPath, 'utf8'));
+        }
+        if (bundledPreProcessors.length > 0 || bundledPostProcessors.length > 0) {
+            writeProgress("🔄 Pushing processors to sandbox...");
+            const processorCounts = await pushProcessorsToSandbox(apiKey, agentId, updatedConfig, bundledPreProcessors, bundledPostProcessors, true);
+            if (processorCounts.preprocessors > 0 || processorCounts.postprocessors > 0) {
+                writeSuccess(`✅ Pushed ${processorCounts.preprocessors} preprocessor(s) and ${processorCounts.postprocessors} postprocessor(s) to sandbox`);
+            }
+        }
         // Use the first skill's sandbox ID for the web interface
         const firstSkillName = Object.keys(sandboxIds)[0];
         const sandboxSkillId = sandboxIds[firstSkillName];
@@ -83,7 +103,8 @@ export async function devCommand() {
             process.exit(1);
         }
         // Step 7: Start web server for chat interface
-        const { server, wss, broadcastLog } = createChatServer(apiKey, agentId, skillId, sandboxSkillId, DEV_SERVER_PORT);
+        const { server, wss, broadcastLog } = createChatServer(apiKey, agentId, skillId, sandboxSkillId, DEV_SERVER_PORT, updatedConfig // Pass config for processor overrides
+        );
         // Step 8: Open browser to chat interface
         try {
             await open(`http://localhost:${DEV_SERVER_PORT}`);

package/dist/commands/push.d.ts

@@ -17,7 +17,8 @@
  *
  * Note: This does NOT deploy to production. Use `lua deploy` for that.
  *
- * @param type - Optional type argument ('skill' or 'persona')
+ * @param type - Optional type argument ('skill', 'persona', 'webhook', 'job', 'preprocessor', 'postprocessor', or 'all')
+ * @param cmdObj - Commander command object with options
  * @returns Promise that resolves when push completes
  */
-export declare function pushCommand(type?: string): Promise<void>;
+export declare function pushCommand(type?: string, cmdObj?: any): Promise<void>;