pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/cache/CacheService.js

@@ -0,0 +1,160 @@
+/**
+ * Cache Service - Performance Caching Layer
+ * Enterprise-grade caching for AST Intelligence Hooks
+ */
+
+/**
+ * In-Memory Cache Service
+ * Fast, TTL-based caching for performance optimization
+ */
+class CacheService {
+    constructor(options = {}, logger = console) {
+        this.cache = new Map();
+        this.defaultTtl = options.ttl ?? 300000;
+        this.maxSize = options.maxSize ?? 1000;
+        this.logger = logger;
+    }
+
+    get(key) {
+        const entry = this.cache.get(key);
+
+        if (!entry) {
+            return null;
+        }
+
+        if (this.isExpired(entry)) {
+            this.cache.delete(key);
+            return null;
+        }
+
+        return entry.value;
+    }
+
+    set(key, value, ttl) {
+        if (this.cache.size >= this.maxSize) {
+            this.evictOldest();
+        }
+
+        const entry = {
+            value,
+            timestamp: Date.now(),
+            ttl: ttl ?? this.defaultTtl
+        };
+
+        this.cache.set(key, entry);
+        if (this.logger && this.logger.debug) {
+            this.logger.debug(`[CacheService] Set key: ${key}`);
+        }
+    }
+
+    has(key) {
+        const entry = this.cache.get(key);
+
+        if (!entry) {
+            return false;
+        }
+
+        if (this.isExpired(entry)) {
+            this.cache.delete(key);
+            return false;
+        }
+
+        return true;
+    }
+
+    delete(key) {
+        const deleted = this.cache.delete(key);
+        if (deleted && this.logger && this.logger.debug) {
+            this.logger.debug(`[CacheService] Deleted key: ${key}`);
+        }
+        return deleted;
+    }
+
+    clear() {
+        this.cache.clear();
+        if (this.logger && this.logger.info) {
+            this.logger.info('[CacheService] Cleared cache');
+        }
+    }
+
+    size() {
+        this.cleanExpired();
+        return this.cache.size;
+    }
+
+    keys() {
+        this.cleanExpired();
+        return Array.from(this.cache.keys());
+    }
+
+    isExpired(entry) {
+        return Date.now() - entry.timestamp > entry.ttl;
+    }
+
+    evictOldest() {
+        let oldestKey = null;
+        let oldestTime = Infinity;
+
+        const entries = Array.from(this.cache.entries());
+        for (const [key, entry] of entries) {
+            if (entry.timestamp < oldestTime) {
+                oldestTime = entry.timestamp;
+                oldestKey = key;
+            }
+        }
+
+        if (oldestKey) {
+            this.cache.delete(oldestKey);
+        }
+    }
+
+    cleanExpired() {
+        const keysToDelete = [];
+
+        const entries = Array.from(this.cache.entries());
+        for (const [key, entry] of entries) {
+            if (this.isExpired(entry)) {
+                keysToDelete.push(key);
+            }
+        }
+
+        for (const key of keysToDelete) {
+            this.cache.delete(key);
+        }
+    }
+
+    getStats() {
+        return {
+            size: this.cache.size,
+            hits: 0,
+            misses: 0
+        };
+    }
+}
+
+/**
+ * Create a cached version of an async function
+ * @param {Function} fn 
+ * @param {CacheService} cache 
+ * @param {Function} keyGenerator 
+ * @param {number} [ttl] 
+ */
+function withCache(fn, cache, keyGenerator, ttl) {
+    return async (...args) => {
+        const key = keyGenerator(...args);
+        const cached = cache.get(key);
+
+        if (cached !== null) {
+            return cached;
+        }
+
+        const result = await fn(...args);
+        cache.set(key, result, ttl);
+        return result;
+    };
+}
+
+module.exports = {
+    CacheService,
+    withCache
+};

package/scripts/hooks-system/infrastructure/cli/__tests__/install-wizard.spec.js

