lua-cli 2.2.8-alpha.2 → 2.3.0-alpha.2

package/dist/utils/deploy-helpers.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Deploy Helper Utilities
+ * Helper functions for deployment operations
+ */
+import { VersionInfo } from '../interfaces/deploy.js';
+/**
+ * Formats a version for display in the selection list.
+ *
+ * @param version - Version information to format
+ * @returns Formatted string for display
+ */
+export declare function formatVersionChoice(version: VersionInfo): string;
+/**
+ * Sorts versions by creation date (newest first).
+ *
+ * @param versions - Array of versions to sort
+ * @returns Sorted array of versions
+ */
+export declare function sortVersionsByDate(versions: VersionInfo[]): VersionInfo[];
+/**
+ * Prompts user to select a version from available versions.
+ *
+ * @param versions - Array of available versions
+ * @returns Selected version string
+ */
+export declare function promptVersionSelection(versions: VersionInfo[]): Promise<string>;
+/**
+ * Prompts user to confirm deployment with warning.
+ *
+ * @returns True if confirmed, false otherwise
+ */
+export declare function confirmDeployment(): Promise<boolean>;
+/**
+ * Validates that configuration has required fields for deployment.
+ *
+ * @param config - Skill configuration
+ * @throws Error if configuration is invalid
+ */
+export declare function validateDeployConfig(config: any): void;
+/**
+ * Validates that versions are available for deployment.
+ *
+ * @param versions - Array of versions
+ * @throws Error if no versions are available
+ */
+export declare function validateVersionsAvailable(versions: VersionInfo[] | undefined): void;

package/dist/utils/deploy-helpers.js

@@ -0,0 +1,86 @@
+/**
+ * Deploy Helper Utilities
+ * Helper functions for deployment operations
+ */
+import inquirer from 'inquirer';
+import { clearPromptLines } from './cli.js';
+/**
+ * Formats a version for display in the selection list.
+ *
+ * @param version - Version information to format
+ * @returns Formatted string for display
+ */
+export function formatVersionChoice(version) {
+    const currentIndicator = version.isCurrent ? ' (CURRENT)' : '';
+    const date = new Date(version.createdDate).toLocaleDateString();
+    return `${version.version}${currentIndicator} - Created: ${date} by ${version.createdByEmail}`;
+}
+/**
+ * Sorts versions by creation date (newest first).
+ *
+ * @param versions - Array of versions to sort
+ * @returns Sorted array of versions
+ */
+export function sortVersionsByDate(versions) {
+    return versions.sort((a, b) => new Date(b.createdDate).getTime() - new Date(a.createdDate).getTime());
+}
+/**
+ * Prompts user to select a version from available versions.
+ *
+ * @param versions - Array of available versions
+ * @returns Selected version string
+ */
+export async function promptVersionSelection(versions) {
+    const { selectedVersion } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "selectedVersion",
+            message: "Select a version to deploy:",
+            choices: versions.map(version => ({
+                name: formatVersionChoice(version),
+                value: version.version
+            }))
+        }
+    ]);
+    clearPromptLines(2);
+    return selectedVersion;
+}
+/**
+ * Prompts user to confirm deployment with warning.
+ *
+ * @returns True if confirmed, false otherwise
+ */
+export async function confirmDeployment() {
+    const { confirmed } = await inquirer.prompt([
+        {
+            type: "confirm",
+            name: "confirmed",
+            message: "⚠️  Warning: This version will be deployed to all users. Do you want to proceed?",
+            default: false
+        }
+    ]);
+    clearPromptLines(2);
+    return confirmed;
+}
+/**
+ * Validates that configuration has required fields for deployment.
+ *
+ * @param config - Skill configuration
+ * @throws Error if configuration is invalid
+ */
+export function validateDeployConfig(config) {
+    if (!config || !config.agent?.agentId || !config.skill?.skillId) {
+        throw new Error("No lua.skill.yaml found or missing agentId/skillId. Please run this command from a skill directory.");
+    }
+}
+/**
+ * Validates that versions are available for deployment.
+ *
+ * @param versions - Array of versions
+ * @throws Error if no versions are available
+ */
+export function validateVersionsAvailable(versions) {
+    if (!versions || versions.length === 0) {
+        throw new Error("No versions found for this skill.");
+    }
+}

