pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/application/services/guard/GuardProcessManager.js

@@ -0,0 +1,113 @@
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+class GuardProcessManager {
+    constructor({
+        repoRoot = process.cwd(),
+        logger = console,
+        fsModule = require('fs'),
+        childProcess = { spawnSync }
+    } = {}) {
+        this.repoRoot = repoRoot;
+        this.logger = logger;
+        this.fs = fsModule;
+        this.childProcess = childProcess;
+
+        this.supervisorPidFile = path.join(this.repoRoot, '.guard-supervisor.pid');
+        this.startScript = path.join(this.repoRoot, 'bin', 'start-guards.sh');
+    }
+
+    isSupervisorRunning() {
+        const pid = this.readSupervisorPid();
+        return pid ? this.isProcessAlive(pid) : false;
+    }
+
+    readSupervisorPid() {
+        if (!this.fs.existsSync(this.supervisorPidFile)) {
+            return null;
+        }
+        try {
+            const raw = this.fs.readFileSync(this.supervisorPidFile, 'utf8').trim();
+            if (!raw) {
+                return null;
+            }
+            const pid = Number(raw);
+            return Number.isFinite(pid) ? pid : null;
+        } catch (error) {
+            if (this.logger?.debug) {
+                this.logger.debug('GUARD_PROCESS_PID_READ_ERROR', { error: error.message });
+            }
+            return null;
+        }
+    }
+
+    isProcessAlive(pid) {
+        if (!pid) {
+            return false;
+        }
+        try {
+            process.kill(pid, 0);
+            return true;
+        } catch (error) {
+            // process.kill throws if process doesn't exist (ESRCH) or no permission (EPERM)
+            if (error.code !== 'ESRCH' && this.logger?.debug) {
+                this.logger.debug('GUARD_PROCESS_CHECK_ERROR', { pid, error: error.message });
+            }
+            return false;
+        }
+    }
+
+    startSupervisor() {
+        try {
+            const result = this.childProcess.spawnSync(this.startScript, ['start'], {
+                cwd: this.repoRoot,
+                stdio: 'pipe'
+            });
+
+            const stdout = (result.stdout || '').toString().trim();
+            const stderr = (result.stderr || '').toString().trim();
+
+            return {
+                success: !result.error,
+                error: result.error,
+                stdout,
+                stderr
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error,
+                stdout: '',
+                stderr: error.message
+            };
+        }
+    }
+
+    stopSupervisor() {
+        try {
+            const result = this.childProcess.spawnSync(this.startScript, ['stop'], {
+                cwd: this.repoRoot,
+                stdio: 'pipe'
+            });
+
+            const stdout = (result.stdout || '').toString().trim();
+            const stderr = (result.stderr || '').toString().trim();
+
+            return {
+                success: !result.error,
+                error: result.error,
+                stdout,
+                stderr
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error,
+                stdout: '',
+                stderr: error.message
+            };
+        }
+    }
+}
+
+module.exports = GuardProcessManager;

package/scripts/hooks-system/application/services/guard/GuardRecoveryService.js

