pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/application/services/notification/NotificationCenterService.js

@@ -0,0 +1,221 @@
+/**
+ * NotificationCenterService
+ *
+ * Centralized service for hook-system notification management.
+ * Implements deduplication, message queue, cooldowns, and retry logic.
+ *
+ * Responsibilities (SRP):
+ * - Orchestrate notification flow
+ * - Delegate specific logic to components (Queue, Dedupe, Cooldown, Retry)
+ */
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const UnifiedLogger = require('../logging/UnifiedLogger');
+const MacNotificationSender = require('./MacNotificationSender');
+const NotificationDeduplicator = require('./components/NotificationDeduplicator');
+const NotificationCooldownManager = require('./components/NotificationCooldownManager');
+const NotificationQueue = require('./components/NotificationQueue');
+const NotificationRetryExecutor = require('./components/NotificationRetryExecutor');
+const NotificationDispatcher = require('./NotificationDispatcher');
+
+class NotificationCenterService {
+    constructor(config = {}) {
+        this.repoRoot = config.repoRoot || process.cwd();
+        this.enabled = config.enabled !== false;
+
+        // Logging Configuration
+        const defaultLogPath = config.logPath || path.join(this.repoRoot, '.audit-reports', 'notifications.log');
+        try {
+            fs.mkdirSync(path.dirname(defaultLogPath), { recursive: true });
+        } catch (e) {
+            // Ignore if it already exists or permissions issues during init
+        }
+
+        this.logger = config.logger || new UnifiedLogger({
+            component: 'NotificationCenter',
+            console: { enabled: true, level: 'info' },
+            file: { enabled: true, level: 'debug', path: defaultLogPath }
+        });
+
+        // Core Components
+        this.queue = new NotificationQueue(config.maxQueueSize || 100);
+        this.deduplicator = new NotificationDeduplicator(config.deduplicationWindowMs, this.logger);
+
+        // Cooldown Configuration
+        const cooldownsByType = {
+            evidence_stale: config.evidenceCooldownMs || 120000,
+            evidence_ok: config.evidenceOkCooldownMs || 300000,
+            token_warning: config.tokenWarningCooldownMs || 180000,
+            token_critical: config.tokenCriticalCooldownMs || 120000,
+            token_ok: config.tokenOkCooldownMs || 300000,
+            dirty_tree_warning: config.dirtyTreeWarningMs || 600000,
+            dirty_tree_critical: config.dirtyTreeCriticalMs || 300000,
+            heartbeat_degraded: config.heartbeatDegradedMs || 180000,
+            heartbeat_ok: config.heartbeatOkMs || 600000,
+            guard_supervisor: config.guardSupervisorMs || 900000
+        };
+        this.cooldownManager = new NotificationCooldownManager(config.defaultCooldownMs, cooldownsByType, this.logger);
+
+        // Sender and Executor
+        this.sender = new MacNotificationSender(this.logger);
+        this.notificationTimeout = config.notificationTimeout || 8;
+        this.retryExecutor = new NotificationRetryExecutor(this.sender, {
+            maxRetries: config.maxRetries || 2,
+            retryDelayMs: config.retryDelayMs || 1000
+        }, this.logger);
+
+        this.dispatcher = new NotificationDispatcher(this.sender, this.retryExecutor, this.cooldownManager, this.logger);
+
+        // Internal State
+        this.processing = false;
+        this.flushIntervalMs = config.flushIntervalMs || 1000;
+        this.flushTimer = null;
+
+        // Statistics
+        this.stats = {
+            totalEnqueued: 0,
+            totalSent: 0,
+            totalDeduplicated: 0,
+            totalCooldownSkipped: 0,
+            totalFailed: 0,
+            totalRetries: 0
+        };
+    }
+
+    /**
+     * Enqueues a notification to be sent
+     */
+    enqueue(notification) {
+        if (!this.enabled) return false;
+
+        const enriched = {
+            ...notification,
+            id: crypto.randomUUID(),
+            timestamp: Date.now(),
+            level: notification.level || 'info',
+            type: notification.type || 'generic',
+            metadata: notification.metadata || {},
+            retries: 0
+        };
+
+        if (this.deduplicator.isDuplicate(enriched)) {
+            this.stats.totalDeduplicated++;
+            this.log('debug', 'Notification deduplicated', { message: enriched.message, type: enriched.type });
+            return false;
+        }
+
+        if (this.cooldownManager.isInCooldown(enriched)) {
+            this.stats.totalCooldownSkipped++;
+            this.log('debug', 'Notification skipped (cooldown)', { message: enriched.message, type: enriched.type });
+            return false;
+        }
+
+        if (!this.queue.enqueue(enriched)) {
+            this.log('warn', 'Queue full, dropping notification', { message: enriched.message });
+            return false;
+        }
+
+        this.stats.totalEnqueued++;
+        this.log('debug', 'Notification enqueued', { id: enriched.id, type: enriched.type });
+
+        this.scheduleFlush();
+        return true;
+    }
+
+    scheduleFlush() {
+        if (!this.processing && !this.flushTimer) {
+            this.flushTimer = setTimeout(() => this.flush(), this.flushIntervalMs);
+        }
+    }
+
+    /**
+     * Processes the notification queue
+     */
+    async flush() {
+        if (this.processing || this.queue.isEmpty()) return;
+
+        this.processing = true;
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+
+        while (!this.queue.isEmpty()) {
+            const notification = this.queue.dequeue();
+            if (notification) {
+                await this.dispatcher.dispatch(notification, this.stats);
+            }
+        }
+
+        this.processing = false;
+    }
+
+    /**
+     * Structured logging
+     */
+    log(level, event, data = {}) {
+        if (this.logger && typeof this.logger[level] === 'function') {
+            this.logger[level](event, data);
+        }
+    }
+
+    /**
+     * Helper: sleep for retry logic
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    /**
+     * Gets service statistics
+     */
+    getStats() {
+        return {
+            ...this.stats,
+            queueSize: this.queue.size(),
+            deduplication: this.deduplicator.getStats(),
+            cooldowns: this.cooldownManager.getStats()
+        };
+    }
+
+    /**
+     * Resets the service (useful for testing)
+     */
+    reset() {
+        this.queue.clear();
+        this.deduplicator.reset();
+        this.cooldownManager.reset();
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this.processing = false;
+        this.stats = {
+            totalEnqueued: 0,
+            totalSent: 0,
+            totalDeduplicated: 0,
+            totalCooldownSkipped: 0,
+            totalFailed: 0,
+            totalRetries: 0
+        };
+    }
+
+    /**
+     * Stops the service cleanly
+     */
+    shutdown() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        if (!this.queue.isEmpty()) {
+            this.flush(); // Attempt one last flush
+        }
+        this.log('info', 'NotificationCenterService shutdown', this.getStats());
+    }
+}
+
+module.exports = NotificationCenterService;