package/dist/utils/deployment.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Deployment Data Generation Utilities
+ * Handles creation of deployment files in both new and legacy formats
+ */
+import { ToolInfo } from '../interfaces/compile.js';
+import { TypeScriptSourceFile } from '../types/compile.types.js';
+/**
+ * Creates deployment data in the new format.
+ * This format includes skill metadata and tool references.
+ * Output: dist/deployment.json
+ *
+ * @param tools - Array of detected tools
+ * @param distDir - Distribution directory for output
+ */
+export declare function createDeploymentData(tools: ToolInfo[], distDir: string): Promise<void>;
+/**
+ * Creates deployment data in the legacy format.
+ * This format includes compressed tool code and is used for backwards compatibility.
+ * Output: .lua/deploy.json and individual tool files
+ *
+ * @param tools - Array of detected tools
+ * @param luaDir - Legacy .lua directory for output
+ * @param indexFile - The TypeScript source file for the index
+ */
+export declare function createLegacyDeploymentData(tools: ToolInfo[], luaDir: string, indexFile: TypeScriptSourceFile): Promise<void>;

package/dist/utils/deployment.js

@@ -0,0 +1,161 @@
+/**
+ * Deployment Data Generation Utilities
+ * Handles creation of deployment files in both new and legacy formats
+ */
+import fs from "fs";
+import path from "path";
+import { Node } from "ts-morph";
+import { readSkillConfig } from './files.js';
+import { COMPILE_DIRS, COMPILE_FILES, SKILL_DEFAULTS, DEFAULT_INPUT_SCHEMA, JSON_FORMAT, } from '../config/compile.constants.js';
+import { compressCode, extractSkillsMetadata, } from './compile.js';
+import { ensureSkillsExistInYaml } from './skill-management.js';
+/**
+ * Creates deployment data in the new format.
+ * This format includes skill metadata and tool references.
+ * Output: dist/deployment.json
+ *
+ * @param tools - Array of detected tools
+ * @param distDir - Distribution directory for output
+ */
+export async function createDeploymentData(tools, distDir) {
+    const config = readSkillConfig();
+    const packageJson = readPackageJson();
+    const deploymentData = {
+        name: config?.skill?.name || packageJson.name || SKILL_DEFAULTS.NAME,
+        version: config?.skill?.version || packageJson.version || SKILL_DEFAULTS.VERSION,
+        skillId: config?.skill?.skillId || '',
+        description: config?.skill?.description || packageJson.description || SKILL_DEFAULTS.DESCRIPTION,
+        context: config?.skill?.context || SKILL_DEFAULTS.CONTEXT,
+        tools: tools.map(tool => ({
+            name: tool.name,
+            className: tool.className,
+            description: tool.description || '',
+            filePath: `${COMPILE_DIRS.TOOLS}/${tool.className}.js`
+        }))
+    };
+    fs.writeFileSync(path.join(distDir, COMPILE_FILES.DEPLOYMENT_JSON), JSON.stringify(deploymentData, null, JSON_FORMAT.INDENT));
+}
+/**
+ * Reads and parses the package.json file.
+ *
+ * @returns The parsed package.json content
+ */
+function readPackageJson() {
+    const packageJsonPath = path.join(process.cwd(), COMPILE_FILES.PACKAGE_JSON);
+    return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+}
+/**
+ * Creates deployment data in the legacy format.
+ * This format includes compressed tool code and is used for backwards compatibility.
+ * Output: .lua/deploy.json and individual tool files
+ *
+ * @param tools - Array of detected tools
+ * @param luaDir - Legacy .lua directory for output
+ * @param indexFile - The TypeScript source file for the index
+ */
+export async function createLegacyDeploymentData(tools, luaDir, indexFile) {
+    const config = readSkillConfig();
+    const skillsMetadata = extractSkillsMetadata(indexFile);
+    // Map tools to their parent skills
+    const skillToTools = mapToolsToSkills(indexFile);
+    // Build skills array with their associated tools
+    const skillsArray = buildSkillsArray(skillsMetadata, skillToTools, tools);
+    // Ensure all skills exist in YAML config and have valid IDs
+    const updatedSkillsArray = await ensureSkillsExistInYaml(skillsArray, config);
+    // Write deployment data
+    const deployData = {
+        skills: updatedSkillsArray
+    };
+    fs.writeFileSync(path.join(luaDir, COMPILE_FILES.DEPLOY_JSON), JSON.stringify(deployData, null, JSON_FORMAT.INDENT));
+    // Write individual tool files (uncompressed for debugging)
+    writeIndividualToolFiles(tools, luaDir);
+}
+/**
+ * Maps tools to their parent skills by analyzing addTools calls in the source code.
+ *
+ * @param indexFile - The TypeScript source file to analyze
+ * @returns Map of skill variable names to their tool class names
+ */
+function mapToolsToSkills(indexFile) {
+    const skillToTools = new Map();
+    indexFile.forEachDescendant((node) => {
+        if (Node.isCallExpression(node)) {
+            const expression = node.getExpression();
+            if (Node.isPropertyAccessExpression(expression) && expression.getName() === 'addTools') {
+                const object = expression.getExpression();
+                const objectName = object.getText();
+                const args = node.getArguments();
+                if (args.length > 0 && Node.isArrayLiteralExpression(args[0])) {
+                    const toolsArray = args[0];
+                    const toolNames = toolsArray.getElements()
+                        .map((element) => {
+                        if (Node.isNewExpression(element)) {
+                            return element.getExpression().getText();
+                        }
+                        return '';
+                    })
+                        .filter(name => name);
+                    skillToTools.set(objectName, toolNames);
+                }
+            }
+        }
+    });
+    return skillToTools;
+}
+/**
+ * Builds the skills array with their associated tools.
+ * Associates tools with skills based on constructor tools or variable name matching.
+ *
+ * @param skillsMetadata - Extracted skill metadata from source code
+ * @param skillToTools - Map of skill variables to tool class names
+ * @param tools - Array of all detected tools
+ * @returns Array of skills with their tools embedded
+ */
+function buildSkillsArray(skillsMetadata, skillToTools, tools) {
+    return skillsMetadata.map(skillMeta => {
+        let skillTools = [];
+        // Strategy 1: Check for tools from constructor
+        if (skillMeta.constructorTools && skillMeta.constructorTools.length > 0) {
+            skillTools = tools.filter(tool => skillMeta.constructorTools.includes(tool.className) ||
+                skillMeta.constructorTools.includes(tool.name));
+        }
+        else {
+            // Strategy 2: Match tools by variable name heuristic
+            for (const [varName, toolNames] of skillToTools.entries()) {
+                const skillNameLower = skillMeta.name.toLowerCase().replace('-skill', '');
+                if (varName.toLowerCase().includes(skillNameLower) ||
+                    varName.toLowerCase().includes(skillMeta.name.toLowerCase())) {
+                    skillTools = tools.filter(tool => toolNames.includes(tool.className) || toolNames.includes(tool.name));
+                    break;
+                }
+            }
+        }
+        return {
+            name: skillMeta.name,
+            version: skillMeta.version,
+            description: skillMeta.description,
+            context: skillMeta.context,
+            tools: skillTools.map(tool => ({
+                name: tool.name,
+                description: tool.description || '',
+                inputSchema: tool.inputSchema || DEFAULT_INPUT_SCHEMA,
+                execute: compressCode(tool.executeCode || '')
+            }))
+        };
+    });
+}
+/**
+ * Writes individual tool files to the .lua directory for debugging.
+ * These are uncompressed versions of the tool code.
+ *
+ * @param tools - Array of tools to write
+ * @param luaDir - Directory to write tool files to
+ */
+function writeIndividualToolFiles(tools, luaDir) {
+    for (const tool of tools) {
+        if (tool.executeCode) {
+            const toolFilePath = path.join(luaDir, `${tool.name}.js`);
+            fs.writeFileSync(toolFilePath, tool.executeCode);
+        }
+    }
+}

