pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/application/services/logging/UnifiedLogger.js

@@ -0,0 +1,142 @@
+const fs = require('fs');
+const path = require('path');
+const { ConfigurationError } = require('../../../domain/errors');
+
+class UnifiedLogger {
+    constructor({
+        component = 'HookSystem',
+        console: consoleConfig = { enabled: true, level: 'info' },
+        file: fileConfig = { enabled: false },
+        defaultData = {}
+    } = {}) {
+        this.component = component;
+        this.consoleConfig = {
+            enabled: consoleConfig.enabled !== false,
+            level: consoleConfig.level || 'info'
+        };
+        this.fileConfig = {
+            enabled: fileConfig.enabled === true,
+            level: fileConfig.level || 'debug',
+            path: fileConfig.path || null,
+            maxSizeBytes: fileConfig.maxSizeBytes || 5 * 1024 * 1024,
+            maxFiles: fileConfig.maxFiles || 5
+        };
+        this.defaultData = defaultData;
+
+        this.levelPriority = new Map([
+            ['debug', 10],
+            ['info', 20],
+            ['warn', 30],
+            ['error', 40]
+        ]);
+
+        if (this.fileConfig.enabled) {
+            if (!this.fileConfig.path) {
+                throw new ConfigurationError('UnifiedLogger file path is required when file logging is enabled', 'fileConfig.path');
+            }
+            const dir = path.dirname(this.fileConfig.path);
+            try {
+                fs.mkdirSync(dir, { recursive: true });
+            } catch (error) {
+                // Directory creation might fail if race condition, can be ignored as next write will retry or fail
+            }
+        }
+    }
+
+    debug(event, data = {}, context = {}) {
+        this.log('debug', event, data, context);
+    }
+
+    info(event, data = {}, context = {}) {
+        this.log('info', event, data, context);
+    }
+
+    warn(event, data = {}, context = {}) {
+        this.log('warn', event, data, context);
+    }
+
+    error(event, data = {}, context = {}) {
+        this.log('error', event, data, context);
+    }
+
+    log(level, event, data = {}, context = {}) {
+        if (!this.levelPriority.has(level)) {
+            throw new ConfigurationError(`Unsupported log level: ${level}`, 'level');
+        }
+
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            component: this.component,
+            event: event || 'LOG',
+            data: { ...this.defaultData, ...data },
+            context
+        };
+
+        if (this.consoleConfig.enabled && this.shouldLog(level, this.consoleConfig.level)) {
+            this.writeConsole(entry);
+        }
+
+        if (this.fileConfig.enabled && this.shouldLog(level, this.fileConfig.level)) {
+            this.writeFile(entry);
+        }
+    }
+
+    shouldLog(level, minLevel) {
+        return this.levelPriority.get(level) >= this.levelPriority.get(minLevel);
+    }
+
+    writeConsole(entry) {
+        const message = `[${entry.timestamp}] [${entry.component}] [${entry.level.toUpperCase()}] ${entry.event}`;
+        const method = console[entry.level] || console.info;
+        method(message, entry.data, entry.context);
+    }
+
+    writeFile(entry) {
+        try {
+            this.rotateFileIfNeeded();
+            fs.appendFileSync(this.fileConfig.path, `${JSON.stringify(entry)}\n`, 'utf8');
+        } catch (error) {
+            if (process.env.DEBUG) {
+                console.error('[UnifiedLogger] Failed to write log file', {
+                    path: this.fileConfig.path,
+                    error: error.message
+                });
+            }
+        }
+    }
+
+    rotateFileIfNeeded() {
+        const { path: filePath, maxSizeBytes, maxFiles } = this.fileConfig;
+
+        if (!fs.existsSync(filePath)) {
+            return;
+        }
+
+        const stats = fs.statSync(filePath);
+        if (stats.size < maxSizeBytes) {
+            return;
+        }
+
+        for (let index = maxFiles - 1; index >= 1; index -= 1) {
+            const src = `${filePath}.${index}`;
+            const dest = `${filePath}.${index + 1}`;
+            if (fs.existsSync(src)) {
+                if (index + 1 > maxFiles) {
+                    fs.rmSync(src, { force: true });
+                } else {
+                    fs.renameSync(src, dest);
+                }
+            }
+        }
+
+        const firstBackup = `${filePath}.1`;
+        if (fs.existsSync(firstBackup) && maxFiles < 1) {
+            fs.rmSync(firstBackup, { force: true });
+        }
+
+        fs.renameSync(filePath, firstBackup);
+    }
+}
+
+module.exports = UnifiedLogger;