package/scripts/hooks-system/application/services/notification/NotificationDispatcher.js

@@ -0,0 +1,42 @@
+class NotificationDispatcher {
+    constructor(sender, retryExecutor, cooldownManager, logger) {
+        this.sender = sender;
+        this.retryExecutor = retryExecutor;
+        this.cooldownManager = cooldownManager;
+        this.logger = logger;
+    }
+
+    async dispatch(notification, stats) {
+        const { success, attempts } = await this.retryExecutor.execute(notification, {
+            timeout: this.sender.timeout || 8
+        });
+
+        if (success) {
+            stats.totalSent++;
+            if (attempts > 1) stats.totalRetries += (attempts - 1);
+            this.cooldownManager.markSent(notification);
+            this.log('info', 'Notification sent', {
+                id: notification.id,
+                type: notification.type,
+                level: notification.level,
+                attempts
+            });
+        } else {
+            stats.totalFailed++;
+            stats.totalRetries += (attempts - 1);
+            this.log('error', 'Notification failed after retries', {
+                id: notification.id,
+                type: notification.type,
+                attempts
+            });
+        }
+    }
+
+    log(level, event, data) {
+        if (this.logger && typeof this.logger[level] === 'function') {
+            this.logger[level](event, data);
+        }
+    }
+}
+
+module.exports = NotificationDispatcher;

package/scripts/hooks-system/application/services/notification/__tests__/NotificationCenterService.spec.js

