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

package/dist/commands/compile.js

@@ -1,781 +1,89 @@
+/**
+ * Compile Command
+ * Orchestrates the skill compilation process by coordinating various compilation steps
+ */
 import fs from "fs";
 import path from "path";
-import { gzipSync } from "zlib";
+import { Project } from "ts-morph";
 import { withErrorHandling, writeProgress, writeSuccess } from "../utils/cli.js";
-import { readSkillConfig } from '../utils/files.js';
-import { loadApiKey } from '../services/auth.js';
-import { ApiService } from '../services/api.js';
-import { Project, Node } from "ts-morph";
-import { build } from "esbuild";
-import yaml from "js-yaml";
-// Compression utilities
-function compressCode(code) {
-    const compressed = gzipSync(code);
-    return compressed.toString('base64');
-}
+import { findIndexFile } from '../utils/compile.js';
+import { detectTools } from '../utils/tool-detection.js';
+import { bundleTool, bundleMainIndex, extractExecuteCode } from '../utils/bundling.js';
+import { createDeploymentData, createLegacyDeploymentData } from '../utils/deployment.js';
+import { COMPILE_DIRS, COMPILE_FILES } from '../config/compile.constants.js';
+/**
+ * Main compile command - orchestrates the entire skill compilation process.
+ *
+ * This command performs the following steps:
+ * 1. Cleans and prepares output directories (dist/ and .lua/)
+ * 2. Analyzes the TypeScript project to detect all tools
+ * 3. Bundles each tool individually using esbuild
+ * 4. Extracts execute code and schemas from bundled tools
+ * 5. Bundles the main index file
+ * 6. Creates deployment data in both new and legacy formats
+ *
+ * Output:
+ * - dist/deployment.json - New deployment format with tool references
+ * - dist/tools/*.js - Individual bundled tool files
+ * - dist/index.js - Main skill entry point
+ * - .lua/deploy.json - Legacy deployment format with compressed tools
+ * - .lua/*.js - Individual uncompressed tool files for debugging
+ *
+ * @returns Promise that resolves when compilation is complete
+ */
 export async function compileCommand() {
     return withErrorHandling(async () => {
         writeProgress("🔨 Compiling Lua skill...");
-        // Clean up old directories
-        const distDir = path.join(process.cwd(), "dist");
-        const luaDir = path.join(process.cwd(), ".lua");
-        if (fs.existsSync(distDir)) {
-            fs.rmSync(distDir, { recursive: true, force: true });
-        }
-        if (fs.existsSync(luaDir)) {
-            fs.rmSync(luaDir, { recursive: true, force: true });
-        }
-        // Create directory structures
-        fs.mkdirSync(distDir, { recursive: true });
-        fs.mkdirSync(path.join(distDir, "tools"), { recursive: true });
-        fs.mkdirSync(luaDir, { recursive: true });
-        // Find index.ts file
+        // Step 1: Prepare output directories
+        const { distDir, luaDir } = prepareOutputDirectories();
+        // Step 2: Analyze TypeScript project and detect tools
         const indexPath = findIndexFile();
-        // Use ts-morph to analyze the TypeScript project
-        const project = new Project({
-            tsConfigFilePath: path.join(process.cwd(), "tsconfig.json"),
-        });
-        // Add the index file to the project
+        const project = createTypeScriptProject();
         const indexFile = project.addSourceFileAtPath(indexPath);
-        // Detect tools from skill.addTools calls
         const tools = await detectTools(indexFile, project);
         writeProgress(`📦 Found ${tools.length} tools to bundle...`);
-        // Bundle each tool individually and extract execute code
+        // Step 3: Bundle each tool and extract metadata
         for (const tool of tools) {
             await bundleTool(tool, distDir);
             await extractExecuteCode(tool, project);
         }
-        // Bundle the main index file
+        // Step 4: Bundle the main index file
         await bundleMainIndex(indexPath, distDir);
-        // Create both deployment formats
+        // Step 5: Create deployment data in both formats
         await createDeploymentData(tools, distDir);
         await createLegacyDeploymentData(tools, luaDir, indexFile);
         writeSuccess(`✅ Skill compiled successfully - ${tools.length} tools bundled`);
     }, "compilation");
 }
