lua-cli 3.0.2-alpha.2 → 3.0.2-alpha.4

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

@@ -25,15 +25,12 @@ 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);
         const response = await this.httpGet(`/developer/agents/${this.agentId}/products?page=${page}&limit=${limit}`, {
             Authorization: `Bearer ${this.apiKey}`,
         });
-        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");
     }
     /**

package/dist/api-exports.d.ts

@@ -131,11 +131,11 @@ export declare const Products: {
     /**
      * Retrieves products with pagination.
      *
-     * @param limit - Items per page
      * @param page - Page number
+     * @param limit - Items per page
      * @returns Promise resolving to product list
      */
-    get(limit?: number, page?: number): Promise<ProductPaginationInstance>;
+    get(page?: number, limit?: number): Promise<ProductPaginationInstance>;
     /**
      * Creates a new product.
      *

package/dist/api-exports.js

@@ -157,13 +157,13 @@ export const Products = {
     /**
      * Retrieves products with pagination.
      *
-     * @param limit - Items per page
      * @param page - Page number
+     * @param limit - Items per page
      * @returns Promise resolving to product list
      */
-    async get(limit, page) {
+    async get(page, limit) {
         const instance = await getProductsInstance();
-        return instance.get(limit, page);
+        return instance.get(page, limit);
     },
     /**
      * Creates a new product.

package/dist/cli/command-definitions.js

@@ -51,6 +51,7 @@ export function setupSkillCommands(program) {
     program
         .command("compile")
         .description("📦 Compile skill to deployable format")
+        .option("--debug", "Enable debug mode with verbose logging and temp file preservation")
         .action(compileCommand);
     program
         .command("test [type]")

package/dist/commands/compile.d.ts

@@ -27,6 +27,9 @@
  * - Skills deleted from code are removed from YAML
  * - Skills not in YAML are deleted from server (or deactivated if they have versions)
  *
+ * @param options - Command options including debug flag
  * @returns Promise that resolves when compilation is complete
  */
-export declare function compileCommand(): Promise<void>;
+export declare function compileCommand(options?: {
+    debug?: boolean;
+}): Promise<void>;

package/dist/commands/compile.js

@@ -43,17 +43,43 @@ import { syncAgentPersonaWithYaml } from '../utils/agent-management.js';
  * - Skills deleted from code are removed from YAML
  * - Skills not in YAML are deleted from server (or deactivated if they have versions)
  *
+ * @param options - Command options including debug flag
  * @returns Promise that resolves when compilation is complete
  */
-export async function compileCommand() {
+export async function compileCommand(options) {
     return withErrorHandling(async () => {
+        const debugMode = options?.debug || process.env.LUA_DEBUG === 'true';
+        if (debugMode) {
+            console.log('🐛 Debug mode enabled');
+            console.log('   - Verbose logging: ON');
+            console.log('   - Temp file preservation: ON');
+            console.log('   - Full error stacks: ON\n');
+        }
         writeProgress("🔨 Compiling Lua skill...");
+        // Track compilation issues
+        const compilationWarnings = [];
+        const failedBundles = [];
+        const startTime = Date.now();
         // Step 1: Prepare output directories
+        if (debugMode)
+            console.log('📁 Preparing output directories...');
         const { distDir, luaDir } = prepareOutputDirectories();
+        if (debugMode)
+            console.log(`   ✓ Created: ${distDir}`);
+        if (debugMode)
+            console.log(`   ✓ Created: ${luaDir}\n`);
         // Step 2: Analyze TypeScript project and detect tools
+        if (debugMode)
+            console.log('🔍 Finding index file...');
         const indexPath = findIndexFile();
+        if (debugMode)
+            console.log(`   ✓ Found: ${indexPath}\n`);
+        if (debugMode)
+            console.log('📚 Creating TypeScript project...');
         const project = createTypeScriptProject();
         const indexFile = project.addSourceFileAtPath(indexPath);
+        if (debugMode)
+            console.log(`   ✓ Loaded source file\n`);
         // Step 2a: Check for LuaAgent (unified agent configuration)
         writeProgress("🔍 Checking for LuaAgent configuration...");
         const { extractLuaAgentMetadata, resolveLuaAgentReferences, getSkillFilePaths } = await import('../utils/compile.js');
@@ -69,7 +95,7 @@ export async function compileCommand() {
             resolvedAgentData = resolveLuaAgentReferences(agentMetadata, indexFile, project);
             // Get file paths where skills are defined so we can scan them for tools
             skillFilePaths = getSkillFilePaths(agentMetadata, indexFile);
-            writeProgress(`📦 Agent contains: ${resolvedAgentData.skills.length} skill(s), ${resolvedAgentData.webhooks.length} webhook(s), ${resolvedAgentData.jobs.length} job(s), ${resolvedAgentData.preProcessors.length} preprocessor(s), ${resolvedAgentData.postProcessors.length} postprocessor(s)`);
+            writeProgress(`📦 Agent contains: ${resolvedAgentData?.skills?.length || 0} skill(s), ${resolvedAgentData?.webhooks?.length || 0} webhook(s), ${resolvedAgentData?.jobs?.length || 0} job(s), ${resolvedAgentData?.preProcessors?.length || 0} preprocessor(s), ${resolvedAgentData?.postProcessors?.length || 0} postprocessor(s)`);
         }
         else {
             writeProgress(`ℹ️  No LuaAgent found, using legacy detection for individual components`);
@@ -80,21 +106,41 @@ export async function compileCommand() {
         // Step 3: Bundle each tool and extract metadata
         const { preBundleJobsInSource, replaceJobPlaceholders } = await import('../utils/pre-bundle-jobs.js');
         for (const tool of tools) {
+            if (debugMode)
+                console.log(`\n🔧 Processing tool: ${tool.className}`);
+            if (debugMode)
+                console.log(`   File: ${tool.filePath}`);
             // Step 3a: Pre-bundle any Jobs.create() in the tool source
+            const toolStartTime = Date.now();
             const { modifiedSource, jobBundles } = await preBundleJobsInSource(tool.filePath, project, distDir);
+            if (debugMode && jobBundles.size > 0) {
+                console.log(`   ✓ Found ${jobBundles.size} nested job(s) to pre-bundle`);
+            }
             // Step 3b: Bundle the tool (with placeholders for job execute functions)
-            await bundleTool(tool, distDir, modifiedSource);
+            await bundleTool(tool, distDir, modifiedSource, debugMode);
             // 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');
+                    const beforeSize = bundledToolCode.length;
                     bundledToolCode = replaceJobPlaceholders(bundledToolCode, jobBundles);
+                    const afterSize = bundledToolCode.length;
+                    if (debugMode)
+                        console.log(`   ✓ Replaced placeholders (+${afterSize - beforeSize} bytes)`);
                     fs.writeFileSync(toolBundlePath, bundledToolCode);
                 }
             }
             // Step 3d: Extract execute code
             await extractExecuteCode(tool, project, distDir);
+            if (debugMode) {
+                const toolTime = Date.now() - toolStartTime;
+                const bundledPath = path.join(distDir, 'tools', `${tool.className}.js`);
+                if (fs.existsSync(bundledPath)) {
+                    const size = fs.statSync(bundledPath).size;
+                    console.log(`   ✓ Bundled: ${(size / 1024).toFixed(2)}KB in ${toolTime}ms`);
+                }
+            }
         }
         // Step 4: Bundle the main index file
         await bundleMainIndex(indexPath, distDir);
@@ -119,8 +165,15 @@ export async function compileCommand() {
             writeProgress(`📦 Found ${webhooksMetadata.length} webhook(s)...`);
             // Bundle each webhook (extract execute function and schemas)
             for (const webhook of webhooksMetadata) {
-                const bundled = await bundleWebhook(webhook, indexFile, distDir, project);
+                if (debugMode)
+                    console.log(`\n🌐 Processing webhook: ${webhook.name}`);
+                const webhookStartTime = Date.now();
+                const bundled = await bundleWebhook(webhook, indexFile, distDir, project, debugMode);
                 bundledWebhooks.push(bundled);
+                if (debugMode) {
+                    const webhookTime = Date.now() - webhookStartTime;
+                    console.log(`   ✓ Completed in ${webhookTime}ms`);
+                }
             }
             // Ensure webhooks exist in YAML with valid IDs
             const configForWebhooks = readSkillConfig(); // Re-read for webhooks
@@ -141,8 +194,15 @@ export async function compileCommand() {
             writeProgress(`📦 Found ${jobsMetadata.length} job(s)...`);
             // Bundle each job (extract execute function)
             for (const job of jobsMetadata) {
-                const bundled = await bundleJob(job, indexFile, distDir, project);
+                if (debugMode)
+                    console.log(`\n⚙️  Processing job: ${job.name}`);
+                const jobStartTime = Date.now();
+                const bundled = await bundleJob(job, indexFile, distDir, project, debugMode);
                 bundledJobs.push(bundled);
+                if (debugMode) {
+                    const jobTime = Date.now() - jobStartTime;
+                    console.log(`   ✓ Completed in ${jobTime}ms`);
+                }
             }
             // Ensure jobs exist in YAML with valid IDs
             const configForJobs = readSkillConfig(); // Re-read for jobs
@@ -162,7 +222,9 @@ export async function compileCommand() {
         if (preprocessorsMetadata.length > 0) {
             writeProgress(`📦 Found ${preprocessorsMetadata.length} preprocessor(s)...`);
             for (const preprocessor of preprocessorsMetadata) {
-                const bundled = await bundlePreProcessor(preprocessor, indexFile, distDir, project);
+                if (debugMode)
+                    console.log(`\n⚡ Processing preprocessor: ${preprocessor.name}`);
+                const bundled = await bundlePreProcessor(preprocessor, indexFile, distDir, project, debugMode);
                 bundledPreProcessors.push(bundled);
             }
             // Ensure preprocessors exist in YAML with valid IDs
@@ -182,7 +244,9 @@ export async function compileCommand() {
         if (postprocessorsMetadata.length > 0) {
             writeProgress(`📦 Found ${postprocessorsMetadata.length} postprocessor(s)...`);
             for (const postprocessor of postprocessorsMetadata) {
-                const bundled = await bundlePostProcessor(postprocessor, indexFile, distDir, project);
+                if (debugMode)
+                    console.log(`\n⚡ Processing postprocessor: ${postprocessor.name}`);
+                const bundled = await bundlePostProcessor(postprocessor, indexFile, distDir, project, debugMode);
                 bundledPostProcessors.push(bundled);
             }
             // Ensure postprocessors exist in YAML with valid IDs
@@ -194,6 +258,7 @@ export async function compileCommand() {
             await syncServerPostProcessorsWithYaml(postprocessorConfig);
             fs.writeFileSync(path.join(distDir, 'postprocessors.json'), JSON.stringify(bundledPostProcessors, null, 2));
         }
+        // Build compilation summary
         const summaryParts = [`${tools.length} tools bundled`];
         if (webhooksMetadata.length > 0)
             summaryParts.push(`${webhooksMetadata.length} webhook(s) registered`);
@@ -203,6 +268,36 @@ export async function compileCommand() {
             summaryParts.push(`${preprocessorsMetadata.length} preprocessor(s) registered`);
         if (postprocessorsMetadata.length > 0)
             summaryParts.push(`${postprocessorsMetadata.length} postprocessor(s) registered`);
+        // Check for empty bundles (potential failures)
+        const emptyBundles = [];
+        for (const tool of tools) {
+            const bundledPath = path.join(distDir, 'tools', `${tool.className}.js`);
+            if (fs.existsSync(bundledPath)) {
+                const size = fs.statSync(bundledPath).size;
+                if (size < 100) { // Less than 100 bytes is suspiciously small
+                    emptyBundles.push(`${tool.className} (${size} bytes)`);
+                }
+            }
+            else {
+                emptyBundles.push(`${tool.className} (file missing)`);
+            }
+        }
+        if (emptyBundles.length > 0) {
+            console.warn(`\n⚠️  Warning: ${emptyBundles.length} tool(s) may have bundling issues:`);
+            emptyBundles.forEach(name => console.warn(`   - ${name}`));
+            console.warn(`   Run with NODE_ENV=development for detailed error logs.\n`);
+        }
+        const totalTime = Date.now() - startTime;
+        if (debugMode) {
+            console.log(`\n⏱️  Total compilation time: ${(totalTime / 1000).toFixed(2)}s`);
+            console.log(`📊 Output directories:`);
+            console.log(`   - ${distDir}`);
+            console.log(`   - ${luaDir}`);
+            const tempDir = path.join(distDir, '.temp');
+            if (fs.existsSync(tempDir)) {
+                console.log(`   - ${tempDir} (preserved for debugging)`);
+            }
+        }
         writeSuccess(`✅ Skill compiled successfully - ${summaryParts.join(', ')}`);
     }, "compilation");
 }
@@ -230,11 +325,22 @@ function prepareOutputDirectories() {
 }
 /**
  * Creates and configures a TypeScript project for AST analysis.
+ * Validates that tsconfig.json exists before creating project.
  *
  * @returns Configured ts-morph Project instance
+ * @throws Error if tsconfig.json is missing or invalid
  */
 function createTypeScriptProject() {
-    return new Project({
-        tsConfigFilePath: path.join(process.cwd(), COMPILE_FILES.TSCONFIG_JSON),
-    });
+    const tsconfigPath = path.join(process.cwd(), COMPILE_FILES.TSCONFIG_JSON);
+    if (!fs.existsSync(tsconfigPath)) {
+        throw new Error(`tsconfig.json not found at ${tsconfigPath}\n` +
+            `Please ensure you're in a Lua CLI project directory.`);
+    }
+    try {
+        return new Project({ tsConfigFilePath: tsconfigPath });
+    }
+    catch (error) {
+        throw new Error(`Failed to parse tsconfig.json: ${error.message}\n` +
+            `Please check that your tsconfig.json is valid.`);
+    }
 }

package/dist/index.js

@@ -10,16 +10,24 @@
  */
 import { Command } from "commander";
 import { setupAuthCommands, setupSkillCommands } from "./cli/command-definitions.js";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+// Get version from package.json
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8'));
+const CLI_VERSION = packageJson.version;
 // Create the main CLI program
 const program = new Command();
 // Configure program metadata
 program
     .name("lua")
     .description("Lua AI - Build and deploy AI agents with superpowers")
-    .version("2.5.8")
+    .version(CLI_VERSION)
     .addHelpText('before', `
 ------------------------------------------------------------------
-  Lua AI CLI v2.5.8 - Build and deploy AI agents with superpowers
+  Lua AI CLI v${CLI_VERSION} - Build and deploy AI agents with superpowers
 ------------------------------------------------------------------
 `)
     .addHelpText('after', `

package/dist/utils/bundling.d.ts

@@ -22,8 +22,10 @@ export declare const sandboxGlobalsPlugin: Plugin;
  *
  * @param tool - The tool to bundle
  * @param distDir - The distribution directory for output
+ * @param modifiedSource - Optional modified source (for pre-bundled jobs)
+ * @param debugMode - Enable verbose logging and preserve temp files
  */
-export declare function bundleTool(tool: ToolInfo, distDir: string, modifiedSource?: string): Promise<void>;
+export declare function bundleTool(tool: ToolInfo, distDir: string, modifiedSource?: string, debugMode?: boolean): Promise<void>;
 /**
  * Bundles the main index.ts file into a standalone JavaScript file.
  * This creates the entry point for the skill.
@@ -39,9 +41,10 @@ export declare function bundleMainIndex(indexPath: string, distDir: string): Pro
  * @param indexFile - The TypeScript source file containing the webhook
  * @param distDir - Distribution directory for output
  * @param project - Optional ts-morph Project for resolving imports
+ * @param debugMode - Enable verbose logging and preserve temp files
  * @returns Webhook with bundled code and schemas
  */
-export declare function bundleWebhook(webhook: any, indexFile: any, distDir: string, project?: any): Promise<any>;
+export declare function bundleWebhook(webhook: any, indexFile: any, distDir: string, project?: any, debugMode?: boolean): Promise<any>;
 /**
  * Extracts and bundles job execute function.
  *
@@ -49,17 +52,18 @@ export declare function bundleWebhook(webhook: any, indexFile: any, distDir: str
  * @param indexFile - The TypeScript source file containing the job
  * @param distDir - Distribution directory for output
  * @param project - Optional ts-morph Project for resolving imports
+ * @param debugMode - Enable verbose logging and preserve temp files
  * @returns Job with bundled code
  */
-export declare function bundleJob(job: any, indexFile: any, distDir: string, project?: any): Promise<any>;
+export declare function bundleJob(job: any, indexFile: any, distDir: string, project?: any, debugMode?: boolean): Promise<any>;
 /**
  * Bundles and compresses preprocessor execute function code.
  */
-export declare function bundlePreProcessor(preprocessor: any, indexFile: any, distDir: string, project?: any): Promise<any>;
+export declare function bundlePreProcessor(preprocessor: any, indexFile: any, distDir: string, project?: any, debugMode?: boolean): Promise<any>;
 /**
  * Bundles and compresses postprocessor execute function code.
  */
-export declare function bundlePostProcessor(postprocessor: any, indexFile: any, distDir: string, project?: any): Promise<any>;
+export declare function bundlePostProcessor(postprocessor: any, indexFile: any, distDir: string, project?: any, debugMode?: boolean): Promise<any>;
 /**
  * Extracts execute code and input schema from a tool.
  * This function:

package/dist/utils/bundling.js

@@ -63,9 +63,10 @@ function extractRelevantImports(sourceFilePath) {
  * @param vmWrapperGenerator - Function that generates the VM wrapper code
  * @param distDir - Distribution directory
  * @param sourceFilePath - Path to source file containing the component
+ * @param debugMode - Enable verbose logging and preserve temp files
  * @returns Compressed base64-encoded bundled code
  */
-async function bundleAndCompressExecuteFunction(executeFunction, componentName, componentType, vmWrapperGenerator, distDir, sourceFilePath) {
+async function bundleAndCompressExecuteFunction(executeFunction, componentName, componentType, vmWrapperGenerator, distDir, sourceFilePath, debugMode) {
     const { compressCode } = await import('./compile.js');
     // Create temporary file with the execute function wrapped as a module
     const tempDir = path.join(distDir, '.temp');
@@ -77,6 +78,12 @@ async function bundleAndCompressExecuteFunction(executeFunction, componentName,
     try {
         // Extract relevant imports from source file
         const relevantImports = extractRelevantImports(sourceFilePath);
+        if (debugMode) {
+            console.log(`   → Found ${relevantImports.length} import(s) to bundle`);
+            if (relevantImports.length > 0 && debugMode) {
+                relevantImports.forEach(imp => console.log(`     - ${imp}`));
+            }
+        }
         // Write execute function as a module export with all relevant imports
         const moduleCode = `
 // ${componentType} execute function for ${componentName}
@@ -88,6 +95,9 @@ const executeFunc = ${executeFunction};
 export default executeFunc;
 `;
         fs.writeFileSync(tempFile, moduleCode);
+        if (debugMode) {
+            console.log(`   → Created temp file: ${path.basename(tempFile)}`);
+        }
         // Bundle with esbuild using the source file's directory for import resolution
         await build({
             entryPoints: [tempFile],
@@ -101,33 +111,71 @@ export default executeFunc;
             plugins: [sandboxGlobalsPlugin],
             absWorkingDir: path.dirname(sourceFilePath), // Use source file's directory for resolution
         });
-        // Read bundled code
+        // Read bundled code and validate it exists and has content
+        if (!fs.existsSync(tempOutput)) {
+            throw new Error(`esbuild failed to create output file for ${componentName}`);
+        }
         const bundledCode = fs.readFileSync(tempOutput, 'utf8');
+        if (bundledCode.length === 0) {
+            throw new Error(`esbuild created empty bundle for ${componentName}`);
+        }
         // Wrap for VM execution using provided generator
         const wrappedCode = vmWrapperGenerator(bundledCode);
         // Compress the wrapped code
         const compressed = compressCode(wrappedCode);
-        // Clean up temp files
-        try {
-            fs.unlinkSync(tempFile);
-            fs.unlinkSync(tempOutput);
+        if (debugMode) {
+            console.log(`   → Bundle size: ${(bundledCode.length / 1024).toFixed(2)}KB (uncompressed)`);
+            console.log(`   → Compressed: ${(compressed.length / 1024).toFixed(2)}KB (base64 gzip)`);
         }
-        catch (cleanupError) {
-            // Ignore cleanup errors
+        // Clean up temp files (unless in debug mode)
+        if (!debugMode) {
+            try {
+                fs.unlinkSync(tempFile);
+                fs.unlinkSync(tempOutput);
+            }
+            catch (cleanupError) {
+                // Ignore cleanup errors
+            }
+        }
+        else {
+            console.log(`   ℹ️  Preserved temp files for debugging:`);
+            console.log(`      - ${tempFile}`);
+            console.log(`      - ${tempOutput}`);
         }
         return compressed;
     }
     catch (error) {
-        console.warn(`Warning: Could not bundle ${componentType} ${componentName} code:`, error);
-        // Clean up on error
-        try {
-            if (fs.existsSync(tempFile))
-                fs.unlinkSync(tempFile);
-            if (fs.existsSync(tempOutput))
-                fs.unlinkSync(tempOutput);
+        // Provide helpful error messages based on error type
+        let errorMessage = `Warning: Could not bundle ${componentType} ${componentName}`;
+        if (error.message && error.message.includes('Could not resolve')) {
+            errorMessage += `\n  Dependency resolution failed: ${error.message}`;
+            errorMessage += `\n  Hint: Ensure all imported packages are in package.json and run 'npm install'`;
+        }
+        else if (error.message && error.message.includes('Transform failed')) {
+            errorMessage += `\n  TypeScript compilation failed: ${error.message}`;
+            errorMessage += `\n  Hint: Check syntax in ${path.basename(sourceFilePath)}`;
+        }
+        else {
+            errorMessage += `: ${error.message || error}`;
+        }
+        console.warn(errorMessage);
+        if (debugMode && error.stack) {
+            console.error('   Full stack trace:', error.stack);
+        }
+        // Clean up on error (unless in debug mode)
+        if (!debugMode) {
+            try {
+                if (fs.existsSync(tempFile))
+                    fs.unlinkSync(tempFile);
+                if (fs.existsSync(tempOutput))
+                    fs.unlinkSync(tempOutput);
+            }
+            catch (cleanupError) {
+                // Ignore cleanup errors
+            }
         }
-        catch (cleanupError) {
-            // Ignore cleanup errors
+        else {
+            console.log(`   ℹ️  Temp files preserved for debugging (check dist/.temp/)`);
         }
         return '';
     }
@@ -211,9 +259,14 @@ export const sandboxGlobalsPlugin = {
  *
  * @param tool - The tool to bundle
  * @param distDir - The distribution directory for output
+ * @param modifiedSource - Optional modified source (for pre-bundled jobs)
+ * @param debugMode - Enable verbose logging and preserve temp files
  */
-export async function bundleTool(tool, distDir, modifiedSource) {
-    writeProgress(`📦 Bundling ${tool.className}...`);
+export async function bundleTool(tool, distDir, modifiedSource, debugMode) {
+    if (!debugMode)
+        writeProgress(`📦 Bundling ${tool.className}...`);
+    if (debugMode)
+        console.log(`   → Bundling ${tool.className}...`);
     try {
         const outputPath = path.join(distDir, COMPILE_DIRS.TOOLS, `${tool.className}.js`);
         let entryPoint = tool.filePath;
@@ -277,8 +330,8 @@ export async function bundleTool(tool, distDir, modifiedSource) {
         }
         // Wrap the bundled code for VM execution environment
         await wrapToolForVM(outputPath, tool);
-        // Clean up temp file if created
-        if (tempFile && fs.existsSync(tempFile)) {
+        // Clean up temp file if created (unless in debug mode)
+        if (tempFile && fs.existsSync(tempFile) && !debugMode) {
             try {
                 fs.unlinkSync(tempFile);
             }
@@ -286,9 +339,16 @@ export async function bundleTool(tool, distDir, modifiedSource) {
                 // Ignore cleanup errors
             }
         }
+        else if (tempFile && debugMode) {
+            if (debugMode)
+                console.log(`   ℹ️  Preserved temp file: ${tempFile}`);
+        }
     }
     catch (error) {
         console.warn(`Warning: Failed to bundle ${tool.className}:`, error);
+        if (debugMode && error instanceof Error) {
+            console.error('   Stack trace:', error.stack);
+        }
     }
 }
 /**
@@ -318,10 +378,12 @@ export async function bundleMainIndex(indexPath, distDir) {
  * @param indexFile - The TypeScript source file containing the webhook
  * @param distDir - Distribution directory for output
  * @param project - Optional ts-morph Project for resolving imports
+ * @param debugMode - Enable verbose logging and preserve temp files
  * @returns Webhook with bundled code and schemas
  */
-export async function bundleWebhook(webhook, indexFile, distDir, project) {
-    writeProgress(`📦 Bundling webhook ${webhook.name}...`);
+export async function bundleWebhook(webhook, indexFile, distDir, project, debugMode) {
+    if (!debugMode)
+        writeProgress(`📦 Bundling webhook ${webhook.name}...`);
     try {
         // Find the LuaWebhook constructor in the AST
         let executeFunction = '';
@@ -420,7 +482,7 @@ export async function bundleWebhook(webhook, indexFile, distDir, project) {
         // Bundle and compress the execute function (like tools)
         let compressedCode = '';
         if (executeFunction) {
-            compressedCode = await bundleAndCompressWebhookCode(executeFunction, webhook.name, distDir, sourceFilePath);
+            compressedCode = await bundleAndCompressWebhookCode(executeFunction, webhook.name, distDir, sourceFilePath, debugMode);
         }
         return {
             ...webhook,
@@ -443,9 +505,10 @@ export async function bundleWebhook(webhook, indexFile, distDir, project) {
  * @param webhookName - Name of the webhook
  * @param distDir - Distribution directory
  * @param sourceFilePath - Path to the source file containing the webhook
+ * @param debugMode - Enable verbose logging and preserve temp files
  * @returns Compressed base64-encoded bundled code
  */
-async function bundleAndCompressWebhookCode(executeFunction, webhookName, distDir, sourceFilePath) {
+async function bundleAndCompressWebhookCode(executeFunction, webhookName, distDir, sourceFilePath, debugMode) {
     return bundleAndCompressExecuteFunction(executeFunction, webhookName, 'webhook', (bundledCode) => `(async (query, headers, body) => {
   
   // Execute the bundled webhook code
@@ -456,7 +519,7 @@ async function bundleAndCompressWebhookCode(executeFunction, webhookName, distDi
   
   // Execute with three separate parameters (not an object)
   return await executeFunction(query, headers, body);
-})`, distDir, sourceFilePath);
+})`, distDir, sourceFilePath, debugMode);
 }
 /**
  * Extracts and bundles job execute function.
@@ -465,10 +528,12 @@ async function bundleAndCompressWebhookCode(executeFunction, webhookName, distDi
  * @param indexFile - The TypeScript source file containing the job
  * @param distDir - Distribution directory for output
  * @param project - Optional ts-morph Project for resolving imports
+ * @param debugMode - Enable verbose logging and preserve temp files
  * @returns Job with bundled code
  */
-export async function bundleJob(job, indexFile, distDir, project) {
-    writeProgress(`📦 Bundling job ${job.name}...`);
+export async function bundleJob(job, indexFile, distDir, project, debugMode) {
+    if (!debugMode)
+        writeProgress(`📦 Bundling job ${job.name}...`);
     try {
         // Find the LuaJob constructor in the AST
         let executeFunction = '';
@@ -538,7 +603,7 @@ export async function bundleJob(job, indexFile, distDir, project) {
         // Bundle and compress the execute function (like tools)
         let compressedCode = '';
         if (executeFunction) {
-            compressedCode = await bundleAndCompressJobCode(executeFunction, job.name, distDir, sourceFilePath);
+            compressedCode = await bundleAndCompressJobCode(executeFunction, job.name, distDir, sourceFilePath, debugMode);
         }
         return {
             ...job,
@@ -560,9 +625,10 @@ export async function bundleJob(job, indexFile, distDir, project) {
  * @param jobName - Name of the job
  * @param distDir - Distribution directory
  * @param sourceFilePath - Path to the source file containing the job
+ * @param debugMode - Enable verbose logging and preserve temp files
  * @returns Compressed base64-encoded bundled code
  */
-async function bundleAndCompressJobCode(executeFunction, jobName, distDir, sourceFilePath) {
+async function bundleAndCompressJobCode(executeFunction, jobName, distDir, sourceFilePath, debugMode) {
     return bundleAndCompressExecuteFunction(executeFunction, jobName, 'job', (bundledCode) => `(async (job) => {
   // Execute the bundled job code
   ${bundledCode}
@@ -572,13 +638,14 @@ async function bundleAndCompressJobCode(executeFunction, jobName, distDir, sourc
   
   // Execute job with job instance parameter
   return await executeFunction(job);
-})`, distDir, sourceFilePath);
+})`, distDir, sourceFilePath, debugMode);
 }
 /**
  * Bundles and compresses preprocessor execute function code.
  */
-export async function bundlePreProcessor(preprocessor, indexFile, distDir, project) {
-    writeProgress(`📦 Bundling preprocessor ${preprocessor.name}...`);
+export async function bundlePreProcessor(preprocessor, indexFile, distDir, project, debugMode) {
+    if (!debugMode)
+        writeProgress(`📦 Bundling preprocessor ${preprocessor.name}...`);
     try {
         let executeFunction = '';
         let sourceFilePath = indexFile.getFilePath();
@@ -642,7 +709,7 @@ export async function bundlePreProcessor(preprocessor, indexFile, distDir, proje
         }
         let compressedCode = '';
         if (executeFunction) {
-            compressedCode = await bundleAndCompressProcessorCode(executeFunction, preprocessor.name, 'pre', distDir, sourceFilePath);
+            compressedCode = await bundleAndCompressProcessorCode(executeFunction, preprocessor.name, 'pre', distDir, sourceFilePath, debugMode);
         }
         return {
             name: preprocessor.name,
@@ -662,8 +729,9 @@ export async function bundlePreProcessor(preprocessor, indexFile, distDir, proje
 /**
  * Bundles and compresses postprocessor execute function code.
  */
-export async function bundlePostProcessor(postprocessor, indexFile, distDir, project) {
-    writeProgress(`📦 Bundling postprocessor ${postprocessor.name}...`);
+export async function bundlePostProcessor(postprocessor, indexFile, distDir, project, debugMode) {
+    if (!debugMode)
+        writeProgress(`📦 Bundling postprocessor ${postprocessor.name}...`);
     try {
         let executeFunction = '';
         let sourceFilePath = indexFile.getFilePath();
@@ -727,7 +795,7 @@ export async function bundlePostProcessor(postprocessor, indexFile, distDir, pro
         }
         let compressedCode = '';
         if (executeFunction) {
-            compressedCode = await bundleAndCompressProcessorCode(executeFunction, postprocessor.name, 'post', distDir, sourceFilePath);
+            compressedCode = await bundleAndCompressProcessorCode(executeFunction, postprocessor.name, 'post', distDir, sourceFilePath, debugMode);
         }
         return {
             name: postprocessor.name,
@@ -748,7 +816,7 @@ export async function bundlePostProcessor(postprocessor, indexFile, distDir, pro
  * Bundles and compresses processor execute function code.
  * Includes all imports from the source file to ensure dependencies are bundled.
  */
-async function bundleAndCompressProcessorCode(executeFunction, processorName, type, distDir, sourceFilePath) {
+async function bundleAndCompressProcessorCode(executeFunction, processorName, type, distDir, sourceFilePath, debugMode) {
     // Processor execute functions receive: (user, message, [response], channel)
     const paramList = type === 'pre' ? 'user, message, channel' : 'user, message, response, channel';
     return bundleAndCompressExecuteFunction(executeFunction, processorName, `${type}processor`, (bundledCode) => `(async (${paramList}) => {
@@ -757,7 +825,7 @@ async function bundleAndCompressProcessorCode(executeFunction, processorName, ty
   
   const executeFunction = module.exports.default || module.exports;
   return await executeFunction(${paramList});
-})`, distDir, sourceFilePath);
+})`, distDir, sourceFilePath, debugMode);
 }
 /**
  * Extracts execute code and input schema from a tool.

package/dist/utils/compile.d.ts

@@ -12,7 +12,10 @@ export declare function compressCode(code: string): string;
  */
 export declare function findIndexFile(): string;
 /**
- * Resolves import path from module specifier
+ * Resolves import path from module specifier with support for multiple extensions and index files
+ * @param moduleSpecifier - The import path (e.g., './tools/MyTool' or '../utils')
+ * @param currentFilePath - The file doing the importing
+ * @returns Resolved absolute file path
  */
 export declare function resolveImportPath(moduleSpecifier: string, currentFilePath: string): string;
 /**

package/dist/utils/compile.js

@@ -29,16 +29,37 @@ export function findIndexFile() {
     throw new Error("index.ts not found in current directory or src/ directory");
 }
 /**
- * Resolves import path from module specifier
+ * Resolves import path from module specifier with support for multiple extensions and index files
+ * @param moduleSpecifier - The import path (e.g., './tools/MyTool' or '../utils')
+ * @param currentFilePath - The file doing the importing
+ * @returns Resolved absolute file path
  */
 export function resolveImportPath(moduleSpecifier, currentFilePath) {
+    const extensions = ['.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx', '/index.js'];
     if (moduleSpecifier.startsWith('./') || moduleSpecifier.startsWith('../')) {
         // Relative import - resolve relative to current file
         const currentDir = path.dirname(currentFilePath);
-        return path.resolve(currentDir, moduleSpecifier + '.ts');
+        const basePath = path.resolve(currentDir, moduleSpecifier);
+        // Try each extension in order
+        for (const ext of extensions) {
+            const fullPath = ext.startsWith('/') ? path.join(basePath, ext) : basePath + ext;
+            if (fs.existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+        // Fallback: return .ts extension (original behavior)
+        return basePath + '.ts';
     }
     else {
-        // Absolute import - assume it's in the project
+        // Absolute import - check in src/ directory
+        const srcBase = path.resolve(process.cwd(), 'src', moduleSpecifier);
+        for (const ext of extensions) {
+            const fullPath = ext.startsWith('/') ? path.join(srcBase, ext) : srcBase + ext;
+            if (fs.existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+        // Fallback: return .ts in src/ (original behavior)
         return path.resolve(process.cwd(), 'src', moduleSpecifier + '.ts');
     }
 }

package/dist/utils/deployment.js

@@ -56,6 +56,10 @@ function readPackageJson() {
  */
 export async function createLegacyDeploymentData(tools, luaDir, indexFile, agentData) {
     const config = readSkillConfig();
+    // Handle null config gracefully
+    if (!config) {
+        console.warn('⚠️  Warning: lua.skill.yaml not found. Creating deployment with default configuration.');
+    }
     let skillsMetadata;
     // Check if we have agent data (from LuaAgent approach)
     if (agentData && agentData.skills && agentData.skills.length > 0) {
@@ -75,9 +79,9 @@ export async function createLegacyDeploymentData(tools, luaDir, indexFile, agent
     // Build skills array with their associated tools
     const skillsArray = buildSkillsArray(skillsMetadata, skillToTools, tools);
     // Ensure all skills exist in YAML config and have valid IDs
-    const updatedSkillsArray = await ensureSkillsExistInYaml(skillsArray, config);
+    const updatedSkillsArray = config ? await ensureSkillsExistInYaml(skillsArray, config) : skillsArray;
     // Override versions from YAML config if they exist
-    const finalSkillsArray = overrideVersionsFromConfig(updatedSkillsArray, config);
+    const finalSkillsArray = config ? overrideVersionsFromConfig(updatedSkillsArray, config) : updatedSkillsArray;
     // Write deployment data
     const deployData = {
         skills: finalSkillsArray
@@ -169,6 +173,10 @@ function buildSkillsArray(skillsMetadata, skillToTools, tools) {
  * @returns Skills array with versions overridden from config
  */
 function overrideVersionsFromConfig(skillsArray, config) {
+    // Handle null config
+    if (!config) {
+        return skillsArray;
+    }
     // Get version map from YAML config
     const configVersionMap = new Map();
     if (config.skills && Array.isArray(config.skills)) {

package/dist/utils/pre-bundle-jobs.d.ts

@@ -22,5 +22,6 @@ export declare function preBundleJobsInSource(sourceFilePath: string, project: P
 /**
  * Replaces placeholders in bundled code with actual job bundles
  * The bundled job code is NOT compressed - it's JavaScript that will be part of the tool
+ * Validates that all placeholders are found and replaced
  */
 export declare function replaceJobPlaceholders(bundledCode: string, jobBundles: Map<string, string>): string;

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

@@ -162,15 +162,27 @@ export default executeFunc;
 /**
  * Replaces placeholders in bundled code with actual job bundles
  * The bundled job code is NOT compressed - it's JavaScript that will be part of the tool
+ * Validates that all placeholders are found and replaced
  */
 export function replaceJobPlaceholders(bundledCode, jobBundles) {
     let result = bundledCode;
+    const replacementsMade = new Map();
     jobBundles.forEach((bundledJobCode, placeholder) => {
         // The placeholder is used as an identifier (not a string), just replace it directly
         // It appears as: execute: __BUNDLED_JOB_EXECUTE___1
-        const placeholderPattern = new RegExp(placeholder, 'g');
+        // Use word boundary to prevent partial matches
+        const placeholderPattern = new RegExp(`\\b${placeholder}\\b`, 'g');
+        const beforeLength = result.length;
         result = result.replace(placeholderPattern, bundledJobCode);
-        // console.log(`[PreBundleJobs] ✅ Replaced ${placeholder} with bundled code (${(bundledJobCode.length / 1024).toFixed(1)}KB)`);
+        const wasReplaced = result.length !== beforeLength;
+        replacementsMade.set(placeholder, wasReplaced);
+        if (wasReplaced) {
+            // console.log(`[PreBundleJobs] ✅ Replaced ${placeholder} with bundled code (${(bundledJobCode.length / 1024).toFixed(1)}KB)`);
+        }
+        else {
+            console.warn(`⚠️  Warning: Placeholder ${placeholder} not found in bundled code. Nested job may not work correctly.`);
+            console.warn(`    This can happen if esbuild mangled the identifier during minification.`);
+        }
     });
     return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lua-cli",
-  "version": "3.0.2-alpha.2",
+  "version": "3.0.2-alpha.4",
   "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",

package/template/lua.skill.yaml

@@ -0,0 +1 @@
+skills: []

package/template/src/skills/tools/ProductsTool.ts

@@ -25,7 +25,7 @@ export class GetAllProductsTool implements LuaTool {
     });
 
     async execute(input: z.infer<typeof this.inputSchema>) {
-        return await Products.get(input.limit, input.limit);
+        return await Products.get(input.page, input.limit);
     }
 }