pumuki-ast-hooks 5.3.1

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

@@ -0,0 +1,137 @@
+const path = require('path');
+
+class AutoRecoveryManager {
+    constructor({
+        repoRoot = process.cwd(),
+        strategies = [],
+        logger = console,
+        notificationCenter = null,
+        timers = { setTimeout, clearTimeout },
+        maxAttempts = 5,
+        baseBackoffMs = 2000,
+        jitter = 0.25
+    } = {}) {
+        this.repoRoot = repoRoot;
+        this.logger = logger || console;
+        this.notificationCenter = notificationCenter;
+        this.timers = timers;
+        this.maxAttempts = maxAttempts;
+        this.baseBackoffMs = baseBackoffMs;
+        this.jitter = jitter;
+        this.strategies = Array.isArray(strategies) && strategies.length
+            ? strategies
+            : [AutoRecoveryManager.createSupervisorRestartStrategy()];
+        this.attempts = new Map();
+        this.timeouts = new Map();
+    }
+
+    static createSupervisorRestartStrategy() {
+        return {
+            id: 'guard-supervisor-restart',
+            condition: ({ reason }) => reason && reason.startsWith('heartbeat-'),
+            action: async ({ logger }) => {
+                logger.info('Attempting guard-supervisor restart via start-guards.sh');
+                return AutoRecoveryManager.runScript('start-guards.sh', ['restart']);
+            }
+        };
+    }
+
+    static runScript(scriptName, args = []) {
+        const { spawnSync } = require('child_process');
+        const scriptPath = path.join(process.cwd(), 'scripts', 'hooks-system', 'bin', scriptName);
+        const result = spawnSync(scriptPath, args, { stdio: 'pipe', cwd: process.cwd() });
+        if (result.error) {
+            throw result.error;
+        }
+        return {
+            stdout: (result.stdout || '').toString(),
+            stderr: (result.stderr || '').toString()
+        };
+    }
+
+    registerStrategy(strategy) {
+        if (!strategy || !strategy.id) {
+            return;
+        }
+        this.strategies.push(strategy);
+    }
+
+    async recover({ key, reason, context = {} }) {
+        const strategy = this.strategies.find(entry => entry.condition({ reason, context }));
+        if (!strategy) {
+            return { status: 'ignored' };
+        }
+
+        const attempts = this.attempts.get(key) || { count: 0, lastAttempt: 0 };
+        if (attempts.count >= this.maxAttempts) {
+            this.log('warn', 'AUTO_RECOVERY_MAX_ATTEMPTS', { key, reason });
+            this.notify(`Recovery skipped for ${key} (max attempts reached)`, 'warn', { key, reason });
+            return { status: 'skipped' };
+        }
+
+        const delay = this.calculateDelay(attempts.count);
+        this.log('info', 'AUTO_RECOVERY_SCHEDULED', { key, reason, delay });
+
+        if (this.timeouts.has(key)) {
+            this.timers.clearTimeout(this.timeouts.get(key));
+        }
+
+        const timeoutRef = this.timers.setTimeout(async () => {
+            const currentAttempts = this.attempts.get(key) || { count: 0 };
+            const nextCount = currentAttempts.count + 1;
+            this.attempts.set(key, { count: nextCount, lastAttempt: Date.now() });
+            try {
+                const result = await strategy.action({
+                    key,
+                    reason,
+                    context,
+                    logger: this.logger
+                });
+                this.log('info', 'AUTO_RECOVERY_SUCCESS', { key, reason, result });
+                this.notify(`Recovery succeeded for ${key}`, 'info', { key, reason });
+            } catch (error) {
+                this.log('error', 'AUTO_RECOVERY_FAILED', { key, reason, error: error.message });
+                this.notify(`Recovery failed for ${key}: ${error.message}`, 'error', { key, reason });
+            } finally {
+                this.timeouts.delete(key);
+            }
+        }, delay);
+
+        this.timeouts.set(key, timeoutRef);
+        return { status: 'scheduled', delay };
+    }
+
+    clear(key) {
+        this.attempts.delete(key);
+        const ref = this.timeouts.get(key);
+        if (ref) {
+            this.timers.clearTimeout(ref);
+            this.timeouts.delete(key);
+        }
+    }
+
+    calculateDelay(attemptCount) {
+        const exponential = this.baseBackoffMs * Math.pow(2, attemptCount);
+        const randomFactor = 1 + (Math.random() * 2 - 1) * this.jitter;
+        return Math.round(exponential * randomFactor);
+    }
+
+    log(level, event, data = {}) {
+        if (this.logger && typeof this.logger[level] === 'function') {
+            this.logger[level](event, data);
+        }
+    }
+
+    notify(message, level, metadata = {}) {
+        if (this.notificationCenter && typeof this.notificationCenter.enqueue === 'function') {
+            this.notificationCenter.enqueue({
+                message,
+                level,
+                type: `auto_recovery_${level}`,
+                metadata
+            });
+        }
+    }
+}
+
+module.exports = { AutoRecoveryManager };

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

