pumuki-ast-hooks 5.3.1

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

@@ -0,0 +1,160 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const fsPromises = fs.promises;
+const CursorTokenService = require('./CursorTokenService');
+const NotificationCenterService = require('../notification/NotificationCenterService');
+const TokenMetricsService = require('./TokenMetricsService');
+const TokenStatusReporter = require('./TokenStatusReporter');
+
+class TokenMonitorService {
+    constructor({
+        repoRoot = process.cwd(),
+        dataFile = null,
+        stateFile = null,
+        notificationService = null,
+        notificationCenter = null,
+        logger = console,
+        thresholds = {},
+        staleThresholdMs = 15 * 60 * 1000,
+        fallbackEstimator = null,
+        cursorTokenService = null
+    } = {}) {
+        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');
+        this.logger = logger || console;
+
+        this.notificationService = notificationService || notificationCenter || new NotificationCenterService({
+            repoRoot: this.repoRoot,
+            logger: this.logger
+        });
+
+        this.thresholds = {
+            maxTokens: thresholds.maxTokens ?? 1_000_000,
+            warningPercent: thresholds.warningPercent ?? 90,
+            criticalPercent: thresholds.criticalPercent ?? 95
+        };
+        this.staleThresholdMs = staleThresholdMs;
+        this.fallbackEstimator = fallbackEstimator || this.defaultFallbackEstimator.bind(this);
+
+        this.cursorTokenService = cursorTokenService || new CursorTokenService({
+            repoRoot: this.repoRoot,
+            usageFile: this.dataFile,
+            logger: this.logger
+        });
+
+        this.metricsService = new TokenMetricsService(this.cursorTokenService, this.thresholds, this.logger);
+        this.statusReporter = new TokenStatusReporter(this.stateFile);
+    }
+
+    async run() {
+        // Collect metrics
+        const metrics = await this.metricsService.collectMetrics(this.fallbackEstimator);
+
+        // Write status file
+        await this.statusReporter.writeStatusFile(metrics);
+
+        // Notify
+        await this.emitNotification(metrics);
+
+        return metrics;
+    }
+
+    async defaultFallbackEstimator() {
+        try {
+            const commitCommand = 'git rev-list --count HEAD --since="1 hour ago"';
+            const filesCommand = 'git diff --name-only HEAD~1 HEAD';
+
+            let commitsCount = 0;
+            let filesModified = 0;
+
+            try {
+                const commitsOutput = execSync(commitCommand, {
+                    cwd: this.repoRoot,
+                    stdio: ['ignore', 'pipe', 'ignore']
+                });
+                commitsCount = parseInt(commitsOutput.toString('utf8').trim(), 10);
+            } catch (error) {
+                const msg = error && error.message ? error.message : String(error);
+                this.logger?.debug?.('TOKEN_MONITOR_FALLBACK_COMMITS_FAILED', { error: msg });
+                commitsCount = 0;
+            }
+
+            try {
+                const filesOutput = execSync(filesCommand, {
+                    cwd: this.repoRoot,
+                    stdio: ['ignore', 'pipe', 'ignore']
+                });
+                filesModified = filesOutput.toString('utf8').split('\n').filter(Boolean).length;
+            } catch (error) {
+                const msg = error && error.message ? error.message : String(error);
+                this.logger?.debug?.('TOKEN_MONITOR_FALLBACK_FILES_FAILED', { error: msg });
+                filesModified = 0;
+            }
+
+            const estimated = commitsCount * 10_000 + filesModified * 2_000 + 5_000;
+            return estimated;
+        } catch (error) {
+            if (this.logger && this.logger.error) {
+                this.logger.error('TOKEN_MONITOR_DEFAULT_ESTIMATE_FAILED', { error: error.message });
+            }
+            return null;
+        }
+    }
+
+    async emitNotification(metrics) {
+        if (!this.notificationService) {
+            return;
+        }
+
+        const metadata = {
+            percentUsed: metrics.percentUsed,
+            tokensUsed: metrics.tokensUsed,
+            remainingTokens: metrics.remainingTokens,
+            source: metrics.source,
+            stale: metrics.stale,
+            untrusted: metrics.untrusted
+        };
+
+        if (metrics.untrusted) {
+            this.notificationService.enqueue({
+                message: `Token usage is heuristic (${metrics.percentUsed}%). Waiting for real metrics before alerting.`,
+                level: 'info',
+                type: 'token_ok',
+                metadata
+            });
+            return;
+        }
+
+        if (metrics.level === 'critical') {
+            this.notificationService.enqueue({
+                message: `🚨 Tokens at ${metrics.percentUsed}% (${this.statusReporter.formatNumber(metrics.tokensUsed)} used). Remaining ${this.statusReporter.formatNumber(metrics.remainingTokens)}.`,
+                level: 'error',
+                type: 'token_critical',
+                metadata: { ...metadata, forceDialog: true }
+            });
+            return;
+        }
+
+        if (metrics.level === 'warning') {
+            this.notificationService.enqueue({
+                message: `⚠️ Tokens at ${metrics.percentUsed}% (${this.statusReporter.formatNumber(metrics.tokensUsed)} used).`,
+                level: 'warn',
+                type: 'token_warning',
+                metadata
+            });
+            return;
+        }
+
+        this.notificationService.enqueue({
+            message: `Token usage healthy (${metrics.percentUsed}% used).`,
+            level: 'info',
+            type: 'token_ok',
+            metadata
+        });
+    }
+}
+
+module.exports = TokenMonitorService;

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