@@ -0,0 +1,90 @@
+class GuardRecoveryService {
+    constructor({
+        repoRoot,
+        logger,
+        startScript,
+        notificationHandler,
+        restartCooldownMs = 2000
+    }) {
+        this.repoRoot = repoRoot;
+        this.logger = logger;
+        this.startScript = startScript;
+        this.notificationHandler = notificationHandler;
+        this.restartCooldownMs = restartCooldownMs;
+        this.lastEnsure = 0;
+    }
+
+    ensureSupervisor(reason, eventLogger) {
+        const now = Date.now();
+        if (now - this.lastEnsure < this.restartCooldownMs) {
+            return false;
+        }
+        this.lastEnsure = now;
+
+        const normalizedReason = reason || 'unknown';
+        const severity = this._determineSeverity(normalizedReason);
+
+        eventLogger.recordEvent(`Asegurando guard-supervisor (motivo: ${normalizedReason}).`);
+
+        const result = this._startSupervisor();
+
+        if (!result.success) {
+            eventLogger.log(`Failed to start supervisor (${reason}): ${result.stderr}`);
+            this._notifyUser(`Fallo al reiniciar guard-supervisor (${normalizedReason}).`, 'error', {
+                reason: `${normalizedReason}-failed`
+            });
+            return false;
+        }
+
+        if (result.stdout) eventLogger.log(`[start stdout] ${result.stdout}`);
+        if (result.stderr) eventLogger.log(`[start stderr] ${result.stderr}`);
+
+        eventLogger.log(`Supervisor ensured (${reason})`);
+        this._notifyUser(
+            normalizedReason === 'initial-start'
+                ? 'Guard-supervisor operativo.'
+                : `Guard-supervisor reiniciado (${normalizedReason}).`,
+            severity,
+            { reason: normalizedReason }
+        );
+
+        return true;
+    }
+
+    _startSupervisor() {
+        try {
+            const result = require('child_process').spawnSync(this.startScript, ['start'], {
+                cwd: this.repoRoot,
+                stdio: 'pipe'
+            });
+
+            return {
+                success: !result.error && result.status === 0,
+                error: result.error,
+                stdout: (result.stdout || '').toString().trim(),
+                stderr: (result.stderr || '').toString().trim()
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error,
+                stdout: '',
+                stderr: error.message
+            };
+        }
+    }
+
+    _determineSeverity(reason) {
+        if (reason === 'missing-supervisor') return 'error';
+        if (reason.startsWith('heartbeat-')) return 'warn';
+        return 'info';
+    }
+
+    _notifyUser(message, level, options) {
+        if (this.notificationHandler) {
+            this.notificationHandler.notify(message, level, options);
+        }
+    }
+}
+
+module.exports = GuardRecoveryService;

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

@@ -0,0 +1,77 @@
+const path = require('path');
+const fs = require('fs');
+
+const { GuardAutoManagerService } = require('../GuardAutoManagerService');
+
+describe('GuardAutoManagerService', () => {
+    const repoRoot = fs.mkdtempSync(path.join(require('os').tmpdir(), 'guard-auto-'));
+
+    afterAll(() => {
+        fs.rmSync(repoRoot, { recursive: true, force: true });
+    });
+
+    const createService = (overrides = {}) => {
+        const logs = [];
+        const logger = {
+            info: (msg, data) => logs.push({ level: 'info', msg, data }),
+            warn: (msg, data) => logs.push({ level: 'warn', msg, data }),
+            error: (msg, data) => logs.push({ level: 'error', msg, data })
+        };
+
+        const enqueue = jest.fn();
+        const timers = {
+            setInterval: jest.fn((fn) => {
+                timers.cb = fn;
+                return Symbol('interval');
+            }),
+            clearInterval: jest.fn()
+        };
+
+        const fsModule = {
+            ...(overrides.fsModule || fs),
+            mkdirSync: jest.fn(),
+            appendFileSync: jest.fn(),
+            writeFileSync: jest.fn(),
+            readFileSync: jest.fn(),
+            rmdirSync: jest.fn(),
+            unlinkSync: jest.fn(),
+            existsSync: jest.fn().mockReturnValue(false)
+        };
+
+        const spawnSync = jest.fn(() => ({ stdout: Buffer.from('ok'), stderr: Buffer.from('') }));
+
+        const service = new GuardAutoManagerService({
+            repoRoot,
+            logger,
+            notificationCenter: { enqueue },
+            fsModule,
+            childProcess: { spawnSync },
+            timers,
+            processRef: { on: jest.fn() }
+        });
+        service.__test = { logs, enqueue, timers, fsModule, spawnSync };
+        return service;
+    };
+
+    it('starts service and schedules monitor loop', () => {
+        const service = createService();
+
+        const started = service.start();
+
+        expect(started).toBe(true);
+        expect(service.__test.timers.setInterval).toHaveBeenCalled();
+    });
+
+    it('enqueues notifications via notification center', () => {
+        const service = createService();
+        service.start();
+        service.notifyUser('Guard-supervisor operativo.', 'info', { reason: 'test', cooldownMs: 0 });
+
+        expect(service.__test.enqueue).toHaveBeenCalledWith({
+            message: 'Guard-supervisor operativo.',
+            level: 'info',
+            type: 'guard_auto_manager_test',
+            metadata: { reason: 'test', cooldownMs: 0 }
+        });
+    });
+});

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