@@ -0,0 +1,62 @@
+const { AutoRecoveryManager } = require('../AutoRecoveryManager');
+
+describe('AutoRecoveryManager', () => {
+    const create = (overrides = {}) => {
+        const enqueue = jest.fn();
+        const logger = { info: jest.fn(), warn: jest.fn(), error: jest.fn() };
+        const timers = {
+            setTimeout: jest.fn((fn) => {
+                timers.fn = fn;
+                return Symbol('timeout');
+            }),
+            clearTimeout: jest.fn()
+        };
+
+        const manager = new AutoRecoveryManager({
+            notificationCenter: { enqueue },
+            logger,
+            timers,
+            baseBackoffMs: 10,
+            jitter: 0,
+            strategies: [
+                {
+                    id: 'test-restart',
+                    condition: ({ reason }) => reason === 'test',
+                    action: jest.fn()
+                }
+            ],
+            ...overrides
+        });
+        manager.__test = { enqueue, logger, timers };
+        return manager;
+    };
+
+    it('schedules recovery with backoff and notifies', async () => {
+        const manager = create();
+        const strategy = manager.strategies[0];
+        const result = await manager.recover({ key: 'guard', reason: 'test' });
+
+        expect(result.status).toBe('scheduled');
+        expect(manager.__test.timers.setTimeout).toHaveBeenCalled();
+
+        await manager.__test.timers.fn();
+
+        expect(strategy.action).toHaveBeenCalled();
+        expect(manager.__test.enqueue).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'auto_recovery_info'
+        }));
+    });
+
+    it('bloquea recuperación cuando excede intentos', async () => {
+        const manager = create({ maxAttempts: 1 });
+        const strategy = manager.strategies[0];
+        await manager.recover({ key: 'guard', reason: 'test' });
+        await manager.__test.timers.fn();
+
+        const second = await manager.recover({ key: 'guard', reason: 'test' });
+
+        expect(second.status).toBe('skipped');
+        expect(manager.__test.logger.warn).toHaveBeenCalledWith('AUTO_RECOVERY_MAX_ATTEMPTS', expect.any(Object));
+        expect(strategy.action).toHaveBeenCalledTimes(1);
+    });
+});

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

