lua-cli 3.5.0-alpha.3 → 3.5.0-beta.1

package/dist/utils/compile.js

@@ -1,1062 +0,0 @@
-/**
- * Utility functions for compile command
- */
-import fs from "fs";
-import path from "path";
-import { gzipSync } from "zlib";
-import { Node } from "ts-morph";
-/**
- * Compresses code using gzip and returns base64 encoded string
- */
-export function compressCode(code) {
-    const compressed = gzipSync(code);
-    return compressed.toString('base64');
-}
-/**
- * Finds the index.ts file in the project
- */
-export 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");
-}
-/**
- * Resolves TypeScript path aliases from tsconfig.json (e.g., @/ -> ./src/)
- * @returns Object with baseUrl and paths mappings, or null if not found
- */
-function getTsConfigPathMappings() {
-    const tsconfigPath = path.join(process.cwd(), 'tsconfig.json');
-    if (!fs.existsSync(tsconfigPath)) {
-        return null;
-    }
-    try {
-        const tsconfigContent = fs.readFileSync(tsconfigPath, 'utf-8');
-        const tsconfig = JSON.parse(tsconfigContent);
-        const compilerOptions = tsconfig.compilerOptions || {};
-        if (compilerOptions.paths) {
-            return {
-                baseUrl: compilerOptions.baseUrl || '.',
-                paths: compilerOptions.paths
-            };
-        }
-    }
-    catch {
-        // Ignore parsing errors
-    }
-    return null;
-}
-/**
- * Resolves a path alias to a relative path using tsconfig.json mappings
- * @param specifier - The import specifier (e.g., '@/src/skills/numida.skill')
- * @returns Resolved path or null if no alias matched
- */
-function resolvePathAlias(specifier) {
-    const mappings = getTsConfigPathMappings();
-    if (!mappings)
-        return null;
-    // Sort patterns by specificity (longest first) to match TypeScript's behavior
-    // e.g., "@/tools/*" should match before "@/*"
-    const sortedPatterns = Object.entries(mappings.paths).sort(([a], [b]) => b.length - a.length);
-    for (const [pattern, targets] of sortedPatterns) {
-        // Convert TypeScript path pattern to regex (e.g., "@/*" -> /^@\/(.*)$/)
-        const patternRegex = new RegExp('^' + pattern.replace(/\*/g, '(.*)').replace(/\//g, '\\/') + '$');
-        const match = specifier.match(patternRegex);
-        if (match) {
-            // Get the captured wildcard portion
-            const captured = match[1] || '';
-            // Use first target path and substitute the wildcard
-            const targetPath = targets[0].replace('*', captured);
-            // Resolve relative to baseUrl (which is relative to tsconfig location)
-            const resolvedPath = path.join(process.cwd(), mappings.baseUrl, targetPath);
-            return resolvedPath;
-        }
-    }
-    return null;
-}
-/**
- * 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).
- * Also handles TypeScript path aliases configured in tsconfig.json (e.g., @/, ~/).
- * @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'];
-    // 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);
-    }
-    // Try to resolve path aliases first (e.g., @/src/skills/numida.skill)
-    const aliasResolved = resolvePathAlias(normalizedSpecifier);
-    if (aliasResolved) {
-        // Try each extension for the alias-resolved path
-        for (const ext of extensions) {
-            const fullPath = ext.startsWith('/') ? path.join(aliasResolved, ext) : aliasResolved + ext;
-            if (fs.existsSync(fullPath)) {
-                return fullPath;
-            }
-        }
-        // Fallback: return .ts extension
-        return aliasResolved + '.ts';
-    }
-    if (normalizedSpecifier.startsWith('./') || normalizedSpecifier.startsWith('../')) {
-        // Relative import - resolve relative to current file
-        const currentDir = path.dirname(currentFilePath);
-        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;
-            if (fs.existsSync(fullPath)) {
-                return fullPath;
-            }
-        }
-        // Fallback: return .ts extension (original behavior)
-        return basePath + '.ts';
-    }
-    else {
-        // Absolute import - check in src/ directory
-        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)) {
-                return fullPath;
-            }
-        }
-        // Fallback: return .ts in src/ (original behavior)
-        return path.resolve(process.cwd(), 'src', normalizedSpecifier + '.ts');
-    }
-}
-/**
- * Evaluates Zod schema code and converts it to JSON Schema
- */
-export 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' };
-    }
-}
-/**
- * Wraps raw bundled tool code for execute function
- */
-export function wrapExecuteForVM(bundledCode, className) {
-    return `async (input) => {
-  ${bundledCode}
-  
-  const ToolClass = module.exports.default || module.exports.${className} || module.exports;
-  const toolInstance = new ToolClass();
-  return await toolInstance.execute(input);
-}`;
-}
-/**
- * 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
- */
-export function extractToolFromNewExpressionSync(newExpr, project) {
-    try {
-        const expression = newExpr.getExpression();
-        const className = expression.getText();
-        const sourceFile = newExpr.getSourceFile();
-        // Strategy 1: Try to find the tool via imports (separate file)
-        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 separate file
-                const toolInfo = extractToolMetadataFromFile(toolFilePath, className, project);
-                if (toolInfo)
-                    return toolInfo;
-            }
-        }
-        // Strategy 2: Check if tool is defined inline in the same file
-        const classDecl = sourceFile.getClass(className);
-        if (classDecl) {
-            // Tool is defined inline - extract metadata directly
-            const toolInfo = extractToolMetadataFromClass(classDecl, className, sourceFile.getFilePath());
-            if (toolInfo)
-                return toolInfo;
-        }
-        return null;
-    }
-    catch (error) {
-        console.warn(`Warning: Could not extract tool info for ${newExpr.getText()}:`, error);
-        return null;
-    }
-}
-/**
- * Extracts tool metadata from a separate tool file.
- */
-function extractToolMetadataFromFile(toolFilePath, className, project) {
-    try {
-        const toolSourceFile = project.addSourceFileAtPath(toolFilePath);
-        const classDecl = toolSourceFile.getClass(className);
-        if (classDecl) {
-            return extractToolMetadataFromClass(classDecl, className, toolFilePath);
-        }
-    }
-    catch (fileError) {
-        console.warn(`Warning: Could not load tool file ${toolFilePath}:`, fileError);
-    }
-    return null;
-}
-/**
- * Extracts tool metadata from a class declaration (works for both inline and separate files).
- */
-function extractToolMetadataFromClass(classDecl, className, filePath) {
-    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, '');
-        }
-    }
-    return {
-        name: toolName,
-        className,
-        filePath,
-        description
-    };
-}
-/**
- * Extracts skills metadata from index file
- */
-export 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 description = '';
-                    let context = '';
-                    let tools = [];
-                    // 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 === '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;
-                                tools = toolsArray.getElements().map((element) => {
-                                    if (Node.isNewExpression(element)) {
-                                        return element.getExpression().getText();
-                                    }
-                                    return '';
-                                }).filter(name => name);
-                            }
-                        }
-                    });
-                    if (skillName) {
-                        skills.push({
-                            name: skillName,
-                            description,
-                            context,
-                            tools
-                        });
-                    }
-                }
-            }
-        }
-    });
-    return skills;
-}
-/**
- * Extracts webhooks metadata from index file
- */
-export function extractWebhooksMetadata(indexFile) {
-    const webhooks = [];
-    // Find all LuaWebhook constructor calls
-    indexFile.forEachDescendant((node) => {
-        if (Node.isNewExpression(node)) {
-            const expression = node.getExpression();
-            if (expression.getText() === 'LuaWebhook') {
-                const args = node.getArguments();
-                if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
-                    const configObj = args[0];
-                    let webhookName = '';
-                    let description = '';
-                    // Extract properties
-                    configObj.getProperties().forEach((prop) => {
-                        if (Node.isPropertyAssignment(prop)) {
-                            const name = prop.getName();
-                            const value = prop.getInitializer();
-                            if (name === 'name' && value) {
-                                webhookName = value.getText().replace(/['"]/g, '');
-                            }
-                            else if (name === 'description' && value) {
-                                description = value.getText().replace(/['"]/g, '');
-                            }
-                        }
-                    });
-                    if (webhookName) {
-                        webhooks.push({
-                            name: webhookName,
-                            description
-                        });
-                    }
-                }
-            }
-        }
-    });
-    return webhooks;
-}
-/**
- * Extracts jobs metadata from index file
- */
-export function extractJobsMetadata(indexFile) {
-    const jobs = [];
-    // Find all LuaJob constructor calls
-    indexFile.forEachDescendant((node) => {
-        if (Node.isNewExpression(node)) {
-            const expression = node.getExpression();
-            if (expression.getText() === 'LuaJob') {
-                const args = node.getArguments();
-                if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
-                    const configObj = args[0];
-                    let jobName = '';
-                    let description = '';
-                    let schedule = null;
-                    let timeout;
-                    let retry = undefined;
-                    let metadata = undefined;
-                    // Extract properties
-                    configObj.getProperties().forEach((prop) => {
-                        if (Node.isPropertyAssignment(prop)) {
-                            const name = prop.getName();
-                            const value = prop.getInitializer();
-                            if (name === 'name' && value) {
-                                jobName = value.getText().replace(/['"]/g, '');
-                            }
-                            else if (name === 'description' && value) {
-                                description = value.getText().replace(/['"]/g, '');
-                            }
-                            else if (name === 'schedule' && value) {
-                                // Extract schedule configuration
-                                try {
-                                    const scheduleText = value.getText();
-                                    // Try to evaluate the schedule object
-                                    schedule = eval(`(${scheduleText})`);
-                                }
-                                catch (error) {
-                                    console.warn('Warning: Could not parse schedule:', error);
-                                    schedule = { type: 'unknown' };
-                                }
-                            }
-                            else if (name === 'timeout' && value) {
-                                const timeoutText = value.getText();
-                                timeout = parseInt(timeoutText, 10);
-                            }
-                            else if (name === 'retry' && value) {
-                                // Extract retry configuration
-                                try {
-                                    const retryText = value.getText();
-                                    retry = eval(`(${retryText})`);
-                                }
-                                catch (error) {
-                                    console.warn('Warning: Could not parse retry config:', error);
-                                }
-                            }
-                            else if (name === 'metadata' && value) {
-                                // Extract metadata
-                                try {
-                                    const metadataText = value.getText();
-                                    metadata = eval(`(${metadataText})`);
-                                }
-                                catch (error) {
-                                    console.warn('Warning: Could not parse metadata:', error);
-                                }
-                            }
-                        }
-                    });
-                    if (jobName) {
-                        jobs.push({
-                            name: jobName,
-                            description,
-                            schedule,
-                            timeout,
-                            retry,
-                            metadata
-                        });
-                    }
-                }
-            }
-        }
-    });
-    return jobs;
-}
-/**
- * Extracts preprocessors metadata from index file
- */
-export function extractPreProcessorsMetadata(indexFile) {
-    const preprocessors = [];
-    // Find all PreProcessor constructor calls
-    indexFile.forEachDescendant((node) => {
-        if (Node.isNewExpression(node)) {
-            const expression = node.getExpression();
-            if (expression.getText() === 'PreProcessor') {
-                const args = node.getArguments();
-                if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
-                    const configObj = args[0];
-                    let name = '';
-                    let description = '';
-                    let asyncMode = false;
-                    configObj.getProperties().forEach((prop) => {
-                        if (Node.isPropertyAssignment(prop)) {
-                            const propName = prop.getName();
-                            const value = prop.getInitializer();
-                            if (propName === 'name' && value) {
-                                name = value.getText().replace(/['"]/g, '');
-                            }
-                            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) {
-                        preprocessors.push({
-                            name,
-                            description,
-                            async: asyncMode
-                        });
-                    }
-                }
-            }
-        }
-    });
-    return preprocessors;
-}
-/**
- * Extracts postprocessors metadata from index file
- */
-export function extractPostProcessorsMetadata(indexFile) {
-    const postprocessors = [];
-    // Find all PostProcessor constructor calls
-    indexFile.forEachDescendant((node) => {
-        if (Node.isNewExpression(node)) {
-            const expression = node.getExpression();
-            if (expression.getText() === 'PostProcessor') {
-                const args = node.getArguments();
-                if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
-                    const configObj = args[0];
-                    let name = '';
-                    let description = '';
-                    configObj.getProperties().forEach((prop) => {
-                        if (Node.isPropertyAssignment(prop)) {
-                            const propName = prop.getName();
-                            const value = prop.getInitializer();
-                            if (propName === 'name' && value) {
-                                name = value.getText().replace(/['"]/g, '');
-                            }
-                            else if (propName === 'description' && value) {
-                                description = value.getText().replace(/['"]/g, '');
-                            }
-                        }
-                    });
-                    if (name) {
-                        postprocessors.push({
-                            name,
-                            description
-                        });
-                    }
-                }
-            }
-        }
-    });
-    return postprocessors;
-}
-/**
- * Extracts LuaAgent metadata from index file.
- * Returns the unified agent configuration if found, otherwise null.
- * This function looks for either:
- * - A LuaAgent constructor call: new LuaAgent({ ... })
- * - A variable assigned to LuaAgent: const agent = new LuaAgent({ ... })
- */
-export function extractLuaAgentMetadata(indexFile) {
-    let agentMetadata = null;
-    // Find LuaAgent constructor calls
-    indexFile.forEachDescendant((node) => {
-        if (Node.isNewExpression(node)) {
-            const expression = node.getExpression();
-            if (expression.getText() === 'LuaAgent') {
-                const args = node.getArguments();
-                if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
-                    const configObj = args[0];
-                    let name = '';
-                    let persona = '';
-                    const skills = [];
-                    const webhooks = [];
-                    const jobs = [];
-                    const preProcessors = [];
-                    const postProcessors = [];
-                    const mcpServers = [];
-                    // Extract properties from LuaAgent config
-                    configObj.getProperties().forEach((prop) => {
-                        if (Node.isPropertyAssignment(prop)) {
-                            const propName = prop.getName();
-                            const value = prop.getInitializer();
-                            if (propName === 'name' && value) {
-                                // Use getLiteralValue for proper string extraction
-                                if (Node.isStringLiteral(value) || Node.isNoSubstitutionTemplateLiteral(value)) {
-                                    name = value.getLiteralValue();
-                                }
-                                else if (Node.isIdentifier(value)) {
-                                    // Handle variable reference - resolve to find the actual value
-                                    const resolved = resolveIdentifierValue(indexFile, value.getText());
-                                    if (resolved) {
-                                        name = resolved;
-                                    }
-                                }
-                            }
-                            else if (propName === 'persona' && value) {
-                                // Use getLiteralValue to get actual string value (handles escapes correctly)
-                                if (Node.isStringLiteral(value) || Node.isNoSubstitutionTemplateLiteral(value)) {
-                                    persona = value.getLiteralValue().trim();
-                                }
-                                else if (Node.isIdentifier(value)) {
-                                    // Handle variable reference - resolve to find the actual value
-                                    const resolved = resolveIdentifierValue(indexFile, value.getText());
-                                    if (resolved) {
-                                        persona = resolved.trim();
-                                    }
-                                }
-                            }
-                            else if (propName === 'skills' && value && Node.isArrayLiteralExpression(value)) {
-                                // Extract skill references from the array
-                                value.getElements().forEach((element) => {
-                                    // Skills can be variable references or inline new LuaSkill()
-                                    if (Node.isIdentifier(element)) {
-                                        skills.push({ ref: element.getText() });
-                                    }
-                                    else if (Node.isNewExpression(element)) {
-                                        // Extract inline skill metadata
-                                        const skillArgs = element.getArguments();
-                                        if (skillArgs.length > 0 && Node.isObjectLiteralExpression(skillArgs[0])) {
-                                            const skillConfig = extractConfigFromObjectLiteral(skillArgs[0], indexFile);
-                                            skills.push(skillConfig);
-                                        }
-                                    }
-                                });
-                            }
-                            else if (propName === 'webhooks' && value && Node.isArrayLiteralExpression(value)) {
-                                value.getElements().forEach((element) => {
-                                    if (Node.isIdentifier(element)) {
-                                        webhooks.push({ ref: element.getText() });
-                                    }
-                                    else if (Node.isNewExpression(element)) {
-                                        const webhookArgs = element.getArguments();
-                                        if (webhookArgs.length > 0 && Node.isObjectLiteralExpression(webhookArgs[0])) {
-                                            const webhookConfig = extractConfigFromObjectLiteral(webhookArgs[0], indexFile);
-                                            webhooks.push(webhookConfig);
-                                        }
-                                    }
-                                });
-                            }
-                            else if (propName === 'jobs' && value && Node.isArrayLiteralExpression(value)) {
-                                value.getElements().forEach((element) => {
-                                    if (Node.isIdentifier(element)) {
-                                        jobs.push({ ref: element.getText() });
-                                    }
-                                    else if (Node.isNewExpression(element)) {
-                                        const jobArgs = element.getArguments();
-                                        if (jobArgs.length > 0 && Node.isObjectLiteralExpression(jobArgs[0])) {
-                                            const jobConfig = extractConfigFromObjectLiteral(jobArgs[0], indexFile);
-                                            jobs.push(jobConfig);
-                                        }
-                                    }
-                                });
-                            }
-                            else if (propName === 'preProcessors' && value && Node.isArrayLiteralExpression(value)) {
-                                value.getElements().forEach((element) => {
-                                    if (Node.isIdentifier(element)) {
-                                        preProcessors.push({ ref: element.getText() });
-                                    }
-                                    else if (Node.isNewExpression(element)) {
-                                        const processorArgs = element.getArguments();
-                                        if (processorArgs.length > 0 && Node.isObjectLiteralExpression(processorArgs[0])) {
-                                            const processorConfig = extractConfigFromObjectLiteral(processorArgs[0], indexFile);
-                                            preProcessors.push(processorConfig);
-                                        }
-                                    }
-                                });
-                            }
-                            else if (propName === 'postProcessors' && value && Node.isArrayLiteralExpression(value)) {
-                                value.getElements().forEach((element) => {
-                                    if (Node.isIdentifier(element)) {
-                                        postProcessors.push({ ref: element.getText() });
-                                    }
-                                    else if (Node.isNewExpression(element)) {
-                                        const processorArgs = element.getArguments();
-                                        if (processorArgs.length > 0 && Node.isObjectLiteralExpression(processorArgs[0])) {
-                                            const processorConfig = extractConfigFromObjectLiteral(processorArgs[0], indexFile);
-                                            postProcessors.push(processorConfig);
-                                        }
-                                    }
-                                });
-                            }
-                            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], indexFile);
-                                            mcpServers.push(mcpConfig);
-                                        }
-                                    }
-                                });
-                            }
-                        }
-                    });
-                    // Return metadata if we found at least a name or persona
-                    // (previously required both, but that broke variable reference detection)
-                    if (name || persona) {
-                        agentMetadata = {
-                            name,
-                            persona,
-                            skills,
-                            webhooks,
-                            jobs,
-                            preProcessors,
-                            postProcessors,
-                            mcpServers
-                        };
-                    }
-                }
-            }
-        }
-    });
-    return agentMetadata;
-}
-/**
- * Helper function to extract configuration from an object literal expression.
- * Used by extractLuaAgentMetadata to parse inline skill/webhook/job definitions.
- * Handles nested objects, arrays, and various data types.
- *
- * @param configObj - The object literal expression to extract from
- * @param sourceFile - Optional source file for resolving variable references
- */
-function extractConfigFromObjectLiteral(configObj, sourceFile) {
-    const config = {};
-    configObj.getProperties().forEach((prop) => {
-        if (Node.isPropertyAssignment(prop)) {
-            const name = prop.getName();
-            const value = prop.getInitializer();
-            if (value) {
-                config[name] = extractValueFromNode(value, sourceFile);
-            }
-        }
-    });
-    return config;
-}
-/**
- * Extracts a value from an AST node, handling various types.
- *
- * @param node - The AST node to extract value from
- * @param sourceFile - Optional source file for resolving variable references
- */
-function extractValueFromNode(node, sourceFile) {
-    if (!node)
-        return undefined;
-    // String literal
-    if (Node.isStringLiteral(node)) {
-        return node.getLiteralValue();
-    }
-    // Template literal without substitutions
-    if (Node.isNoSubstitutionTemplateLiteral(node)) {
-        return node.getLiteralValue();
-    }
-    // Numeric literal
-    if (Node.isNumericLiteral(node)) {
-        return node.getLiteralValue();
-    }
-    // Boolean literal (TrueKeyword = 110, FalseKeyword = 95)
-    const nodeKind = node.getKind();
-    if (nodeKind === 110)
-        return true; // TrueKeyword
-    if (nodeKind === 95)
-        return false; // FalseKeyword
-    // Identifier (variable reference) - resolve to actual value if sourceFile provided
-    if (Node.isIdentifier(node) && sourceFile) {
-        const resolved = resolveIdentifierValue(sourceFile, node.getText());
-        if (resolved !== null) {
-            return resolved;
-        }
-        // If we can't resolve it, return the identifier name as-is (might be a class reference)
-        return node.getText();
-    }
-    // New expression (for tools: [new ToolClass()])
-    // Extract just the class name for compatibility with buildSkillsArray
-    if (Node.isNewExpression(node)) {
-        const expression = node.getExpression();
-        return expression.getText(); // Returns class name like "GetWeatherTool"
-    }
-    // Array literal
-    if (Node.isArrayLiteralExpression(node)) {
-        return node.getElements().map((element) => extractValueFromNode(element, sourceFile));
-    }
-    // Object literal
-    if (Node.isObjectLiteralExpression(node)) {
-        return extractConfigFromObjectLiteral(node, sourceFile);
-    }
-    // Arrow function or function expression (for execute, etc.)
-    if (Node.isArrowFunction(node) || Node.isFunctionExpression(node)) {
-        return node.getText(); // Return the function as a string
-    }
-    // Template literal or other complex expressions
-    // For persona, context, etc. that might be multiline
-    const text = node.getText();
-    // Handle boolean strings (fallback if node kind check didn't catch it)
-    if (text === 'true')
-        return true;
-    if (text === 'false')
-        return false;
-    // If it starts with a quote, remove quotes
-    if ((text.startsWith('"') && text.endsWith('"')) ||
-        (text.startsWith("'") && text.endsWith("'")) ||
-        (text.startsWith('`') && text.endsWith('`'))) {
-        return text.slice(1, -1).replace(/\\n/g, '\n');
-    }
-    return text;
-}
-/**
- * Gets the file paths where skills are defined in a LuaAgent.
- * This is used to scan those files for tools.
- * Returns deduplicated file paths.
- *
- * @param agentMetadata - Agent metadata from extractLuaAgentMetadata
- * @param indexFile - The index source file
- * @returns Array of unique file paths where skills are defined
- */
-export function getSkillFilePaths(agentMetadata, indexFile) {
-    const filePathsSet = new Set();
-    const imports = indexFile.getImportDeclarations();
-    for (const skill of agentMetadata.skills) {
-        if (skill.ref) {
-            // Find where this skill is imported from
-            for (const importDecl of imports) {
-                const namedImports = importDecl.getNamedImports();
-                const defaultImport = importDecl.getDefaultImport();
-                let isMatch = false;
-                // Check named imports
-                for (const namedImport of namedImports) {
-                    if (namedImport.getName() === skill.ref) {
-                        isMatch = true;
-                        break;
-                    }
-                }
-                // Check default import
-                if (!isMatch && defaultImport && defaultImport.getText() === skill.ref) {
-                    isMatch = true;
-                }
-                if (isMatch) {
-                    const moduleSpecifier = importDecl.getModuleSpecifierValue();
-                    const importPath = resolveImportPath(moduleSpecifier, indexFile.getFilePath());
-                    if (fs.existsSync(importPath)) {
-                        filePathsSet.add(importPath); // Use Set to avoid duplicates
-                    }
-                    break;
-                }
-            }
-        }
-    }
-    return Array.from(filePathsSet);
-}
-/**
- * Resolves references in LuaAgent metadata to actual definitions.
- * When a LuaAgent contains references like `skills: [userSkill]`, this function
- * finds where `userSkill` is defined and extracts its metadata.
- */
-export function resolveLuaAgentReferences(agentMetadata, indexFile, project) {
-    const resolveArrayReferences = (items, extractFunction) => {
-        const resolved = [];
-        for (const item of items) {
-            if (item.ref) {
-                // This is a reference, need to resolve it
-                const varName = item.ref;
-                // Find the variable declaration in the index file
-                const varDecl = findVariableDeclaration(indexFile, varName);
-                if (varDecl) {
-                    // If it's a new expression, extract metadata
-                    const initializer = varDecl.getInitializer();
-                    if (initializer && Node.isNewExpression(initializer)) {
-                        const expression = initializer.getExpression();
-                        const args = initializer.getArguments();
-                        if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
-                            const config = extractConfigFromObjectLiteral(args[0], indexFile);
-                            resolved.push(config);
-                        }
-                    }
-                }
-                else {
-                    // Check if it's imported from another file
-                    const importedMetadata = findImportedDefinition(indexFile, varName, project, extractFunction);
-                    if (importedMetadata) {
-                        resolved.push(...importedMetadata);
-                    }
-                }
-            }
-            else {
-                // Not a reference, already has metadata
-                resolved.push(item);
-            }
-        }
-        return resolved;
-    };
-    return {
-        skills: resolveArrayReferences(agentMetadata.skills, extractSkillsMetadata),
-        webhooks: resolveArrayReferences(agentMetadata.webhooks, extractWebhooksMetadata),
-        jobs: resolveArrayReferences(agentMetadata.jobs, extractJobsMetadata),
-        preProcessors: resolveArrayReferences(agentMetadata.preProcessors, extractPreProcessorsMetadata),
-        postProcessors: resolveArrayReferences(agentMetadata.postProcessors, extractPostProcessorsMetadata),
-        mcpServers: resolveArrayReferences(agentMetadata.mcpServers, extractMCPServersMetadata)
-    };
-}
-/**
- * Extracts MCP server metadata from a source file.
- * Looks for LuaMCPServer constructor calls.
- *
- * Note: Function-based resolvers for env, headers, and url are detected
- * during extraction but bundled separately in compile.ts using esbuild
- * for proper TypeScript transpilation.
- */
-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], sourceFile);
-                    // Return raw config - resolver bundling is done in compile.ts
-                    mcpServers.push(config);
-                }
-            }
-        }
-    });
-    return mcpServers;
-}
-/**
- * Resolves an identifier (variable name) to its string value.
- * Used when name or persona are defined as variables rather than inline literals.
- *
- * @param sourceFile - The source file containing the identifier
- * @param identifierName - The name of the variable to resolve
- * @returns The string value if found, null otherwise
- */
-function resolveIdentifierValue(sourceFile, identifierName) {
-    // Find the variable declaration
-    const varDecl = findVariableDeclaration(sourceFile, identifierName);
-    if (!varDecl) {
-        return null;
-    }
-    const initializer = varDecl.getInitializer();
-    if (!initializer) {
-        return null;
-    }
-    // Check if it's a string literal or template literal
-    if (Node.isStringLiteral(initializer) || Node.isNoSubstitutionTemplateLiteral(initializer)) {
-        return initializer.getLiteralValue();
-    }
-    // For template literals with substitutions, get the text and clean it up
-    if (Node.isTemplateExpression(initializer)) {
-        // This is a complex template with ${} substitutions - get raw text
-        const text = initializer.getText();
-        // Remove the backticks
-        return text.slice(1, -1);
-    }
-    return null;
-}
-/**
- * Finds a variable declaration in a source file by name.
- */
-function findVariableDeclaration(sourceFile, varName) {
-    const declarations = sourceFile.getVariableDeclarations();
-    for (const decl of declarations) {
-        if (decl.getName() === varName) {
-            return decl;
-        }
-    }
-    return null;
-}
-/**
- * Finds an imported definition and extracts its metadata.
- * This directly extracts the config from the variable declaration in the imported file.
- * Handles both named imports and default imports.
- */
-function findImportedDefinition(sourceFile, varName, project, extractFunction) {
-    const imports = sourceFile.getImportDeclarations();
-    for (const importDecl of imports) {
-        let isMatch = false;
-        // Check named imports: import { varName } from '...'
-        const namedImports = importDecl.getNamedImports();
-        for (const namedImport of namedImports) {
-            if (namedImport.getName() === varName) {
-                isMatch = true;
-                break;
-            }
-        }
-        // Check default import: import varName from '...'
-        if (!isMatch) {
-            const defaultImport = importDecl.getDefaultImport();
-            if (defaultImport && defaultImport.getText() === varName) {
-                isMatch = true;
-            }
-        }
-        if (isMatch) {
-            // Found the import, resolve the file
-            const moduleSpecifier = importDecl.getModuleSpecifierValue();
-            const importPath = resolveImportPath(moduleSpecifier, sourceFile.getFilePath());
-            if (fs.existsSync(importPath)) {
-                try {
-                    const importedFile = project.addSourceFileAtPath(importPath);
-                    // Strategy 1: Look for a variable declaration with the same name
-                    let varDecl = importedFile.getVariableDeclaration(varName);
-                    // Strategy 2: If it's a default import, look for default export
-                    if (!varDecl) {
-                        // Find any variable declaration with default export
-                        const allVarDecls = importedFile.getVariableDeclarations();
-                        for (const decl of allVarDecls) {
-                            // Check if this is exported as default
-                            const statement = decl.getVariableStatement();
-                            if (statement && statement.hasDefaultKeyword()) {
-                                varDecl = decl;
-                                break;
-                            }
-                        }
-                        // If still not found, just take the first variable declaration
-                        if (!varDecl && allVarDecls.length > 0) {
-                            varDecl = allVarDecls[0];
-                        }
-                    }
-                    if (varDecl) {
-                        const initializer = varDecl.getInitializer();
-                        // Check if it's a new expression (new LuaSkill, new LuaJob, etc.)
-                        if (initializer && Node.isNewExpression(initializer)) {
-                            const args = initializer.getArguments();
-                            if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
-                                // Extract configuration from the object literal
-                                const config = extractConfigFromObjectLiteral(args[0], importedFile);
-                                return [config];
-                            }
-                        }
-                    }
-                    // Fallback: use the extract function to scan the whole file
-                    const metadata = extractFunction(importedFile);
-                    if (metadata.length > 0) {
-                        // Try to find a match by name
-                        const matchingItem = metadata.find((item) => {
-                            return item.name && item.name.toLowerCase().includes(varName.toLowerCase().replace('skill', '').replace('job', '').replace('webhook', ''));
-                        });
-                        if (matchingItem) {
-                            return [matchingItem];
-                        }
-                        // Return first item as fallback
-                        return [metadata[0]];
-                    }
-                }
-                catch (error) {
-                    console.warn(`Warning: Could not resolve import ${varName} from ${importPath}:`, error);
-                }
-            }
-        }
-    }
-    return null;
-}
-//# sourceMappingURL=compile.js.map