pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/application/services/PlaybookRunner.js

@@ -0,0 +1,39 @@
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { DomainError, NotFoundError } = require('../../domain/errors');
+
+const PLAYBOOKS_PATH = path.join(process.cwd(), 'scripts', 'hooks-system', 'config', 'playbooks.json');
+
+class PlaybookRunner {
+  constructor(options = {}) {
+    this.cwd = options.cwd || process.cwd();
+    this.playbooks = JSON.parse(fs.readFileSync(PLAYBOOKS_PATH, 'utf8'));
+  }
+
+  list() {
+    return Object.entries(this.playbooks).map(([id, playbook]) => ({ id, ...playbook }));
+  }
+
+  run(id) {
+    const playbook = this.playbooks[id];
+    if (!playbook) {
+      throw new Error(`Playbook '${id}' not found`);
+    }
+
+    for (const step of playbook.steps) {
+      if (step.type === 'command') {
+        const result = spawnSync(step.cmd, {
+          shell: true,
+          stdio: 'inherit',
+          cwd: this.cwd,
+        });
+        if (result.status !== 0) {
+          throw new DomainError(`Step failed: ${step.cmd}`, 'PLAYBOOK_STEP_FAILED', { cmd: step.cmd, status: result.status });
+        }
+      }
+    }
+  }
+}
+
+module.exports = PlaybookRunner;

package/scripts/hooks-system/application/services/PredictiveHookAdvisor.js

@@ -0,0 +1,56 @@
+const fs = require('fs');
+const path = require('path');
+
+const METRICS_FILE = path.join(process.cwd(), '.audit_tmp', 'hook-metrics.jsonl');
+
+class PredictiveHookAdvisor {
+  constructor({ windowSize = 200 } = {}) {
+    this.windowSize = windowSize;
+  }
+
+  loadMetrics() {
+    if (!fs.existsSync(METRICS_FILE)) {
+      return [];
+    }
+    const lines = fs.readFileSync(METRICS_FILE, 'utf8').trim().split('\n').filter(Boolean);
+    const recent = lines.slice(-this.windowSize);
+    return recent.map(line => {
+      try {
+        return JSON.parse(line);
+      } catch (error) {
+        return null;
+      }
+    }).filter(Boolean);
+  }
+
+  getFailureProbabilities() {
+    const metrics = this.loadMetrics();
+    const stats = {};
+
+    for (const metric of metrics) {
+      const key = metric.hook || 'unknown';
+      if (!stats[key]) {
+        stats[key] = { total: 0, failures: 0 };
+      }
+      stats[key].total += 1;
+      if (metric.status === 'failure') {
+        stats[key].failures += 1;
+      }
+    }
+
+    return Object.entries(stats)
+      .map(([hook, { total, failures }]) => ({
+        hook,
+        total,
+        failures,
+        probability: total > 0 ? failures / total : 0,
+      }))
+      .sort((a, b) => b.probability - a.probability);
+  }
+
+  suggestPreemptiveActions(threshold = 0.3) {
+    return this.getFailureProbabilities().filter(item => item.probability >= threshold);
+  }
+}
+
+module.exports = PredictiveHookAdvisor;

package/scripts/hooks-system/application/services/RealtimeGuardPlugin.js