package/scripts/hooks-system/application/services/logging/__tests__/UnifiedLogger.spec.js

@@ -0,0 +1,66 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const UnifiedLogger = require('../UnifiedLogger');
+
+describe('UnifiedLogger', () => {
+    let tmpDir;
+    const originalConsole = { ...console };
+
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'unified-logger-'));
+        console.info = jest.fn();
+        console.warn = jest.fn();
+        console.error = jest.fn();
+        console.debug = jest.fn();
+    });
+
+    afterEach(() => {
+        console.info = originalConsole.info;
+        console.warn = originalConsole.warn;
+        console.error = originalConsole.error;
+        console.debug = originalConsole.debug;
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('logs to console and file with structured entry', () => {
+        const logPath = path.join(tmpDir, 'hook.log');
+        const logger = new UnifiedLogger({
+            component: 'TestComponent',
+            console: { enabled: true, level: 'info' },
+            file: { enabled: true, level: 'debug', path: logPath, maxSizeBytes: 1024, maxFiles: 2 }
+        });
+
+        logger.info('TEST_EVENT', { value: 42 });
+
+        expect(console.info).toHaveBeenCalledTimes(1);
+        const consoleArgs = console.info.mock.calls[0];
+        expect(consoleArgs[0]).toContain('[TestComponent]');
+        expect(consoleArgs[0]).toContain('TEST_EVENT');
+
+        const content = fs.readFileSync(logPath, 'utf8').trim();
+        const parsed = JSON.parse(content);
+        expect(parsed.component).toBe('TestComponent');
+        expect(parsed.event).toBe('TEST_EVENT');
+        expect(parsed.data.value).toBe(42);
+    });
+
+    it('rotates files when the max size is exceeded', () => {
+        const logPath = path.join(tmpDir, 'rotate.log');
+        const logger = new UnifiedLogger({
+            component: 'RotateComponent',
+            console: { enabled: false },
+            file: { enabled: true, level: 'debug', path: logPath, maxSizeBytes: 200, maxFiles: 2 }
+        });
+
+        for (let index = 0; index < 20; index += 1) {
+            logger.info('ROTATE_EVENT', { index });
+        }
+
+        const rotatedExists = fs.existsSync(`${logPath}.1`);
+        const mainExists = fs.existsSync(logPath);
+        expect(rotatedExists).toBe(true);
+        expect(mainExists).toBe(true);
+    });
+});

package/scripts/hooks-system/application/services/monitoring/ActivityMonitor.js