@@ -0,0 +1,40 @@
+const NotificationCenterService = require('../NotificationCenterService');
+
+describe('NotificationCenterService', () => {
+  describe('module structure', () => {
+    it('should export a class', () => {
+      expect(NotificationCenterService).toBeDefined();
+      expect(typeof NotificationCenterService).toBe('function');
+    });
+
+    it('should be instantiable with default config', () => {
+      const instance = new NotificationCenterService();
+      expect(instance).toBeDefined();
+    });
+
+    it('should accept custom config', () => {
+      const instance = new NotificationCenterService({ repoRoot: '/tmp' });
+      expect(instance.repoRoot).toBe('/tmp');
+    });
+  });
+
+  describe('core methods', () => {
+    let service;
+
+    beforeEach(() => {
+      service = new NotificationCenterService({ repoRoot: '/tmp' });
+    });
+
+    it('should have enqueue method', () => {
+      expect(typeof service.enqueue).toBe('function');
+    });
+
+    it('should have flush method', () => {
+      expect(typeof service.flush).toBe('function');
+    });
+
+    it('should have sleep helper', () => {
+      expect(typeof service.sleep).toBe('function');
+    });
+  });
+});

package/scripts/hooks-system/application/services/notification/components/NotificationCooldownManager.js

@@ -0,0 +1,62 @@
+class NotificationCooldownManager {
+    constructor(defaultCooldownMs = 60000, cooldownsByType = {}, logger = null) {
+        this.cooldowns = new Map();
+        this.defaultCooldownMs = defaultCooldownMs;
+        this.cooldownsByType = cooldownsByType;
+        this.logger = logger;
+    }
+
+    isInCooldown(notification) {
+        const type = notification.type;
+        const now = Date.now();
+
+        if (!this.cooldowns.has(type)) {
+            return false;
+        }
+
+        const lastSent = this.cooldowns.get(type);
+        const cooldownMs = this.cooldownsByType[type] || this.defaultCooldownMs;
+
+        const inCooldown = (now - lastSent) < cooldownMs;
+
+        if (inCooldown && this.logger && this.logger.debug) {
+            this.logger.debug('NOTIFICATION_COOLDOWN', {
+                type,
+                lastSent,
+                cooldownMs,
+                remaining: cooldownMs - (now - lastSent)
+            });
+        }
+
+        return inCooldown;
+    }
+
+    markSent(notification) {
+        this.cooldowns.set(notification.type, Date.now());
+        if (this.logger && this.logger.debug) {
+            this.logger.debug('NOTIFICATION_SENT_MARK', { type: notification.type });
+        }
+    }
+
+    clearExpired() {
+        const now = Date.now();
+        for (const [type, lastSent] of this.cooldowns.entries()) {
+            const cooldownMs = this.cooldownsByType[type] || this.defaultCooldownMs;
+            if (now - lastSent > cooldownMs) {
+                this.cooldowns.delete(type);
+            }
+        }
+    }
+
+    getStats() {
+        return {
+            activeCooldowns: this.cooldowns.size
+        };
+    }
+
+    reset() {
+        this.cooldowns.clear();
+    }
+}
+
+module.exports = NotificationCooldownManager;

package/scripts/hooks-system/application/services/notification/components/NotificationDeduplicator.js

@@ -0,0 +1,67 @@
+const crypto = require('crypto');
+
+class NotificationDeduplicator {
+    constructor(windowMs = 5000, logger = null) {
+        this.deduplicationMap = new Map();
+        this.windowMs = windowMs;
+        this.logger = logger;
+    }
+
+    isDuplicate(notification) {
+        const hash = this.hashNotification(notification);
+        const now = Date.now();
+
+        if (this.deduplicationMap.has(hash)) {
+            const existing = this.deduplicationMap.get(hash);
+
+            if (now - existing.lastSeen < this.windowMs) {
+                existing.count++;
+                existing.lastSeen = now;
+                if (this.logger && this.logger.debug) {
+                    this.logger.debug('NOTIFICATION_DUPLICATE', {
+                        hash,
+                        count: existing.count,
+                        message: notification.message
+                    });
+                }
+                return true;
+            }
+
+            this.deduplicationMap.set(hash, { count: 1, firstSeen: now, lastSeen: now });
+            return false;
+        }
+
+        this.deduplicationMap.set(hash, { count: 1, firstSeen: now, lastSeen: now });
+        this.cleanup(now);
+        return false;
+    }
+
+    hashNotification(notification) {
+        const payload = `${notification.message}|${notification.type}|${notification.level}`;
+        return crypto.createHash('md5').update(payload).digest('hex');
+    }
+
+    cleanup(now) {
+        if (this.deduplicationMap.size < 100) {
+            return;
+        }
+
+        for (const [hash, data] of this.deduplicationMap.entries()) {
+            if (now - data.lastSeen > this.windowMs * 2) {
+                this.deduplicationMap.delete(hash);
+            }
+        }
+    }
+
+    getStats() {
+        return {
+            size: this.deduplicationMap.size
+        };
+    }
+
+    reset() {
+        this.deduplicationMap.clear();
+    }
+}
+
+module.exports = NotificationDeduplicator;

