pumuki-ast-hooks 5.3.1

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

@@ -0,0 +1,162 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function resolveUpdateEvidenceScript(repoRoot) {
+    const candidates = [
+        path.join(repoRoot, 'scripts/hooks-system/bin/update-evidence.sh'),
+        path.join(repoRoot, 'node_modules/@pumuki/ast-intelligence-hooks/bin/update-evidence.sh'),
+        path.join(repoRoot, 'bin/update-evidence.sh')
+    ];
+
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+
+    return null;
+}
+
+class EvidenceMonitorService {
+    constructor({
+        repoRoot = process.cwd(),
+        evidencePath = path.join(process.cwd(), '.AI_EVIDENCE.json'),
+        updateScriptPath = resolveUpdateEvidenceScript(repoRoot) || path.join(process.cwd(), 'scripts', 'hooks-system', 'bin', 'update-evidence.sh'),
+        notifier = () => { },
+        logger = console,
+        autoRefreshEnabled = process.env.HOOK_GUARD_AUTO_REFRESH !== 'false',
+        autoRefreshCooldownMs = Number(process.env.HOOK_GUARD_AUTO_REFRESH_COOLDOWN || 180000),
+        staleThresholdMs = Number(process.env.HOOK_GUARD_EVIDENCE_STALE_THRESHOLD || 10 * 60 * 1000),
+        fsModule = fs,
+        execFn = execSync
+    } = {}) {
+        this.repoRoot = repoRoot;
+        this.evidencePath = evidencePath;
+        this.updateScriptPath = updateScriptPath;
+        this.notifier = notifier;
+        this.logger = logger;
+        this.autoRefreshEnabled = autoRefreshEnabled;
+        this.autoRefreshCooldownMs = autoRefreshCooldownMs;
+        this.staleThresholdMs = staleThresholdMs;
+        this.fs = fsModule;
+        this.exec = execFn;
+        this.watchers = [];
+        this.lastAutoRefresh = 0;
+    }
+
+    start() {
+        this.performInitialChecks();
+        this.watchEvidenceFreshness();
+    }
+
+    stop() {
+        this.watchers.forEach(watcher => {
+            try {
+                watcher.close();
+            } catch (error) {
+                this.logger.warn?.('EVIDENCE_MONITOR_WATCHER_CLOSE_FAILED', { error: error.message });
+            }
+        });
+        this.watchers = [];
+    }
+
+    performInitialChecks() {
+        if (!this.fs.existsSync(this.evidencePath)) {
+            this.notify({
+                message: 'Missing .AI_EVIDENCE.json, run update-evidence.',
+                level: 'warn',
+                type: 'evidence_missing'
+            });
+            this.attemptAutoRefresh('initial-missing');
+        } else {
+            this.evaluateEvidence('initial-check');
+        }
+    }
+
+    watchEvidenceFreshness() {
+        try {
+            const watcher = this.fs.watch(this.evidencePath, () => this.evaluateEvidence('fs-watch'));
+            this.watchers.push(watcher);
+        } catch (error) {
+            this.logger.error?.('EVIDENCE_MONITOR_WATCH_FAILED', { error: error.message });
+        }
+    }
+
+    evaluateEvidence(reason) {
+        try {
+            const raw = this.fs.readFileSync(this.evidencePath, 'utf8');
+            const data = JSON.parse(raw);
+            const timestamp = new Date(data.timestamp).getTime();
+            if (!Number.isFinite(timestamp)) {
+                this.notify({
+                    message: 'Evidence timestamp is invalid.',
+                    level: 'error',
+                    type: 'evidence_invalid'
+                });
+                return;
+            }
+            const age = Date.now() - timestamp;
+            if (age > this.staleThresholdMs) {
+                this.notify({
+                    message: 'Evidence older than allowed threshold, please refresh.',
+                    level: 'warn',
+                    type: 'evidence_stale',
+                    metadata: { ageMs: age }
+                });
+                this.attemptAutoRefresh(reason);
+            }
+        } catch (error) {
+            this.notify({
+                message: `Unable to validate .AI_EVIDENCE.json: ${error.message}`,
+                level: 'error',
+                type: 'evidence_read_error'
+            });
+        }
+    }
+
+    attemptAutoRefresh(reason) {
+        if (!this.autoRefreshEnabled) {
+            return;
+        }
+        if (!this.updateScriptPath || !this.fs.existsSync(this.updateScriptPath)) {
+            this.updateScriptPath = resolveUpdateEvidenceScript(this.repoRoot);
+            if (!this.updateScriptPath || !this.fs.existsSync(this.updateScriptPath)) {
+                return;
+            }
+        }
+        const now = Date.now();
+        if (now - this.lastAutoRefresh < this.autoRefreshCooldownMs) {
+            return;
+        }
+        try {
+            this.exec(`bash ${this.updateScriptPath} --auto --platforms 1,2,3,4`, {
+                cwd: this.repoRoot,
+                stdio: 'ignore'
+            });
+            this.lastAutoRefresh = now;
+            this.notify({
+                message: `Evidence auto-refreshed (${reason}).`,
+                level: 'info',
+                type: 'evidence_ok'
+            });
+        } catch (error) {
+            this.logger.error?.('EVIDENCE_MONITOR_AUTO_REFRESH_FAILED', { error: error.message, reason });
+            this.notify({
+                message: `Auto refresh failed: ${error.message}`,
+                level: 'error',
+                type: 'evidence_refresh_failed'
+            });
+        }
+    }
+
+    notify({ message, level, type = 'evidence_generic', metadata = {} }) {
+        try {
+            this.notifier({ message, level, type, metadata });
+        } catch (error) {
+            this.logger.warn?.('EVIDENCE_MONITOR_NOTIFY_FAILED', { error: error.message });
+        }
+    }
+}
+
+module.exports = EvidenceMonitorService;

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