@@ -0,0 +1,56 @@
+const fs = require('fs');
+const fsPromises = fs.promises;
+
+class TokenStatusReporter {
+    constructor(stateFile) {
+        this.stateFile = stateFile;
+    }
+
+    async writeStatusFile(metrics) {
+        const lines = [];
+        lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        lines.push('🔋 TOKEN USAGE - Current Session');
+        lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        lines.push('');
+        lines.push(`Status: ${metrics.level.toUpperCase()}${metrics.stale ? ' (stale data)' : ''}`);
+        lines.push(`Tokens Used: ${this.formatNumber(metrics.tokensUsed)} / ${this.formatNumber(metrics.maxTokens)} (${metrics.percentUsed}%)`);
+        lines.push(`Remaining: ${this.formatNumber(metrics.remainingTokens)} tokens`);
+        lines.push(`Source: ${metrics.source}`);
+        lines.push('');
+
+        if (metrics.level === 'critical') {
+            lines.push('🚨 CRITICAL: Approaching token limit!');
+            lines.push('   → Save your work and prepare for context switch');
+            lines.push('');
+        } else if (metrics.level === 'warning') {
+            lines.push('⚠️  WARNING: High token usage');
+            lines.push('   → Consider wrapping up current task');
+            lines.push('');
+        } else {
+            lines.push('✅ Token usage healthy');
+            lines.push('   → Continue working normally');
+            lines.push('');
+        }
+
+        if (metrics.untrusted) {
+            lines.push('⚠️  Data marked as heuristic/untrusted. Verify token feed.');
+            lines.push('');
+        }
+
+        if (metrics.stale) {
+            lines.push('ℹ️  Data is stale. Ensure guards are running and refreshing token usage.');
+            lines.push('');
+        }
+
+        lines.push(`Last updated: ${new Date().toISOString()}`);
+        lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+        await fsPromises.writeFile(this.stateFile, `${lines.join('\n')}\n`, 'utf8');
+    }
+
+    formatNumber(value) {
+        return value.toLocaleString('en-US');
+    }
+}
+
+module.exports = TokenStatusReporter;

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

