lua-cli 2.5.4 → 2.5.6

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

@@ -0,0 +1,54 @@
+import { HttpClient } from "../common/http.client.js";
+import { ApiResponse } from "../interfaces/common.js";
+/**
+ * Environment variables response structure from the API
+ * The actual environment variables are nested in the 'data' property
+ */
+interface EnvironmentVariablesResponse {
+    data: Record<string, string>;
+    _id?: string;
+    agentId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    __v?: number;
+}
+/**
+ * Developer API calls for agent management and configuration
+ */
+export default class DeveloperApi extends HttpClient {
+    private apiKey;
+    private agentId;
+    /**
+     * Creates an instance of DeveloperApi
+     * @param baseUrl - The base URL for the API
+     * @param apiKey - The API key for authentication
+     * @param agentId - The unique identifier of the agent
+     */
+    constructor(baseUrl: string, apiKey: string, agentId: string);
+    /**
+     * Retrieves all environment variables for the agent in production
+     * The response includes metadata (_id, agentId, timestamps) and the actual env vars in the 'data' property
+     * @returns Promise resolving to an ApiResponse containing environment variables and metadata
+     * @throws Error if the API request fails or the agent is not found
+     */
+    getEnvironmentVariables(): Promise<ApiResponse<EnvironmentVariablesResponse>>;
+    /**
+     * Updates all environment variables for the agent in production
+     * This operation replaces all existing environment variables with the provided set
+     * @param envData - Object containing environment variable key-value pairs
+     * @returns Promise resolving to an ApiResponse with the updated environment variables and metadata
+     * @throws Error if the API request fails or the agent is not found
+     */
+    updateEnvironmentVariables(envData: Record<string, string>): Promise<ApiResponse<EnvironmentVariablesResponse>>;
+    /**
+     * Deletes a specific environment variable by key
+     * @param key - The environment variable key to delete
+     * @returns Promise resolving to an ApiResponse with confirmation
+     * @throws Error if the API request fails, the agent is not found, or the key doesn't exist
+     */
+    deleteEnvironmentVariable(key: string): Promise<ApiResponse<{
+        message: string;
+        key: string;
+    }>>;
+}
+export {};

package/dist/api/developer.api.service.js

