lua-cli 3.1.0-alpha.4 → 3.1.0-alpha.5

package/dist/types/skill.js

@@ -459,7 +459,7 @@ export class PreProcessor {
  *   name: 'response-formatter',
  *   description: 'Formats responses with branding',
  *   execute: async (user, message, response, channel) => {
- *     return response + '\n\n---\nPowered by Acme Corp';
+ *     return { modifiedResponse: response + '\n\n---\nPowered by Acme Corp' };
  *   }
  * });
  * ```
@@ -468,7 +468,6 @@ export class PostProcessor {
     constructor(config) {
         this.name = config.name || 'unnamed-postprocessor';
         this.description = config.description;
-        this.asyncMode = config.async ?? false; // Default to synchronous
         this.executeFunction = config.execute;
     }
     getName() {
@@ -477,13 +476,99 @@ export class PostProcessor {
     getDescription() {
         return this.description;
     }
-    getAsync() {
-        return this.asyncMode;
-    }
     async execute(user, message, response, channel) {
         return this.executeFunction(user, message, response, channel);
     }
 }
+/**
+ * LuaMCPServer class.
+ * Defines an MCP (Model Context Protocol) server connection.
+ *
+ * MCP servers provide tools that can be used by your agent at runtime.
+ * You can connect to local servers (via stdio) or remote servers (via SSE/HTTP).
+ *
+ * @example
+ * ```typescript
+ * import { LuaMCPServer } from 'lua-cli';
+ *
+ * // Local MCP server via npx
+ * const wikipediaServer = new LuaMCPServer({
+ *   name: 'wikipedia',
+ *   transport: 'stdio',
+ *   command: 'npx',
+ *   args: ['-y', 'wikipedia-mcp'],
+ *   description: 'Wikipedia search and retrieval'
+ * });
+ *
+ * // Remote MCP server via SSE
+ * const weatherServer = new LuaMCPServer({
+ *   name: 'weather',
+ *   transport: 'sse',
+ *   url: 'https://api.example.com/mcp',
+ *   headers: {
+ *     'Authorization': 'Bearer ${env.WEATHER_API_KEY}'
+ *   },
+ *   description: 'Weather information service'
+ * });
+ * ```
+ */
+export class LuaMCPServer {
+    constructor(config) {
+        if (!config.name) {
+            throw new Error('MCP server name is required');
+        }
+        if (config.transport === 'stdio' && !config.command) {
+            throw new Error('Command is required for stdio transport');
+        }
+        if (config.transport === 'sse' && !config.url) {
+            throw new Error('URL is required for sse transport');
+        }
+        this.config = config;
+    }
+    getName() {
+        return this.config.name;
+    }
+    getTransport() {
+        return this.config.transport;
+    }
+    getTimeout() {
+        return this.config.timeout;
+    }
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Returns the server configuration in a format suitable for serialization.
+     * Environment variable references (${env.VAR_NAME}) are preserved for runtime resolution.
+     */
+    toJSON() {
+        const base = {
+            name: this.config.name,
+            transport: this.config.transport,
+        };
+        if (this.config.timeout) {
+            base.timeout = this.config.timeout;
+        }
+        if (this.config.transport === 'stdio') {
+            const stdioConfig = this.config;
+            base.command = stdioConfig.command;
+            if (stdioConfig.args) {
+                base.args = stdioConfig.args;
+            }
+            if (stdioConfig.env) {
+                base.env = stdioConfig.env;
+            }
+        }
+        else {
+            const sseConfig = this.config;
+            base.url = sseConfig.url;
+            if (sseConfig.headers) {
+                base.headers = sseConfig.headers;
+            }
+        }
+        return base;
+    }
+}
 /**
  * LuaAgent class.
  * Unified agent configuration that consolidates skills, webhooks, jobs, and processors.
@@ -524,6 +609,7 @@ export class LuaAgent {
      * @param config.jobs - Optional array of jobs
      * @param config.preProcessors - Optional array of preprocessors
      * @param config.postProcessors - Optional array of postprocessors
+     * @param config.mcpServers - Optional array of MCP servers
      */
     constructor(config) {
         this.name = config.name;
@@ -533,6 +619,7 @@ export class LuaAgent {
         this.jobs = config.jobs || [];
         this.preProcessors = config.preProcessors || [];
         this.postProcessors = config.postProcessors || [];
+        this.mcpServers = config.mcpServers || [];
     }
     getName() {
         return this.name;
@@ -555,4 +642,7 @@ export class LuaAgent {
     getPostProcessors() {
         return this.postProcessors;
     }
+    getMCPServers() {
+        return this.mcpServers;
+    }
 }

package/dist/utils/bundling.d.ts

@@ -65,15 +65,8 @@ export declare function bundlePreProcessor(preprocessor: any, indexFile: any, di
  */
 export declare function bundlePostProcessor(postprocessor: any, indexFile: any, distDir: string, project?: any, debugMode?: boolean): Promise<any>;
 /**
- * Extracts execute code and input schema from a tool.
- * This function:
- * 1. Reads the bundled tool code
- * 2. Detects and bundles any Jobs.create() calls within execute
- * 3. Extracts the execute function
- * 4. Converts Zod schema to JSON Schema format
- *
- * @param tool - The tool to extract metadata from (mutated with executeCode and inputSchema)
- * @param project - The ts-morph Project instance for AST analysis
- * @param distDir - Distribution directory for bundling nested jobs
+ * Extracts tool code from a bundled tool.
+ * Reads the bundled code, wraps it for VM execution (execute and condition),
+ * and converts the Zod schema to JSON Schema format.
  */
-export declare function extractExecuteCode(tool: ToolInfo, project: Project, distDir?: string): Promise<void>;
+export declare function extractToolCode(tool: ToolInfo, project: Project): Promise<void>;

package/dist/utils/bundling.js

@@ -8,7 +8,7 @@ import { build } from "esbuild";
 import { Project, Node } from "ts-morph";
 import { writeProgress } from "./cli.js";
 import { COMPILE_DIRS, COMPILE_FILES, ESBUILD_TOOL_CONFIG, ESBUILD_INDEX_CONFIG, DEFAULT_INPUT_SCHEMA, EXTERNAL_PACKAGES, } from '../config/compile.constants.js';
-import { wrapToolForVM, createExecuteFunction, evaluateZodSchemaToJsonSchema } from './compile.js';
+import { wrapExecuteForVM, wrapConditionForVM, evaluateZodSchemaToJsonSchema } from './compile.js';
 /**
  * Helper function to remove lua-cli and api-exports imports from source code.
  * Used when bundling via stdin or temp files where the plugin can't process them.
@@ -347,8 +347,6 @@ export async function bundleTool(tool, distDir, modifiedSource, debugMode) {
                 plugins: [sandboxGlobalsPlugin],
             });
         }
-        // Wrap the bundled code for VM execution environment
-        await wrapToolForVM(outputPath, tool);
         // Clean up temp file if created (unless in debug mode)
         if (tempFile && fs.existsSync(tempFile) && !debugMode) {
             try {
@@ -819,7 +817,6 @@ export async function bundlePostProcessor(postprocessor, indexFile, distDir, pro
             name: postprocessor.name,
             version: postprocessor.version,
             description: postprocessor.description,
-            async: postprocessor.async === true ? true : false, // Explicitly set boolean
             executeFunction,
             code: compressedCode
         };
@@ -845,18 +842,11 @@ async function bundleAndCompressProcessorCode(executeFunction, processorName, ty
 })`, distDir, sourceFilePath, debugMode);
 }
 /**
- * Extracts execute code and input schema from a tool.
- * This function:
- * 1. Reads the bundled tool code
- * 2. Detects and bundles any Jobs.create() calls within execute
- * 3. Extracts the execute function
- * 4. Converts Zod schema to JSON Schema format
- *
- * @param tool - The tool to extract metadata from (mutated with executeCode and inputSchema)
- * @param project - The ts-morph Project instance for AST analysis
- * @param distDir - Distribution directory for bundling nested jobs
+ * Extracts tool code from a bundled tool.
+ * Reads the bundled code, wraps it for VM execution (execute and condition),
+ * and converts the Zod schema to JSON Schema format.
  */
