pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/adapters/LegacyAnalyzerAdapter.js

@@ -0,0 +1,61 @@
+
+const Finding = require('../../domain/entities/Finding');
+const { createProject, listSourceFiles } = require('../ast/ast-core');
+
+class LegacyAnalyzerAdapter {
+  constructor(legacyAnalyzerFunction, platform) {
+    this.legacyAnalyzerFunction = legacyAnalyzerFunction;
+    this.platform = platform;
+  }
+
+  async analyze(targetPath, options = {}) {
+    try {
+
+      const legacyFindings = [];
+      const allFiles = listSourceFiles(targetPath);
+      const project = createProject(allFiles);
+
+      await this.legacyAnalyzerFunction(project, legacyFindings, this.platform);
+
+      const findings = this.convertToFindings(legacyFindings);
+
+      return findings;
+
+    } catch (error) {
+      return [];
+    }
+  }
+
+  async analyzeFiles(files, options = {}) {
+    try {
+      const legacyFindings = [];
+      const project = createProject(files);
+
+      await this.legacyAnalyzerFunction(project, legacyFindings, this.platform);
+
+      return this.convertToFindings(legacyFindings);
+
+    } catch (error) {
+      return [];
+    }
+  }
+
+  convertToFindings(legacyFindings) {
+    return legacyFindings.map(legacy => {
+      try {
+        return new Finding(
+          legacy.ruleId || 'unknown',
+          legacy.severity || 'low',
+          legacy.message || 'No message',
+          legacy.filePath || 'unknown',
+          legacy.line || 1,
+          legacy.platform || this.platform
+        );
+      } catch (error) {
+        return null;
+      }
+    }).filter(f => f !== null);
+  }
+}
+
+module.exports = LegacyAnalyzerAdapter;

package/scripts/hooks-system/infrastructure/adapters/MacOSNotificationAdapter.js

