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

package/dist/types/compile.types.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Type definitions for compile command
+ */
+import { SourceFile } from "ts-morph";
+/**
+ * Represents a TypeScript source file from ts-morph
+ */
+export type TypeScriptSourceFile = SourceFile;
+/**
+ * Represents an AST node from ts-morph
+ */
+export type ASTNode = any;
+/**
+ * Skill metadata extracted from source code
+ */
+export interface SkillMetadata {
+    name: string;
+    version: string;
+    description: string;
+    context: string;
+    constructorTools: string[];
+}
+/**
+ * Configuration from lua.skill.yaml
+ */
+export interface SkillConfig {
+    skill?: {
+        name?: string;
+        version?: string;
+        skillId?: string;
+        description?: string;
+        context?: string;
+    };
+    agent?: {
+        agentId?: string;
+    };
+    skills?: Array<{
+        name: string;
+        version: string;
+        skillId: string;
+    }>;
+}
+/**
+ * Deployment data format for new deployment system
+ */
+export interface DeploymentData {
+    name: string;
+    version: string;
+    skillId: string;
+    description: string;
+    context: string;
+    tools: Array<{
+        name: string;
+        className: string;
+        description: string;
+        filePath: string;
+    }>;
+}
+/**
+ * Legacy deployment data format
+ */
+export interface LegacyDeployData {
+    skills: Array<{
+        name: string;
+        version: string;
+        description: string;
+        context: string;
+        skillId?: string;
+        tools: Array<{
+            name: string;
+            description: string;
+            inputSchema: any;
+            execute: string;
+        }>;
+    }>;
+}

package/dist/types/compile.types.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for compile command
+ */
+export {};

package/dist/types/index.d.ts

@@ -1,123 +1,25 @@
-export interface UserData {
-    uid: string;
-    email: string;
-    emailVerified: boolean;
-    fullName: string;
-    mobileNumbers: any[];
-    emailAddresses: EmailAddress[];
-    country: Country;
-    admin: Admin;
-    channels: Record<string, any>;
-    rights: Record<string, any>;
-    setupPersona: Record<string, any>;
-    notifications: Record<string, any>;
-}
-export interface EmailAddress {
-    address: string;
-    validated: boolean;
-    validatedAt: number;
-    _id: string;
-}
-export interface Country {
-    code: string;
-    name: string;
-}
-export interface Admin {
-    userId: string;
-    orgs: Organization[];
-    id: string;
-    createdAt: number;
-    __v: number;
-}
-export interface Organization {
-    id: string;
-    rights?: string[];
-    agents: Agent[];
-    registeredName: string;
-    country: string;
-    phoneNumber?: string | null;
-    type: string;
-}
-export interface Agent {
-    agentId: string;
-    rights: string[];
-    name: string;
-}
-export interface OTPResponse {
-    signInToken: string;
-}
-export interface ApiKeyResponse {
-    message: string;
-    userId: string;
-    apiKey: string;
-    apiId: string;
-}
-import { ZodType } from "zod";
 /**
- * Validates that a tool name contains only alphanumeric characters, hyphens, and underscores.
- * No spaces or other special characters are allowed.
+ * Types Module - Barrel Export
+ *
+ * This file serves as the main entry point for all type definitions.
+ * It re-exports types from various modules for convenient importing.
+ *
+ * Usage:
+ * ```typescript
+ * // Import from types module
+ * import { LuaSkill, LuaTool, env } from './types/index.js';
+ *
+ * // Or import specific type groups
+ * import { UserDataAPI, ProductAPI } from './types/api-contracts.js';
+ * import { validateToolName } from './types/tool-validation.js';
+ * ```
  */