package/dist/utils/dev-api.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Dev API Utilities
+ * Handles all API calls for dev mode (chat, push, update)
+ */
+import { DevVersionResponse, UpdateDevVersionResponse, SandboxIdsMap } from '../interfaces/dev.js';
+/**
+ * Sends a chat message to the API with skill override for sandbox testing.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param sandboxId - Sandbox skill ID
+ * @param message - Message to send
+ * @param persona - Optional persona override
+ * @param deployData - Deploy data containing all skills
+ * @returns The chat response text or null if failed
+ */
+export declare function sendChatMessage(apiKey: string, agentId: string, skillId: string, sandboxId: string, message: string, persona: string | undefined, deployData: any): Promise<string | null>;
+/**
+ * Updates an existing sandbox version.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param sandboxVersionId - Existing sandbox version ID
+ * @param versionData - Version data to update
+ * @returns Update response
+ */
+export declare function updateDevVersion(apiKey: string, agentId: string, skillId: string, sandboxVersionId: string, versionData: any): Promise<UpdateDevVersionResponse>;
+/**
+ * Creates a new sandbox version.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param versionData - Version data to create
+ * @returns Dev version response
+ */
+export declare function pushDevVersion(apiKey: string, agentId: string, skillId: string, versionData: any): Promise<DevVersionResponse>;
+/**
+ * Pushes a single skill to the sandbox.
+ * Attempts to update existing sandbox version, creates new one if update fails.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param skillData - Skill data to push
+ * @param isInitial - Whether this is the initial push (affects logging)
+ * @returns True if successful, false otherwise
+ */
+export declare function pushSingleSkillToSandbox(apiKey: string, agentId: string, skillId: string, skillData: any, isInitial?: boolean): Promise<boolean>;
+/**
+ * Pushes multiple skills to the sandbox.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param deployData - Deploy data containing all skills
+ * @param isInitial - Whether this is the initial push
+ * @returns Map of skill names to their sandbox IDs
+ */
+export declare function pushSkillsToSandbox(apiKey: string, agentId: string, deployData: any, isInitial?: boolean): Promise<SandboxIdsMap>;