@@ -0,0 +1,123 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+class GitTreeMonitor {
+    constructor(repoRoot, options = {}) {
+        this.repoRoot = repoRoot;
+        this.stagedThreshold = options.stagedThreshold || 10;
+        this.unstagedThreshold = options.unstagedThreshold || 15;
+        this.totalThreshold = options.totalThreshold || 20;
+        this.checkIntervalMs = options.checkIntervalMs || 60000;
+        this.reminderMs = options.reminderMs || 300000;
+        this.tempDir = path.join(repoRoot, '.audit_tmp');
+        this.markerPath = path.join(this.tempDir, 'dirty-tree-state.json');
+        this.lastNotification = 0;
+        this.isActive = false;
+        this.timer = null;
+        this.lastState = null;
+        this.loadState();
+    }
+
+    loadState() {
+        try {
+            if (fs.existsSync(this.markerPath)) {
+                this.lastState = JSON.parse(fs.readFileSync(this.markerPath, 'utf8'));
+            }
+        } catch (error) {
+            this.lastState = null;
+        }
+    }
+
+    saveState(state) {
+        try {
+            fs.writeFileSync(this.markerPath, JSON.stringify(state, null, 2));
+            this.lastState = state;
+        } catch (error) {
+            console.error('[GitTreeMonitor] Failed to save state:', error.message);
+        }
+    }
+
+    getTreeState() {
+        try {
+            const stagedRaw = execSync('git diff --cached --name-only', {
+                cwd: this.repoRoot,
+                encoding: 'utf8'
+            }).trim();
+            const unstagedRaw = execSync('git diff --name-only', {
+                cwd: this.repoRoot,
+                encoding: 'utf8'
+            }).trim();
+            const untrackedRaw = execSync('git ls-files --others --exclude-standard', {
+                cwd: this.repoRoot,
+                encoding: 'utf8'
+            }).trim();
+
+            const staged = stagedRaw ? stagedRaw.split('\n').length : 0;
+            const unstaged = unstagedRaw ? unstagedRaw.split('\n').length : 0;
+            const untracked = untrackedRaw ? untrackedRaw.split('\n').length : 0;
+            const total = staged + unstaged + untracked;
+
+            return {
+                staged,
+                unstaged,
+                untracked,
+                total,
+                isBeyondLimit: total > this.totalThreshold ||
+                    staged > this.stagedThreshold ||
+                    unstaged > this.unstagedThreshold,
+                timestamp: Date.now()
+            };
+        } catch (error) {
+            return {
+                staged: 0,
+                unstaged: 0,
+                untracked: 0,
+                total: 0,
+                isBeyondLimit: false,
+                error: error.message,
+                timestamp: Date.now()
+            };
+        }
+    }
+
+    startMonitoring(onStateChange) {
+        this.timer = setInterval(() => {
+            const currentState = this.getTreeState();
+
+            if (!this.lastState ||
+                currentState.total !== this.lastState.total ||
+                currentState.isBeyondLimit !== this.lastState.isBeyondLimit) {
+
+                this.saveState(currentState);
+
+                if (currentState.isBeyondLimit) {
+                    this.isActive = true;
+                    const now = Date.now();
+                    if (now - this.lastNotification > this.reminderMs) {
+                        this.lastNotification = now;
+                        onStateChange && onStateChange(currentState);
+                    }
+                } else {
+                    if (this.isActive) {
+                        this.isActive = false;
+                        onStateChange && onStateChange(currentState);
+                    }
+                }
+            }
+        }, this.checkIntervalMs);
+    }
+
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+
+    isActive() {
+        return this.isActive;
+    }
+}
+
+module.exports = GitTreeMonitor;

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