@@ -0,0 +1,69 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const CursorTokenService = require('../CursorTokenService');
+
+describe('CursorTokenService', () => {
+    let tmpDir;
+    let usageFile;
+
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cursor-token-'));
+        usageFile = path.join(tmpDir, 'token-usage.jsonl');
+    });
+
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('returns data from API when available', async () => {
+        const fetchMock = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({ tokensUsed: 500000, maxTokens: 1000000, percentUsed: 50, timestamp: '2025-11-10T10:00:00Z' })
+        });
+
+        const service = new CursorTokenService({
+            apiUrl: 'https://example.com/usage',
+            apiToken: 'token',
+            fetchImpl: fetchMock,
+            usageFile
+        });
+
+        const result = await service.getCurrentUsage();
+
+        expect(result).toMatchObject({ source: 'api', tokensUsed: 500000, percentUsed: 50 });
+        expect(fetchMock).toHaveBeenCalled();
+    });
+
+    it.skip('falls back to file when API fails', async () => {
+        const fetchMock = jest.fn().mockResolvedValue({ ok: false, status: 500 });
+        const records = [
+            { timestamp: '2025-11-10T11:00:00Z', tokensUsed: 300000, maxTokens: 1000000, percentUsed: 30 }
+        ];
+        fs.writeFileSync(usageFile, records.map(record => JSON.stringify(record)).join('\n'));
+
+        const service = new CursorTokenService({
+            apiUrl: 'https://example.com/usage',
+            fetchImpl: fetchMock,
+            usageFile,
+            logger: { warn: jest.fn(), error: jest.fn() }
+        });
+
+        const result = await service.getCurrentUsage();
+
+        expect(result).toMatchObject({ source: 'file', tokensUsed: 300000, percentUsed: 30 });
+    });
+
+    it('marks heuristic records as untrusted', async () => {
+        const record = { timestamp: '2025-11-10T09:00:00Z', tokensUsed: 900000, maxTokens: 1000000, source: 'heuristic' };
+        fs.writeFileSync(usageFile, `${JSON.stringify(record)}\n`);
+
+        const service = new CursorTokenService({ usageFile });
+
+        const result = await service.getCurrentUsage();
+
+        expect(result.untrusted).toBe(true);
+        expect(result.source).toBe('heuristic');
+    });
+});

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

@@ -0,0 +1,185 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const TokenMonitorService = require('../TokenMonitorService');
+
+describe('TokenMonitorService', () => {
+    let tmpDir;
+    let notificationCenter;
+    let logger;
+    let cursorTokenService;
+
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'token-monitor-'));
+        notificationCenter = { enqueue: jest.fn() };
+        logger = { info: jest.fn(), warn: jest.fn(), error: jest.fn() };
+        cursorTokenService = { getCurrentUsage: jest.fn() };
+    });
+
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('debe calcular métricas utilizando datos recientes del jsonl', async () => {
+        const record = {
+            timestamp: new Date().toISOString(),
+            tokensUsed: 250000,
+            maxTokens: 1_000_000,
+            percentUsed: 25
+        };
+
+        const service = new TokenMonitorService({
+            repoRoot: tmpDir,
+            notificationCenter,
+            logger,
+            staleThresholdMs: 30 * 60 * 1000,
+            cursorTokenService,
+            fallbackEstimator: () => null
+        });
+
+        cursorTokenService.getCurrentUsage.mockResolvedValue({
+            timestamp: record.timestamp,
+            tokensUsed: record.tokensUsed,
+            maxTokens: record.maxTokens,
+            percentUsed: record.percentUsed,
+            source: 'file'
+        });
+
+        const metrics = await service.run();
+
+        expect(metrics.tokensUsed).toBe(250000);
+        expect(metrics.percentUsed).toBe(25);
+        expect(metrics.level).toBe('ok');
+        expect(metrics.stale).toBe(false);
+        expect(notificationCenter.enqueue).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'token_ok'
+        }));
+
+        const statusFile = path.join(tmpDir, '.AI_TOKEN_STATUS.txt');
+        expect(fs.existsSync(statusFile)).toBe(true);
+        const statusContent = fs.readFileSync(statusFile, 'utf8');
+        expect(statusContent).toContain('Tokens Used');
+    });
+
+    it('debe usar el estimador fallback cuando no hay datos', async () => {
+        const service = new TokenMonitorService({
+            repoRoot: tmpDir,
+            notificationCenter,
+            logger,
+            fallbackEstimator: () => 910000,
+            cursorTokenService
+        });
+
+        cursorTokenService.getCurrentUsage.mockResolvedValue(null);
+
+        const metrics = await service.run();
+
+        expect(metrics.tokensUsed).toBe(910000);
+        expect(metrics.source).toBe('fallback');
+        expect(metrics.level).toBe('warning');
+        expect(notificationCenter.enqueue).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'token_warning'
+        }));
+    });
+
+    it('debe emitir alerta crítica cuando supera el umbral', async () => {
+        const record = {
+            timestamp: new Date().toISOString(),
+            tokensUsed: 960000,
+            maxTokens: 1_000_000,
+            percentUsed: 96
+        };
+
+        const service = new TokenMonitorService({
+            repoRoot: tmpDir,
+            notificationCenter,
+            logger,
+            fallbackEstimator: () => null,
+            cursorTokenService
+        });
+
+        cursorTokenService.getCurrentUsage.mockResolvedValue({
+            timestamp: record.timestamp,
+            tokensUsed: record.tokensUsed,
+            maxTokens: record.maxTokens,
+            percentUsed: record.percentUsed,
+            source: 'file'
+        });
+
+        const metrics = await service.run();
+
+        expect(metrics.level).toBe('critical');
+        expect(notificationCenter.enqueue).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'token_critical'
+        }));
+    });
+
+    it('debe marcar datos como stale cuando el registro es antiguo', async () => {
+        const oldTimestamp = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000).toISOString();
+        const record = {
+            timestamp: oldTimestamp,
+            tokensUsed: 120000,
+            maxTokens: 1_000_000,
+            percentUsed: 12
+        };
+
+        const service = new TokenMonitorService({
+            repoRoot: tmpDir,
+            notificationCenter,
+            logger,
+            staleThresholdMs: 60 * 60 * 1000,
+            fallbackEstimator: () => 50000,
+            cursorTokenService
+        });
+
+        cursorTokenService.getCurrentUsage.mockResolvedValue({
+            timestamp: oldTimestamp,
+            tokensUsed: record.tokensUsed,
+            maxTokens: record.maxTokens,
+            percentUsed: record.percentUsed,
+            source: 'file'
+        });
+
+        const metrics = await service.run();
+
+        expect(metrics.stale).toBe(true);
+        expect(metrics.source).toBe('file');
+        expect(notificationCenter.enqueue).toHaveBeenCalled();
+    });
+
+    it('debe marcar registros heurísticos como no confiables y evitar alertas', async () => {
+        const record = {
+            timestamp: new Date().toISOString(),
+            tokensUsed: 950000,
+            maxTokens: 1_000_000,
+            percentUsed: 95,
+            source: 'heuristic'
+        };
+
+        const service = new TokenMonitorService({
+            repoRoot: tmpDir,
+            notificationCenter,
+            logger,
+            fallbackEstimator: () => null,
+            cursorTokenService
+        });
+
+        cursorTokenService.getCurrentUsage.mockResolvedValue({
+            timestamp: record.timestamp,
+            tokensUsed: record.tokensUsed,
+            maxTokens: record.maxTokens,
+            percentUsed: 95,
+            source: 'heuristic',
+            untrusted: true
+        });
+
+        const metrics = await service.run();
+
+        expect(metrics.untrusted).toBe(true);
+        expect(metrics.source).toBe('heuristic');
+        expect(notificationCenter.enqueue).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'token_ok'
+        }));
+    });
+});

