pumuki-ast-hooks 5.3.18 → 5.3.20

package/scripts/hooks-system/application/services/monitoring/GitTreeMonitorService.js

@@ -1,3 +1,7 @@
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class GitTreeMonitorService {
     constructor({
         repoRoot = process.cwd(),
@@ -10,6 +14,12 @@ class GitTreeMonitorService {
         logger = console,
         debugLogger = null
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'git_tree_monitor_service',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.limit = limit;
         this.warning = warning;
@@ -23,10 +33,18 @@ class GitTreeMonitorService {
         this.lastCritical = 0;
         this.lastWarning = 0;
         this.wasOverLimit = false;
+        m_constructor.success();
     }
 
     start() {
+        const m_start = createMetricScope({
+            hook: 'git_tree_monitor_service',
+            operation: 'start'
+        });
+
+        m_start.started();
         if (!Number.isFinite(this.limit) || this.limit <= 0 || typeof this.getState !== 'function') {
+            m_start.success();
             return;
         }
         this.check('startup');
@@ -36,13 +54,21 @@ class GitTreeMonitorService {
                 this.timer.unref();
             }
         }
+        m_start.success();
     }
 
     stop() {
+        const m_stop = createMetricScope({
+            hook: 'git_tree_monitor_service',
+            operation: 'stop'
+        });
+
+        m_stop.started();
         if (this.timer) {
             clearInterval(this.timer);
             this.timer = null;
         }
+        m_stop.success();
     }
 
     check(reason) {

package/scripts/hooks-system/application/services/monitoring/HealthCheckProviders.js

@@ -1,6 +1,10 @@
 const fs = require('fs');
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 const defaultHeartbeatPath = repoRoot => path.join(repoRoot, '.audit_tmp', 'guard-heartbeat.json');
 const defaultTokenUsagePath = repoRoot => path.join(repoRoot, '.audit_tmp', 'token-usage.jsonl');
 const defaultEvidencePath = repoRoot => path.join(repoRoot, '.AI_EVIDENCE.json');

package/scripts/hooks-system/application/services/monitoring/HealthCheckService.js

@@ -1,6 +1,10 @@
 const fs = require('fs');
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class HealthCheckService {
     constructor({
         repoRoot = process.cwd(),
@@ -12,6 +16,12 @@ class HealthCheckService {
         intervalMs = 0,
         timers = { setInterval, clearInterval }
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'health_check_service',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.providers = Array.isArray(providers) ? providers : [];
         this.notificationCenter = notificationCenter;
@@ -22,9 +32,16 @@ class HealthCheckService {
         this.timers = timers;
         this.history = [];
         this.timerRef = null;
+        m_constructor.success();
     }
 
     start(reason = 'startup') {
+        const m_start = createMetricScope({
+            hook: 'health_check_service',
+            operation: 'start'
+        });
+
+        m_start.started();
         this.collect(reason);
         if (this.intervalMs > 0) {
             this.timerRef = this.timers.setInterval(() => this.collect('interval'), this.intervalMs);
@@ -32,13 +49,21 @@ class HealthCheckService {
                 this.timerRef.unref();
             }
         }
+        m_start.success();
     }
 
     stop() {
+        const m_stop = createMetricScope({
+            hook: 'health_check_service',
+            operation: 'stop'
+        });
+
+        m_stop.started();
         if (this.timerRef) {
             this.timers.clearInterval(this.timerRef);
             this.timerRef = null;
         }
+        m_stop.success();
     }
 
     async collect(reason = 'manual') {

package/scripts/hooks-system/application/services/monitoring/HeartbeatMonitorService.js

@@ -1,6 +1,10 @@
 const fs = require('fs');
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class HeartbeatMonitorService {
     constructor({
         repoRoot = process.cwd(),
@@ -9,6 +13,12 @@ class HeartbeatMonitorService {
         statusProvider = () => null,
         logger = console
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'heartbeat_monitor_service',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.heartbeatPath = heartbeatPath;
         this.intervalMs = intervalMs;
@@ -16,10 +26,18 @@ class HeartbeatMonitorService {
         this.logger = logger;
         this.timer = null;
         this.lastStatus = null;
+        m_constructor.success();
     }
 
     start() {
+        const m_start = createMetricScope({
+            hook: 'heartbeat_monitor_service',
+            operation: 'start'
+        });
+
+        m_start.started();
         if (!Number.isFinite(this.intervalMs) || this.intervalMs <= 0) {
+            m_start.success();
             return;
         }
         this.emitHeartbeat();
@@ -27,13 +45,21 @@ class HeartbeatMonitorService {
         if (this.timer && typeof this.timer.unref === 'function') {
             this.timer.unref();
         }
+        m_start.success();
     }
 
     stop() {
+        const m_stop = createMetricScope({
+            hook: 'heartbeat_monitor_service',
+            operation: 'stop'
+        });
+
+        m_stop.started();
         if (this.timer) {
             clearInterval(this.timer);
             this.timer = null;
         }
+        m_stop.success();
     }
 
     emitHeartbeat() {

package/scripts/hooks-system/application/services/monitoring/TokenMonitor.js

@@ -3,11 +3,22 @@ const path = require('path');
 const { spawn, spawnSync } = require('child_process');
 const { ConfigurationError } = require('../../../domain/errors');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class TokenMonitor {
     constructor(repoRoot, options = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'token_monitor',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.scriptPath = path.join(repoRoot, 'infrastructure', 'watchdog', 'token-monitor-loop.sh');
         this.process = null;
+        m_constructor.success();
     }
 
     isAvailable() {
@@ -15,6 +26,12 @@ class TokenMonitor {
     }
 
     start() {
+        const m_start = createMetricScope({
+            hook: 'token_monitor',
+            operation: 'start'
+        });
+
+        m_start.started();
         if (!this.isAvailable()) {
             throw new ConfigurationError('Token monitor script not found', 'scriptPath');
         }
@@ -42,14 +59,23 @@ class TokenMonitor {
             this.process = null;
         });
 
+        m_start.success();
+
         return this.process;
     }
 
     stop() {
+        const m_stop = createMetricScope({
+            hook: 'token_monitor',
+            operation: 'stop'
+        });
+
+        m_stop.started();
         if (this.process && this.process.kill) {
             this.process.kill('SIGTERM');
             this.process = null;
         }
+        m_stop.success();
     }
 
     isRunning() {

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

@@ -1,11 +1,22 @@
 const { spawnSync } = require('child_process');
 const fs = require('fs');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class MacNotificationSender {
     constructor(logger) {
+        const m_constructor = createMetricScope({
+            hook: 'mac_notification_sender',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.logger = logger;
         this.terminalNotifierPath = this.resolveTerminalNotifier();
         this.osascriptPath = this.resolveOsascript();
+        m_constructor.success();
     }
 
     resolveTerminalNotifier() {

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

@@ -21,8 +21,18 @@ const NotificationQueue = require('./components/NotificationQueue');
 const NotificationRetryExecutor = require('./components/NotificationRetryExecutor');
 const NotificationDispatcher = require('./NotificationDispatcher');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class NotificationCenterService {
     constructor(config = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'notification_center_service',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = config.repoRoot || process.cwd();
         this.enabled = config.enabled !== false;
 
@@ -83,6 +93,7 @@ class NotificationCenterService {
             totalFailed: 0,
             totalRetries: 0
         };
+        m_constructor.success();
     }
 
     /**
@@ -173,6 +184,13 @@ class NotificationCenterService {
      * Gets service statistics
      */
     getStats() {
+        const m_get_stats = createMetricScope({
+            hook: 'notification_center_service',
+            operation: 'get_stats'
+        });
+
+        m_get_stats.started();
+        m_get_stats.success();
         return {
             ...this.stats,
             queueSize: this.queue.size(),

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

@@ -1,9 +1,20 @@
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class NotificationDispatcher {
     constructor(sender, retryExecutor, cooldownManager, logger) {
+        const m_constructor = createMetricScope({
+            hook: 'notification_dispatcher',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.sender = sender;
         this.retryExecutor = retryExecutor;
         this.cooldownManager = cooldownManager;
         this.logger = logger;
+        m_constructor.success();
     }
 
     async dispatch(notification, stats) {

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

@@ -1,9 +1,20 @@
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class NotificationCooldownManager {
     constructor(defaultCooldownMs = 60000, cooldownsByType = {}, logger = null) {
+        const m_constructor = createMetricScope({
+            hook: 'notification_cooldown_manager',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.cooldowns = new Map();
         this.defaultCooldownMs = defaultCooldownMs;
         this.cooldownsByType = cooldownsByType;
         this.logger = logger;
+        m_constructor.success();
     }
 
     isInCooldown(notification) {
@@ -49,6 +60,13 @@ class NotificationCooldownManager {
     }
 
     getStats() {
+        const m_get_stats = createMetricScope({
+            hook: 'notification_cooldown_manager',
+            operation: 'get_stats'
+        });
+
+        m_get_stats.started();
+        m_get_stats.success();
         return {
             activeCooldowns: this.cooldowns.size
         };

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

@@ -1,10 +1,21 @@
 const crypto = require('crypto');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class NotificationDeduplicator {
     constructor(windowMs = 5000, logger = null) {
+        const m_constructor = createMetricScope({
+            hook: 'notification_deduplicator',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.deduplicationMap = new Map();
         this.windowMs = windowMs;
         this.logger = logger;
+        m_constructor.success();
     }
 
     isDuplicate(notification) {
@@ -54,6 +65,13 @@ class NotificationDeduplicator {
     }
 
     getStats() {
+        const m_get_stats = createMetricScope({
+            hook: 'notification_deduplicator',
+            operation: 'get_stats'
+        });
+
+        m_get_stats.started();
+        m_get_stats.success();
         return {
             size: this.deduplicationMap.size
         };

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

@@ -1,7 +1,18 @@
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class NotificationQueue {
     constructor(maxSize = 100) {
+        const m_constructor = createMetricScope({
+            hook: 'notification_queue',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.maxSize = maxSize;
         this.items = [];
+        m_constructor.success();
     }
 
     enqueue(item) {

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

@@ -1,12 +1,29 @@
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class NotificationRetryExecutor {
     constructor(sender, config = {}, logger = null) {
+        const m_constructor = createMetricScope({
+            hook: 'notification_retry_executor',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.sender = sender;
         this.maxRetries = config.maxRetries || 2;
         this.retryDelayMs = config.retryDelayMs || 1000;
         this.logger = logger;
+        m_constructor.success();
     }
 
     async execute(notification, options = {}) {
+        const m_execute = createMetricScope({
+            hook: 'notification_retry_executor',
+            operation: 'execute'
+        });
+
+        m_execute.started();
         const currentRetries = notification.retries || 0;
         const remainingRetries = currentRetries < this.maxRetries ? this.maxRetries - currentRetries : 0;
 
@@ -21,6 +38,7 @@ class NotificationRetryExecutor {
                     if (attempt > 0) {
                         this.logRetrySuccess(notification, attempt);
                     }
+                    m_execute.success();
                     return { success: true, attempts: attempt + 1 };
                 }
             } catch (error) {
@@ -28,6 +46,8 @@ class NotificationRetryExecutor {
             }
         }
 
+        m_execute.success();
+
         return { success: false, attempts: remainingRetries + 1 };
     }
 

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

@@ -1,9 +1,20 @@
 const fs = require('fs');
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class PlatformHeuristics {
     constructor(platformDetector) {
+        const m_constructor = createMetricScope({
+            hook: 'platform_heuristics',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.platformDetector = platformDetector;
+        m_constructor.success();
     }
 
     detectFromASTSystemFiles(files) {
@@ -129,6 +140,12 @@ class PlatformHeuristics {
     }
 
     getPlatformFrequencyInHistory(platform, commits) {
+        const m_get_platform_frequency_in_history = createMetricScope({
+            hook: 'platform_heuristics',
+            operation: 'get_platform_frequency_in_history'
+        });
+
+        m_get_platform_frequency_in_history.started();
         if (!commits || commits.length === 0) return 0;
 
         const platformCommits = commits.filter(commit =>
@@ -137,6 +154,8 @@ class PlatformHeuristics {
             )
         );
 
+        m_get_platform_frequency_in_history.success();
+
         return platformCommits.length / commits.length;
     }
 }

package/scripts/hooks-system/application/services/recovery/AutoRecoveryManager.js

@@ -1,5 +1,9 @@
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class AutoRecoveryManager {
     constructor({
         repoRoot = process.cwd(),
@@ -11,6 +15,12 @@ class AutoRecoveryManager {
         baseBackoffMs = 2000,
         jitter = 0.25
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'auto_recovery_manager',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.logger = logger || console;
         this.notificationCenter = notificationCenter;
@@ -23,14 +33,23 @@ class AutoRecoveryManager {
             : [AutoRecoveryManager.createSupervisorRestartStrategy()];
         this.attempts = new Map();
         this.timeouts = new Map();
+        m_constructor.success();
     }
 
     static createSupervisorRestartStrategy() {
+        const m_create_supervisor_restart_strategy = createMetricScope({
+            hook: 'auto_recovery_manager',
+            operation: 'create_supervisor_restart_strategy'
+        });
+
+        m_create_supervisor_restart_strategy.started();
+        m_create_supervisor_restart_strategy.success();
         return {
             id: 'guard-supervisor-restart',
             condition: ({ reason }) => reason && reason.startsWith('heartbeat-'),
             action: async ({ logger }) => {
                 logger.info('Attempting guard-supervisor restart via start-guards.sh');
+                m_create_supervisor_restart_strategy.success();
                 return AutoRecoveryManager.runScript('start-guards.sh', ['restart']);
             }
         };

package/scripts/hooks-system/application/services/smart-commit/CommitMessageSuggester.js

@@ -1,7 +1,17 @@
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class CommitMessageSuggester {
     constructor(featureDetector) {
+        const m_constructor = createMetricScope({
+            hook: 'commit_message_suggester',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.featureDetector = featureDetector;
         this.commitTypePatterns = {
             feat: ['feature/', 'feat/', 'add', 'new', 'create', 'implement'],
@@ -12,6 +22,7 @@ class CommitMessageSuggester {
             chore: ['chore/', 'config/', 'build/', 'ci/'],
             style: ['style/', 'css/', 'scss/', 'styling']
         };
+        m_constructor.success();
     }
 
     suggest(group) {

package/scripts/hooks-system/application/services/smart-commit/FileContextGrouper.js

@@ -1,9 +1,20 @@
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class FileContextGrouper {
     constructor(featureDetector, platformDetector = null) {
+        const m_constructor = createMetricScope({
+            hook: 'file_context_grouper',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.featureDetector = featureDetector;
         this.platformDetector = platformDetector;
+        m_constructor.success();
     }
 
     group(files) {
@@ -89,10 +100,18 @@ class FileContextGrouper {
     }
 
     getContextDirectory(file) {
+        const m_get_context_directory = createMetricScope({
+            hook: 'file_context_grouper',
+            operation: 'get_context_directory'
+        });
+
+        m_get_context_directory.started();
         const parts = file.split(path.sep);
         if (parts.length <= 2) {
+            m_get_context_directory.success();
             return parts[0] || 'root';
         }
+        m_get_context_directory.success();
         return parts.slice(0, 2).join(path.sep);
     }
 

package/scripts/hooks-system/application/services/smart-commit/SmartCommitSummaryBuilder.js

@@ -1,3 +1,7 @@
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class SmartCommitSummaryBuilder {
     build(suggestions, orphans) {
         const lines = [];