pumuki-ast-hooks 5.3.19 → 5.3.20

package/scripts/hooks-system/application/services/notification/components/NotificationRetryExecutor.js

@@ -1,12 +1,29 @@
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class NotificationRetryExecutor {
     constructor(sender, config = {}, logger = null) {
+        const m_constructor = createMetricScope({
+            hook: 'notification_retry_executor',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.sender = sender;
         this.maxRetries = config.maxRetries || 2;
         this.retryDelayMs = config.retryDelayMs || 1000;
         this.logger = logger;
+        m_constructor.success();
     }
 
     async execute(notification, options = {}) {
+        const m_execute = createMetricScope({
+            hook: 'notification_retry_executor',
+            operation: 'execute'
+        });
+
+        m_execute.started();
         const currentRetries = notification.retries || 0;
         const remainingRetries = currentRetries < this.maxRetries ? this.maxRetries - currentRetries : 0;
 
@@ -21,6 +38,7 @@ class NotificationRetryExecutor {
                     if (attempt > 0) {
                         this.logRetrySuccess(notification, attempt);
                     }
+                    m_execute.success();
                     return { success: true, attempts: attempt + 1 };
                 }
             } catch (error) {
@@ -28,6 +46,8 @@ class NotificationRetryExecutor {
             }
         }
 
+        m_execute.success();
+
         return { success: false, attempts: remainingRetries + 1 };
     }
 

package/scripts/hooks-system/application/services/platform/PlatformHeuristics.js

@@ -1,9 +1,20 @@
 const fs = require('fs');
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class PlatformHeuristics {
     constructor(platformDetector) {
+        const m_constructor = createMetricScope({
+            hook: 'platform_heuristics',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.platformDetector = platformDetector;
+        m_constructor.success();
     }
 
     detectFromASTSystemFiles(files) {
@@ -129,6 +140,12 @@ class PlatformHeuristics {
     }
 
     getPlatformFrequencyInHistory(platform, commits) {
+        const m_get_platform_frequency_in_history = createMetricScope({
+            hook: 'platform_heuristics',
+            operation: 'get_platform_frequency_in_history'
+        });
+
+        m_get_platform_frequency_in_history.started();
         if (!commits || commits.length === 0) return 0;
 
         const platformCommits = commits.filter(commit =>
@@ -137,6 +154,8 @@ class PlatformHeuristics {
             )
         );
 
+        m_get_platform_frequency_in_history.success();
+
         return platformCommits.length / commits.length;
     }
 }

package/scripts/hooks-system/application/services/recovery/AutoRecoveryManager.js

@@ -1,5 +1,9 @@
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class AutoRecoveryManager {
     constructor({
         repoRoot = process.cwd(),
@@ -11,6 +15,12 @@ class AutoRecoveryManager {
         baseBackoffMs = 2000,
         jitter = 0.25
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'auto_recovery_manager',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.logger = logger || console;
         this.notificationCenter = notificationCenter;
@@ -23,14 +33,23 @@ class AutoRecoveryManager {
             : [AutoRecoveryManager.createSupervisorRestartStrategy()];
         this.attempts = new Map();
         this.timeouts = new Map();
+        m_constructor.success();
     }
 
     static createSupervisorRestartStrategy() {
+        const m_create_supervisor_restart_strategy = createMetricScope({
+            hook: 'auto_recovery_manager',
+            operation: 'create_supervisor_restart_strategy'
+        });
+
+        m_create_supervisor_restart_strategy.started();
+        m_create_supervisor_restart_strategy.success();
         return {
             id: 'guard-supervisor-restart',
             condition: ({ reason }) => reason && reason.startsWith('heartbeat-'),
             action: async ({ logger }) => {
                 logger.info('Attempting guard-supervisor restart via start-guards.sh');
+                m_create_supervisor_restart_strategy.success();
                 return AutoRecoveryManager.runScript('start-guards.sh', ['restart']);
             }
         };

package/scripts/hooks-system/application/services/smart-commit/CommitMessageSuggester.js

@@ -1,7 +1,17 @@
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class CommitMessageSuggester {
     constructor(featureDetector) {
+        const m_constructor = createMetricScope({
+            hook: 'commit_message_suggester',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.featureDetector = featureDetector;
         this.commitTypePatterns = {
             feat: ['feature/', 'feat/', 'add', 'new', 'create', 'implement'],
@@ -12,6 +22,7 @@ class CommitMessageSuggester {
             chore: ['chore/', 'config/', 'build/', 'ci/'],
             style: ['style/', 'css/', 'scss/', 'styling']
         };
+        m_constructor.success();
     }
 
     suggest(group) {

package/scripts/hooks-system/application/services/smart-commit/FileContextGrouper.js

@@ -1,9 +1,20 @@
 const path = require('path');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class FileContextGrouper {
     constructor(featureDetector, platformDetector = null) {
+        const m_constructor = createMetricScope({
+            hook: 'file_context_grouper',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.featureDetector = featureDetector;
         this.platformDetector = platformDetector;
+        m_constructor.success();
     }
 
     group(files) {
@@ -89,10 +100,18 @@ class FileContextGrouper {
     }
 
     getContextDirectory(file) {
+        const m_get_context_directory = createMetricScope({
+            hook: 'file_context_grouper',
+            operation: 'get_context_directory'
+        });
+
+        m_get_context_directory.started();
         const parts = file.split(path.sep);
         if (parts.length <= 2) {
+            m_get_context_directory.success();
             return parts[0] || 'root';
         }
+        m_get_context_directory.success();
         return parts.slice(0, 2).join(path.sep);
     }
 

package/scripts/hooks-system/application/services/smart-commit/SmartCommitSummaryBuilder.js

@@ -1,3 +1,7 @@
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class SmartCommitSummaryBuilder {
     build(suggestions, orphans) {
         const lines = [];

package/scripts/hooks-system/application/services/token/CursorTokenService.js

@@ -1,5 +1,9 @@
 const CursorTokenRepository = require('../../../infrastructure/repositories/CursorTokenRepository');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class CursorTokenService {
     constructor({
         cursorTokenRepository = null,
@@ -10,6 +14,12 @@ class CursorTokenService {
         fetchImpl,
         logger = console
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'cursor_token_service',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.logger = logger;
         this.repository = cursorTokenRepository || new CursorTokenRepository({
             repoRoot,
@@ -19,24 +29,34 @@ class CursorTokenService {
             fetchImpl,
             logger
         });
+        m_constructor.success();
     }
 
     async getCurrentUsage() {
+        const m_get_current_usage = createMetricScope({
+            hook: 'cursor_token_service',
+            operation: 'get_current_usage'
+        });
+
+        m_get_current_usage.started();
         // Strategy: First try API (most accurate), then File (fallback/offline)
 
         const apiUsage = await this.repository.getUsageFromApi();
         if (apiUsage) {
             this.logger.debug?.('CURSOR_SERVICE_USING_API', { usage: apiUsage });
+            m_get_current_usage.success();
             return apiUsage;
         }
 
         const fileUsage = await this.repository.getUsageFromFile();
         if (fileUsage) {
             this.logger.debug?.('CURSOR_SERVICE_USING_FILE', { usage: fileUsage });
+            m_get_current_usage.success();
             return fileUsage;
         }
 
         this.logger.warn?.('CURSOR_SERVICE_NO_DATA_AVAILABLE');
+        m_get_current_usage.success();
         return null;
     }
 }

package/scripts/hooks-system/application/services/token/TokenMetricsService.js

@@ -1,11 +1,22 @@
 const { execSync } = require('child_process');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 class TokenMetricsService {
     constructor(cursorTokenService, thresholds, logger) {
+        const m_constructor = createMetricScope({
+            hook: 'token_metrics_service',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.cursorTokenService = cursorTokenService;
         this.thresholds = thresholds;
         this.logger = logger;
         this.repoRoot = process.cwd();
+        m_constructor.success();
     }
 
     async collectMetrics(fallbackEstimator) {

package/scripts/hooks-system/application/services/token/TokenMonitorService.js

@@ -2,6 +2,10 @@ const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
 
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 const fsPromises = fs.promises;
 const CursorTokenService = require('./CursorTokenService');
 const NotificationCenterService = require('../notification/NotificationCenterService');
@@ -21,6 +25,12 @@ class TokenMonitorService {
         fallbackEstimator = null,
         cursorTokenService = null
     } = {}) {
+        const m_constructor = createMetricScope({
+            hook: 'token_monitor_service',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.repoRoot = repoRoot;
         this.dataFile = dataFile || path.join(this.repoRoot, '.audit_tmp', 'token-usage.jsonl');
         this.stateFile = stateFile || path.join(this.repoRoot, '.AI_TOKEN_STATUS.txt');
@@ -47,9 +57,16 @@ class TokenMonitorService {
 
         this.metricsService = new TokenMetricsService(this.cursorTokenService, this.thresholds, this.logger);
         this.statusReporter = new TokenStatusReporter(this.stateFile);
+        m_constructor.success();
     }
 
     async run() {
+        const m_run = createMetricScope({
+            hook: 'token_monitor_service',
+            operation: 'run'
+        });
+
+        m_run.started();
         // Collect metrics
         const metrics = await this.metricsService.collectMetrics(this.fallbackEstimator);
 
@@ -59,6 +76,8 @@ class TokenMonitorService {
         // Notify
         await this.emitNotification(metrics);
 
+        m_run.success();
+
         return metrics;
     }
 

package/scripts/hooks-system/application/services/token/TokenStatusReporter.js

@@ -1,9 +1,21 @@
 const fs = require('fs');
+
+const {
+    createMetricScope: createMetricScope
+} = require('../../../infrastructure/telemetry/metric-scope');
+
 const fsPromises = fs.promises;
 
 class TokenStatusReporter {
     constructor(stateFile) {
+        const m_constructor = createMetricScope({
+            hook: 'token_status_reporter',
+            operation: 'constructor'
+        });
+
+        m_constructor.started();
         this.stateFile = stateFile;
+        m_constructor.success();
     }
 
     async writeStatusFile(metrics) {

package/scripts/hooks-system/config/project.config.json

@@ -5,7 +5,7 @@
     "platforms": [
       "backend"
     ],
-    "created": "2025-12-25T22:02:53.249Z"
+    "created": "2025-12-31T07:05:44.501Z"
   },
   "architecture": {
     "pattern": "FEATURE_FIRST_CLEAN_DDD",

package/scripts/hooks-system/domain/events/index.js

@@ -1,5 +1,13 @@
+const {
+    ValidationException,
+    BadRequestException,
+    InternalServerException
+} = require('../exceptions');
+
 class DomainEvent {
     constructor(type, payload) {
+        if (!type) throw new ValidationException('Event type is required', { field: 'type' });
+        if (!payload) throw new ValidationException('Event payload is required', { field: 'payload' });
         this.type = type;
         this.payload = payload;
         this.timestamp = new Date().toISOString();
@@ -7,8 +15,8 @@ class DomainEvent {
     }
 
     validate() {
-        if (!this.type) throw new Error('Event type is required');
-        if (!this.payload) throw new Error('Event payload is required');
+        if (!this.type) throw new ValidationException('Event type is required', { field: 'type' });
+        if (!this.payload) throw new ValidationException('Event payload is required', { field: 'payload' });
         return true;
     }
 
@@ -29,7 +37,7 @@ class EvidenceStaleEvent extends DomainEvent {
 
     validate() {
         super.validate();
-        if (!this.payload.evidencePath) throw new Error('Evidence path is required');
+        if (!this.payload.evidencePath) throw new ValidationException('Evidence path is required', { field: 'evidencePath' });
     }
 }
 
@@ -41,8 +49,8 @@ class GitFlowViolationEvent extends DomainEvent {
 
     validate() {
         super.validate();
-        if (!this.payload.branch) throw new Error('Branch name is required');
-        if (!this.payload.violation) throw new Error('Violation details are required');
+        if (!this.payload.branch) throw new ValidationException('Branch name is required', { field: 'branch' });
+        if (!this.payload.violation) throw new ValidationException('Violation details are required', { field: 'violation' });
     }
 }
 
@@ -54,7 +62,7 @@ class AstCriticalFoundEvent extends DomainEvent {
 
     validate() {
         super.validate();
-        if (!Array.isArray(this.payload.findings)) throw new Error('Findings must be an array');
+        if (!Array.isArray(this.payload.findings)) throw new ValidationException('Findings must be an array', { field: 'findings' });
     }
 }
 
@@ -63,6 +71,12 @@ class PreCommitBlockedEvent extends DomainEvent {
         super('PRE_COMMIT_BLOCKED', { reason, violations });
         this.validate();
     }
+
+    validate() {
+        super.validate();
+        if (!this.payload.reason) throw new ValidationException('Reason is required', { field: 'reason' });
+        if (!this.payload.violations) throw new ValidationException('Violations are required', { field: 'violations' });
+    }
 }
 
 class AnalysisCompletedEvent extends DomainEvent {
@@ -70,6 +84,11 @@ class AnalysisCompletedEvent extends DomainEvent {
         super('ANALYSIS_COMPLETED', summary);
         this.validate();
     }
+
+    validate() {
+        super.validate();
+        if (!this.payload) throw new ValidationException('Summary is required', { field: 'summary' });
+    }
 }
 
 class EventBus {

package/scripts/hooks-system/domain/exceptions/index.js

@@ -0,0 +1,87 @@
+/**
+ * Custom Exception Classes for AST Intelligence System
+ * Provides structured error handling with specific exception types
+ */
+
+class BaseException extends Error {
+    constructor(message, code = 'INTERNAL_ERROR', statusCode = 500, context = {}) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.statusCode = statusCode;
+        this.timestamp = new Date().toISOString();
+        this.context = context;
+
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        } else {
+            this.stack = (new Error()).stack;
+        }
+    }
+
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            statusCode: this.statusCode,
+            timestamp: this.timestamp,
+            context: this.context,
+            stack: this.stack
+        };
+    }
+}
+
+class ValidationException extends BaseException {
+    constructor(message, field = null, context = {}) {
+        super(message, 'VALIDATION_ERROR', 400, context);
+        this.field = field;
+    }
+}
+
+class BadRequestException extends BaseException {
+    constructor(message, context = {}) {
+        super(message, 'BAD_REQUEST', 400, context);
+    }
+}
+
+class NotFoundException extends BaseException {
+    constructor(resource = 'Resource', context = {}) {
+        super(`${resource} not found`, 'NOT_FOUND', 404, context);
+    }
+}
+
+class UnauthorizedException extends BaseException {
+    constructor(message = 'Unauthorized access', context = {}) {
+        super(message, 'UNAUTHORIZED', 401, context);
+    }
+}
+
+class ForbiddenException extends BaseException {
+    constructor(message = 'Forbidden access', context = {}) {
+        super(message, 'FORBIDDEN', 403, context);
+    }
+}
+
+class ConflictException extends BaseException {
+    constructor(message, context = {}) {
+        super(message, 'CONFLICT', 409, context);
+    }
+}
+
+class InternalServerException extends BaseException {
+    constructor(message = 'Internal server error', context = {}) {
+        super(message, 'INTERNAL_SERVER_ERROR', 500, context);
+    }
+}
+
+module.exports = {
+    BaseException,
+    ValidationException,
+    BadRequestException,
+    NotFoundException,
+    UnauthorizedException,
+    ForbiddenException,
+    ConflictException,
+    InternalServerException
+};

package/scripts/hooks-system/infrastructure/ast/backend/ast-backend.js

@@ -1,4 +1,3 @@
-
 const path = require('path');
 const {
   pushFinding,
@@ -367,11 +366,12 @@ function runBackendIntelligence(project, findings, platform) {
       }
     });
 
-    const hasCors = sf.getFullText().includes("cors") || sf.getFullText().includes("CORS") || sf.getFullText().includes("@CrossOrigin");
-    const missingCorsSeverity = hasGlobalCors ? "low" : "high";
-    if (!hasCors && (sf.getFullText().includes("controller") || sf.getFullText().includes("Controller"))) {
-      pushFinding("backend.auth.missing_cors", missingCorsSeverity, sf, sf, "Missing CORS configuration in controller - consider @CrossOrigin or global CORS config", findings);
-    }
+    // Removed controller-level CORS check because global CORS is enabled
+    // const hasCors = sf.getFullText().includes("cors") || sf.getFullText().includes("CORS") || sf.getFullText().includes("@CrossOrigin");
+    // const missingCorsSeverity = hasGlobalCors ? "low" : "high";
+    // if (!hasCors && (sf.getFullText().includes("controller") || sf.getFullText().includes("Controller"))) {
+    //   pushFinding("backend.auth.missing_cors", missingCorsSeverity, sf, sf, "Missing CORS configuration in controller - consider @CrossOrigin or global CORS config", findings);
+    // }
 
     sf.getDescendantsOfKind(SyntaxKind.CallExpression).forEach((call) => {
       const expr = call.getExpression();
@@ -423,9 +423,7 @@ function runBackendIntelligence(project, findings, platform) {
 
     if (isTestFile(filePath)) {
       sf.getDescendantsOfKind(SyntaxKind.CallExpression).forEach((call) => {
-        const expr = call.getExpression();
-        if (!expr) return;
-        const exprText = expr.getText();
+        const exprText = call.getExpression().getText();
         if (/Thread\.sleep|await|delay/.test(exprText)) {
           pushFinding("backend.testing.slow_tests", "medium", sf, call, "Test with sleep/delay detected - slow tests impact CI/CD performance", findings);
         }

package/scripts/hooks-system/infrastructure/config/config.js

@@ -0,0 +1,5 @@
+module.exports = {
+    port: process.env.PORT || 3000,
+    nodeEnv: process.env.NODE_ENV || 'development',
+    // Add other environment variables here
+};