lua-cli 3.0.0-alpha.8 → 3.0.0

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,59 @@ 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}`);
+        }
+        if (!response.body) {
+            throw new Error('Response body is not readable');
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            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 and call onChunk immediately
+                        if (chunk.type === 'text-delta' && chunk.textDelta) {
+                            onChunk(chunk.textDelta);
+                        }
+                    }
+                    catch (error) {
+                        // Skip invalid JSON lines
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
 }

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

@@ -59,8 +59,9 @@ export default class ProductApi extends HttpClient implements ProductAPI {
     /**
      * Performs semantic search on products using a text query
      * @param searchQuery - The search text to find matching products
+     * @param limit - The maximum number of products to return (default: 5)
      * @returns Promise resolving to a ProductSearchInstance containing search results
      * @throws Error if the search fails or the API request is unsuccessful
      */
-    search(searchQuery: string): Promise<ProductSearchInstance>;
+    search(searchQuery: string, limit?: number): Promise<ProductSearchInstance>;
 }

package/dist/api/products.api.service.js

@@ -25,16 +25,16 @@ export default class ProductApi extends HttpClient {
      * @throws Error if the request fails or products cannot be retrieved
      */
     async get(page = 1, limit = 10) {
-        console.log('get products', page, limit, this.agentId, this.apiKey);
+        console.log("get products", page, limit, this.agentId, this.apiKey);
         const response = await this.httpGet(`/developer/agents/${this.agentId}/products?page=${page}&limit=${limit}`, {
             Authorization: `Bearer ${this.apiKey}`,
         });
-        console.log('get products response', response);
+        console.log("get products response", response);
         if (response.success) {
             return new ProductPaginationInstance(this, response);
         }
         console.error(response);
-        throw new Error(response.error?.message || 'Failed to get products');
+        throw new Error(response.error?.message || "Failed to get products");
     }
     /**
      * Retrieves a single product by its unique identifier
@@ -49,7 +49,7 @@ export default class ProductApi extends HttpClient {
         if (response.success && response.data) {
             return new ProductInstance(this, response.data);
         }
-        throw new Error(response.error?.message || 'Failed to get product');
+        throw new Error(response.error?.message || "Failed to get product");
     }
     /**
      * Creates a new product in the agent's catalog
@@ -64,7 +64,7 @@ export default class ProductApi extends HttpClient {
         if (response.success && response.data) {
             return new ProductInstance(this, response.data.product);
         }
-        throw new Error(response.error?.message || 'Failed to create product');
+        throw new Error(response.error?.message || "Failed to create product");
     }
     /**
      * Updates an existing product's information
@@ -80,7 +80,7 @@ export default class ProductApi extends HttpClient {
         if (response.success) {
             return response.data;
         }
-        throw new Error(response.error?.message || 'Failed to update product');
+        throw new Error(response.error?.message || "Failed to update product");
     }
     /**
      * Deletes a product from the agent's catalog
@@ -95,21 +95,22 @@ export default class ProductApi extends HttpClient {
         if (response.success) {
             return response.data;
         }
-        throw new Error(response.error?.message || 'Failed to delete product');
+        throw new Error(response.error?.message || "Failed to delete product");
     }
     /**
      * Performs semantic search on products using a text query
      * @param searchQuery - The search text to find matching products
+     * @param limit - The maximum number of products to return (default: 5)
      * @returns Promise resolving to a ProductSearchInstance containing search results
      * @throws Error if the search fails or the API request is unsuccessful
      */
-    async search(searchQuery) {
-        const response = await this.httpGet(`/developer/agents/${this.agentId}/products/search?searchQuery=${encodeURIComponent(searchQuery)}`, {
+    async search(searchQuery, limit = 5) {
+        const response = await this.httpGet(`/developer/agents/${this.agentId}/products/search?searchQuery=${encodeURIComponent(searchQuery)}&limit=${limit}`, {
             Authorization: `Bearer ${this.apiKey}`,
         });
         if (response.success) {
             return new ProductSearchInstance(this, response);
         }
-        throw new Error(response.error?.message || 'Failed to search products');
+        throw new Error(response.error?.message || "Failed to search products");
     }
 }

package/dist/api-exports.d.ts

@@ -402,5 +402,5 @@ export declare const AI: {
     generate(context: string, messages: import("./interfaces/chat.js").ChatMessage[], agentId?: string): Promise<string>;
 };
 export { LuaSkill, LuaTool, LuaWebhook, LuaWebhookConfig, LuaJob, LuaJobConfig, JobSchedule, PreProcessor, PreProcessorConfig, PostProcessor, PostProcessorConfig, LuaAgent, LuaAgentConfig, BasketStatus, OrderStatus, env };
-export { JobInstance };
+export { JobInstance, UserDataInstance, DataEntryInstance, ProductInstance, BasketInstance, OrderInstance };
 export { ChatHistoryMessage, ChatHistoryContent, ChatMessage, TextMessage, ImageMessage, FileMessage, PreProcessorOverride, PostProcessorOverride };

package/dist/api-exports.js

@@ -31,6 +31,11 @@ import { BasketStatus } from "./interfaces/baskets.js";
 import { OrderStatus } from "./interfaces/orders.js";
 import { getUserInstance, getDataInstance, getProductsInstance, getBasketsInstance, getOrderInstance, getJobInstance, getChatInstance, } from "./api/lazy-instances.js";
 import { JobInstance } from "./common/job.instance.js";
+import ProductInstance from "./common/product.instance.js";
+import DataEntryInstance from "./common/data.entry.instance.js";
+import UserDataInstance from "./common/user.instance.js";
+import BasketInstance from "./common/basket.instance.js";
+import OrderInstance from "./common/order.instance.js";
 export const User = {
     /**
      * Retrieves current user data.
@@ -543,4 +548,4 @@ export const AI = {
 // Export skill classes and utilities
 export { LuaSkill, LuaWebhook, LuaJob, PreProcessor, PostProcessor, LuaAgent, BasketStatus, OrderStatus, env };
 // Export instance classes
-export { JobInstance };
+export { JobInstance, UserDataInstance, DataEntryInstance, ProductInstance, BasketInstance, OrderInstance };

package/dist/commands/chat.js

@@ -123,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,
@@ -146,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();
@@ -202,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: [
@@ -230,17 +245,12 @@ async function sendSandboxMessage(chatEnv, message) {
         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: [
             {
@@ -254,10 +264,5 @@ async function sendProductionMessage(chatEnv, message) {
         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/init.js

@@ -127,14 +127,18 @@ export async function initCommand() {
         }
         // Step 5: Initialize or update project
         if (yamlExists) {
-            // Update existing YAML only
+            // Update existing YAML and LuaAgent in index.ts
             writeInfo("📝 Updating existing lua.skill.yaml with new agent...");
             updateYamlAgent(selectedAgent.agentId, selectedOrg.id, persona, welcomeMessage);
+            // Also update LuaAgent in index.ts if it exists
+            const { updateLuaAgentInIndexFile } = await import("../utils/init-helpers.js");
+            updateLuaAgentInIndexFile(process.cwd(), selectedAgent.name, persona, welcomeMessage);
             writeSuccess("✅ lua.skill.yaml updated successfully!");
+            writeSuccess("✅ LuaAgent configuration updated!");
         }
         else {
             // Full project initialization
-            const currentDir = initializeProject(selectedAgent.agentId, selectedOrg.id, persona, welcomeMessage);
+            const currentDir = initializeProject(selectedAgent.agentId, selectedOrg.id, persona, welcomeMessage, selectedAgent.name);
             // Step 6: Install dependencies
             await installDependencies(currentDir);
             writeSuccess("✅ Lua skill project initialized successfully!");
@@ -290,7 +294,11 @@ async function handleAgentSwitch(userData, apiKey, existingYaml) {
     // Update existing YAML file with new agent
     writeInfo("\n📝 Updating lua.skill.yaml with new agent...");
     updateYamlAgent(selectedAgent.agentId, selectedOrg.id, finalPersona, finalWelcomeMessage);
+    // Also update LuaAgent in index.ts if it exists
+    const { updateLuaAgentInIndexFile } = await import("../utils/init-helpers.js");
+    updateLuaAgentInIndexFile(process.cwd(), selectedAgent.name, finalPersona, finalWelcomeMessage);
     writeSuccess("✅ lua.skill.yaml updated successfully!");
+    writeSuccess("✅ LuaAgent configuration updated!");
     writeInfo("\n💡 Your project now uses the new agent. Run 'lua compile' to update your skills.\n");
 }
 /**

package/dist/index.js

@@ -16,10 +16,10 @@ const program = new Command();
 program
     .name("lua")
     .description("Lua AI - Build and deploy AI agents with superpowers")
-    .version("2.4.1")
+    .version("2.5.8")
     .addHelpText('before', `
 ------------------------------------------------------------------