@@ -0,0 +1,123 @@
+const fs = require('fs');
+const path = require('path');
+
+const COLORS = {
+    reset: '\x1b[0m',
+    green: '\x1b[32m',
+    blue: '\x1b[34m',
+    yellow: '\x1b[33m'
+};
+
+class ConfigurationGeneratorService {
+    constructor(targetRoot, hookSystemRoot) {
+        this.targetRoot = targetRoot || process.cwd();
+        this.hookSystemRoot = hookSystemRoot;
+    }
+
+    createProjectConfig(platforms) {
+        const config = {
+            version: '3.1.0',
+            project: {
+                name: path.basename(this.targetRoot),
+                platforms: platforms,
+                created: new Date().toISOString()
+            },
+            architecture: {
+                pattern: 'FEATURE_FIRST_CLEAN_DDD',
+                strictMode: true,
+                enforcement: 'strict'
+            },
+            rules: {
+                enabled: true,
+                platforms: {}
+            },
+            commitGating: {
+                mode: 'strict',
+                blockOn: ['critical', 'high'],
+                stagingAreaOnly: true
+            },
+            bypass: {
+                enabled: true,
+                envVar: 'GIT_BYPASS_HOOK'
+            }
+        };
+
+        platforms.forEach(platform => {
+            config.rules.platforms[platform] = {
+                enabled: true,
+                customRulesPath: null
+            };
+
+            if (platform === 'ios') {
+                config.architecture.ios = {
+                    architecturePattern: 'FEATURE_FIRST_CLEAN_DDD',
+                    allowedPatterns: ['FEATURE_FIRST_CLEAN_DDD', 'MVVM-C'],
+                    prohibitedPatterns: ['MVC'],
+                    documentation: 'docs/ARCHITECTURE.md'
+                };
+            }
+
+            if (platform === 'android') {
+                config.architecture.android = {
+                    strictKotlin: true,
+                    composeOnly: true,
+                    hiltRequired: true
+                };
+            }
+        });
+
+        const configPath = path.join(this.targetRoot, 'scripts/hooks-system/config/project.config.json');
+        // Ensure dir exists just in case
+        const configDir = path.dirname(configPath);
+        if (!fs.existsSync(configDir)) fs.mkdirSync(configDir, { recursive: true });
+
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        this.logSuccess('Configuration created');
+    }
+
+    installESLintConfigs() {
+        const templatesDir = path.join(this.hookSystemRoot, 'infrastructure/external-tools/eslint');
+        const backendDir = path.join(this.targetRoot, 'apps/backend');
+
+        if (fs.existsSync(backendDir)) {
+            const templatePath = path.join(templatesDir, 'backend.config.template.mjs');
+            const targetPath = path.join(backendDir, 'eslint.config.mjs');
+
+            if (fs.existsSync(templatePath)) {
+                fs.copyFileSync(templatePath, targetPath);
+                this.logSuccess('Created apps/backend/eslint.config.mjs');
+            }
+        }
+    }
+
+    addNpmScripts() {
+        const projectPackageJsonPath = path.join(this.targetRoot, 'package.json');
+
+        if (!fs.existsSync(projectPackageJsonPath)) {
+            this.logWarning('package.json not found, skipping npm scripts');
+            return;
+        }
+
+        try {
+            const packageJson = JSON.parse(fs.readFileSync(projectPackageJsonPath, 'utf8'));
+
+            if (!packageJson.scripts) {
+                packageJson.scripts = {};
+            }
+
+            // 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';
+
+            fs.writeFileSync(projectPackageJsonPath, JSON.stringify(packageJson, null, 2));
+            this.logSuccess('npm scripts added');
+        } catch (error) {
+            this.logWarning(`Failed to update package.json: ${error.message}`);
+        }
+    }
+
+    logSuccess(msg) { process.stdout.write(`${COLORS.green}✓ ${msg}${COLORS.reset}\n`); }
+    logWarning(msg) { process.stdout.write(`${COLORS.yellow}⚠️  ${msg}${COLORS.reset}\n`); }
+}
+
+module.exports = ConfigurationGeneratorService;

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

