lua-cli 2.5.7 → 3.0.0-alpha.1

package/dist/api-exports.js

@@ -26,17 +26,11 @@
  * const products = await Products.search('laptop');
  * ```
  */
-import { LuaSkill, env } from "./types/skill.js";
+import { LuaSkill, LuaWebhook, LuaJob, PreProcessor, PostProcessor, LuaAgent, env } from "./types/skill.js";
 import { BasketStatus } from "./interfaces/baskets.js";
 import { OrderStatus } from "./interfaces/orders.js";
-import { getUserInstance, getDataInstance, getProductsInstance, getBasketsInstance, getOrderInstance, } from "./api/lazy-instances.js";
-// ============================================================================
-// USER DATA API
-// ============================================================================
-/**
- * User Data API
- * Access user information and preferences
- */
+import { getUserInstance, getDataInstance, getProductsInstance, getBasketsInstance, getOrderInstance, getJobInstance, getChatInstance, } from "./api/lazy-instances.js";
+import { JobInstance } from "./common/job.instance.js";
 export const User = {
     /**
      * Retrieves current user data.
@@ -46,6 +40,24 @@ export const User = {
     async get() {
         const instance = await getUserInstance();
         return instance.get();
+    },
+    /**
+     * Gets the chat history for the current user.
+     *
+     * @returns Promise resolving to array of chat messages
+     *
+     * @example
+     * ```typescript
+     * const history = await User.getChatHistory();
+     * // Returns: [
+     * //   { role: 'user', content: [{type: 'text', text: 'hello'}], createdAt: '...', id: '...', threadId: '...' },
+     * //   { role: 'assistant', content: [{type: 'text', text: 'hi'}], createdAt: '...', id: '...', threadId: '...' }
+     * // ]
+     * ```
+     */
+    async getChatHistory() {
+        const instance = await getUserInstance();
+        return instance.getChatHistory();
     }
 };
 // ============================================================================
@@ -158,17 +170,6 @@ export const Products = {
         const instance = await getProductsInstance();
         return instance.create(product);
     },
-    /**
-     * Updates an existing product.
-     *
-     * @param data - Updated product data
-     * @param id - Product ID
-     * @returns Promise resolving to updated product
-     */
-    async update(data, id) {
-        const instance = await getProductsInstance();
-        return instance.update(data, id);
-    },
     /**
      * Deletes a product.
      *
@@ -366,7 +367,167 @@ export const Orders = {
     }
 };
 // ============================================================================
+// JOBS API
+// ============================================================================
+/**
+ * Jobs API
+ * Manage and trigger scheduled jobs from within your tools
+ */
+export const Jobs = {
+    /**
+     * Creates a new job dynamically from within a tool.
+     * This allows tools to schedule one-time or recurring jobs programmatically.
+     *
+     * @param config - Job configuration
+     * @param config.name - Unique job name
+     * @param config.description - Job description
+     * @param config.schedule - Schedule configuration (cron, once, or interval)
+     * @param config.execute - Async function to execute
+     * @param config.timeout - Optional timeout in seconds
+     * @param config.retry - Optional retry configuration
+     * @returns Promise resolving to created job details
+     *
+     * @example
+     * ```typescript
+     * // Create a one-time job to check basket in 3 hours
+     * await Jobs.create({
+     *   name: `check-basket-${basketId}`,
+     *   description: 'Check if basket was abandoned',
+     *   schedule: {
+     *     type: 'once',
+     *     executeAt: new Date(Date.now() + 3 * 60 * 60 * 1000)
+     *   },
+     *   execute: async () => {
+     *     const basket = await Baskets.getById(basketId);
+     *     if (basket.status === 'active') {
+     *       // Send reminder
+     *     }
+     *     return { checked: true };
+     *   }
+     * });
+     * ```
+     */
+    async create(config) {
+        const instance = await getJobInstance();
+        // Convert the execute function to a string
+        const executeString = config.execute.toString();
+        // Step 1: Create the job
+        const createResult = await instance.createJobInstance({
+            name: config.name,
+            description: config.description,
+            context: config.description || '',
+            schedule: config.schedule,
+            timeout: config.timeout,
+            retry: config.retry,
+            metadata: config.metadata
+        });
+        const jobId = createResult.jobId;
+        // Step 2: Push the initial version with execute function
+        const pushResult = await instance.pushJob(jobId, {
+            name: config.name,
+            version: '1.0.0',
+            description: config.description,
+            context: config.description || '',
+            jobId: jobId,
+            schedule: config.schedule,
+            timeout: config.timeout,
+            retry: config.retry,
+            executeFunction: executeString,
+            metadata: config.metadata
+        });
+        if (!pushResult.success) {
+            throw new Error(`Failed to push job version: ${pushResult.error?.message}`);
+        }
+        // Step 3: Activate the job so it starts running
+        const activateResult = await instance.activateJob(jobId);
+        if (!activateResult.success) {
+            console.warn(`Job created but activation failed: ${activateResult.error?.message}`);
+        }
+        // Step 4: Return a JobInstance for easy manipulation
+        return new JobInstance(instance, {
+            id: jobId,
+            jobId: jobId,
+            name: config.name,
+            schedule: config.schedule,
+            metadata: config.metadata || {},
+            active: activateResult.success
+        });
+    },
+    /**
+     * Retrieves a job by its unique identifier
+     * @param jobId - The unique identifier of the job to retrieve
+     * @returns Promise resolving to an JobInstance representing the job
+     * @throws Error if the job is not found or the request fails
+     */
+    async getJob(jobId) {
+        const instance = await getJobInstance();
+        return instance.getJob(jobId);
+    }
+};
+// ============================================================================
+// AI GENERATION API
+// ============================================================================
+/**
+ * AI API
+ * Generate AI responses with custom context
+ */
+export const AI = {
+    /**
+     * Generates an AI response with custom runtime context.
+     *
+     * @param context - Runtime context to provide to the AI
+     * @param messages - Array of messages (text, image, file, etc.)
+     * @param agentId - Optional agent ID to use (defaults to current agent)
+     * @returns Promise resolving to AI response text
+     *
+     * @example
+     * ```typescript
+     * // Simple text message with current agent
+     * const response = await AI.generate(
+     *   'You are a helpful sales assistant for our e-commerce store.',
+     *   [{ type: 'text', text: 'What products do you recommend for beginners?' }]
+     * );
+     * console.log(response); // AI-generated recommendation
+     *
+     * // Multiple messages with images
+     * const response2 = await AI.generate(
+     *   'You are an image analysis expert.',
+     *   [
+     *     { type: 'text', text: 'What do you see in this image?' },
+     *     { type: 'image', url: 'https://example.com/image.jpg' }
+     *   ]
+     * );
+     *
+     * // Use a different agent
+     * const response3 = await AI.generate(
+     *   'You are a specialized assistant.',
+     *   [{ type: 'text', text: 'Help me with this task' }],
+     *   'agent_different_123'
+     * );
+     * ```
+     */
+    async generate(context, messages, agentId) {
+        const chatInstance = await getChatInstance();
+        const { getCredentials } = await import('./api/credentials.js');
+        const credentials = await getCredentials();
+        // Use provided agentId or default to current agent
+        const targetAgentId = agentId || 'luaAgent';
+        const result = await chatInstance.sendMessage(targetAgentId, {
+            messages,
+            navigate: false,
+            skillOverride: [],
+            runtimeContext: context
+        });
+        if (!result.success) {
+            throw new Error(result.error?.message || 'AI generation failed');
+        }
+        return result.data?.text || '';
+    }
+};
+// ============================================================================
 // EXPORTS
 // ============================================================================
 // Export skill classes and utilities
-export { LuaSkill, BasketStatus, OrderStatus, env };
+export { LuaSkill, LuaWebhook, LuaJob, PreProcessor, PostProcessor, LuaAgent, BasketStatus, OrderStatus, env };
+// Export instance classes
+export { JobInstance };

package/dist/cli/command-definitions.js

@@ -2,7 +2,7 @@
  * Command Definitions
  * Centralized command structure for the CLI
  */
-import { configureCommand, initCommand, destroyCommand, apiKeyCommand, compileCommand, testCommand, pushCommand, deployCommand, chatCommand, chatClearCommand, envCommand, personaCommand, productionCommand, resourcesCommand, adminCommand, docsCommand, channelsCommand, logsCommand } from "../commands/index.js";
+import { configureCommand, initCommand, destroyCommand, apiKeyCommand, compileCommand, testCommand, pushCommand, deployCommand, chatCommand, chatClearCommand, envCommand, personaCommand, productionCommand, resourcesCommand, adminCommand, docsCommand, channelsCommand, logsCommand, completionCommand, skillsCommand, webhooksCommand, jobsCommand, featuresCommand, preprocessorsCommand, postprocessorsCommand } from "../commands/index.js";
 /**
  * Sets up authentication-related commands.
  *
@@ -53,13 +53,34 @@ export function setupSkillCommands(program) {
         .description("📦 Compile skill to deployable format")
         .action(compileCommand);
     program
-        .command("test")
-        .description("🧪 Test skill tools interactively")
+        .command("test [type]")
+        .description("🧪 Test skills, webhooks, or jobs interactively")
+        .addHelpText('after', `
+Arguments:
+  type                   Optional: 'skill', 'webhook', or 'job' (prompts if not provided)
+
+Examples:
+  $ lua test             Interactive selection
+  $ lua test skill       Test a skill/tool directly
+  $ lua test webhook     Test a webhook with query/headers/body
+  $ lua test job         Test a job by executing it
+`)
         .action(testCommand);
     // Deployment Commands
     program
-        .command("push")
-        .description("☁️  Push skill version to server")
+        .command("push [type]")
+        .description("☁️  Push skill, webhook, job, or persona version to server")
+        .addHelpText('after', `
+Arguments:
+  type                   Optional: 'skill', 'webhook', 'job', or 'persona' (prompts if not provided)
+
+Examples:
+  $ lua push             Interactive selection
+  $ lua push skill       Push a skill directly
+  $ lua push webhook     Push a webhook directly
+  $ lua push job         Push a job directly
+  $ lua push persona     Push a persona directly
+`)
         .action(pushCommand);
     program
         .command("deploy")
@@ -86,12 +107,32 @@ Examples:
         .action(chatClearCommand);
     // Configuration Commands
     program
-        .command("env")
+        .command("env [environment]")
         .description("⚙️  Manage environment variables")
+        .addHelpText('after', `
+Arguments:
+  environment            Optional: 'sandbox', 'staging', or 'production' (prompts if not provided)
+
+Examples:
+  $ lua env                    Interactive selection
+  $ lua env sandbox            Manage sandbox env vars directly
+  $ lua env staging            Manage staging env vars (alias for sandbox)
+  $ lua env production         Manage production env vars directly
+`)
         .action(envCommand);
     program
-        .command("persona")
+        .command("persona [env]")
         .description("🤖 Manage agent persona")
+        .addHelpText('after', `
+Arguments:
+  env                    Optional: 'sandbox', 'staging', or 'production' (prompts if not provided)
+
+Examples:
+  $ lua persona                Interactive selection
+  $ lua persona sandbox        Manage sandbox persona directly
+  $ lua persona staging        Manage staging persona (alias for sandbox)
+  $ lua persona production     Manage production persona directly
+`)
         .action(personaCommand);
     program
         .command("production")
@@ -117,4 +158,105 @@ Examples:
         .command("logs")
         .description("📊 View agent and skill logs")
         .action(logsCommand);
+    program
+        .command("skills [env]")
+        .description("⚙️  Manage and view skills")
+        .addHelpText('after', `
+Arguments:
+  env                    Optional: 'sandbox', 'staging', or 'production' (prompts if not provided)
+
+Examples:
+  $ lua skills                 Interactive selection
+  $ lua skills sandbox         View sandbox skills directly
+  $ lua skills staging         View staging skills (alias for sandbox)
+  $ lua skills production      Manage production skills directly
+`)
+        .action(skillsCommand);
+    program
+        .command("webhooks [env]")
+        .description("🪝 Manage and view webhooks")
+        .addHelpText('after', `
+Arguments:
+  env                    Optional: 'sandbox', 'staging', or 'production' (prompts if not provided)
+
+Examples:
+  $ lua webhooks                 Interactive selection
+  $ lua webhooks sandbox         View sandbox webhooks directly
+  $ lua webhooks staging         View staging webhooks (alias for sandbox)
+  $ lua webhooks production      Manage production webhooks directly
+`)
+        .action(webhooksCommand);
+    program
+        .command("jobs [env]")
+        .description("⏰ Manage and view scheduled jobs")
+        .addHelpText('after', `
+Arguments:
+  env                    Optional: 'sandbox', 'staging', or 'production' (prompts if not provided)
+
+Examples:
+  $ lua jobs                     Interactive selection
+  $ lua jobs sandbox             View sandbox jobs directly
+  $ lua jobs staging             View staging jobs (alias for sandbox)
+  $ lua jobs production          Manage production jobs (pause/resume/trigger)
+`)
+        .action(jobsCommand);
+    program
+        .command("features")
+        .description("🎯 Manage agent features (tickets, RAG, etc.)")
+        .addHelpText('after', `
+Features:
+  • View all available features
+  • Enable/disable features
+  • Update feature context and instructions
+  • Manage capabilities like tickets, RAG search, web search, and more
+
+Examples:
+  $ lua features               View and manage all agent features
+`)
+        .action(featuresCommand);
+    program
+        .command("preprocessors")
+        .description("📥 Manage message preprocessors")
+        .addHelpText('after', `
+Features:
+  • View deployed preprocessors
+  • View preprocessor versions
+  • Deploy versions to production
+  • Activate/deactivate preprocessors
+  • Delete preprocessors
+
+Examples:
+  $ lua preprocessors          Manage production preprocessors
+`)
+        .action(preprocessorsCommand);
+    program
+        .command("postprocessors")
+        .description("📤 Manage response postprocessors")
+        .addHelpText('after', `
+Features:
+  • View deployed postprocessors
+  • View postprocessor versions
+  • Deploy versions to production
+  • Activate/deactivate postprocessors
+  • Delete postprocessors
+
+Examples:
+  $ lua postprocessors         Manage production postprocessors
+`)
+        .action(postprocessorsCommand);
+    program
+        .command("completion [shell]")
+        .description("🎯 Generate shell completion script")
+        .addHelpText('after', `
+Arguments:
+  shell                  Optional: 'bash', 'zsh', or 'fish' (shows instructions if not provided)
+
+Examples:
+  $ lua completion              Show installation instructions
+  $ lua completion bash         Generate bash completion script
+  $ lua completion bash >> ~/.bashrc
+  $ lua completion zsh >> ~/.zshrc
+  $ lua completion fish > ~/.config/fish/completions/lua.fish
+`)
+        .action(completionCommand);
 }

package/dist/commands/compile.js

@@ -6,13 +6,18 @@ import fs from "fs";
 import path from "path";
 import { Project } from "ts-morph";
 import { withErrorHandling, writeProgress, writeSuccess } from "../utils/cli.js";
-import { findIndexFile } from '../utils/compile.js';
+import { findIndexFile, extractWebhooksMetadata, extractJobsMetadata, extractPreProcessorsMetadata, extractPostProcessorsMetadata } from '../utils/compile.js';
 import { detectTools } from '../utils/tool-detection.js';
-import { bundleTool, bundleMainIndex, extractExecuteCode } from '../utils/bundling.js';
+import { bundleTool, bundleMainIndex, extractExecuteCode, bundleWebhook, bundleJob, bundlePreProcessor, bundlePostProcessor } from '../utils/bundling.js';
 import { createDeploymentData, createLegacyDeploymentData } from '../utils/deployment.js';
 import { syncYamlWithDeployJson, syncServerSkillsWithYaml } from '../utils/skill-management.js';
+import { ensureWebhooksExistInYaml, syncServerWebhooksWithYaml } from '../utils/webhook-management.js';
+import { ensureJobsExistInYaml, syncServerJobsWithYaml } from '../utils/job-management.js';
+import { ensurePreProcessorsExistInYaml, syncServerPreProcessorsWithYaml } from '../utils/preprocessor-management.js';
+import { ensurePostProcessorsExistInYaml, syncServerPostProcessorsWithYaml } from '../utils/postprocessor-management.js';
 import { readSkillConfig } from '../utils/files.js';
 import { COMPILE_DIRS, COMPILE_FILES } from '../config/compile.constants.js';
+import { syncAgentPersonaWithYaml } from '../utils/agent-management.js';
 /**
  * Main compile command - orchestrates the entire skill compilation process.
  *
@@ -49,7 +54,28 @@ export async function compileCommand() {
         const indexPath = findIndexFile();
         const project = createTypeScriptProject();
         const indexFile = project.addSourceFileAtPath(indexPath);
-        const tools = await detectTools(indexFile, project);
+        // Step 2a: Check for LuaAgent (unified agent configuration)
+        writeProgress("🔍 Checking for LuaAgent configuration...");
+        const { extractLuaAgentMetadata, resolveLuaAgentReferences, getSkillFilePaths } = await import('../utils/compile.js');
+        const agentMetadata = extractLuaAgentMetadata(indexFile);
+        let skillFilePaths = [];
+        let resolvedAgentData = null;
+        if (agentMetadata) {
+            writeProgress(`✨ Found LuaAgent: ${agentMetadata.name}`);
+            writeProgress(`   Using new unified agent configuration approach`);
+            // Sync persona and welcome message with YAML
+            await syncAgentPersonaWithYaml(agentMetadata);
+            // Resolve references to get actual metadata for all components
+            resolvedAgentData = resolveLuaAgentReferences(agentMetadata, indexFile, project);
+            // Get file paths where skills are defined so we can scan them for tools
+            skillFilePaths = getSkillFilePaths(agentMetadata, indexFile);
+            writeProgress(`📦 Agent contains: ${resolvedAgentData.skills.length} skill(s), ${resolvedAgentData.webhooks.length} webhook(s), ${resolvedAgentData.jobs.length} job(s), ${resolvedAgentData.preProcessors.length} preprocessor(s), ${resolvedAgentData.postProcessors.length} postprocessor(s)`);
+        }
+        else {
+            writeProgress(`ℹ️  No LuaAgent found, using legacy detection for individual components`);
+        }
+        // Step 2b: Detect tools from index file and skill files
+        const tools = await detectTools(indexFile, project, skillFilePaths);
         writeProgress(`📦 Found ${tools.length} tools to bundle...`);
         // Step 3: Bundle each tool and extract metadata
         for (const tool of tools) {
@@ -60,7 +86,7 @@ export async function compileCommand() {
         await bundleMainIndex(indexPath, distDir);
         // Step 5: Create deployment data in both formats
         await createDeploymentData(tools, distDir);
-        await createLegacyDeploymentData(tools, luaDir, indexFile);
+        await createLegacyDeploymentData(tools, luaDir, indexFile, resolvedAgentData);
         // Step 6: Sync YAML with deploy.json
         writeProgress("🔄 Syncing YAML with deploy.json...");
         const deployJsonPath = path.join(luaDir, COMPILE_FILES.DEPLOY_JSON);
@@ -70,7 +96,100 @@ export async function compileCommand() {
         writeProgress("🔄 Syncing server with YAML...");
         const updatedConfig = readSkillConfig(); // Re-read config after YAML sync
         await syncServerSkillsWithYaml(updatedConfig);
-        writeSuccess(`✅ Skill compiled successfully - ${tools.length} tools bundled`);
+        // Step 8: Detect and process webhooks
+        writeProgress("🔍 Detecting webhooks...");
+        // Use resolved agent webhooks if available, otherwise scan index file
+        let webhooksMetadata = resolvedAgentData?.webhooks || extractWebhooksMetadata(indexFile);
+        let bundledWebhooks = [];
+        if (webhooksMetadata.length > 0) {
+            writeProgress(`📦 Found ${webhooksMetadata.length} webhook(s)...`);
+            // Bundle each webhook (extract execute function and schemas)
+            for (const webhook of webhooksMetadata) {
+                const bundled = await bundleWebhook(webhook, indexFile, distDir, project);
+                bundledWebhooks.push(bundled);
+            }
+            // Ensure webhooks exist in YAML with valid IDs
+            const configForWebhooks = readSkillConfig(); // Re-read for webhooks
+            await ensureWebhooksExistInYaml(webhooksMetadata, configForWebhooks);
+            // Sync server webhooks with YAML
+            writeProgress("🔄 Syncing server webhooks with YAML...");
+            const webhookConfig = readSkillConfig(); // Re-read after webhook updates
+            await syncServerWebhooksWithYaml(webhookConfig);
+            // Write bundled webhooks to file for reference
+            fs.writeFileSync(path.join(distDir, 'webhooks.json'), JSON.stringify(bundledWebhooks, null, 2));
+        }
+        // Step 9: Detect and process jobs
+        writeProgress("🔍 Detecting jobs...");
+        // Use resolved agent jobs if available, otherwise scan index file
+        let jobsMetadata = resolvedAgentData?.jobs || extractJobsMetadata(indexFile);
+        let bundledJobs = [];
+        if (jobsMetadata.length > 0) {
+            writeProgress(`📦 Found ${jobsMetadata.length} job(s)...`);
+            // Bundle each job (extract execute function)
+            for (const job of jobsMetadata) {
+                const bundled = await bundleJob(job, indexFile, distDir, project);
+                bundledJobs.push(bundled);
+            }
+            // Ensure jobs exist in YAML with valid IDs
+            const configForJobs = readSkillConfig(); // Re-read for jobs
+            await ensureJobsExistInYaml(jobsMetadata, configForJobs);
+            // Sync server jobs with YAML
+            writeProgress("🔄 Syncing server jobs with YAML...");
+            const jobConfig = readSkillConfig(); // Re-read after job updates
+            await syncServerJobsWithYaml(jobConfig);
+            // Write bundled jobs to file for reference
+            fs.writeFileSync(path.join(distDir, 'jobs.json'), JSON.stringify(bundledJobs, null, 2));
+        }
+        // Step 10: Detect and process preprocessors
+        writeProgress("🔍 Detecting preprocessors...");
+        // Use resolved agent preprocessors if available, otherwise scan index file
+        let preprocessorsMetadata = resolvedAgentData?.preProcessors || extractPreProcessorsMetadata(indexFile);
+        let bundledPreProcessors = [];
+        if (preprocessorsMetadata.length > 0) {
+            writeProgress(`📦 Found ${preprocessorsMetadata.length} preprocessor(s)...`);
+            for (const preprocessor of preprocessorsMetadata) {
+                const bundled = await bundlePreProcessor(preprocessor, indexFile, distDir, project);
+                bundledPreProcessors.push(bundled);
+            }
+            // Ensure preprocessors exist in YAML with valid IDs
+            const configForPreProcessors = readSkillConfig();
+            await ensurePreProcessorsExistInYaml(preprocessorsMetadata, configForPreProcessors);
+            // Sync server preprocessors with YAML
+            writeProgress("🔄 Syncing server preprocessors with YAML...");
+            const preprocessorConfig = readSkillConfig();
+            await syncServerPreProcessorsWithYaml(preprocessorConfig);
+            fs.writeFileSync(path.join(distDir, 'preprocessors.json'), JSON.stringify(bundledPreProcessors, null, 2));
+        }
+        // Step 11: Detect and process postprocessors
+        writeProgress("🔍 Detecting postprocessors...");
+        // Use resolved agent postprocessors if available, otherwise scan index file
+        let postprocessorsMetadata = resolvedAgentData?.postProcessors || extractPostProcessorsMetadata(indexFile);
+        let bundledPostProcessors = [];
+        if (postprocessorsMetadata.length > 0) {
+            writeProgress(`📦 Found ${postprocessorsMetadata.length} postprocessor(s)...`);
+            for (const postprocessor of postprocessorsMetadata) {
+                const bundled = await bundlePostProcessor(postprocessor, indexFile, distDir, project);
+                bundledPostProcessors.push(bundled);
+            }
+            // Ensure postprocessors exist in YAML with valid IDs
+            const configForPostProcessors = readSkillConfig();
+            await ensurePostProcessorsExistInYaml(postprocessorsMetadata, configForPostProcessors);
+            // Sync server postprocessors with YAML
+            writeProgress("🔄 Syncing server postprocessors with YAML...");
+            const postprocessorConfig = readSkillConfig();
+            await syncServerPostProcessorsWithYaml(postprocessorConfig);
+            fs.writeFileSync(path.join(distDir, 'postprocessors.json'), JSON.stringify(bundledPostProcessors, null, 2));
+        }
+        const summaryParts = [`${tools.length} tools bundled`];
+        if (webhooksMetadata.length > 0)
+            summaryParts.push(`${webhooksMetadata.length} webhook(s) registered`);
+        if (jobsMetadata.length > 0)
+            summaryParts.push(`${jobsMetadata.length} job(s) registered`);
+        if (preprocessorsMetadata.length > 0)
+            summaryParts.push(`${preprocessorsMetadata.length} preprocessor(s) registered`);
+        if (postprocessorsMetadata.length > 0)
+            summaryParts.push(`${postprocessorsMetadata.length} postprocessor(s) registered`);
+        writeSuccess(`✅ Skill compiled successfully - ${summaryParts.join(', ')}`);
     }, "compilation");
 }
 /**

package/dist/commands/completion.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Completion Command
+ * Generates shell completion scripts for the Lua CLI
+ */
+/**
+ * Main completion command - generates shell completion scripts
+ *
+ * @param shell - Shell type (bash, zsh, fish)
+ * @returns Promise that resolves when command completes
+ */
+export declare function completionCommand(shell?: string): Promise<void>;