package/dist/utils/dev-api.js

@@ -0,0 +1,262 @@
+/**
+ * Dev API Utilities
+ * Handles all API calls for dev mode (chat, push, update)
+ */
+import ChatApi from '../api/chat.api.service.js';
+import SkillApi from '../api/skills.api.service.js';
+import { BASE_URLS } from '../config/constants.js';
+import { writeProgress, writeSuccess } from './cli.js';
+import { loadEnvironmentVariables } from './sandbox.js';
+import { getSandboxSkillId, setSandboxSkillId, getAllSandboxSkillIds } from './sandbox-storage.js';
+/**
+ * Sends a chat message to the API with skill override for sandbox testing.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param sandboxId - Sandbox skill ID
+ * @param message - Message to send
+ * @param persona - Optional persona override
+ * @param deployData - Deploy data containing all skills
+ * @returns The chat response text or null if failed
+ */
+export async function sendChatMessage(apiKey, agentId, skillId, sandboxId, message, persona, deployData) {
+    try {
+        // Get all sandbox skill IDs for skill override
+        const allSkillOverrides = await getAllSandboxSkillIds(deployData);
+        // If no skills found, fallback to the provided skillId and sandboxId
+        const skillOverride = allSkillOverrides.length > 0 ? allSkillOverrides : [
+            {
+                skillId: skillId,
+                sandboxId: sandboxId
+            }
+        ];
+        const chatRequest = {
+            messages: [
+                {
+                    type: "text",
+                    text: message
+                }
+            ],
+            navigate: true,
+            skillOverride: skillOverride
+        };
+        // Add persona override if provided
+        if (persona) {
+            chatRequest.personaOverride = persona;
+        }
+        const chatApi = new ChatApi(BASE_URLS.CHAT, apiKey);
+        const response = await chatApi.sendMessage(agentId, chatRequest);
+        if (!response.success) {
+            console.error(`❌ Chat API error: ${response.error?.message || 'Unknown error'}`);
+            return null;
+        }
+        return response.data?.text || null;
+    }
+    catch (error) {
+        console.error("❌ Error sending chat message:", error);
+        return null;
+    }
+}
+/**
+ * Updates an existing sandbox version.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param sandboxVersionId - Existing sandbox version ID
+ * @param versionData - Version data to update
+ * @returns Update response
+ */
+export async function updateDevVersion(apiKey, agentId, skillId, sandboxVersionId, versionData) {
+    try {
+        const skillsApi = new SkillApi(BASE_URLS.API, apiKey, agentId);
+        const response = await skillsApi.updateDevSkill(skillId, sandboxVersionId, versionData);
+        if (response.success) {
+            return {
+                success: true,
+                data: response.data
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: {
+                    message: response.error?.message || 'Unknown error',
+                    error: response.error?.message || 'Unknown error',
+                    statusCode: response.error?.statusCode || 500
+                }
+            };
+        }
+    }
+    catch (error) {
+        console.error("Network error updating dev version:", error);
+        return {
+            success: false,
+            error: {
+                message: "Network error",
+                error: error instanceof Error ? error.message : "Failed to connect to server",
+                statusCode: 500
+            }
+        };
+    }
+}
+/**
+ * Creates a new sandbox version.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param versionData - Version data to create
+ * @returns Dev version response
+ */
+export async function pushDevVersion(apiKey, agentId, skillId, versionData) {
+    try {
+        const skillsApi = new SkillApi(BASE_URLS.API, apiKey, agentId);
+        const response = await skillsApi.pushDevSkill(skillId, versionData);
+        if (response.success) {
+            return {
+                success: true,
+                data: response.data
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: {
+                    message: response.error?.message || 'Unknown error',
+                    error: response.error?.message || 'Unknown error',
+                    statusCode: response.error?.statusCode || 500
+                }
+            };
+        }
+    }
+    catch (error) {
+        console.error("❌ Network error pushing dev version:", error);
+        return {
+            success: false,
+            error: {
+                message: "Network error",
+                error: error instanceof Error ? error.message : "Failed to connect to server",
+                statusCode: 500
+            }
+        };
+    }
+}
+/**
+ * Pushes a single skill to the sandbox.
+ * Attempts to update existing sandbox version, creates new one if update fails.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param skillData - Skill data to push
+ * @param isInitial - Whether this is the initial push (affects logging)
+ * @returns True if successful, false otherwise
+ */
+export async function pushSingleSkillToSandbox(apiKey, agentId, skillId, skillData, isInitial = false) {
+    const skillName = skillData.name || 'Unknown Skill';
+    const sandboxSkillId = await getSandboxSkillId(skillName);
+    // Load environment variables
+    const envVars = loadEnvironmentVariables();
+    const payloadWithNameAndEnv = {
+        ...skillData,
+        name: skillName,
+        env: envVars
+    };
+    if (sandboxSkillId) {
+        // Try to update existing sandbox version
+        if (!isInitial) {
+            writeProgress("🔄 Updating existing sandbox version...");
+        }
+        const updateResult = await updateDevVersion(apiKey, agentId, skillId, sandboxSkillId, payloadWithNameAndEnv);
+        if (updateResult.success && updateResult.data) {
+            if (!isInitial) {
+                // writeSuccess(`✅ Version ${updateResult.data.version} updated in sandbox successfully`);
+                // writeSuccess(`🔑 Sandbox Skill ID: ${updateResult.data.skillId}`);
+            }
+            return true;
+        }
+        else if (updateResult.error) {
+            writeProgress("⚠️  Failed to update existing sandbox, creating new one...");
+            console.error(`❌ Sandbox update failed: ${updateResult.error.message}`);
+            if (updateResult.error.error) {
+                console.error(`   Details: ${updateResult.error.error}`);
+            }
+            // If skill not found during update, give helpful guidance before trying to create
+            if (updateResult.error.message.includes('Skill not found') || updateResult.error.statusCode === 400 || updateResult.error.statusCode === 404) {
+                console.error('\n💡 The skill doesn\'t exist on the server.');
+                console.error('   Please run "lua push" first to deploy your skill, then try "lua dev" again.\n');
+            }
+            // Fall through to create new sandbox
+        }
+    }
+    // Create new sandbox version (either no existing ID or update failed)
+    if (!isInitial) {
+        writeProgress("🔄 Creating new sandbox version...");
+    }
+    const result = await pushDevVersion(apiKey, agentId, skillId, payloadWithNameAndEnv);
+    if (result.success && result.data) {
+        // Store the new sandbox skill ID
+        await setSandboxSkillId(result.data.skillId, skillName);
+        if (!isInitial) {
+            writeSuccess(`✅ Version ${result.data.version} pushed to sandbox successfully`);
+            writeSuccess(`🔑 Sandbox Skill ID: ${result.data.skillId}`);
+        }
+        return true;
+    }
+    else if (result.error) {
+        console.error(`❌ Sandbox creation failed: ${result.error.message}`);
+        if (result.error.error) {
+            console.error(`   Details: ${result.error.error}`);
+        }
+        if (result.error.statusCode) {
+            console.error(`   Status Code: ${result.error.statusCode}`);
+        }
+        // If skill not found, give helpful guidance
+        if (result.error.message.includes('Skill not found') || result.error.statusCode === 400 || result.error.statusCode === 404) {
+            console.error('\n💡 The skill hasn\'t been deployed to the server yet.');
+            console.error('   Please run "lua push" first to deploy your skill, then try "lua dev" again.');
+        }
+        return false;
+    }
+    else {
+        console.error("❌ Failed to push version to sandbox. Please try again.");
+        return false;
+    }
+}
+/**
+ * Pushes multiple skills to the sandbox.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param deployData - Deploy data containing all skills
+ * @param isInitial - Whether this is the initial push
+ * @returns Map of skill names to their sandbox IDs
+ */
+export async function pushSkillsToSandbox(apiKey, agentId, deployData, isInitial = false) {
+    const sandboxIds = {};
+    if (!deployData.skills || !Array.isArray(deployData.skills)) {
+        throw new Error("No skills found in deploy data");
+    }
+    for (const skill of deployData.skills) {
+        if (!skill.skillId) {
+            console.warn(`⚠️  Skipping skill ${skill.name} - no skillId found`);
+            continue;
+        }
+        try {
+            const success = await pushSingleSkillToSandbox(apiKey, agentId, skill.skillId, skill, isInitial);
+            if (success) {
+                // Get the sandbox ID for this skill
+                const sandboxId = await getSandboxSkillId(skill.name);
+                if (sandboxId) {
+                    sandboxIds[skill.name] = sandboxId;
+                }
+            }
+        }
+        catch (error) {
+            console.error(`❌ Failed to push skill ${skill.name}:`, error);
+        }
+    }
+    return sandboxIds;
+}