@@ -0,0 +1,112 @@
+const fs = require('fs');
+const path = require('path');
+
+const COLORS = {
+    reset: '\x1b[0m',
+    green: '\x1b[32m',
+    cyan: '\x1b[36m'
+};
+
+class FileSystemInstallerService {
+    constructor(targetRoot, hookSystemRoot, logger = null) {
+        this.targetRoot = targetRoot || process.cwd();
+        this.hookSystemRoot = hookSystemRoot;
+        this.logger = logger;
+    }
+
+    createDirectoryStructure() {
+        const dirs = [
+            'scripts/hooks-system',
+            'scripts/hooks-system/docs',
+            'scripts/hooks-system/config'
+        ];
+
+        dirs.forEach(dir => {
+            const fullPath = path.join(this.targetRoot, dir);
+            if (!fs.existsSync(fullPath)) {
+                fs.mkdirSync(fullPath, { recursive: true });
+                if (this.logger) this.logger.debug('DIR_CREATED', { path: fullPath });
+            }
+        });
+        this.logSuccess('Directory structure created');
+    }
+
+    copySystemFiles() {
+        const itemsToCopy = [
+            'domain/',
+            'application/',
+            'infrastructure/',
+            'presentation/',
+            'docs/examples/',
+            'docs/guides/',
+            'bin/',
+            'index.js'
+        ];
+
+        itemsToCopy.forEach(item => {
+            const source = path.join(this.hookSystemRoot, item);
+            const dest = path.join(this.targetRoot, 'scripts/hooks-system', item);
+
+            if (fs.existsSync(source)) {
+                if (item === 'infrastructure/') {
+                    this.copyRecursiveExcluding(source, dest, ['scripts']);
+                } else {
+                    this.copyRecursive(source, dest);
+                }
+            }
+        });
+        this.logSuccess('System files copied');
+        if (this.logger) this.logger.info('SYSTEM_FILES_COPIED');
+    }
+
+    copyManageLibraryScript() {
+        // Assuming hookSystemRoot is .../scripts/hooks-system or .../node_modules/@package/
+        // We need to go up to the root of the library package
+        const libraryRoot = path.resolve(this.hookSystemRoot, '..');
+        const source = path.join(libraryRoot, 'manage-library.sh');
+        const dest = path.join(this.targetRoot, 'manage-library.sh');
+
+        if (fs.existsSync(source) && !fs.existsSync(dest)) {
+            fs.copyFileSync(source, dest);
+            fs.chmodSync(dest, '755');
+            this.logSuccess('Copied manage-library.sh to project root');
+        }
+    }
+
+    copyRecursive(source, dest) {
+        if (fs.statSync(source).isDirectory()) {
+            if (!fs.existsSync(dest)) {
+                fs.mkdirSync(dest, { recursive: true });
+            }
+            fs.readdirSync(source).forEach(file => {
+                this.copyRecursive(path.join(source, file), path.join(dest, file));
+            });
+        } else {
+            fs.copyFileSync(source, dest);
+        }
+    }
+
+    copyRecursiveExcluding(source, dest, excludeDirs) {
+        if (fs.statSync(source).isDirectory()) {
+            if (!fs.existsSync(dest)) {
+                fs.mkdirSync(dest, { recursive: true });
+            }
+            fs.readdirSync(source).forEach(file => {
+                if (excludeDirs.includes(file)) {
+                    return;
+                }
+                this.copyRecursiveExcluding(
+                    path.join(source, file),
+                    path.join(dest, file),
+                    excludeDirs
+                );
+            });
+        } else {
+            fs.copyFileSync(source, dest);
+        }
+    }
+
+    logSuccess(msg) { process.stdout.write(`${COLORS.green}✓ ${msg}${COLORS.reset}\n`); }
+}
+
+module.exports = FileSystemInstallerService;

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

