pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/domain/errors/index.js

@@ -0,0 +1,169 @@
+class DomainError extends Error {
+    constructor(message, code = null, details = {}) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.details = details;
+        this.timestamp = new Date().toISOString();
+
+        // Maintains proper stack trace for where our error was thrown
+        Error.captureStackTrace(this, this.constructor);
+    }
+
+    isFatal() {
+        return this.code === 'CRITICAL_ERROR' ||
+            this.code === 'AUTHENTICATION_ERROR' ||
+            this.code === 'AUTHORIZATION_ERROR';
+    }
+
+    shouldNotify() {
+        return true;
+    }
+
+    getLoggingLevel() {
+        if (this.isFatal()) return 'error';
+        return 'warn';
+    }
+
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            details: this.details,
+            timestamp: this.timestamp,
+            stack: this.stack,
+            isFatal: this.isFatal()
+        };
+    }
+}
+
+/**
+ * Validation errors for invalid input/data
+ */
+class ValidationError extends DomainError {
+    constructor(message, field = null, value = null) {
+        super(message, 'VALIDATION_ERROR', { field, value });
+    }
+}
+
+/**
+ * Authentication/Authorization errors
+ */
+class AuthenticationError extends DomainError {
+    constructor(message = 'Authentication failed') {
+        super(message, 'AUTHENTICATION_ERROR');
+    }
+}
+
+class AuthorizationError extends DomainError {
+    constructor(message = 'Access denied') {
+        super(message, 'AUTHORIZATION_ERROR');
+    }
+}
+
+/**
+ * Business rule violations
+ */
+class BusinessRuleError extends DomainError {
+    constructor(message, rule = null) {
+        super(message, 'BUSINESS_RULE_ERROR', { rule });
+    }
+}
+
+/**
+ * Resource not found errors
+ */
+class NotFoundError extends DomainError {
+    constructor(resource = 'Resource', id = null) {
+        super(`${resource}${id ? ` with id ${id}` : ''} not found`, 'NOT_FOUND', { resource, id });
+    }
+}
+
+/**
+ * Conflict/State errors
+ */
+class ConflictError extends DomainError {
+    constructor(message, currentState = null) {
+        super(message, 'CONFLICT_ERROR', { currentState });
+    }
+}
+
+/**
+ * External service errors
+ */
+class ExternalServiceError extends DomainError {
+    constructor(service, message, statusCode = null) {
+        super(`${service} error: ${message}`, 'EXTERNAL_SERVICE_ERROR', { service, statusCode });
+    }
+}
+
+/**
+ * Configuration errors
+ */
+class ConfigurationError extends DomainError {
+    constructor(message, configKey = null) {
+        super(message, 'CONFIGURATION_ERROR', { configKey });
+    }
+}
+
+/**
+ * Audit/Guard specific errors
+ */
+class GuardError extends DomainError {
+    constructor(message, gate = null) {
+        super(message, 'GUARD_ERROR', { gate });
+    }
+
+    static fromViolation(violation, gate) {
+        return new GuardError(`Guard violation: ${violation}`, gate);
+    }
+}
+
+class EvidenceError extends DomainError {
+    constructor(message, evidencePath = null) {
+        super(message, 'EVIDENCE_ERROR', { evidencePath });
+    }
+
+    static stale(path, age) {
+        return new EvidenceError(`Evidence at ${path} is stale (${age}s old)`, path);
+    }
+
+    static missing(path) {
+        return new EvidenceError(`Evidence file not found: ${path}`, path);
+    }
+}
+
+/**
+ * Git operation errors
+ */
+class GitError extends DomainError {
+    constructor(message, operation = null) {
+        super(message, 'GIT_ERROR', { operation });
+    }
+}
+
+/**
+ * Not implemented errors for interface methods
+ */
+class NotImplementedError extends DomainError {
+    constructor(message = 'Not implemented') {
+        super(message, 'NOT_IMPLEMENTED');
+    }
+}
+
+module.exports = {
+    DomainError,
+    ValidationError,
+    AuthenticationError,
+    AuthorizationError,
+    BusinessRuleError,
+    NotFoundError,
+    ConflictError,
+    ExternalServiceError,
+    ConfigurationError,
+    GuardError,
+    EvidenceError,
+    GitError,
+    NotImplementedError
+};

package/scripts/hooks-system/domain/events/__tests__/DomainEvents.spec.js