package/scripts/hooks-system/application/state/HookSystemStateMachine.js

@@ -0,0 +1,59 @@
+const fs = require('fs');
+const path = require('path');
+const { toErrorMessage } = require('../../infrastructure/utils/error-utils');
+const { DomainError } = require('../../domain/errors');
+
+const STATE_FILE = path.join(process.cwd(), '.audit_tmp', 'autonomous-state.json');
+const STATE_MAP_PATH = path.join(__dirname, '..', '..', 'config', 'state-map.json');
+
+class HookSystemStateMachine {
+  constructor(options = {}) {
+    this.stateMap = JSON.parse(fs.readFileSync(STATE_MAP_PATH, 'utf8'));
+    this.defaultState = options.defaultState || 'idle';
+    this.state = this.loadState();
+  }
+
+  loadState() {
+    try {
+      if (fs.existsSync(STATE_FILE)) {
+        const data = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+        if (data && data.state && this.stateMap[data.state]) {
+          return data.state;
+        }
+      }
+    } catch (error) {
+      console.error(`[HookSystemStateMachine] Failed to load state: ${toErrorMessage(error)}`);
+    }
+    this.persistState(this.defaultState);
+    return this.defaultState;
+  }
+
+  persistState(state) {
+    const dir = path.dirname(STATE_FILE);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(STATE_FILE, JSON.stringify({ state, updatedAt: Date.now() }, null, 2));
+  }
+
+  getState() {
+    return this.state;
+  }
+
+  canTransition(event) {
+    const stateConfig = this.stateMap[this.state];
+    return Boolean(stateConfig && stateConfig.on && stateConfig.on[event]);
+  }
+
+  transition(event) {
+    if (!this.canTransition(event)) {
+      throw new DomainError(`Invalid transition from '${this.state}' via '${event}'`, 'INVALID_STATE_TRANSITION');
+    }
+    const nextState = this.stateMap[this.state].on[event];
+    this.state = nextState;
+    this.persistState(nextState);
+    return this.state;
+  }
+}
+
+module.exports = HookSystemStateMachine;