@@ -0,0 +1,97 @@
+const path = require('path');
+
+class CommitMessageSuggester {
+    constructor(featureDetector) {
+        this.featureDetector = featureDetector;
+        this.commitTypePatterns = {
+            feat: ['feature/', 'feat/', 'add', 'new', 'create', 'implement'],
+            fix: ['fix/', 'bugfix/', 'hotfix/', 'patch'],
+            refactor: ['refactor/', 'clean', 'restructure'],
+            docs: ['docs/', 'documentation', 'readme', 'changelog'],
+            test: ['test/', 'spec/', '__tests__'],
+            chore: ['chore/', 'config/', 'build/', 'ci/'],
+            style: ['style/', 'css/', 'scss/', 'styling']
+        };
+    }
+
+    suggest(group) {
+        const { context, platform, files } = group;
+        let commitType;
+
+        if (group.isTestGroup) {
+            commitType = 'test';
+        } else if (group.isMiscGroup) {
+            commitType = 'chore';
+        } else {
+            commitType = this.inferCommitType(files, context);
+        }
+
+        const scope = this.inferScope(context, platform);
+        const action = this.inferAction(files);
+
+        return {
+            type: commitType,
+            scope,
+            message: `${commitType}(${scope}): ${action}`,
+            files: files.length,
+            fileList: files.slice(0, 5)
+        };
+    }
+
+    inferCommitType(files, context) {
+        const lowerContext = (context || '').toLowerCase();
+
+        for (const [type, patterns] of Object.entries(this.commitTypePatterns)) {
+            if (patterns.some(p => lowerContext.includes(p))) {
+                return type;
+            }
+        }
+
+        if (files.some(f => this.featureDetector.isTestFile(f))) {
+            return 'test';
+        }
+
+        if (files.some(f => /\.md$/.test(f))) {
+            return 'docs';
+        }
+
+        if (files.some(f => /\.json$|\.yaml$|\.yml$/.test(f))) {
+            return 'chore';
+        }
+
+        return 'feat';
+    }
+
+    inferScope(context, platform) {
+        if (context && context !== 'misc' && context !== 'other') {
+            const parts = context.split(path.sep);
+            const lastPart = parts[parts.length - 1];
+            if (lastPart && lastPart.length <= 20) {
+                return lastPart.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+            }
+        }
+
+        if (platform && platform !== 'other') {
+            return platform;
+        }
+
+        return 'general';
+    }
+
+    inferAction(files) {
+        if (files.length === 1) {
+            const basename = path.basename(files[0]);
+            return `update ${basename}`;
+        }
+
+        const extensions = new Set(files.map(f => path.extname(f)).filter(Boolean));
+        if (extensions.size === 1) {
+            const ext = Array.from(extensions)[0];
+            return `update ${files.length} ${ext} files`;
+        }
+
+        return `update ${files.length} files`;
+    }
+}
+
+module.exports = CommitMessageSuggester;

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

@@ -0,0 +1,114 @@
+const path = require('path');
+
+class FileContextGrouper {
+    constructor(featureDetector, platformDetector = null) {
+        this.featureDetector = featureDetector;
+        this.platformDetector = platformDetector;
+    }
+
+    group(files) {
+        const byDirectory = new Map();
+        const byPlatform = new Map();
+
+        for (const file of files) {
+            const dir = this.getContextDirectory(file);
+            const platform = this.detectPlatform(file);
+
+            if (!byDirectory.has(dir)) {
+                byDirectory.set(dir, []);
+            }
+            byDirectory.get(dir).push(file);
+
+            if (!byPlatform.has(platform)) {
+                byPlatform.set(platform, []);
+            }
+            byPlatform.get(platform).push(file);
+        }
+
+        const groups = [];
+        const assigned = new Set();
+
+        for (const [dir, dirFiles] of byDirectory.entries()) {
+            if (dirFiles.length >= 2) {
+                const unassigned = dirFiles.filter(f => !assigned.has(f));
+                if (unassigned.length >= 2) {
+                    const platform = this.detectPlatform(unassigned[0]);
+                    groups.push({
+                        context: dir,
+                        platform,
+                        files: unassigned
+                    });
+                    unassigned.forEach(f => assigned.add(f));
+                }
+            }
+        }
+
+        for (const [platform, platformFiles] of byPlatform.entries()) {
+            const unassigned = platformFiles.filter(f => !assigned.has(f));
+            if (unassigned.length >= 2) {
+                groups.push({
+                    context: platform,
+                    platform,
+                    files: unassigned
+                });
+                unassigned.forEach(f => assigned.add(f));
+            }
+        }
+
+        const remaining = files.filter(f => !assigned.has(f));
+        if (remaining.length > 0) {
+            const testFiles = remaining.filter(f => this.featureDetector.isTestFile(f));
+            const nonTestFiles = remaining.filter(f => !this.featureDetector.isTestFile(f));
+
+            if (testFiles.length >= 2) {
+                groups.push({
+                    context: 'tests',
+                    platform: 'test',
+                    files: testFiles,
+                    isTestGroup: true
+                });
+                testFiles.forEach(f => assigned.add(f));
+            }
+
+            if (nonTestFiles.length >= 2) {
+                groups.push({
+                    context: 'misc',
+                    platform: 'other',
+                    files: nonTestFiles,
+                    isMiscGroup: true
+                });
+                nonTestFiles.forEach(f => assigned.add(f));
+            }
+        }
+
+        // Return both groups and orphans
+        const groupedFiles = new Set(groups.flatMap(g => g.files));
+        const orphans = files.filter(f => !groupedFiles.has(f));
+
+        return { groups, orphans };
+    }
+
+    getContextDirectory(file) {
+        const parts = file.split(path.sep);
+        if (parts.length <= 2) {
+            return parts[0] || 'root';
+        }
+        return parts.slice(0, 2).join(path.sep);
+    }
+
+    detectPlatform(file) {
+        // Prefer injected detector if available
+        if (this.platformDetector && typeof this.platformDetector.detectPlatformFromFile === 'function') {
+            const detected = this.platformDetector.detectPlatformFromFile(file);
+            if (detected && detected !== 'other') {
+                return detected;
+            }
+        }
+
+        // Fallback to shared feature detector
+        const detected = this.featureDetector.detectPlatform(file);
+        return detected !== 'shared' ? detected : 'other';
+    }
+}
+
+module.exports = FileContextGrouper;

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

