x-fidelity 3.9.1 → 3.11.0

package/.github/CODEOWNERS

@@ -0,0 +1,15 @@
+# Default owners for everything in the repo
+* @zotoio/core-team
+
+# Specific ownership rules
+/src/core/ @zotoio/core-team
+/src/facts/ @zotoio/rules-team
+/src/operators/ @zotoio/rules-team
+/src/plugins/ @zotoio/plugin-team
+/src/server/ @zotoio/api-team
+/src/types/ @zotoio/core-team
+/src/utils/ @zotoio/core-team
+/website/ @zotoio/docs-team
+
+# Notification test team
+/src/notifications/ @zotoio/notification-team

package/.xfi-config.json

@@ -34,5 +34,27 @@
     ],
     "additionalFacts": ["customFact"],
     "additionalOperators": ["customOperator"],
-    "additionalPlugins": ["xfiPluginSimpleExample"]
+    "additionalPlugins": ["xfiPluginSimpleExample"],
+    "notifications": {
+        "recipients": {
+            "email": [
+                "io@zoto.io"
+            ],
+            "slack": [
+                "U123456",
+                "U789012"
+            ],
+            "teams": [
+                "user1@example.com",
+                "user2@example.com"
+            ]
+        },
+        "codeOwners": true,
+        "notifyOnSuccess": false,
+        "notifyOnFailure": true,
+        "customTemplates": {
+            "success": "# Success! 🎉\n\nYour codebase passed all X-Fidelity checks.\n\n- Archetype: ${archetype}\n- Files analyzed: ${fileCount}\n- Execution time: ${executionTime} seconds\n\nGreat job keeping the code clean!",
+            "failure": "# Issues Detected ⚠️\n\nX-Fidelity found issues in your codebase:\n\n- Archetype: ${archetype}\n- Files analyzed: ${fileCount}\n- Total issues: ${totalIssues}\n  - Warnings: ${warningCount}\n  - Errors: ${errorCount}\n  - Fatalities: ${fatalityCount}\n\n## Affected Files\n${affectedFiles}\n\nPlease address these issues as soon as possible."
+        }
+    }
 }

package/CHANGELOG.md

