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

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,
@@ -124,25 +149,19 @@ async function startChatLoop(chatEnv) {
             return;
         }
         try {
-            // Show typing indicator with animated dots
-            const typingInterval = startTypingIndicator();
-            let response = null;
+            // Start showing the assistant response
+            process.stdout.write('🌙 Assistant: ');
+            let fullResponse = '';
             if (chatEnv.type === 'sandbox') {
-                // Send to sandbox with skill overrides
-                response = await sendSandboxMessage(chatEnv, message);
+                // Send to sandbox with skill overrides (streaming)
+                fullResponse = await sendSandboxMessageStream(chatEnv, message);
             }
             else {
-                // Send to production
-                response = await sendProductionMessage(chatEnv, message);
-            }
-            // Stop typing indicator
-            stopTypingIndicator(typingInterval);
-            if (response) {
-                console.log(`🌙 Assistant: ${response}\n`);
-            }
-            else {
-                console.log("🌙 Assistant: ❌ Failed to get response. Please try again.\n");
+                // Send to production (streaming)
+                fullResponse = await sendProductionMessageStream(chatEnv, message);
             }
+            // Add newline after response
+            console.log('\n');
         }
         catch (error) {
             console.error(`\n❌ Error: ${error instanceof Error ? error.message : 'Unknown error'}\n`);
@@ -179,9 +198,9 @@ 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) {
     if (!chatEnv.deployData) {
         return "❌ Sandbox environment not properly initialized.";
     }
@@ -198,24 +217,33 @@ 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;
+    let fullResponse = '';
+    try {
+        await chatApi.sendMessageStream(chatEnv.agentId, chatRequest, (chunk) => {
+            // Write each chunk to stdout as it arrives
+            process.stdout.write(chunk);
+            fullResponse += chunk;
+        });
+        return fullResponse;
+    }
+    catch (error) {
+        console.error(`\n❌ Chat API error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        return '';
     }
-    return response.data?.text || null;
 }
 /**
- * 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) {
     const chatRequest = {
         messages: [
             {
@@ -224,13 +252,22 @@ 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;
+    let fullResponse = '';
+    try {
+        await chatApi.sendMessageStream(chatEnv.agentId, chatRequest, (chunk) => {
+            // Write each chunk to stdout as it arrives
+            process.stdout.write(chunk);
+            fullResponse += chunk;
+        });
+        return fullResponse;
+    }
+    catch (error) {
+        console.error(`\n❌ Chat API error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        return '';
     }
-    return response.data?.text || null;
 }

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