@@ -0,0 +1,62 @@
+const EvidenceMonitorService = require('./monitoring/EvidenceMonitorService');
+
+class EvidenceRealtimeGuardPlugin {
+    constructor({
+        repoRoot = process.cwd(),
+        notificationCenter = null,
+        logger = console,
+        evidenceMonitor = null
+    } = {}) {
+        this.repoRoot = repoRoot;
+        this.notificationCenter = notificationCenter;
+        this.logger = logger || console;
+
+        this.evidenceMonitor = evidenceMonitor || new EvidenceMonitorService({
+            repoRoot: this.repoRoot,
+            logger: this.logger,
+            notifier: payload => this.forwardNotification(payload)
+        });
+    }
+
+    start() {
+        if (typeof this.evidenceMonitor.start === 'function') {
+            this.evidenceMonitor.start();
+        }
+    }
+
+    stop() {
+        if (typeof this.evidenceMonitor.stop === 'function') {
+            this.evidenceMonitor.stop();
+        }
+    }
+
+    forwardNotification(payload) {
+        if (!payload) {
+            return;
+        }
+        const notification = {
+            message: payload.message || '',
+            level: payload.level || 'info',
+            type: payload.type || 'evidence_plugin',
+            metadata: payload.metadata || {}
+        };
+
+        if (this.notificationCenter && typeof this.notificationCenter.enqueue === 'function') {
+            this.notificationCenter.enqueue(notification);
+            return;
+        }
+
+        const message = `EvidenceMonitor: ${notification.message}`;
+        if (notification.level === 'error') {
+            this.logger.error?.(message, notification.metadata);
+            return;
+        }
+        if (notification.level === 'warn') {
+            this.logger.warn?.(message, notification.metadata);
+            return;
+        }
+        this.logger.info?.(message, notification.metadata);
+    }
+}
+
+module.exports = { EvidenceRealtimeGuardPlugin };

package/scripts/hooks-system/application/services/RealtimeGuardService.js