@@ -0,0 +1,60 @@
+const {
+    DomainEvent,
+    EvidenceStaleEvent,
+    GitFlowViolationEvent,
+    AstCriticalFoundEvent
+} = require('../index');
+
+describe('Domain Events', () => {
+    describe('DomainEvent', () => {
+        it('should validate presence of type and payload', () => {
+            const validEvent = new DomainEvent('TEST', { data: 1 });
+            expect(validEvent.validate()).toBe(true);
+
+            const invalidEvent = new DomainEvent(null, null);
+            expect(() => invalidEvent.validate()).toThrow();
+        });
+
+        it('should correctly identify critical events', () => {
+            const critical = new DomainEvent('CRITICAL_ALERT', {});
+            const blocked = new DomainEvent('PRE_COMMIT_BLOCKED', {});
+            const normal = new DomainEvent('INFO_EVENT', {});
+
+            expect(critical.isCritical()).toBe(true);
+            expect(blocked.isCritical()).toBe(true);
+            expect(normal.isCritical()).toBe(false);
+        });
+
+        it('should generate a summary string', () => {
+            const event = new DomainEvent('TEST', { key: 'val' });
+            const summary = event.getSummary();
+            expect(summary).toContain('TEST');
+            expect(summary).toContain('val');
+        });
+    });
+
+    describe('EvidenceStaleEvent', () => {
+        it('should validate specific payload requirements', () => {
+            expect(() => new EvidenceStaleEvent(null, Date.now())).toThrow(/Evidence path/);
+            const event = new EvidenceStaleEvent('/path', Date.now());
+            expect(event.type).toBe('EVIDENCE_STALE');
+        });
+    });
+
+    describe('GitFlowViolationEvent', () => {
+        it('should validate branch and violation details', () => {
+            expect(() => new GitFlowViolationEvent(null, 'error')).toThrow(/Branch name/);
+            expect(() => new GitFlowViolationEvent('main', null)).toThrow(/Violation details/);
+            const event = new GitFlowViolationEvent('main', 'Protected branch write');
+            expect(event.payload.branch).toBe('main');
+        });
+    });
+
+    describe('AstCriticalFoundEvent', () => {
+        it('should validate findings is an array', () => {
+            expect(() => new AstCriticalFoundEvent('not-an-array')).toThrow(/Findings must be an array/);
+            const event = new AstCriticalFoundEvent([{ id: 1 }]);
+            expect(event.payload.count).toBe(1);
+        });
+    });
+});

package/scripts/hooks-system/domain/events/index.js