@@ -0,0 +1,53 @@
+class SmartCommitSummaryBuilder {
+    build(suggestions, orphans) {
+        const lines = [];
+
+        if (suggestions.length > 0) {
+            lines.push('📦 Suggested commits:');
+            suggestions.forEach((suggestion, i) => {
+                lines.push(`  ${i + 1}. ${suggestion.message} (${suggestion.files} files)`);
+            });
+        }
+
+        if (orphans.length > 0) {
+            lines.push('');
+            lines.push(`⚠️ Ungrouped files (${orphans.length}):`);
+            orphans.slice(0, 5).forEach(f => {
+                lines.push(`  - ${f}`);
+            });
+            if (orphans.length > 5) {
+                lines.push(`  ... and ${orphans.length - 5} more`);
+            }
+        }
+
+        return lines.join('\n');
+    }
+
+    formatNotification(suggestions, orphans, summary) {
+        if (suggestions.length === 0 && orphans.length === 0) {
+            return null;
+        }
+
+        let message = '';
+
+        if (suggestions.length > 0) {
+            message += `${suggestions.length} commit groups detected:\n`;
+            suggestions.forEach((suggestion, i) => {
+                message += `${i + 1}. ${suggestion.message}\n`;
+            });
+        }
+
+        if (orphans.length > 0) {
+            message += `\n⚠️ ${orphans.length} files need review`;
+        }
+
+        return {
+            title: 'Smart Commit Suggestions',
+            message: message.trim(),
+            level: orphans.length > 0 ? 'warn' : 'info',
+            summary
+        };
+    }
+}
+
+module.exports = SmartCommitSummaryBuilder;

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

@@ -0,0 +1,44 @@
+const CursorTokenRepository = require('../../../infrastructure/repositories/CursorTokenRepository');
+
+class CursorTokenService {
+    constructor({
+        cursorTokenRepository = null,
+        repoRoot = process.cwd(),
+        usageFile,
+        apiUrl,
+        apiToken,
+        fetchImpl,
+        logger = console
+    } = {}) {
+        this.logger = logger;
+        this.repository = cursorTokenRepository || new CursorTokenRepository({
+            repoRoot,
+            usageFile,
+            apiUrl,
+            apiToken,
+            fetchImpl,
+            logger
+        });
+    }
+
+    async getCurrentUsage() {
+        // 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 });
+            return apiUsage;
+        }
+
+        const fileUsage = await this.repository.getUsageFromFile();
+        if (fileUsage) {
+            this.logger.debug?.('CURSOR_SERVICE_USING_FILE', { usage: fileUsage });
+            return fileUsage;
+        }
+
+        this.logger.warn?.('CURSOR_SERVICE_NO_DATA_AVAILABLE');
+        return null;
+    }
+}
+
+module.exports = CursorTokenService;

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