-export async function extractExecuteCode(tool, project, distDir) {
+export async function extractToolCode(tool, project) {
     try {
         const toolSourceFile = project.getSourceFile(tool.filePath);
         if (!toolSourceFile) {
@@ -890,28 +880,30 @@ export async function extractExecuteCode(tool, project, distDir) {
                 return;
             }
         }
-        // Extract execute code from bundled file
-        tool.executeCode = extractExecuteCodeFromBundledFile(tool);
-        // NOTE: Dynamic job bundling moved to source-level processing
-        // Attempting to extract from minified bundled code is too fragile
+        // Read bundled code and wrap for VM execution
+        const rawBundledCode = readBundledToolCode(tool);
+        if (rawBundledCode) {
+            tool.executeCode = wrapExecuteForVM(rawBundledCode, tool.className);
+            // Check if tool has condition and wrap it
+            const hasCondition = classDecl.getMethod('condition') || classDecl.getProperty('condition');
+            if (hasCondition) {
+                tool.conditionCode = wrapConditionForVM(rawBundledCode, tool.className);
+            }
+        }
         // Extract and convert input schema
         tool.inputSchema = await extractInputSchema(classDecl, tool);
     }
     catch (error) {
-        console.warn(`Warning: Could not extract execute code for ${tool.className}:`, error);
+        console.warn(`Warning: Could not extract tool metadata for ${tool.className}:`, error);
     }
 }
 /**
- * Extracts execute code from the bundled tool file.
- *
- * @param tool - The tool whose bundled code to read
- * @returns The execute function code or undefined if not found
+ * Reads the raw bundled tool code from the dist directory.
  */
-function extractExecuteCodeFromBundledFile(tool) {
+function readBundledToolCode(tool) {
     const bundledPath = path.join(process.cwd(), COMPILE_DIRS.DIST, COMPILE_DIRS.TOOLS, `${tool.className}.js`);
     if (fs.existsSync(bundledPath)) {
-        const bundledCode = fs.readFileSync(bundledPath, 'utf8');
-        return createExecuteFunction(bundledCode, tool);
+        return fs.readFileSync(bundledPath, 'utf8');
     }
     return undefined;
 }

package/dist/utils/compile.d.ts

@@ -12,24 +12,25 @@ export declare function compressCode(code: string): string;
  */
 export declare function findIndexFile(): string;
 /**
- * Resolves import path from module specifier with support for multiple extensions and index files
- * @param moduleSpecifier - The import path (e.g., './tools/MyTool' or '../utils')
+ * Resolves import path from module specifier with support for multiple extensions and index files.
+ * Handles modern TypeScript projects that use .js extensions in imports (Node16/NodeNext resolution).
+ * @param moduleSpecifier - The import path (e.g., './tools/MyTool.js' or '../utils')
  * @param currentFilePath - The file doing the importing
  * @returns Resolved absolute file path
  */
 export declare function resolveImportPath(moduleSpecifier: string, currentFilePath: string): string;
-/**
- * Creates execute function wrapper from bundled code
- */
-export declare function createExecuteFunction(bundledCode: string, tool: ToolInfo): string;
 /**
  * Evaluates Zod schema code and converts it to JSON Schema
  */
 export declare function evaluateZodSchemaToJsonSchema(zodSchemaCode: string): Promise<any>;
 /**
- * Wraps bundled tool code for VM execution
+ * Wraps raw bundled tool code for execute function
+ */
+export declare function wrapExecuteForVM(bundledCode: string, className: string): string;
+/**
+ * Wraps raw bundled tool code for condition evaluation
  */
-export declare function wrapToolForVM(outputPath: string, tool: ToolInfo): Promise<void>;
+export declare function wrapConditionForVM(bundledCode: string, className: string): string;
 /**
  * Extracts tool information from a new expression in the AST
  */
@@ -69,6 +70,7 @@ export declare function extractLuaAgentMetadata(indexFile: any): {
     jobs: any[];
     preProcessors: any[];
     postProcessors: any[];
+    mcpServers: any[];
 } | null;
 /**
  * Gets the file paths where skills are defined in a LuaAgent.
@@ -93,10 +95,17 @@ export declare function resolveLuaAgentReferences(agentMetadata: {
     jobs: any[];
     preProcessors: any[];
     postProcessors: any[];
+    mcpServers: any[];
 }, indexFile: any, project: Project): {
     skills: any[];
     webhooks: any[];
     jobs: any[];
     preProcessors: any[];
     postProcessors: any[];
+    mcpServers: any[];
 };
+/**
+ * Extracts MCP server metadata from a source file.
+ * Looks for LuaMCPServer constructor calls.
+ */
+export declare function extractMCPServersMetadata(sourceFile: any): any[];

package/dist/utils/compile.js

@@ -29,17 +29,24 @@ export function findIndexFile() {
     throw new Error("index.ts not found in current directory or src/ directory");
 }
 /**
- * Resolves import path from module specifier with support for multiple extensions and index files
- * @param moduleSpecifier - The import path (e.g., './tools/MyTool' or '../utils')
+ * Resolves import path from module specifier with support for multiple extensions and index files.
+ * Handles modern TypeScript projects that use .js extensions in imports (Node16/NodeNext resolution).
+ * @param moduleSpecifier - The import path (e.g., './tools/MyTool.js' or '../utils')
  * @param currentFilePath - The file doing the importing
  * @returns Resolved absolute file path
  */
 export function resolveImportPath(moduleSpecifier, currentFilePath) {
     const extensions = ['.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx', '/index.js'];
-    if (moduleSpecifier.startsWith('./') || moduleSpecifier.startsWith('../')) {
+    // Handle modern TS projects using .js extensions in imports (Node16/NodeNext module resolution)
+    // Strip the extension so we can properly resolve to the .ts source file
+    let normalizedSpecifier = moduleSpecifier;
+    if (moduleSpecifier.endsWith('.js')) {
+        normalizedSpecifier = moduleSpecifier.slice(0, -3);
+    }
+    if (normalizedSpecifier.startsWith('./') || normalizedSpecifier.startsWith('../')) {
         // Relative import - resolve relative to current file
         const currentDir = path.dirname(currentFilePath);
-        const basePath = path.resolve(currentDir, moduleSpecifier);
+        const basePath = path.resolve(currentDir, normalizedSpecifier);
         // Try each extension in order
         for (const ext of extensions) {
             const fullPath = ext.startsWith('/') ? path.join(basePath, ext) : basePath + ext;
@@ -52,7 +59,7 @@ export function resolveImportPath(moduleSpecifier, currentFilePath) {
     }
     else {
         // Absolute import - check in src/ directory
-        const srcBase = path.resolve(process.cwd(), 'src', moduleSpecifier);
+        const srcBase = path.resolve(process.cwd(), 'src', normalizedSpecifier);
         for (const ext of extensions) {
             const fullPath = ext.startsWith('/') ? path.join(srcBase, ext) : srcBase + ext;
             if (fs.existsSync(fullPath)) {
@@ -60,17 +67,9 @@ export function resolveImportPath(moduleSpecifier, currentFilePath) {
             }
         }
         // Fallback: return .ts in src/ (original behavior)
-        return path.resolve(process.cwd(), 'src', moduleSpecifier + '.ts');
+        return path.resolve(process.cwd(), 'src', normalizedSpecifier + '.ts');
     }
 }
-/**
- * Creates execute function wrapper from bundled code
- */
-export function createExecuteFunction(bundledCode, tool) {
-    // The bundled code is already wrapped for VM execution by wrapToolForVM
-    // Just return it directly since it's already an async function
-    return bundledCode;
-}
 /**
  * Evaluates Zod schema code and converts it to JSON Schema
  */
@@ -109,25 +108,28 @@ export async function evaluateZodSchemaToJsonSchema(zodSchemaCode) {
     }
 }
 /**
- * Wraps bundled tool code for VM execution
+ * Wraps raw bundled tool code for execute function
  */
-export async function wrapToolForVM(outputPath, tool) {
-    const bundledCode = fs.readFileSync(outputPath, 'utf8');
-    // Create a wrapper that's compatible with the existing sandbox.ts VM system
-    // The sandbox expects: const executeFunction = ${toolCode}; module.exports = async (input) => { return await executeFunction(input); };
-    const wrappedCode = `async (input) => {
-  
-  // Execute the bundled tool code
+export function wrapExecuteForVM(bundledCode, className) {
+    return `async (input) => {
   ${bundledCode}
   
-  // Get the tool class from exports
-  const ToolClass = module.exports.default || module.exports.${tool.className} || module.exports;
-  
-  // Create and execute the tool
+  const ToolClass = module.exports.default || module.exports.${className} || module.exports;
   const toolInstance = new ToolClass();
   return await toolInstance.execute(input);
 }`;
-    fs.writeFileSync(outputPath, wrappedCode);
+}
+/**
+ * Wraps raw bundled tool code for condition evaluation
+ */
+export function wrapConditionForVM(bundledCode, className) {
+    return `async () => {
+  ${bundledCode}
+  
+  const ToolClass = module.exports.default || module.exports.${className} || module.exports;
+  const toolInstance = new ToolClass();
+  return await toolInstance.condition() === true;
+}`;
 }
 /**
  * Extracts tool information from a new expression in the AST
@@ -463,7 +465,6 @@ export function extractPostProcessorsMetadata(indexFile) {
                     const configObj = args[0];
                     let name = '';
                     let description = '';
-                    let asyncMode = false;
                     configObj.getProperties().forEach((prop) => {
                         if (Node.isPropertyAssignment(prop)) {
                             const propName = prop.getName();
@@ -474,18 +475,12 @@ export function extractPostProcessorsMetadata(indexFile) {
                             else if (propName === 'description' && value) {
                                 description = value.getText().replace(/['"]/g, '');
                             }
-                            else if (propName === 'async' && value) {
-                                // Properly extract boolean value by checking node kind
-                                const nodeKind = value.getKind();
-                                asyncMode = nodeKind === 110; // TrueKeyword = 110, FalseKeyword = 95
-                            }
                         }
                     });
                     if (name) {
                         postprocessors.push({
                             name,
-                            description,
-                            async: asyncMode
+                            description
                         });
                     }
                 }
@@ -518,6 +513,7 @@ export function extractLuaAgentMetadata(indexFile) {
                     const jobs = [];
                     const preProcessors = [];
                     const postProcessors = [];
+                    const mcpServers = [];
                     // Extract properties from LuaAgent config
                     configObj.getProperties().forEach((prop) => {
                         if (Node.isPropertyAssignment(prop)) {
@@ -608,6 +604,22 @@ export function extractLuaAgentMetadata(indexFile) {
                                     }
                                 });
                             }
+                            else if (propName === 'mcpServers' && value && Node.isArrayLiteralExpression(value)) {
+                                // Extract MCP server references from the array
+                                value.getElements().forEach((element) => {
+                                    if (Node.isIdentifier(element)) {
+                                        mcpServers.push({ ref: element.getText() });
+                                    }
+                                    else if (Node.isNewExpression(element)) {
+                                        // Extract inline MCP server metadata
+                                        const mcpArgs = element.getArguments();
+                                        if (mcpArgs.length > 0 && Node.isObjectLiteralExpression(mcpArgs[0])) {
+                                            const mcpConfig = extractConfigFromObjectLiteral(mcpArgs[0]);
+                                            mcpServers.push(mcpConfig);
+                                        }
+                                    }
+                                });
+                            }
                         }
                     });
                     if (name && persona) {
@@ -618,7 +630,8 @@ export function extractLuaAgentMetadata(indexFile) {
                             webhooks,
                             jobs,
                             preProcessors,
-                            postProcessors
+                            postProcessors,
+                            mcpServers
                         };
                     }
                 }
@@ -788,9 +801,30 @@ export function resolveLuaAgentReferences(agentMetadata, indexFile, project) {
         webhooks: resolveArrayReferences(agentMetadata.webhooks, extractWebhooksMetadata),
         jobs: resolveArrayReferences(agentMetadata.jobs, extractJobsMetadata),
         preProcessors: resolveArrayReferences(agentMetadata.preProcessors, extractPreProcessorsMetadata),
-        postProcessors: resolveArrayReferences(agentMetadata.postProcessors, extractPostProcessorsMetadata)
+        postProcessors: resolveArrayReferences(agentMetadata.postProcessors, extractPostProcessorsMetadata),
+        mcpServers: resolveArrayReferences(agentMetadata.mcpServers, extractMCPServersMetadata)
     };
 }
+/**
+ * Extracts MCP server metadata from a source file.
+ * Looks for LuaMCPServer constructor calls.
+ */
+export function extractMCPServersMetadata(sourceFile) {
+    const mcpServers = [];
+    sourceFile.forEachDescendant((node) => {
+        if (Node.isNewExpression(node)) {
+            const expression = node.getExpression();
+            if (expression.getText() === 'LuaMCPServer') {
+                const args = node.getArguments();
+                if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
+                    const config = extractConfigFromObjectLiteral(args[0]);
+                    mcpServers.push(config);
+                }
+            }
+        }
+    });
+    return mcpServers;
+}
 /**
  * Finds a variable declaration in a source file by name.
  */

package/dist/utils/deployment.js

@@ -154,12 +154,19 @@ function buildSkillsArray(skillsMetadata, skillToTools, tools) {
             name: skillMeta.name,
             description: skillMeta.description,
             context: skillMeta.context,
-            tools: skillTools.map(tool => ({
-                name: tool.name,
-                description: tool.description || '',
-                inputSchema: tool.inputSchema || DEFAULT_INPUT_SCHEMA,
-                execute: compressCode(tool.executeCode || '')
-            }))
+            tools: skillTools.map(tool => {
+                const toolData = {
+                    name: tool.name,
+                    description: tool.description || '',
+                    inputSchema: tool.inputSchema || DEFAULT_INPUT_SCHEMA,
+                    execute: compressCode(tool.executeCode || '')
+                };
+                // Include condition if tool has one
+                if (tool.conditionCode) {
+                    toolData.condition = compressCode(tool.conditionCode);
+                }
+                return toolData;
+            })
         };
     });
 }

package/dist/utils/dev-api.js

@@ -349,8 +349,7 @@ export async function pushSinglePostProcessorToSandbox(apiKey, agentId, postproc
         version: sandboxVersion,
         description: postprocessorData.description,
         code: postprocessorData.code,
-        executeFunction: postprocessorData.executeFunction,
-        async: Boolean(postprocessorData.async ?? false)
+        executeFunction: postprocessorData.executeFunction
     };
     if (sandboxPostProcessorId) {
         // Try to update existing sandbox version

package/dist/utils/dev-server.js

@@ -792,7 +792,7 @@ async function handleCustomDataEndpoint(req, res, apiKey, agentId) {
                 req.on('end', () => resolve(data));
             });
             const updateData = JSON.parse(body);
-            result = await customDataApi.update(collectionName, entryId, updateData);
+            result = await customDataApi.update(collectionName, entryId, updateData.data, updateData.searchText);
             res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ success: true, data: result }));
         }

package/dist/utils/files.d.ts

@@ -1,4 +1,11 @@
-export declare function copyTemplateFiles(templateDir: string, targetDir: string): void;
+/**
+ * Copies template files to target directory.
+ *
+ * @param templateDir - Source template directory
+ * @param targetDir - Target directory to copy to
+ * @param includeExamples - Whether to include the examples/ directory (default: false)
+ */
+export declare function copyTemplateFiles(templateDir: string, targetDir: string, includeExamples?: boolean): void;
 export declare function createSkillYaml(agentId: string, orgId: string, skillName?: string, skillId?: string, persona?: string): void;
 export declare function readSkillYaml(): any;
 export declare function readSkillConfig(): any;

package/dist/utils/files.js

@@ -2,18 +2,29 @@ import * as fs from "fs";
 import * as path from "path";
 import pkg from 'js-yaml';
 const { load, dump } = pkg;
-export function copyTemplateFiles(templateDir, targetDir) {
+/**
+ * Copies template files to target directory.
+ *
+ * @param templateDir - Source template directory
+ * @param targetDir - Target directory to copy to
+ * @param includeExamples - Whether to include the examples/ directory (default: false)
+ */
+export function copyTemplateFiles(templateDir, targetDir, includeExamples = false) {
     const files = fs.readdirSync(templateDir);
     for (const file of files) {
         // Skip node_modules and package-lock.json to avoid circular dependencies
         if (file === 'node_modules' || file === 'package-lock.json') {
             continue;
         }
+        // Skip examples/ by default (user can include with --with-examples flag)
+        if (file === 'examples' && !includeExamples) {
+            continue;
+        }
         const srcPath = path.join(templateDir, file);
         const destPath = path.join(targetDir, file);
         if (fs.statSync(srcPath).isDirectory()) {
             fs.mkdirSync(destPath, { recursive: true });
-            copyTemplateFiles(srcPath, destPath);
+            copyTemplateFiles(srcPath, destPath, includeExamples);
         }
         else if (file === 'package.json') {
             // Special handling for package.json to update lua-cli version

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

@@ -14,9 +14,11 @@ export declare function getTemplateDir(): string;
  * @param agentId - Agent ID for configuration
  * @param orgId - Organization ID for configuration
  * @param persona - Optional persona configuration
+ * @param agentName - Optional agent name
+ * @param withExamples - Whether to include example skills, tools, jobs, etc. (default: false)
  * @returns Current working directory
  */
-export declare function initializeProject(agentId: string, orgId: string, persona?: string, agentName?: string): string;
+export declare function initializeProject(agentId: string, orgId: string, persona?: string, agentName?: string, withExamples?: boolean): string;
 /**
  * Installs npm dependencies for the project.
  *

package/dist/utils/init-helpers.js

@@ -24,17 +24,22 @@ export function getTemplateDir() {
  * @param agentId - Agent ID for configuration
  * @param orgId - Organization ID for configuration
  * @param persona - Optional persona configuration
+ * @param agentName - Optional agent name
+ * @param withExamples - Whether to include example skills, tools, jobs, etc. (default: false)
  * @returns Current working directory
  */
-export function initializeProject(agentId, orgId, persona, agentName) {
+export function initializeProject(agentId, orgId, persona, agentName, withExamples = false) {
     const templateDir = getTemplateDir();
     const currentDir = process.cwd();
-    copyTemplateFiles(templateDir, currentDir);
+    copyTemplateFiles(templateDir, currentDir, withExamples);
     createSkillYaml(agentId, orgId, undefined, undefined, persona);
     // Update LuaAgent in index.ts with agent configuration
     updateLuaAgentInIndexFile(currentDir, agentName, persona);
     writeProgress("✅ Created lua.skill.yaml");
     writeProgress("✅ Copied template files");
+    if (withExamples) {
+        writeProgress("✅ Included example skills, tools, jobs, and webhooks");
+    }
     writeProgress("✅ Updated LuaAgent configuration");
     return currentDir;
 }