-  Lua AI CLI v2.4.1 - Build and deploy AI agents with superpowers
+  Lua AI CLI v2.5.8 - Build and deploy AI agents with superpowers
 ------------------------------------------------------------------
 `)
     .addHelpText('after', `

package/dist/interfaces/message.d.ts

@@ -5,12 +5,12 @@ export type TextMessage = {
 export type ImageMessage = {
     type: "image";
     image: string;
-    mimeType: string;
+    mediaType: string;
 };
 export type FileMessage = {
     type: "file";
     data: string;
-    mimeType: string;
+    mediaType: string;
 };
 export type Message = TextMessage | ImageMessage | FileMessage;
 export interface SendMessageRequest {

package/dist/utils/agent-management.d.ts

@@ -3,7 +3,7 @@
  * Handles LuaAgent persona and welcome message synchronization with lua.skill.yaml
  */
 /**
- * Syncs the agent's persona and welcome message with lua.skill.yaml.
+ * Syncs the agent's name, persona, and welcome message with lua.skill.yaml.
  * This ensures the YAML configuration reflects the agent definition in code.
  *
  * @param agentMetadata - Agent metadata extracted from LuaAgent

package/dist/utils/agent-management.js

@@ -7,7 +7,7 @@ import path from "path";
 import yaml from "js-yaml";
 import { COMPILE_FILES, YAML_FORMAT } from '../config/compile.constants.js';
 /**
- * Syncs the agent's persona and welcome message with lua.skill.yaml.
+ * Syncs the agent's name, persona, and welcome message with lua.skill.yaml.
  * This ensures the YAML configuration reflects the agent definition in code.
  *
  * @param agentMetadata - Agent metadata extracted from LuaAgent
@@ -20,12 +20,14 @@ export async function syncAgentPersonaWithYaml(agentMetadata) {
         const yamlContent = fs.readFileSync(yamlPath, 'utf8');
         config = yaml.load(yamlContent);
     }
-    // Update agent section with persona and welcome message
+    // Update agent section with name, persona, and welcome message
     config.agent = {
         ...config.agent,
         persona: agentMetadata.persona,
         welcomeMessage: agentMetadata.welcomeMessage
     };
+    // Store agent name as a comment or in metadata (YAML doesn't have an agentName field)
+    // The agent name is primarily for the LuaAgent in code
     // Write updated YAML with consistent formatting
     const yamlContent = yaml.dump(config, {
         indent: YAML_FORMAT.INDENT,
@@ -37,7 +39,7 @@ export async function syncAgentPersonaWithYaml(agentMetadata) {
         }
     });
     fs.writeFileSync(yamlPath, yamlContent);
-    console.log(`✅ Synced agent persona to lua.skill.yaml`);
+    console.log(`✅ Synced agent configuration to lua.skill.yaml`);
 }
 /**
  * Reads the agent persona from lua.skill.yaml.

package/dist/utils/init-helpers.d.ts

@@ -17,7 +17,7 @@ export declare function getTemplateDir(): string;
  * @param welcomeMessage - Optional welcome message
  * @returns Current working directory
  */
-export declare function initializeProject(agentId: string, orgId: string, persona?: string, welcomeMessage?: string): string;
+export declare function initializeProject(agentId: string, orgId: string, persona?: string, welcomeMessage?: string, agentName?: string): string;
 /**
  * Installs npm dependencies for the project.
  *
@@ -39,3 +39,12 @@ export declare function calculatePromptLines(baseCount: number, additionalLines:
  * @param lineCount - Number of lines to clear
  */
 export declare function clearLinesIfNeeded(lineCount: number): void;
+/**
+ * Updates the LuaAgent configuration in the template's index.ts file
+ *
+ * @param projectDir - Project directory containing src/index.ts
+ * @param agentName - Name of the agent
+ * @param persona - Agent persona
+ * @param welcomeMessage - Welcome message
+ */
+export declare function updateLuaAgentInIndexFile(projectDir: string, agentName?: string, persona?: string, welcomeMessage?: string): void;

package/dist/utils/init-helpers.js

@@ -4,6 +4,7 @@
  */
 import { fileURLToPath } from "url";
 import path from "path";
+import fs from "fs";
 import { copyTemplateFiles, createSkillYaml } from "./files.js";
 import { clearPromptLines, writeProgress } from "./cli.js";
 import { execSync } from 'child_process';
@@ -26,13 +27,16 @@ export function getTemplateDir() {
  * @param welcomeMessage - Optional welcome message
  * @returns Current working directory
  */
-export function initializeProject(agentId, orgId, persona, welcomeMessage) {
+export function initializeProject(agentId, orgId, persona, welcomeMessage, agentName) {
     const templateDir = getTemplateDir();
     const currentDir = process.cwd();
     copyTemplateFiles(templateDir, currentDir);
     createSkillYaml(agentId, orgId, undefined, undefined, persona, welcomeMessage);
+    // Update LuaAgent in index.ts with agent configuration
+    updateLuaAgentInIndexFile(currentDir, agentName, persona, welcomeMessage);
     writeProgress("✅ Created lua.skill.yaml");
     writeProgress("✅ Copied template files");
+    writeProgress("✅ Updated LuaAgent configuration");
     return currentDir;
 }
 /**
@@ -71,3 +75,42 @@ export function clearLinesIfNeeded(lineCount) {
         clearPromptLines(lineCount);
     }
 }
+/**
+ * Updates the LuaAgent configuration in the template's index.ts file
+ *
+ * @param projectDir - Project directory containing src/index.ts
+ * @param agentName - Name of the agent
+ * @param persona - Agent persona
+ * @param welcomeMessage - Welcome message
+ */
+export function updateLuaAgentInIndexFile(projectDir, agentName, persona, welcomeMessage) {
+    const indexPath = path.join(projectDir, 'src', 'index.ts');
+    if (!fs.existsSync(indexPath)) {
+        // If no index.ts, skip (might be an old template structure)
+        return;
+    }
+    try {
+        let content = fs.readFileSync(indexPath, 'utf8');
+        // Check if LuaAgent exists in the file
+        if (!content.includes('new LuaAgent(')) {
+            return; // No LuaAgent to update
+        }
+        // Update agent name
+        if (agentName) {
+            content = content.replace(/name:\s*['"][^'"]*['"]/, `name: '${agentName.replace(/'/g, "\\'")}'`);
+        }
+        // Update persona
+        if (persona) {
+            content = content.replace(/(persona:\s*['"`])[\s\S]*?(['"`])/, `$1${persona.replace(/'/g, "\\'").replace(/`/g, '\\`')}$2`);
+        }
+        // Update welcome message
+        if (welcomeMessage) {
+            content = content.replace(/(welcomeMessage:\s*['"])[\s\S]*?(['"])/, `$1${welcomeMessage.replace(/'/g, "\\'")}$2`);
+        }
+        fs.writeFileSync(indexPath, content);
+    }
+    catch (error) {
+        // Silently fail - not critical
+        console.warn('Warning: Could not update LuaAgent in index.ts');
+    }
+}

package/dist/utils/pre-bundle-jobs.js

@@ -40,7 +40,7 @@ export async function preBundleJobsInSource(sourceFilePath, project, distDir) {
                 if (object.getText() === 'Jobs' && property === 'create') {
                     jobIndex++;
                     const placeholder = `${JOB_PLACEHOLDER}_${jobIndex}`;
-                    console.log(`[PreBundleJobs] Found Jobs.create() #${jobIndex}`);
+                    // console.log(`[PreBundleJobs] Found Jobs.create() #${jobIndex}`);
                     // Get the config object argument
                     const args = node.getArguments();
                     if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
@@ -51,12 +51,12 @@ export async function preBundleJobsInSource(sourceFilePath, project, distDir) {
                             const executeInitializer = executeProperty.getInitializer();
                             if (executeInitializer) {
                                 const executeCode = executeInitializer.getText();
-                                console.log(`[PreBundleJobs] Extracting execute function for bundling...`);
+                                // console.log(`[PreBundleJobs] Extracting execute function for bundling...`);
                                 // Bundle the execute function with dependencies (async)
                                 const bundlePromise = bundleJobExecuteFunction(executeCode, `job_${jobIndex}`, distDir, sourceFilePath).then(bundledCode => {
                                     if (bundledCode) {
                                         jobBundles.set(placeholder, bundledCode);
-                                        console.log(`[PreBundleJobs] ✅ Bundled job #${jobIndex} with dependencies`);
+                                        // console.log(`[PreBundleJobs] ✅ Bundled job #${jobIndex} with dependencies`);
                                     }
                                 });
                                 bundlingPromises.push(bundlePromise);
@@ -74,9 +74,9 @@ export async function preBundleJobsInSource(sourceFilePath, project, distDir) {
     });
     // Wait for all bundling to complete
     if (bundlingPromises.length > 0) {
-        console.log(`[PreBundleJobs] Waiting for ${bundlingPromises.length} job(s) to bundle...`);
+        // console.log(`[PreBundleJobs] Waiting for ${bundlingPromises.length} job(s) to bundle...`);
         await Promise.all(bundlingPromises);
-        console.log(`[PreBundleJobs] ✅ All job bundles complete`);
+        // console.log(`[PreBundleJobs] ✅ All job bundles complete`);
     }
     return { modifiedSource, jobBundles };
 }
@@ -103,7 +103,7 @@ async function bundleJobExecuteFunction(executeCode, jobName, distDir, sourceFil
             !imp.includes('api-exports') && // Exclude api-exports
             !imp.includes('../../../dist/api-exports') // Exclude direct api-exports imports
         );
-        console.log(`[PreBundleJobs] Including ${relevantImports.length} import(s) in job bundle`);
+        // console.log(`[PreBundleJobs] Including ${relevantImports.length} import(s) in job bundle`);
         // Create a TypeScript module with the execute function and all imports
         const moduleCode = `
 // Auto-generated job execute bundle
@@ -133,7 +133,7 @@ export default executeFunc;
         });
         // Read bundled code
         const bundledCode = fs.readFileSync(tempOutput, 'utf8');
-        console.log(`[PreBundleJobs] Bundle size: ${(bundledCode.length / 1024).toFixed(2)}KB`);
+        // console.log(`[PreBundleJobs] Bundle size: ${(bundledCode.length / 1024).toFixed(2)}KB`);
         // DON'T compress - just wrap for VM execution
         // Compression happens later when the entire tool is bundled
         const wrappedCode = `(async (job) => {
@@ -150,7 +150,7 @@ export default executeFunc;
         return wrappedCode;
     }
     catch (error) {
-        console.warn(`[PreBundleJobs] Error bundling job ${jobName}:`, error);
+        // console.warn(`[PreBundleJobs] Error bundling job ${jobName}:`, error);
         try {
             if (fs.existsSync(tempOutput))
                 fs.unlinkSync(tempOutput);
@@ -170,7 +170,7 @@ export function replaceJobPlaceholders(bundledCode, jobBundles) {
         // It appears as: execute: __BUNDLED_JOB_EXECUTE___1
         const placeholderPattern = new RegExp(placeholder, 'g');
         result = result.replace(placeholderPattern, bundledJobCode);
-        console.log(`[PreBundleJobs] ✅ Replaced ${placeholder} with bundled code (${(bundledJobCode.length / 1024).toFixed(1)}KB)`);
+        // console.log(`[PreBundleJobs] ✅ Replaced ${placeholder} with bundled code (${(bundledJobCode.length / 1024).toFixed(1)}KB)`);
     });
     return result;
 }

package/dist/utils/sandbox.js

@@ -231,10 +231,9 @@ export function createSandbox(options) {
                 const executeString = typeof config.execute === 'function'
                     ? config.execute.toString()
                     : config.execute;
-                console.log('IsDynamicJob', config.dynamic);
                 // Create job with version and activation
                 return await jobService.createJobInstance({
-                    name: config.name,
+                    name: config.name + '_' + Date.now(),
                     description: config.description,
                     context: config.description || '',
                     schedule: config.schedule,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lua-cli",
-  "version": "3.0.0-alpha.8",
-  "description": "Command-line interface for Lua AI platform - develop, test, and deploy LuaSkills with custom tools",
+  "version": "3.0.0",
+  "description": "Build, test, and deploy AI agents with custom tools, webhooks, and scheduled jobs. Features LuaAgent unified configuration, streaming chat, and batch deployment.",
   "readmeFilename": "README.md",
   "main": "dist/api-exports.js",
   "bin": {
@@ -72,7 +72,7 @@
     "inquirer": "^12.9.6",
     "js-yaml": "^4.1.0",
     "keytar": "^7.9.0",
-    "lua-ai-chat": "^0.0.4",
+    "lua-ai-chat": "^0.0.6",
     "lua-cli": "^2.3.0-alpha.1",
     "luaniverse": "^4.0.43",
     "node-fetch": "^3.3.2",