@@ -0,0 +1,51 @@
+import { HttpClient } from "../common/http.client.js";
+/**
+ * Developer API calls for agent management and configuration
+ */
+export default class DeveloperApi extends HttpClient {
+    /**
+     * Creates an instance of DeveloperApi
+     * @param baseUrl - The base URL for the API
+     * @param apiKey - The API key for authentication
+     * @param agentId - The unique identifier of the agent
+     */
+    constructor(baseUrl, apiKey, agentId) {
+        super(baseUrl);
+        this.apiKey = apiKey;
+        this.agentId = agentId;
+    }
+    /**
+     * Retrieves all environment variables for the agent in production
+     * The response includes metadata (_id, agentId, timestamps) and the actual env vars in the 'data' property
+     * @returns Promise resolving to an ApiResponse containing environment variables and metadata
+     * @throws Error if the API request fails or the agent is not found
+     */
+    async getEnvironmentVariables() {
+        return this.httpGet(`/developer/agents/${this.agentId}/env`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Updates all environment variables for the agent in production
+     * This operation replaces all existing environment variables with the provided set
+     * @param envData - Object containing environment variable key-value pairs
+     * @returns Promise resolving to an ApiResponse with the updated environment variables and metadata
+     * @throws Error if the API request fails or the agent is not found
+     */
+    async updateEnvironmentVariables(envData) {
+        return this.httpPost(`/developer/agents/${this.agentId}/env`, envData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Deletes a specific environment variable by key
+     * @param key - The environment variable key to delete
+     * @returns Promise resolving to an ApiResponse with confirmation
+     * @throws Error if the API request fails, the agent is not found, or the key doesn't exist
+     */
+    async deleteEnvironmentVariable(key) {
+        return this.httpDelete(`/developer/agents/${this.agentId}/env/${key}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+}

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

@@ -1,6 +1,7 @@
 import { DevVersionResponse, UpdateDevVersionResponse } from "../interfaces/dev.js";
 import { HttpClient } from "../common/http.client.js";
 import { ApiResponse } from "../interfaces/common.js";
+import { GetSkillsResponse, DeleteSkillResponse } from "../interfaces/skills.js";
 /**
  * Skill API calls
  */
@@ -14,6 +15,12 @@ export default class SkillApi extends HttpClient {
      * @param agentId - The unique identifier of the agent
      */
     constructor(baseUrl: string, apiKey: string, agentId: string);
+    /**
+     * Retrieves all skills for the agent
+     * @returns Promise resolving to an ApiResponse containing an array of skills with their versions and tools
+     * @throws Error if the API request fails or the agent is not found
+     */
+    getSkills(): Promise<ApiResponse<GetSkillsResponse>>;
     /**
      * Creates a new skill for the agent
      * @param skillData - The skill data including name, description, and optional context
@@ -74,4 +81,13 @@ export default class SkillApi extends HttpClient {
         activeVersionId: string;
         publishedAt: string;
     }>>;
+    /**
+     * Deletes a skill and all its versions, or deactivates it if it has versions
+     * @param skillId - The unique identifier of the skill to delete
+     * @returns Promise resolving to an ApiResponse with deletion status
+     *   - If deleted is true: skill was successfully deleted
+     *   - If deleted is false and deactivated is true: skill has versions and was deactivated instead
+     * @throws Error if the skill is not found or the delete operation fails
+     */
+    deleteSkill(skillId: string): Promise<ApiResponse<DeleteSkillResponse>>;
 }

package/dist/api/skills.api.service.js

@@ -14,6 +14,16 @@ export default class SkillApi extends HttpClient {
         this.apiKey = apiKey;
         this.agentId = agentId;
     }
+    /**
+     * Retrieves all skills for the agent
+     * @returns Promise resolving to an ApiResponse containing an array of skills with their versions and tools
+     * @throws Error if the API request fails or the agent is not found
+     */
+    async getSkills() {
+        return this.httpGet(`/developer/skills/${this.agentId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
     /**
      * Creates a new skill for the agent
      * @param skillData - The skill data including name, description, and optional context
@@ -85,4 +95,17 @@ export default class SkillApi extends HttpClient {
             Authorization: `Bearer ${this.apiKey}`,
         });
     }
+    /**
+     * Deletes a skill and all its versions, or deactivates it if it has versions
+     * @param skillId - The unique identifier of the skill to delete
+     * @returns Promise resolving to an ApiResponse with deletion status
+     *   - If deleted is true: skill was successfully deleted
+     *   - If deleted is false and deactivated is true: skill has versions and was deactivated instead
+     * @throws Error if the skill is not found or the delete operation fails
+     */
+    async deleteSkill(skillId) {
+        return this.httpDelete(`/developer/skills/${this.agentId}/${skillId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
 }

package/dist/commands/compile.d.ts

@@ -12,6 +12,8 @@
  * 4. Extracts execute code and schemas from bundled tools
  * 5. Bundles the main index file
  * 6. Creates deployment data in both new and legacy formats
+ * 7. Syncs lua.skill.yaml with deploy.json (removes deleted skills from YAML)
+ * 8. Syncs server with YAML (deletes/deactivates skills not in YAML)
  *
  * Output:
  * - dist/deployment.json - New deployment format with tool references
@@ -19,6 +21,11 @@
  * - dist/index.js - Main skill entry point
  * - .lua/deploy.json - Legacy deployment format with compressed tools
  * - .lua/*.js - Individual uncompressed tool files for debugging
+ * - lua.skill.yaml - Updated to match compiled skills
+ *
+ * Server Sync:
+ * - Skills deleted from code are removed from YAML
+ * - Skills not in YAML are deleted from server (or deactivated if they have versions)
  *
  * @returns Promise that resolves when compilation is complete
  */

package/dist/commands/compile.js

@@ -10,6 +10,8 @@ import { findIndexFile } from '../utils/compile.js';
 import { detectTools } from '../utils/tool-detection.js';
 import { bundleTool, bundleMainIndex, extractExecuteCode } from '../utils/bundling.js';
 import { createDeploymentData, createLegacyDeploymentData } from '../utils/deployment.js';
+import { syncYamlWithDeployJson, syncServerSkillsWithYaml } from '../utils/skill-management.js';
+import { readSkillConfig } from '../utils/files.js';
 import { COMPILE_DIRS, COMPILE_FILES } from '../config/compile.constants.js';
 /**
  * Main compile command - orchestrates the entire skill compilation process.
@@ -21,6 +23,8 @@ import { COMPILE_DIRS, COMPILE_FILES } from '../config/compile.constants.js';
  * 4. Extracts execute code and schemas from bundled tools
  * 5. Bundles the main index file
  * 6. Creates deployment data in both new and legacy formats
+ * 7. Syncs lua.skill.yaml with deploy.json (removes deleted skills from YAML)
+ * 8. Syncs server with YAML (deletes/deactivates skills not in YAML)
  *
  * Output:
  * - dist/deployment.json - New deployment format with tool references
@@ -28,6 +32,11 @@ import { COMPILE_DIRS, COMPILE_FILES } from '../config/compile.constants.js';
  * - dist/index.js - Main skill entry point
  * - .lua/deploy.json - Legacy deployment format with compressed tools
  * - .lua/*.js - Individual uncompressed tool files for debugging
+ * - lua.skill.yaml - Updated to match compiled skills
+ *
+ * Server Sync:
+ * - Skills deleted from code are removed from YAML
+ * - Skills not in YAML are deleted from server (or deactivated if they have versions)
  *
  * @returns Promise that resolves when compilation is complete
  */
@@ -52,6 +61,15 @@ export async function compileCommand() {
         // Step 5: Create deployment data in both formats
         await createDeploymentData(tools, distDir);
         await createLegacyDeploymentData(tools, luaDir, indexFile);
+        // Step 6: Sync YAML with deploy.json
+        writeProgress("🔄 Syncing YAML with deploy.json...");
+        const deployJsonPath = path.join(luaDir, COMPILE_FILES.DEPLOY_JSON);
+        const config = readSkillConfig();
+        await syncYamlWithDeployJson(deployJsonPath, config);
+        // Step 7: Sync server with YAML (delete skills not in YAML)
+        writeProgress("🔄 Syncing server with YAML...");
+        const updatedConfig = readSkillConfig(); // Re-read config after YAML sync
+        await syncServerSkillsWithYaml(updatedConfig);
         writeSuccess(`✅ Skill compiled successfully - ${tools.length} tools bundled`);
     }, "compilation");
 }

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/env.js

@@ -10,6 +10,7 @@ import { readSkillConfig } from '../utils/files.js';
 import { withErrorHandling, writeProgress, writeSuccess } from '../utils/cli.js';
 import { BASE_URLS } from '../config/constants.js';
 import { validateConfig, validateAgentConfig, } from '../utils/dev-helpers.js';
+import DeveloperApi from '../api/developer.api.service.js';
 /**
  * Main env command - manages environment variables
  *
@@ -57,6 +58,7 @@ export async function envCommand() {
             }
             await checkApiKey(apiKey);
             context.apiKey = apiKey;
+            context.developerApi = new DeveloperApi(BASE_URLS.API, apiKey, agentId);
             writeProgress("✅ Authenticated");
         }
         // Step 4: Start management loop
@@ -160,19 +162,22 @@ function loadSandboxEnvVariables() {
  */
 async function loadProductionEnvVariables(context) {
     try {
-        const response = await fetch(`${BASE_URLS.API}/developer/agents/${context.agentId}/env`, {
-            method: 'GET',
-            headers: {
-                'accept': 'application/json',
-                'Authorization': `Bearer ${context.apiKey}`
-            }
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
+        if (!context.developerApi) {
+            throw new Error('Developer API not initialized');
+        }
+        const response = await context.developerApi.getEnvironmentVariables();
+        if (!response.success) {
+            throw new Error(response.error?.message || 'Failed to load environment variables');
         }
-        const data = await response.json();
-        if (data.data && typeof data.data === 'object') {
-            return Object.entries(data.data).map(([key, value]) => ({
+        // The API returns environment variables nested in a 'data' property
+        // Response structure: { success: true, data: { data: { KEY: "value", ... }, _id: "...", ... } }
+        const envData = response.data?.data || response.data;
+        if (envData && typeof envData === 'object') {
+            // Filter out metadata fields like _id, agentId, createdAt, updatedAt, __v
+            const metadataKeys = ['_id', 'agentId', 'data', 'createdAt', 'updatedAt', '__v'];
+            return Object.entries(envData)
+                .filter(([key]) => !metadataKeys.includes(key))
+                .map(([key, value]) => ({
                 key,
                 value: String(value)
             }));
@@ -231,23 +236,18 @@ function saveSandboxEnvVariables(variables) {
  */
 async function saveProductionEnvVariables(context, variables) {
     try {
+        if (!context.developerApi) {
+            throw new Error('Developer API not initialized');
+        }
         const envData = {};
         variables.forEach(v => {
             if (v.key.trim()) {
                 envData[v.key.trim()] = v.value;
             }
         });
-        const response = await fetch(`${BASE_URLS.API}/developer/agents/${context.agentId}/env`, {
-            method: 'POST',
-            headers: {
-                'accept': 'application/json',
-                'Authorization': `Bearer ${context.apiKey}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify(envData)
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
+        const response = await context.developerApi.updateEnvironmentVariables(envData);
+        if (!response.success) {
+            throw new Error(response.error?.message || 'Failed to save environment variables');
         }
         return true;
     }
@@ -383,14 +383,30 @@ async function deleteVariable(context, currentVariables) {
         console.log("\nℹ️  Deletion cancelled.\n");
         return;
     }
-    const updatedVariables = currentVariables.filter(v => v.key !== selectedKey);
-    writeProgress("🔄 Saving...");
+    writeProgress("🔄 Deleting...");
     let success = false;
     if (context.environment === 'sandbox') {
+        const updatedVariables = currentVariables.filter(v => v.key !== selectedKey);
         success = saveSandboxEnvVariables(updatedVariables);
     }
     else {
-        success = await saveProductionEnvVariables(context, updatedVariables);
+        // Use the dedicated delete API endpoint for production
+        if (!context.developerApi) {
+            console.error("❌ Developer API not initialized");
+            return;
+        }
+        try {
+            const response = await context.developerApi.deleteEnvironmentVariable(selectedKey);
+            if (response.success) {
+                success = true;
+            }
+            else {
+                console.error(`❌ ${response.error?.message || 'Failed to delete variable'}`);
+            }
+        }
+        catch (error) {
+            console.error('❌ Error deleting production env variable:', error);
+        }
     }
     if (success) {
         writeSuccess(`✅ Variable "${selectedKey}" deleted successfully`);

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)}`));
         }
     });