pumuki-ast-hooks 5.3.19 → 5.3.20

package/scripts/hooks-system/application/services/PlatformDetectionService.js

@@ -1,9 +1,19 @@
 
+const {
+  createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 const fs = require('fs').promises;
 const path = require('path');
 
 class PlatformDetectionService {
   constructor() {
+    const m_constructor = createMetricScope({
+      hook: 'platform_detection_service',
+      operation: 'constructor'
+    });
+
+    m_constructor.started();
     this.cache = {
       detections: new Map(),
       timestamp: 0,
@@ -43,6 +53,7 @@ class PlatformDetectionService {
         '*.java',
       ],
     };
+    m_constructor.success();
   }
 
   async detectPlatforms(targetPath) {
@@ -142,6 +153,12 @@ class PlatformDetectionService {
   }
 
   getAmbiguityScore(filePath) {
+    const m_get_ambiguity_score = createMetricScope({
+      hook: 'platform_detection_service',
+      operation: 'get_ambiguity_score'
+    });
+
+    m_get_ambiguity_score.started();
     const platform = this._detectPlatformUncached(filePath);
     const lowerPath = filePath.toLowerCase();
     const ext = path.extname(filePath);
@@ -156,6 +173,8 @@ class PlatformDetectionService {
     if (ext === '.ts' || ext === '.tsx') return 60;
     if (ext === '.js' || ext === '.jsx') return 70;
 
+    m_get_ambiguity_score.success();
+
     return 100;
   }
 

package/scripts/hooks-system/application/services/PlaybookRunner.js

@@ -2,13 +2,27 @@ const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const { DomainError, NotFoundError } = require('../../domain/errors');
+const { NotFoundException } = require('../domain/exceptions');
+
+const { recordMetric } = require('../../../infrastructure/telemetry/metrics-logger');
+
+const {
+  createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
 
 const PLAYBOOKS_PATH = path.join(process.cwd(), 'scripts', 'hooks-system', 'config', 'playbooks.json');
 
 class PlaybookRunner {
   constructor(options = {}) {
+    const m_constructor = createMetricScope({
+      hook: 'playbook_runner',
+      operation: 'constructor'
+    });
+
+    m_constructor.started();
     this.cwd = options.cwd || process.cwd();
     this.playbooks = JSON.parse(fs.readFileSync(PLAYBOOKS_PATH, 'utf8'));
+    m_constructor.success();
   }
 
   list() {
@@ -16,9 +30,15 @@ class PlaybookRunner {
   }
 
   run(id) {
+    const m_run = createMetricScope({
+      hook: 'playbook_runner',
+      operation: 'run'
+    });
+
+    m_run.started();
     const playbook = this.playbooks[id];
     if (!playbook) {
-      throw new Error(`Playbook '${id}' not found`);
+      throw new NotFoundException('Playbook', { id });
     }
 
     for (const step of playbook.steps) {
@@ -33,6 +53,7 @@ class PlaybookRunner {
         }
       }
     }
+    m_run.success();
   }
 }
 

package/scripts/hooks-system/application/services/PredictiveHookAdvisor.js

@@ -1,11 +1,22 @@
 const fs = require('fs');
 const path = require('path');
 
+const {
+  createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 const METRICS_FILE = path.join(process.cwd(), '.audit_tmp', 'hook-metrics.jsonl');
 
 class PredictiveHookAdvisor {
   constructor({ windowSize = 200 } = {}) {
+    const m_constructor = createMetricScope({
+      hook: 'predictive_hook_advisor',
+      operation: 'constructor'
+    });
+
+    m_constructor.started();
     this.windowSize = windowSize;
+    m_constructor.success();
   }
 
   loadMetrics() {
@@ -24,6 +35,12 @@ class PredictiveHookAdvisor {
   }
 
   getFailureProbabilities() {
+    const m_get_failure_probabilities = createMetricScope({
+      hook: 'predictive_hook_advisor',
+      operation: 'get_failure_probabilities'
+    });
+
+    m_get_failure_probabilities.started();
     const metrics = this.loadMetrics();
     const stats = {};
 
@@ -38,6 +55,8 @@ class PredictiveHookAdvisor {
       }
     }
 
+    m_get_failure_probabilities.success();
+
     return Object.entries(stats)
       .map(([hook, { total, failures }]) => ({
         hook,

package/scripts/hooks-system/application/services/RealtimeGuardPlugin.js

@@ -1,5 +1,9 @@
 const EvidenceMonitorService = require('./monitoring/EvidenceMonitorService');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class EvidenceRealtimeGuardPlugin {
     constructor({
         repoRoot = process.cwd(),
@@ -7,6 +11,12 @@ class EvidenceRealtimeGuardPlugin {
         logger = console,
         evidenceMonitor = null
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'realtime_guard_plugin',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.notificationCenter = notificationCenter;
         this.logger = logger || console;
@@ -16,18 +26,33 @@ class EvidenceRealtimeGuardPlugin {
             logger: this.logger,
             notifier: payload => this.forwardNotification(payload)
         });
+        m_constructor.success();
     }
 
     start() {
+        const m_start = createMetricScope({
+            hook: 'realtime_guard_plugin',
+            operation: 'start'
+        });
+
+        m_start.started();
         if (typeof this.evidenceMonitor.start === 'function') {
             this.evidenceMonitor.start();
         }
+        m_start.success();
     }
 
     stop() {
+        const m_stop = createMetricScope({
+            hook: 'realtime_guard_plugin',
+            operation: 'stop'
+        });
+
+        m_stop.started();
         if (typeof this.evidenceMonitor.stop === 'function') {
             this.evidenceMonitor.stop();
         }
+        m_stop.success();
     }
 
     forwardNotification(payload) {

package/scripts/hooks-system/application/services/RealtimeGuardService.js

@@ -2,6 +2,12 @@ const fs = require('fs');
 const path = require('path');
 const { getGitTreeState, isTreeBeyondLimit } = require('./GitTreeState');
 
+const { recordMetric } = require('../../../infrastructure/telemetry/metrics-logger');
+
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class RealtimeGuardService {
     /**
      * @param {Object} dependencies
@@ -12,6 +18,13 @@ class RealtimeGuardService {
      * @param {Object} dependencies.config
      */
     constructor(dependencies = {}) {
+        recordMetric({
+            hook: 'realtime_guard_service',
+            operation: 'constructor',
+            status: 'started',
+            hasDependencies: !!dependencies
+        });
+
         const {
             logger,
             notificationService,
@@ -62,6 +75,12 @@ class RealtimeGuardService {
     }
 
     start() {
+        const m_start = createMetricScope({
+            hook: 'realtime_guard_service',
+            operation: 'start'
+        });
+
+        m_start.started();
         this.logger.info('Starting RealtimeGuardService...');
 
         // Start all monitors
@@ -78,9 +97,16 @@ class RealtimeGuardService {
         this._startGitFlowSync();
 
         this.logger.info('[RealtimeGuardService] All services started');
+        m_start.success();
     }
 
     stop() {
+        const m_stop = createMetricScope({
+            hook: 'realtime_guard_service',
+            operation: 'stop'
+        });
+
+        m_stop.started();
         this.logger.info('Stopping RealtimeGuardService...');
 
         this.watchers.forEach(w => w.close());
@@ -93,6 +119,7 @@ class RealtimeGuardService {
         });
 
         this.logger.info('[RealtimeGuardService] All services stopped');
+        m_stop.success();
     }
 
     _startEvidenceMonitoring() {

package/scripts/hooks-system/application/services/SmartDirtyTreeAnalyzer.js

@@ -3,12 +3,22 @@ const FileContextGrouper = require('./smart-commit/FileContextGrouper');
 const CommitMessageSuggester = require('./smart-commit/CommitMessageSuggester');
 const SmartCommitSummaryBuilder = require('./smart-commit/SmartCommitSummaryBuilder');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class SmartDirtyTreeAnalyzer {
     constructor({
         platformDetector = null,
         repoRoot = process.cwd(),
         logger = console
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'smart_dirty_tree_analyzer',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.logger = logger;
 
@@ -16,6 +26,7 @@ class SmartDirtyTreeAnalyzer {
         this.grouper = new FileContextGrouper(this.featureDetector, platformDetector);
         this.suggester = new CommitMessageSuggester(this.featureDetector);
         this.summaryBuilder = new SmartCommitSummaryBuilder();
+        m_constructor.success();
     }
 
     analyze(files) {

package/scripts/hooks-system/application/services/commit/CommitMessageGenerator.js

@@ -1,6 +1,17 @@
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class CommitMessageGenerator {
     constructor(logger = console) {
+        const m_constructor = createMetricScope({
+            hook: 'commit_message_generator',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.logger = logger;
+        m_constructor.success();
     }
 
     /**

package/scripts/hooks-system/application/services/commit/FeatureDetector.js

@@ -1,6 +1,17 @@
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class FeatureDetector {
     constructor(logger = console) {
+        const m_constructor = createMetricScope({
+            hook: 'feature_detector',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.logger = logger;
+        m_constructor.success();
     }
 
     /**

package/scripts/hooks-system/application/services/evidence/EvidenceContextManager.js

@@ -3,6 +3,10 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 const { DomainError } = require('../../../domain/errors');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 const DEFAULT_PLATFORMS = ['1', '2', '3', '4'];
 
 function resolveUpdateEvidenceScript(repoRoot) {
@@ -33,6 +37,12 @@ class EvidenceContextManager {
         timers = { setInterval, clearInterval },
         runCommand = EvidenceContextManager.runUpdateScript
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'evidence_context_manager',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.updateScript = updateScript;
         this.thresholdSeconds = thresholdSeconds;
@@ -44,6 +54,7 @@ class EvidenceContextManager {
         this.runCommand = runCommand;
         this.timerRef = null;
         this.refreshInProgress = false;
+        m_constructor.success();
     }
 
     static runUpdateScript(scriptPath, platforms) {
@@ -61,6 +72,12 @@ class EvidenceContextManager {
     }
 
     start(reason = 'startup') {
+        const m_start = createMetricScope({
+            hook: 'evidence_context_manager',
+            operation: 'start'
+        });
+
+        m_start.started();
         this.ensureFresh(reason).catch(error => {
             this.log('error', 'EVIDENCE_STARTUP_REFRESH_FAILED', { error: error.message });
         });
@@ -74,13 +91,21 @@ class EvidenceContextManager {
                 this.timerRef.unref();
             }
         }
+        m_start.success();
     }
 
     stop() {
+        const m_stop = createMetricScope({
+            hook: 'evidence_context_manager',
+            operation: 'stop'
+        });
+
+        m_stop.started();
         if (this.timerRef) {
             this.timers.clearInterval(this.timerRef);
             this.timerRef = null;
         }
+        m_stop.success();
     }
 
     async ensureFresh(reason = 'manual') {

package/scripts/hooks-system/application/services/guard/GuardAutoManagerService.js

@@ -11,6 +11,10 @@ const GuardNotificationHandler = require('./GuardNotificationHandler');
 const GuardMonitorLoop = require('./GuardMonitorLoop');
 const GuardHealthReminder = require('./GuardHealthReminder');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class GuardAutoManagerService {
     constructor({
         repoRoot = process.cwd(),
@@ -23,6 +27,12 @@ class GuardAutoManagerService {
         processRef = process,
         heartbeatMonitor = null
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'guard_auto_manager_service',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.process = processRef;
 
         // Configuration & Infrastructure
@@ -49,6 +59,7 @@ class GuardAutoManagerService {
         this.lastHeartbeatState = { healthy: true, reason: 'healthy' };
         this.lastHeartbeatRestart = 0;
         this.shuttingDown = false;
+        m_constructor.success();
     }
 
     notifyUser(message, level = 'info', metadata = {}) {
@@ -57,8 +68,15 @@ class GuardAutoManagerService {
     }
 
     start() {
+        const m_start = createMetricScope({
+            hook: 'guard_auto_manager_service',
+            operation: 'start'
+        });
+
+        m_start.started();
         if (!this.lockManager.acquireLock()) {
             this.eventLogger.log('Another guard auto manager instance detected. Exiting.');
+            m_start.success();
             return false;
         }
         this.lockManager.writePidFile();
@@ -68,6 +86,7 @@ class GuardAutoManagerService {
         this._startReminder();
         this.monitorLoop.start();
         this.registerProcessHooks();
+        m_start.success();
         return true;
     }
 

package/scripts/hooks-system/application/services/guard/GuardConfig.js

@@ -1,5 +1,15 @@
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class GuardConfig {
     constructor(env = process.env) {
+        const m_constructor = createMetricScope({
+            hook: 'guard_config',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.healthyReminderIntervalMs = Number(env.GUARD_AUTOSTART_HEALTHY_INTERVAL || 0);
         this.heartbeatNotifyCooldownMs = Number(env.GUARD_AUTOSTART_NOTIFY_COOLDOWN || 60000);
         this.healthyReminderCooldownMs = Number(
@@ -9,6 +19,7 @@ class GuardConfig {
         this.monitorIntervalMs = Number(env.GUARD_AUTOSTART_MONITOR_INTERVAL || 5000);
         this.restartCooldownMs = Number(env.GUARD_AUTOSTART_RESTART_COOLDOWN || 2000);
         this.stopSupervisorOnExit = env.GUARD_AUTOSTART_STOP_SUPERVISOR_ON_EXIT !== 'false';
+        m_constructor.success();
     }
 }
 

package/scripts/hooks-system/application/services/guard/GuardEventLogger.js

@@ -1,12 +1,22 @@
 const fs = require('fs');
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class GuardEventLogger {
     constructor({
         repoRoot = process.cwd(),
         logger = console,
         fsModule = fs
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'guard_event_logger',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.logger = logger;
         this.fs = fsModule;
@@ -26,6 +36,7 @@ class GuardEventLogger {
                 this.logger.debug('GUARD_EVENT_LOGGER_INIT_ERROR', { error: error.message });
             }
         }
+        m_constructor.success();
     }
 
     log(message, data = {}) {

package/scripts/hooks-system/application/services/guard/GuardHealthReminder.js

@@ -1,17 +1,35 @@
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class GuardHealthReminder {
     constructor(timers, notificationHandler, config) {
+        const m_constructor = createMetricScope({
+            hook: 'guard_health_reminder',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.timers = timers;
         this.notificationHandler = notificationHandler;
         this.config = config;
         this.timer = null;
         this.lastReminderAt = 0;
+        m_constructor.success();
     }
 
     start(checkHealthCallback) {
+        const m_start = createMetricScope({
+            hook: 'guard_health_reminder',
+            operation: 'start'
+        });
+
+        m_start.started();
         this.stop();
 
         const { healthyReminderIntervalMs } = this.config;
         if (!Number.isFinite(healthyReminderIntervalMs) || healthyReminderIntervalMs <= 0) {
+            m_start.success();
             return;
         }
 
@@ -22,13 +40,21 @@ class GuardHealthReminder {
         if (this.timer && typeof this.timer.unref === 'function') {
             this.timer.unref();
         }
+        m_start.success();
     }
 
     stop() {
+        const m_stop = createMetricScope({
+            hook: 'guard_health_reminder',
+            operation: 'stop'
+        });
+
+        m_stop.started();
         if (this.timer) {
             this.timers.clearInterval(this.timer);
             this.timer = null;
         }
+        m_stop.success();
     }
 
     _tick(checkHealthCallback) {

package/scripts/hooks-system/application/services/guard/GuardHeartbeatMonitor.js

@@ -1,6 +1,10 @@
 const fs = require('fs');
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class GuardHeartbeatMonitor {
     constructor({
         repoRoot = process.cwd(),
@@ -8,6 +12,12 @@ class GuardHeartbeatMonitor {
         fsModule = fs,
         env = process.env
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'guard_heartbeat_monitor',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.logger = logger;
         this.fs = fsModule;
@@ -28,6 +38,7 @@ class GuardHeartbeatMonitor {
                 .map(entry => entry.trim().toLowerCase())
                 .filter(Boolean)
         );
+        m_constructor.success();
     }
 
     evaluate() {

package/scripts/hooks-system/application/services/guard/GuardLockManager.js

@@ -1,12 +1,22 @@
 const fs = require('fs');
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class GuardLockManager {
     constructor({
         repoRoot = process.cwd(),
         logger = console,
         fsModule = fs
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'guard_lock_manager',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.logger = logger;
         this.fs = fsModule;
@@ -26,6 +36,7 @@ class GuardLockManager {
                 this.logger.debug('GUARD_LOCK_MANAGER_INIT_DEBUG', { error: error.message });
             }
         }
+        m_constructor.success();
     }
 
     acquireLock() {

package/scripts/hooks-system/application/services/guard/GuardMonitorLoop.js

@@ -1,13 +1,30 @@
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class GuardMonitorLoop {
     constructor(timers, intervalMs, tickCallback, logger) {
+        const m_constructor = createMetricScope({
+            hook: 'guard_monitor_loop',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.timers = timers;
         this.intervalMs = intervalMs;
         this.tickCallback = tickCallback;
         this.logger = logger;
         this.timer = null;
+        m_constructor.success();
     }
 
     start() {
+        const m_start = createMetricScope({
+            hook: 'guard_monitor_loop',
+            operation: 'start'
+        });
+
+        m_start.started();
         this.stop();
         this.timer = this.timers.setInterval(() => {
             try {
@@ -16,13 +33,21 @@ class GuardMonitorLoop {
                 this.logger.log(`Monitor error: ${error.message}`);
             }
         }, this.intervalMs);
+        m_start.success();
     }
 
     stop() {
+        const m_stop = createMetricScope({
+            hook: 'guard_monitor_loop',
+            operation: 'stop'
+        });
+
+        m_stop.started();
         if (this.timer) {
             this.timers.clearInterval(this.timer);
             this.timer = null;
         }
+        m_stop.success();
     }
 }