@@ -0,0 +1,99 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+
+class MacOSNotificationAdapter {
+    constructor(config = {}) {
+        this.enabled = config.enabled !== false;
+        this.defaultSound = config.defaultSound || 'Hero';
+        this.defaultTitle = config.defaultTitle || 'Hook-System Guard';
+        this.terminalNotifierPath = this.resolveTerminalNotifier();
+        this.osascriptPath = '/usr/bin/osascript';
+
+        this.soundMap = {
+            info: 'Hero',
+            warn: 'Submarine',
+            error: 'Basso',
+            success: 'Glass'
+        };
+    }
+
+    resolveTerminalNotifier() {
+        const candidates = [
+            '/opt/homebrew/bin/terminal-notifier',
+            '/usr/local/bin/terminal-notifier',
+            '/usr/bin/terminal-notifier'
+        ];
+        return candidates.find(p => fs.existsSync(p)) || null;
+    }
+
+    async send(notification) {
+        if (!this.enabled) {
+            return false;
+        }
+
+        const {
+            title = this.defaultTitle,
+            message,
+            level = 'info',
+            sound
+        } = notification;
+
+        const resolvedSound = sound || this.soundMap[level] || this.defaultSound;
+
+        if (this.terminalNotifierPath) {
+            return this.sendWithTerminalNotifier(title, message, level, resolvedSound);
+        }
+
+        return this.sendWithOsascript(title, message, resolvedSound);
+    }
+
+    sendWithTerminalNotifier(title, message, level, sound) {
+        try {
+            const args = [
+                '-title', title,
+                '-message', message,
+                '-sound', sound,
+                '-group', 'hook-system-guard',
+                '-ignoreDnD'
+            ];
+
+            if (level === 'error' || level === 'warn') {
+                args.push('-subtitle', level.toUpperCase());
+            }
+
+            const { spawnSync } = require('child_process');
+            const result = spawnSync(this.terminalNotifierPath, args, {
+                stdio: 'ignore',
+                timeout: 5000
+            });
+
+            return result.status === 0;
+        } catch (error) {
+            console.error('[MacOSNotificationAdapter] terminal-notifier failed:', error.message);
+            return this.sendWithOsascript(title, message, sound);
+        }
+    }
+
+    sendWithOsascript(title, message, sound) {
+        try {
+            const safeMessage = message.replace(/"/g, '\\"').replace(/'/g, "\\'");
+            const safeTitle = title.replace(/"/g, '\\"');
+
+            execSync(
+                `/usr/bin/osascript -e 'display notification "${safeMessage}" with title "${safeTitle}" sound name "${sound}"'`,
+                { encoding: 'utf8', timeout: 5000 }
+            );
+
+            return true;
+        } catch (error) {
+            console.error('[MacOSNotificationAdapter] osascript failed:', error.message);
+            return false;
+        }
+    }
+
+    isEnabled() {
+        return this.enabled;
+    }
+}
+
+module.exports = MacOSNotificationAdapter;

package/scripts/hooks-system/infrastructure/adapters/__tests__/AstAnalyzerAdapter.spec.js

@@ -0,0 +1,32 @@
+const AstAnalyzerAdapter = require('../AstAnalyzerAdapter');
+
+describe('AstAnalyzerAdapter', () => {
+  describe('constructor', () => {
+    it('should be a class', () => {
+      expect(typeof AstAnalyzerAdapter).toBe('function');
+    });
+
+    it('should initialize with default config', () => {
+      const adapter = new AstAnalyzerAdapter();
+      expect(adapter.repoRoot).toBeDefined();
+      expect(adapter.astModulesPath).toBeDefined();
+    });
+
+    it('should have ignored patterns', () => {
+      const adapter = new AstAnalyzerAdapter();
+      expect(adapter.ignoredPatterns).toBeDefined();
+      expect(Array.isArray(adapter.ignoredPatterns)).toBe(true);
+    });
+
+    it('should accept custom config', () => {
+      const adapter = new AstAnalyzerAdapter({ repoRoot: '/custom/path' });
+      expect(adapter.repoRoot).toBe('/custom/path');
+    });
+  });
+
+  describe('exports', () => {
+    it('should export AstAnalyzerAdapter class', () => {
+      expect(AstAnalyzerAdapter).toBeDefined();
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/adapters/__tests__/FileEvidenceAdapter.spec.js

@@ -0,0 +1,31 @@
+const FileEvidenceAdapter = require('../FileEvidenceAdapter');
+
+describe('FileEvidenceAdapter', () => {
+  describe('constructor', () => {
+    it('should be a class', () => {
+      expect(typeof FileEvidenceAdapter).toBe('function');
+    });
+
+    it('should initialize with default config', () => {
+      const adapter = new FileEvidenceAdapter();
+      expect(adapter.repoRoot).toBeDefined();
+      expect(adapter.evidencePath).toBeDefined();
+    });
+
+    it('should accept custom config', () => {
+      const adapter = new FileEvidenceAdapter({ repoRoot: '/custom/path' });
+      expect(adapter.repoRoot).toBe('/custom/path');
+    });
+
+    it('should have stale threshold', () => {
+      const adapter = new FileEvidenceAdapter();
+      expect(adapter.staleThreshold).toBeDefined();
+    });
+  });
+
+  describe('exports', () => {
+    it('should export FileEvidenceAdapter class', () => {
+      expect(FileEvidenceAdapter).toBeDefined();
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/adapters/__tests__/GitCliAdapter.spec.js

@@ -0,0 +1,39 @@
+const GitCliAdapter = require('../GitCliAdapter');
+
+describe('GitCliAdapter', () => {
+  describe('constructor', () => {
+    it('should be a class', () => {
+      expect(typeof GitCliAdapter).toBe('function');
+    });
+
+    it('should initialize with default config', () => {
+      const adapter = new GitCliAdapter();
+      expect(adapter.repoRoot).toBeDefined();
+      expect(adapter.protectedBranches).toBeDefined();
+    });
+
+    it('should have default protected branches', () => {
+      const adapter = new GitCliAdapter();
+      expect(adapter.protectedBranches).toContain('main');
+      expect(adapter.protectedBranches).toContain('develop');
+    });
+
+    it('should accept custom config', () => {
+      const adapter = new GitCliAdapter({ repoRoot: '/custom/path' });
+      expect(adapter.repoRoot).toBe('/custom/path');
+    });
+  });
+
+  describe('exec', () => {
+    it('should be a method', () => {
+      const adapter = new GitCliAdapter();
+      expect(typeof adapter.exec).toBe('function');
+    });
+  });
+
+  describe('exports', () => {
+    it('should export GitCliAdapter class', () => {
+      expect(GitCliAdapter).toBeDefined();
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/adapters/__tests__/MacOSNotificationAdapter.spec.js

@@ -0,0 +1,33 @@
+const MacOSNotificationAdapter = require('../MacOSNotificationAdapter');
+
+describe('MacOSNotificationAdapter', () => {
+  describe('constructor', () => {
+    it('should be a class', () => {
+      expect(typeof MacOSNotificationAdapter).toBe('function');
+    });
+
+    it('should initialize with default config', () => {
+      const adapter = new MacOSNotificationAdapter();
+      expect(adapter.enabled).toBe(true);
+      expect(adapter.defaultTitle).toBeDefined();
+    });
+
+    it('should accept custom config', () => {
+      const adapter = new MacOSNotificationAdapter({ enabled: false });
+      expect(adapter.enabled).toBe(false);
+    });
+
+    it('should have sound map', () => {
+      const adapter = new MacOSNotificationAdapter();
+      expect(adapter.soundMap).toBeDefined();
+      expect(adapter.soundMap.info).toBeDefined();
+      expect(adapter.soundMap.error).toBeDefined();
+    });
+  });
+
+  describe('exports', () => {
+    it('should export MacOSNotificationAdapter class', () => {
+      expect(MacOSNotificationAdapter).toBeDefined();
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/adapters/git/GitCommandRunner.js

@@ -0,0 +1,78 @@
+const { execSync } = require('child_process');
+const { ConfigurationError } = require('../../../domain/errors');
+
+class GitCommandRunner {
+    constructor(repoRoot, logger = console, options = {}) {
+        this.repoRoot = repoRoot;
+        this.logger = logger;
+        this.options = {
+            timeout: options.timeout || 30000, // 30s default timeout
+            maxRetries: options.maxRetries || 3,
+            retryDelay: options.retryDelay || 1000,
+            ...options
+        };
+    }
+
+    exec(command, options = {}) {
+        const timeout = options.timeout || this.options.timeout;
+        const maxRetries = options.retries !== undefined ? options.retries : this.options.maxRetries;
+        let attempt = 0;
+        let lastError = null;
+
+        while (attempt <= maxRetries) {
+            try {
+                if (this.logger && this.logger.debug) {
+                    this.logger.debug('GIT_EXEC', { command, attempt: attempt + 1, timeout });
+                }
+
+                return execSync(command, {
+                    cwd: this.repoRoot,
+                    encoding: 'utf-8',
+                    timeout: timeout,
+                    stdio: ['pipe', 'pipe', 'pipe']
+                }).trim();
+            } catch (error) {
+                lastError = error;
+                const isRetryable = this._isRetryableError(error);
+
+                if (this.logger && this.logger.warn) {
+                    this.logger.warn('GIT_EXEC_ATTEMPT_FAILED', {
+                        command,
+                        attempt: attempt + 1,
+                        error: error.message,
+                        retryable: isRetryable
+                    });
+                }
+
+                if (!isRetryable || attempt >= maxRetries) {
+                    break;
+                }
+
+                this._sleep(this.options.retryDelay * Math.pow(2, attempt)); // Exponential backoff
+                attempt++;
+            }
+        }
+
+        if (this.logger && this.logger.error) {
+            this.logger.error('GIT_EXEC_FAILED', { command, error: lastError.message, attempts: attempt + 1 });
+        }
+        return null;
+    }
+
+    _isRetryableError(error) {
+        // Retry on lock files or temporary connection issues
+        const msg = error.message || '';
+        return msg.includes('index.lock') ||
+            msg.includes('Temporary failure') ||
+            msg.includes('Connection timed out');
+    }
+
+    _sleep(ms) {
+        const start = Date.now();
+        while (Date.now() - start < ms) {
+            // Synchronous block for sleep since execSync is sync
+        }
+    }
+}
+
+module.exports = GitCommandRunner;

package/scripts/hooks-system/infrastructure/adapters/git/GitCommandService.js

@@ -0,0 +1,67 @@
+class GitCommandService {
+    constructor(commandRunner) {
+        this.runner = commandRunner;
+    }
+
+    createBranch(branchName) {
+        const result = this.runner.exec(`git checkout -b ${branchName}`);
+        return result !== null;
+    }
+
+    checkout(branchName) {
+        const result = this.runner.exec(`git checkout ${branchName}`);
+        return result !== null;
+    }
+
+    stageFiles(files) {
+        if (!files || files.length === 0) return false;
+        const fileList = files.join(' ');
+        const result = this.runner.exec(`git add ${fileList}`);
+        return result !== null;
+    }
+
+    stageAll() {
+        const result = this.runner.exec('git add -A');
+        return result !== null;
+    }
+
+    commit(message) {
+        const safeMessage = message.replace(/"/g, '\\"');
+        const result = this.runner.exec(`git commit -m "${safeMessage}"`);
+        return result !== null;
+    }
+
+    push(remote = 'origin', branch = null) {
+        const targetBranch = branch || 'HEAD'; // Default to HEAD if no branch, handled by caller mostly
+        const result = this.runner.exec(`git push ${remote} ${targetBranch}`);
+        return result !== null;
+    }
+
+    pushWithUpstream(remote = 'origin', branch) {
+        const result = this.runner.exec(`git push -u ${remote} ${branch}`);
+        return result !== null;
+    }
+
+    fetchRemote(remote = 'origin') {
+        const result = this.runner.exec(`git fetch ${remote}`);
+        return result !== null;
+    }
+
+    pull(remote = 'origin', branch = null) {
+        const target = branch ? `${remote} ${branch}` : '';
+        const result = this.runner.exec(`git pull ${target}`.trim());
+        return result !== null;
+    }
+
+    stash(message = 'WIP') {
+        const result = this.runner.exec(`git stash -u -m "${message}"`);
+        return result !== null;
+    }
+
+    stashPop() {
+        const result = this.runner.exec('git stash pop');
+        return result !== null;
+    }
+}
+
+module.exports = GitCommandService;

package/scripts/hooks-system/infrastructure/adapters/git/GitQueryService.js

@@ -0,0 +1,50 @@
+class GitQueryService {
+    constructor(commandRunner) {
+        this.runner = commandRunner;
+    }
+
+    getCurrentBranch() {
+        return this.runner.exec('git branch --show-current') || 'unknown';
+    }
+
+    getUncommittedChanges() {
+        return this.runner.exec('git status --porcelain') || '';
+    }
+
+    getStagedFiles() {
+        const output = this.runner.exec('git diff --cached --name-only');
+        if (!output) return [];
+        return output.split('\n').filter(f => f.trim().length > 0);
+    }
+
+    hasUncommittedChanges() {
+        const changes = this.getUncommittedChanges();
+        return changes.length > 0;
+    }
+
+    hasStagedChanges() {
+        const staged = this.getStagedFiles();
+        return staged.length > 0;
+    }
+
+    getRecentCommits(count = 5) {
+        const output = this.runner.exec(`git log -${count} --oneline`);
+        if (!output) return [];
+        return output.split('\n').filter(l => l.trim().length > 0);
+    }
+
+    getDiff(cached = false) {
+        const flag = cached ? '--cached' : '';
+        return this.runner.exec(`git diff ${flag} --patch`) || '';
+    }
+
+    getStatusShort() {
+        return this.runner.exec('git status --short') || '';
+    }
+
+    getLog(count = 10) {
+        return this.runner.exec(`git log -${count} --pretty=format:"%H|%s" --name-only`) || '';
+    }
+}
+
+module.exports = GitQueryService;

package/scripts/hooks-system/infrastructure/adapters/index.js

@@ -0,0 +1,14 @@
+/**
+ * Infrastructure Adapters - Implementations of domain ports
+ */
+const MacOSNotificationAdapter = require('./MacOSNotificationAdapter');
+const GitCliAdapter = require('./GitCliAdapter');
+const AstAnalyzerAdapter = require('./AstAnalyzerAdapter');
+const FileEvidenceAdapter = require('./FileEvidenceAdapter');
+
+module.exports = {
+    MacOSNotificationAdapter,
+    GitCliAdapter,
+    AstAnalyzerAdapter,
+    FileEvidenceAdapter
+};