lua-cli 2.5.8 → 3.0.0-alpha.10

package/dist/utils/compile.js

@@ -115,8 +115,8 @@ export function extractToolFromNewExpressionSync(newExpr, project) {
     try {
         const expression = newExpr.getExpression();
         const className = expression.getText();
-        // Find the import declaration for this class
         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();
@@ -134,43 +134,20 @@ export function extractToolFromNewExpressionSync(newExpr, project) {
                 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);
-                }
+                // 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) {
@@ -178,6 +155,51 @@ export function extractToolFromNewExpressionSync(newExpr, project) {
         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
  */
@@ -240,3 +262,657 @@ export function extractSkillsMetadata(indexFile) {
     });
     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 webhookVersion = '';
+                    let description = '';
+                    let context = '';
+                    // 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 === 'version' && value) {
+                                webhookVersion = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (name === 'description' && value) {
+                                description = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (name === 'context' && value) {
+                                context = value.getText().replace(/['"]/g, '');
+                            }
+                        }
+                    });
+                    if (webhookName) {
+                        webhooks.push({
+                            name: webhookName,
+                            version: webhookVersion || '1.0.0',
+                            description,
+                            context
+                        });
+                    }
+                }
+            }
+        }
+    });
+    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 jobVersion = '';
+                    let description = '';
+                    let context = '';
+                    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 === 'version' && value) {
+                                jobVersion = 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 === '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,
+                            version: jobVersion || '1.0.0',
+                            description,
+                            context,
+                            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 version = '';
+                    let description = '';
+                    let context = '';
+                    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 === 'version' && value) {
+                                version = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (propName === 'description' && value) {
+                                description = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (propName === 'context' && value) {
+                                context = 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,
+                            version: version || '1.0.0',
+                            description,
+                            context,
+                            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 version = '';
+                    let description = '';
+                    let context = '';
+                    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 === 'version' && value) {
+                                version = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (propName === 'description' && value) {
+                                description = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (propName === 'context' && value) {
+                                context = 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,
+                            version: version || '1.0.0',
+                            description,
+                            context,
+                            async: asyncMode
+                        });
+                    }
+                }
+            }
+        }
+    });
+    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 = '';
+                    let welcomeMessage = '';
+                    const skills = [];
+                    const webhooks = [];
+                    const jobs = [];
+                    const preProcessors = [];
+                    const postProcessors = [];
+                    // 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) {
+                                name = value.getText().replace(/['"]/g, '');
+                            }
+                            else if (propName === 'persona' && value) {
+                                // Handle multi-line strings and template literals
+                                const personaText = value.getText();
+                                persona = personaText
+                                    .replace(/^['"`]/, '')
+                                    .replace(/['"`]$/, '')
+                                    .replace(/\\n/g, '\n')
+                                    .trim();
+                            }
+                            else if (propName === 'welcomeMessage' && value) {
+                                welcomeMessage = value.getText().replace(/['"]/g, '');
+                            }
+                            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]);
+                                            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]);
+                                            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]);
+                                            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]);
+                                            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]);
+                                            postProcessors.push(processorConfig);
+                                        }
+                                    }
+                                });
+                            }
+                        }
+                    });
+                    if (name && persona) {
+                        agentMetadata = {
+                            name,
+                            persona,
+                            welcomeMessage: welcomeMessage || undefined,
+                            skills,
+                            webhooks,
+                            jobs,
+                            preProcessors,
+                            postProcessors
+                        };
+                    }
+                }
+            }
+        }
+    });
+    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.
+ */
+function extractConfigFromObjectLiteral(configObj) {
+    const config = {};
+    configObj.getProperties().forEach((prop) => {
+        if (Node.isPropertyAssignment(prop)) {
+            const name = prop.getName();
+            const value = prop.getInitializer();
+            if (value) {
+                config[name] = extractValueFromNode(value);
+            }
+        }
+    });
+    return config;
+}
+/**
+ * Extracts a value from an AST node, handling various types.
+ */
+function extractValueFromNode(node) {
+    if (!node)
+        return undefined;
+    // String literal
+    if (Node.isStringLiteral(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
+    // 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));
+    }
+    // Object literal
+    if (Node.isObjectLiteralExpression(node)) {
+        return extractConfigFromObjectLiteral(node);
+    }
+    // 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]);
+                            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)
+    };
+}
+/**
+ * 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]);
+                                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;
+}