lua-cli 2.5.5 → 2.5.6

package/dist/commands/deploy.js

@@ -7,6 +7,7 @@ import { readSkillConfig } from '../utils/files.js';
 import { withErrorHandling, writeProgress, writeSuccess, writeInfo } from '../utils/cli.js';
 import { sortVersionsByDate, promptVersionSelection, confirmDeployment, validateDeployConfig, validateVersionsAvailable, promptSkillSelection, getAvailableSkills, } from '../utils/deploy-helpers.js';
 import { fetchVersions, publishVersion } from '../utils/deploy-api.js';
+import { updateSkillVersionInYaml } from '../utils/push-helpers.js';
 /**
  * Main deploy command - deploys a skill version to production.
  *
@@ -82,6 +83,12 @@ export async function deployCommand() {
         // Step 7: Publish the selected version
         writeProgress("🔄 Publishing version...");
         const publishResponse = await publishVersion(apiKey, config.agent.agentId, selectedSkill.skillId, selectedVersion);
-        writeSuccess(`✅ Version ${publishResponse.activeVersionId} of "${selectedSkill.name}" deployed successfully`);
+        const deployedVersion = publishResponse.activeVersionId;
+        writeSuccess(`✅ Version ${deployedVersion} of "${selectedSkill.name}" deployed successfully`);
+        // Step 8: Update YAML with the deployed version
+        if (deployedVersion !== selectedSkill.version) {
+            writeInfo(`📝 Updating YAML with deployed version: ${deployedVersion}`);
+            updateSkillVersionInYaml(selectedSkill.name, deployedVersion);
+        }
     }, "deployment");
 }

package/dist/commands/init.js

@@ -2,11 +2,13 @@
  * Init Command
  * Orchestrates the initialization of a new Lua skill project
  */
+import inquirer from 'inquirer';
 import { loadApiKey, checkApiKey } from "../services/auth.js";
-import { withErrorHandling, writeProgress, writeSuccess, } from "../utils/cli.js";
+import { withErrorHandling, writeProgress, writeSuccess, writeInfo, writeError, } from "../utils/cli.js";
 import { promptAgentChoice, promptOrganizationSelection, promptAgentSelection, promptMetadataCollection, promptFeatureConfiguration, promptBusinessConfiguration, } from "../utils/init-prompts.js";
-import { fetchAgentTypes, selectBaseAgentType, createNewAgent, } from "../utils/init-agent.js";
+import { fetchAgentTypes, selectBaseAgentType, createNewAgent, fetchExistingAgentDetails, } from "../utils/init-agent.js";
 import { initializeProject, installDependencies, clearLinesIfNeeded, } from "../utils/init-helpers.js";