@@ -0,0 +1,109 @@
+const { execSync } = require('child_process');
+
+class TokenMetricsService {
+    constructor(cursorTokenService, thresholds, logger) {
+        this.cursorTokenService = cursorTokenService;
+        this.thresholds = thresholds;
+        this.logger = logger;
+        this.repoRoot = process.cwd();
+    }
+
+    async collectMetrics(fallbackEstimator) {
+        const usage = await this.cursorTokenService.getCurrentUsage();
+        const now = new Date();
+        const maxTokens = this.thresholds.maxTokens;
+
+        let tokensUsed = 0;
+        let source = 'fallback';
+        let untrusted = false;
+        let timestamp = now.toISOString();
+        let stale = true;
+
+        if (usage) {
+            tokensUsed = typeof usage.tokensUsed === 'number' ? usage.tokensUsed : tokensUsed;
+            const usageMaxTokens = typeof usage.maxTokens === 'number' ? usage.maxTokens : maxTokens;
+            if (Number.isFinite(usageMaxTokens)) {
+                // If usage has a maxTokens, use it, otherwise use our threshold default
+                // But wait, the original logic was:
+                // tokensUsed = Math.min(tokensUsed, usageMaxTokens); 
+                // This seems wrong if usageMaxTokens is the limit. 
+                // Let's stick to the original logic for safety but it looks like clamping usage to limit?
+                // Actually if usage.maxTokens is provided by the API, we should probably trust it or update our threshold?
+                // For now, let's keep original behavior:
+                tokensUsed = Math.min(tokensUsed, usageMaxTokens);
+            }
+            source = usage.source || 'realtime';
+            untrusted = Boolean(usage.untrusted);
+            timestamp = usage.timestamp || timestamp;
+            stale = now.getTime() - new Date(timestamp).getTime() > (15 * 60 * 1000); // 15 min stale threshold hardcoded in original service logic or passed in?
+            // The original service had staleThresholdMs passed in constructor. I should probably pass it here too.
+        }
+
+        if (source === 'fallback' && fallbackEstimator) {
+            const fallbackTokens = await this.safeFallbackEstimate(fallbackEstimator);
+            if (fallbackTokens != null) {
+                tokensUsed = fallbackTokens;
+            }
+        }
+
+        tokensUsed = Math.max(0, Math.min(tokensUsed, maxTokens));
+        const percentUsed = maxTokens === 0 ? 0 : (tokensUsed / maxTokens) * 100;
+        const remainingTokens = Math.max(0, maxTokens - tokensUsed);
+
+        let level = this.resolveLevel(percentUsed);
+        if (untrusted) {
+            level = 'ok';
+        }
+        const forceLevel = (process.env.TOKEN_MONITOR_FORCE_LEVEL || '').toLowerCase();
+        if (forceLevel === 'warning' || forceLevel === 'critical' || forceLevel === 'ok') {
+            level = forceLevel;
+        }
+
+        const metrics = {
+            timestamp,
+            tokensUsed,
+            maxTokens,
+            percentUsed: Number(percentUsed.toFixed(2)),
+            remainingTokens,
+            level,
+            source,
+            stale,
+            untrusted
+        };
+
+        if (this.logger && typeof this.logger.debug === 'function') {
+            this.logger.debug('TOKEN_MONITOR_METRICS', metrics);
+        }
+
+        return metrics;
+    }
+
+    async safeFallbackEstimate(fallbackEstimator) {
+        try {
+            const estimate = await fallbackEstimator();
+            if (typeof estimate === 'number' && Number.isFinite(estimate)) {
+                return estimate;
+            }
+            return null;
+        } catch (error) {
+            if (this.logger && this.logger.warn) {
+                this.logger.warn('TOKEN_MONITOR_FALLBACK_FAILED', { error: error.message });
+            }
+            return null;
+        }
+    }
+
+    resolveLevel(percentUsed) {
+        if (percentUsed >= this.thresholds.criticalPercent) {
+            return 'critical';
+        }
+
+        if (percentUsed >= this.thresholds.warningPercent) {
+            return 'warning';
+        }
+
+        return 'ok';
+    }
+}
+
+module.exports = TokenMetricsService;