@jterrats/smart-deployment 1.0.3 → 1.0.4

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

@@ -8,35 +8,18 @@
  * - 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';
+import { parseBotComponent, parseFlowComponent, parseGenAiPromptComponent, } from './scanners/automation-ai-metadata-scanner.js';
+import { CODE_DIRECTORY_SCANNERS, CODE_FILE_SCANNERS } from './scanners/code-metadata-scanner.js';
+import { parseCustomMetadataComponents, parseCustomObjectComponent } from './scanners/data-metadata-scanner.js';
+import { parseEmailTemplateComponent, parseFlexiPageComponent, parseLayoutComponent, parseVisualforceComponent, } from './scanners/experience-metadata-scanner.js';
+import { fileExists, scanMetadataDirectories, scanMetadataFiles, scanRegisteredDirectoryMetadata, scanRegisteredFileMetadata, } from './scanners/scanner-runtime.js';
+import { parsePermissionSetComponent, parseProfileComponent } from './scanners/security-metadata-scanner.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
@@ -53,6 +36,7 @@ function isDefined(value) {
  */
 export class MetadataScannerService {
     forceIgnoreParser;
+    shouldIgnorePath = (filePath) => this.shouldIgnore(filePath);
     /**
      * Scan project and analyze dependencies
      */
@@ -72,7 +56,7 @@ export class MetadataScannerService {
         });
         // Parse .forceignore
         const forceIgnorePath = path.join(projectInfo.projectRoot, '.forceignore');
-        if (await this.fileExists(forceIgnorePath)) {
+        if (await fileExists(forceIgnorePath)) {
             this.forceIgnoreParser = new ForceIgnoreParser();
             const loadResult = await this.forceIgnoreParser.load(projectInfo.projectRoot);
             logger.info('Loaded .forceignore', {
@@ -110,7 +94,7 @@ export class MetadataScannerService {
     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))) {
+            if (!(await fileExists(packagePath))) {
                 logger.warn('Package directory not found', { packagePath });
                 warnings.push(`Package directory not found: ${packagePath}`);
                 return [];
@@ -124,507 +108,57 @@ export class MetadataScannerService {
      */
     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 componentGroups = await Promise.all([
+            this.scanRegisteredFileMetadata(packagePath, errors),
+            this.scanRegisteredDirectoryMetadata(packagePath, errors),
+            this.scanAutomationMetadata(packagePath, errors),
+            this.scanDataMetadata(packagePath, errors),
+            this.scanSecurityMetadata(packagePath, errors),
+            this.scanExperienceMetadata(packagePath, errors),
+            this.scanAIMetadata(packagePath, errors),
+        ]);
+        return componentGroups.flat();
+    }
+    async scanAutomationMetadata(packagePath, errors) {
+        return scanMetadataFiles(packagePath, '**/flows/**/*.flow-meta.xml', errors, 'Flow', this.shouldIgnorePath, parseFlowComponent);
+    }
+    async scanDataMetadata(packagePath, errors) {
+        const objectComponents = await scanMetadataDirectories(packagePath, '**/objects/*', errors, 'Custom Object', this.shouldIgnorePath, parseCustomObjectComponent);
+        const customMetadataComponents = await scanMetadataDirectories(packagePath, '**/customMetadata/*', errors, 'Custom Metadata Type', this.shouldIgnorePath, async (cmtDir) => {
             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;
+            if (!(await fileExists(typeFile))) {
+                return [];
             }
-        }));
-        components.push(...visualforceComponents.filter(isDefined));
-        return components;
+            return parseCustomMetadataComponents(cmtDir);
+        }, (directoryPath) => path.basename(directoryPath));
+        return [...objectComponents, ...customMetadataComponents];
     }
-    /**
-     * 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;
+    async scanSecurityMetadata(packagePath, errors) {
+        const profileComponents = await scanMetadataFiles(packagePath, '**/profiles/**/*.profile-meta.xml', errors, 'Profile', this.shouldIgnorePath, parseProfileComponent);
+        const permissionSetComponents = await scanMetadataFiles(packagePath, '**/permissionsets/**/*.permissionset-meta.xml', errors, 'Permission Set', this.shouldIgnorePath, parsePermissionSetComponent);
+        return [...profileComponents, ...permissionSetComponents];
     }
-    /**
-     * 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);
+    async scanExperienceMetadata(packagePath, errors) {
+        const flexipageComponents = await scanMetadataFiles(packagePath, '**/flexipages/**/*.flexipage-meta.xml', errors, 'FlexiPage', this.shouldIgnorePath, parseFlexiPageComponent);
+        const layoutComponents = await scanMetadataFiles(packagePath, '**/layouts/**/*.layout-meta.xml', errors, 'Layout', this.shouldIgnorePath, parseLayoutComponent);
+        const emailTemplateComponents = await scanMetadataFiles(packagePath, '**/email/**/*.email-meta.xml', errors, 'Email Template', this.shouldIgnorePath, (filePath) => parseEmailTemplateComponent(filePath, fileExists));
+        const visualforceComponents = await Promise.all([
+            scanMetadataFiles(packagePath, '**/pages/**/*.page', errors, 'Visualforce', this.shouldIgnorePath, parseVisualforceComponent),
+            scanMetadataFiles(packagePath, '**/components/**/*.component', errors, 'Visualforce', this.shouldIgnorePath, parseVisualforceComponent),
+        ]);
+        return [...flexipageComponents, ...layoutComponents, ...emailTemplateComponents, ...visualforceComponents.flat()];
+    }
+    async scanAIMetadata(packagePath, errors) {
+        const botComponents = await scanMetadataFiles(packagePath, '**/bots/**/*.bot-meta.xml', errors, 'Bot', this.shouldIgnorePath, parseBotComponent);
+        const genAiPromptComponents = await scanMetadataFiles(packagePath, '**/genaiPromptTemplates/**/*.genAiPromptTemplate-meta.xml', errors, 'GenAI Prompt', this.shouldIgnorePath, parseGenAiPromptComponent);
+        return [...botComponents, ...genAiPromptComponents];
+    }
+    async scanRegisteredFileMetadata(packagePath, errors) {
+        return scanRegisteredFileMetadata(packagePath, errors, this.shouldIgnorePath, CODE_FILE_SCANNERS);
+    }
+    async scanRegisteredDirectoryMetadata(packagePath, errors) {
+        return scanRegisteredDirectoryMetadata(packagePath, errors, this.shouldIgnorePath, CODE_DIRECTORY_SCANNERS);
     }
     /**
      * Check if file should be ignored by .forceignore
@@ -635,17 +169,5 @@ export class MetadataScannerService {
         }
         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