+import { readSkillYaml, updateYamlAgent } from "../utils/files.js";
 /**
  * Main init command - initializes a new Lua skill project.
  *
@@ -40,40 +42,114 @@ export async function initCommand() {
         }
         const userData = await checkApiKey(apiKey);
         writeProgress("✅ Authenticated");
-        // Step 2: Choose between existing or new agent
+        // Step 2: Check for existing YAML file
+        const existingYaml = readSkillYaml();
+        const yamlExists = existingYaml !== null;
+        if (yamlExists) {
+            const existingAgentId = existingYaml?.agent?.agentId;
+            if (existingAgentId) {
+                // Check if user has access to this agent
+                const hasAccess = checkUserHasAccessToAgent(userData, existingAgentId);
+                if (!hasAccess) {
+                    writeError("\n⚠️  You don't have access to the agent in this project");
+                    writeInfo(`   Agent ID: ${existingAgentId}\n`);
+                    const { action } = await inquirer.prompt([
+                        {
+                            type: 'list',
+                            name: 'action',
+                            message: 'What would you like to do?',
+                            choices: [
+                                { name: '📧 Contact the agent admin to request access', value: 'contact' },
+                                { name: '🔄 Switch to a different agent', value: 'switch' },
+                                { name: '❌ Cancel', value: 'cancel' }
+                            ]
+                        }
+                    ]);
+                    if (action === 'contact') {
+                        writeInfo("\n💡 Please contact the agent administrator to grant you access.");
+                        writeInfo(`   Agent ID: ${existingAgentId}\n`);
+                        process.exit(0);
+                    }
+                    if (action === 'cancel') {
+                        writeInfo("\n❌ Initialization cancelled.\n");
+                        process.exit(0);
+                    }
+                    // User chose to switch agent - update existing YAML only
+                    await handleAgentSwitch(userData, apiKey, existingYaml);
+                    return;
+                }
+                else {
+                    // User has access - ask if they want to switch anyway
+                    writeInfo("\n📋 Found existing project configuration");
+                    writeInfo(`   Current Agent ID: ${existingAgentId}\n`);
+                    const { wantSwitch } = await inquirer.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'wantSwitch',
+                            message: 'Do you want to switch this project to a different agent?',
+                            default: false
+                        }
+                    ]);
+                    if (wantSwitch) {
+                        // User wants to switch agent - update existing YAML only
+                        await handleAgentSwitch(userData, apiKey, existingYaml);
+                        return;
+                    }
+                    else {
+                        writeInfo("\n✅ Keeping current agent configuration\n");
+                        process.exit(0);
+                    }
+                }
+            }
+        }
+        // Step 3: Choose between existing or new agent
         const agentChoice = await promptAgentChoice();
         let selectedAgent;
         let selectedOrg;
         let persona;
         let welcomeMessage;
+        let skipProjectInit = false;
         if (agentChoice === "existing") {
-            // Step 3a: Select existing agent
-            const result = await selectExistingAgent(userData);
+            // Step 4a: Select existing agent
+            const result = await selectExistingAgent(userData, apiKey);
             selectedAgent = result.agent;
             selectedOrg = result.org;
+            persona = result.persona;
+            welcomeMessage = result.welcomeMessage;
         }
         else {
-            // Step 3b: Create new agent
+            // Step 4b: Create new agent
             const result = await createNewAgentFlow(apiKey);
             selectedAgent = result.agent;
             selectedOrg = result.org;
             persona = result.persona;
             welcomeMessage = result.welcomeMessage;
         }
-        // Step 4: Initialize project
-        const currentDir = initializeProject(selectedAgent.agentId, selectedOrg.id, persona, welcomeMessage);
-        // Step 5: Install dependencies
-        await installDependencies(currentDir);
-        writeSuccess("✅ Lua skill project initialized successfully!");
+        // Step 5: Initialize or update project
+        if (yamlExists) {
+            // Update existing YAML only
+            writeInfo("📝 Updating existing lua.skill.yaml with new agent...");
+            updateYamlAgent(selectedAgent.agentId, selectedOrg.id, persona, welcomeMessage);
+            writeSuccess("✅ lua.skill.yaml updated successfully!");
+        }
+        else {
+            // Full project initialization
+            const currentDir = initializeProject(selectedAgent.agentId, selectedOrg.id, persona, welcomeMessage);
+            // Step 6: Install dependencies
+            await installDependencies(currentDir);
+            writeSuccess("✅ Lua skill project initialized successfully!");
+        }
     }, "initialization");
 }
 /**
  * Handles the flow for selecting an existing agent.
+ * Fetches the agent details from the server to get persona and welcomeMessage.
  *
  * @param userData - User's data
- * @returns Selected agent and organization
+ * @param apiKey - User's API key
+ * @returns Selected agent, organization, and optional persona/welcome message
  */