@@ -0,0 +1,114 @@
+class GitTreeMonitorService {
+    constructor({
+        repoRoot = process.cwd(),
+        limit,
+        warning,
+        reminderMs = 300000,
+        intervalMs = 60000,
+        getState,
+        notifier = () => { },
+        logger = console,
+        debugLogger = null
+    } = {}) {
+        this.repoRoot = repoRoot;
+        this.limit = limit;
+        this.warning = warning;
+        this.reminderMs = reminderMs;
+        this.intervalMs = intervalMs;
+        this.getState = getState;
+        this.notifier = notifier;
+        this.logger = logger;
+        this.debugLogger = debugLogger;
+        this.timer = null;
+        this.lastCritical = 0;
+        this.lastWarning = 0;
+        this.wasOverLimit = false;
+    }
+
+    start() {
+        if (!Number.isFinite(this.limit) || this.limit <= 0 || typeof this.getState !== 'function') {
+            return;
+        }
+        this.check('startup');
+        if (this.intervalMs > 0) {
+            this.timer = setInterval(() => this.check('interval'), this.intervalMs);
+            if (this.timer && typeof this.timer.unref === 'function') {
+                this.timer.unref();
+            }
+        }
+    }
+
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+
+    check(reason) {
+        try {
+            const state = this.getState({ repoRoot: this.repoRoot });
+            if (!state) {
+                return;
+            }
+            this.evaluateState(state, reason);
+        } catch (error) {
+            this.logger.error?.('GIT_TREE_MONITOR_FAILED', { error: error.message, reason });
+        }
+    }
+
+    evaluateState(state, reason) {
+        const now = Date.now();
+        const isOverLimit = state.uniqueCount > this.limit || state.stagedCount > this.limit || state.workingCount > this.limit;
+
+        if (this.warning && state.uniqueCount >= this.warning) {
+            const withinWarning = this.lastWarning > 0 && now - this.lastWarning < this.reminderMs;
+            if (!withinWarning) {
+                this.lastWarning = now;
+                this.notify(`Git tree is growing (staged ${state.stagedCount}, working ${state.workingCount}, unique ${state.uniqueCount}) during ${reason}.`, 'warn');
+            }
+        } else {
+            this.lastWarning = 0;
+        }
+
+        if (isOverLimit) {
+            this.wasOverLimit = true;
+            const withinCritical = this.lastCritical > 0 && now - this.lastCritical < this.reminderMs;
+            if (!withinCritical) {
+                this.lastCritical = now;
+                this.lastWarning = now;
+                this.debugLog(`DIRTY_TREE_ALERT|${state.stagedCount}|${state.workingCount}|${state.uniqueCount}`);
+                this.notify(`Git tree limit exceeded (staged ${state.stagedCount}, working ${state.workingCount}, unique ${state.uniqueCount}) during ${reason}.`, 'error');
+            } else {
+                this.debugLog(`DIRTY_TREE_SUPPRESSED|${state.stagedCount}|${state.workingCount}|${state.uniqueCount}`);
+            }
+            return;
+        }
+
+        if (this.wasOverLimit) {
+            this.wasOverLimit = false;
+            this.debugLog(`DIRTY_TREE_CLEAR|${state.stagedCount}|${state.workingCount}|${state.uniqueCount}`);
+        }
+
+        if (state.uniqueCount < this.warning) {
+            this.lastWarning = 0;
+        }
+        this.lastCritical = 0;
+    }
+
+    debugLog(message) {
+        if (typeof this.debugLogger === 'function') {
+            this.debugLogger(message);
+        }
+    }
+
+    notify(message, level) {
+        try {
+            this.notifier(message, level);
+        } catch (error) {
+            this.logger.warn?.('GIT_TREE_MONITOR_NOTIFY_FAILED', { error: error.message });
+        }
+    }
+}
+
+module.exports = GitTreeMonitorService;

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