@@ -0,0 +1,374 @@
+const fs = require('fs');
+const path = require('path');
+const { getGitTreeState, isTreeBeyondLimit } = require('./GitTreeState');
+
+class RealtimeGuardService {
+    /**
+     * @param {Object} dependencies
+     * @param {Object} dependencies.logger
+     * @param {Object} dependencies.notificationService
+     * @param {Object} dependencies.monitors
+     * @param {Object} dependencies.orchestration
+     * @param {Object} dependencies.config
+     */
+    constructor(dependencies = {}) {
+        const {
+            logger,
+            notificationService,
+            monitors,
+            orchestration,
+            config,
+            // Legacy/test options
+            notifier,
+            notifications
+        } = dependencies;
+
+        this.logger = logger || console;
+        this.notificationService = notificationService;
+        this.notifier = typeof notifier === 'function' ? notifier : null;
+        this.notificationsEnabled = notifications !== false;
+        this.monitors = monitors || {};
+        this.orchestration = orchestration;
+        this.config = config || {};
+
+        if (!this.config.debugLogPath) {
+            this.config.debugLogPath = path.join(process.cwd(), '.audit-reports', 'guard-debug.log');
+        }
+
+        this.evidencePath = this.config.evidencePath || path.join(process.cwd(), '.AI_EVIDENCE.json');
+        this.staleThresholdMs = Number(process.env.HOOK_GUARD_EVIDENCE_STALE_THRESHOLD || 60000);
+        this.reminderIntervalMs = Number(process.env.HOOK_GUARD_EVIDENCE_REMINDER_INTERVAL || 60000);
+        this.inactivityGraceMs = Number(process.env.HOOK_GUARD_INACTIVITY_GRACE_MS || 120000);
+        this.pollIntervalMs = Number(process.env.HOOK_GUARD_EVIDENCE_POLL_INTERVAL || 30000);
+        this.pollTimer = null;
+        this.lastStaleNotification = 0;
+        this.lastUserActivityAt = 0;
+
+        this.gitTreeStagedThreshold = Number(process.env.HOOK_GUARD_DIRTY_TREE_STAGED_LIMIT || 10);
+        this.gitTreeUnstagedThreshold = Number(process.env.HOOK_GUARD_DIRTY_TREE_UNSTAGED_LIMIT || 15);
+        this.gitTreeTotalThreshold = Number(process.env.HOOK_GUARD_DIRTY_TREE_TOTAL_LIMIT || 20);
+        this.gitTreeCheckIntervalMs = Number(process.env.HOOK_GUARD_DIRTY_TREE_INTERVAL || 60000);
+        this.gitTreeReminderMs = Number(process.env.HOOK_GUARD_DIRTY_TREE_REMINDER || 300000);
+        this.gitTreeTimer = null;
+        this.lastDirtyTreeNotification = 0;
+        this.dirtyTreeActive = false;
+
+        this.autoRefreshCooldownMs = Number(process.env.HOOK_GUARD_EVIDENCE_AUTO_REFRESH_COOLDOWN || 180000);
+        this.lastAutoRefresh = 0;
+        this.autoRefreshInFlight = false;
+
+        this.watchers = [];
+        this.embedTokenMonitor = process.env.HOOK_GUARD_EMBEDDED_TOKEN_MONITOR === 'true';
+    }
+
+    start() {
+        this.logger.info('Starting RealtimeGuardService...');
+
+        // Start all monitors
+        this._startEvidenceMonitoring();
+        this._startGitTreeMonitoring();
+        this._startActivityMonitoring();
+        this._startDevDocsMonitoring();
+        this._startAstMonitoring();
+
+        if (this.embedTokenMonitor) {
+            this._startTokenMonitoring();
+        }
+
+        this._startGitFlowSync();
+
+        this.logger.info('[RealtimeGuardService] All services started');
+    }
+
+    stop() {
+        this.logger.info('Stopping RealtimeGuardService...');
+
+        this.watchers.forEach(w => w.close());
+        this.watchers = [];
+
+        Object.values(this.monitors).forEach(monitor => {
+            if (typeof monitor.stop === 'function') {
+                monitor.stop();
+            }
+        });
+
+        this.logger.info('[RealtimeGuardService] All services stopped');
+    }
+
+    _startEvidenceMonitoring() {
+        this.monitors.evidence.startPolling(
+            () => this.notify('🔄 Evidence is stale - Auto-refreshing...', 'warning'),
+            () => this.notify('✅ Evidence refreshed successfully', 'success')
+        );
+    }
+
+    _startGitTreeMonitoring() {
+        if (process.env.HOOK_GUARD_DIRTY_TREE_DISABLED === 'true') return;
+
+        this.monitors.gitTree.startMonitoring((state) => {
+            if (state.isBeyondLimit) {
+                const message = `Git tree has too many files: ${state.total} total (${state.staged} staged, ${state.unstaged} unstaged)`;
+                this.notify(message, 'error', { forceDialog: true });
+            } else {
+                this.notify('✅ Git tree is clean', 'success');
+            }
+        });
+    }
+
+    _startTokenMonitoring() {
+        if (!this.monitors.token.isAvailable()) {
+            this.logger.warn('[RealtimeGuardService] Token monitor script not found');
+            return;
+        }
+
+        try {
+            this.monitors.token.start();
+            this.notify('🔋 Token monitor started', 'info');
+        } catch (error) {
+            this.notify(`Failed to start token monitor: ${error.message}`, 'error');
+        }
+    }
+
+    _startGitFlowSync() {
+        if (!this.monitors.gitFlow.autoSyncEnabled) return;
+
+        const syncInterval = setInterval(() => {
+            if (this.monitors.gitFlow.isClean()) {
+                const result = this.monitors.gitFlow.syncBranches();
+                if (result.success) {
+                    this.notify('🔄 Branches synchronized', 'info');
+                }
+            }
+        }, Number(process.env.HOOK_GUARD_GITFLOW_AUTOSYNC_INTERVAL || 300000));
+
+        syncInterval.unref();
+    }
+
+    _startActivityMonitoring() {
+        if (this.monitors.activity) this.monitors.activity.start();
+    }
+
+    _startDevDocsMonitoring() {
+        if (this.monitors.devDocs) this.monitors.devDocs.start();
+    }
+
+    _startAstMonitoring() {
+        if (this.monitors.ast) this.monitors.ast.start();
+    }
+
+    notify(message, level = 'info', options = {}) {
+        const { forceDialog = false, ...metadata } = options;
+        this._appendDebugLog(`NOTIFY|${level}|${forceDialog ? 'force-dialog|' : ''}${message}`);
+
+        if (this.notifier && this.notificationsEnabled) {
+            try {
+                this.notifier(message, level, { ...metadata, forceDialog });
+            } catch (error) {
+                const msg = error && error.message ? error.message : String(error);
+                this._appendDebugLog(`NOTIFIER_ERROR|${msg}`);
+                this.logger?.debug?.('REALTIME_GUARD_NOTIFIER_ERROR', { error: msg });
+            }
+        }
+
+        if (this.notificationService) {
+            this.notificationService.enqueue({
+                message,
+                level,
+                metadata: { ...metadata, forceDialog }
+            });
+        }
+    }
+
+    _appendDebugLog(entry) {
+        try {
+            const timestamp = new Date().toISOString();
+            fs.appendFileSync(this.config.debugLogPath, `[${timestamp}] ${entry}\n`);
+        } catch (error) {
+            console.error('[RealtimeGuardService] Failed to write debug log:', error.message);
+        }
+    }
+
+    appendDebugLog(entry) {
+        this._appendDebugLog(entry);
+    }
+
+    readEvidenceTimestamp() {
+        try {
+            if (!fs.existsSync(this.evidencePath)) {
+                return null;
+            }
+            const raw = fs.readFileSync(this.evidencePath, 'utf8');
+            const json = JSON.parse(raw);
+            const ts = json?.timestamp;
+            if (!ts) {
+                return null;
+            }
+            const ms = new Date(ts).getTime();
+            if (Number.isNaN(ms)) {
+                return null;
+            }
+            return ms;
+        } catch (error) {
+            const msg = error && error.message ? error.message : String(error);
+            this._appendDebugLog(`EVIDENCE_TIMESTAMP_ERROR|${msg}`);
+            this.logger?.debug?.('REALTIME_GUARD_EVIDENCE_TIMESTAMP_ERROR', { error: msg });
+            return null;
+        }
+    }
+
+    evaluateEvidenceAge(source = 'manual', notifyFresh = false) {
+        const now = Date.now();
+        const timestamp = this.readEvidenceTimestamp();
+        if (!timestamp) {
+            return;
+        }
+
+        const ageMs = now - timestamp;
+        const isStale = ageMs > this.staleThresholdMs;
+        const isRecentlyActive = this.lastUserActivityAt && (now - this.lastUserActivityAt) < this.inactivityGraceMs;
+
+        if (isStale && !isRecentlyActive) {
+            this.triggerStaleAlert(source, ageMs);
+            return;
+        }
+
+        if (notifyFresh && this.lastStaleNotification > 0 && !isStale) {
+            this.notify('Evidence updated; back within SLA.', 'info');
+            this.lastStaleNotification = 0;
+        }
+    }
+
+    triggerStaleAlert(source, ageMs) {
+        const now = Date.now();
+        if (this.lastStaleNotification && (now - this.lastStaleNotification) < this.reminderIntervalMs) {
+            return;
+        }
+
+        this.lastStaleNotification = now;
+        const ageSec = Math.floor(ageMs / 1000);
+        this.notify(`Evidence has been stale for ${ageSec}s (source: ${source}).`, 'warn', { forceDialog: true });
+        void this.attemptAutoRefresh('stale');
+    }
+
+    async attemptAutoRefresh(reason = 'manual') {
+        if (process.env.HOOK_GUARD_AUTO_REFRESH !== 'true') {
+            return;
+        }
+
+        const updateScriptCandidates = [
+            path.join(process.cwd(), 'scripts/hooks-system/bin/update-evidence.sh'),
+            path.join(process.cwd(), 'node_modules/@pumuki/ast-intelligence-hooks/bin/update-evidence.sh'),
+            path.join(process.cwd(), 'bin/update-evidence.sh')
+        ];
+
+        const updateScript = updateScriptCandidates.find(p => fs.existsSync(p));
+        if (!updateScript) {
+            return;
+        }
+
+        const now = Date.now();
+        const ts = this.readEvidenceTimestamp();
+        if (ts && (now - ts) <= this.staleThresholdMs) {
+            return;
+        }
+
+        if (this.lastAutoRefresh && (now - this.lastAutoRefresh) < this.autoRefreshCooldownMs) {
+            return;
+        }
+
+        if (this.autoRefreshInFlight) {
+            return;
+        }
+
+        this.autoRefreshInFlight = true;
+        try {
+            await this.runDirectEvidenceRefresh(reason);
+            this.lastAutoRefresh = now;
+        } finally {
+            this.autoRefreshInFlight = false;
+        }
+    }
+
+    async runDirectEvidenceRefresh(_reason) {
+        return;
+    }
+
+    async evaluateGitTree() {
+        try {
+            const state = getGitTreeState();
+            const limits = {
+                stagedLimit: this.gitTreeStagedThreshold,
+                unstagedLimit: this.gitTreeUnstagedThreshold,
+                totalLimit: this.gitTreeTotalThreshold
+            };
+
+            if (isTreeBeyondLimit(state, limits)) {
+                this.handleDirtyTree(state, limits);
+                return;
+            }
+            this.resolveDirtyTree(state, limits);
+        } catch (error) {
+            this.appendDebugLog(`DIRTY_TREE_ERROR|${error.message}`);
+        }
+    }
+
+    resolveDirtyTree(_state, _limits) {
+        this.dirtyTreeActive = false;
+    }
+
+    handleDirtyTree(_state, limitOrLimits) {
+        const now = Date.now();
+        const limits = typeof limitOrLimits === 'number'
+            ? { totalLimit: limitOrLimits }
+            : (limitOrLimits || {});
+
+        if (this.lastDirtyTreeNotification && (now - this.lastDirtyTreeNotification) < this.gitTreeReminderMs) {
+            return;
+        }
+
+        this.lastDirtyTreeNotification = now;
+        this.dirtyTreeActive = true;
+        this.notify('Git tree is dirty; please stage/unstage to reduce file count.', 'warn', { forceDialog: true, ...limits });
+        this.persistDirtyTreeState();
+    }
+
+    persistDirtyTreeState() {
+        return;
+    }
+
+    startGitTreeMonitoring() {
+        if (this.gitTreeTimer) {
+            clearInterval(this.gitTreeTimer);
+            this.gitTreeTimer = null;
+        }
+
+        const thresholdsValid = this.gitTreeStagedThreshold > 0 || this.gitTreeUnstagedThreshold > 0 || this.gitTreeTotalThreshold > 0;
+        if (!thresholdsValid || this.gitTreeCheckIntervalMs <= 0) {
+            this.gitTreeTimer = null;
+            return;
+        }
+
+        void this.evaluateGitTree();
+        this.gitTreeTimer = setInterval(() => {
+            void this.evaluateGitTree();
+        }, this.gitTreeCheckIntervalMs);
+    }
+
+    startEvidencePolling() {
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+
+        if (this.pollIntervalMs <= 0) {
+            this.pollTimer = null;
+            return;
+        }
+
+        this.pollTimer = setInterval(() => {
+            this.evaluateEvidenceAge('polling');
+        }, this.pollIntervalMs);
+    }
+}
+
+module.exports = RealtimeGuardService;