-async function selectExistingAgent(userData) {
+async function selectExistingAgent(userData, apiKey) {
     // Extract organizations
     const orgs = userData.admin.orgs;
     if (!orgs || orgs.length === 0) {
@@ -83,7 +159,14 @@ async function selectExistingAgent(userData) {
     const selectedOrg = await promptOrganizationSelection(orgs);
     // Select agent from organization
     const selectedAgent = await promptAgentSelection(selectedOrg);
-    return { agent: selectedAgent, org: selectedOrg };
+    // Fetch agent details to get persona and welcomeMessage
+    const agentDetails = await fetchExistingAgentDetails(apiKey, selectedAgent.agentId);
+    return {
+        agent: selectedAgent,
+        org: selectedOrg,
+        persona: agentDetails.persona,
+        welcomeMessage: agentDetails.welcomeMessage
+    };
 }
 /**
  * Handles the flow for creating a new agent.
@@ -115,3 +198,103 @@ async function createNewAgentFlow(apiKey) {
     const result = await createNewAgent(apiKey, selectedAgentType, businessConfig, metadata, features);
     return result;
 }
+/**
+ * Check if user has access to a specific agent
+ */
+function checkUserHasAccessToAgent(userData, agentId) {
+    const orgs = userData.admin.orgs;
+    for (const org of orgs) {
+        const agent = org.agents.find((a) => a.agentId === agentId);
+        if (agent) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Handle switching to a different agent
+ */
+async function handleAgentSwitch(userData, apiKey, existingYaml) {
+    writeInfo("\n🔄 Let's switch to a different agent...\n");
+    // Prompt for agent choice
+    const agentChoice = await promptAgentChoice();
+    let selectedAgent;
+    let selectedOrg;
+    let persona;
+    let welcomeMessage;
+    if (agentChoice === "existing") {
+        // Select existing agent
+        const result = await selectExistingAgent(userData, apiKey);
+        selectedAgent = result.agent;
+        selectedOrg = result.org;
+        persona = result.persona;
+        welcomeMessage = result.welcomeMessage;
+    }
+    else {
+        // Create new agent
+        const result = await createNewAgentFlow(apiKey);
+        selectedAgent = result.agent;
+        selectedOrg = result.org;
+        persona = result.persona;
+        welcomeMessage = result.welcomeMessage;
+    }
+    // Ask about persona and welcome message
+    const finalPersona = await promptPersonaReplacement(existingYaml, persona);
+    const finalWelcomeMessage = await promptWelcomeMessageReplacement(existingYaml, welcomeMessage);
+    // Update existing YAML file with new agent
+    writeInfo("\n📝 Updating lua.skill.yaml with new agent...");
+    updateYamlAgent(selectedAgent.agentId, selectedOrg.id, finalPersona, finalWelcomeMessage);
+    writeSuccess("✅ lua.skill.yaml updated successfully!");
+    writeInfo("\n💡 Your project now uses the new agent. Run 'lua compile' to update your skills.\n");
+}
+/**
+ * Prompt user about replacing existing persona
+ */
+async function promptPersonaReplacement(existingYaml, newPersona) {
+    const existingPersona = existingYaml?.agent?.persona;
+    // If no existing persona, use new one
+    if (!existingPersona) {
+        return newPersona;
+    }
+    // If no new persona, keep existing
+    if (!newPersona) {
+        return existingPersona;
+    }
+    // Both exist - ask user
+    writeInfo("\n📝 Persona Configuration:");
+    writeInfo("   Existing persona found in project");
+    const { replacePersona } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'replacePersona',
+            message: 'Replace existing persona with the new agent\'s persona?',
+            default: false
+        }
+    ]);
+    return replacePersona ? newPersona : existingPersona;
+}
+/**
+ * Prompt user about replacing existing welcome message
+ */
+async function promptWelcomeMessageReplacement(existingYaml, newWelcomeMessage) {
+    const existingWelcomeMessage = existingYaml?.agent?.welcomeMessage;
+    // If no existing welcome message, use new one
+    if (!existingWelcomeMessage) {
+        return newWelcomeMessage;
+    }
+    // If no new welcome message, keep existing
+    if (!newWelcomeMessage) {
+        return existingWelcomeMessage;
+    }
+    // Both exist - ask user
+    writeInfo("   Existing welcome message found in project");
+    const { replaceWelcomeMessage } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'replaceWelcomeMessage',
+            message: 'Replace existing welcome message with the new agent\'s welcome message?',
+            default: false
+        }
+    ]);
+    return replaceWelcomeMessage ? newWelcomeMessage : existingWelcomeMessage;
+}

package/dist/commands/logs.js

@@ -160,7 +160,9 @@ function displayLogs(logs, pagination, title) {
         writeInfo("No logs found.");
         return;
     }