-function findIndexFile() {
-    // Check for index.ts in current directory
-    let indexPath = path.join(process.cwd(), "index.ts");
-    if (fs.existsSync(indexPath)) {
-        return indexPath;
-    }
-    // Check for index.ts in src directory
-    indexPath = path.join(process.cwd(), "src", "index.ts");
-    if (fs.existsSync(indexPath)) {
-        return indexPath;
-    }
-    throw new Error("index.ts not found in current directory or src/ directory");
-}
-async function detectTools(indexFile, project) {
-    const tools = [];
-    // Find tools in LuaSkill constructors
-    indexFile.forEachDescendant((node) => {
-        if (Node.isNewExpression(node)) {
-            const expression = node.getExpression();
-            if (expression.getText() === 'LuaSkill') {
-                const args = node.getArguments();
-                if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
-                    const configObj = args[0];
-                    // Look for tools property in constructor
-                    configObj.getProperties().forEach((prop) => {
-                        if (Node.isPropertyAssignment(prop) && prop.getName() === 'tools') {
-                            const value = prop.getInitializer();
-                            if (value && Node.isArrayLiteralExpression(value)) {
-                                const toolsArray = value;
-                                toolsArray.getElements().forEach((element) => {
-                                    if (Node.isNewExpression(element)) {
-                                        const toolInfo = extractToolFromNewExpressionSync(element, project);
-                                        if (toolInfo) {
-                                            tools.push(toolInfo);
-                                        }
-                                    }
-                                });
-                            }
-                        }
-                    });
-                }
-            }
-        }
-    });
-    // Find all call expressions in the file (addTools method calls)
-    indexFile.forEachDescendant((node) => {
-        if (Node.isCallExpression(node)) {
-            const expression = node.getExpression();
-            // Check if this is skill.addTools or skill.addTool
-            if (Node.isPropertyAccessExpression(expression)) {
-                const object = expression.getExpression();
-                const property = expression.getName();
-                if (property === 'addTools' || property === 'addTool') {
-                    const args = node.getArguments();
-                    if (property === 'addTools' && args.length > 0) {
-                        // Handle skill.addTools([...]) - array of tools
-                        const arrayArg = args[0];
-                        if (Node.isArrayLiteralExpression(arrayArg)) {
-                            const elements = arrayArg.getElements();
-                            for (const element of elements) {
-                                if (Node.isNewExpression(element)) {
-                                    const toolInfo = extractToolFromNewExpressionSync(element, project);
-                                    if (toolInfo) {
-                                        tools.push(toolInfo);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    else if (property === 'addTool' && args.length > 0) {
-                        // Handle skill.addTool(new ToolClass()) - single tool
-                        const arg = args[0];
-                        if (Node.isNewExpression(arg)) {
-                            const toolInfo = extractToolFromNewExpressionSync(arg, project);
-                            if (toolInfo) {
-                                tools.push(toolInfo);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    });
-    return tools;
-}
-function extractToolFromNewExpressionSync(newExpr, project) {
-    try {
-        const expression = newExpr.getExpression();
-        const className = expression.getText();
-        // Find the import declaration for this class
-        const sourceFile = newExpr.getSourceFile();
-        const imports = sourceFile.getImportDeclarations();
-        for (const importDecl of imports) {
-            const namedImports = importDecl.getNamedImports();
-            const defaultImport = importDecl.getDefaultImport();
-            let toolFilePath = null;
-            // Check named imports
-            for (const namedImport of namedImports) {
-                if (namedImport.getName() === className) {
-                    toolFilePath = resolveImportPath(importDecl.getModuleSpecifierValue(), sourceFile.getFilePath());
-                    break;
-                }
-            }
-            // Check default import
-            if (!toolFilePath && defaultImport && defaultImport.getText() === className) {
-                toolFilePath = resolveImportPath(importDecl.getModuleSpecifierValue(), sourceFile.getFilePath());
-            }
-            if (toolFilePath && fs.existsSync(toolFilePath)) {
-                // Extract tool metadata from the class file
-                try {
-                    const toolSourceFile = project.addSourceFileAtPath(toolFilePath);
-                    const classDecl = toolSourceFile.getClass(className);
-                    if (classDecl) {
-                        const nameProperty = classDecl.getProperty('name');
-                        const descProperty = classDecl.getProperty('description');
-                        let toolName = className.replace(/Tool$/, '').toLowerCase();
-                        let description = '';
-                        // Extract name from property if available
-                        if (nameProperty && nameProperty.getInitializer()) {
-                            const nameValue = nameProperty.getInitializer()?.getText();
-                            if (nameValue) {
-                                toolName = nameValue.replace(/['"]/g, '');
-                            }
-                        }
-                        // Extract description from property if available
-                        if (descProperty && descProperty.getInitializer()) {
-                            const descValue = descProperty.getInitializer()?.getText();
-                            if (descValue) {
-                                description = descValue.replace(/['"]/g, '');
-                            }
-                        }
-                        const toolInfo = {
-                            name: toolName,
-                            className,
-                            filePath: toolFilePath,
-                            description
-                        };
-                        return toolInfo;
-                    }
-                }
-                catch (fileError) {
-                    console.warn(`Warning: Could not load tool file ${toolFilePath}:`, fileError);
-                }
-            }
-        }
-        return null;
-    }
-    catch (error) {
-        console.warn(`Warning: Could not extract tool info for ${newExpr.getText()}:`, error);
-        return null;
-    }
-}
-function resolveImportPath(moduleSpecifier, currentFilePath) {
-    if (moduleSpecifier.startsWith('./') || moduleSpecifier.startsWith('../')) {
-        // Relative import - resolve relative to current file
-        const currentDir = path.dirname(currentFilePath);
-        return path.resolve(currentDir, moduleSpecifier + '.ts');
-    }
-    else {
-        // Absolute import - assume it's in the project
-        return path.resolve(process.cwd(), 'src', moduleSpecifier + '.ts');
-    }
-}
-async function bundleTool(tool, distDir) {
-    writeProgress(`📦 Bundling ${tool.className}...`);
-    try {
-        const outputPath = path.join(distDir, 'tools', `${tool.className}.js`);
-        await build({
-            entryPoints: [tool.filePath],
-            bundle: true,
-            format: 'cjs',
-            platform: 'node',
-            target: 'node16',
-            outfile: outputPath,
-            external: ['lua-cli/skill', 'lua-cli/user-data-api', 'lua-cli/product-api', 'lua-cli/custom-data-api', 'zod', 'keytar', 'esbuild', 'commander', 'inquirer', 'node-fetch', 'ws', 'socket.io-client', 'ts-morph'], // Exclude lua-cli modules, zod, and native modules
-            minify: true, // Minify for smaller file sizes
-            sourcemap: false,
-            resolveExtensions: ['.ts', '.js', '.json'],
-            define: {
-                'process.env.NODE_ENV': '"production"'
-            },
-            // Ensure all other dependencies are bundled
-            packages: 'bundle',
-            // Handle different module formats
-            mainFields: ['main', 'module'],
-            conditions: ['node']
-        });
-        // Add VM-compatible wrapper
-        await wrapToolForVM(outputPath, tool);
-    }
-    catch (error) {
-        console.warn(`Warning: Failed to bundle ${tool.className}:`, error);
-    }
-}
-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) => {
-  // Mock lua-cli/skill module for external dependencies
-  const luaCliSkill = {
-    env: function(key) {
-      if (typeof env !== 'undefined') {
-        return env(key);
-      }
-      return process.env[key] || '';
-    }
-  };
-  
-  // Mock lua-cli/user-data-api module
-  const luaCliUserDataApi = {
-    user: typeof user !== 'undefined' ? user : {
-      data: {
-        get: async () => ({}),
-        update: async (data) => data,
-        create: async (data) => data
-      }
-    }
-  };
-
-  // Mock lua-cli/product-api module
-  const luaCliProductApi = {
-    product: typeof product !== 'undefined' ? product : {
-      data: {
-        get: async (page = 1, limit = 10) => ({ success: true, data: [], pagination: { currentPage: page, totalPages: 1, totalCount: 0, limit, hasNextPage: false, hasPrevPage: false, nextPage: null, prevPage: null } }),
-        update: async (data, productId) => ({ updated: true, isNew: false, product: data }),
-        create: async (data) => ({ updated: false, isNew: true, product: data }),
-        delete: async (productId) => ({ deleted: true }),
-        search: async (searchQuery) => ({ success: true, message: \`Found 0 products for "\${searchQuery}"\`, data: [] })
-      }
-    }
-  };
-
-  // Mock lua-cli/custom-data-api module
-  const luaCliCustomDataApi = {
-    customData: typeof customData !== 'undefined' ? customData : {
-      create: async (collectionName, data) => ({
-        id: 'mock-id-' + Date.now(),
-        data: data.data,
-        createdAt: Date.now(),
-        updatedAt: Date.now(),
-        searchText: data.searchText
-      }),
-      get: async (collectionName, filter, page = 1, limit = 10) => ({
-        data: [],
-        pagination: {
-          currentPage: page,
-          totalPages: 1,
-          totalCount: 0,
-          limit,
-          hasNextPage: false,
-          hasPrevPage: false
-        }
-      }),
-      getEntry: async (collectionName, entryId) => null,
-      update: async (collectionName, entryId, data) => ({
-        status: 'success',
-        message: 'Custom data entry updated'
-      }),
-      search: async (collectionName, searchText, limit = 10, scoreThreshold = 0.6) => ({
-        data: [],
-        count: 0
-      }),
-      delete: async (collectionName, entryId) => ({
-        status: 'success',
-        message: 'Custom data entry deleted'
-      })
-    }
-  };
-  
-  // Mock zod module  
-  const zodModule = (() => {
-    try {
-      if (typeof require !== 'undefined') {
-        return require('zod');
-      }
-    } catch (e) {
-      // Fallback zod implementation
-    }
-    return {
-      z: {
-        object: (schema) => ({
-          parse: (data) => data,
-          safeParse: (data) => ({ success: true, data })
-        }),
-        string: () => ({
-          parse: (data) => String(data),
-          safeParse: (data) => ({ success: true, data: String(data) })
-        }),
-        number: () => ({
-          parse: (data) => Number(data),
-          safeParse: (data) => ({ success: true, data: Number(data) })
-        }),
-        boolean: () => ({
-          parse: (data) => Boolean(data),
-          safeParse: (data) => ({ success: true, data: Boolean(data) })
-        })
-      }
-    };
-  })();
-  
-  // Override require for external modules during execution
-  const originalRequire = require;
-  require = function(id) {
-    if (id === 'lua-cli/skill') {
-      return luaCliSkill;
-    }
-    if (id === 'lua-cli/user-data-api') {
-      return luaCliUserDataApi;
-    }
-    if (id === 'lua-cli/product-api') {
-      return luaCliProductApi;
-    }
-    if (id === 'lua-cli/custom-data-api') {
-      return luaCliCustomDataApi;
-    }
-    if (id === 'zod') {
-      return zodModule;
-    }
-    return originalRequire(id);
-  };
-  
-  // Execute the bundled tool code
-  ${bundledCode}
-  
-  // Restore original require
-  require = originalRequire;
-  
-  // Get the tool class from exports
-  const ToolClass = module.exports.default || module.exports.${tool.className} || module.exports;
-  
-  // Create and execute the tool
-  const toolInstance = new ToolClass();
-  return await toolInstance.execute(input);
-}`;
-    fs.writeFileSync(outputPath, wrappedCode);
-}
-async function bundleMainIndex(indexPath, distDir) {
-    writeProgress("📦 Bundling main index...");
-    try {
-        await build({
-            entryPoints: [indexPath],
-            bundle: true,
-            format: 'cjs',
-            platform: 'node',
-            target: 'node16',
-            outfile: path.join(distDir, 'index.js'),
-            external: ['lua-cli/skill', 'lua-cli/user-data-api', 'lua-cli/product-api', 'lua-cli/custom-data-api', 'zod', 'keytar', 'esbuild', 'commander', 'inquirer', 'node-fetch', 'ws', 'socket.io-client', 'ts-morph'], // Exclude lua-cli modules, zod, and native modules
-            minify: true, // Minify for smaller file sizes
-            sourcemap: false,
-            resolveExtensions: ['.ts', '.js', '.json'],
-            define: {
-                'process.env.NODE_ENV': '"production"'
-            },
-            packages: 'bundle',
-            mainFields: ['main', 'module'],
-            conditions: ['node']
-        });
-    }
-    catch (error) {
-        console.warn("Warning: Failed to bundle main index:", error);
-    }
-}
-async function extractExecuteCode(tool, project) {
-    try {
-        const toolSourceFile = project.getSourceFile(tool.filePath);
-        if (!toolSourceFile) {
-            console.warn(`Warning: Could not find source file for ${tool.className}`);
-            return;
-        }
-        const classDecl = toolSourceFile.getClass(tool.className);
-        if (!classDecl) {
-            console.warn(`Warning: Could not find class ${tool.className} in ${tool.filePath}`);
-            return;
-        }
-        // Extract the execute method
-        const executeMethod = classDecl.getMethod('execute');
-        if (!executeMethod) {
-            console.warn(`Warning: Could not find execute method in ${tool.className}`);
-            return;
-        }
-        // Get the execute method body
-        const executeBody = executeMethod.getBodyText();
-        if (!executeBody) {
-            console.warn(`Warning: Execute method has no body in ${tool.className}`);
-            return;
-        }
-        // Read the bundled tool file to get the self-contained code
-        const bundledPath = path.join(process.cwd(), 'dist', 'tools', `${tool.className}.js`);
-        if (fs.existsSync(bundledPath)) {
-            const bundledCode = fs.readFileSync(bundledPath, 'utf8');
-            // Extract just the tool execution function from the bundled code
-            // The bundled code contains the VM wrapper, we need to extract the core functionality
-            const executeFunction = createExecuteFunction(bundledCode, tool);
-            tool.executeCode = executeFunction;
-        }
-        // Extract input schema from zod definition using proper library
-        const inputSchemaProperty = classDecl.getProperty('inputSchema');
-        if (inputSchemaProperty && inputSchemaProperty.getInitializer()) {
-            const initializer = inputSchemaProperty.getInitializer();
-            if (initializer) {
-                try {
-                    // Evaluate the Zod schema to get the actual schema object
-                    const zodSchemaCode = initializer.getText();
-                    tool.inputSchema = await evaluateZodSchemaToJsonSchema(zodSchemaCode);
-                }
-                catch (error) {
-                    console.warn(`Warning: Could not parse Zod schema for ${tool.className}:`, error);
-                    tool.inputSchema = { type: "object" };
-                }
-            }
-        }
-        if (!tool.inputSchema) {
-            tool.inputSchema = { type: "object" };
-        }
-    }
-    catch (error) {
-        console.warn(`Warning: Could not extract execute code for ${tool.className}:`, error);
-    }
-}
-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;
-}
-async function evaluateZodSchemaToJsonSchema(zodSchemaCode) {
-    try {
-        // Import zod and zod-to-json-schema dynamically
-        const { z } = await import('zod');
-        const { zodToJsonSchema } = await import('zod-to-json-schema');
-        // Create a safe evaluation context using Function constructor
-        const evalFunction = new Function('z', `return ${zodSchemaCode}`);
-        const zodSchema = evalFunction(z);
-        // Convert to JSON Schema using the library
-        const jsonSchema = zodToJsonSchema(zodSchema, 'schema');
-        // Extract just the core schema, removing JSON Schema references and definitions
-        if (jsonSchema.$ref && jsonSchema.definitions && jsonSchema.definitions.schema) {
-            // Return just the schema definition without the wrapper
-            return jsonSchema.definitions.schema;
-        }
-        // Remove the top-level $schema and title properties that we don't need
-        const { $schema, title, definitions, $ref, ...cleanSchema } = jsonSchema;
-        return cleanSchema;
-    }
-    catch (error) {
-        console.warn('Warning: Could not evaluate Zod schema, falling back to basic parsing:', error);
-        // Fallback to basic parsing for simple cases
-        if (zodSchemaCode.includes('z.object({')) {
-            return { type: 'object' };
-        }
-        if (zodSchemaCode.includes('z.string()'))
-            return { type: 'string' };
-        if (zodSchemaCode.includes('z.number()'))
-            return { type: 'number' };
-        if (zodSchemaCode.includes('z.boolean()'))
-            return { type: 'boolean' };
-        return { type: 'object' };
-    }
-}
-async function createDeploymentData(tools, distDir) {
-    const config = readSkillConfig();
-    const packageJsonPath = path.join(process.cwd(), "package.json");
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-    const deploymentData = {
-        name: config?.skill?.name || packageJson.name || "lua-skill",
-        version: config?.skill?.version || packageJson.version || "1.0.0",
-        skillId: config?.skill?.skillId || "",
-        description: config?.skill?.description || packageJson.description || "",
-        context: config?.skill?.context || "",
-        tools: tools.map(tool => ({
-            name: tool.name,
-            className: tool.className,
-            description: tool.description || "",
-            filePath: `tools/${tool.className}.js`
-        }))
-    };
-    fs.writeFileSync(path.join(distDir, 'deployment.json'), JSON.stringify(deploymentData, null, 2));
-}
-async function createLegacyDeploymentData(tools, luaDir, indexFile) {
-    const config = readSkillConfig();
-    const packageJsonPath = path.join(process.cwd(), "package.json");
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-    // Extract skills metadata from index.ts
-    const skillsMetadata = extractSkillsMetadata(indexFile);
-    // Group tools by skill based on addTools calls
-    const skillToTools = new Map();
-    // Find addTools calls to associate tools with skills
-    indexFile.forEachDescendant((node) => {
-        if (Node.isCallExpression(node)) {
-            const expression = node.getExpression();
-            if (Node.isPropertyAccessExpression(expression) && expression.getName() === 'addTools') {
-                const object = expression.getExpression();
-                const objectName = object.getText();
-                // Get the tools array
-                const args = node.getArguments();
-                if (args.length > 0 && Node.isArrayLiteralExpression(args[0])) {
-                    const toolsArray = args[0];
-                    const toolNames = toolsArray.getElements().map((element) => {
-                        if (Node.isNewExpression(element)) {
-                            return element.getExpression().getText();
-                        }
-                        return '';
-                    }).filter(name => name);
-                    skillToTools.set(objectName, toolNames);
-                }
-            }
-        }
-    });
-    // Create skills array with their associated tools
-    const skillsArray = skillsMetadata.map(skillMeta => {
-        let skillTools = [];
-        // First, check for tools from constructor
-        if (skillMeta.constructorTools && skillMeta.constructorTools.length > 0) {
-            skillTools = tools.filter(tool => {
-                return skillMeta.constructorTools.includes(tool.className) ||
-                    skillMeta.constructorTools.includes(tool.name);
-            });
-        }
-        else {
-            // Find tools for this skill by matching variable names from addTools calls
-            for (const [varName, toolNames] of skillToTools.entries()) {
-                // Simple heuristic: if variable name contains skill name, associate tools
-                if (varName.toLowerCase().includes(skillMeta.name.toLowerCase().replace('-skill', '')) ||
-                    varName.toLowerCase().includes(skillMeta.name.toLowerCase())) {
-                    skillTools = tools.filter(tool => {
-                        return toolNames.includes(tool.className) || toolNames.includes(tool.name);
-                    });
-                    break;
-                }
-            }
-        }
-        return {
-            name: skillMeta.name,
-            version: skillMeta.version,
-            description: skillMeta.description,
-            context: skillMeta.context,
-            tools: skillTools.map(tool => ({
-                name: tool.name,
-                description: tool.description || "",
-                inputSchema: tool.inputSchema || { type: "object" },
-                execute: compressCode(tool.executeCode || "")
-            }))
-        };
-    });
-    // Match skills from code with skills in YAML and create missing ones
-    const updatedSkillsArray = await ensureSkillsExistInYaml(skillsArray, config);
-    const deployData = {
-        skills: updatedSkillsArray
-    };
-    // Write legacy deploy.json to .lua directory
-    fs.writeFileSync(path.join(luaDir, "deploy.json"), JSON.stringify(deployData, null, 2));
-    // Write individual tool files to .lua directory (uncompressed)
-    for (const tool of tools) {
-        if (tool.executeCode) {
-            const toolFilePath = path.join(luaDir, `${tool.name}.js`);
-            fs.writeFileSync(toolFilePath, tool.executeCode);
-        }
-    }
-}
-function extractSkillsMetadata(indexFile) {
-    const skills = [];
-    // Find all LuaSkill constructor calls
-    indexFile.forEachDescendant((node) => {
-        if (Node.isNewExpression(node)) {
-            const expression = node.getExpression();
-            if (expression.getText() === 'LuaSkill') {
-                const args = node.getArguments();
-                if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
-                    const configObj = args[0];
-                    let skillName = '';
-                    let skillVersion = '';
-                    let description = '';
-                    let context = '';
-                    let constructorTools = [];
-                    // Extract properties
-                    configObj.getProperties().forEach((prop) => {
-                        if (Node.isPropertyAssignment(prop)) {
-                            const name = prop.getName();
-                            const value = prop.getInitializer();
-                            if (name === 'name' && value) {
-                                skillName = value.getText().replace(/['"]/g, '');
-                            }
-                            else if (name === 'version' && value) {
-                                skillVersion = value.getText().replace(/['"]/g, '');
-                            }
-                            else if (name === 'description' && value) {
-                                description = value.getText().replace(/['"]/g, '');
-                            }
-                            else if (name === 'context' && value) {
-                                context = value.getText().replace(/['"]/g, '');
-                            }
-                            else if (name === 'tools' && value && Node.isArrayLiteralExpression(value)) {
-                                // Extract tools from constructor array
-                                const toolsArray = value;
-                                constructorTools = toolsArray.getElements().map((element) => {
-                                    if (Node.isNewExpression(element)) {
-                                        return element.getExpression().getText();
-                                    }
-                                    return '';
-                                }).filter(name => name);
-                            }
-                        }
-                    });
-                    if (skillName) {
-                        skills.push({
-                            name: skillName,
-                            version: skillVersion || '1.0.0',
-                            description,
-                            context,
-                            constructorTools
-                        });
-                    }
-                }
-            }
-        }
-    });
-    return skills;
-}
-async function ensureSkillsExistInYaml(skillsArray, config) {
-    const updatedSkillsArray = [];
-    let yamlUpdated = false;
-    // Get existing skills from YAML
-    const existingSkills = config?.skills || [];
-    const existingSkillsMap = new Map();
-    // Create map of existing skills
-    existingSkills.forEach((skill) => {
-        existingSkillsMap.set(skill.name, skill);
-    });
-    // Process each detected skill
-    for (const skill of skillsArray) {
-        const existingSkill = existingSkillsMap.get(skill.name);
-        if (existingSkill && existingSkill.skillId && existingSkill.skillId !== '') {
-            // Skill exists with valid skillId - use it
-            // console.log(`Using existing skillId for ${skill.name}: ${existingSkill.skillId}`);
-            updatedSkillsArray.push({
-                ...skill,
-                skillId: existingSkill.skillId
-            });
-        }
-        else {
-            // Skill doesn't exist or missing skillId - create it via API
-            // console.log(`Creating new skill: ${skill.name}`);
-            try {
-                // Get API key and agent ID for skill creation
-                const apiKey = await loadApiKey();
-                if (!apiKey) {
-                    throw new Error("No API key found. Run 'lua auth configure' first.");
-                }
-                const agentId = config?.agent?.agentId;
-                if (!agentId) {
-                    throw new Error("No agent ID found in lua.skill.yaml. Run 'lua init' first.");
-                }
-                // Call create skill API
-                console.log(`Calling create skill API for: ${skill.name}`);
-                const skillPayload = {
-                    name: skill.name,
-                    description: skill.description || `A Lua skill for ${skill.name}`,
-                    context: skill.context || ''
-                };
-                const result = await ApiService.Skill.createSkill(apiKey, agentId, skillPayload);
-                // console.log(`Create skill API response:`, result);
-                if (result.success && result.data && result.data.id) {
-                    const newSkillId = result.data.id; // API returns 'id', not 'skillId'
-                    // console.log(`✅ Created skill ${skill.name} with ID: ${newSkillId}`);
-                    updatedSkillsArray.push({
-                        ...skill,
-                        skillId: newSkillId
-                    });
-                    // Update YAML with new skill
-                    if (!existingSkill) {
-                        existingSkills.push({
-                            name: skill.name || '',
-                            version: skill.version || '1.0.0',
-                            skillId: newSkillId
-                        });
-                        yamlUpdated = true;
-                    }
-                    else {
-                        // Update existing skill with new skillId
-                        existingSkill.skillId = newSkillId;
-                        yamlUpdated = true;
-                    }
-                }
-                else {
-                    console.error(`❌ Failed to create skill ${skill.name}:`, result.error);
-                    throw new Error(result.error?.message || 'Failed to create skill - no ID returned from API');
-                }
-            }
-            catch (error) {
-                console.error(`❌ Failed to create skill ${skill.name}:`, error);
-                throw error; // Don't use temp IDs, let the process fail properly
-            }
-        }
-    }
-    // Update YAML file if needed
-    if (yamlUpdated) {
-        await updateYamlWithSkills(existingSkills, config);
-    }
-    return updatedSkillsArray;
-}
-async function updateYamlWithSkills(skills, config) {
-    // Clean skills array to ensure no undefined values
-    const cleanedSkills = skills.map(skill => ({
-        name: skill.name || '',
-        version: skill.version || '1.0.0',
-        skillId: skill.skillId || '' // Ensure skillId is never undefined
-    }));
-    // Update config with cleaned skills array
-    const updatedConfig = {
-        ...config,
-        skills: cleanedSkills
-    };
-    // Write updated YAML
-    const yamlPath = path.join(process.cwd(), 'lua.skill.yaml');
-    const yamlContent = yaml.dump(updatedConfig, {
-        indent: 2,
-        lineWidth: -1,
-        noRefs: true,
-        replacer: (key, value) => {
-            // Replace undefined values with empty strings
-            return value === undefined ? '' : value;
-        }
+/**
+ * Prepares output directories for compilation.
+ * Removes old directories and creates fresh ones for dist and .lua outputs.
+ *
+ * @returns Object containing the dist and lua directory paths
+ */
+function prepareOutputDirectories() {
+    const distDir = path.join(process.cwd(), COMPILE_DIRS.DIST);
+    const luaDir = path.join(process.cwd(), COMPILE_DIRS.LUA);
+    // Clean up old directories
+    if (fs.existsSync(distDir)) {
+        fs.rmSync(distDir, { recursive: true, force: true });
+    }
+    if (fs.existsSync(luaDir)) {
+        fs.rmSync(luaDir, { recursive: true, force: true });
+    }
+    // Create fresh directory structures
+    fs.mkdirSync(distDir, { recursive: true });
+    fs.mkdirSync(path.join(distDir, COMPILE_DIRS.TOOLS), { recursive: true });
+    fs.mkdirSync(luaDir, { recursive: true });
+    return { distDir, luaDir };
+}
+/**
+ * Creates and configures a TypeScript project for AST analysis.
+ *
+ * @returns Configured ts-morph Project instance
+ */
+function createTypeScriptProject() {
+    return new Project({
+        tsConfigFilePath: path.join(process.cwd(), COMPILE_FILES.TSCONFIG_JSON),
     });
-    fs.writeFileSync(yamlPath, yamlContent);
-    console.log('Updated lua.skill.yaml with new skills');
 }