@@ -0,0 +1,166 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+
+const COLORS = {
+    reset: '\x1b[0m',
+    blue: '\x1b[34m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    cyan: '\x1b[36m'
+};
+
+class GitEnvironmentService {
+    constructor(targetRoot) {
+        this.targetRoot = targetRoot || process.cwd();
+    }
+
+    checkGitRepository() {
+        const gitDir = path.join(this.targetRoot, '.git');
+        if (!fs.existsSync(gitDir)) {
+            this.logError('❌ CRITICAL: Git repository not found!');
+            this.logWarning('   This library REQUIRES a Git repository to function properly.');
+            this.logInfo('   Please run: git init\n');
+            this.logWarning('⚠️  Without Git:');
+            this.logInfo('   • Pre-commit hooks cannot be installed');
+            this.logInfo('   • Git Flow automation will not work');
+            this.logInfo('   • Code analysis on commits is disabled\n');
+            return false;
+        }
+
+        try {
+            execSync('git rev-parse --show-toplevel', {
+                cwd: this.targetRoot,
+                stdio: 'ignore'
+            });
+            return true;
+        } catch (err) {
+            this.logError('❌ Git repository is not properly initialized!');
+            this.logWarning('   Found .git directory but git commands fail.');
+            this.logInfo('   Please ensure Git is installed and working.\n');
+            return false;
+        }
+    }
+
+    ensureGitInfoExclude() {
+        const gitDir = path.join(this.targetRoot, '.git');
+        if (!fs.existsSync(gitDir)) return;
+
+        const excludePath = path.join(gitDir, 'info', 'exclude');
+        fs.mkdirSync(path.dirname(excludePath), { recursive: true });
+
+        const header = '# AST Intelligence Hooks (generated artifacts)';
+        const patterns = [
+            '.AI_TOKEN_STATUS.txt',
+            '.audit-reports/*.log',
+            '.realtime-guard.pid',
+            '.token-monitor-guard.pid'
+        ];
+
+        let existing = '';
+        if (fs.existsSync(excludePath)) {
+            existing = fs.readFileSync(excludePath, 'utf8');
+            if (existing.includes(header)) return;
+        }
+
+        const block = '\n' + header + '\n' + patterns.join('\n') + '\n';
+        fs.appendFileSync(excludePath, block);
+        this.logSuccess('  ✅ Added artifact patterns to .git/info/exclude');
+    }
+
+    installGitHooks() {
+        const gitHooksDir = path.join(this.targetRoot, '.git/hooks');
+
+        if (!fs.existsSync(gitHooksDir)) {
+            this.logError('✗ .git/hooks directory not found');
+            this.logWarning('  Git hooks cannot be installed without a valid Git repository.');
+            return;
+        }
+
+        const preCommitHook = this.getPreCommitHookContent();
+        const preCommitPath = path.join(gitHooksDir, 'pre-commit');
+
+        fs.writeFileSync(preCommitPath, preCommitHook);
+        fs.chmodSync(preCommitPath, '755');
+        this.logSuccess('  ✅ Installed pre-commit hook');
+    }
+
+    getPreCommitHookContent() {
+        return `#!/bin/bash
+# AST Intelligence Hooks - Pre-commit
+# Auto-generated by @pumuki/ast-intelligence-hooks v5.3.1
+
+# Check for bypass
+if [[ -n "\${GIT_BYPASS_HOOK}" ]]; then
+  echo "⚠️  Bypassing AST hooks (GIT_BYPASS_HOOK=1)"
+  exit 0
+fi
+
+# Change to project root (where package.json is)
+cd "$(git rev-parse --show-toplevel)" || exit 1
+
+# Check if there are staged files
+STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM 2>/dev/null | grep -E '\\.(ts|tsx|js|jsx|swift|kt)$' || true)
+if [ -z "$STAGED_FILES" ]; then
+  # No staged files to analyze, allow commit
+  exit 0
+fi
+
+# Try node_modules/.bin first (works with npm install)
+if [ -f "node_modules/.bin/ast-hooks" ]; then
+  OUTPUT=$(node_modules/.bin/ast-hooks ast 2>&1)
+  EXIT_CODE=$?
+  echo "$OUTPUT"
+  if [ $EXIT_CODE -ne 0 ]; then
+    exit $EXIT_CODE
+  fi
+  # Block commits only when there are actual CRITICAL/HIGH violations.
+  # Do NOT block on summary lines like: "CRITICAL=0 HIGH=0".
+  if echo "$OUTPUT" | grep -qE "CRITICAL=[1-9]|HIGH=[1-9]|\[CRITICAL\]|\[HIGH\]"; then
+    echo ""
+    echo "❌ Commit blocked: Critical or High violations detected in staged files"
+    
+    # Extract counts (best-effort) for notification.
+    # Prefer explicit totals (CRITICAL=, HIGH=) and fallback to tag counts.
+    CRITICAL_COUNT=$(echo "$OUTPUT" | grep -oE "CRITICAL=[0-9]+" | head -1 | cut -d= -f2)
+    HIGH_COUNT=$(echo "$OUTPUT" | grep -oE "HIGH=[0-9]+" | head -1 | cut -d= -f2)
+
+    if [ -z "$CRITICAL_COUNT" ]; then
+      CRITICAL_COUNT=$(echo "$OUTPUT" | grep -oE "\[CRITICAL\]" | wc -l | tr -d ' ')
+    fi
+    if [ -z "$HIGH_COUNT" ]; then
+      HIGH_COUNT=$(echo "$OUTPUT" | grep -oE "\[HIGH\]" | wc -l | tr -d ' ')
+    fi
+
+    CRITICAL_COUNT=$(printf '%s' "$CRITICAL_COUNT" | tr -cd '0-9')
+    HIGH_COUNT=$(printf '%s' "$HIGH_COUNT" | tr -cd '0-9')
+    [ -z "$CRITICAL_COUNT" ] && CRITICAL_COUNT=0
+    [ -z "$HIGH_COUNT" ] && HIGH_COUNT=0
+    TOTAL_VIOLATIONS=$((CRITICAL_COUNT + HIGH_COUNT))
+    [ "$TOTAL_VIOLATIONS" -le 0 ] && TOTAL_VIOLATIONS=1
+    
+    osascript -e "display notification \\"Commit blocked by violations\\" with title \\"🚫 Commit Blocked\\" sound name \\"Basso\\"" 2>/dev/null || true
+    
+    exit 1
+  fi
+  # Copy ast-summary.json to root if it exists
+  if [ -f ".audit_tmp/ast-summary.json" ]; then
+    cp .audit_tmp/ast-summary.json ast-summary.json 2>/dev/null || true
+  fi
+  exit 0
+fi
+
+# Fallback: direct execution logic here...
+echo "⚠️  ast-intelligence-hooks not found"
+exit 0
+`;
+    }
+
+    logInfo(msg) { process.stdout.write(`${COLORS.cyan}${msg}${COLORS.reset}\n`); }
+    logSuccess(msg) { process.stdout.write(`${COLORS.green}${msg}${COLORS.reset}\n`); }
+    logWarning(msg) { process.stdout.write(`${COLORS.yellow}${msg}${COLORS.reset}\n`); }
+    logError(msg) { process.stdout.write(`${COLORS.red}${msg}${COLORS.reset}\n`); }
+}
+
+module.exports = GitEnvironmentService;