lua-cli 2.5.4 → 2.5.6

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

@@ -0,0 +1,51 @@
+/**
+ * Skills Interfaces
+ * Structures for skill management
+ */
+/**
+ * Tool definition within a skill version
+ */
+export interface SkillTool {
+    name: string;
+    description: string;
+}
+/**
+ * Skill version information
+ */
+export interface SkillVersion {
+    id: string;
+    version: string;
+    description: string;
+    active: boolean;
+    context: string;
+    tools: SkillTool[];
+}
+/**
+ * Skill information
+ */
+export interface Skill {
+    id: string;
+    name: string;
+    description: string;
+    public: boolean;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+    versions: SkillVersion[];
+}
+/**
+ * Response from get all skills API endpoint
+ */
+export interface GetSkillsResponse {
+    skills: Skill[];
+}
+/**
+ * Response from delete skill API endpoint
+ * If deleted is false and deactivated is true, the skill has versions
+ * and cannot be deleted, so it was deactivated instead
+ */
+export interface DeleteSkillResponse {
+    message: string;
+    deleted: boolean;
+    deactivated: boolean;
+}

package/dist/interfaces/skills.js

@@ -0,0 +1,5 @@
+/**
+ * Skills Interfaces
+ * Structures for skill management
+ */
+export {};

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/dist/utils/skill-management.d.ts

@@ -12,3 +12,23 @@ import { SkillConfig } from '../types/compile.types.js';
  * @returns Updated skills array with valid skill IDs
  */
 export declare function ensureSkillsExistInYaml(skillsArray: any[], config: SkillConfig): Promise<any[]>;
+/**
+ * Updates the YAML file with skills from the deploy.json file.
+ * This ensures the YAML reflects what's actually in the compiled code.
+ * Only updates skill entries that already exist in YAML (preserves skillId).
+ * Removes skills from YAML that are no longer in deploy.json.
+ *
+ * @param deployJsonPath - Path to the deploy.json file
+ * @param config - Current skill configuration
+ */
+export declare function syncYamlWithDeployJson(deployJsonPath: string, config: SkillConfig): Promise<void>;
+/**
+ * Syncs the server skills with the YAML configuration.
+ * Performs a two-way sync:
+ * 1. Deletes/deactivates skills from server that aren't in YAML
+ * 2. Updates YAML with active version numbers from server
+ *
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Array of messages about sync operations
+ */
+export declare function syncServerSkillsWithYaml(config: SkillConfig): Promise<string[]>;

package/dist/utils/skill-management.js

@@ -146,3 +146,162 @@ async function updateYamlWithSkills(skills, config) {
     });
     fs.writeFileSync(yamlPath, yamlContent);
 }