-export declare function validateToolName(name: string): boolean;
-/**
- * Throws an error if the tool name is invalid
- */
-export declare function assertValidToolName(name: string): void;
-export interface LuaTool<TInput extends ZodType = ZodType> {
-    name: string;
-    description: string;
-    inputSchema: TInput;
-    execute: (input: any) => Promise<any>;
-}
-export interface LuaSkillConfig {
-    name: string;
-    version: string;
-    description: string;
-    context: string;
-}
-export declare class LuaSkill {
-    private readonly tools;
-    private readonly name;
-    private readonly version;
-    private readonly description;
-    private readonly context;
-    constructor(config: LuaSkillConfig);
-    addTool<TInput extends ZodType>(tool: LuaTool<TInput>): void;
-    addTools(tools: LuaTool<any>[]): void;
-    run(input: Record<string, any>): Promise<any>;
-}
-export interface UserDataAPI {
-    get(): Promise<any>;
-    update(data: Record<string, any>): Promise<any>;
-    clear(): Promise<any>;
-}
-export interface ProductAPI {
-    get(limit?: number, page?: number): Promise<any>;
-    create(product: any): Promise<any>;
-    update(data: any, id: string): Promise<any>;
-    delete(id: string): Promise<any>;
-    search(query: string): Promise<any>;
-}
-export interface BasketAPI {
-    create(basketData: any): Promise<any>;
-    get(status?: any): Promise<any>;
-    addItem(basketId: string, itemData: any): Promise<any>;
-    removeItem(basketId: string, itemId: string): Promise<any>;
-    clear(basketId: string): Promise<any>;
-    updateStatus(basketId: string, status: any): Promise<any>;
-    updateMetadata(basketId: string, metadata: any): Promise<any>;
-    placeOrder(data: Record<string, any>, basketId: string): Promise<any>;
-}
-export interface OrderAPI {
-    create(orderData: any): Promise<any>;
-    updateStatus(status: any, orderId: string): Promise<any>;
-    updateData(data: Record<string, any>, orderId: string): Promise<any>;
-    get(status?: any): Promise<any>;
-}
-export interface CustomDataAPI {
-    create(collectionName: string, data: any): Promise<any>;
-    get(collectionName: string, filter?: any, page?: number, limit?: number): Promise<any>;
-    getEntry(collectionName: string, entryId: string): Promise<any>;
-    update(collectionName: string, entryId: string, data: any): Promise<any>;
-    search(collectionName: string, searchText: string, limit?: number, scoreThreshold?: number): Promise<any>;
-    delete(collectionName: string, entryId: string): Promise<any>;
-}
+export { LuaSkill, LuaTool, LuaSkillConfig, env } from './skill.js';
+export { validateToolName, assertValidToolName } from './tool-validation.js';
+export { UserDataAPI, ProductAPI, BasketAPI, OrderAPI, CustomDataAPI } from './api-contracts.js';
+export { UserData, EmailAddress, Country, Admin, Organization, AgentAuth, OTPResponse, ApiKeyResponse } from '../interfaces/admin.js';
+export { Agent, AgentType, CreateAgentRequest, CreateAgentResponse, AgentDetailsResponse } from '../interfaces/agent.js';
+export { BasketStatus, BasketItem, Basket } from '../interfaces/baskets.js';
+export { OrderStatus, OrderResponse } from '../interfaces/orders.js';
+export { Product } from '../interfaces/product.js';
+export { ApiResponse, Pagination } from '../interfaces/common.js';

package/dist/types/index.js

@@ -1,16 +1,27 @@
 /**
- * Validates that a tool name contains only alphanumeric characters, hyphens, and underscores.
- * No spaces or other special characters are allowed.
+ * Types Module - Barrel Export
+ *
+ * This file serves as the main entry point for all type definitions.
+ * It re-exports types from various modules for convenient importing.
+ *
+ * Usage:
+ * ```typescript
+ * // Import from types module
+ * import { LuaSkill, LuaTool, env } from './types/index.js';
+ *
+ * // Or import specific type groups
+ * import { UserDataAPI, ProductAPI } from './types/api-contracts.js';
+ * import { validateToolName } from './types/tool-validation.js';
+ * ```
  */
-export function validateToolName(name) {
-    const validNameRegex = /^[a-zA-Z0-9_-]+$/;
-    return validNameRegex.test(name);
-}
-/**
- * Throws an error if the tool name is invalid
- */
-export function assertValidToolName(name) {
-    if (!validateToolName(name)) {
-        throw new Error(`Invalid tool name "${name}". Tool names can only contain alphanumeric characters, hyphens (-), and underscores (_). No spaces or other special characters are allowed.`);
-    }
-}
+// ============================================================================
+// SKILL SYSTEM EXPORTS
+// ============================================================================
+// Core skill classes and utilities
+export { LuaSkill, env } from './skill.js';
+// Tool validation utilities
+export { validateToolName, assertValidToolName } from './tool-validation.js';
+// Basket types
+export { BasketStatus } from '../interfaces/baskets.js';
+// Order types
+export { OrderStatus } from '../interfaces/orders.js';