@@ -0,0 +1,16 @@
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+describe('install-wizard CLI', () => {
+    it('runs successfully when user confirms', () => {
+        const script = path.join(__dirname, '..', 'install-wizard.js');
+        const result = spawnSync('node', [script], {
+            cwd: path.join(__dirname, '../../..'),
+            stdio: ['pipe', 'pipe', 'pipe'],
+            input: Buffer.from('y\n')
+        });
+
+        expect(result.status).toBe(0);
+        expect(result.stdout.toString()).toContain('Hook-system install wizard completed.');
+    });
+});

package/scripts/hooks-system/infrastructure/cli/install-wizard.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const { createUnifiedLogger } = require('../logging/UnifiedLoggerFactory');
+
+async function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise(resolve => {
+        rl.question(question, answer => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+
+async function run() {
+    const repoRoot = process.cwd();
+    const logger = createUnifiedLogger({
+        repoRoot,
+        component: 'InstallWizard',
+        fileName: 'install-wizard.log'
+    });
+
+    logger.info('INSTALL_WIZARD_START', { repoRoot });
+
+    const confirm = await prompt('This will configure hook-system guards. Continue? (y/N) ');
+    if (confirm.toLowerCase() !== 'y') {
+        logger.warn('INSTALL_WIZARD_ABORTED');
+        console.log('Install wizard aborted.');
+        process.exit(0);
+    }
+
+    const guardDir = path.join(repoRoot, '.git', 'hooks');
+    fs.mkdirSync(guardDir, { recursive: true });
+
+    const configDir = path.join(repoRoot, '.hook-system');
+    fs.mkdirSync(configDir, { recursive: true });
+
+    const configPath = path.join(configDir, 'config.json');
+    if (!fs.existsSync(configPath)) {
+        fs.writeFileSync(configPath, JSON.stringify({
+            notification: { enabled: true },
+            recovery: { maxAttempts: 5 }
+        }, null, 2));
+        logger.info('INSTALL_WIZARD_CONFIG_CREATED', { configPath });
+    } else {
+        logger.info('INSTALL_WIZARD_CONFIG_EXISTS', { configPath });
+    }
+
+    const symlinkTarget = path.join(repoRoot, 'scripts', 'hooks-system', 'bin', 'guard-supervisor.js');
+    const symlinkPath = path.join(guardDir, 'guard-supervisor');
+    try {
+        if (!fs.existsSync(symlinkPath)) {
+            fs.symlinkSync(symlinkTarget, symlinkPath);
+            logger.info('INSTALL_WIZARD_SYMLINK_CREATED', { symlinkPath });
+        }
+    } catch (error) {
+        logger.error('INSTALL_WIZARD_SYMLINK_FAILED', { error: error.message });
+    }
+
+    console.log('Hook-system install wizard completed.');
+    logger.info('INSTALL_WIZARD_COMPLETED');
+}
+
+run().catch(error => {
+    console.error('Install wizard failed:', error.message);
+    process.exit(1);
+});

package/scripts/hooks-system/infrastructure/core/GitOperations.js

@@ -0,0 +1,50 @@
+const { execSync } = require('child_process');
+
+class GitOperations {
+    static getStagedFiles() {
+        try {
+            const result = execSync('git diff --cached --name-only --diff-filter=ACM', { encoding: 'utf8' });
+            return result.trim().split('\n').filter(f => f);
+        } catch {
+            return [];
+        }
+    }
+
+    static getWorkingDirectoryFiles() {
+        try {
+            const result = execSync('git diff --name-only --diff-filter=ACM', { encoding: 'utf8' });
+            return result.trim().split('\n').filter(f => f);
+        } catch {
+            return [];
+        }
+    }
+
+    static getAllChangedFiles() {
+        try {
+            const result = execSync('git diff --cached --name-only && git diff --name-only', { encoding: 'utf8' });
+            return result.trim().split('\n').filter(f => f);
+        } catch {
+            return [];
+        }
+    }
+
+    static isInGitRepository() {
+        try {
+            execSync('git rev-parse --git-dir', { stdio: 'ignore' });
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    static getRepositoryRoot() {
+        try {
+            const result = execSync('git rev-parse --show-toplevel', { encoding: 'utf8' });
+            return result.trim();
+        } catch {
+            return process.cwd();
+        }
+    }
+}
+
+module.exports = { GitOperations };

package/scripts/hooks-system/infrastructure/core/GitOperations.ts

@@ -0,0 +1,112 @@
+import { execSync } from 'child_process';
+
+/**
+ * Git Operations Service
+ * Centralized Git operations for the hook system
+ */
+export class GitOperations {
+    /**
+     * Get list of staged files
+     * @returns Array of staged file paths
+     */
+    static getStagedFiles(): string[] {
+        try {
+            const result = execSync('git diff --cached --name-only --diff-filter=ACM', {
+                encoding: 'utf8'
+            });
+            return result.trim().split('\n').filter((file: string) => file.length > 0);
+        } catch {
+            return [];
+        }
+    }
+
+    /**
+     * Get list of working directory modified files
+     * @returns Array of modified file paths
+     */
+    static getWorkingDirectoryFiles(): string[] {
+        try {
+            const result = execSync('git diff --name-only --diff-filter=ACM', {
+                encoding: 'utf8'
+            });
+            return result.trim().split('\n').filter((file: string) => file.length > 0);
+        } catch {
+            return [];
+        }
+    }
+
+    /**
+     * Get all changed files (staged + working directory)
+     * @returns Array of all changed file paths
+     */
+    static getAllChangedFiles(): string[] {
+        try {
+            const result = execSync('git diff --cached --name-only && git diff --name-only', {
+                encoding: 'utf8'
+            });
+            return result.trim().split('\n').filter((file: string) => file.length > 0);
+        } catch {
+            return [];
+        }
+    }
+
+    /**
+     * Check if current directory is a Git repository
+     * @returns True if in Git repository
+     */
+    static isInGitRepository(): boolean {
+        try {
+            execSync('git rev-parse --git-dir', { stdio: 'ignore' });
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * Get Git repository root directory
+     * @returns Absolute path to repository root
+     */
+    static getRepositoryRoot(): string {
+        try {
+            const result = execSync('git rev-parse --show-toplevel', {
+                encoding: 'utf8'
+            });
+            return result.trim();
+        } catch {
+            return process.cwd();
+        }
+    }
+
+    /**
+     * Get current branch name
+     * @returns Current branch name
+     */
+    static getCurrentBranch(): string {
+        try {
+            const result = execSync('git rev-parse --abbrev-ref HEAD', {
+                encoding: 'utf8'
+            });
+            return result.trim();
+        } catch {
+            return 'unknown';
+        }
+    }
+
+    /**
+     * Get current commit hash
+     * @returns Current commit hash (short)
+     */
+    static getCurrentCommit(): string {
+        try {
+            const result = execSync('git rev-parse --short HEAD', {
+                encoding: 'utf8'
+            });
+            return result.trim();
+        } catch {
+            return 'unknown';
+        }
+    }
+}
+
+export default GitOperations;

package/scripts/hooks-system/infrastructure/core/__tests__/GitOperations.spec.js

@@ -0,0 +1,146 @@
+const { GitOperations } = require('../GitOperations');
+const { execSync } = require('child_process');
+
+jest.mock('child_process');
+
+function makeMockGitOutput(files) {
+  return files.join('\n') + (files.length > 0 ? '\n' : '');
+}
+
+describe('GitOperations', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getStagedFiles', () => {
+    it('should return array of staged files', () => {
+      const mockFiles = ['file1.ts', 'file2.ts', 'file3.ts'];
+      execSync.mockReturnValue(makeMockGitOutput(mockFiles));
+      const files = GitOperations.getStagedFiles();
+      expect(files).toEqual(mockFiles);
+      expect(execSync).toHaveBeenCalledWith(
+        'git diff --cached --name-only --diff-filter=ACM',
+        { encoding: 'utf8' }
+      );
+    });
+
+    it('should return empty array when no staged files', () => {
+      execSync.mockReturnValue('');
+      const files = GitOperations.getStagedFiles();
+      expect(files).toEqual([]);
+    });
+
+    it('should filter out empty lines', () => {
+      execSync.mockReturnValue('file1.ts\n\nfile2.ts\n');
+      const files = GitOperations.getStagedFiles();
+      expect(files).toEqual(['file1.ts', 'file2.ts']);
+    });
+
+    it('should return empty array on git error', () => {
+      execSync.mockImplementation(() => {
+        throw new Error('Not a git repository');
+      });
+      const files = GitOperations.getStagedFiles();
+      expect(files).toEqual([]);
+    });
+  });
+
+  describe('getWorkingDirectoryFiles', () => {
+    it('should return array of working directory files', () => {
+      const mockFiles = ['file1.ts', 'file2.ts'];
+      execSync.mockReturnValue(makeMockGitOutput(mockFiles));
+      const files = GitOperations.getWorkingDirectoryFiles();
+      expect(files).toEqual(mockFiles);
+      expect(execSync).toHaveBeenCalledWith(
+        'git diff --name-only --diff-filter=ACM',
+        { encoding: 'utf8' }
+      );
+    });
+
+    it('should return empty array when no working files', () => {
+      execSync.mockReturnValue('');
+      const files = GitOperations.getWorkingDirectoryFiles();
+      expect(files).toEqual([]);
+    });
+
+    it('should return empty array on git error', () => {
+      execSync.mockImplementation(() => {
+        throw new Error('Git error');
+      });
+      const files = GitOperations.getWorkingDirectoryFiles();
+      expect(files).toEqual([]);
+    });
+  });
+
+  describe('getAllChangedFiles', () => {
+    it('should return array of all changed files', () => {
+      const mockFiles = ['staged1.ts', 'staged2.ts', 'working1.ts'];
+      execSync.mockReturnValue(makeMockGitOutput(mockFiles));
+      const files = GitOperations.getAllChangedFiles();
+      expect(files).toEqual(mockFiles);
+    });
+
+    it('should combine staged and working files', () => {
+      execSync.mockReturnValue('staged.ts\nworking.ts\n');
+      const files = GitOperations.getAllChangedFiles();
+      expect(files).toContain('staged.ts');
+      expect(files).toContain('working.ts');
+    });
+
+    it('should return empty array on git error', () => {
+      execSync.mockImplementation(() => {
+        throw new Error('Git error');
+      });
+      const files = GitOperations.getAllChangedFiles();
+      expect(files).toEqual([]);
+    });
+  });
+
+  describe('isInGitRepository', () => {
+    it('should return true when in git repository', () => {
+      execSync.mockReturnValue('.git');
+      const isGit = GitOperations.isInGitRepository();
+      expect(isGit).toBe(true);
+      expect(execSync).toHaveBeenCalledWith(
+        'git rev-parse --git-dir',
+        { stdio: 'ignore' }
+      );
+    });
+
+    it('should return false when not in git repository', () => {
+      execSync.mockImplementation(() => {
+        throw new Error('Not a git repository');
+      });
+      const isGit = GitOperations.isInGitRepository();
+      expect(isGit).toBe(false);
+    });
+  });
+
+  describe('getRepositoryRoot', () => {
+    it('should return repository root path', () => {
+      const mockRoot = '/path/to/repo';
+      execSync.mockReturnValue(mockRoot + '\n');
+      const root = GitOperations.getRepositoryRoot();
+      expect(root).toBe(mockRoot);
+      expect(execSync).toHaveBeenCalledWith(
+        'git rev-parse --show-toplevel',
+        { encoding: 'utf8' }
+      );
+    });
+
+    it('should return current working directory on error', () => {
+      execSync.mockImplementation(() => {
+        throw new Error('Not a git repository');
+      });
+      const root = GitOperations.getRepositoryRoot();
+      expect(root).toBe(process.cwd());
+    });
+
+    it('should trim whitespace from root path', () => {
+      execSync.mockReturnValue('  /path/to/repo  \n');
+      const root = GitOperations.getRepositoryRoot();
+      expect(root).toBe('/path/to/repo');
+    });
+  });
+});
+

package/scripts/hooks-system/infrastructure/eslint/eslint-integration.sh

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+# ESLint Integration - Infrastructure Layer
+# Implementation of ESLint code analysis
+
+source "$(dirname "${BASH_SOURCE[0]}")/../shell/core/constants.sh"
+source "$(dirname "${BASH_SOURCE[0]}")/../shell/core/utils.sh"
+
+run_eslint_for_app() {
+  local app_path="$1"
+  local report_path="$2"
+  pushd "$app_path" >/dev/null
+  if command -v npx >/dev/null 2>&1; then
+    npx eslint "." -f json --max-warnings=0 > "$report_path" || true
+  else
+    ./node_modules/.bin/eslint "." -f json --max-warnings=0 > "$report_path" || true
+  fi
+  popd >/dev/null
+}
+
+aggregate_eslint() {
+  local json_file="$1"
+  if [[ ! -s "$json_file" ]]; then
+    echo "0 0 0"
+    return
+  fi
+  local errors warnings infos
+  errors=$(grep -o '"severity":2' "$json_file" | wc -l | tr -d ' ' || true)
+  warnings=$(grep -o '"severity":1' "$json_file" | wc -l | tr -d ' ' || true)
+  infos=0
+  echo "$errors $warnings $infos"
+}
+
+run_eslint_suite_impl() {
+  local root_dir="$1"
+  local tmp_dir="$2"
+
+  printf "%b%s%b\n" "$YELLOW" "$MSG_ESLINT" "$NC"
+  local admin_report="$tmp_dir/eslint-admin.json"
+  local web_report="$tmp_dir/eslint-web.json"
+  local total_apps=0
+
+  if [[ -d "${root_dir}/apps/admin-dashboard" ]]; then
+    total_apps=$((total_apps + 1))
+  fi
+  if [[ -d "${root_dir}/apps/web-app" ]]; then
+    total_apps=$((total_apps + 1))
+  fi
+
+  local app_step=0
+  if [[ -d "${root_dir}/apps/admin-dashboard" ]]; then
+    app_step=$((app_step + 1))
+    progress_bar_simple $app_step $total_apps "[${app_step}/${total_apps}] Running ESLint on Admin Dashboard..." >&2
+    run_eslint_for_app "${root_dir}/apps/admin-dashboard" "$admin_report"
+  fi
+
+  if [[ -d "${root_dir}/apps/web-app" ]]; then
+    app_step=$((app_step + 1))
+    progress_bar_simple $app_step $total_apps "[${app_step}/${total_apps}] Running ESLint on Web App..." >&2
+    run_eslint_for_app "${root_dir}/apps/web-app" "$web_report"
+  fi
+
+  printf "%b✅ ESLint audits completed%b\n\n" "$GREEN" "$NC"
+
+  local a_err a_warn _ a2_err a2_warn _2
+  read -r a_err a_warn _ < <(aggregate_eslint "$admin_report")
+  read -r a2_err a2_warn _2 < <(aggregate_eslint "$web_report")
+
+  local total_err=$((a_err + a2_err))
+  local total_warn=$((a_warn + a2_warn))
+
+  local emj_err="$EMJ_ERR"; local emj_warn="$EMJ_WARN"
+  printf "ESLint Admin: %s errors=%s %s warnings=%s\n" "$emj_err" "$a_err" "$emj_warn" "$a_warn"
+  printf "ESLint Web:   %s errors=%s %s warnings=%s\n" "$emj_err" "$a2_err" "$emj_warn" "$a2_warn"
+  printf "%bESLint Total:%b %s errors=%s %s warnings=%s\n" "$GREEN" "$NC" "$emj_err" "$total_err" "$emj_warn" "$total_warn" | tee "$tmp_dir/eslint-summary.txt"
+}