package/scripts/hooks-system/application/services/notification/components/NotificationQueue.js

@@ -0,0 +1,36 @@
+class NotificationQueue {
+    constructor(maxSize = 100) {
+        this.maxSize = maxSize;
+        this.items = [];
+    }
+
+    enqueue(item) {
+        if (this.items.length >= this.maxSize) {
+            return false;
+        }
+        this.items.push(item);
+        return true;
+    }
+
+    dequeue() {
+        return this.items.shift();
+    }
+
+    isEmpty() {
+        return this.items.length === 0;
+    }
+
+    size() {
+        return this.items.length;
+    }
+
+    clear() {
+        this.items = [];
+    }
+
+    peek() {
+        return this.items.length > 0 ? this.items[0] : undefined;
+    }
+}
+
+module.exports = NotificationQueue;

package/scripts/hooks-system/application/services/notification/components/NotificationRetryExecutor.js

@@ -0,0 +1,58 @@
+class NotificationRetryExecutor {
+    constructor(sender, config = {}, logger = null) {
+        this.sender = sender;
+        this.maxRetries = config.maxRetries || 2;
+        this.retryDelayMs = config.retryDelayMs || 1000;
+        this.logger = logger;
+    }
+
+    async execute(notification, options = {}) {
+        const currentRetries = notification.retries || 0;
+        const remainingRetries = currentRetries < this.maxRetries ? this.maxRetries - currentRetries : 0;
+
+        for (let attempt = 0; attempt <= remainingRetries; attempt++) {
+            if (attempt > 0) {
+                await this.sleep(this.retryDelayMs * attempt);
+            }
+
+            try {
+                const success = this.sender.send(notification, options);
+                if (success) {
+                    if (attempt > 0) {
+                        this.logRetrySuccess(notification, attempt);
+                    }
+                    return { success: true, attempts: attempt + 1 };
+                }
+            } catch (error) {
+                this.logError(notification, error, attempt);
+            }
+        }
+
+        return { success: false, attempts: remainingRetries + 1 };
+    }
+
+    logRetrySuccess(notification, attempt) {
+        if (this.logger && this.logger.debug) {
+            this.logger.debug('Notification sent after retry', {
+                id: notification.id,
+                attempts: attempt + 1
+            });
+        }
+    }
+
+    logError(notification, error, attempt) {
+        if (this.logger && this.logger.warn) {
+            this.logger.warn('Notification send attempt failed', {
+                id: notification.id,
+                attempt: attempt + 1,
+                error: error.message
+            });
+        }
+    }
+
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+
+module.exports = NotificationRetryExecutor;

package/scripts/hooks-system/application/services/platform/PlatformHeuristics.js

@@ -0,0 +1,144 @@
+const fs = require('fs');
+const path = require('path');
+
+class PlatformHeuristics {
+    constructor(platformDetector) {
+        this.platformDetector = platformDetector;
+    }
+
+    detectFromASTSystemFiles(files) {
+        if (!files) return [];
+
+        const platforms = new Set();
+        const systemFilePatterns = {
+            backend: [
+                'bin/',
+                '.AI_EVIDENCE.json',
+                'test-notification.ts',
+                '.github/workflows/',
+                'infrastructure/mcp/'
+            ],
+            frontend: [
+                'rulesfront.mdc',
+                'apps/admin-dashboard/',
+                'apps/web-app/'
+            ],
+            ios: ['rulesios.mdc', 'CustomLintRules/'],
+            android: ['rulesandroid.mdc', 'custom-rules/']
+        };
+
+        for (const file of files) {
+            for (const [platform, patterns] of Object.entries(systemFilePatterns)) {
+                if (patterns.some(pattern => file.includes(pattern))) {
+                    platforms.add(platform);
+                }
+            }
+        }
+
+        return Array.from(platforms);
+    }
+
+    detectFromBranchKeywords(branchName) {
+        if (!branchName) return [];
+
+        const platforms = [];
+        const keywords = {
+            backend: ['backend', 'api', 'server', 'mcp', 'hooks', 'gitflow', 'notification', 'automation', 'infrastructure'],
+            frontend: ['frontend', 'web', 'admin', 'dashboard', 'ui', 'component', 'page'],
+            ios: ['ios', 'swift', 'apple'],
+            android: ['android', 'kotlin']
+        };
+
+        const lowerBranch = branchName.toLowerCase();
+
+        for (const [platform, words] of Object.entries(keywords)) {
+            if (words.some(word => lowerBranch.includes(word))) {
+                platforms.push(platform);
+            }
+        }
+
+        return platforms;
+    }
+
+    detectFromEvidenceFile() {
+        try {
+            const evidencePath = path.join(process.cwd(), '.AI_EVIDENCE.json');
+            if (!fs.existsSync(evidencePath)) return [];
+
+            const evidence = JSON.parse(fs.readFileSync(evidencePath, 'utf-8'));
+            const platforms = new Set();
+
+            if (evidence.rules_read) {
+                const rulesRead = Array.isArray(evidence.rules_read)
+                    ? evidence.rules_read
+                    : [evidence.rules_read];
+
+                rulesRead.forEach(rule => {
+                    const ruleStr = typeof rule === 'object' ? rule.file : rule;
+                    if (ruleStr.includes('backend')) platforms.add('backend');
+                    if (ruleStr.includes('frontend') || ruleStr.includes('front')) platforms.add('frontend');
+                    if (ruleStr.includes('ios')) platforms.add('ios');
+                    if (ruleStr.includes('android')) platforms.add('android');
+                });
+            }
+
+            return Array.from(platforms);
+        } catch (error) {
+            return [];
+        }
+    }
+
+    isDirectoryUnambiguous(files, platform) {
+        if (!files || files.length === 0) return false;
+
+        const neutralFilenames = new Set(['.AI_EVIDENCE.json', 'README.md']);
+        const relevantFiles = files.filter(file => !neutralFilenames.has(file));
+
+        if (relevantFiles.length === 0) return false;
+
+        const unambiguousPaths = {
+            backend: ['/apps/backend/', 'apps/backend/', '/backend/', 'backend/', '/server/', 'server/', '/api/', 'api/'],
+            frontend: ['/apps/admin/', 'apps/admin/', '/apps/web-app/', 'apps/web-app/', '/frontend/', 'frontend/', '/client/', 'client/'],
+            ios: ['/apps/ios/', 'apps/ios/', '/ios/', 'ios/', 'CustomLintRules/'],
+            android: ['/apps/android/', 'apps/android/', '/android/', 'android/', 'custom-rules/']
+        };
+
+        const platformPaths = unambiguousPaths[platform] || [];
+
+        return relevantFiles.every(file =>
+            platformPaths.some(p => file.includes(p))
+        );
+    }
+
+    hasSpecificExtension(files, platform) {
+        if (!files || files.length === 0) return false;
+
+        const specificExtensions = {
+            ios: ['.swift'],
+            android: ['.kt', '.kts'],
+            backend: [],
+            frontend: []
+        };
+
+        const platformExts = specificExtensions[platform] || [];
+        if (platformExts.length === 0) return false;
+
+        return files.some(file =>
+            platformExts.some(ext => file.endsWith(ext))
+        );
+    }
+
+    getPlatformFrequencyInHistory(platform, commits) {
+        if (!commits || commits.length === 0) return 0;
+
+        const platformCommits = commits.filter(commit =>
+            commit.files && commit.files.some(file =>
+                this.platformDetector.detectPlatformFromFile(file) === platform
+            )
+        );
+
+        return platformCommits.length / commits.length;
+    }
+}
+
+module.exports = PlatformHeuristics;