package/dist/types/skill.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Lua Skill System
+ * Core types and classes for building Lua AI skills
+ */
+import { ZodType } from "zod";
+/**
+ * Safe environment variable access function.
+ * Gets injected at runtime with skill-specific environment variables.
+ *
+ * Checks in order:
+ * 1. Process environment variables (.env file)
+ * 2. lua.skill.yaml configuration
+ *
+ * @param key - The environment variable key to retrieve
+ * @returns The environment variable value or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const baseUrl = env('BASE_URL');
+ * const apiKey = env('API_KEY');
+ * ```
+ */
+export declare const env: (key: string) => string | undefined;
+/**
+ * Lua Tool interface.
+ * Defines the structure of a tool that can be added to a LuaSkill.
+ *
+ * @template TInput - Zod schema type for input validation
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ * import { LuaTool } from 'lua-cli';
+ *
+ * const weatherTool: LuaTool = {
+ *   name: 'get_weather',
+ *   description: 'Gets current weather for a city',
+ *   inputSchema: z.object({
+ *     city: z.string(),
+ *     units: z.enum(['metric', 'imperial']).optional()
+ *   }),
+ *   execute: async (input) => {
+ *     // Fetch weather data...
+ *     return { temperature: 72, condition: 'sunny' };
+ *   }
+ * };
+ * ```
+ */
+export interface LuaTool<TInput extends ZodType = ZodType> {
+    /** Unique tool name (alphanumeric, hyphens, underscores only) */
+    name: string;
+    /** Description of what the tool does */
+    description: string;
+    /** Zod schema for input validation */
+    inputSchema: TInput;
+    /** Async function that executes the tool logic */
+    execute: (input: any) => Promise<any>;
+}
+/**
+ * Lua Skill configuration.
+ * Used to initialize a new LuaSkill instance.
+ */
+export interface LuaSkillConfig {
+    /** Skill name (optional, defaults to 'unnamed-skill') */
+    name?: string;
+    /** Skill version (optional, defaults to '1.0.0') */
+    version?: string;
+    /** Short description of the skill (1-2 sentences) */
+    description: string;
+    /** Detailed context for how the agent should use the tools */
+    context: string;
+    /** Optional array of tools to add during construction */
+    tools?: LuaTool<any>[];
+}
+/**
+ * Lua Skill class.
+ * Main class for building AI skills with tools.
+ *
+ * A skill is a collection of tools that the AI agent can use to accomplish tasks.
+ * Tools are functions with validated inputs and well-defined outputs.
+ *
+ * @example
+ * ```typescript
+ * import { LuaSkill } from 'lua-cli';
+ *
+ * const skill = new LuaSkill({
+ *   name: 'weather-skill',
+ *   version: '1.0.0',
+ *   description: "Weather and calculator utilities",
+ *   context: "This skill provides weather information and math operations. " +
+ *            "Use get_weather for current conditions and calculator for arithmetic.",
+ *   tools: [weatherTool, calculatorTool]
+ * });
+ *
+ * // Or add tools after construction
+ * skill.addTool(anotherTool);
+ * ```
+ */
+export declare class LuaSkill {
+    private readonly tools;
+    private readonly name;
+    private readonly version;
+    private readonly description;
+    private readonly context;
+    /**
+     * Creates a new LuaSkill instance.
+     *
+     * @param config - Configuration object containing skill metadata
+     * @param config.name - Skill name (optional, defaults to 'unnamed-skill')
+     * @param config.version - Skill version (optional, defaults to '1.0.0')
+     * @param config.description - Short description of what the skill does (1-2 sentences)
+     * @param config.context - Detailed explanation of how the agent should use the tools
+     * @param config.tools - Optional array of tools to add immediately
+     */
+    constructor(config: LuaSkillConfig);
+    /**
+     * Adds a single tool to the skill.
+     * Tool name is validated before being added.
+     *
+     * @param tool - Tool to add
+     * @throws Error if tool name is invalid
+     */
+    addTool<TInput extends ZodType>(tool: LuaTool<TInput>): void;
+    /**
+     * Adds multiple tools to the skill.
+     * All tool names are validated before being added.
+     *
+     * @param tools - Array of tools to add
+     * @throws Error if any tool name is invalid
+     */
+    addTools(tools: LuaTool<any>[]): void;
+    /**
+     * Executes a tool by name with provided input.
+     * Input is validated against the tool's Zod schema.
+     *
+     * @param input - Input object containing tool name and parameters
+     * @param input.tool - Name of the tool to execute
+     * @returns Promise resolving to tool execution result
+     * @throws Error if tool not found or input validation fails
+     */
+    run(input: Record<string, any>): Promise<any>;
+}

