pumuki-ast-hooks 5.3.18 → 5.3.20

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,30 +1,44 @@
 const fs = require('fs');
 const path = require('path');
-const env = require('../../../config/env');
+
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
 
 class GuardHeartbeatMonitor {
     constructor({
         repoRoot = process.cwd(),
         logger = console,
-        fsModule = fs
+        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;
-        const heartbeatRelative = env.get('HOOK_GUARD_HEARTBEAT_PATH', path.join('.audit_tmp', 'guard-heartbeat.json'));
+        this.env = env;
+
+        const heartbeatRelative = env.HOOK_GUARD_HEARTBEAT_PATH || path.join('.audit_tmp', 'guard-heartbeat.json');
         this.heartbeatPath = path.isAbsolute(heartbeatRelative)
             ? heartbeatRelative
             : path.join(this.repoRoot, heartbeatRelative);
 
-        this.heartbeatMaxAgeMs = env.getNumber('GUARD_AUTOSTART_HEARTBEAT_MAX_AGE',
-            env.getNumber('HOOK_GUARD_HEARTBEAT_MAX_AGE', 60000));
+        this.heartbeatMaxAgeMs = Number(
+            env.GUARD_AUTOSTART_HEARTBEAT_MAX_AGE || env.HOOK_GUARD_HEARTBEAT_MAX_AGE || 60000
+        );
 
         this.heartbeatRestartReasons = new Set(
-            (env.get('GUARD_AUTOSTART_HEARTBEAT_RESTART', 'missing,stale,invalid,degraded'))
+            (env.GUARD_AUTOSTART_HEARTBEAT_RESTART || 'missing,stale,invalid,degraded')
                 .split(',')
                 .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();
     }
 }
 

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

@@ -1,9 +1,20 @@
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class GuardNotificationHandler {
     constructor(notificationCenter, eventLogger, config) {
+        const m_constructor = createMetricScope({
+            hook: 'guard_notification_handler',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.notificationCenter = notificationCenter;
         this.eventLogger = eventLogger;
         this.config = config;
         this.lastNotificationState = { reason: null, at: 0 };
+        m_constructor.success();
     }
 
     notify(message, level = 'info', options = {}) {

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

@@ -1,8 +1,9 @@
 const path = require('path');
 const { spawnSync } = require('child_process');
 
-// Import AuditLogger for logging critical operations
-const AuditLogger = require('../logging/AuditLogger');
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
 
 class GuardProcessManager {
     constructor({
@@ -11,6 +12,12 @@ class GuardProcessManager {
         fsModule = require('fs'),
         childProcess = { spawnSync }
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'guard_process_manager',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.logger = logger;
         this.fs = fsModule;
@@ -18,10 +25,7 @@ class GuardProcessManager {
 
         this.supervisorPidFile = path.join(this.repoRoot, '.guard-supervisor.pid');
         this.startScript = path.join(this.repoRoot, 'bin', 'start-guards.sh');
-        this.busy = false;
-
-        // Initialize audit logger
-        this.auditLogger = new AuditLogger({ repoRoot, logger: this.logger });
+        m_constructor.success();
     }
 
     isSupervisorRunning() {
@@ -65,15 +69,6 @@ class GuardProcessManager {
     }
 
     startSupervisor() {
-        if (this.busy) {
-            return {
-                success: false,
-                error: new Error('bulkhead_busy'),
-                stdout: '',
-                stderr: 'bulkhead_busy'
-            };
-        }
-        this.busy = true;
         try {
             const result = this.childProcess.spawnSync(this.startScript, ['start'], {
                 cwd: this.repoRoot,
@@ -96,21 +91,10 @@ class GuardProcessManager {
                 stdout: '',
                 stderr: error.message
             };
-        } finally {
-            this.busy = false;
         }
     }
 
     stopSupervisor() {
-        if (this.busy) {
-            return {
-                success: false,
-                error: new Error('bulkhead_busy'),
-                stdout: '',
-                stderr: 'bulkhead_busy'
-            };
-        }
-        this.busy = true;
         try {
             const result = this.childProcess.spawnSync(this.startScript, ['stop'], {
                 cwd: this.repoRoot,
@@ -133,8 +117,6 @@ class GuardProcessManager {
                 stdout: '',
                 stderr: error.message
             };
-        } finally {
-            this.busy = false;
         }
     }
 }

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

@@ -1,3 +1,7 @@
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class GuardRecoveryService {
     constructor({
         repoRoot,
@@ -6,12 +10,19 @@ class GuardRecoveryService {
         notificationHandler,
         restartCooldownMs = 2000
     }) {
+        const m_constructor = createMetricScope({
+            hook: 'guard_recovery_service',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.logger = logger;
         this.startScript = startScript;
         this.notificationHandler = notificationHandler;
         this.restartCooldownMs = restartCooldownMs;
         this.lastEnsure = 0;
+        m_constructor.success();
     }
 
     ensureSupervisor(reason, eventLogger) {

package/scripts/hooks-system/application/services/installation/ConfigurationGeneratorService.js

@@ -1,6 +1,10 @@
 const fs = require('fs');
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 const COLORS = {
     reset: '\x1b[0m',
     green: '\x1b[32m',
@@ -10,11 +14,24 @@ const COLORS = {
 
 class ConfigurationGeneratorService {
     constructor(targetRoot, hookSystemRoot) {
+        const m_constructor = createMetricScope({
+            hook: 'configuration_generator_service',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.targetRoot = targetRoot || process.cwd();
         this.hookSystemRoot = hookSystemRoot;
+        m_constructor.success();
     }
 
     createProjectConfig(platforms) {
+        const m_create_project_config = createMetricScope({
+            hook: 'configuration_generator_service',
+            operation: 'create_project_config'
+        });
+
+        m_create_project_config.started();
         const config = {
             version: '3.1.0',
             project: {
@@ -73,6 +90,7 @@ class ConfigurationGeneratorService {
 
         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
         this.logSuccess('Configuration created');
+        m_create_project_config.success();
     }
 
     installESLintConfigs() {

package/scripts/hooks-system/application/services/installation/FileSystemInstallerService.js

@@ -1,6 +1,10 @@
 const fs = require('fs');
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 const COLORS = {
     reset: '\x1b[0m',
     green: '\x1b[32m',
@@ -9,12 +13,25 @@ const COLORS = {
 
 class FileSystemInstallerService {
     constructor(targetRoot, hookSystemRoot, logger = null) {
+        const m_constructor = createMetricScope({
+            hook: 'file_system_installer_service',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.targetRoot = targetRoot || process.cwd();
         this.hookSystemRoot = hookSystemRoot;
         this.logger = logger;
+        m_constructor.success();
     }
 
     createDirectoryStructure() {
+        const m_create_directory_structure = createMetricScope({
+            hook: 'file_system_installer_service',
+            operation: 'create_directory_structure'
+        });
+
+        m_create_directory_structure.started();
         const dirs = [
             'scripts/hooks-system',
             'scripts/hooks-system/docs',
@@ -29,6 +46,7 @@ class FileSystemInstallerService {
             }
         });
         this.logSuccess('Directory structure created');
+        m_create_directory_structure.success();
     }
 
     copySystemFiles() {

package/scripts/hooks-system/application/services/installation/GitEnvironmentService.js

@@ -2,8 +2,9 @@ const fs = require('fs');
 const path = require('path');
 const { execSync, spawnSync } = require('child_process');
 
-// Import recordMetric for prometheus metrics
-const { recordMetric } = require('../../../infrastructure/telemetry/metrics-logger');
+const {
+  createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
 
 const COLORS = {
   reset: '\x1b[0m',
@@ -16,8 +17,15 @@ const COLORS = {
 
 class GitEnvironmentService {
   constructor(targetRoot, version = 'unknown') {
+    const m_constructor = createMetricScope({
+      hook: 'git_environment_service',
+      operation: 'constructor'
+    });
+
+    m_constructor.started();
     this.targetRoot = targetRoot || process.cwd();
     this.version = version;
+    m_constructor.success();
   }
 
   checkGitRepository() {
@@ -91,6 +99,13 @@ class GitEnvironmentService {
   }
 
   getPreCommitHookContent() {
+    const m_get_pre_commit_hook_content = createMetricScope({
+      hook: 'git_environment_service',
+      operation: 'get_pre_commit_hook_content'
+    });
+
+    m_get_pre_commit_hook_content.started();
+    m_get_pre_commit_hook_content.success();
     return `#!/bin/bash
 # AST Intelligence Hooks - Pre-commit
 # Auto-generated by pumuki-ast-hooks v${this.version}
@@ -113,7 +128,7 @@ fi
 
 # Try node_modules/.bin first (works with npm install)
 if [ -f "node_modules/.bin/ast-hooks" ]; then
-  OUTPUT=$(node_modules/.bin/ast-hooks ast --staged 2>&1)
+  OUTPUT=$(node_modules/.bin/ast-hooks ast 2>&1)
   EXIT_CODE=$?
   echo "$OUTPUT"
   if [ $EXIT_CODE -ne 0 ]; then

package/scripts/hooks-system/application/services/installation/HookInstaller.js

@@ -1,8 +1,18 @@
 const fs = require('fs');
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class HookInstaller {
     constructor(targetRoot, hookSystemRoot, logger = null) {
+        const m_constructor = createMetricScope({
+            hook: 'hook_installer',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.targetRoot = targetRoot;
         this.hookSystemRoot = hookSystemRoot;
         this.logger = logger;
@@ -12,6 +22,7 @@ class HookInstaller {
             yellow: '\x1b[33m',
             cyan: '\x1b[36m'
         };
+        m_constructor.success();
     }
 
     install(platforms) {
@@ -128,6 +139,12 @@ class HookInstaller {
     }
 
     getRelevantSkills(platforms) {
+        const m_get_relevant_skills = createMetricScope({
+            hook: 'hook_installer',
+            operation: 'get_relevant_skills'
+        });
+
+        m_get_relevant_skills.started();
         const allSkills = ['backend-guidelines', 'frontend-guidelines', 'ios-guidelines', 'android-guidelines'];
         const relevantSkills = [];
 
@@ -136,6 +153,8 @@ class HookInstaller {
         if (platforms.includes('ios')) relevantSkills.push('ios-guidelines');
         if (platforms.includes('android')) relevantSkills.push('android-guidelines');
 
+        m_get_relevant_skills.success();
+
         return relevantSkills.length > 0 ? relevantSkills : allSkills;
     }
 

package/scripts/hooks-system/application/services/installation/IdeIntegrationService.js

@@ -2,6 +2,10 @@ const McpConfigurator = require('./McpConfigurator');
 const HookInstaller = require('./HookInstaller');
 const VSCodeTaskConfigurator = require('./VSCodeTaskConfigurator');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 const COLORS = {
     reset: '\x1b[0m',
     green: '\x1b[32m',
@@ -11,6 +15,12 @@ const COLORS = {
 
 class IdeIntegrationService {
     constructor(targetRoot, hookSystemRoot, logger = null) {
+        const m_constructor = createMetricScope({
+            hook: 'ide_integration_service',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.targetRoot = targetRoot || process.cwd();
         this.hookSystemRoot = hookSystemRoot;
         this.logger = logger;
@@ -18,6 +28,7 @@ class IdeIntegrationService {
         this.mcpConfigurator = new McpConfigurator(this.targetRoot, this.hookSystemRoot, this.logger);
         this.hookInstaller = new HookInstaller(this.targetRoot, this.hookSystemRoot, this.logger);
         this.vscodeConfigurator = new VSCodeTaskConfigurator(this.targetRoot, this.logger);
+        m_constructor.success();
     }
 
     installCursorHooks(platforms) {

package/scripts/hooks-system/application/services/installation/InstallService.js

@@ -8,6 +8,10 @@ const ConfigurationGeneratorService = require('./ConfigurationGeneratorService')
 const IdeIntegrationService = require('./IdeIntegrationService');
 const UnifiedLogger = require('../logging/UnifiedLogger');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 const COLORS = {
     reset: '\x1b[0m',
     blue: '\x1b[34m',
@@ -19,6 +23,12 @@ const COLORS = {
 
 class InstallService {
     constructor() {
+        const m_constructor = createMetricScope({
+            hook: 'install_service',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.targetRoot = process.cwd();
         // Assuming this script is located at scripts/hooks-system/application/services/installation/InstallService.js
         this.hookSystemRoot = path.resolve(__dirname, '../../../');
@@ -30,7 +40,13 @@ class InstallService {
             path.resolve(this.hookSystemRoot, '../package.json'),
             path.resolve(this.hookSystemRoot, '../../package.json'),
             (() => {
-                try { return require.resolve('pumuki-ast-hooks/package.json'); } catch { return null; }
+                try {
+                    m_constructor.success();
+                    return require.resolve('pumuki-ast-hooks/package.json');
+                } catch {
+                    m_constructor.success();
+                    return null;
+                }
             })()
         ].filter(Boolean);
 
@@ -73,9 +89,16 @@ class InstallService {
         this.fsInstaller = new FileSystemInstallerService(this.targetRoot, this.hookSystemRoot, this.logger);
         this.configGenerator = new ConfigurationGeneratorService(this.targetRoot, this.hookSystemRoot);
         this.ideIntegration = new IdeIntegrationService(this.targetRoot, this.hookSystemRoot, this.logger);
+        m_constructor.success();
     }
 
     async run() {
+        const m_run = createMetricScope({
+            hook: 'install_service',
+            operation: 'run'
+        });
+
+        m_run.started();
         this.logger.info('INSTALLATION_STARTED', { targetRoot: this.targetRoot });
         this.printHeader();
 
@@ -124,6 +147,7 @@ class InstallService {
 
         this.logger.info('INSTALLATION_COMPLETED_SUCCESSFULLY');
         this.printFooter();
+        m_run.success();
     }
 
     printHeader() {

package/scripts/hooks-system/application/services/installation/McpConfigurator.js

@@ -3,7 +3,10 @@ const path = require('path');
 const { execSync } = require('child_process');
 const crypto = require('crypto');
 const os = require('os');
-const env = require('../../config/env');
+
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
 
 const COLORS = {
     reset: '\x1b[0m',
@@ -32,7 +35,7 @@ function computeRepoFingerprint(repoRoot) {
 
 function computeServerIdForRepo(repoRoot) {
     const legacyServerId = 'ast-intelligence-automation';
-    const forced = (env.get('MCP_SERVER_ID', '') || '').trim();
+    const forced = (process.env.MCP_SERVER_ID || '').trim();
     if (forced.length > 0) return forced;
 
     const repoName = path.basename(repoRoot || process.cwd());
@@ -43,12 +46,26 @@ function computeServerIdForRepo(repoRoot) {
 
 class McpConfigurator {
     constructor(targetRoot, hookSystemRoot, logger = null) {
+        const m_constructor = createMetricScope({
+            hook: 'mcp_configurator',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.targetRoot = targetRoot;
         this.hookSystemRoot = hookSystemRoot;
         this.logger = logger;
+        m_constructor.success();
     }
 
     getGlobalWindsurfConfigPath() {
+        const m_get_global_windsurf_config_path = createMetricScope({
+            hook: 'mcp_configurator',
+            operation: 'get_global_windsurf_config_path'
+        });
+
+        m_get_global_windsurf_config_path.started();
+        m_get_global_windsurf_config_path.success();
         return path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json');
     }
 

package/scripts/hooks-system/application/services/installation/PlatformDetectorService.js

@@ -1,9 +1,20 @@
 const glob = require('glob');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class PlatformDetectorService {
     constructor(targetRoot) {
+        const m_constructor = createMetricScope({
+            hook: 'platform_detector_service',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.targetRoot = targetRoot || process.cwd();
         this.platforms = [];
+        m_constructor.success();
     }
 
     detect() {