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

package/dist/utils/dev-watcher.js

@@ -0,0 +1,110 @@
+/**
+ * Dev File Watcher Utilities
+ * Handles file system watching and automatic recompilation
+ */
+import { watch } from 'fs';
+import { compileCommand } from '../commands/compile.js';
+import { pushSkillsToSandbox } from './dev-api.js';
+import { writeProgress } from './cli.js';
+import { FILE_WATCH_CONFIG, WATCH_IGNORE_PATTERNS, WATCH_IGNORE_EXTENSIONS, } from '../config/dev.constants.js';
+/**
+ * Checks if a file should be ignored during watching.
+ *
+ * @param filename - The filename to check
+ * @returns True if file should be ignored, false otherwise
+ */
+export function shouldIgnoreFile(filename) {
+    if (!filename) {
+        return true;
+    }
+    // Check ignore patterns
+    for (const pattern of WATCH_IGNORE_PATTERNS) {
+        if (filename.includes(pattern)) {
+            return true;
+        }
+    }
+    // Check ignore extensions
+    for (const ext of WATCH_IGNORE_EXTENSIONS) {
+        if (filename.endsWith(ext)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Creates and starts a file watcher for development mode.
+ * Watches for file changes and automatically recompiles and pushes to sandbox.
+ *
+ * @param config - File watcher configuration
+ * @returns The watcher instance
+ */
+export function createFileWatcher(config) {
+    const { apiKey, agentId, readDeployJson, broadcastLog } = config;
+    let isCompiling = false;
+    let pendingCompile = false;
+    let compileTimeout = null;
+    const watcher = watch(process.cwd(), { recursive: FILE_WATCH_CONFIG.RECURSIVE }, async (eventType, filename) => {
+        // Ignore changes in build artifacts and dependencies
+        if (shouldIgnoreFile(filename)) {
+            return;
+        }
+        // Debounce rapid changes
+        if (isCompiling) {
+            pendingCompile = true;
+            return;
+        }
+        // Clear any existing timeout
+        if (compileTimeout) {
+            clearTimeout(compileTimeout);
+        }
+        // Debounce file changes with configured delay
+        compileTimeout = setTimeout(async () => {
+            if (isCompiling) {
+                return;
+            }
+            isCompiling = true;
+            pendingCompile = false;
+            try {
+                writeProgress(`🔄 File changed: ${filename} - Compiling and pushing...`);
+                broadcastLog(`🔄 File changed: ${filename} - Compiling and pushing...`, 'info');
+                // Compile the skill
+                await compileCommand();
+                broadcastLog("✅ Compilation completed", 'info');
+                // Read updated deploy.json
+                const updatedDeployData = readDeployJson();
+                if (!updatedDeployData) {
+                    writeProgress("❌ Compilation failed, skipping push");
+                    return;
+                }
+                // Verify updated deploy.json has skills
+                if (!updatedDeployData.skills || !Array.isArray(updatedDeployData.skills) || updatedDeployData.skills.length === 0) {
+                    writeProgress("❌ No skills found in updated deploy.json, skipping push");
+                    return;
+                }
+                // Push all skills to sandbox
+                const updatedSandboxIds = await pushSkillsToSandbox(apiKey, agentId, updatedDeployData, false);
+                if (Object.keys(updatedSandboxIds).length === 0) {
+                    writeProgress("❌ Failed to push any skills to sandbox, will retry on next change");
+                    broadcastLog("❌ Failed to push skills to sandbox, will retry on next change", 'error');
+                }
+                else {
+                    broadcastLog(`✅ Successfully pushed ${Object.keys(updatedSandboxIds).length} skills to sandbox`, 'info');
+                }
+            }
+            catch (error) {
+                writeProgress(`❌ Error during auto-compile: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+            finally {
+                isCompiling = false;
+            }
+        }, FILE_WATCH_CONFIG.DEBOUNCE_DELAY);
+    });
+    // Handle graceful shutdown
+    const cleanup = () => {
+        if (compileTimeout) {
+            clearTimeout(compileTimeout);
+        }
+        watcher.close();
+    };
+    return { watcher, cleanup };
+}

package/dist/utils/files.js

@@ -49,11 +49,6 @@ function updatePackageJson(srcPath, destPath) {
     }
     catch (error) {
         // If we can't read any package.json, use the fallback version
-        // console.log(`Using fallback CLI version: ${currentCliVersion}`);
-    }
-    // Update the lua-cli dependency version
-    if (templatePackageJson.dependencies && templatePackageJson.dependencies['lua-cli']) {
-        // templatePackageJson.dependencies['lua-cli'] = `^${currentCliVersion}`;
     }
     // Write the updated package.json
     fs.writeFileSync(destPath, JSON.stringify(templatePackageJson, null, 2) + '\n');

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

@@ -0,0 +1,34 @@
+/**
+ * Init Agent Management Utilities
+ * Handles agent type selection, creation, and retrieval
+ */
+import { AgentType } from '../interfaces/agent.js';
+import { AgentCreationResult, BusinessConfig } from '../interfaces/init.js';
+/**
+ * Fetches available agent types from the API.
+ *
+ * @param apiKey - User's API key
+ * @returns Array of available agent types
+ */
+export declare function fetchAgentTypes(apiKey: string): Promise<AgentType[]>;
+/**
+ * Selects the Base Agent type from available types.
+ * Falls back to first available type if Base Agent is not found.
+ *
+ * @param agentTypes - Array of available agent types
+ * @returns Selected agent type
+ * @throws Error if no agent types are available
+ */
+export declare function selectBaseAgentType(agentTypes: AgentType[]): AgentType;
+/**
+ * Creates a new agent with the provided configuration.
+ *
+ * @param apiKey - User's API key
+ * @param agentType - Selected agent type
+ * @param businessConfig - Business configuration
+ * @param metadata - Agent metadata
+ * @param features - Feature configuration
+ * @returns Agent creation result with agent and org details
+ * @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>;

package/dist/utils/init-agent.js

@@ -0,0 +1,129 @@
+/**
+ * Init Agent Management Utilities
+ * Handles agent type selection, creation, and retrieval
+ */
+import AgentApi from '../api/agent.api.service.js';
+import { BASE_URLS } from '../config/constants.js';
+import { writeProgress } from './cli.js';
+import { AGENT_READY_WAIT_TIME, PREFERRED_AGENT_TYPES, } from '../config/init.constants.js';
+/**
+ * Fetches available agent types from the API.
+ *
+ * @param apiKey - User's API key
+ * @returns Array of available agent types
+ */
+export async function fetchAgentTypes(apiKey) {
+    writeProgress("🔄 Fetching agent types...");
+    const agentApi = new AgentApi(BASE_URLS.API, apiKey);
+    const agentTypesResult = await agentApi.getAgentTypes();
+    const agentTypes = agentTypesResult.success ? agentTypesResult.data || [] : [];
+    writeProgress("✅ Agent types loaded");
+    return agentTypes;
+}
+/**
+ * Selects the Base Agent type from available types.
+ * Falls back to first available type if Base Agent is not found.
+ *
+ * @param agentTypes - Array of available agent types
+ * @returns Selected agent type
+ * @throws Error if no agent types are available
+ */
+export function selectBaseAgentType(agentTypes) {
+    // Try to find Base Agent by preferred names
+    let selectedAgentType = agentTypes.find((type) => PREFERRED_AGENT_TYPES.some(name => type.name === name || type.name.toLowerCase().includes(name.toLowerCase())));
+    // If not found, use the first available type
+    if (!selectedAgentType && agentTypes.length > 0) {
+        selectedAgentType = agentTypes[0];
+        writeProgress(`⚠️  baseAgent not found, using ${selectedAgentType.name} instead`);
+    }
+    if (!selectedAgentType) {
+        throw new Error("No agent types available. Please contact support.");
+    }
+    writeProgress(`✅ Using agent type: ${selectedAgentType.name}`);
+    return selectedAgentType;
+}
+/**
+ * Creates a new agent with the provided configuration.
+ *
+ * @param apiKey - User's API key
+ * @param agentType - Selected agent type
+ * @param businessConfig - Business configuration
+ * @param metadata - Agent metadata
+ * @param features - Feature configuration
+ * @returns Agent creation result with agent and org details
+ * @throws Error if agent creation fails
+ */
+export async function createNewAgent(apiKey, agentType, businessConfig, metadata, features) {
+    writeProgress("🔄 Creating agent...");
+    const agentData = {
+        id: `agent_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+        type: agentType.id,
+        metadata,
+        persona: {
+            agentName: businessConfig.agentName,
+            businessType: businessConfig.businessType,
+            brandPersonality: businessConfig.brandPersonality,
+            brandTraits: businessConfig.brandTraits
+        },
+        features,
+        channels: [],
+        org: {
+            registeredName: businessConfig.businessName
+        }
+    };
+    const agentApi = new AgentApi(BASE_URLS.API, apiKey);
+    const createAgentResult = await agentApi.createAgent(agentData);
+    if (!createAgentResult.success || !createAgentResult.data) {
+        throw new Error(createAgentResult.error?.message || "Failed to create agent");
+    }
+    writeProgress("✅ Agent created successfully!");
+    // Wait for agent to be ready
+    await waitForAgentReady();
+    // Validate required fields from API response
+    const agentId = createAgentResult.data?.data?.agentId;
+    const agentName = createAgentResult.data?.data?.name;
+    const orgId = createAgentResult.data?.data?.org?.id;
+    if (!agentId || !agentName || !orgId) {
+        throw new Error("Failed to create agent: Missing required fields in API response");
+    }
+    // Fetch agent details
+    const agentDetails = await fetchAgentDetails(agentApi, agentId);
+    return {
+        agent: {
+            agentId,
+            name: agentName
+        },
+        org: {
+            id: orgId
+        },
+        persona: agentDetails.persona,
+        welcomeMessage: agentDetails.welcomeMessage
+    };
+}
+/**
+ * Waits for the agent to be ready after creation.
+ */
+async function waitForAgentReady() {
+    writeProgress("⏳ Waiting for agent to be ready...");
+    await new Promise(resolve => setTimeout(resolve, AGENT_READY_WAIT_TIME));
+}
+/**
+ * Fetches detailed agent information.
+ *
+ * @param agentApi - Agent API instance
+ * @param agentId - Agent ID to fetch
+ * @returns Agent details including persona and welcome message
+ * @throws Error if fetch fails
+ */
+async function fetchAgentDetails(agentApi, agentId) {
+    writeProgress("🔄 Fetching agent details...");
+    const agentDetailsResult = await agentApi.getAgent(agentId);
+    if (!agentDetailsResult.success || !agentDetailsResult.data) {
+        throw new Error(agentDetailsResult.error?.message || "Failed to fetch agent details");
+    }
+    writeProgress("✅ Agent details loaded");
+    return {
+        persona: agentDetailsResult.data.persona,
+        welcomeMessage: agentDetailsResult.data.welcomeMessage
+    };
+}

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

@@ -0,0 +1,41 @@
+/**
+ * Init Helper Utilities
+ * Helper functions for initialization process
+ */
+/**
+ * Gets the template directory path.
+ *
+ * @returns Absolute path to template directory
+ */
+export declare function getTemplateDir(): string;
+/**
+ * Initializes the project by copying template files and creating YAML.
+ *
+ * @param agentId - Agent ID for configuration
+ * @param orgId - Organization ID for configuration
+ * @param persona - Optional persona configuration
+ * @param welcomeMessage - Optional welcome message
+ * @returns Current working directory
+ */
+export declare function initializeProject(agentId: string, orgId: string, persona?: string, welcomeMessage?: string): string;
+/**
+ * Installs npm dependencies for the project.
+ *
+ * @param projectDir - Directory to install dependencies in
+ */
+export declare function installDependencies(projectDir: string): Promise<void>;
+/**
+ * Counts total prompt lines to clear.
+ * This is a helper for managing terminal output cleanup.
+ *
+ * @param baseCount - Base number of lines
+ * @param additionalLines - Additional lines to add
+ * @returns Total line count
+ */
+export declare function calculatePromptLines(baseCount: number, additionalLines: number): number;
+/**
+ * Clears terminal lines if count is greater than zero.
+ *
+ * @param lineCount - Number of lines to clear
+ */
+export declare function clearLinesIfNeeded(lineCount: number): void;

package/dist/utils/init-helpers.js

@@ -0,0 +1,73 @@
+/**
+ * Init Helper Utilities
+ * Helper functions for initialization process
+ */
+import { fileURLToPath } from "url";
+import path from "path";
+import { copyTemplateFiles, createSkillYaml } from "./files.js";
+import { clearPromptLines, writeProgress } from "./cli.js";
+import { execSync } from 'child_process';
+/**
+ * Gets the template directory path.
+ *
+ * @returns Absolute path to template directory
+ */
+export function getTemplateDir() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    return path.join(__dirname, "..", "..", "template");
+}
+/**
+ * Initializes the project by copying template files and creating YAML.
+ *
+ * @param agentId - Agent ID for configuration
+ * @param orgId - Organization ID for configuration
+ * @param persona - Optional persona configuration
+ * @param welcomeMessage - Optional welcome message
+ * @returns Current working directory
+ */
+export function initializeProject(agentId, orgId, persona, welcomeMessage) {
+    const templateDir = getTemplateDir();
+    const currentDir = process.cwd();
+    copyTemplateFiles(templateDir, currentDir);
+    createSkillYaml(agentId, orgId, undefined, undefined, persona, welcomeMessage);
+    writeProgress("✅ Created lua.skill.yaml");
+    writeProgress("✅ Copied template files");
+    return currentDir;
+}
+/**
+ * Installs npm dependencies for the project.
+ *
+ * @param projectDir - Directory to install dependencies in
+ */
+export async function installDependencies(projectDir) {
+    writeProgress("📦 Installing dependencies...");
+    try {
+        execSync('npm install --force', { stdio: 'inherit', cwd: projectDir });
+        writeProgress("✅ Dependencies installed successfully");
+    }
+    catch (error) {
+        writeProgress("⚠️  Warning: Failed to install dependencies automatically. Please run 'npm install' manually.");
+    }
+}
+/**
+ * Counts total prompt lines to clear.
+ * This is a helper for managing terminal output cleanup.
+ *
+ * @param baseCount - Base number of lines
+ * @param additionalLines - Additional lines to add
+ * @returns Total line count
+ */
+export function calculatePromptLines(baseCount, additionalLines) {
+    return baseCount + additionalLines;
+}
+/**
+ * Clears terminal lines if count is greater than zero.
+ *
+ * @param lineCount - Number of lines to clear
+ */
+export function clearLinesIfNeeded(lineCount) {
+    if (lineCount > 0) {
+        clearPromptLines(lineCount);
+    }
+}

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

@@ -0,0 +1,47 @@
+/**
+ * Init Command Prompt Utilities
+ * Handles all interactive prompts for agent initialization
+ */
+import { AgentChoiceType, SelectedAgent, SelectedOrg, OrganizationData, BusinessConfig } from '../interfaces/init.js';
+import { AgentType } from '../interfaces/agent.js';
+/**
+ * Prompts user to choose between existing or new agent.
+ *
+ * @returns Selected choice ('existing' or 'create')
+ */
+export declare function promptAgentChoice(): Promise<AgentChoiceType>;
+/**
+ * Prompts user to select an organization from available options.
+ *
+ * @param orgs - Array of organizations to choose from
+ * @returns Selected organization
+ */
+export declare function promptOrganizationSelection(orgs: OrganizationData[]): Promise<SelectedOrg>;
+/**
+ * Prompts user to select an agent from an organization.
+ *
+ * @param org - Organization containing agents
+ * @returns Selected agent
+ */
+export declare function promptAgentSelection(org: SelectedOrg): Promise<SelectedAgent>;
+/**
+ * Prompts for metadata fields required by the agent type.
+ *
+ * @param requiredFields - Array of required metadata field names
+ * @returns Object containing collected metadata
+ */
+export declare function promptMetadataCollection(requiredFields: string[]): Promise<Record<string, any>>;
+/**
+ * Prompts for feature configuration.
+ *
+ * @param agentType - Agent type containing available features
+ * @returns Object containing feature enable/disable status
+ */
+export declare function promptFeatureConfiguration(agentType: AgentType): Promise<Record<string, boolean>>;
+/**
+ * Prompts for business and agent configuration.
+ * Collects business name, agent name, type, personality, and traits.
+ *
+ * @returns Complete business configuration
+ */
+export declare function promptBusinessConfiguration(): Promise<BusinessConfig>;

package/dist/utils/init-prompts.js

@@ -0,0 +1,168 @@
+/**
+ * Init Command Prompt Utilities
+ * Handles all interactive prompts for agent initialization
+ */
+import inquirer from "inquirer";
+import { BUSINESS_TYPES, BRAND_PERSONALITIES, DEFAULT_BUSINESS_NAME, } from '../config/init.constants.js';
+/**
+ * Prompts user to choose between existing or new agent.
+ *
+ * @returns Selected choice ('existing' or 'create')
+ */
+export async function promptAgentChoice() {
+    const { agentChoice } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "agentChoice",
+            message: "What would you like to do?",
+            choices: [
+                { name: "Select existing agent", value: "existing" },
+                { name: "Create new agent", value: "create" }
+            ]
+        }
+    ]);
+    return agentChoice;
+}
+/**
+ * Prompts user to select an organization from available options.
+ *
+ * @param orgs - Array of organizations to choose from
+ * @returns Selected organization
+ */
+export async function promptOrganizationSelection(orgs) {
+    const orgChoices = orgs.map((org) => ({
+        name: org.registeredName || org.name || 'Unknown Organization',
+        value: org
+    }));
+    const { selectedOrg } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "selectedOrg",
+            message: "Select an organization:",
+            choices: orgChoices
+        }
+    ]);
+    return selectedOrg;
+}
+/**
+ * Prompts user to select an agent from an organization.
+ *
+ * @param org - Organization containing agents
+ * @returns Selected agent
+ */
+export async function promptAgentSelection(org) {
+    if (!org.agents || org.agents.length === 0) {
+        throw new Error("No agents found in the selected organization.");
+    }
+    const agentChoices = org.agents.map((agent) => ({
+        name: agent.name,
+        value: agent
+    }));
+    const { selectedAgent } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "selectedAgent",
+            message: "Select an agent:",
+            choices: agentChoices
+        }
+    ]);
+    return selectedAgent;
+}
+/**
+ * Prompts for metadata fields required by the agent type.
+ *
+ * @param requiredFields - Array of required metadata field names
+ * @returns Object containing collected metadata
+ */
+export async function promptMetadataCollection(requiredFields) {
+    const metadata = {};
+    for (const field of requiredFields) {
+        const { [field]: value } = await inquirer.prompt([
+            {
+                type: "input",
+                name: field,
+                message: `Enter ${field}:`,
+                validate: (input) => input.trim().length > 0 || `${field} is required`
+            }
+        ]);
+        metadata[field] = value;
+    }
+    return metadata;
+}
+/**
+ * Prompts for feature configuration.
+ *
+ * @param agentType - Agent type containing available features
+ * @returns Object containing feature enable/disable status
+ */
+export async function promptFeatureConfiguration(agentType) {
+    const features = {};
+    const availableFeatures = Object.keys(agentType.features);
+    for (const feature of availableFeatures) {
+        const { [feature]: enabled } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: feature,
+                message: `Enable ${feature} feature?`,
+                default: agentType.features[feature]?.active || false
+            }
+        ]);
+        features[feature] = enabled;
+    }
+    return features;
+}
+/**
+ * Prompts for business and agent configuration.
+ * Collects business name, agent name, type, personality, and traits.
+ *
+ * @returns Complete business configuration
+ */
+export async function promptBusinessConfiguration() {
+    const { businessName } = await inquirer.prompt([
+        {
+            type: "input",
+            name: "businessName",
+            message: "Enter business name:",
+            default: DEFAULT_BUSINESS_NAME
+        }
+    ]);
+    const { agentName } = await inquirer.prompt([
+        {
+            type: "input",
+            name: "agentName",
+            message: "Enter agent name:",
+            validate: (input) => input.trim().length > 0 || "Agent name is required"
+        }
+    ]);
+    const { businessType } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "businessType",
+            message: "Select business type:",
+            choices: BUSINESS_TYPES
+        }
+    ]);
+    const { brandPersonality } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "brandPersonality",
+            message: "Select brand personality:",
+            choices: BRAND_PERSONALITIES
+        }
+    ]);
+    const { brandTraits } = await inquirer.prompt([
+        {
+            type: "input",
+            name: "brandTraits",
+            message: "Enter brand traits (any traits the agent might have):",
+            default: ""
+        }
+    ]);
+    return {
+        businessName,
+        agentName,
+        businessType,
+        brandPersonality,
+        brandTraits
+    };
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Push API Utilities
+ * Handles API calls for pushing skill versions
+ */
+import { PushVersionResponse } from '../interfaces/push.js';
+/**
+ * Pushes a skill version to the server.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param versionData - Version data to push
+ * @returns Push version response
+ */
+export declare function pushVersion(apiKey: string, agentId: string, skillId: string, versionData: any): Promise<PushVersionResponse>;

package/dist/utils/push-api.js

@@ -0,0 +1,48 @@
+/**
+ * Push API Utilities
+ * Handles API calls for pushing skill versions
+ */
+import SkillApi from '../api/skills.api.service.js';
+import { BASE_URLS } from '../config/constants.js';
+/**
+ * Pushes a skill version to the server.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param versionData - Version data to push
+ * @returns Push version response
+ */
+export async function pushVersion(apiKey, agentId, skillId, versionData) {
+    try {
+        const skillApi = new SkillApi(BASE_URLS.API, apiKey, agentId);
+        const response = await skillApi.pushSkill(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("❌ Error pushing version:", error);
+        return {
+            success: false,
+            error: {
+                message: "Network error",
+                error: "Failed to connect to server",
+                statusCode: 500
+            }
+        };
+    }
+}