pumuki-ast-hooks 5.3.19 → 5.3.20

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,6 +1,10 @@
 const path = require('path');
 const { spawnSync } = require('child_process');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class GuardProcessManager {
     constructor({
         repoRoot = process.cwd(),
@@ -8,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;
@@ -15,6 +25,7 @@ class GuardProcessManager {
 
         this.supervisorPidFile = path.join(this.repoRoot, '.guard-supervisor.pid');
         this.startScript = path.join(this.repoRoot, 'bin', 'start-guards.sh');
+        m_constructor.success();
     }
 
     isSupervisorRunning() {

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,6 +2,10 @@ const fs = require('fs');
 const path = require('path');
 const { execSync, spawnSync } = require('child_process');
 
+const {
+  createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 const COLORS = {
   reset: '\x1b[0m',
   blue: '\x1b[34m',
@@ -13,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() {
@@ -88,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}

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

@@ -4,6 +4,10 @@ const { execSync } = require('child_process');
 const crypto = require('crypto');
 const os = require('os');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 const COLORS = {
     reset: '\x1b[0m',
     green: '\x1b[32m',
@@ -42,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() {

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

@@ -1,8 +1,18 @@
 const fs = require('fs');
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class VSCodeTaskConfigurator {
     constructor(targetRoot, logger = null) {
+        const m_constructor = createMetricScope({
+            hook: 'vscode_task_configurator',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.targetRoot = targetRoot;
         this.logger = logger;
         this.COLORS = {
@@ -11,6 +21,7 @@ class VSCodeTaskConfigurator {
             yellow: '\x1b[33m',
             cyan: '\x1b[36m'
         };
+        m_constructor.success();
     }
 
     configure() {

package/scripts/hooks-system/application/services/logging/AuditLogger.js

@@ -4,6 +4,10 @@ const path = require('path');
 // Import recordMetric for prometheus metrics
 const { recordMetric } = require('../../../infrastructure/telemetry/metrics-logger');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class AuditLogger {
     /**
      * @param {Object} options

package/scripts/hooks-system/application/services/logging/UnifiedLogger.js

@@ -2,6 +2,10 @@ const fs = require('fs');
 const path = require('path');
 const { ConfigurationError } = require('../../../domain/errors');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class UnifiedLogger {
     constructor({
         component = 'HookSystem',
@@ -9,6 +13,12 @@ class UnifiedLogger {
         file: fileConfig = { enabled: false },
         defaultData = {}
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'unified_logger',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.component = component;
         this.consoleConfig = {
             enabled: consoleConfig.enabled !== false,
@@ -41,6 +51,7 @@ class UnifiedLogger {
                 // Directory creation might fail if race condition, can be ignored as next write will retry or fail
             }
         }
+        m_constructor.success();
     }
 
     debug(event, data = {}, context = {}) {

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

@@ -1,22 +1,40 @@
 const fs = require('fs');
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class ActivityMonitor {
     constructor({
         repoRoot = process.cwd(),
         inactivityGraceMs = 420000, // 7 minutes
         logger = console
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'activity_monitor',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.inactivityGraceMs = inactivityGraceMs;
         this.logger = logger;
         this.lastUserActivityAt = Date.now();
         this.watcher = null;
         this.debounceTimer = null;
+        m_constructor.success();
     }
 
     start() {
+        const m_start = createMetricScope({
+            hook: 'activity_monitor',
+            operation: 'start'
+        });
+
+        m_start.started();
         if (this.watcher) {
+            m_start.success();
             return;
         }
 
@@ -42,9 +60,16 @@ class ActivityMonitor {
         } catch (error) {
             this.logger.error('[ActivityMonitor] Failed to start watcher:', { error: error.message });
         }
+        m_start.success();
     }
 
     stop() {
+        const m_stop = createMetricScope({
+            hook: 'activity_monitor',
+            operation: 'stop'
+        });
+
+        m_stop.started();
         if (this.watcher) {
             this.watcher.close();
             this.watcher = null;
@@ -53,6 +78,7 @@ class ActivityMonitor {
             clearTimeout(this.debounceTimer);
             this.debounceTimer = null;
         }
+        m_stop.success();
     }
 
     recordActivity(source = 'unknown') {
@@ -73,6 +99,13 @@ class ActivityMonitor {
     }
 
     getLastActivityTime() {
+        const m_get_last_activity_time = createMetricScope({
+            hook: 'activity_monitor',
+            operation: 'get_last_activity_time'
+        });
+
+        m_get_last_activity_time.started();
+        m_get_last_activity_time.success();
         return this.lastUserActivityAt;
     }
 }

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

@@ -2,6 +2,10 @@ const fs = require('fs');
 const path = require('path');
 const { spawn } = require('child_process');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class AstMonitor {
     constructor({
         repoRoot = process.cwd(),
@@ -11,6 +15,12 @@ class AstMonitor {
         logger = console,
         notificationService = null
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'ast_monitor',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.debounceMs = debounceMs;
         this.cooldownMs = cooldownMs;
@@ -26,15 +36,24 @@ class AstMonitor {
         this.evidencePath = path.join(repoRoot, '.AI_EVIDENCE.json');
         this.tempDir = path.join(repoRoot, '.audit_tmp');
         this.astScript = path.join(repoRoot, 'infrastructure', 'ast', 'ast-intelligence.js');
+        m_constructor.success();
     }
 
     start() {
+        const m_start = createMetricScope({
+            hook: 'ast_monitor',
+            operation: 'start'
+        });
+
+        m_start.started();
         if (!this.enabled) {
             this.logger.info('[AstMonitor] AST Watch disabled');
+            m_start.success();
             return;
         }
 
         if (this.watcher) {
+            m_start.success();
             return;
         }
 
@@ -58,9 +77,16 @@ class AstMonitor {
         } catch (error) {
             this.logger.error('[AstMonitor] Failed to start watchers:', { error: error.message });
         }
+        m_start.success();
     }
 
     stop() {
+        const m_stop = createMetricScope({
+            hook: 'ast_monitor',
+            operation: 'stop'
+        });
+
+        m_stop.started();
         // fs.watch returns FSWatcher which has close(). 
         // Since we might have multiple watchers (one per dir), we should track them if we want to close properly.
         // For simplicity in this iteration, we assume the process exit handles it, or we rely on the debounce timer clear.
@@ -70,6 +96,7 @@ class AstMonitor {
             this.timer = null;
         }
         // Ideally we would close all FSWatchers here
+        m_stop.success();
     }
 
     scheduleAnalysis() {