pumuki-ast-hooks 5.5.14 → 5.5.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki-ast-hooks",
-  "version": "5.5.14",
+  "version": "5.5.15",
   "description": "Enterprise-grade AST Intelligence System with multi-platform support (iOS, Android, Backend, Frontend) and Feature-First + DDD + Clean Architecture enforcement. Includes dynamic violations API for intelligent querying.",
   "main": "index.js",
   "bin": {

package/scripts/hooks-system/application/services/installation/ConfigurationGeneratorService.js

@@ -110,6 +110,11 @@ class ConfigurationGeneratorService {
             // Add helper scripts
             packageJson.scripts['ast:refresh'] = 'node scripts/hooks-system/bin/update-evidence.sh';
             packageJson.scripts['ast:audit'] = 'node scripts/hooks-system/infrastructure/ast/ast-intelligence.js';
+            packageJson.scripts['ast:guard:start'] = 'bash scripts/hooks-system/bin/evidence-guard start';
+            packageJson.scripts['ast:guard:stop'] = 'bash scripts/hooks-system/bin/evidence-guard stop';
+            packageJson.scripts['ast:guard:restart'] = 'bash scripts/hooks-system/bin/evidence-guard restart';
+            packageJson.scripts['ast:guard:status'] = 'bash scripts/hooks-system/bin/evidence-guard status';
+            packageJson.scripts['ast:guard:logs'] = 'bash scripts/hooks-system/bin/evidence-guard logs';
 
             fs.writeFileSync(projectPackageJsonPath, JSON.stringify(packageJson, null, 2));
             this.logSuccess('npm scripts added');

package/scripts/hooks-system/application/services/installation/InstallService.js

@@ -123,10 +123,48 @@ class InstallService {
         this.logStep('8/8', 'Adding npm scripts to package.json...');
         this.configGenerator.addNpmScripts();
 
+        this.logStep('8.5/8', 'Starting evidence guard daemon...');
+        this.startEvidenceGuard();
+
         this.logger.info('INSTALLATION_COMPLETED_SUCCESSFULLY');
         this.printFooter();
     }
 
+    startEvidenceGuard() {
+        const { spawn } = require('child_process');
+        const guardScript = path.join(this.targetRoot, 'scripts/hooks-system/bin/evidence-guard');
+
+        if (!fs.existsSync(guardScript)) {
+            this.logWarning('Evidence guard script not found, skipping daemon start');
+            return;
+        }
+
+        try {
+            const child = spawn('bash', [guardScript, 'start'], {
+                cwd: this.targetRoot,
+                stdio: 'pipe',
+                detached: false
+            });
+
+            let output = '';
+            child.stdout.on('data', (data) => { output += data.toString(); });
+            child.stderr.on('data', (data) => { output += data.toString(); });
+
+            child.on('close', (code) => {
+                if (code === 0) {
+                    this.logSuccess('Evidence guard daemon started');
+                } else {
+                    this.logWarning('Failed to start evidence guard daemon');
+                    if (output) {
+                        console.log(output);
+                    }
+                }
+            });
+        } catch (error) {
+            this.logWarning(`Failed to start evidence guard: ${error.message}`);
+        }
+    }
+
     printHeader() {
         const versionPadded = `v${this.version}`.padStart(24).padEnd(48);
         process.stdout.write(`${COLORS.blue}
@@ -141,6 +179,10 @@ ${COLORS.reset}\n`);
         process.stdout.write(`
 ${COLORS.green}✨ Installation Complete! ✨${COLORS.reset}
 
+${COLORS.cyan}Evidence Guard Daemon:${COLORS.reset}
+- Auto-refresh is now running in background (every 180 seconds)
+- Manage with: ${COLORS.yellow}npm run ast:guard:{start|stop|status|logs}${COLORS.reset}
+
 ${COLORS.cyan}Next Steps:${COLORS.reset}
 1. Review generated configuration in ${COLORS.yellow}scripts/hooks-system/config/project.config.json${COLORS.reset}
 2. Run ${COLORS.yellow}./manage-library.sh verify${COLORS.reset} to check installation

package/scripts/hooks-system/bin/evidence-guard

@@ -0,0 +1,110 @@
+#!/bin/bash
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+GUARD_SCRIPT="$SCRIPT_DIR/../infrastructure/daemons/evidence-guard.js"
+PID_FILE="$PROJECT_ROOT/.evidence-guard.pid"
+LOG_FILE="$PROJECT_ROOT/.evidence-guard.log"
+
+command="${1:-status}"
+
+case "$command" in
+    start)
+        if [ -f "$PID_FILE" ]; then
+            PID=$(cat "$PID_FILE")
+            if kill -0 "$PID" 2>/dev/null; then
+                echo "Evidence guard is already running (PID: $PID)"
+                exit 0
+            else
+                rm -f "$PID_FILE"
+            fi
+        fi
+
+        echo "Starting evidence guard..."
+        nohup node "$GUARD_SCRIPT" > "$LOG_FILE" 2>&1 &
+        sleep 1
+
+        if [ -f "$PID_FILE" ]; then
+            PID=$(cat "$PID_FILE")
+            echo "Evidence guard started (PID: $PID)"
+            echo "Log file: $LOG_FILE"
+        else
+            echo "Failed to start evidence guard"
+            exit 1
+        fi
+        ;;
+
+    stop)
+        if [ ! -f "$PID_FILE" ]; then
+            echo "Evidence guard is not running"
+            exit 0
+        fi
+
+        PID=$(cat "$PID_FILE")
+        if kill -0 "$PID" 2>/dev/null; then
+            echo "Stopping evidence guard (PID: $PID)..."
+            kill "$PID"
+            sleep 1
+            
+            if kill -0 "$PID" 2>/dev/null; then
+                echo "Force killing evidence guard..."
+                kill -9 "$PID"
+            fi
+            
+            rm -f "$PID_FILE"
+            echo "Evidence guard stopped"
+        else
+            echo "Evidence guard is not running (stale PID file)"
+            rm -f "$PID_FILE"
+        fi
+        ;;
+
+    restart)
+        "$0" stop
+        sleep 1
+        "$0" start
+        ;;
+
+    status)
+        if [ ! -f "$PID_FILE" ]; then
+            echo "Evidence guard is not running"
+            exit 1
+        fi
+
+        PID=$(cat "$PID_FILE")
+        if kill -0 "$PID" 2>/dev/null; then
+            echo "Evidence guard is running (PID: $PID)"
+            if [ -f "$LOG_FILE" ]; then
+                echo ""
+                echo "Recent activity:"
+                tail -n 5 "$LOG_FILE"
+            fi
+            exit 0
+        else
+            echo "Evidence guard is not running (stale PID file)"
+            rm -f "$PID_FILE"
+            exit 1
+        fi
+        ;;
+
+    logs)
+        if [ -f "$LOG_FILE" ]; then
+            tail -f "$LOG_FILE"
+        else
+            echo "No log file found"
+            exit 1
+        fi
+        ;;
+
+    *)
+        echo "Usage: $0 {start|stop|restart|status|logs}"
+        echo ""
+        echo "Commands:"
+        echo "  start   - Start the evidence guard daemon"
+        echo "  stop    - Stop the evidence guard daemon"
+        echo "  restart - Restart the evidence guard daemon"
+        echo "  status  - Check if the daemon is running"
+        echo "  logs    - Tail the daemon logs"
+        exit 1
+        ;;
+esac

package/scripts/hooks-system/infrastructure/daemons/evidence-guard.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const REFRESH_INTERVAL_MS = 180000;
+const EVIDENCE_FILE = '.AI_EVIDENCE.json';
+const PID_FILE = '.evidence-guard.pid';
+
+class EvidenceGuard {
+    constructor() {
+        this.projectRoot = this.findProjectRoot();
+        this.pidFile = path.join(this.projectRoot, PID_FILE);
+        this.evidenceFile = path.join(this.projectRoot, EVIDENCE_FILE);
+        this.updateScript = this.findUpdateScript();
+        this.isRunning = false;
+        this.intervalId = null;
+    }
+
+    findProjectRoot() {
+        let currentDir = process.cwd();
+        while (currentDir !== '/') {
+            if (fs.existsSync(path.join(currentDir, 'package.json'))) {
+                return currentDir;
+            }
+            currentDir = path.dirname(currentDir);
+        }
+        return process.cwd();
+    }
+
+    findUpdateScript() {
+        const possiblePaths = [
+            path.join(this.projectRoot, 'scripts/hooks-system/bin/update-evidence.sh'),
+            path.join(this.projectRoot, 'node_modules/pumuki-ast-hooks/scripts/hooks-system/bin/update-evidence.sh'),
+            path.join(__dirname, '../../bin/update-evidence.sh')
+        ];
+
+        for (const scriptPath of possiblePaths) {
+            if (fs.existsSync(scriptPath)) {
+                return scriptPath;
+            }
+        }
+
+        throw new Error('update-evidence.sh not found');
+    }
+
+    writePidFile() {
+        try {
+            fs.writeFileSync(this.pidFile, process.pid.toString(), 'utf8');
+        } catch (error) {
+            console.error('[EvidenceGuard] Failed to write PID file:', error.message);
+        }
+    }
+
+    removePidFile() {
+        try {
+            if (fs.existsSync(this.pidFile)) {
+                fs.unlinkSync(this.pidFile);
+            }
+        } catch (error) {
+            console.error('[EvidenceGuard] Failed to remove PID file:', error.message);
+        }
+    }
+
+    isAlreadyRunning() {
+        if (!fs.existsSync(this.pidFile)) {
+            return false;
+        }
+
+        try {
+            const pid = parseInt(fs.readFileSync(this.pidFile, 'utf8').trim(), 10);
+            process.kill(pid, 0);
+            return true;
+        } catch (error) {
+            this.removePidFile();
+            return false;
+        }
+    }
+
+    async refreshEvidence() {
+        return new Promise((resolve) => {
+            const child = spawn('bash', [this.updateScript, '--auto'], {
+                cwd: this.projectRoot,
+                stdio: 'ignore',
+                detached: false
+            });
+
+            child.on('close', (code) => {
+                if (code === 0) {
+                    console.log(`[EvidenceGuard] Evidence refreshed at ${new Date().toISOString()}`);
+                } else {
+                    console.error(`[EvidenceGuard] Refresh failed with code ${code}`);
+                }
+                resolve();
+            });
+
+            child.on('error', (error) => {
+                console.error('[EvidenceGuard] Refresh error:', error.message);
+                resolve();
+            });
+        });
+    }
+
+    async start() {
+        if (this.isAlreadyRunning()) {
+            console.log('[EvidenceGuard] Already running');
+            process.exit(0);
+        }
+
+        this.writePidFile();
+        this.isRunning = true;
+
+        console.log('[EvidenceGuard] Started');
+        console.log(`[EvidenceGuard] Project root: ${this.projectRoot}`);
+        console.log(`[EvidenceGuard] Refresh interval: ${REFRESH_INTERVAL_MS / 1000}s`);
+
+        await this.refreshEvidence();
+
+        this.intervalId = setInterval(async () => {
+            if (this.isRunning) {
+                await this.refreshEvidence();
+            }
+        }, REFRESH_INTERVAL_MS);
+
+        process.on('SIGTERM', () => this.stop());
+        process.on('SIGINT', () => this.stop());
+        process.on('exit', () => this.cleanup());
+    }
+
+    stop() {
+        console.log('[EvidenceGuard] Stopping...');
+        this.isRunning = false;
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        this.cleanup();
+        process.exit(0);
+    }
+
+    cleanup() {
+        this.removePidFile();
+    }
+}
+
+if (require.main === module) {
+    const guard = new EvidenceGuard();
+    guard.start().catch((error) => {
+        console.error('[EvidenceGuard] Fatal error:', error);
+        process.exit(1);
+    });
+}
+
+module.exports = EvidenceGuard;