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

package/dist/types/api-contracts.d.ts

@@ -0,0 +1,211 @@
+/**
+ * API Contract Interfaces
+ * TypeScript interfaces that API service classes must implement
+ *
+ * These interfaces define the contract that API services must fulfill.
+ * They ensure consistent method signatures across all API implementations.
+ */
+/**
+ * User Data API contract.
+ * Defines operations for managing user data.
+ */
+export interface UserDataAPI {
+    /**
+     * Retrieves current user data.
+     * @returns Promise resolving to user data
+     */
+    get(): Promise<any>;
+    /**
+     * Updates user data.
+     * @param data - Data to update
+     * @returns Promise resolving to updated user data
+     */
+    update(data: Record<string, any>): Promise<any>;
+    /**
+     * Clears user data.
+     * @returns Promise resolving when data is cleared
+     */
+    clear(): Promise<any>;
+}
+/**
+ * Product API contract.
+ * Defines operations for managing products.
+ */
+export interface ProductAPI {
+    /**
+     * Gets products with pagination.
+     * @param limit - Items per page
+     * @param page - Page number
+     * @returns Promise resolving to product list
+     */
+    get(limit?: number, page?: number): Promise<any>;
+    /**
+     * Creates a new product.
+     * @param product - Product data
+     * @returns Promise resolving to created product
+     */
+    create(product: any): Promise<any>;
+    /**
+     * Updates an existing product.
+     * @param data - Updated product data
+     * @param id - Product ID
+     * @returns Promise resolving to updated product
+     */
+    update(data: any, id: string): Promise<any>;
+    /**
+     * Deletes a product.
+     * @param id - Product ID
+     * @returns Promise resolving when deletion is complete
+     */
+    delete(id: string): Promise<any>;
+    /**
+     * Searches products.
+     * @param query - Search query
+     * @returns Promise resolving to search results
+     */
+    search(query: string): Promise<any>;
+}
+/**
+ * Basket API contract.
+ * Defines operations for managing shopping baskets.
+ */
+export interface BasketAPI {
+    /**
+     * Creates a new basket.
+     * @param basketData - Basket initialization data
+     * @returns Promise resolving to created basket
+     */
+    create(basketData: any): Promise<any>;
+    /**
+     * Gets baskets, optionally filtered by status.
+     * @param status - Optional status filter
+     * @returns Promise resolving to basket list
+     */
+    get(status?: any): Promise<any>;
+    /**
+     * Adds an item to a basket.
+     * @param basketId - Basket ID
+     * @param itemData - Item data to add
+     * @returns Promise resolving to updated basket
+     */
+    addItem(basketId: string, itemData: any): Promise<any>;
+    /**
+     * Removes an item from a basket.
+     * @param basketId - Basket ID
+     * @param itemId - Item ID to remove
+     * @returns Promise resolving to updated basket
+     */
+    removeItem(basketId: string, itemId: string): Promise<any>;
+    /**
+     * Clears all items from a basket.
+     * @param basketId - Basket ID
+     * @returns Promise resolving to cleared basket
+     */
+    clear(basketId: string): Promise<any>;
+    /**
+     * Updates basket status.
+     * @param basketId - Basket ID
+     * @param status - New status
+     * @returns Promise resolving to updated basket
+     */
+    updateStatus(basketId: string, status: any): Promise<any>;
+    /**
+     * Updates basket metadata.
+     * @param basketId - Basket ID
+     * @param metadata - Metadata to update
+     * @returns Promise resolving to updated basket
+     */
+    updateMetadata(basketId: string, metadata: any): Promise<any>;
+    /**
+     * Converts basket to order.
+     * @param data - Order data
+     * @param basketId - Basket ID
+     * @returns Promise resolving to created order
+     */
+    placeOrder(data: Record<string, any>, basketId: string): Promise<any>;
+}
+/**
+ * Order API contract.
+ * Defines operations for managing orders.
+ */
+export interface OrderAPI {
+    /**
+     * Creates a new order.
+     * @param orderData - Order data
+     * @returns Promise resolving to created order
+     */
+    create(orderData: any): Promise<any>;
+    /**
+     * Updates order status.
+     * @param status - New status
+     * @param orderId - Order ID
+     * @returns Promise resolving to updated order
+     */
+    updateStatus(status: any, orderId: string): Promise<any>;
+    /**
+     * Updates order data.
+     * @param data - Data to update
+     * @param orderId - Order ID
+     * @returns Promise resolving to updated order
+     */
+    updateData(data: Record<string, any>, orderId: string): Promise<any>;
+    /**
+     * Gets orders, optionally filtered by status.
+     * @param status - Optional status filter
+     * @returns Promise resolving to order list
+     */
+    get(status?: any): Promise<any>;
+}
+/**
+ * Custom Data API contract.
+ * Defines operations for managing custom data collections with vector search.
+ */
+export interface CustomDataAPI {
+    /**
+     * Creates a new entry in a custom data collection.
+     * @param collectionName - Collection name
+     * @param data - Data to store
+     * @returns Promise resolving to created entry
+     */
+    create(collectionName: string, data: any): Promise<any>;
+    /**
+     * Gets entries from a collection with filtering and pagination.
+     * @param collectionName - Collection name
+     * @param filter - Optional filter criteria
+     * @param page - Page number
+     * @param limit - Items per page
+     * @returns Promise resolving to entries
+     */
+    get(collectionName: string, filter?: any, page?: number, limit?: number): Promise<any>;
+    /**
+     * Gets a specific entry by ID.
+     * @param collectionName - Collection name
+     * @param entryId - Entry ID
+     * @returns Promise resolving to entry data
+     */
+    getEntry(collectionName: string, entryId: string): Promise<any>;
+    /**
+     * Updates an existing entry.
+     * @param collectionName - Collection name
+     * @param entryId - Entry ID
+     * @param data - Updated data
+     * @returns Promise resolving to updated entry
+     */
+    update(collectionName: string, entryId: string, data: any): Promise<any>;
+    /**
+     * Performs vector search on a collection.
+     * @param collectionName - Collection name
+     * @param searchText - Text to search for
+     * @param limit - Maximum results
+     * @param scoreThreshold - Minimum similarity score
+     * @returns Promise resolving to search results
+     */
+    search(collectionName: string, searchText: string, limit?: number, scoreThreshold?: number): Promise<any>;
+    /**
+     * Deletes an entry from a collection.
+     * @param collectionName - Collection name
+     * @param entryId - Entry ID to delete
+     * @returns Promise resolving when deletion is complete
+     */
+    delete(collectionName: string, entryId: string): Promise<any>;
+}

package/dist/types/api-contracts.js

@@ -0,0 +1,8 @@
+/**
+ * API Contract Interfaces
+ * TypeScript interfaces that API service classes must implement
+ *
+ * These interfaces define the contract that API services must fulfill.
+ * They ensure consistent method signatures across all API implementations.
+ */
+export {};

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,87 +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 { 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>;
+}