@@ -0,0 +1,153 @@
+const fs = require('fs');
+const path = require('path');
+
+const defaultHeartbeatPath = repoRoot => path.join(repoRoot, '.audit_tmp', 'guard-heartbeat.json');
+const defaultTokenUsagePath = repoRoot => path.join(repoRoot, '.audit_tmp', 'token-usage.jsonl');
+const defaultEvidencePath = repoRoot => path.join(repoRoot, '.AI_EVIDENCE.json');
+
+const resolvePath = (maybePath, fallback) => {
+    if (!maybePath) {
+        return fallback();
+    }
+    return path.isAbsolute(maybePath) ? maybePath : path.join(process.cwd(), maybePath);
+};
+
+const safeReadJson = targetPath => {
+    const content = fs.readFileSync(targetPath, 'utf8');
+    return JSON.parse(content);
+};
+
+const makeEvidenceProvider = ({ repoRoot, evidencePath }) => async () => {
+    const target = evidencePath || defaultEvidencePath(repoRoot);
+    if (!fs.existsSync(target)) {
+        return { name: 'evidence', status: 'error', details: { message: 'missing .AI_EVIDENCE.json' } };
+    }
+
+    try {
+        const content = safeReadJson(target);
+        const timestamp = new Date(content.timestamp || 0).getTime();
+        if (!Number.isFinite(timestamp) || timestamp === 0) {
+            return { name: 'evidence', status: 'error', details: { message: 'invalid timestamp' } };
+        }
+        const ageMs = Date.now() - timestamp;
+        const status = ageMs > 15 * 60 * 1000 ? 'error' : ageMs > 5 * 60 * 1000 ? 'warn' : 'ok';
+        return {
+            name: 'evidence',
+            status,
+            details: {
+                ageMs,
+                timestamp: content.timestamp
+            }
+        };
+    } catch (error) {
+        return { name: 'evidence', status: 'error', details: { message: error.message } };
+    }
+};
+
+const makeGitTreeProvider = ({ repoRoot, getGitTreeState, warningThreshold = 12, errorThreshold = 24 }) => async () => {
+    if (typeof getGitTreeState !== 'function') {
+        return { name: 'gitTree', status: 'error', details: { message: 'getGitTreeState not provided' } };
+    }
+
+    try {
+        const state = await getGitTreeState({ repoRoot });
+        if (!state) {
+            return { name: 'gitTree', status: 'warn', details: { message: 'no state returned' } };
+        }
+        const unique = state.uniqueCount || 0;
+        const status = unique > errorThreshold ? 'error' : unique > warningThreshold ? 'warn' : 'ok';
+        return { name: 'gitTree', status, details: state };
+    } catch (error) {
+        return { name: 'gitTree', status: 'error', details: { message: error.message } };
+    }
+};
+
+const makeHeartbeatProvider = ({ repoRoot, heartbeatPath }) => async () => {
+    const target = heartbeatPath || defaultHeartbeatPath(repoRoot);
+    if (!fs.existsSync(target)) {
+        return { name: 'heartbeat', status: 'error', details: { message: 'missing heartbeat file' } };
+    }
+
+    try {
+        const data = safeReadJson(target);
+        const timestamp = Date.parse(data.timestamp);
+        if (!Number.isFinite(timestamp)) {
+            return { name: 'heartbeat', status: 'error', details: { message: 'invalid timestamp' } };
+        }
+        const ageMs = Date.now() - timestamp;
+        const statusField = (data.status || '').toLowerCase();
+        const status = ageMs > 60000 || (statusField && statusField !== 'healthy') ? 'warn' : 'ok';
+        return { name: 'heartbeat', status, details: data };
+    } catch (error) {
+        return { name: 'heartbeat', status: 'error', details: { message: error.message } };
+    }
+};
+
+const makeTokenProvider = ({ repoRoot, tokenUsagePath }) => async () => {
+    const target = tokenUsagePath || defaultTokenUsagePath(repoRoot);
+    if (!fs.existsSync(target)) {
+        return { name: 'tokens', status: 'warn', details: { message: 'no usage log found' } };
+    }
+
+    try {
+        const lines = fs.readFileSync(target, 'utf8').trim().split('\n').filter(Boolean);
+        if (!lines.length) {
+            return { name: 'tokens', status: 'warn', details: { message: 'empty token usage log' } };
+        }
+        const last = JSON.parse(lines[lines.length - 1]);
+        const percent = Number.isFinite(Number(last.percentUsed)) ? Number(last.percentUsed) : Number((last.tokensUsed / last.maxTokens) * 100);
+        if (!Number.isFinite(percent)) {
+            return { name: 'tokens', status: 'warn', details: { message: 'token usage percent unavailable' } };
+        }
+        const status = percent >= 95 ? 'error' : percent >= 85 ? 'warn' : 'ok';
+        return { name: 'tokens', status, details: { percent } };
+    } catch (error) {
+        return { name: 'tokens', status: 'error', details: { message: error.message } };
+    }
+};
+
+const makeProcessProvider = ({ name, pidResolver }) => async () => {
+    if (typeof pidResolver !== 'function') {
+        return { name, status: 'warn', details: { message: 'pid resolver missing' } };
+    }
+    try {
+        const pid = await pidResolver();
+        if (!pid) {
+            return { name, status: 'error', details: { message: 'process not running' } };
+        }
+        try {
+            process.kill(pid, 0);
+            return { name, status: 'ok', details: { pid } };
+        } catch (error) {
+            return { name, status: 'error', details: { message: 'process unreachable', pid } };
+        }
+    } catch (error) {
+        return { name, status: 'error', details: { message: error.message } };
+    }
+};
+
+const createHealthCheckProviders = ({
+    repoRoot = process.cwd(),
+    getGitTreeState,
+    heartbeatPath,
+    tokenUsagePath,
+    evidencePath,
+    processes = []
+} = {}) => {
+    const providers = [
+        makeEvidenceProvider({ repoRoot, evidencePath }),
+        makeGitTreeProvider({ repoRoot, getGitTreeState }),
+        makeHeartbeatProvider({ repoRoot, heartbeatPath }),
+        makeTokenProvider({ repoRoot, tokenUsagePath })
+    ];
+
+    processes.forEach(processConfig => {
+        providers.push(makeProcessProvider(processConfig));
+    });
+
+    return providers;
+};
+
+module.exports = {
+    createHealthCheckProviders
+};

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

