@jterrats/smart-deployment 1.0.3

package/lib/services/metadata-scanner-service.js

@@ -0,0 +1,651 @@
+/**
+ * Metadata Scanner Service
+ * Orchestrates project scanning, parsing, and dependency analysis
+ *
+ * Integrates:
+ * - SfdxProjectDetector
+ * - ForceIgnoreParser
+ * - Metadata parsers (all types)
+ * - DependencyGraphBuilder
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { glob as globAsync } from 'glob';
+import { DependencyGraphBuilder } from '../dependencies/dependency-graph-builder.js';
+import { parseAura } from '../parsers/aura-parser.js';
+import { parseApexClass } from '../parsers/apex-class-parser.js';
+import { parseApexTrigger } from '../parsers/apex-trigger-parser.js';
+import { parseBot } from '../parsers/bot-parser.js';
+import { parseCustomMetadataType } from '../parsers/custom-metadata-parser.js';
+import { parseCustomObject } from '../parsers/custom-object-parser.js';
+import { parseEmailTemplate } from '../parsers/email-template-parser.js';
+import { parseFlexiPage } from '../parsers/flexipage-parser.js';
+import { parseFlow } from '../parsers/flow-parser.js';
+import { parseGenAiPrompt } from '../parsers/genai-prompt-parser.js';
+import { parseLayout } from '../parsers/layout-parser.js';
+import { parseLWC } from '../parsers/lwc-parser.js';
+import { parsePermissionSet } from '../parsers/permission-set-parser.js';
+import { parseProfile } from '../parsers/profile-parser.js';
+import { parseVisualforce } from '../parsers/visualforce-parser.js';
+import { ForceIgnoreParser } from '../scanner/forceignore-parser.js';
+import { SfdxProjectDetector } from '../scanner/sfdx-project-detector.js';
+import { getLogger } from '../utils/logger.js';
+const logger = getLogger('MetadataScannerService');
+function toNodeIds(dependencies, defaultType) {
+    return new Set([...dependencies].map((dependency) => (dependency.includes(':') ? dependency : `${defaultType}:${dependency}`)));
+}
+function isDefined(value) {
+    return value !== undefined;
+}
+/**
+ * Metadata file pattern matcher
+ * TODO: Use when implementing pattern-based metadata detection
+ */
+// interface MetadataPattern {
+//   type: MetadataType;
+//   patterns: string[];
+//   isContainer?: boolean; // For LWC, Aura, CustomObject bundles
+//   parser?: (filePath: string, content: string, metadataXml?: string) => Promise<MetadataComponent> | MetadataComponent;
+// }
+/**
+ * Metadata Scanner Service
+ * Scans project, parses metadata, and builds dependency graph
+ */
+export class MetadataScannerService {
+    forceIgnoreParser;
+    /**
+     * Scan project and analyze dependencies
+     */
+    async scan(options = {}) {
+        const startTime = Date.now();
+        const errors = [];
+        const warnings = [];
+        // Detect project
+        const sourcePath = options.sourcePath ?? process.cwd();
+        const projectInfo = await SfdxProjectDetector.detect(sourcePath);
+        if (!projectInfo.detected) {
+            throw new Error(`SFDX project not found in ${sourcePath}`);
+        }
+        logger.info('Project detected', {
+            root: projectInfo.projectRoot,
+            packageDirs: projectInfo.packageDirectories.length,
+        });
+        // Parse .forceignore
+        const forceIgnorePath = path.join(projectInfo.projectRoot, '.forceignore');
+        if (await this.fileExists(forceIgnorePath)) {
+            this.forceIgnoreParser = new ForceIgnoreParser();
+            const loadResult = await this.forceIgnoreParser.load(projectInfo.projectRoot);
+            logger.info('Loaded .forceignore', {
+                rules: loadResult.totalRules,
+            });
+        }
+        // Scan and parse metadata
+        const components = await this.scanMetadata(projectInfo.projectRoot, projectInfo.packageDirectories, errors, warnings);
+        // Build dependency graph
+        const graphBuilder = new DependencyGraphBuilder();
+        for (const component of components) {
+            graphBuilder.addComponent(component);
+        }
+        const dependencyResult = graphBuilder.build();
+        const executionTime = Date.now() - startTime;
+        logger.info('Scan complete', {
+            components: components.length,
+            dependencies: dependencyResult.stats.totalDependencies,
+            executionTime,
+            errors: errors.length,
+            warnings: warnings.length,
+        });
+        return {
+            components,
+            dependencyResult,
+            projectRoot: projectInfo.projectRoot,
+            executionTime,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Scan metadata files from package directories
+     */
+    async scanMetadata(projectRoot, packageDirs, errors, warnings) {
+        const scannedPackages = await Promise.all(packageDirs.map(async (packageDir) => {
+            const packagePath = path.isAbsolute(packageDir) ? packageDir : path.join(projectRoot, packageDir);
+            if (!(await this.fileExists(packagePath))) {
+                logger.warn('Package directory not found', { packagePath });
+                warnings.push(`Package directory not found: ${packagePath}`);
+                return [];
+            }
+            return this.scanPackageDirectory(packagePath, errors, warnings);
+        }));
+        return scannedPackages.flat();
+    }
+    /**
+     * Scan a package directory for all metadata types
+     */
+    async scanPackageDirectory(packagePath, errors, warnings) {
+        void warnings;
+        const components = [];
+        // Scan Apex Classes
+        const apexFiles = await this.findFiles(packagePath, '**/classes/**/*.cls');
+        const apexComponents = await Promise.all(apexFiles
+            .filter((filePath) => !this.shouldIgnore(filePath) && !filePath.endsWith('.cls-meta.xml'))
+            .map(async (filePath) => {
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                const parsed = parseApexClass(filePath, content);
+                return {
+                    name: parsed.className,
+                    type: 'ApexClass',
+                    filePath,
+                    dependencies: toNodeIds(parsed.dependencies.map((d) => d.className), 'ApexClass'),
+                    dependents: new Set(),
+                    priorityBoost: 0,
+                };
+            }
+            catch (error) {
+                const errorMsg = `Failed to parse Apex class ${filePath}: ${error instanceof Error ? error.message : String(error)}`;
+                logger.warn(errorMsg);
+                errors.push(errorMsg);
+                return undefined;
+            }
+        }));
+        components.push(...apexComponents.filter(isDefined));
+        // Scan Apex Triggers
+        const triggerFiles = await this.findFiles(packagePath, '**/triggers/**/*.trigger');
+        const triggerComponents = await Promise.all(triggerFiles
+            .filter((filePath) => !this.shouldIgnore(filePath) && !filePath.endsWith('.trigger-meta.xml'))
+            .map(async (filePath) => {
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                const parsed = parseApexTrigger(filePath, content);
+                return {
+                    name: parsed.triggerName,
+                    type: 'ApexTrigger',
+                    filePath,
+                    dependencies: toNodeIds(parsed.dependencies.map((d) => d.className), 'ApexClass'),
+                    dependents: new Set(),
+                    priorityBoost: 0,
+                };
+            }
+            catch (error) {
+                const errorMsg = `Failed to parse Apex trigger ${filePath}: ${error instanceof Error ? error.message : String(error)}`;
+                logger.warn(errorMsg);
+                errors.push(errorMsg);
+                return undefined;
+            }
+        }));
+        components.push(...triggerComponents.filter(isDefined));
+        // Scan LWC Components (container-based)
+        const lwcDirs = await this.findDirectories(packagePath, '**/lwc/*');
+        const lwcComponents = await Promise.all(lwcDirs
+            .filter((lwcDir) => !this.shouldIgnore(lwcDir))
+            .map(async (lwcDir) => {
+            const componentName = path.basename(lwcDir);
+            const jsFile = path.join(lwcDir, `${componentName}.js`);
+            const tsFile = path.join(lwcDir, `${componentName}.ts`);
+            const metaFile = path.join(lwcDir, `${componentName}.js-meta.xml`);
+            const jsExists = await this.fileExists(jsFile);
+            const tsExists = jsExists ? false : await this.fileExists(tsFile);
+            const codeFile = jsExists ? jsFile : tsExists ? tsFile : null;
+            if (!codeFile) {
+                return undefined;
+            }
+            try {
+                const jsContent = await fs.readFile(codeFile, 'utf-8');
+                const metaContent = (await this.fileExists(metaFile)) ? await fs.readFile(metaFile, 'utf-8') : undefined;
+                const parsed = parseLWC(componentName, jsContent, metaContent);
+                return {
+                    name: componentName,
+                    type: 'LightningComponentBundle',
+                    filePath: codeFile,
+                    dependencies: new Set([...parsed.apexImports, ...parsed.lwcImports.map((imp) => `c:${imp}`)]),
+                    dependents: new Set(),
+                    priorityBoost: 0,
+                };
+            }
+            catch (error) {
+                const errorMsg = `Failed to parse LWC ${componentName}: ${error instanceof Error ? error.message : String(error)}`;
+                logger.warn(errorMsg);
+                errors.push(errorMsg);
+                return undefined;
+            }
+        }));
+        components.push(...lwcComponents.filter(isDefined));
+        // Scan Aura Components (container-based)
+        const auraDirs = await this.findDirectories(packagePath, '**/aura/*');
+        const auraComponents = await Promise.all(auraDirs
+            .filter((auraDir) => !this.shouldIgnore(auraDir))
+            .map(async (auraDir) => {
+            const componentName = path.basename(auraDir);
+            const cmpFile = path.join(auraDir, `${componentName}.cmp`);
+            if (!(await this.fileExists(cmpFile))) {
+                return undefined;
+            }
+            try {
+                const cmpContent = await fs.readFile(cmpFile, 'utf-8');
+                const parsed = parseAura(componentName, cmpContent);
+                const deps = new Set();
+                if (parsed.apexController)
+                    deps.add(parsed.apexController);
+                if (parsed.extendsComponent)
+                    deps.add(parsed.extendsComponent);
+                parsed.implementsInterfaces.forEach((i) => deps.add(i));
+                parsed.childComponents.forEach((c) => deps.add(`c:${c}`));
+                return {
+                    name: componentName,
+                    type: 'AuraDefinitionBundle',
+                    filePath: cmpFile,
+                    dependencies: deps,
+                    dependents: new Set(),
+                    priorityBoost: 0,
+                };
+            }
+            catch (error) {
+                const errorMsg = `Failed to parse Aura component ${componentName}: ${error instanceof Error ? error.message : String(error)}`;
+                logger.warn(errorMsg);
+                errors.push(errorMsg);
+                return undefined;
+            }
+        }));
+        components.push(...auraComponents.filter(isDefined));
+        // Scan Flows
+        const flowFiles = await this.findFiles(packagePath, '**/flows/**/*.flow-meta.xml');
+        const flowComponents = await Promise.all(flowFiles
+            .filter((filePath) => !this.shouldIgnore(filePath))
+            .map(async (filePath) => {
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                const parsed = parseFlow(filePath, content);
+                const deps = new Set();
+                parsed.dependencies.forEach((d) => {
+                    if (d.type === 'apex_action' || d.type === 'subflow') {
+                        deps.add(d.name);
+                    }
+                });
+                return {
+                    name: parsed.flowName,
+                    type: 'Flow',
+                    filePath,
+                    dependencies: deps,
+                    dependents: new Set(),
+                    priorityBoost: 0,
+                };
+            }
+            catch (error) {
+                const errorMsg = `Failed to parse Flow ${filePath}: ${error instanceof Error ? error.message : String(error)}`;
+                logger.warn(errorMsg);
+                errors.push(errorMsg);
+                return undefined;
+            }
+        }));
+        components.push(...flowComponents.filter(isDefined));
+        // Scan Custom Objects
+        const objectDirs = await this.findDirectories(packagePath, '**/objects/*');
+        const objectComponents = await Promise.all(objectDirs.map(async (objectDir) => {
+            if (this.shouldIgnore(objectDir)) {
+                return undefined;
+            }
+            const objectName = path.basename(objectDir);
+            const objectFile = path.join(objectDir, `${objectName}.object-meta.xml`);
+            if (!(await this.fileExists(objectFile))) {
+                return undefined;
+            }
+            try {
+                const content = await fs.readFile(objectFile, 'utf-8');
+                const parsed = await parseCustomObject(objectName, content);
+                const deps = new Set();
+                parsed.dependencies.forEach((dependency) => {
+                    if ((dependency.type === 'lookup_field' || dependency.type === 'master_detail_field') &&
+                        dependency.referencedObject) {
+                        deps.add(dependency.referencedObject);
+                    }
+                });
+                return {
+                    name: objectName,
+                    type: 'CustomObject',
+                    filePath: objectFile,
+                    dependencies: deps,
+                    dependents: new Set(),
+                    priorityBoost: 0,
+                };
+            }
+            catch (error) {
+                const errorMsg = `Failed to parse Custom Object ${objectName}: ${error instanceof Error ? error.message : String(error)}`;
+                logger.warn(errorMsg);
+                errors.push(errorMsg);
+                return undefined;
+            }
+        }));
+        components.push(...objectComponents.filter(isDefined));
+        // Scan Custom Metadata Types
+        const cmtDirs = await this.findDirectories(packagePath, '**/customMetadata/*');
+        const customMetadataComponents = await Promise.all(cmtDirs.map(async (cmtDir) => {
+            if (this.shouldIgnore(cmtDir)) {
+                return undefined;
+            }
+            const typeName = path.basename(cmtDir);
+            const typeFile = path.join(cmtDir, `${typeName}.md-meta.xml`);
+            if (!(await this.fileExists(typeFile))) {
+                return undefined;
+            }
+            try {
+                const content = await fs.readFile(typeFile, 'utf-8');
+                await parseCustomMetadataType(typeName, content);
+                return {
+                    name: typeName,
+                    type: 'CustomMetadata',
+                    filePath: typeFile,
+                    dependencies: new Set(),
+                    dependents: new Set(),
+                    priorityBoost: 0,
+                };
+            }
+            catch (error) {
+                const errorMsg = `Failed to parse Custom Metadata Type ${typeName}: ${error instanceof Error ? error.message : String(error)}`;
+                logger.warn(errorMsg);
+                errors.push(errorMsg);
+                return undefined;
+            }
+        }));
+        components.push(...customMetadataComponents.filter(isDefined));
+        // Scan Profiles
+        const profileFiles = await this.findFiles(packagePath, '**/profiles/**/*.profile-meta.xml');
+        const profileComponents = await Promise.all(profileFiles.map(async (filePath) => {
+            if (this.shouldIgnore(filePath)) {
+                return undefined;
+            }
+            try {
+                const profileName = path.basename(filePath, '.profile-meta.xml');
+                const parsed = await parseProfile(filePath, profileName);
+                const deps = new Set();
+                parsed.objectPermissions.forEach((permission) => deps.add(permission));
+                parsed.apexClassAccesses.forEach((classAccess) => deps.add(classAccess));
+                parsed.layoutAssignments.forEach((layoutAssignment) => deps.add(layoutAssignment));
+                return {
+                    name: profileName,
+                    type: 'Profile',
+                    filePath,
+                    dependencies: deps,
+                    dependents: new Set(),
+                    priorityBoost: 0,
+                };
+            }
+            catch (error) {
+                const errorMsg = `Failed to parse Profile ${filePath}: ${error instanceof Error ? error.message : String(error)}`;
+                logger.warn(errorMsg);
+                errors.push(errorMsg);
+                return undefined;
+            }
+        }));
+        components.push(...profileComponents.filter(isDefined));
+        // Scan Permission Sets
+        const permSetFiles = await this.findFiles(packagePath, '**/permissionsets/**/*.permissionset-meta.xml');
+        const permissionSetComponents = await Promise.all(permSetFiles.map(async (filePath) => {
+            if (this.shouldIgnore(filePath)) {
+                return undefined;
+            }
+            try {
+                const permSetName = path.basename(filePath, '.permissionset-meta.xml');
+                const parsed = await parsePermissionSet(filePath, permSetName);
+                const deps = new Set();
+                parsed.objectPermissions.forEach((permission) => deps.add(permission));
+                parsed.apexClassAccesses.forEach((classAccess) => deps.add(classAccess));
+                parsed.customPermissions.forEach((customPermission) => deps.add(customPermission));
+                return {
+                    name: permSetName,
+                    type: 'PermissionSet',
+                    filePath,
+                    dependencies: deps,
+                    dependents: new Set(),
+                    priorityBoost: 0,
+                };
+            }
+            catch (error) {
+                const errorMsg = `Failed to parse Permission Set ${filePath}: ${error instanceof Error ? error.message : String(error)}`;
+                logger.warn(errorMsg);
+                errors.push(errorMsg);
+                return undefined;
+            }
+        }));
+        components.push(...permissionSetComponents.filter(isDefined));
+        // Scan FlexiPages
+        const flexipageFiles = await this.findFiles(packagePath, '**/flexipages/**/*.flexipage-meta.xml');
+        const flexipageComponents = await Promise.all(flexipageFiles.map(async (filePath) => {
+            if (this.shouldIgnore(filePath)) {
+                return undefined;
+            }
+            try {
+                const flexipageName = path.basename(filePath, '.flexipage-meta.xml');
+                const parsed = await parseFlexiPage(filePath, flexipageName);
+                const deps = new Set();
+                parsed.lwcComponents.forEach((componentName) => deps.add(`c:${componentName}`));
+                parsed.auraComponents.forEach((componentName) => deps.add(`c:${componentName}`));
+                parsed.objects.forEach((objectName) => deps.add(objectName));
+                return {
+                    name: flexipageName,
+                    type: 'FlexiPage',
+                    filePath,
+                    dependencies: deps,
+                    dependents: new Set(),
+                    priorityBoost: 0,
+                };
+            }
+            catch (error) {
+                const errorMsg = `Failed to parse FlexiPage ${filePath}: ${error instanceof Error ? error.message : String(error)}`;
+                logger.warn(errorMsg);
+                errors.push(errorMsg);
+                return undefined;
+            }
+        }));
+        components.push(...flexipageComponents.filter(isDefined));
+        // Scan Layouts
+        const layoutFiles = await this.findFiles(packagePath, '**/layouts/**/*.layout-meta.xml');
+        const layoutComponents = await Promise.all(layoutFiles.map(async (filePath) => {
+            if (this.shouldIgnore(filePath)) {
+                return undefined;
+            }
+            try {
+                const layoutName = path.basename(filePath, '.layout-meta.xml');
+                const parsed = await parseLayout(filePath, layoutName);
+                const deps = new Set();
+                deps.add(parsed.object);
+                parsed.customButtons.forEach((buttonName) => deps.add(buttonName));
+                parsed.visualforcePages.forEach((pageName) => deps.add(pageName));
+                return {
+                    name: layoutName,
+                    type: 'Layout',
+                    filePath,
+                    dependencies: deps,
+                    dependents: new Set(),
+                    priorityBoost: 0,
+                };
+            }
+            catch (error) {
+                const errorMsg = `Failed to parse Layout ${filePath}: ${error instanceof Error ? error.message : String(error)}`;
+                logger.warn(errorMsg);
+                errors.push(errorMsg);
+                return undefined;
+            }
+        }));
+        components.push(...layoutComponents.filter(isDefined));
+        // Scan Email Templates
+        const emailTemplateFiles = await this.findFiles(packagePath, '**/email/**/*.email-meta.xml');
+        const emailTemplateComponents = await Promise.all(emailTemplateFiles.map(async (filePath) => {
+            if (this.shouldIgnore(filePath)) {
+                return undefined;
+            }
+            try {
+                const templateName = path.basename(filePath, '.email-meta.xml');
+                const content = await fs.readFile(filePath, 'utf-8');
+                const parsed = await parseEmailTemplate(templateName, content, content);
+                const deps = new Set();
+                parsed.dependencies.forEach((dependency) => {
+                    if (dependency.type === 'visualforce_page') {
+                        deps.add(dependency.name);
+                    }
+                });
+                return {
+                    name: templateName,
+                    type: 'EmailTemplate',
+                    filePath,
+                    dependencies: deps,
+                    dependents: new Set(),
+                    priorityBoost: 0,
+                };
+            }
+            catch (error) {
+                const errorMsg = `Failed to parse Email Template ${filePath}: ${error instanceof Error ? error.message : String(error)}`;
+                logger.warn(errorMsg);
+                errors.push(errorMsg);
+                return undefined;
+            }
+        }));
+        components.push(...emailTemplateComponents.filter(isDefined));
+        // Scan Bots
+        const botFiles = await this.findFiles(packagePath, '**/bots/**/*.bot-meta.xml');
+        const botComponents = await Promise.all(botFiles.map(async (filePath) => {
+            if (this.shouldIgnore(filePath)) {
+                return undefined;
+            }
+            try {
+                const botName = path.basename(filePath, '.bot-meta.xml');
+                const parsed = await parseBot(filePath, botName);
+                const deps = new Set();
+                parsed.flows.forEach((flowName) => deps.add(flowName));
+                parsed.apexActions.forEach((actionName) => deps.add(actionName));
+                parsed.genAiPrompts.forEach((promptName) => deps.add(promptName));
+                return {
+                    name: botName,
+                    type: 'Bot',
+                    filePath,
+                    dependencies: deps,
+                    dependents: new Set(),
+                    priorityBoost: 0,
+                };
+            }
+            catch (error) {
+                const errorMsg = `Failed to parse Bot ${filePath}: ${error instanceof Error ? error.message : String(error)}`;
+                logger.warn(errorMsg);
+                errors.push(errorMsg);
+                return undefined;
+            }
+        }));
+        components.push(...botComponents.filter(isDefined));
+        // Scan GenAI Prompts
+        const genaiFiles = await this.findFiles(packagePath, '**/genaiPromptTemplates/**/*.genAiPromptTemplate-meta.xml');
+        const genAiPromptComponents = await Promise.all(genaiFiles.map(async (filePath) => {
+            if (this.shouldIgnore(filePath)) {
+                return undefined;
+            }
+            try {
+                const promptName = path.basename(filePath, '.genAiPromptTemplate-meta.xml');
+                const parsed = await parseGenAiPrompt(filePath, promptName);
+                const deps = new Set();
+                parsed.sobjects.forEach((sObjectName) => deps.add(sObjectName));
+                parsed.dependencies.sobjects.forEach((sObjectName) => deps.add(sObjectName));
+                return {
+                    name: promptName,
+                    type: 'GenAiPromptTemplate',
+                    filePath,
+                    dependencies: deps,
+                    dependents: new Set(),
+                    priorityBoost: 0,
+                };
+            }
+            catch (error) {
+                const errorMsg = `Failed to parse GenAI Prompt ${filePath}: ${error instanceof Error ? error.message : String(error)}`;
+                logger.warn(errorMsg);
+                errors.push(errorMsg);
+                return undefined;
+            }
+        }));
+        components.push(...genAiPromptComponents.filter(isDefined));
+        // Scan Visualforce Pages/Components
+        const vfPageFiles = await this.findFiles(packagePath, '**/pages/**/*.page');
+        const vfComponentFiles = await this.findFiles(packagePath, '**/components/**/*.component');
+        const visualforceComponents = await Promise.all([...vfPageFiles, ...vfComponentFiles].map(async (filePath) => {
+            if (this.shouldIgnore(filePath)) {
+                return undefined;
+            }
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                const fileName = path.basename(filePath);
+                const parsed = parseVisualforce(fileName, content);
+                const deps = new Set();
+                parsed.dependencies.forEach((dependency) => {
+                    if (dependency.type === 'apex_controller' || dependency.type === 'apex_extension') {
+                        deps.add(dependency.name);
+                    }
+                });
+                const componentType = parsed.type === 'page' ? 'VisualforcePage' : 'VisualforceComponent';
+                return {
+                    name: parsed.name,
+                    type: componentType,
+                    filePath,
+                    dependencies: deps,
+                    dependents: new Set(),
+                    priorityBoost: 0,
+                };
+            }
+            catch (error) {
+                const errorMsg = `Failed to parse Visualforce ${filePath}: ${error instanceof Error ? error.message : String(error)}`;
+                logger.warn(errorMsg);
+                errors.push(errorMsg);
+                return undefined;
+            }
+        }));
+        components.push(...visualforceComponents.filter(isDefined));
+        return components;
+    }
+    /**
+     * Find files matching a glob pattern
+     */
+    async findFiles(rootPath, pattern) {
+        const fullPattern = path.join(rootPath, pattern);
+        const files = await globAsync(fullPattern, {
+            ignore: ['**/node_modules/**', '**/.git/**'],
+        });
+        return files;
+    }
+    /**
+     * Find directories matching a glob pattern
+     */
+    async findDirectories(rootPath, pattern) {
+        const fullPattern = path.join(rootPath, pattern);
+        const allMatches = await globAsync(fullPattern, {
+            ignore: ['**/node_modules/**', '**/.git/**'],
+        });
+        const directoryMatches = await Promise.all(allMatches.map(async (match) => {
+            try {
+                const stat = await fs.stat(match);
+                return stat.isDirectory() ? match : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        }));
+        return directoryMatches.filter((match) => match !== undefined);
+    }
+    /**
+     * Check if file should be ignored by .forceignore
+     */
+    shouldIgnore(filePath) {
+        if (!this.forceIgnoreParser) {
+            return false;
+        }
+        return this.forceIgnoreParser.isIgnored(filePath);
+    }
+    /**
+     * Check if file/directory exists
+     */
+    async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=metadata-scanner-service.js.map