@@ -0,0 +1,80 @@
+const fs = require('fs');
+const path = require('path');
+
+class ActivityMonitor {
+    constructor({
+        repoRoot = process.cwd(),
+        inactivityGraceMs = 420000, // 7 minutes
+        logger = console
+    } = {}) {
+        this.repoRoot = repoRoot;
+        this.inactivityGraceMs = inactivityGraceMs;
+        this.logger = logger;
+        this.lastUserActivityAt = Date.now();
+        this.watcher = null;
+        this.debounceTimer = null;
+    }
+
+    start() {
+        if (this.watcher) {
+            return;
+        }
+
+        try {
+            // Watch the git HEAD as a proxy for significant developer activity
+            // Watching the whole repo can be expensive and noisy
+            const gitHeadPath = path.join(this.repoRoot, '.git', 'HEAD');
+
+            if (fs.existsSync(gitHeadPath)) {
+                this.watcher = fs.watch(gitHeadPath, (eventType, filename) => {
+                    this.recordActivity(`git activity: ${filename}`);
+                });
+                this.logger.info('[ActivityMonitor] Started watching .git/HEAD for activity');
+            } else {
+                // Fallback to watching repo root non-recursively for file additions/deletions
+                this.watcher = fs.watch(this.repoRoot, { recursive: false }, (eventType, filename) => {
+                    if (filename && !filename.startsWith('.git') && !filename.startsWith('node_modules')) {
+                        this.recordActivity(`file change: ${filename}`);
+                    }
+                });
+                this.logger.info('[ActivityMonitor] Started watching repo root for activity');
+            }
+        } catch (error) {
+            this.logger.error('[ActivityMonitor] Failed to start watcher:', { error: error.message });
+        }
+    }
+
+    stop() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+    }
+
+    recordActivity(source = 'unknown') {
+        // Debounce activity updates
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+
+        this.debounceTimer = setTimeout(() => {
+            this.lastUserActivityAt = Date.now();
+            this.logger.debug(`[ActivityMonitor] Activity detected via ${source}`);
+        }, 1000);
+    }
+
+    isActive() {
+        const idleTime = Date.now() - this.lastUserActivityAt;
+        return idleTime < this.inactivityGraceMs;
+    }
+
+    getLastActivityTime() {
+        return this.lastUserActivityAt;
+    }
+}
+
+module.exports = ActivityMonitor;

package/scripts/hooks-system/application/services/monitoring/AstMonitor.js