@@ -0,0 +1,118 @@
+const fs = require('fs');
+const path = require('path');
+
+class HealthCheckService {
+    constructor({
+        repoRoot = process.cwd(),
+        providers = [],
+        notificationCenter = null,
+        logger = console,
+        outputFile = path.join(process.cwd(), '.audit_tmp', 'health-status.json'),
+        historyLimit = 50,
+        intervalMs = 0,
+        timers = { setInterval, clearInterval }
+    } = {}) {
+        this.repoRoot = repoRoot;
+        this.providers = Array.isArray(providers) ? providers : [];
+        this.notificationCenter = notificationCenter;
+        this.logger = logger || console;
+        this.outputFile = outputFile;
+        this.historyLimit = historyLimit;
+        this.intervalMs = intervalMs;
+        this.timers = timers;
+        this.history = [];
+        this.timerRef = null;
+    }
+
+    start(reason = 'startup') {
+        this.collect(reason);
+        if (this.intervalMs > 0) {
+            this.timerRef = this.timers.setInterval(() => this.collect('interval'), this.intervalMs);
+            if (this.timerRef && typeof this.timerRef.unref === 'function') {
+                this.timerRef.unref();
+            }
+        }
+    }
+
+    stop() {
+        if (this.timerRef) {
+            this.timers.clearInterval(this.timerRef);
+            this.timerRef = null;
+        }
+    }
+
+    async collect(reason = 'manual') {
+        const timestamp = new Date().toISOString();
+        const results = [];
+        let overall = 'ok';
+
+        for (const provider of this.providers) {
+            if (typeof provider !== 'function') {
+                continue;
+            }
+            try {
+                const result = await provider({ repoRoot: this.repoRoot, reason });
+                if (!result || !result.name) {
+                    continue;
+                }
+                const status = result.status || 'ok';
+                if (status === 'error') {
+                    overall = 'error';
+                } else if (status === 'warn' && overall !== 'error') {
+                    overall = 'warn';
+                }
+                results.push({
+                    name: result.name,
+                    status,
+                    details: result.details || {}
+                });
+            } catch (error) {
+                overall = 'error';
+                results.push({
+                    name: provider.name || 'provider',
+                    status: 'error',
+                    details: { message: error.message }
+                });
+                this.logger.error?.('HEALTHCHECK_PROVIDER_FAILED', { provider: provider.name, error: error.message });
+            }
+        }
+
+        const payload = {
+            timestamp,
+            reason,
+            status: overall,
+            results
+        };
+
+        this.persist(payload);
+        this.history.unshift(payload);
+        if (this.history.length > this.historyLimit) {
+            this.history.length = this.historyLimit;
+        }
+
+        if (this.notificationCenter && typeof this.notificationCenter.enqueue === 'function') {
+            this.notificationCenter.enqueue({
+                message: `Health check status: ${overall}`,
+                level: overall === 'error' ? 'error' : overall === 'warn' ? 'warn' : 'info',
+                type: `health_check_${overall}`,
+                metadata: { reason, timestamp, results }
+            });
+        }
+
+        return payload;
+    }
+
+    persist(payload) {
+        try {
+            const dir = path.dirname(this.outputFile);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(this.outputFile, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+        } catch (error) {
+            this.logger.error?.('HEALTHCHECK_WRITE_FAILED', { error: error.message });
+        }
+    }
+}
+
+module.exports = { HealthCheckService };