+/**
+ * Updates the YAML file with skills from the deploy.json file.
+ * This ensures the YAML reflects what's actually in the compiled code.
+ * Only updates skill entries that already exist in YAML (preserves skillId).
+ * Removes skills from YAML that are no longer in deploy.json.
+ *
+ * @param deployJsonPath - Path to the deploy.json file
+ * @param config - Current skill configuration
+ */
+export async function syncYamlWithDeployJson(deployJsonPath, config) {
+    try {
+        // Read deploy.json
+        if (!fs.existsSync(deployJsonPath)) {
+            console.warn("⚠️  deploy.json not found. Skipping YAML sync.");
+            return;
+        }
+        const deployData = JSON.parse(fs.readFileSync(deployJsonPath, 'utf8'));
+        const deploySkills = deployData.skills || [];
+        // Create map of deploy skills by name
+        const deploySkillsMap = new Map();
+        deploySkills.forEach((skill) => {
+            deploySkillsMap.set(skill.name, skill);
+        });
+        // Get existing YAML skills
+        const existingYamlSkills = config?.skills || [];
+        // Update YAML skills to match deploy.json
+        const updatedSkills = existingYamlSkills
+            .filter((yamlSkill) => {
+            // Keep only skills that exist in deploy.json
+            return deploySkillsMap.has(yamlSkill.name);
+        })
+            .map((yamlSkill) => {
+            // Update version and description from deploy.json if available
+            const deploySkill = deploySkillsMap.get(yamlSkill.name);
+            return {
+                name: yamlSkill.name,
+                version: deploySkill?.version || yamlSkill.version || SKILL_DEFAULTS.VERSION,
+                skillId: yamlSkill.skillId || ''
+            };
+        });
+        // Add new skills from deploy.json that aren't in YAML yet
+        deploySkills.forEach((deploySkill) => {
+            const existsInYaml = updatedSkills.some((s) => s.name === deploySkill.name);
+            if (!existsInYaml) {
+                updatedSkills.push({
+                    name: deploySkill.name,
+                    version: deploySkill.version || SKILL_DEFAULTS.VERSION,
+                    skillId: '' // Will be created via API later
+                });
+            }
+        });
+        // Update YAML file
+        await updateYamlWithSkills(updatedSkills, config);
+        console.log("✅ YAML synced with deploy.json");
+    }
+    catch (error) {
+        console.error("❌ Error syncing YAML with deploy.json:", error);
+    }
+}
+/**
+ * Syncs the server skills with the YAML configuration.
+ * Performs a two-way sync:
+ * 1. Deletes/deactivates skills from server that aren't in YAML
+ * 2. Updates YAML with active version numbers from server
+ *
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Array of messages about sync operations
+ */
+export async function syncServerSkillsWithYaml(config) {
+    const messages = [];
+    let yamlNeedsUpdate = false;
+    try {
+        // Validate prerequisites
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.warn("⚠️  No API key found. Skipping server sync.");
+            return messages;
+        }
+        const agentId = config?.agent?.agentId;
+        if (!agentId) {
+            console.warn("⚠️  No agent ID found in lua.skill.yaml. Skipping server sync.");
+            return messages;
+        }
+        // Get skills from server
+        const skillApi = new SkillApi(BASE_URLS.API, apiKey, agentId);
+        const serverSkillsResponse = await skillApi.getSkills();
+        if (!serverSkillsResponse.success || !serverSkillsResponse.data?.skills) {
+            console.warn("⚠️  Could not retrieve server skills. Skipping server sync.");
+            return messages;
+        }
+        const serverSkills = serverSkillsResponse.data.skills;
+        const yamlSkills = config?.skills || [];
+        // Create maps for efficient lookup
+        const yamlSkillsMap = new Map(yamlSkills
+            .filter((skill) => skill.skillId)
+            .map((skill) => [skill.skillId, skill]));
+        const serverSkillsMap = new Map(serverSkills.map(skill => [skill.id, skill]));
+        // Part 1: Delete skills from server that aren't in YAML
+        const skillsToDelete = serverSkills.filter(serverSkill => !yamlSkillsMap.has(serverSkill.id));
+        for (const skill of skillsToDelete) {
+            try {
+                const deleteResponse = await skillApi.deleteSkill(skill.id);
+                if (deleteResponse.success && deleteResponse.data) {
+                    if (deleteResponse.data.deleted) {
+                        const msg = `✅ Deleted skill "${skill.name}" from server`;
+                        messages.push(msg);
+                        console.log(msg);
+                    }
+                    else if (deleteResponse.data.deactivated) {
+                        const msg = `⚠️  Skill "${skill.name}" has versions and cannot be deleted. It has been deactivated instead.`;
+                        messages.push(msg);
+                        console.warn(msg);
+                    }
+                }
+                else {
+                    const msg = `❌ Failed to delete skill "${skill.name}": ${deleteResponse.error?.message || 'Unknown error'}`;
+                    messages.push(msg);
+                    console.error(msg);
+                }
+            }
+            catch (error) {
+                const msg = `❌ Error deleting skill "${skill.name}": ${error}`;
+                messages.push(msg);
+                console.error(msg);
+            }
+        }
+        // Part 2: Sync version numbers from server to YAML
+        const updatedYamlSkills = yamlSkills.map((yamlSkill) => {
+            const serverSkill = serverSkillsMap.get(yamlSkill.skillId);
+            if (serverSkill && serverSkill.versions && serverSkill.versions.length > 0) {
+                // Find the active version on the server
+                const activeVersion = serverSkill.versions.find((v) => v.active);
+                if (activeVersion && activeVersion.version !== yamlSkill.version) {
+                    const msg = `📝 Updated "${yamlSkill.name}" version in YAML: ${yamlSkill.version} → ${activeVersion.version}`;
+                    messages.push(msg);
+                    console.log(msg);
+                    yamlNeedsUpdate = true;
+                    return {
+                        ...yamlSkill,
+                        version: activeVersion.version
+                    };
+                }
+            }
+            return yamlSkill;
+        });
+        // Update YAML file if versions changed
+        if (yamlNeedsUpdate) {
+            await updateYamlWithSkills(updatedYamlSkills, config);
+            console.log("✅ YAML versions synced with server");
+        }
+        if (skillsToDelete.length === 0 && !yamlNeedsUpdate) {
+            console.log("✅ Server and YAML are fully in sync");
+        }
+    }
+    catch (error) {
+        console.error("❌ Error syncing server skills:", error);
+    }
+    return messages;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lua-cli",
-  "version": "2.5.4",
+  "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.3",
+    "lua-cli": "^2.5.6",
     "openai": "^5.23.0",
     "uuid": "^13.0.0",
     "zod": "^3.24.1"