-    logs.forEach((log, index) => {
+    // Reverse logs so latest appears at the bottom (oldest first, newest last)
+    const reversedLogs = [...logs].reverse();
+    reversedLogs.forEach((log, index) => {
         const timestamp = new Date(log.timestamp).toLocaleString();
         const icon = getLogIcon(log.subType);
         const color = getLogColor(log.subType);
@@ -179,7 +181,7 @@ function displayLogs(logs, pagination, title) {
             ? log.message.substring(0, 200) + '...'
             : log.message;
         console.log(`   ${message}`);
-        if (index < logs.length - 1) {
+        if (index < reversedLogs.length - 1) {
             console.log(chalk.gray(`   ${'-'.repeat(78)}`));
         }
     });

package/dist/commands/push.js

@@ -85,7 +85,14 @@ export async function pushCommand() {
         writeProgress("🔄 Pushing version to server...");
         const result = await pushVersion(apiKey, agentId, skillId, skillDeployData);
         if (result.success && result.data) {
-            writeSuccess(`✅ Version ${result.data.version} of "${selectedSkill.name}" pushed successfully`);
+            const pushedVersion = result.data.version;
+            writeSuccess(`✅ Version ${pushedVersion} of "${selectedSkill.name}" pushed successfully`);
+            // Update YAML with the version returned from server (in case it's different)
+            if (pushedVersion !== selectedSkill.version) {
+                writeInfo(`📝 Updating YAML with server version: ${pushedVersion}`);
+                updateSkillVersionInYaml(selectedSkill.name, pushedVersion);
+                selectedSkill.version = pushedVersion;
+            }
             // Ask if user wants to deploy now
             const deployAnswer = await safePrompt([
                 {
@@ -96,7 +103,7 @@ export async function pushCommand() {
                 }
             ]);
             if (deployAnswer && deployAnswer.deployNow) {
-                await deployVersionAfterPush(apiKey, config.agent.agentId, selectedSkill, result.data.version);
+                await deployVersionAfterPush(apiKey, config.agent.agentId, selectedSkill, pushedVersion);
             }
         }
         else if (result.error) {
@@ -145,6 +152,9 @@ async function deployVersionAfterPush(apiKey, agentId, selectedSkill, pushedVers
         writeProgress("🔄 Publishing version...");
         const publishResponse = await publishVersion(apiKey, agentId, selectedSkill.skillId, pushedVersion);
         writeSuccess(`\n✅ Version ${pushedVersion} of "${selectedSkill.name}" deployed successfully to production\n`);
+        // Update YAML with deployed version (should already be updated from push, but ensure consistency)
+        writeInfo(`📝 Ensuring YAML is updated with deployed version: ${pushedVersion}`);
+        updateSkillVersionInYaml(selectedSkill.name, pushedVersion);
     }
     catch (error) {
         console.error('\n❌ Error deploying version:', error);

package/dist/utils/files.d.ts

@@ -2,4 +2,8 @@ export declare function copyTemplateFiles(templateDir: string, targetDir: string
 export declare function createSkillYaml(agentId: string, orgId: string, skillName?: string, skillId?: string, persona?: string, welcomeMessage?: string): void;
 export declare function readSkillYaml(): any;
 export declare function readSkillConfig(): any;
+/**
+ * Update only the agent information in an existing YAML file
+ */
+export declare function updateYamlAgent(agentId: string, orgId: string, persona?: string, welcomeMessage?: string): void;
 export declare function updateSkillYamlPersona(persona: string, welcomeMessage?: string): void;

package/dist/utils/files.js

@@ -78,6 +78,33 @@ export function readSkillConfig() {
     // Read YAML config file
     return readSkillYaml();
 }
+/**
+ * Update only the agent information in an existing YAML file
+ */
+export function updateYamlAgent(agentId, orgId, persona, welcomeMessage) {
+    const yamlPath = path.join(process.cwd(), 'lua.skill.yaml');
+    if (!fs.existsSync(yamlPath)) {
+        throw new Error('lua.skill.yaml not found');
+    }
+    const config = readSkillYaml();
+    // Update agent information
+    config.agent = config.agent || {};
+    config.agent.agentId = agentId;
+    config.agent.orgId = orgId;
+    if (persona) {
+        config.agent.persona = persona;
+    }
+    if (welcomeMessage) {
+        config.agent.welcomeMessage = welcomeMessage;
+    }
+    // Write back to file
+    const yamlContent = dump(config, {
+        indent: 2,
+        lineWidth: -1,
+        noRefs: true
+    });
+    fs.writeFileSync(yamlPath, yamlContent);
+}
 export function updateSkillYamlPersona(persona, welcomeMessage) {
     const yamlPath = path.join(process.cwd(), 'lua.skill.yaml');
     if (!fs.existsSync(yamlPath)) {

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

@@ -32,3 +32,16 @@ export declare function selectBaseAgentType(agentTypes: AgentType[]): AgentType;
  * @throws Error if agent creation fails
  */
 export declare function createNewAgent(apiKey: string, agentType: AgentType, businessConfig: BusinessConfig, metadata: Record<string, any>, features: Record<string, boolean>): Promise<AgentCreationResult>;
+/**
+ * Fetches detailed agent information for an existing agent.
+ * Used when selecting an existing agent during init.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID to fetch
+ * @returns Agent details including persona and welcome message
+ * @throws Error if fetch fails
+ */
+export declare function fetchExistingAgentDetails(apiKey: string, agentId: string): Promise<{
+    persona?: string;
+    welcomeMessage?: string;
+}>;

package/dist/utils/init-agent.js

@@ -127,3 +127,16 @@ async function fetchAgentDetails(agentApi, agentId) {
         welcomeMessage: agentDetailsResult.data.welcomeMessage
     };
 }
+/**
+ * Fetches detailed agent information for an existing agent.
+ * Used when selecting an existing agent during init.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID to fetch
+ * @returns Agent details including persona and welcome message
+ * @throws Error if fetch fails
+ */
+export async function fetchExistingAgentDetails(apiKey, agentId) {
+    const agentApi = new AgentApi(BASE_URLS.API, apiKey);
+    return fetchAgentDetails(agentApi, agentId);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lua-cli",
-  "version": "2.5.5",
+  "version": "2.5.6",
   "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/package.json

@@ -19,7 +19,7 @@
     "axios": "^1.6.0",
     "inquirer": "^12.9.6",
     "js-yaml": "^4.1.0",
-    "lua-cli": "^2.5.5",
+    "lua-cli": "^2.5.6",
     "openai": "^5.23.0",
     "uuid": "^13.0.0",
     "zod": "^3.24.1"