package/scripts/hooks-system/application/state/__tests__/HookSystemStateMachine.spec.js

@@ -0,0 +1,115 @@
+const HookSystemStateMachine = require('../HookSystemStateMachine');
+const fs = require('fs');
+const path = require('path');
+
+function makeSUT(options = {}) {
+  return new HookSystemStateMachine(options);
+}
+
+function cleanupStateFile() {
+  const stateFile = path.join(process.cwd(), '.audit_tmp', 'autonomous-state.json');
+  if (fs.existsSync(stateFile)) {
+    fs.unlinkSync(stateFile);
+  }
+}
+
+describe('HookSystemStateMachine', () => {
+  beforeEach(() => {
+    cleanupStateFile();
+  });
+
+  afterEach(() => {
+    cleanupStateFile();
+  });
+
+  describe('constructor', () => {
+    it('should initialize with default state when no options provided', () => {
+      const stateMachine = makeSUT();
+      expect(stateMachine.getState()).toBeDefined();
+    });
+
+    it('should initialize with custom default state', () => {
+      const stateMachine = makeSUT({ defaultState: 'active' });
+      expect(stateMachine.getState()).toBe('active');
+    });
+
+    it('should load state from file if exists', () => {
+      const stateFile = path.join(process.cwd(), '.audit_tmp', 'autonomous-state.json');
+      const stateDir = path.dirname(stateFile);
+      if (!fs.existsSync(stateDir)) {
+        fs.mkdirSync(stateDir, { recursive: true });
+      }
+      const validState = 'idle';
+      fs.writeFileSync(stateFile, JSON.stringify({ state: validState, updatedAt: Date.now() }, null, 2));
+      const stateMachine = makeSUT();
+      expect(stateMachine.getState()).toBe(validState);
+    });
+  });
+
+  describe('getState', () => {
+    it('should return current state', () => {
+      const stateMachine = makeSUT();
+      const state = stateMachine.getState();
+      expect(typeof state).toBe('string');
+    });
+  });
+
+  describe('canTransition', () => {
+    it('should return true for valid transitions', () => {
+      const stateMachine = makeSUT();
+      const canTransition = stateMachine.canTransition('start');
+      expect(typeof canTransition).toBe('boolean');
+    });
+
+    it('should return false for invalid transitions', () => {
+      const stateMachine = makeSUT();
+      const canTransition = stateMachine.canTransition('invalid_event');
+      expect(canTransition).toBe(false);
+    });
+  });
+
+  describe('transition', () => {
+    it('should transition to new state on valid event', () => {
+      const stateMachine = makeSUT();
+      if (stateMachine.canTransition('start')) {
+        const newState = stateMachine.transition('start');
+        expect(newState).toBeDefined();
+        expect(stateMachine.getState()).toBe(newState);
+      }
+    });
+
+    it('should throw error on invalid transition', () => {
+      const stateMachine = makeSUT();
+      expect(() => {
+        stateMachine.transition('invalid_event');
+      }).toThrow('Invalid transition');
+    });
+
+    it('should persist state after transition', () => {
+      const stateMachine = makeSUT();
+      if (stateMachine.canTransition('start')) {
+        const newState = stateMachine.transition('start');
+        const stateFile = path.join(process.cwd(), '.audit_tmp', 'autonomous-state.json');
+        expect(fs.existsSync(stateFile)).toBe(true);
+        const persisted = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+        expect(persisted.state).toBe(newState);
+      }
+    });
+  });
+
+  describe('loadState', () => {
+    it('should return default state when file does not exist', () => {
+      cleanupStateFile();
+      const stateMachine = makeSUT({ defaultState: 'idle' });
+      expect(stateMachine.getState()).toBe('idle');
+    });
+
+    it('should persist default state when loading fails', () => {
+      cleanupStateFile();
+      const stateMachine = makeSUT({ defaultState: 'idle' });
+      const stateFile = path.join(process.cwd(), '.audit_tmp', 'autonomous-state.json');
+      expect(fs.existsSync(stateFile)).toBe(true);
+    });
+  });
+});
+