pumuki-ast-hooks 5.3.20 → 5.3.22

package/scripts/hooks-system/application/CompositionRoot.js

@@ -21,9 +21,11 @@ const TokenMonitor = require('./services/monitoring/TokenMonitor');
 const ActivityMonitor = require('./services/monitoring/ActivityMonitor');
 const DevDocsMonitor = require('./services/monitoring/DevDocsMonitor');
 const AstMonitor = require('./services/monitoring/AstMonitor');
+const AuditLogger = require('./services/logging/AuditLogger');
 
 const path = require('path');
 const fs = require('fs');
+const env = require('../config/env');
 
 class CompositionRoot {
     constructor(repoRoot) {
@@ -51,7 +53,7 @@ class CompositionRoot {
                 file: {
                     enabled: true,
                     path: path.join(this.auditDir, 'guard-audit.jsonl'),
-                    level: process.env.HOOK_LOG_LEVEL || 'info'
+                    level: env.get('HOOK_LOG_LEVEL', env.isProd ? 'warn' : 'info')
                 },
                 console: {
                     enabled: false,
@@ -73,6 +75,18 @@ class CompositionRoot {
         return this.instances.get('notificationService');
     }
 
+    getAuditLogger() {
+        if (!this.instances.has('auditLogger')) {
+            const logger = this.getLogger();
+            this.instances.set('auditLogger', new AuditLogger({
+                repoRoot: this.repoRoot,
+                filename: path.join('.audit_tmp', 'audit.log'),
+                logger
+            }));
+        }
+        return this.instances.get('auditLogger');
+    }
+
     // --- Infrastructure Adapters ---
 
     getNotificationAdapter() {
@@ -183,9 +197,9 @@ class CompositionRoot {
     getEvidenceMonitor() {
         if (!this.instances.has('evidenceMonitor')) {
             this.instances.set('evidenceMonitor', new EvidenceMonitor(this.repoRoot, {
-                staleThresholdMs: Number(process.env.HOOK_GUARD_EVIDENCE_STALE_THRESHOLD || 180000),
-                pollIntervalMs: Number(process.env.HOOK_GUARD_EVIDENCE_POLL_INTERVAL || 30000),
-                reminderIntervalMs: Number(process.env.HOOK_GUARD_EVIDENCE_REMINDER_INTERVAL || 60000)
+                staleThresholdMs: env.getNumber('HOOK_GUARD_EVIDENCE_STALE_THRESHOLD', 180000),
+                pollIntervalMs: env.getNumber('HOOK_GUARD_EVIDENCE_POLL_INTERVAL', 30000),
+                reminderIntervalMs: env.getNumber('HOOK_GUARD_EVIDENCE_REMINDER_INTERVAL', 60000)
             }));
         }
         return this.instances.get('evidenceMonitor');
@@ -194,11 +208,11 @@ class CompositionRoot {
     getGitTreeMonitor() {
         if (!this.instances.has('gitTreeMonitor')) {
             this.instances.set('gitTreeMonitor', new GitTreeMonitor(this.repoRoot, {
-                stagedThreshold: Number(process.env.HOOK_GUARD_DIRTY_TREE_STAGED_LIMIT || 10),
-                unstagedThreshold: Number(process.env.HOOK_GUARD_DIRTY_TREE_UNSTAGED_LIMIT || 15),
-                totalThreshold: Number(process.env.HOOK_GUARD_DIRTY_TREE_TOTAL_LIMIT || 20),
-                checkIntervalMs: Number(process.env.HOOK_GUARD_DIRTY_TREE_INTERVAL || 60000),
-                reminderMs: Number(process.env.HOOK_GUARD_DIRTY_TREE_REMINDER || 300000)
+                stagedThreshold: env.getNumber('HOOK_GUARD_DIRTY_TREE_STAGED_LIMIT', 10),
+                unstagedThreshold: env.getNumber('HOOK_GUARD_DIRTY_TREE_UNSTAGED_LIMIT', 15),
+                totalThreshold: env.getNumber('HOOK_GUARD_DIRTY_TREE_TOTAL_LIMIT', 20),
+                checkIntervalMs: env.getNumber('HOOK_GUARD_DIRTY_TREE_INTERVAL', 60000),
+                reminderMs: env.getNumber('HOOK_GUARD_DIRTY_TREE_REMINDER', 300000)
             }));
         }
         return this.instances.get('gitTreeMonitor');
@@ -219,11 +233,11 @@ class CompositionRoot {
             const github = this.getGitHubAdapter();
 
             this.instances.set('gitFlowService', new GitFlowService(this.repoRoot, {
-                developBranch: process.env.HOOK_GUARD_GITFLOW_DEVELOP_BRANCH || 'develop',
-                mainBranch: process.env.HOOK_GUARD_GITFLOW_MAIN_BRANCH || 'main',
-                autoSyncEnabled: process.env.HOOK_GUARD_GITFLOW_AUTOSYNC !== 'false',
-                autoCleanEnabled: process.env.HOOK_GUARD_GITFLOW_AUTOCLEAN !== 'false',
-                requireClean: process.env.HOOK_GUARD_GITFLOW_REQUIRE_CLEAN !== 'false'
+                developBranch: env.get('HOOK_GUARD_GITFLOW_DEVELOP_BRANCH', 'develop'),
+                mainBranch: env.get('HOOK_GUARD_GITFLOW_MAIN_BRANCH', 'main'),
+                autoSyncEnabled: env.getBool('HOOK_GUARD_GITFLOW_AUTOSYNC', true),
+                autoCleanEnabled: env.getBool('HOOK_GUARD_GITFLOW_AUTOCLEAN', true),
+                requireClean: env.getBool('HOOK_GUARD_GITFLOW_REQUIRE_CLEAN', true)
             }, logger, gitQuery, gitCommand, github));
         }
         return this.instances.get('gitFlowService');
@@ -234,7 +248,7 @@ class CompositionRoot {
             const logger = this.getLogger();
             this.instances.set('activityMonitor', new ActivityMonitor({
                 repoRoot: this.repoRoot,
-                inactivityGraceMs: Number(process.env.HOOK_GUARD_INACTIVITY_GRACE_MS || 420000),
+                inactivityGraceMs: env.getNumber('HOOK_GUARD_INACTIVITY_GRACE_MS', 420000),
                 logger
             }));
         }
@@ -247,9 +261,9 @@ class CompositionRoot {
             const notificationService = this.getNotificationService();
             this.instances.set('devDocsMonitor', new DevDocsMonitor({
                 repoRoot: this.repoRoot,
-                checkIntervalMs: Number(process.env.HOOK_GUARD_DEV_DOCS_CHECK_INTERVAL || 300000),
-                staleThresholdMs: Number(process.env.HOOK_GUARD_DEV_DOCS_STALE_THRESHOLD || 86400000),
-                autoRefreshEnabled: process.env.HOOK_GUARD_DEV_DOCS_AUTO_REFRESH !== 'false',
+                checkIntervalMs: env.getNumber('HOOK_GUARD_DEV_DOCS_CHECK_INTERVAL', 300000),
+                staleThresholdMs: env.getNumber('HOOK_GUARD_DEV_DOCS_STALE_THRESHOLD', 86400000),
+                autoRefreshEnabled: env.getBool('HOOK_GUARD_DEV_DOCS_AUTO_REFRESH', true),
                 logger,
                 notificationService
             }));
@@ -263,9 +277,9 @@ class CompositionRoot {
             const notificationService = this.getNotificationService();
             this.instances.set('astMonitor', new AstMonitor({
                 repoRoot: this.repoRoot,
-                debounceMs: Number(process.env.HOOK_AST_WATCH_DEBOUNCE || 8000),
-                cooldownMs: Number(process.env.HOOK_AST_WATCH_COOLDOWN || 30000),
-                enabled: process.env.HOOK_AST_WATCH !== 'false',
+                debounceMs: env.getNumber('HOOK_AST_WATCH_DEBOUNCE', 8000),
+                cooldownMs: env.getNumber('HOOK_AST_WATCH_COOLDOWN', 30000),
+                enabled: env.getBool('HOOK_AST_WATCH', true),
                 logger,
                 notificationService
             }));
@@ -291,6 +305,7 @@ class CompositionRoot {
             const notificationService = this.getNotificationService();
             const monitors = this.getMonitors();
             const orchestrator = this.getOrchestrator();
+            const auditLogger = this.getAuditLogger();
             const config = {
                 debugLogPath: path.join(this.auditDir, 'guard-debug.log'),
                 repoRoot: this.repoRoot
@@ -301,7 +316,8 @@ class CompositionRoot {
                 notificationService,
                 monitors,
                 orchestration: orchestrator,
-                config
+                config,
+                auditLogger
             }));
         }
         return this.instances.get('guardService');

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

@@ -3,18 +3,8 @@ const { execSync } = require('child_process');
 const path = require('path');
 const UnifiedLogger = require('./logging/UnifiedLogger');
 
-const {
-    createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
-
 class AutonomousOrchestrator {
     constructor(contextEngine, platformDetector, rulesLoader, logger = new UnifiedLogger()) {
-        const m_constructor = createMetricScope({
-            hook: 'autonomous_orchestrator',
-            operation: 'constructor'
-        });
-
-        m_constructor.started();
         this.contextEngine = contextEngine;
         this.platformDetector = platformDetector || new PlatformDetectionService();
         this.rulesLoader = rulesLoader;
@@ -25,7 +15,6 @@ class AutonomousOrchestrator {
         };
         this.lastAnalysis = null;
         this.lastAnalysisTime = 0;
-        m_constructor.success();
     }
 
     detectFromASTSystemFiles(files) {
@@ -134,13 +123,6 @@ class AutonomousOrchestrator {
     }
 
     getLastAnalysis() {
-        const m_get_last_analysis = createMetricScope({
-            hook: 'autonomous_orchestrator',
-            operation: 'get_last_analysis'
-        });
-
-        m_get_last_analysis.started();
-        m_get_last_analysis.success();
         return this.lastAnalysis;
     }
 }

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

@@ -1,17 +1,7 @@
 const crypto = require('crypto');
 
-const {
-    createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
-
 class ContextDetectionEngine {
     constructor(repoRootOrGitPort = null, logger = console) {
-        const m_constructor = createMetricScope({
-            hook: 'context_detection_engine',
-            operation: 'constructor'
-        });
-
-        m_constructor.started();
         if (typeof repoRootOrGitPort === 'string') {
             this.repoRoot = repoRootOrGitPort;
             this.git = null;
@@ -26,7 +16,6 @@ class ContextDetectionEngine {
             timestamp: 0,
             ttl: 10000
         };
-        m_constructor.success();
     }
 
     async detectContext() {
@@ -65,74 +54,40 @@ class ContextDetectionEngine {
     }
 
     getStagedFiles() {
-        const m_get_staged_files = createMetricScope({
-            hook: 'context_detection_engine',
-            operation: 'get_staged_files'
-        });
-
-        m_get_staged_files.started();
         try {
-            m_get_staged_files.success();
             return this.git.getStagedFiles();
         } catch (error) {
             this.logger.error('ContextDetectionEngine: Failed to get staged files', error);
-            m_get_staged_files.success();
             return [];
         }
-        m_get_staged_files.success();
     }
 
     getStagedSignature() {
-        const m_get_staged_signature = createMetricScope({
-            hook: 'context_detection_engine',
-            operation: 'get_staged_signature'
-        });
-
-        m_get_staged_signature.started();
         try {
             const patch = this.git.getDiff(true);
             if (!patch) return '';
-            m_get_staged_signature.success();
             return crypto.createHash('sha1').update(patch).digest('hex');
         } catch (error) {
-            m_get_staged_signature.success();
             return '';
         }
-        m_get_staged_signature.success();
     }
 
     getRecentlyModifiedFiles() {
-        const m_get_recently_modified_files = createMetricScope({
-            hook: 'context_detection_engine',
-            operation: 'get_recently_modified_files'
-        });
-
-        m_get_recently_modified_files.started();
         try {
             const output = this.git.getStatusShort();
             if (!output) return [];
 
-            m_get_recently_modified_files.success();
-
             return output
                 .split('\n')
                 .filter(Boolean)
                 .map(line => line.trim().substring(2)) // Remove status code
                 .filter(file => !file.startsWith('.git'));
         } catch (error) {
-            m_get_recently_modified_files.success();
             return [];
         }
-        m_get_recently_modified_files.success();
     }
 
     getRecentCommitPatterns() {
-        const m_get_recent_commit_patterns = createMetricScope({
-            hook: 'context_detection_engine',
-            operation: 'get_recent_commit_patterns'
-        });
-
-        m_get_recent_commit_patterns.started();
         try {
             const output = this.git.getLog(10);
             if (!output) return [];
@@ -161,31 +116,18 @@ class ContextDetectionEngine {
                 commits.push(currentCommit);
             }
 
-            m_get_recent_commit_patterns.success();
-
             return commits.slice(0, 10);
         } catch (error) {
-            m_get_recent_commit_patterns.success();
             return [];
         }
-        m_get_recent_commit_patterns.success();
     }
 
     getCurrentBranch() {
-        const m_get_current_branch = createMetricScope({
-            hook: 'context_detection_engine',
-            operation: 'get_current_branch'
-        });
-
-        m_get_current_branch.started();
         try {
-            m_get_current_branch.success();
             return this.git.getCurrentBranch();
         } catch (error) {
-            m_get_current_branch.success();
             return 'unknown';
         }
-        m_get_current_branch.success();
     }
 
     inferFromGitStatus() {

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

@@ -1,18 +1,9 @@
-const {
-    createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
-
 const fs = require('fs').promises;
 const path = require('path');
+const env = require('../config/env');
 
 class DynamicRulesLoader {
     constructor(rulesDirectory, logger = console) {
-        const m_constructor = createMetricScope({
-            hook: 'dynamic_rules_loader',
-            operation: 'constructor'
-        });
-
-        m_constructor.started();
         this.rulesDirectory = rulesDirectory || null;
         this.logger = logger;
         this.rulesDirectories = this.resolveRulesDirectories();
@@ -28,7 +19,6 @@ class DynamicRulesLoader {
             ttl: 60000
         };
         this.lastLoadWarnings = [];
-        m_constructor.success();
     }
 
     resolveRulesDirectories() {
@@ -38,7 +28,7 @@ class DynamicRulesLoader {
             return [this.rulesDirectory];
         }
 
-        const envRaw = process.env.AST_RULES_DIRECTORIES;
+        const envRaw = env.get('AST_RULES_DIRECTORIES');
         if (envRaw && typeof envRaw === 'string' && envRaw.trim().length > 0) {
             return envRaw
                 .split(',')

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

@@ -1,22 +1,8 @@
 const { execSync, spawnSync } = require('child_process');
 const { ConfigurationError } = require('../../domain/errors');
 
-const { recordMetric } = require('../../../infrastructure/telemetry/metrics-logger');
-
-const {
-    createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
-
 class GitFlowService {
     constructor(repoRoot, options = {}, logger = console, gitQuery = null, gitCommand = null, githubAdapter = null) {
-        recordMetric({
-            hook: 'git_flow_service',
-            operation: 'constructor',
-            status: 'started',
-            repoRoot: repoRoot.substring(0, 100),
-            hasOptions: !!options
-        });
-
         this.repoRoot = repoRoot;
         this.logger = logger;
         this.gitQuery = gitQuery;
@@ -30,16 +16,6 @@ class GitFlowService {
         this.requireClean = options.requireClean !== false;
 
         this._validateDependencies();
-
-        recordMetric({
-            hook: 'git_flow_service',
-            operation: 'constructor',
-            status: 'success',
-            developBranch: this.developBranch,
-            mainBranch: this.mainBranch,
-            autoSyncEnabled: this.autoSyncEnabled,
-            autoCleanEnabled: this.autoCleanEnabled
-        });
     }
 
     _validateDependencies() {
@@ -49,17 +25,9 @@ class GitFlowService {
     }
 
     getCurrentBranch() {
-        const m_get_current_branch = createMetricScope({
-            hook: 'git_flow_service',
-            operation: 'get_current_branch'
-        });
-
-        m_get_current_branch.started();
         if (this.gitQuery) {
-            m_get_current_branch.success();
             return this.gitQuery.getCurrentBranch();
         }
-        m_get_current_branch.success();
         return 'unknown';
     }
 
@@ -72,31 +40,12 @@ class GitFlowService {
     }
 
     syncBranches() {
-        recordMetric({
-            hook: 'git_flow_service',
-            operation: 'sync_branches',
-            status: 'started',
-            autoSyncEnabled: this.autoSyncEnabled
-        });
-
         if (!this.autoSyncEnabled) {
-            recordMetric({
-                hook: 'git_flow_service',
-                operation: 'sync_branches',
-                status: 'skipped',
-                reason: 'auto_sync_disabled'
-            });
             return { success: false, message: 'Auto-sync disabled' };
         }
 
         if (!this.isClean()) {
             this.logger.warn('Skipping sync: working directory not clean');
-            recordMetric({
-                hook: 'git_flow_service',
-                operation: 'sync_branches',
-                status: 'skipped',
-                reason: 'working_directory_not_clean'
-            });
             return { success: false, message: 'Working directory not clean' };
         }
 
@@ -115,47 +64,22 @@ class GitFlowService {
 
                 this.gitCommand.checkout(current);
             } else {
-                recordMetric({
-                    hook: 'git_flow_service',
-                    operation: 'sync_branches',
-                    status: 'failed',
-                    reason: 'no_git_command_adapter'
-                });
                 throw new ConfigurationError('GitCommandAdapter is required for branch synchronization', 'gitCommand');
             }
 
             this.logger.info('Branches synchronized successfully', {
                 branches: [this.developBranch, this.mainBranch]
             });
-            recordMetric({
-                hook: 'git_flow_service',
-                operation: 'sync_branches',
-                status: 'success',
-                branches: [this.developBranch, this.mainBranch].join(',')
-            });
             return { success: true, message: 'Branches synchronized' };
         } catch (error) {
             this.logger.error('Branch synchronization failed', { error: error.message });
-            recordMetric({
-                hook: 'git_flow_service',
-                operation: 'sync_branches',
-                status: 'failed',
-                error: error.message.substring(0, 100)
-            });
             return { success: false, message: error.message };
         }
     }
 
     createPullRequest(sourceBranch, targetBranch, title, body) {
-        const m_create_pull_request = createMetricScope({
-            hook: 'git_flow_service',
-            operation: 'create_pull_request'
-        });
-
-        m_create_pull_request.started();
         if (!this.github) {
             this.logger.error('GitHub adapter not available');
-            m_create_pull_request.success();
             return null;
         }
 
@@ -170,15 +94,11 @@ class GitFlowService {
                 this.logger.warn('Pull Request creation failed or returned no URL');
             }
 
-            m_create_pull_request.success();
-
             return prUrl;
         } catch (error) {
             this.logger.error('[GitFlowService] Failed to create PR:', { error: error.message });
-            m_create_pull_request.success();
             return null;
         }
-        m_create_pull_request.success();
     }
 
     mergeDevelopToMain() {

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

@@ -1,11 +1,8 @@
 const { execSync } = require('child_process');
+const path = require('path');
 
 // Import recordMetric for prometheus metrics
-const { recordMetric } = require('../../../infrastructure/telemetry/metrics-logger');
-
-const {
-    createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
+const { recordMetric } = require(path.join(__dirname, '..', '..', 'infrastructure', 'telemetry', 'metrics-logger'));
 
 const extractFilePath = line => {
     recordMetric({

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

@@ -1,10 +1,6 @@
 const { recordMetric } = require('../../infrastructure/telemetry/metrics-logger');
 const HookSystemStateMachine = require('../state/HookSystemStateMachine');
 
-const {
-  createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
-
 class HookSystemScheduler {
   constructor({ orchestrator, contextEngine, intervalMs = 30000 }) {
     recordMetric({

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

@@ -5,23 +5,12 @@ const FeatureDetector = require('./commit/FeatureDetector');
 const CommitMessageGenerator = require('./commit/CommitMessageGenerator');
 const UnifiedLogger = require('./logging/UnifiedLogger');
 
-const {
-    createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
-
 class IntelligentCommitAnalyzer {
     constructor({ repoRoot = process.cwd(), logger = null } = {}) {
-        const m_constructor = createMetricScope({
-            hook: 'intelligent_commit_analyzer',
-            operation: 'constructor'
-        });
-
-        m_constructor.started();
         this.repoRoot = repoRoot;
         this.logger = logger || console;
         this.featureDetector = new FeatureDetector(this.logger);
         this.messageGenerator = new CommitMessageGenerator(this.logger);
-        m_constructor.success();
     }
 
     detectFeature(filePath) {
@@ -148,13 +137,6 @@ class IntelligentCommitAnalyzer {
      * Get ready-to-commit groups (all groups are ready - no verification)
      */
     getReadyCommits(suggestions) {
-        const m_get_ready_commits = createMetricScope({
-            hook: 'intelligent_commit_analyzer',
-            operation: 'get_ready_commits'
-        });
-
-        m_get_ready_commits.started();
-        m_get_ready_commits.success();
         return suggestions;
     }
 
@@ -162,13 +144,6 @@ class IntelligentCommitAnalyzer {
      * Get groups that need attention (none - we don't verify)
      */
     getNeedsAttention(suggestions) {
-        const m_get_needs_attention = createMetricScope({
-            hook: 'intelligent_commit_analyzer',
-            operation: 'get_needs_attention'
-        });
-
-        m_get_needs_attention.started();
-        m_get_needs_attention.success();
         return [];
     }
 }

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

@@ -1,10 +1,6 @@
 const IntelligentCommitAnalyzer = require('./IntelligentCommitAnalyzer');
 const { getGitTreeState } = require('./GitTreeState');
 
-const {
-    createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
-
 class IntelligentGitTreeMonitor {
     constructor({
         repoRoot = process.cwd(),
@@ -12,18 +8,11 @@ class IntelligentGitTreeMonitor {
         logger = console,
         autoCommitEnabled = false
     } = {}) {
-        const m_constructor = createMetricScope({
-            hook: 'intelligent_git_tree_monitor',
-            operation: 'constructor'
-        });
-
-        m_constructor.started();
         this.repoRoot = repoRoot;
         this.notifier = notifier;
         this.logger = logger;
         this.autoCommitEnabled = autoCommitEnabled;
         this.analyzer = new IntelligentCommitAnalyzer({ repoRoot, logger });
-        m_constructor.success();
     }
 
     /**

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

@@ -2,21 +2,10 @@ const path = require('path');
 const fs = require('fs');
 const PlatformHeuristics = require('./platform/PlatformHeuristics');
 
-const {
-    createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
-
 class PlatformAnalysisService {
     constructor(platformDetector) {
-        const m_constructor = createMetricScope({
-            hook: 'platform_analysis_service',
-            operation: 'constructor'
-        });
-
-        m_constructor.started();
         this.platformDetector = platformDetector;
         this.heuristics = new PlatformHeuristics(platformDetector);
-        m_constructor.success();
     }
 
     /**
@@ -141,12 +130,6 @@ class PlatformAnalysisService {
     }
 
     getScoreReasons(platform, context) {
-        const m_get_score_reasons = createMetricScope({
-            hook: 'platform_analysis_service',
-            operation: 'get_score_reasons'
-        });
-
-        m_get_score_reasons.started();
         const reasons = [];
 
         if (context.stagedFiles && context.stagedFiles.length > 0) {
@@ -183,8 +166,6 @@ class PlatformAnalysisService {
             }
         }
 
-        m_get_score_reasons.success();
-
         return reasons;
     }
 }