@@ -0,0 +1,121 @@
+class DomainEvent {
+    constructor(type, payload) {
+        this.type = type;
+        this.payload = payload;
+        this.timestamp = new Date().toISOString();
+        this.id = `${type}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    validate() {
+        if (!this.type) throw new Error('Event type is required');
+        if (!this.payload) throw new Error('Event payload is required');
+        return true;
+    }
+
+    getSummary() {
+        return `[${this.timestamp}] ${this.type}: ${JSON.stringify(this.payload)}`;
+    }
+
+    isCritical() {
+        return this.type.includes('CRITICAL') || this.type.includes('BLOCKED');
+    }
+}
+
+class EvidenceStaleEvent extends DomainEvent {
+    constructor(evidencePath, lastUpdated) {
+        super('EVIDENCE_STALE', { evidencePath, lastUpdated });
+        this.validate();
+    }
+
+    validate() {
+        super.validate();
+        if (!this.payload.evidencePath) throw new Error('Evidence path is required');
+    }
+}
+
+class GitFlowViolationEvent extends DomainEvent {
+    constructor(branch, violation) {
+        super('GITFLOW_VIOLATION', { branch, violation });
+        this.validate();
+    }
+
+    validate() {
+        super.validate();
+        if (!this.payload.branch) throw new Error('Branch name is required');
+        if (!this.payload.violation) throw new Error('Violation details are required');
+    }
+}
+
+class AstCriticalFoundEvent extends DomainEvent {
+    constructor(findings) {
+        super('AST_CRITICAL_FOUND', { findings, count: findings.length });
+        this.validate();
+    }
+
+    validate() {
+        super.validate();
+        if (!Array.isArray(this.payload.findings)) throw new Error('Findings must be an array');
+    }
+}
+
+class PreCommitBlockedEvent extends DomainEvent {
+    constructor(reason, violations) {
+        super('PRE_COMMIT_BLOCKED', { reason, violations });
+        this.validate();
+    }
+}
+
+class AnalysisCompletedEvent extends DomainEvent {
+    constructor(summary) {
+        super('ANALYSIS_COMPLETED', summary);
+        this.validate();
+    }
+}
+
+class EventBus {
+    constructor() {
+        this.subscribers = new Map();
+    }
+
+    subscribe(eventType, handler) {
+        if (!this.subscribers.has(eventType)) {
+            this.subscribers.set(eventType, []);
+        }
+        this.subscribers.get(eventType).push(handler);
+        return () => this.unsubscribe(eventType, handler);
+    }
+
+    unsubscribe(eventType, handler) {
+        const handlers = this.subscribers.get(eventType);
+        if (handlers) {
+            const index = handlers.indexOf(handler);
+            if (index > -1) handlers.splice(index, 1);
+        }
+    }
+
+    async publish(event) {
+        const handlers = this.subscribers.get(event.type) || [];
+        const wildcardHandlers = this.subscribers.get('*') || [];
+        const allHandlers = [...handlers, ...wildcardHandlers];
+
+        await Promise.all(allHandlers.map(handler => handler(event)));
+        return event;
+    }
+
+    subscribeAll(handler) {
+        return this.subscribe('*', handler);
+    }
+}
+
+const globalEventBus = new EventBus();
+
+module.exports = {
+    DomainEvent,
+    EvidenceStaleEvent,
+    GitFlowViolationEvent,
+    AstCriticalFoundEvent,
+    PreCommitBlockedEvent,
+    AnalysisCompletedEvent,
+    EventBus,
+    globalEventBus
+};

package/scripts/hooks-system/domain/ports/IAstPort.js

@@ -0,0 +1,67 @@
+/**
+ * IAstPort
+ *
+ * Port interface for AST analysis operations.
+ * Infrastructure adapters must implement this interface.
+ */
+const { NotImplementedError } = require('../errors');
+
+class IAstPort {
+    /**
+     * Analyze a single file for AST violations
+     * @param {string} filePath - Path to the file
+     * @param {string} platform - Platform: 'backend' | 'frontend' | 'ios' | 'android'
+     * @returns {Object[]} Array of findings
+     */
+    analyzeFile(filePath, platform) {
+        throw new NotImplementedError('IAstPort.analyzeFile() must be implemented');
+    }
+
+    /**
+     * Analyze multiple files
+     * @param {string[]} filePaths - Array of file paths
+     * @param {string} platform - Platform
+     * @returns {Object[]} Array of findings
+     */
+    analyzeFiles(filePaths, platform) {
+        throw new NotImplementedError('IAstPort.analyzeFiles() must be implemented');
+    }
+
+    /**
+     * Get available rules for a platform
+     * @param {string} platform - Platform
+     * @returns {Object[]} Array of rule definitions
+     */
+    getRulesForPlatform(platform) {
+        throw new NotImplementedError('IAstPort.getRulesForPlatform() must be implemented');
+    }
+
+    /**
+     * Check if a file should be ignored from analysis
+     * @param {string} filePath - Path to the file
+     * @returns {boolean}
+     */
+    shouldIgnoreFile(filePath) {
+        throw new NotImplementedError('IAstPort.shouldIgnoreFile() must be implemented');
+    }
+
+    /**
+     * Get blocking findings (HIGH severity)
+     * @param {Object[]} findings - All findings
+     * @returns {Object[]} Only blocking findings
+     */
+    getBlockingFindings(findings) {
+        throw new NotImplementedError('IAstPort.getBlockingFindings() must be implemented');
+    }
+
+    /**
+     * Format findings for display
+     * @param {Object[]} findings - Findings to format
+     * @returns {string} Formatted output
+     */
+    formatFindings(findings) {
+        throw new NotImplementedError('IAstPort.formatFindings() must be implemented');
+    }
+}
+
+module.exports = IAstPort;

package/scripts/hooks-system/domain/ports/IEvidencePort.js

@@ -0,0 +1,86 @@
+/**
+ * IEvidencePort
+ *
+ * Port interface for Evidence operations.
+ * Infrastructure adapters must implement this interface.
+ */
+const { NotImplementedError } = require('../errors');
+
+class IEvidencePort {
+    /**
+     * Read the current evidence state
+     * @returns {Object|null} Evidence object or null if not found
+     */
+    read() {
+        throw new NotImplementedError('IEvidencePort.read() must be implemented');
+    }
+
+    /**
+     * Write evidence to storage
+     * @param {Object} evidence - Evidence object to write
+     * @returns {boolean} Success status
+     */
+    write(evidence) {
+        throw new NotImplementedError('IEvidencePort.write() must be implemented');
+    }
+
+    /**
+     * Check if evidence exists
+     * @returns {boolean}
+     */
+    exists() {
+        throw new NotImplementedError('IEvidencePort.exists() must be implemented');
+    }
+
+    /**
+     * Get evidence age in seconds
+     * @returns {number} Age in seconds, or Infinity if not found
+     */
+    getAgeSeconds() {
+        throw new NotImplementedError('IEvidencePort.getAgeSeconds() must be implemented');
+    }
+
+    /**
+     * Check if evidence is stale (older than threshold)
+     * @param {number} thresholdSeconds - Max age in seconds (default: 180)
+     * @returns {boolean}
+     */
+    isStale(thresholdSeconds = 180) {
+        throw new NotImplementedError('IEvidencePort.isStale() must be implemented');
+    }
+
+    /**
+     * Refresh evidence by running update script
+     * @param {Object} options - Options for refresh
+     * @returns {boolean} Success status
+     */
+    refresh(options = {}) {
+        throw new NotImplementedError('IEvidencePort.refresh() must be implemented');
+    }
+
+    /**
+     * Get the current session name from evidence
+     * @returns {string|null}
+     */
+    getSession() {
+        throw new NotImplementedError('IEvidencePort.getSession() must be implemented');
+    }
+
+    /**
+     * Get platforms from evidence
+     * @returns {string[]}
+     */
+    getPlatforms() {
+        throw new NotImplementedError('IEvidencePort.getPlatforms() must be implemented');
+    }
+
+    /**
+     * Get modified files from evidence
+     * @returns {string[]}
+     */
+    getModifiedFiles() {
+        throw new NotImplementedError('IEvidencePort.getModifiedFiles() must be implemented');
+    }
+}
+
+module.exports = IEvidencePort;

package/scripts/hooks-system/domain/ports/IGitCommandPort.js

@@ -0,0 +1,110 @@
+/**
+ * IGitCommandPort
+ *
+ * Port interface for Git write operations (Commands).
+ */
+const { NotImplementedError } = require('../errors');
+
+class IGitCommandPort {
+    /**
+     * Create a new branch from current HEAD
+     * @param {string} branchName
+     * @returns {boolean}
+     */
+    createBranch(branchName) {
+        throw new NotImplementedError('IGitCommandPort.createBranch() must be implemented');
+    }
+
+    /**
+     * Checkout to a branch
+     * @param {string} branchName
+     * @returns {boolean}
+     */
+    checkout(branchName) {
+        throw new NotImplementedError('IGitCommandPort.checkout() must be implemented');
+    }
+
+    /**
+     * Stage files
+     * @param {string[]} files
+     * @returns {boolean}
+     */
+    stageFiles(files) {
+        throw new NotImplementedError('IGitCommandPort.stageFiles() must be implemented');
+    }
+
+    /**
+     * Stage all files
+     * @returns {boolean}
+     */
+    stageAll() {
+        throw new NotImplementedError('IGitCommandPort.stageAll() must be implemented');
+    }
+
+    /**
+     * Commit staged changes
+     * @param {string} message
+     * @returns {boolean}
+     */
+    commit(message) {
+        throw new NotImplementedError('IGitCommandPort.commit() must be implemented');
+    }
+
+    /**
+     * Push to remote
+     * @param {string} remote
+     * @param {string} branch
+     * @returns {boolean}
+     */
+    push(remote, branch) {
+        throw new NotImplementedError('IGitCommandPort.push() must be implemented');
+    }
+
+    /**
+     * Push to remote setting upstream
+     * @param {string} remote
+     * @param {string} branch
+     * @returns {boolean}
+     */
+    pushWithUpstream(remote, branch) {
+        throw new NotImplementedError('IGitCommandPort.pushWithUpstream() must be implemented');
+    }
+
+    /**
+     * Fetch from remote
+     * @param {string} remote
+     * @returns {boolean}
+     */
+    fetchRemote(remote) {
+        throw new NotImplementedError('IGitCommandPort.fetchRemote() must be implemented');
+    }
+
+    /**
+     * Pull from remote
+     * @param {string} remote
+     * @param {string} branch
+     * @returns {boolean}
+     */
+    pull(remote, branch) {
+        throw new NotImplementedError('IGitCommandPort.pull() must be implemented');
+    }
+
+    /**
+     * Stash changes
+     * @param {string} message
+     * @returns {boolean}
+     */
+    stash(message) {
+        throw new NotImplementedError('IGitCommandPort.stash() must be implemented');
+    }
+
+    /**
+     * Pop stash
+     * @returns {boolean}
+     */
+    stashPop() {
+        throw new NotImplementedError('IGitCommandPort.stashPop() must be implemented');
+    }
+}
+
+module.exports = IGitCommandPort;