pumuki-ast-hooks 5.3.18 → 5.3.20

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

@@ -1,8 +1,22 @@
 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;
@@ -16,6 +30,16 @@ 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() {
@@ -25,9 +49,17 @@ 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';
     }
 
@@ -40,12 +72,31 @@ 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' };
         }
 
@@ -64,22 +115,47 @@ 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;
         }
 
@@ -94,11 +170,15 @@ 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,16 +1,57 @@
 const { execSync } = require('child_process');
 
+// Import recordMetric for prometheus metrics
+const { recordMetric } = require('../../../infrastructure/telemetry/metrics-logger');
+
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 const extractFilePath = line => {
+    recordMetric({
+        hook: 'git_tree_state',
+        operation: 'extract_file_path',
+        status: 'started',
+        lineLength: line ? line.length : 0
+    });
+
     if (!line) {
+        recordMetric({
+            hook: 'git_tree_state',
+            operation: 'extract_file_path',
+            status: 'success',
+            result: ''
+        });
         return '';
     }
     if (line.startsWith('??')) {
-        return line.slice(3).trim();
+        const result = line.slice(3).trim();
+        recordMetric({
+            hook: 'git_tree_state',
+            operation: 'extract_file_path',
+            status: 'success',
+            resultLength: result.length
+        });
+        return result;
     }
-    return line.length > 3 ? line.slice(3).trim() : line.trim();
+    const result = line.length > 3 ? line.slice(3).trim() : line.trim();
+    recordMetric({
+        hook: 'git_tree_state',
+        operation: 'extract_file_path',
+        status: 'success',
+        resultLength: result.length
+    });
+    return result;
 };
 
 const buildStateFromStatus = (statusOutput = '') => {
+    recordMetric({
+        hook: 'git_tree_state',
+        operation: 'build_state_from_status',
+        status: 'started',
+        statusOutputLength: statusOutput ? statusOutput.length : 0
+    });
+
     const lines = statusOutput
         .split('\n')
         .map(entry => entry.replace(/\r$/, ''))
@@ -44,24 +85,51 @@ const buildStateFromStatus = (statusOutput = '') => {
 
     const uniqueSet = new Set([...stagedSet, ...workingSet]);
 
-    return {
+    const result = {
         stagedFiles: Array.from(stagedSet),
         workingFiles: Array.from(workingSet),
         stagedCount: stagedSet.size,
         workingCount: workingSet.size,
         uniqueCount: uniqueSet.size
     };
+
+    recordMetric({
+        hook: 'git_tree_state',
+        operation: 'build_state_from_status',
+        status: 'success',
+        stagedCount: stagedSet.size,
+        workingCount: workingSet.size,
+        uniqueCount: uniqueSet.size
+    });
+
+    return result;
 };
 
 const getGitTreeState = ({ repoRoot = process.cwd() } = {}) => {
+    recordMetric({
+        hook: 'git_tree_state',
+        operation: 'get_git_tree_state',
+        status: 'started',
+        repoRoot: repoRoot.substring(0, 100)
+    });
+
     try {
         const statusOutput = execSync('git status --porcelain', {
             cwd: repoRoot,
             encoding: 'utf8'
         });
-        return buildStateFromStatus(statusOutput);
+        const result = buildStateFromStatus(statusOutput);
+        recordMetric({
+            hook: 'git_tree_state',
+            operation: 'get_git_tree_state',
+            status: 'success',
+            stagedCount: result.stagedCount,
+            workingCount: result.workingCount,
+            uniqueCount: result.uniqueCount
+        });
+        return result;
     } catch (error) {
-        return {
+        const result = {
             stagedFiles: [],
             workingFiles: [],
             stagedCount: 0,
@@ -69,37 +137,92 @@ const getGitTreeState = ({ repoRoot = process.cwd() } = {}) => {
             uniqueCount: 0,
             error: error.message
         };
+        recordMetric({
+            hook: 'git_tree_state',
+            operation: 'get_git_tree_state',
+            status: 'failed',
+            error: error.message
+        });
+        return result;
     }
 };
 
 const isTreeBeyondLimit = (state, limits) => {
+    recordMetric({
+        hook: 'git_tree_state',
+        operation: 'is_tree_beyond_limit',
+        status: 'started',
+        hasState: !!state,
+        limitsType: typeof limits
+    });
+
     if (!state) {
+        recordMetric({
+            hook: 'git_tree_state',
+            operation: 'is_tree_beyond_limit',
+            status: 'success',
+            result: false
+        });
         return false;
     }
-    
+
     if (typeof limits === 'number') {
         const limit = limits;
         if (!Number.isFinite(limit) || limit <= 0) {
+            recordMetric({
+                hook: 'git_tree_state',
+                operation: 'is_tree_beyond_limit',
+                status: 'success',
+                result: false
+            });
             return false;
         }
-        return (
+        const result = (
             state.stagedCount > limit ||
             state.workingCount > limit ||
             state.uniqueCount > limit
         );
+        recordMetric({
+            hook: 'git_tree_state',
+            operation: 'is_tree_beyond_limit',
+            status: 'success',
+            result: result
+        });
+        return result;
     }
-    
+
     const { stagedLimit = 10, unstagedLimit = 15, totalLimit = 20 } = limits || {};
-    
+
     const stagedExceeded = Number.isFinite(stagedLimit) && stagedLimit > 0 && state.stagedCount > stagedLimit;
     const unstagedExceeded = Number.isFinite(unstagedLimit) && unstagedLimit > 0 && state.workingCount > unstagedLimit;
     const totalExceeded = Number.isFinite(totalLimit) && totalLimit > 0 && state.uniqueCount > totalLimit;
-    
-    return stagedExceeded || unstagedExceeded || totalExceeded;
+
+    const result = stagedExceeded || unstagedExceeded || totalExceeded;
+    recordMetric({
+        hook: 'git_tree_state',
+        operation: 'is_tree_beyond_limit',
+        status: 'success',
+        result: result
+    });
+    return result;
 };
 
 const summarizeTreeState = (state, limits) => {
+    recordMetric({
+        hook: 'git_tree_state',
+        operation: 'summarize_tree_state',
+        status: 'started',
+        hasState: !!state,
+        limitsType: typeof limits
+    });
+
     if (!state) {
+        recordMetric({
+            hook: 'git_tree_state',
+            operation: 'summarize_tree_state',
+            status: 'success',
+            result: 'no data'
+        });
         return 'no data';
     }
     const parts = [
@@ -107,7 +230,7 @@ const summarizeTreeState = (state, limits) => {
         `working ${state.workingCount}`,
         `unique ${state.uniqueCount}`
     ];
-    
+
     if (typeof limits === 'number') {
         const limit = limits;
         if (Number.isFinite(limit) && limit > 0) {
@@ -129,7 +252,14 @@ const summarizeTreeState = (state, limits) => {
             parts.push(`(${limitParts.join(', ')})`);
         }
     }
-    return parts.join(', ');
+    const result = parts.join(', ');
+    recordMetric({
+        hook: 'git_tree_state',
+        operation: 'summarize_tree_state',
+        status: 'success',
+        resultLength: result.length
+    });
+    return result;
 };
 
 module.exports = {

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

@@ -1,25 +1,72 @@
 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({
+      hook: 'hook_system_scheduler',
+      operation: 'constructor',
+      status: 'started',
+      intervalMs
+    });
+
     this.orchestrator = orchestrator;
     this.contextEngine = contextEngine;
     this.intervalMs = intervalMs;
     this.stateMachine = new HookSystemStateMachine();
     this.timer = null;
+
+    recordMetric({
+      hook: 'hook_system_scheduler',
+      operation: 'constructor',
+      status: 'success',
+      intervalMs
+    });
   }
 
   start() {
+    recordMetric({
+      hook: 'hook_system_scheduler',
+      operation: 'start',
+      status: 'started',
+      intervalMs: this.intervalMs
+    });
+
     if (this.timer) return;
+
     this.timer = setInterval(() => this.tick(), this.intervalMs);
+
+    recordMetric({
+      hook: 'hook_system_scheduler',
+      operation: 'start',
+      status: 'success',
+      intervalMs: this.intervalMs
+    });
   }
 
   stop() {
+    recordMetric({
+      hook: 'hook_system_scheduler',
+      operation: 'stop',
+      status: 'started',
+      hadTimer: !!this.timer
+    });
+
     if (this.timer) {
       clearInterval(this.timer);
       this.timer = null;
     }
+
+    recordMetric({
+      hook: 'hook_system_scheduler',
+      operation: 'stop',
+      status: 'success',
+      hadTimer: !!this.timer
+    });
   }
 
   async tick() {

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

@@ -5,12 +5,23 @@ 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) {
@@ -137,6 +148,13 @@ 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;
     }
 
@@ -144,6 +162,13 @@ 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,6 +1,10 @@
 const IntelligentCommitAnalyzer = require('./IntelligentCommitAnalyzer');
 const { getGitTreeState } = require('./GitTreeState');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class IntelligentGitTreeMonitor {
     constructor({
         repoRoot = process.cwd(),
@@ -8,11 +12,18 @@ 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,10 +2,21 @@ 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();
     }
 
     /**
@@ -130,6 +141,12 @@ 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) {
@@ -166,6 +183,8 @@ class PlatformAnalysisService {
             }
         }
 
+        m_get_score_reasons.success();
+
         return reasons;
     }
 }

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 NotFoundError(`Playbook '${id}'`);
+      throw new NotFoundException('Playbook', { id });
     }
 
     for (const step of playbook.steps) {
@@ -33,6 +53,7 @@ class PlaybookRunner {
         }
       }
     }
+    m_run.success();
   }
 }