@@ -0,0 +1,140 @@
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+class AstMonitor {
+    constructor({
+        repoRoot = process.cwd(),
+        debounceMs = 8000,
+        cooldownMs = 30000,
+        enabled = true,
+        logger = console,
+        notificationService = null
+    } = {}) {
+        this.repoRoot = repoRoot;
+        this.debounceMs = debounceMs;
+        this.cooldownMs = cooldownMs;
+        this.enabled = enabled;
+        this.logger = logger;
+        this.notificationService = notificationService;
+
+        this.watcher = null;
+        this.timer = null;
+        this.lastRun = 0;
+        this.isRunning = false;
+
+        this.evidencePath = path.join(repoRoot, '.AI_EVIDENCE.json');
+        this.tempDir = path.join(repoRoot, '.audit_tmp');
+        this.astScript = path.join(repoRoot, 'infrastructure', 'ast', 'ast-intelligence.js');
+    }
+
+    start() {
+        if (!this.enabled) {
+            this.logger.info('[AstMonitor] AST Watch disabled');
+            return;
+        }
+
+        if (this.watcher) {
+            return;
+        }
+
+        // Watch for file changes in source directories to trigger AST analysis
+        // We avoid watching node_modules or .git
+        const watchDirs = ['application', 'domain', 'infrastructure', 'presentation', 'hooks', 'bin', 'src'];
+
+        this.logger.info('[AstMonitor] Starting AST watch on source directories');
+
+        try {
+            watchDirs.forEach(dir => {
+                const fullPath = path.join(this.repoRoot, dir);
+                if (fs.existsSync(fullPath)) {
+                    fs.watch(fullPath, { recursive: true }, (eventType, filename) => {
+                        if (filename && (filename.endsWith('.js') || filename.endsWith('.ts'))) {
+                            this.scheduleAnalysis();
+                        }
+                    });
+                }
+            });
+        } catch (error) {
+            this.logger.error('[AstMonitor] Failed to start watchers:', { error: error.message });
+        }
+    }
+
+    stop() {
+        // fs.watch returns FSWatcher which has close(). 
+        // Since we might have multiple watchers (one per dir), we should track them if we want to close properly.
+        // For simplicity in this iteration, we assume the process exit handles it, or we rely on the debounce timer clear.
+
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        // Ideally we would close all FSWatchers here
+    }
+
+    scheduleAnalysis() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+        }
+
+        this.timer = setTimeout(() => {
+            this.runAnalysis();
+        }, this.debounceMs);
+    }
+
+    async runAnalysis() {
+        const now = Date.now();
+        if (now - this.lastRun < this.cooldownMs || this.isRunning) {
+            return;
+        }
+
+        this.isRunning = true;
+        this.lastRun = now;
+        this.logger.info('[AstMonitor] Triggering AST Analysis due to changes');
+
+        if (this.notificationService && typeof this.notificationService.enqueue === 'function') {
+            this.notificationService.enqueue({
+                message: '🔍 Analyzing code changes...',
+                level: 'info',
+                type: 'ast_analysis_start'
+            });
+        }
+
+        const child = spawn('node', [this.astScript], {
+            cwd: this.repoRoot,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+
+        let stderr = '';
+
+        child.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+
+        child.on('close', (code) => {
+            this.isRunning = false;
+            if (code === 0) {
+                this.logger.info('[AstMonitor] AST Analysis complete');
+                if (this.notificationService && typeof this.notificationService.enqueue === 'function') {
+                    this.notificationService.enqueue({
+                        message: '✅ AST Analysis updated',
+                        level: 'info',
+                        type: 'ast_analysis_success'
+                    });
+                }
+            } else {
+                this.logger.error('[AstMonitor] AST Analysis failed', { code, stderr });
+                if (this.notificationService && typeof this.notificationService.enqueue === 'function') {
+                    this.notificationService.enqueue({
+                        message: '❌ AST Analysis failed',
+                        level: 'error',
+                        type: 'ast_analysis_error',
+                        metadata: { code, stderr }
+                    });
+                }
+            }
+        });
+    }
+}
+
+module.exports = AstMonitor;

package/scripts/hooks-system/application/services/monitoring/DevDocsMonitor.js

@@ -0,0 +1,85 @@
+const fs = require('fs');
+const path = require('path');
+
+class DevDocsMonitor {
+    constructor({
+        repoRoot = process.cwd(),
+        checkIntervalMs = 300000, // 5 minutes
+        staleThresholdMs = 86400000, // 24 hours
+        autoRefreshEnabled = true,
+        logger = console,
+        notificationService = null
+    } = {}) {
+        this.repoRoot = repoRoot;
+        this.checkIntervalMs = checkIntervalMs;
+        this.staleThresholdMs = staleThresholdMs;
+        this.autoRefreshEnabled = autoRefreshEnabled;
+        this.logger = logger;
+        this.notificationService = notificationService;
+        this.timer = null;
+        this.docsStatePath = path.join(repoRoot, '.audit_tmp', 'dev-docs-state.json');
+    }
+
+    start() {
+        if (!this.autoRefreshEnabled) {
+            this.logger.info('[DevDocsMonitor] Auto-refresh disabled');
+            return;
+        }
+
+        this.checkDocs();
+        this.timer = setInterval(() => this.checkDocs(), this.checkIntervalMs);
+        if (this.timer.unref) {
+            this.timer.unref();
+        }
+        this.logger.info('[DevDocsMonitor] Started');
+    }
+
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+
+    async checkDocs() {
+        try {
+            const rulesFiles = [
+                'rulesbackend.mdc',
+                'rulesfront.mdc',
+                'rulesios.mdc',
+                'rulesandroid.mdc'
+            ];
+
+            const staleDocs = [];
+
+            for (const file of rulesFiles) {
+                const filePath = path.join(this.repoRoot, '.cursor', 'rules', file);
+                if (fs.existsSync(filePath)) {
+                    const stats = fs.statSync(filePath);
+                    const ageMs = Date.now() - stats.mtime.getTime();
+                    if (ageMs > this.staleThresholdMs) {
+                        staleDocs.push(file);
+                    }
+                }
+            }
+
+            if (staleDocs.length > 0) {
+                const message = `⚠️ Developer documentation (${staleDocs.length} files) may be stale.`;
+                this.logger.warn(`[DevDocsMonitor] Stale docs detected: ${staleDocs.join(', ')}`);
+
+                if (this.notificationService && typeof this.notificationService.enqueue === 'function') {
+                    this.notificationService.enqueue({
+                        message,
+                        level: 'warn',
+                        type: 'docs_stale',
+                        metadata: { staleDocs }
+                    });
+                }
+            }
+        } catch (error) {
+            this.logger.error('[DevDocsMonitor] Failed to check docs:', { error: error.message });
+        }
+    }
+}
+
+module.exports = DevDocsMonitor;

package/scripts/hooks-system/application/services/monitoring/EvidenceMonitor.js

@@ -0,0 +1,103 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { ConfigurationError, DomainError } = require('../../../domain/errors');
+
+class EvidenceMonitor {
+    constructor(repoRoot, options = {}) {
+        this.repoRoot = repoRoot;
+        this.staleThresholdMs = options.staleThresholdMs || 180000;
+        this.pollIntervalMs = options.pollIntervalMs || 30000;
+        this.reminderIntervalMs = options.reminderIntervalMs || 60000;
+        this.lastStaleNotification = 0;
+        this.pollTimer = null;
+        this.evidencePath = path.join(repoRoot, '.AI_EVIDENCE.json');
+        this.tempDir = path.join(repoRoot, '.audit_tmp');
+        this.updateScript = this.resolveUpdateEvidenceScript();
+    }
+
+    resolveUpdateEvidenceScript() {
+        const candidates = [
+            path.join(this.repoRoot, 'node_modules/@pumuki/ast-intelligence-hooks/bin/update-evidence.sh'),
+            path.join(this.repoRoot, 'bin/update-evidence.sh')
+        ];
+
+        for (const candidate of candidates) {
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+
+        return null;
+    }
+
+    isStale() {
+        try {
+            if (!fs.existsSync(this.evidencePath)) {
+                return true;
+            }
+
+            const stats = fs.statSync(this.evidencePath);
+            const ageMs = Date.now() - stats.mtime.getTime();
+            return ageMs > this.staleThresholdMs;
+        } catch (error) {
+            return true;
+        }
+    }
+
+    async refresh() {
+        if (!this.updateScript) {
+            throw new ConfigurationError('Update evidence script not found', 'updateScript');
+        }
+
+        return new Promise((resolve, reject) => {
+            const child = require('child_process').spawn('bash', [this.updateScript, '--auto', '--refresh-only'], {
+                cwd: this.repoRoot,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+
+            let output = '';
+            child.stdout.on('data', (data) => {
+                output += data.toString();
+            });
+
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve(output);
+                } else {
+                    reject(new DomainError(`Evidence refresh failed with code ${code}`, 'EVIDENCE_REFRESH_FAILED'));
+                }
+            });
+
+            child.on('error', reject);
+        });
+    }
+
+    startPolling(onStale, onRefreshed) {
+        this.pollTimer = setInterval(async () => {
+            if (this.isStale()) {
+                const now = Date.now();
+                if (now - this.lastStaleNotification > this.reminderIntervalMs) {
+                    this.lastStaleNotification = now;
+                    onStale && onStale();
+
+                    try {
+                        await this.refresh();
+                        onRefreshed && onRefreshed();
+                    } catch (error) {
+                        console.error('[EvidenceMonitor] Failed to refresh:', error.message);
+                    }
+                }
+            }
+        }, this.pollIntervalMs);
+    }
+
+    stop() {
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+}
+
+module.exports = EvidenceMonitor;