lua-cli 3.0.0-alpha.4 → 3.0.0-alpha.5

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/push.d.ts

@@ -17,7 +17,11 @@
  *
  * 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 options - Command options (force, autoDeploy)
  * @returns Promise that resolves when push completes
  */
-export declare function pushCommand(type?: string): Promise<void>;
+export declare function pushCommand(type?: string, options?: {
+    force?: boolean;
+    autoDeploy?: boolean;
+}): Promise<void>;

package/dist/commands/push.js

@@ -31,17 +31,29 @@ import PostProcessorApi from '../api/postprocessor.api.service.js';
  *
  * 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 options - Command options (force, autoDeploy)
  * @returns Promise that resolves when push completes
  */
-export async function pushCommand(type) {
+export async function pushCommand(type, options) {
     return withErrorHandling(async () => {
         let selectedType;
+        // Handle 'all' type with force flag
+        if (type === 'all') {
+            if (!options?.force) {
+                console.error('❌ The "all" type requires the --force flag');
+                console.log('\nUsage:');
+                console.log('  lua push all --force                Push all components without prompts');
+                console.log('  lua push all --force --auto-deploy  Push and deploy all to production');
+                process.exit(1);
+            }
+            return await pushAllCommand(options);
+        }
         // Step 1: Check if type was provided as argument
         if (type) {
             // Validate the provided type
             if (type !== 'skill' && type !== 'persona' && type !== 'webhook' && type !== 'job' && type !== 'preprocessor' && type !== 'postprocessor') {
-                console.error(`❌ Invalid type: "${type}". Must be "skill", "persona", "webhook", "job", "preprocessor", or "postprocessor".`);
+                console.error(`❌ Invalid type: "${type}". Must be "skill", "persona", "webhook", "job", "preprocessor", "postprocessor", or "all".`);
                 console.log('\nUsage:');
                 console.log('  lua push                - Interactive selection');
                 console.log('  lua push skill          - Push a skill directly');
@@ -50,6 +62,7 @@ export async function pushCommand(type) {
                 console.log('  lua push job            - Push a job directly');
                 console.log('  lua push preprocessor   - Push a preprocessor directly');
                 console.log('  lua push postprocessor  - Push a postprocessor directly');
+                console.log('  lua push all --force    - Push all components without prompts');
                 process.exit(1);
             }
             selectedType = type;
@@ -1031,3 +1044,394 @@ async function deployVersionAfterPush(apiKey, agentId, selectedSkill, pushedVers
         console.log('💡 You can deploy later using: lua deploy\n');
     }
 }
+/**
+ * Push all command - Pushes all components (skills, webhooks, jobs, processors) without prompts
+ *
+ * This command:
+ * 1. Compiles the project
+ * 2. Reads lua.skill.yaml to get all components
+ * 3. Auto-bumps patch versions
+ * 4. Pushes all components
+ * 5. Optionally auto-deploys to production
+ *
+ * @param options - Command options (force is required, autoDeploy is optional)
+ */
+async function pushAllCommand(options) {
+    writeProgress("🚀 Push All - Pushing all components to server...\n");
+    // Step 1: Compile first
+    writeProgress("📦 Compiling project...");
+    await compileCommand();
+    // Step 2: Load configuration and API key
+    const config = readSkillConfig();
+    if (!config?.agent?.agentId) {
+        console.error('❌ No agent ID found in lua.skill.yaml. Run "lua init" first.');
+        process.exit(1);
+    }
+    const apiKey = await loadApiKey();
+    if (!apiKey) {
+        console.error('❌ No API key found. Run "lua auth configure" first.');
+        process.exit(1);
+    }
+    const agentId = config.agent.agentId; // Validated above, safe to assert
+    // Step 3: Read deploy.json for component data
+    const deployJsonPath = path.join(process.cwd(), '.lua', 'deploy.json');
+    if (!fs.existsSync(deployJsonPath)) {
+        console.error('❌ No deploy.json found. Compilation may have failed.');
+        process.exit(1);
+    }
+    const deployData = JSON.parse(fs.readFileSync(deployJsonPath, 'utf8'));
+    // Track results
+    const results = {
+        skills: [],
+        webhooks: [],
+        jobs: [],
+        preprocessors: [],
+        postprocessors: []
+    };
+    // Step 4: Push all skills
+    if (config.skills && config.skills.length > 0) {
+        writeProgress(`\n📦 Pushing ${config.skills.length} skill(s)...`);
+        for (const skillConfig of config.skills) {
+            try {
+                const skillData = deployData.skills.find((s) => s.name === skillConfig.name);
+                if (!skillData) {
+                    console.warn(`⚠️  Skill "${skillConfig.name}" not found in deploy.json, skipping`);
+                    continue;
+                }
+                // Validate skillId and version exist
+                const skillId = skillConfig.skillId;
+                const currentVersion = skillConfig.version;
+                if (!skillId) {
+                    console.warn(`⚠️  Skill "${skillConfig.name}" has no skillId, skipping`);
+                    continue;
+                }
+                if (!currentVersion) {
+                    console.warn(`⚠️  Skill "${skillConfig.name}" has no version, skipping`);
+                    continue;
+                }
+                // Auto-bump patch version
+                const newVersion = bumpPatchVersion(currentVersion);
+                writeInfo(`  📝 ${skillConfig.name}: ${currentVersion} → ${newVersion}`);
+                // Push version
+                const pushResult = await pushVersion(apiKey, agentId, skillId, {
+                    version: newVersion,
+                    description: skillConfig.description || '',
+                    context: skillConfig.context || '',
+                    code: skillData.code,
+                    executeFunction: skillData.executeFunction,
+                    inputSchema: skillData.inputSchema,
+                    outputSchema: skillData.outputSchema,
+                });
+                // Update YAML with new version
+                updateSkillVersionInYaml(skillConfig.name, newVersion);
+                results.skills.push({ name: skillConfig.name, version: newVersion, skillId });
+                writeSuccess(`  ✅ ${skillConfig.name} v${newVersion} pushed`);
+                // Auto-deploy if requested
+                if (options.autoDeploy) {
+                    await publishVersion(apiKey, agentId, skillId, newVersion);
+                    writeSuccess(`  🚀 ${skillConfig.name} v${newVersion} deployed to production`);
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to push ${skillConfig.name}:`, error.message);
+            }
+        }
+    }
+    // Step 5: Push all webhooks
+    if (config.webhooks && config.webhooks.length > 0) {
+        writeProgress(`\n🪝 Pushing ${config.webhooks.length} webhook(s)...`);
+        for (const webhookConfig of config.webhooks) {
+            try {
+                const webhookData = deployData.webhooks?.find((w) => w.name === webhookConfig.name);
+                if (!webhookData) {
+                    console.warn(`⚠️  Webhook "${webhookConfig.name}" not found in deploy.json, skipping`);
+                    continue;
+                }
+                // Validate webhookId and version exist
+                if (!webhookConfig.webhookId) {
+                    console.warn(`⚠️  Webhook "${webhookConfig.name}" has no webhookId, skipping`);
+                    continue;
+                }
+                if (!webhookConfig.version) {
+                    console.warn(`⚠️  Webhook "${webhookConfig.name}" has no version, skipping`);
+                    continue;
+                }
+                // Auto-bump patch version
+                const newVersion = bumpPatchVersion(webhookConfig.version);
+                writeInfo(`  📝 ${webhookConfig.name}: ${webhookConfig.version} → ${newVersion}`);
+                // Prepare webhook data for push
+                const pushData = {
+                    name: webhookConfig.name,
+                    version: newVersion,
+                    description: webhookData.description || webhookConfig.description || '',
+                    context: webhookData.context || webhookConfig.context || '',
+                    webhookId: webhookConfig.webhookId,
+                    querySchema: webhookData.querySchema,
+                    headerSchema: webhookData.headerSchema,
+                    bodySchema: webhookData.bodySchema,
+                    code: webhookData.code,
+                    executeFunction: webhookData.executeFunction
+                };
+                // Push version using fetch (like existing webhook push)
+                const response = await fetch(`${BASE_URLS.API}/developer/webhooks/${agentId}/${webhookConfig.webhookId}/version`, {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${apiKey}`,
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify(pushData)
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+                }
+                // Update YAML
+                updateWebhookVersionInYaml(webhookConfig.name, newVersion);
+                results.webhooks.push({ name: webhookConfig.name, version: newVersion });
+                writeSuccess(`  ✅ ${webhookConfig.name} v${newVersion} pushed`);
+                // Auto-deploy if requested
+                if (options.autoDeploy) {
+                    const deployResponse = await fetch(`${BASE_URLS.API}/developer/webhooks/${agentId}/${webhookConfig.webhookId}/${newVersion}/publish`, {
+                        method: 'PUT',
+                        headers: {
+                            'Authorization': `Bearer ${apiKey}`,
+                            'Content-Type': 'application/json'
+                        }
+                    });
+                    if (deployResponse.ok) {
+                        writeSuccess(`  🚀 ${webhookConfig.name} v${newVersion} deployed to production`);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to push ${webhookConfig.name}:`, error.message);
+            }
+        }
+    }
+    // Step 6: Push all jobs
+    if (config.jobs && config.jobs.length > 0) {
+        writeProgress(`\n⏰ Pushing ${config.jobs.length} job(s)...`);
+        for (const jobConfig of config.jobs) {
+            try {
+                const jobData = deployData.jobs?.find((j) => j.name === jobConfig.name);
+                if (!jobData) {
+                    console.warn(`⚠️  Job "${jobConfig.name}" not found in deploy.json, skipping`);
+                    continue;
+                }
+                // Validate jobId and version exist
+                if (!jobConfig.jobId) {
+                    console.warn(`⚠️  Job "${jobConfig.name}" has no jobId, skipping`);
+                    continue;
+                }
+                if (!jobConfig.version) {
+                    console.warn(`⚠️  Job "${jobConfig.name}" has no version, skipping`);
+                    continue;
+                }
+                // Auto-bump patch version
+                const newVersion = bumpPatchVersion(jobConfig.version);
+                writeInfo(`  📝 ${jobConfig.name}: ${jobConfig.version} → ${newVersion}`);
+                // Prepare job data for push
+                const pushData = {
+                    name: jobConfig.name,
+                    version: newVersion,
+                    description: jobData.description || jobConfig.description || '',
+                    context: jobData.context || jobConfig.context || '',
+                    jobId: jobConfig.jobId,
+                    schedule: jobData.schedule || jobConfig.schedule,
+                    timeout: jobData.timeout,
+                    retry: jobData.retry,
+                    code: jobData.code,
+                    executeFunction: jobData.executeFunction,
+                    metadata: jobData.metadata || jobConfig.metadata
+                };
+                // Push version using fetch
+                const response = await fetch(`${BASE_URLS.API}/developer/jobs/${agentId}/${jobConfig.jobId}/version`, {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${apiKey}`,
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify(pushData)
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+                }
+                // Update YAML
+                updateJobVersionInYaml(jobConfig.name, newVersion);
+                results.jobs.push({ name: jobConfig.name, version: newVersion });
+                writeSuccess(`  ✅ ${jobConfig.name} v${newVersion} pushed`);
+                // Auto-deploy if requested
+                if (options.autoDeploy) {
+                    const deployResponse = await fetch(`${BASE_URLS.API}/developer/jobs/${agentId}/${jobConfig.jobId}/${newVersion}/publish`, {
+                        method: 'PUT',
+                        headers: {
+                            'Authorization': `Bearer ${apiKey}`,
+                            'Content-Type': 'application/json'
+                        }
+                    });
+                    if (deployResponse.ok) {
+                        writeSuccess(`  🚀 ${jobConfig.name} v${newVersion} deployed to production`);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to push ${jobConfig.name}:`, error.message);
+            }
+        }
+    }
+    // Step 7: Push all preprocessors
+    if (config.preprocessors && config.preprocessors.length > 0) {
+        writeProgress(`\n📥 Pushing ${config.preprocessors.length} preprocessor(s)...`);
+        const preprocessorService = new PreProcessorApi(BASE_URLS.API, apiKey, agentId);
+        for (const processorConfig of config.preprocessors) {
+            try {
+                const processorData = deployData.preprocessors?.find((p) => p.name === processorConfig.name);
+                if (!processorData) {
+                    console.warn(`⚠️  Preprocessor "${processorConfig.name}" not found in deploy.json, skipping`);
+                    continue;
+                }
+                // Validate preprocessorId and version exist
+                const preprocessorId = processorConfig.preprocessorId;
+                const currentVersion = processorConfig.version;
+                if (!preprocessorId) {
+                    console.warn(`⚠️  Preprocessor "${processorConfig.name}" has no preprocessorId, skipping`);
+                    continue;
+                }
+                if (!currentVersion) {
+                    console.warn(`⚠️  Preprocessor "${processorConfig.name}" has no version, skipping`);
+                    continue;
+                }
+                // Auto-bump patch version
+                const newVersion = bumpPatchVersion(currentVersion);
+                writeInfo(`  📝 ${processorConfig.name}: ${currentVersion} → ${newVersion}`);
+                // Prepare version data
+                const versionData = {
+                    name: processorConfig.name,
+                    version: newVersion,
+                    description: processorData.description || processorConfig.description || '',
+                    context: processorData.context || processorConfig.context || '',
+                    preprocessorId: preprocessorId,
+                    code: processorData.code,
+                    executeFunction: processorData.executeFunction,
+                    async: Boolean(processorData.async ?? false)
+                };
+                // Push version
+                const result = await preprocessorService.pushPreProcessor(preprocessorId, versionData);
+                if (!result.success) {
+                    throw new Error(result.error?.message || 'Failed to push preprocessor');
+                }
+                // Update YAML
+                updateProcessorVersionInYaml('preprocessors', processorConfig.name, newVersion);
+                results.preprocessors.push({ name: processorConfig.name, version: newVersion });
+                writeSuccess(`  ✅ ${processorConfig.name} v${newVersion} pushed`);
+                // Auto-deploy if requested
+                if (options.autoDeploy) {
+                    const deployResult = await preprocessorService.publishPreProcessorVersion(preprocessorId, newVersion);
+                    if (deployResult.success) {
+                        writeSuccess(`  🚀 ${processorConfig.name} v${newVersion} deployed to production`);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to push ${processorConfig.name}:`, error.message);
+            }
+        }
+    }
+    // Step 8: Push all postprocessors
+    if (config.postprocessors && config.postprocessors.length > 0) {
+        writeProgress(`\n📤 Pushing ${config.postprocessors.length} postprocessor(s)...`);
+        const postprocessorService = new PostProcessorApi(BASE_URLS.API, apiKey, agentId);
+        for (const processorConfig of config.postprocessors) {
+            try {
+                const processorData = deployData.postprocessors?.find((p) => p.name === processorConfig.name);
+                if (!processorData) {
+                    console.warn(`⚠️  Postprocessor "${processorConfig.name}" not found in deploy.json, skipping`);
+                    continue;
+                }
+                // Validate postprocessorId and version exist
+                const postprocessorId = processorConfig.postprocessorId;
+                const currentVersion = processorConfig.version;
+                if (!postprocessorId) {
+                    console.warn(`⚠️  Postprocessor "${processorConfig.name}" has no postprocessorId, skipping`);
+                    continue;
+                }
+                if (!currentVersion) {
+                    console.warn(`⚠️  Postprocessor "${processorConfig.name}" has no version, skipping`);
+                    continue;
+                }
+                // Auto-bump patch version
+                const newVersion = bumpPatchVersion(currentVersion);
+                writeInfo(`  📝 ${processorConfig.name}: ${currentVersion} → ${newVersion}`);
+                // Prepare version data
+                const versionData = {
+                    name: processorConfig.name,
+                    version: newVersion,
+                    description: processorData.description || processorConfig.description || '',
+                    context: processorData.context || processorConfig.context || '',
+                    postprocessorId: postprocessorId,
+                    code: processorData.code,
+                    executeFunction: processorData.executeFunction,
+                    async: Boolean(processorData.async ?? false)
+                };
+                // Push version
+                const result = await postprocessorService.pushPostProcessor(postprocessorId, versionData);
+                if (!result.success) {
+                    throw new Error(result.error?.message || 'Failed to push postprocessor');
+                }
+                // Update YAML
+                updateProcessorVersionInYaml('postprocessors', processorConfig.name, newVersion);
+                results.postprocessors.push({ name: processorConfig.name, version: newVersion });
+                writeSuccess(`  ✅ ${processorConfig.name} v${newVersion} pushed`);
+                // Auto-deploy if requested
+                if (options.autoDeploy) {
+                    const deployResult = await postprocessorService.publishPostProcessorVersion(postprocessorId, newVersion);
+                    if (deployResult.success) {
+                        writeSuccess(`  🚀 ${processorConfig.name} v${newVersion} deployed to production`);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to push ${processorConfig.name}:`, error.message);
+            }
+        }
+    }
+    // Step 9: Print summary
+    writeSuccess('\n✅ Push All Complete!\n');
+    if (results.skills.length > 0) {
+        console.log(`🛠️  Skills (${results.skills.length}):`);
+        results.skills.forEach(s => console.log(`   • ${s.name} v${s.version}`));
+    }
+    if (results.webhooks.length > 0) {
+        console.log(`🪝 Webhooks (${results.webhooks.length}):`);
+        results.webhooks.forEach(w => console.log(`   • ${w.name} v${w.version}`));
+    }
+    if (results.jobs.length > 0) {
+        console.log(`⏰ Jobs (${results.jobs.length}):`);
+        results.jobs.forEach(j => console.log(`   • ${j.name} v${j.version}`));
+    }
+    if (results.preprocessors.length > 0) {
+        console.log(`📥 PreProcessors (${results.preprocessors.length}):`);
+        results.preprocessors.forEach(p => console.log(`   • ${p.name} v${p.version}`));
+    }
+    if (results.postprocessors.length > 0) {
+        console.log(`📤 PostProcessors (${results.postprocessors.length}):`);
+        results.postprocessors.forEach(p => console.log(`   • ${p.name} v${p.version}`));
+    }
+    if (options.autoDeploy) {
+        writeSuccess('\n🚀 All components deployed to production!');
+    }
+    console.log('');
+}
+/**
+ * Bumps the patch version of a semantic version string
+ * e.g., "1.2.3" -> "1.2.4"
+ */
+function bumpPatchVersion(version) {
+    const parts = version.split('.');
+    if (parts.length !== 3) {
+        // If not a valid semver, just return incremented version
+        return version + '.1';
+    }
+    const [major, minor, patch] = parts;
+    const newPatch = parseInt(patch, 10) + 1;
+    return `${major}.${minor}.${newPatch}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lua-cli",
-  "version": "3.0.0-alpha.4",
+  "version": "3.0.0-alpha.5",
   "description": "Command-line interface for Lua AI platform - develop, test, and deploy LuaSkills with custom tools",
   "readmeFilename": "README.md",
   "main": "dist/api-exports.js",

package/template/lua.skill.yaml

@@ -14,25 +14,25 @@ agent:
   welcomeMessage: Hi, I am your AI assistant. How can I help you today?
 skills:
   - name: general-skill
-    version: 0.0.3
+    version: 0.0.4
     skillId: 1faf9b3a-e352-4e63-a6c4-a3deca815361
   - name: user-data-skill
-    version: 0.0.1
+    version: 0.0.2
     skillId: e0c382c1-f469-4880-962a-a756ea3c1411
   - name: product-skill
-    version: 0.0.1
+    version: 0.0.2
     skillId: d4cdc7bc-6d42-4232-902d-2b9cf68bd74a
   - name: basket-skill
-    version: 0.0.1
+    version: 0.0.2
     skillId: 5b06c5ff-7cf3-49c4-8641-142270c81db4
   - name: order-skill
-    version: 0.0.1
+    version: 0.0.2
     skillId: d4045304-7c30-4750-9edd-340eb1357a39
   - name: custom-data-skill
-    version: 0.0.1
+    version: 0.0.2
     skillId: 83fe411c-90a1-4bd3-9271-ac8e03d6a3be
   - name: payment-skill
-    version: 0.0.1
+    version: 0.0.2
     skillId: f2248c02-c6c6-4c3a-89bf-ff09ec11529a
 jobs:
   - name: test-job

package/template/package.json

@@ -20,7 +20,7 @@
     "inquirer": "^12.9.6",
     "stripe": "^17.5.0",
     "js-yaml": "^4.1.0",
-    "lua-cli": "^3.0.0-alpha.4",
+    "lua-cli": "^3.0.0-alpha.5",
     "openai": "^5.23.0",
     "uuid": "^13.0.0",
     "zod": "^3.24.1"