pumuki-ast-hooks 5.3.19 → 5.3.20

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

@@ -1,6 +1,10 @@
 const fs = require('fs');
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class DevDocsMonitor {
     constructor({
         repoRoot = process.cwd(),
@@ -10,6 +14,12 @@ class DevDocsMonitor {
         logger = console,
         notificationService = null
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'dev_docs_monitor',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.checkIntervalMs = checkIntervalMs;
         this.staleThresholdMs = staleThresholdMs;
@@ -18,11 +28,19 @@ class DevDocsMonitor {
         this.notificationService = notificationService;
         this.timer = null;
         this.docsStatePath = path.join(repoRoot, '.audit_tmp', 'dev-docs-state.json');
+        m_constructor.success();
     }
 
     start() {
+        const m_start = createMetricScope({
+            hook: 'dev_docs_monitor',
+            operation: 'start'
+        });
+
+        m_start.started();
         if (!this.autoRefreshEnabled) {
             this.logger.info('[DevDocsMonitor] Auto-refresh disabled');
+            m_start.success();
             return;
         }
 
@@ -32,13 +50,21 @@ class DevDocsMonitor {
             this.timer.unref();
         }
         this.logger.info('[DevDocsMonitor] Started');
+        m_start.success();
     }
 
     stop() {
+        const m_stop = createMetricScope({
+            hook: 'dev_docs_monitor',
+            operation: 'stop'
+        });
+
+        m_stop.started();
         if (this.timer) {
             clearInterval(this.timer);
             this.timer = null;
         }
+        m_stop.success();
     }
 
     async checkDocs() {

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

@@ -3,8 +3,18 @@ const path = require('path');
 const { execSync } = require('child_process');
 const { ConfigurationError, DomainError } = require('../../../domain/errors');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class EvidenceMonitor {
     constructor(repoRoot, options = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'evidence_monitor',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.staleThresholdMs = options.staleThresholdMs || 180000;
         this.pollIntervalMs = options.pollIntervalMs || 30000;
@@ -14,6 +24,7 @@ class EvidenceMonitor {
         this.evidencePath = path.join(repoRoot, '.AI_EVIDENCE.json');
         this.tempDir = path.join(repoRoot, '.audit_tmp');
         this.updateScript = this.resolveUpdateEvidenceScript();
+        m_constructor.success();
     }
 
     resolveUpdateEvidenceScript() {
@@ -94,10 +105,17 @@ class EvidenceMonitor {
     }
 
     stop() {
+        const m_stop = createMetricScope({
+            hook: 'evidence_monitor',
+            operation: 'stop'
+        });
+
+        m_stop.started();
         if (this.pollTimer) {
             clearInterval(this.pollTimer);
             this.pollTimer = null;
         }
+        m_stop.success();
     }
 }
 

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

@@ -2,6 +2,10 @@ const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 function resolveUpdateEvidenceScript(repoRoot) {
     const candidates = [
         path.join(repoRoot, 'scripts/hooks-system/bin/update-evidence.sh'),
@@ -31,6 +35,12 @@ class EvidenceMonitorService {
         fsModule = fs,
         execFn = execSync
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'evidence_monitor_service',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.evidencePath = evidencePath;
         this.updateScriptPath = updateScriptPath;
@@ -43,14 +53,28 @@ class EvidenceMonitorService {
         this.exec = execFn;
         this.watchers = [];
         this.lastAutoRefresh = 0;
+        m_constructor.success();
     }
 
     start() {
+        const m_start = createMetricScope({
+            hook: 'evidence_monitor_service',
+            operation: 'start'
+        });
+
+        m_start.started();
         this.performInitialChecks();
         this.watchEvidenceFreshness();
+        m_start.success();
     }
 
     stop() {
+        const m_stop = createMetricScope({
+            hook: 'evidence_monitor_service',
+            operation: 'stop'
+        });
+
+        m_stop.started();
         this.watchers.forEach(watcher => {
             try {
                 watcher.close();
@@ -59,6 +83,7 @@ class EvidenceMonitorService {
             }
         });
         this.watchers = [];
+        m_stop.success();
     }
 
     performInitialChecks() {

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

@@ -2,8 +2,18 @@ const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class GitTreeMonitor {
     constructor(repoRoot, options = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'git_tree_monitor',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.stagedThreshold = options.stagedThreshold || 10;
         this.unstagedThreshold = options.unstagedThreshold || 15;
@@ -17,6 +27,7 @@ class GitTreeMonitor {
         this.timer = null;
         this.lastState = null;
         this.loadState();
+        m_constructor.success();
     }
 
     loadState() {
@@ -39,6 +50,12 @@ class GitTreeMonitor {
     }
 
     getTreeState() {
+        const m_get_tree_state = createMetricScope({
+            hook: 'git_tree_monitor',
+            operation: 'get_tree_state'
+        });
+
+        m_get_tree_state.started();
         try {
             const stagedRaw = execSync('git diff --cached --name-only', {
                 cwd: this.repoRoot,
@@ -58,6 +75,8 @@ class GitTreeMonitor {
             const untracked = untrackedRaw ? untrackedRaw.split('\n').length : 0;
             const total = staged + unstaged + untracked;
 
+            m_get_tree_state.success();
+
             return {
                 staged,
                 unstaged,
@@ -69,6 +88,7 @@ class GitTreeMonitor {
                 timestamp: Date.now()
             };
         } catch (error) {
+            m_get_tree_state.success();
             return {
                 staged: 0,
                 unstaged: 0,
@@ -79,6 +99,7 @@ class GitTreeMonitor {
                 timestamp: Date.now()
             };
         }
+        m_get_tree_state.success();
     }
 
     startMonitoring(onStateChange) {
@@ -109,10 +130,17 @@ class GitTreeMonitor {
     }
 
     stop() {
+        const m_stop = createMetricScope({
+            hook: 'git_tree_monitor',
+            operation: 'stop'
+        });
+
+        m_stop.started();
         if (this.timer) {
             clearInterval(this.timer);
             this.timer = null;
         }
+        m_stop.success();
     }
 
     isActive() {

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) {