@@ -1,3 +1,31 @@
+# [3.11.0](https://github.com/zotoio/x-fidelity/compare/v3.10.0...v3.11.0) (2025-03-09)
+
+
+### Bug Fixes
+
+* Remove duplicate import statement in notifications test ([f5c6468](https://github.com/zotoio/x-fidelity/commit/f5c6468063c1575610cd4b54aad84b97d4884437))
+* **results:** fix missing filesystem match details ([bc62faf](https://github.com/zotoio/x-fidelity/commit/bc62faff20e69fa6977e1ceee1bc22ad578cf2ba))
+* update NotificationManager mock to properly handle registerProvider ([6102837](https://github.com/zotoio/x-fidelity/commit/6102837f206938500885faf33560a91235a41885))
+
+
+### Features
+
+* add CODEOWNERS and notification test config ([5dc2904](https://github.com/zotoio/x-fidelity/commit/5dc29047d86f33b27fc9603077884b4df3f37330))
+* add debug logging for notification flow ([0e6af6b](https://github.com/zotoio/x-fidelity/commit/0e6af6b1583636935561f85a33c0bbea830905a5))
+* add detailed debug logging for email notifications ([18d929b](https://github.com/zotoio/x-fidelity/commit/18d929b3cc49b538c6ea3330d51d2670b090f7ba))
+* add email notification configuration to node-fullstack archetype ([424c5a0](https://github.com/zotoio/x-fidelity/commit/424c5a007c1b9eabeaffbca375cac131142ff7c9))
+* add notification system with email, slack and teams providers ([95d4ade](https://github.com/zotoio/x-fidelity/commit/95d4ade7de8db30c1592087ffa8dd78845c4ee47))
+* add notification team to CODEOWNERS file ([edb648e](https://github.com/zotoio/x-fidelity/commit/edb648e7378239ae7b6f672b9ce73c97e820a82a))
+* add package version to XFI_RESULT metadata ([1ee061a](https://github.com/zotoio/x-fidelity/commit/1ee061a971bbf63d18014f529a3353d4efb63482))
+* add xfiVersion field to ResultMetadata interface ([e59b187](https://github.com/zotoio/x-fidelity/commit/e59b18725b98781f547e58c5d9581d2ad7d5949f))
+
+# [3.10.0](https://github.com/zotoio/x-fidelity/compare/v3.9.1...v3.10.0) (2025-03-08)
+
+
+### Features
+
+* **canary:** add example canary rollout script using launchdarkly ([73fbcfb](https://github.com/zotoio/x-fidelity/commit/73fbcfb4eca11be8af7eb9fca20f7ed132898a83))
+
 ## [3.9.1](https://github.com/zotoio/x-fidelity/compare/v3.9.0...v3.9.1) (2025-03-02)
 
 

package/canary-install-example.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+#
+# This script uses the LaunchDarkly Node SDK to evaluate a feature flag
+# and conditionally run a command based on the flag’s value.
+#
+# Requirements:
+#   - Node.js installed.
+#   - LaunchDarkly Node SDK installed:
+#       yarn global add launchdarkly-node-client-sdk
+#
+# Set your LaunchDarkly clientid and feature flag key here.
+# note that the clientid is not a secret, as it is public in the client-side SDKs
+#
+# export XFI_LD_CLIENT_ID="YOUR_LAUNCHDARKLY_CLIENT_ID"
+# export XFI_VERSION_FLAG_KEY="your-feature-flag-key"
+
+# get the first commit on this repo to use as the context key
+XFI_CONTEXT_KEY=$(git rev-list --max-parents=0 HEAD | head -n 1)
+
+# print config
+echo "XFI_CONTEXT_KEY: $XFI_CONTEXT_KEY"
+echo "XFI_LD_CLIENT_ID: $XFI_LD_CLIENT_ID"
+echo "XFI_VERSION_FLAG_KEY: $XFI_VERSION_FLAG_KEY"
+
+# Run a Node.js script to evaluate the flag.
+FLAG_VALUE=$(node ./flagCheck.js $XFI_CONTEXT_KEY)
+echo "FLAG_VALUE: $FLAG_VALUE"
+
+# Check if the Node.js command succeeded.
+if [ $? -ne 0 ]; then
+  echo 'Error: Failed to evaluate the feature flag.'
+  exit 0
+fi
+
+# Decide which command to run based on the flag value.
+if [ "$FLAG_VALUE" == "true" ]; then
+  echo "Installing the NEW version of xfi"
+  # add your canary CI install command here
+  # eg. yarn global add x-fidelity@3.9.1 --ignore-engines
+else
+  echo "Installing the current version of xfi"
+  # add your current CI install command here
+  # eg. yarn global add x-fidelity@2.17.2 --ignore-engines
+fi

package/dist/core/cli.js

@@ -35,7 +35,8 @@ function initCLI() {
             info: (obj) => console.log(JSON.stringify(obj)),
             error: (obj) => console.error(JSON.stringify(obj)),
             warn: (obj) => console.warn(JSON.stringify(obj)),
-            debug: (obj) => console.debug(JSON.stringify(obj))
+            debug: (obj) => console.debug(JSON.stringify(obj)),
+            trace: (obj) => console.trace(JSON.stringify(obj))
         };
         global.logger = fallbackLogger;
     }

package/dist/core/engine/analyzer.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeCodebase = analyzeCodebase;
 const logger_1 = require("../../utils/logger");
 const configManager_1 = require("../configManager");
+const package_json_1 = require("../../../package.json");
 const openaiUtils_1 = require("../../utils/openaiUtils");
 const telemetry_1 = require("../../utils/telemetry");
 const repoFilesystemFacts_1 = require("../../facts/repoFilesystemFacts");
@@ -172,7 +173,8 @@ function analyzeCodebase(params) {
                 exemptCount: exemptCount,
                 options: cli_1.options,
                 repoPath,
-                repoUrl
+                repoUrl,
+                xfiVersion: package_json_1.version
             }
         };
         // Send telemetry for analysis end

package/dist/demoConfig/node-fullstack.json

@@ -59,6 +59,20 @@
             ".*\\.(ts|tsx|js|jsx)$",
             ".*\\/xfiTestMatch\\.json$",
             ".*\\/README\\.md$"
-        ]
+        ],
+        "notifications": {
+            "enabled": true,
+            "providers": ["email"],
+            "recipients": {
+                "email": ["io@zoto.io"]
+            },
+            "codeOwners": true,
+            "notifyOnSuccess": true,
+            "notifyOnFailure": true,
+            "customTemplates": {
+                "success": "All checks passed successfully! 🎉\n\nArchetype: ${archetype}\nFiles analyzed: ${fileCount}\nExecution time: ${executionTime}s",
+                "failure": "Issues found in codebase:\n\nArchetype: ${archetype}\nTotal issues: ${totalIssues}\n- Warnings: ${warningCount}\n- Errors: ${errorCount}\n- Fatalities: ${fatalityCount}\n\nAffected files:\n${affectedFiles}"
+            }
+        }
     }
 }

package/dist/facts/repoFilesystemFacts.js

@@ -130,11 +130,11 @@ function repoFileAnalysis(params, almanac) {
             return result;
         }
         //if there is already a resultFact for this file, we need to append
-        // const existingResult = almanac.factValue(params.resultFact);
-        // if (Object.keys(existingResult).includes('result')) {
-        //     logger.error(JSON.stringify(existingResult));
-        //     result.result = existingResult.result;
-        // }
+        const existingResult = almanac.factValue(params.resultFact);
+        if (Object.keys(existingResult).includes('result')) {
+            logger_1.logger.error(JSON.stringify(existingResult));
+            result.result = existingResult.result;
+        }
         const analysis = [];
         const lines = fileContent.split('\n');
         logger_1.logger.debug({ lineCount: lines.length }, 'Processing file lines');
@@ -196,8 +196,8 @@ function repoFileAnalysis(params, almanac) {
                 result.result[resultLength + i] = fileAnalysis[i];
             }
         }
-        //result.result. = analysis;
-        almanac.addRuntimeFact(params.resultFact, result);
+        result.result = analysis;
+        almanac.addRuntimeFact(params.resultFact, result.result);
         return result;
         // testing match on 'oracle'
         // testing match on 'declare'

package/dist/index.js

@@ -62,6 +62,7 @@ const prettyjson_1 = __importDefault(require("prettyjson"));
 const analyzer_1 = require("./core/engine/analyzer");
 const configServer_1 = require("./server/configServer");
 const telemetry_1 = require("./utils/telemetry");
+const notifications_1 = require("./notifications");
 // Function to handle errors and send telemetry
 const handleError = (error) => __awaiter(void 0, void 0, void 0, function* () {
     yield (0, telemetry_1.sendTelemetry)({
@@ -85,6 +86,16 @@ logger_1.logger.debug({ options: cli_1.options }, 'Startup options');
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         try {
+            // Initialize notification system
+            const notificationConfig = {
+                enabled: process.env.NOTIFICATIONS_ENABLED === 'true',
+                providers: (process.env.NOTIFICATION_PROVIDERS || '').split(',').filter(Boolean),
+                codeOwnersPath: process.env.CODEOWNERS_PATH || '.github/CODEOWNERS',
+                codeOwnersEnabled: process.env.CODEOWNERS_ENABLED !== 'false', // Default to true
+                notifyOnSuccess: process.env.NOTIFY_ON_SUCCESS === 'true',
+                notifyOnFailure: process.env.NOTIFY_ON_FAILURE !== 'false', // Default to true
+            };
+            const notificationManager = yield (0, notifications_1.initializeNotifications)(notificationConfig);
             if (cli_1.options.examine && process.env.NODE_ENV !== 'test') {
                 const { validateArchetypeConfig } = yield Promise.resolve().then(() => __importStar(require('./core/validateConfig')));
                 validateArchetypeConfig();
@@ -103,6 +114,24 @@ function main() {
                     });
                     const resultString = JSON.stringify(resultMetadata);
                     const prettyResult = prettyjson_1.default.render(resultMetadata.XFI_RESULT);
+                    // Add debug logging before notification check
+                    logger_1.logger.debug({
+                        notificationsEnabled: process.env.NOTIFICATIONS_ENABLED,
+                        notificationConfig: notificationConfig,
+                        hasNotificationManager: !!notificationManager
+                    }, 'Checking notification status');
+                    // Send notifications if enabled
+                    if (notificationConfig.enabled) {
+                        logger_1.logger.debug('Notifications are enabled, preparing to send report');
+                        // Get list of affected files (those with issues)
+                        const affectedFiles = getAffectedFiles(resultMetadata);
+                        logger_1.logger.debug({
+                            affectedFilesCount: affectedFiles.length,
+                            hasRepoConfig: !!resultMetadata.XFI_RESULT.repoXFIConfig
+                        }, 'Preparing notification data');
+                        // Pass the repo config to the notification manager
+                        yield notificationManager.sendReport(resultMetadata, affectedFiles, resultMetadata.XFI_RESULT.repoXFIConfig);
+                    }
                     // if results are found, there were issues found in the codebase
                     if (resultMetadata.XFI_RESULT.totalIssues > 0) {
                         logger_1.logger.warn(`WARNING: lo-fi attributes detected in codebase. ${resultMetadata.XFI_RESULT.warningCount} are warnings, ${resultMetadata.XFI_RESULT.fatalityCount} are fatal.`);
@@ -142,6 +171,18 @@ function main() {
         }
     });
 }
+// Helper function to extract affected files from results
+function getAffectedFiles(resultMetadata) {
+    const affectedFiles = [];
+    if (resultMetadata.XFI_RESULT.issueDetails) {
+        for (const issue of resultMetadata.XFI_RESULT.issueDetails) {
+            if (issue.filePath && !affectedFiles.includes(issue.filePath)) {
+                affectedFiles.push(issue.filePath);
+            }
+        }
+    }
+    return affectedFiles;
+}
 var configManager_1 = require("./core/configManager");
 Object.defineProperty(exports, "repoDir", { enumerable: true, get: function () { return configManager_1.repoDir; } });
 __exportStar(require("./utils/logger"), exports);

package/dist/notifications/index.d.ts

@@ -0,0 +1,3 @@
+import { NotificationManager } from './notificationManager';
+import { NotificationConfig } from '../types/notificationTypes';
+export declare function initializeNotifications(config: NotificationConfig): Promise<NotificationManager>;

package/dist/notifications/index.js

@@ -0,0 +1,120 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeNotifications = initializeNotifications;
+const notificationManager_1 = require("./notificationManager");
+const emailProvider_1 = require("./providers/emailProvider");
+const slackProvider_1 = require("./providers/slackProvider");
+const teamsProvider_1 = require("./providers/teamsProvider");
+const logger_1 = require("../utils/logger");
+function initializeNotifications(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!config.enabled) {
+            logger_1.logger.info('Notifications are disabled');
+            return notificationManager_1.NotificationManager.getInstance(config);
+        }
+        const notificationManager = notificationManager_1.NotificationManager.getInstance(config);
+        // Register configured providers
+        for (const providerName of config.providers) {
+            switch (providerName) {
+                case 'email':
+                    const emailConfig = loadEmailConfig();
+                    if (emailConfig) {
+                        notificationManager.registerProvider(new emailProvider_1.EmailProvider(emailConfig));
+                    }
+                    break;
+                case 'slack':
+                    const slackConfig = loadSlackConfig();
+                    if (slackConfig) {
+                        notificationManager.registerProvider(new slackProvider_1.SlackProvider(slackConfig));
+                    }
+                    break;
+                case 'teams':
+                    const teamsConfig = loadTeamsConfig();
+                    if (teamsConfig) {
+                        notificationManager.registerProvider(new teamsProvider_1.TeamsProvider(teamsConfig));
+                    }
+                    break;
+                default:
+                    logger_1.logger.warn(`Unknown notification provider: ${providerName}`);
+            }
+        }
+        return notificationManager;
+    });
+}
+function loadEmailConfig() {
+    try {
+        const config = {
+            host: process.env.NOTIFICATION_EMAIL_HOST || '',
+            port: parseInt(process.env.NOTIFICATION_EMAIL_PORT || '587'),
+            secure: process.env.NOTIFICATION_EMAIL_SECURE === 'true',
+            auth: {
+                user: process.env.NOTIFICATION_EMAIL_USER || '',
+                pass: process.env.NOTIFICATION_EMAIL_PASS || '',
+            },
+            from: process.env.NOTIFICATION_EMAIL_FROM || 'x-fidelity@noreply.com',
+        };
+        // Add debug logging
+        logger_1.logger.debug({
+            emailConfig: Object.assign(Object.assign({}, config), { auth: {
+                    user: config.auth.user,
+                    pass: '****' // Mask password
+                } })
+        }, 'Email configuration loaded');
+        // Validate required fields
+        if (!config.host || !config.auth.user || !config.auth.pass) {
+            logger_1.logger.warn('Missing required email configuration fields', {
+                hasHost: !!config.host,
+                hasUser: !!config.auth.user,
+                hasPass: !!config.auth.pass
+            });
+            return null;
+        }
+        return config;
+    }
+    catch (error) {
+        logger_1.logger.error(error, 'Failed to load email configuration');
+        return null;
+    }
+}
+function loadSlackConfig() {
+    try {
+        const webhookUrl = process.env.NOTIFICATION_SLACK_WEBHOOK;
+        if (!webhookUrl) {
+            logger_1.logger.warn('Slack webhook URL not configured');
+            return null;
+        }
+        return {
+            webhookUrl,
+            channel: process.env.NOTIFICATION_SLACK_CHANNEL,
+        };
+    }
+    catch (error) {
+        logger_1.logger.error(error, 'Failed to load Slack configuration');
+        return null;
+    }
+}
+function loadTeamsConfig() {
+    try {
+        const webhookUrl = process.env.NOTIFICATION_TEAMS_WEBHOOK;
+        if (!webhookUrl) {
+            logger_1.logger.warn('Teams webhook URL not configured');
+            return null;
+        }
+        return {
+            webhookUrl
+        };
+    }
+    catch (error) {
+        logger_1.logger.error(error, 'Failed to load Teams configuration');
+        return null;
+    }
+}

package/dist/notifications/notificationManager.d.ts

@@ -0,0 +1,19 @@
+import { ResultMetadata, RepoXFIConfig } from '../types/typeDefs';
+import { NotificationProvider, NotificationConfig } from '../types/notificationTypes';
+export declare class NotificationManager {
+    private static instance;
+    private providers;
+    private config;
+    private codeOwners;
+    private constructor();
+    static getInstance(config: NotificationConfig): NotificationManager;
+    registerProvider(provider: NotificationProvider): void;
+    sendReport(results: ResultMetadata, affectedFiles: string[], repoXFIConfig?: RepoXFIConfig): Promise<void>;
+    private mergeNotificationConfig;
+    private getRecipients;
+    private loadCodeOwners;
+    private getCodeOwnersForFiles;
+    private matchesGlob;
+    private applyTemplate;
+    private generateReportContent;
+}

package/dist/notifications/notificationManager.js

@@ -0,0 +1,249 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationManager = void 0;
+const logger_1 = require("../utils/logger");
+const fs_1 = __importDefault(require("fs"));
+class NotificationManager {
+    constructor(config) {
+        this.providers = new Map();
+        this.codeOwners = [];
+        this.config = config;
+        this.loadCodeOwners();
+    }
+    static getInstance(config) {
+        if (!NotificationManager.instance) {
+            NotificationManager.instance = new NotificationManager(config);
+        }
+        else {
+            // Update config if it changes
+            NotificationManager.instance.config = Object.assign(Object.assign({}, NotificationManager.instance.config), config);
+        }
+        return NotificationManager.instance;
+    }
+    registerProvider(provider) {
+        this.providers.set(provider.name, provider);
+        logger_1.logger.info(`Registered notification provider: ${provider.name}`);
+    }
+    sendReport(results, affectedFiles, repoXFIConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!this.config.enabled) {
+                logger_1.logger.debug('Notifications are disabled');
+                return;
+            }
+            // Merge global config with repo-specific config
+            const notifyConfig = this.mergeNotificationConfig(repoXFIConfig);
+            // Determine if we should send notification based on results
+            const hasIssues = results.XFI_RESULT.totalIssues > 0;
+            if (hasIssues && !notifyConfig.notifyOnFailure) {
+                logger_1.logger.debug('Skipping notification for failure as notifyOnFailure is disabled');
+                return;
+            }
+            if (!hasIssues && !notifyConfig.notifyOnSuccess) {
+                logger_1.logger.debug('Skipping notification for success as notifyOnSuccess is disabled');
+                return;
+            }
+            // Get recipients from multiple sources
+            const recipients = this.getRecipients(affectedFiles, repoXFIConfig, notifyConfig);
+            if (Object.values(recipients).every(list => list.length === 0)) {
+                logger_1.logger.warn('No recipients found for notification');
+                return;
+            }
+            // Generate report content
+            const subject = hasIssues
+                ? `[X-Fidelity] Issues found in your codebase (${results.XFI_RESULT.totalIssues})`
+                : '[X-Fidelity] Your codebase passed all checks';
+            // Use custom template if available
+            const templateKey = hasIssues ? 'failure' : 'success';
+            const customTemplate = (_b = (_a = repoXFIConfig === null || repoXFIConfig === void 0 ? void 0 : repoXFIConfig.notifications) === null || _a === void 0 ? void 0 : _a.customTemplates) === null || _b === void 0 ? void 0 : _b[templateKey];
+            const content = customTemplate
+                ? this.applyTemplate(customTemplate, results, affectedFiles)
+                : this.generateReportContent(results, affectedFiles);
+            // Send through all configured providers
+            for (const providerName of this.config.providers) {
+                const provider = this.providers.get(providerName);
+                if (provider) {
+                    try {
+                        // Only send to recipients configured for this provider
+                        const providerRecipients = recipients[providerName] || [];
+                        if (providerRecipients.length === 0) {
+                            logger_1.logger.debug(`No recipients configured for ${providerName}`);
+                            continue;
+                        }
+                        const notification = {
+                            recipients: providerRecipients,
+                            subject,
+                            content,
+                            metadata: {
+                                results,
+                                ciRunUrl: process.env.CI_RUN_URL || process.env.GITHUB_SERVER_URL && process.env.GITHUB_REPOSITORY && process.env.GITHUB_RUN_ID
+                                    ? `${process.env.GITHUB_SERVER_URL}/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`
+                                    : undefined
+                            }
+                        };
+                        yield provider.send(notification);
+                        logger_1.logger.info(`Sent notification via ${providerName} to ${providerRecipients.join(', ')}`);
+                    }
+                    catch (error) {
+                        logger_1.logger.error(error, `Failed to send notification via ${providerName}`);
+                    }
+                }
+                else {
+                    logger_1.logger.warn(`Notification provider not found: ${providerName}`);
+                }
+            }
+        });
+    }
+    mergeNotificationConfig(repoXFIConfig) {
+        if (!(repoXFIConfig === null || repoXFIConfig === void 0 ? void 0 : repoXFIConfig.notifications)) {
+            return this.config;
+        }
+        return Object.assign(Object.assign({}, this.config), { notifyOnSuccess: repoXFIConfig.notifications.notifyOnSuccess !== undefined
+                ? repoXFIConfig.notifications.notifyOnSuccess
+                : this.config.notifyOnSuccess, notifyOnFailure: repoXFIConfig.notifications.notifyOnFailure !== undefined
+                ? repoXFIConfig.notifications.notifyOnFailure
+                : this.config.notifyOnFailure, 
+            // Use codeOwners setting from repo config if specified
+            codeOwnersEnabled: repoXFIConfig.notifications.codeOwners !== undefined
+                ? repoXFIConfig.notifications.codeOwners
+                : this.config.codeOwnersEnabled });
+    }
+    getRecipients(affectedFiles, repoXFIConfig, notifyConfig) {
+        var _a;
+        const result = {
+            email: [],
+            slack: [],
+            teams: []
+        };
+        // Add recipients from repo config
+        if ((_a = repoXFIConfig === null || repoXFIConfig === void 0 ? void 0 : repoXFIConfig.notifications) === null || _a === void 0 ? void 0 : _a.recipients) {
+            const configRecipients = repoXFIConfig.notifications.recipients;
+            if (configRecipients.email) {
+                result.email.push(...configRecipients.email);
+            }
+            if (configRecipients.slack) {
+                result.slack.push(...configRecipients.slack);
+            }
+            if (configRecipients.teams) {
+                result.teams.push(...configRecipients.teams);
+            }
+        }
+        // Add code owners if enabled
+        if (notifyConfig === null || notifyConfig === void 0 ? void 0 : notifyConfig.codeOwnersEnabled) {
+            const codeOwners = this.getCodeOwnersForFiles(affectedFiles);
+            // Add code owners to all provider types
+            for (const key of Object.keys(result)) {
+                result[key].push(...codeOwners);
+            }
+        }
+        // Deduplicate recipients
+        for (const key of Object.keys(result)) {
+            result[key] = [...new Set(result[key])];
+        }
+        return result;
+    }
+    loadCodeOwners() {
+        if (!this.config.codeOwnersPath) {
+            logger_1.logger.warn('No CODEOWNERS file path specified');
+            return;
+        }
+        try {
+            const codeOwnersContent = fs_1.default.readFileSync(this.config.codeOwnersPath, 'utf8');
+            const lines = codeOwnersContent.split('\n');
+            for (const line of lines) {
+                // Skip comments and empty lines
+                if (line.trim().startsWith('#') || line.trim() === '')
+                    continue;
+                const parts = line.trim().split(/\s+/);
+                if (parts.length >= 2) {
+                    const path = parts[0];
+                    const owners = parts.slice(1).map(owner => {
+                        // Remove @ from GitHub usernames if present
+                        return owner.startsWith('@') ? owner.substring(1) : owner;
+                    });
+                    this.codeOwners.push({ path, owners });
+                }
+            }
+            logger_1.logger.info(`Loaded ${this.codeOwners.length} code owner entries`);
+        }
+        catch (error) {
+            logger_1.logger.error(error, `Failed to load CODEOWNERS file from ${this.config.codeOwnersPath}`);
+        }
+    }
+    getCodeOwnersForFiles(files) {
+        const owners = new Set();
+        for (const file of files) {
+            for (const codeOwner of this.codeOwners) {
+                // Simple glob matching (can be enhanced with proper glob matching)
+                if (this.matchesGlob(file, codeOwner.path)) {
+                    codeOwner.owners.forEach(owner => owners.add(owner));
+                }
+            }
+        }
+        return Array.from(owners);
+    }
+    matchesGlob(filePath, pattern) {
+        // Simple implementation - can be replaced with a proper glob matching library
+        if (pattern === '*')
+            return true;
+        if (pattern.endsWith('/*')) {
+            const dir = pattern.slice(0, -2);
+            return filePath.startsWith(dir + '/');
+        }
+        if (pattern.endsWith('/**')) {
+            const dir = pattern.slice(0, -3);
+            return filePath.startsWith(dir + '/');
+        }
+        return filePath === pattern;
+    }
+    applyTemplate(template, results, affectedFiles) {
+        // Replace template variables with actual values
+        return template
+            .replace(/\${archetype}/g, results.XFI_RESULT.archetype)
+            .replace(/\${fileCount}/g, String(results.XFI_RESULT.fileCount))
+            .replace(/\${totalIssues}/g, String(results.XFI_RESULT.totalIssues))
+            .replace(/\${warningCount}/g, String(results.XFI_RESULT.warningCount))
+            .replace(/\${errorCount}/g, String(results.XFI_RESULT.errorCount))
+            .replace(/\${fatalityCount}/g, String(results.XFI_RESULT.fatalityCount))
+            .replace(/\${exemptCount}/g, String(results.XFI_RESULT.exemptCount))
+            .replace(/\${affectedFiles}/g, affectedFiles.map(file => `- ${file}`).join('\n'))
+            .replace(/\${date}/g, new Date().toISOString())
+            .replace(/\${executionTime}/g, String(results.XFI_RESULT.durationSeconds));
+    }
+    generateReportContent(results, affectedFiles) {
+        // Basic template - can be enhanced or made configurable
+        return `
+# X-Fidelity Analysis Report
+
+## Summary
+- Archetype: ${results.XFI_RESULT.archetype}
+- Total files analyzed: ${results.XFI_RESULT.fileCount}
+- Issues found: ${results.XFI_RESULT.totalIssues}
+  - Warnings: ${results.XFI_RESULT.warningCount}
+  - Errors: ${results.XFI_RESULT.errorCount}
+  - Fatalities: ${results.XFI_RESULT.fatalityCount}
+- Exemptions: ${results.XFI_RESULT.exemptCount}
+
+## Affected Files
+${affectedFiles.map(file => `- ${file}`).join('\n')}
+
+## Execution Time
+${results.XFI_RESULT.durationSeconds} seconds
+
+For detailed information, please check the CI logs.
+`;
+    }
+}
+exports.NotificationManager = NotificationManager;