package/dist/utils/dev-helpers.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Dev Helper Utilities
+ * Small helper functions for dev mode
+ */
+/**
+ * Reads the version from config (handles both old and new formats).
+ *
+ * @param config - The skill configuration
+ * @returns The version string
+ */
+export declare function readConfigVersion(config: any): string;
+/**
+ * Reads the deploy.json file from .lua directory.
+ *
+ * @returns Parsed deploy data or null if not found
+ */
+export declare function readDeployJson(): any | null;
+/**
+ * Extracts skill ID from config (handles both old and new formats).
+ * For multi-skill projects, returns the first skill's ID.
+ *
+ * @param config - The skill configuration
+ * @returns The skill ID or null if not found
+ */
+export declare function extractSkillId(config: any): string | null;
+/**
+ * Validates that the configuration has required fields.
+ *
+ * @param config - The skill configuration to validate
+ * @throws Error if configuration is invalid
+ */
+export declare function validateConfig(config: any): void;
+/**
+ * Validates that deploy data has skills.
+ *
+ * @param deployData - The deploy data to validate
+ * @throws Error if deploy data is invalid
+ */
+export declare function validateDeployData(deployData: any): void;
+/**
+ * Validates that config has required agent information.
+ *
+ * @param config - The skill configuration
+ * @throws Error if agent info is missing
+ */
+export declare function validateAgentConfig(config: any): void;