package/dist/{skill.js → types/skill.js}

@@ -1,10 +1,18 @@
-import { assertValidToolName } from "./types/index.js";
+/**
+ * Lua Skill System
+ * Core types and classes for building Lua AI skills
+ */
+import { assertValidToolName } from "./tool-validation.js";
 import fs from "fs";
 import path from "path";
 import yaml from "js-yaml";
 /**
- * Safe environment variable access function
- * Gets injected at runtime with skill-specific environment variables
+ * Safe environment variable access function.
+ * Gets injected at runtime with skill-specific environment variables.
+ *
+ * Checks in order:
+ * 1. Process environment variables (.env file)
+ * 2. lua.skill.yaml configuration
  *
  * @param key - The environment variable key to retrieve
  * @returns The environment variable value or undefined if not found
@@ -18,13 +26,13 @@ import yaml from "js-yaml";
 export const env = (key) => {
     // Try to load environment variables from lua.skill.yaml
     try {
-        // Look for lua.skill.yaml in current directory and parent directories
-        let currentDir = process.cwd();
-        let yamlPath = null;
-        //check if in .env file
+        // Check process.env first (.env file)
         if (process.env[key]) {
             return process.env[key];
         }
+        // Look for lua.skill.yaml in current directory and parent directories
+        let currentDir = process.cwd();
+        let yamlPath = null;
         while (currentDir !== path.dirname(currentDir)) {
             const potentialPath = path.join(currentDir, 'lua.skill.yaml');
             if (fs.existsSync(potentialPath)) {
@@ -45,21 +53,40 @@ export const env = (key) => {
     }
     return undefined;
 };
+/**
+ * Lua Skill class.
+ * Main class for building AI skills with tools.
+ *
+ * A skill is a collection of tools that the AI agent can use to accomplish tasks.
+ * Tools are functions with validated inputs and well-defined outputs.
+ *
+ * @example
+ * ```typescript
+ * import { LuaSkill } from 'lua-cli';
+ *
+ * const skill = new LuaSkill({
+ *   name: 'weather-skill',
+ *   version: '1.0.0',
+ *   description: "Weather and calculator utilities",
+ *   context: "This skill provides weather information and math operations. " +
+ *            "Use get_weather for current conditions and calculator for arithmetic.",
+ *   tools: [weatherTool, calculatorTool]
+ * });
+ *
+ * // Or add tools after construction
+ * skill.addTool(anotherTool);
+ * ```
+ */
 export class LuaSkill {
     /**
-     * Creates a new LuaSkill instance
+     * Creates a new LuaSkill instance.
      *
      * @param config - Configuration object containing skill metadata
+     * @param config.name - Skill name (optional, defaults to 'unnamed-skill')
+     * @param config.version - Skill version (optional, defaults to '1.0.0')
      * @param config.description - Short description of what the skill does (1-2 sentences)
      * @param config.context - Detailed explanation of how the agent should use the tools
-     *
-     * @example
-     * ```typescript
-     * const skill = new LuaSkill({
-     *   description: "Weather and calculator utilities",
-     *   context: "This skill provides weather information for any city and basic mathematical operations. Use get_weather for current conditions and calculator for arithmetic operations."
-     * });
-     * ```
+     * @param config.tools - Optional array of tools to add immediately
      */
     constructor(config) {
         this.tools = [];
@@ -72,11 +99,24 @@ export class LuaSkill {
             this.addTools(config.tools);
         }
     }
+    /**
+     * Adds a single tool to the skill.
+     * Tool name is validated before being added.
+     *
+     * @param tool - Tool to add
+     * @throws Error if tool name is invalid
+     */
     addTool(tool) {
-        // Validate the tool name before adding it
         assertValidToolName(tool.name);
         this.tools.push(tool);
     }
+    /**
+     * Adds multiple tools to the skill.
+     * All tool names are validated before being added.
+     *
+     * @param tools - Array of tools to add
+     * @throws Error if any tool name is invalid
+     */
     addTools(tools) {
         // Validate all tool names before adding them
         for (const tool of tools) {
@@ -84,6 +124,15 @@ export class LuaSkill {
         }
         this.tools.push(...tools);
     }
+    /**
+     * Executes a tool by name with provided input.
+     * Input is validated against the tool's Zod schema.
+     *
+     * @param input - Input object containing tool name and parameters
+     * @param input.tool - Name of the tool to execute
+     * @returns Promise resolving to tool execution result
+     * @throws Error if tool not found or input validation fails
+     */
     async run(input) {
         const tool = this.tools.find(tool => tool.name === input.tool);
         if (!tool) {

package/dist/types/tool-validation.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Tool Validation Utilities
+ * Validates tool names and other tool-related constraints
+ */
+/**
+ * Validates that a tool name contains only alphanumeric characters, hyphens, and underscores.
+ * No spaces or other special characters are allowed.
+ *
+ * This restriction ensures tool names:
+ * - Are compatible with all systems
+ * - Can be used in URLs and file paths
+ * - Are easy to reference in code
+ *
+ * Valid examples: "my-tool", "calculate_sum", "getTodo123"
+ * Invalid examples: "my tool", "calc@sum", "get.todo"
+ *
+ * @param name - Tool name to validate
+ * @returns True if name is valid, false otherwise
+ */
+export declare function validateToolName(name: string): boolean;
+/**
+ * Asserts that a tool name is valid, throwing an error if not.
+ * Use this when adding tools to ensure names are valid.
+ *
+ * @param name - Tool name to validate
+ * @throws Error if tool name is invalid
+ *
+ * @example
+ * ```typescript
+ * assertValidToolName('my-tool'); // OK
+ * assertValidToolName('my tool'); // Throws error
+ * ```
+ */
+export declare function assertValidToolName(name: string): void;

package/dist/types/tool-validation.js

@@ -0,0 +1,42 @@
+/**
+ * Tool Validation Utilities
+ * Validates tool names and other tool-related constraints
+ */
+/**
+ * Validates that a tool name contains only alphanumeric characters, hyphens, and underscores.
+ * No spaces or other special characters are allowed.
+ *
+ * This restriction ensures tool names:
+ * - Are compatible with all systems
+ * - Can be used in URLs and file paths
+ * - Are easy to reference in code
+ *
+ * Valid examples: "my-tool", "calculate_sum", "getTodo123"
+ * Invalid examples: "my tool", "calc@sum", "get.todo"
+ *
+ * @param name - Tool name to validate
+ * @returns True if name is valid, false otherwise
+ */
+export function validateToolName(name) {
+    const validNameRegex = /^[a-zA-Z0-9_-]+$/;
+    return validNameRegex.test(name);
+}
+/**
+ * Asserts that a tool name is valid, throwing an error if not.
+ * Use this when adding tools to ensure names are valid.
+ *
+ * @param name - Tool name to validate
+ * @throws Error if tool name is invalid
+ *
+ * @example
+ * ```typescript
+ * assertValidToolName('my-tool'); // OK
+ * assertValidToolName('my tool'); // Throws error
+ * ```
+ */
+export function assertValidToolName(name) {
+    if (!validateToolName(name)) {
+        throw new Error(`Invalid tool name "${name}". Tool names can only contain alphanumeric characters, ` +
+            `hyphens (-), and underscores (_). No spaces or other special characters are allowed.`);
+    }
+}

package/dist/utils/auth-flows.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Authentication Flow Utilities
+ * Handles different authentication methods (API key and email OTP)
+ */
+/**
+ * Handles API key authentication flow.
+ * Prompts for API key, validates it, and saves it securely.
+ *
+ * @returns Promise that resolves when authentication is complete
+ * @throws Error if API key is invalid
+ */
+export declare function handleApiKeyAuth(): Promise<void>;
+/**
+ * Handles email authentication flow with OTP verification.
+ * Sends OTP to email, verifies it, generates API key, and saves it.
+ *
+ * @returns Promise that resolves when authentication is complete
+ * @throws Error if OTP sending fails, verification fails, or API key generation fails
+ */
+export declare function handleEmailAuth(): Promise<void>;
+/**
+ * Prompts user to choose authentication method.
+ *
+ * @returns Selected authentication method ('api-key' or 'email')
+ */
+export declare function promptAuthMethod(): Promise<'api-key' | 'email'>;