pumuki-ast-hooks 5.3.18 → 5.3.20

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

@@ -1,6 +1,13 @@
 const fs = require('fs');
 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
@@ -9,6 +16,13 @@ class AuditLogger {
      * @param {Object} [options.logger=console] - fallback logger for warnings
      */
     constructor({ repoRoot = process.cwd(), filename, logger = console } = {}) {
+        recordMetric({
+            hook: 'audit_logger',
+            operation: 'constructor',
+            status: 'started',
+            repoRoot: repoRoot.substring(0, 100)
+        });
+
         this.repoRoot = repoRoot;
         this.logger = logger;
         this.logPath = filename
@@ -16,9 +30,22 @@ class AuditLogger {
             : path.join(repoRoot, '.audit_tmp', 'audit.log');
 
         this.ensureDir();
+
+        recordMetric({
+            hook: 'audit_logger',
+            operation: 'constructor',
+            status: 'success',
+            repoRoot: repoRoot.substring(0, 100)
+        });
     }
 
     ensureDir() {
+        recordMetric({
+            hook: 'audit_logger',
+            operation: 'ensure_dir',
+            status: 'started'
+        });
+
         try {
             const dir = path.dirname(this.logPath);
             if (!fs.existsSync(dir)) {
@@ -30,14 +57,33 @@ class AuditLogger {
         } catch (error) {
             this.warn('AUDIT_LOGGER_INIT_ERROR', error);
         }
+
+        recordMetric({
+            hook: 'audit_logger',
+            operation: 'ensure_dir',
+            status: 'success'
+        });
     }
 
     warn(message, error) {
+        recordMetric({
+            hook: 'audit_logger',
+            operation: 'warn',
+            status: 'started',
+            message: message
+        });
+
         if (this.logger?.warn) {
             this.logger.warn(message, { error: error?.message });
         } else {
             console.warn(message, error?.message);
         }
+
+        recordMetric({
+            hook: 'audit_logger',
+            operation: 'warn',
+            status: 'success'
+        });
     }
 
     /**
@@ -50,7 +96,22 @@ class AuditLogger {
      * @param {string|null} [entry.correlationId=null]
      */
     record(entry = {}) {
-        if (!entry.action) return;
+        recordMetric({
+            hook: 'audit_logger',
+            operation: 'record',
+            status: 'started',
+            action: entry.action
+        });
+
+        if (!entry.action) {
+            recordMetric({
+                hook: 'audit_logger',
+                operation: 'record',
+                status: 'success',
+                reason: 'no_action'
+            });
+            return;
+        }
         const safeMeta = this.sanitizeMeta(entry.meta || {});
 
         const payload = {
@@ -65,12 +126,32 @@ class AuditLogger {
 
         try {
             fs.appendFileSync(this.logPath, `${JSON.stringify(payload)}\n`, { encoding: 'utf8' });
+            recordMetric({
+                hook: 'audit_logger',
+                operation: 'record',
+                status: 'success',
+                action: entry.action
+            });
         } catch (error) {
             this.warn('AUDIT_LOGGER_WRITE_ERROR', error);
+            recordMetric({
+                hook: 'audit_logger',
+                operation: 'record',
+                status: 'failed',
+                action: entry.action,
+                error: error.message
+            });
         }
     }
 
     sanitizeMeta(meta) {
+        recordMetric({
+            hook: 'audit_logger',
+            operation: 'sanitize_meta',
+            status: 'started',
+            metaKeys: Object.keys(meta || {}).length
+        });
+
         const forbidden = ['token', 'password', 'secret', 'authorization', 'auth', 'apiKey'];
         const clone = {};
         Object.entries(meta).forEach(([k, v]) => {
@@ -81,6 +162,14 @@ class AuditLogger {
                 clone[k] = v;
             }
         });
+
+        recordMetric({
+            hook: 'audit_logger',
+            operation: 'sanitize_meta',
+            status: 'success',
+            metaKeys: Object.keys(clone).length
+        });
+
         return clone;
     }
 }

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 = {}) {
@@ -97,19 +108,10 @@ class UnifiedLogger {
             this.rotateFileIfNeeded();
             fs.appendFileSync(this.fileConfig.path, `${JSON.stringify(entry)}\n`, 'utf8');
         } catch (error) {
-            try {
-                const env = require('../../../config/env');
-                if (env.getBool('DEBUG', false)) {
-                    console.error('[UnifiedLogger] Failed to write log file', {
-                        path: this.fileConfig.path,
-                        error: error.message
-                    });
-                } else {
-                    console.warn('[UnifiedLogger] File logging skipped due to error');
-                }
-            } catch (secondaryError) {
-                console.error('[UnifiedLogger] Secondary logging failure', {
-                    error: secondaryError.message
+            if (process.env.DEBUG) {
+                console.error('[UnifiedLogger] Failed to write log file', {
+                    path: this.fileConfig.path,
+                    error: error.message
                 });
             }
         }

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

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,11 +24,13 @@ 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() {
         const candidates = [
             path.join(this.repoRoot, 'node_modules/@pumuki/ast-intelligence-hooks/bin/update-evidence.sh'),
+            path.join(this.repoRoot, 'scripts/hooks-system/bin/update-evidence.sh'),
             path.join(this.repoRoot, 'bin/update-evidence.sh')
         ];
 
@@ -93,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

@@ -1,10 +1,10 @@
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
-const env = require('../../config/env');
 
-// Import recordMetric for prometheus metrics
-const { recordMetric } = require('../../../infrastructure/telemetry/metrics-logger');
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
 
 function resolveUpdateEvidenceScript(repoRoot) {
     const candidates = [
@@ -29,12 +29,18 @@ class EvidenceMonitorService {
         updateScriptPath = resolveUpdateEvidenceScript(repoRoot) || path.join(process.cwd(), 'scripts', 'hooks-system', 'bin', 'update-evidence.sh'),
         notifier = () => { },
         logger = console,
-        autoRefreshEnabled = env.getBool('HOOK_GUARD_AUTO_REFRESH', true),
-        autoRefreshCooldownMs = env.getNumber('HOOK_GUARD_AUTO_REFRESH_COOLDOWN', 180000),
-        staleThresholdMs = env.getNumber('HOOK_GUARD_EVIDENCE_STALE_THRESHOLD', 10 * 60 * 1000),
+        autoRefreshEnabled = process.env.HOOK_GUARD_AUTO_REFRESH !== 'false',
+        autoRefreshCooldownMs = Number(process.env.HOOK_GUARD_AUTO_REFRESH_COOLDOWN || 180000),
+        staleThresholdMs = Number(process.env.HOOK_GUARD_EVIDENCE_STALE_THRESHOLD || 10 * 60 * 1000),
         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;
@@ -47,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();
@@ -63,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() {