package/scripts/hooks-system/application/services/SmartDirtyTreeAnalyzer.js

@@ -0,0 +1,63 @@
+const FeatureDetector = require('./commit/FeatureDetector');
+const FileContextGrouper = require('./smart-commit/FileContextGrouper');
+const CommitMessageSuggester = require('./smart-commit/CommitMessageSuggester');
+const SmartCommitSummaryBuilder = require('./smart-commit/SmartCommitSummaryBuilder');
+
+class SmartDirtyTreeAnalyzer {
+    constructor({
+        platformDetector = null,
+        repoRoot = process.cwd(),
+        logger = console
+    } = {}) {
+        this.repoRoot = repoRoot;
+        this.logger = logger;
+
+        this.featureDetector = new FeatureDetector(logger);
+        this.grouper = new FileContextGrouper(this.featureDetector, platformDetector);
+        this.suggester = new CommitMessageSuggester(this.featureDetector);
+        this.summaryBuilder = new SmartCommitSummaryBuilder();
+    }
+
+    analyze(files) {
+        if (!files || !Array.isArray(files) || files.length === 0) {
+            return {
+                groups: [],
+                suggestions: [],
+                orphans: [],
+                shouldAlert: false,
+                summary: 'No files to analyze'
+            };
+        }
+
+        if (this.logger.debug) {
+            this.logger.debug(`[SmartDirtyTreeAnalyzer] Analyzing ${files.length} files`);
+        }
+
+        const { groups, orphans } = this.grouper.group(files);
+        const suggestions = groups.map(g => this.suggester.suggest(g));
+        const summary = this.summaryBuilder.build(suggestions, orphans);
+
+        const shouldAlert = orphans.length > 0 || groups.length > 3;
+
+        return {
+            groups,
+            suggestions,
+            orphans,
+            shouldAlert,
+            summary
+        };
+    }
+
+    formatNotification(analysis) {
+        if (!analysis || !analysis.shouldAlert) {
+            return null;
+        }
+        return this.summaryBuilder.formatNotification(
+            analysis.suggestions,
+            analysis.orphans,
+            analysis.summary
+        );
+    }
+}
+
+module.exports = SmartDirtyTreeAnalyzer;

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

@@ -0,0 +1,36 @@
+const AutonomousOrchestrator = require('../AutonomousOrchestrator');
+
+describe('AutonomousOrchestrator', () => {
+  describe('constructor', () => {
+    it('should be a class', () => {
+      expect(typeof AutonomousOrchestrator).toBe('function');
+    });
+
+    it('should initialize with context engine', () => {
+      const mockContextEngine = { detectContext: jest.fn() };
+      const orchestrator = new AutonomousOrchestrator(mockContextEngine);
+      expect(orchestrator.contextEngine).toBe(mockContextEngine);
+    });
+
+    it('should have confidence thresholds', () => {
+      const mockContextEngine = { detectContext: jest.fn() };
+      const orchestrator = new AutonomousOrchestrator(mockContextEngine);
+      expect(orchestrator.confidenceThresholds).toBeDefined();
+      expect(orchestrator.confidenceThresholds.autoExecute).toBeDefined();
+    });
+  });
+
+  describe('analyzeContext', () => {
+    it('should be a method', () => {
+      const mockContextEngine = { detectContext: jest.fn() };
+      const orchestrator = new AutonomousOrchestrator(mockContextEngine);
+      expect(typeof orchestrator.analyzeContext).toBe('function');
+    });
+  });
+
+  describe('exports', () => {
+    it('should export AutonomousOrchestrator class', () => {
+      expect(AutonomousOrchestrator).toBeDefined();
+    });
+  });
+});

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

@@ -0,0 +1,33 @@
+const ContextDetectionEngine = require('../ContextDetectionEngine');
+
+describe('ContextDetectionEngine', () => {
+  describe('constructor', () => {
+    it('should be a class', () => {
+      expect(typeof ContextDetectionEngine).toBe('function');
+    });
+
+    it('should initialize with repo root', () => {
+      const engine = new ContextDetectionEngine('/test/path');
+      expect(engine.repoRoot).toBe('/test/path');
+    });
+
+    it('should have cache with TTL', () => {
+      const engine = new ContextDetectionEngine();
+      expect(engine.cache).toBeDefined();
+      expect(engine.cache.ttl).toBeDefined();
+    });
+  });
+
+  describe('detectContext', () => {
+    it('should be a method', () => {
+      const engine = new ContextDetectionEngine();
+      expect(typeof engine.detectContext).toBe('function');
+    });
+  });
+
+  describe('exports', () => {
+    it('should export ContextDetectionEngine class', () => {
+      expect(ContextDetectionEngine).toBeDefined();
+    });
+  });
+});