pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/bin/watch-hooks.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+const CompositionRoot = require('../application/CompositionRoot');
+
+// Initialize Composition Root
+const compositionRoot = CompositionRoot.createForProduction(process.cwd());
+
+// Resolve dependencies graph
+const guard = compositionRoot.getRealtimeGuardService();
+const notificationCenter = compositionRoot.getNotificationService();
+
+guard.start();
+console.log('Realtime guard active. Watching evidence freshness and critical docs...');
+
+process.on('SIGINT', () => {
+  guard.stop();
+  notificationCenter.shutdown();
+  console.log('\nRealtime guard stopped');
+  process.exit(0);
+});

package/scripts/hooks-system/config/project.config.json

@@ -0,0 +1,36 @@
+{
+  "version": "3.1.0",
+  "project": {
+    "name": "ast-intelligence-hooks",
+    "platforms": [
+      "backend"
+    ],
+    "created": "2025-12-25T22:02:53.249Z"
+  },
+  "architecture": {
+    "pattern": "FEATURE_FIRST_CLEAN_DDD",
+    "strictMode": true,
+    "enforcement": "strict"
+  },
+  "rules": {
+    "enabled": true,
+    "platforms": {
+      "backend": {
+        "enabled": true,
+        "customRulesPath": null
+      }
+    }
+  },
+  "commitGating": {
+    "mode": "strict",
+    "blockOn": [
+      "critical",
+      "high"
+    ],
+    "stagingAreaOnly": true
+  },
+  "bypass": {
+    "enabled": true,
+    "envVar": "GIT_BYPASS_HOOK"
+  }
+}

package/scripts/hooks-system/config/state-map.json

@@ -0,0 +1,12 @@
+{
+    "idle": {
+        "on": {
+            "start": "active"
+        }
+    },
+    "active": {
+        "on": {
+            "stop": "idle"
+        }
+    }
+}

package/scripts/hooks-system/domain/entities/AuditResult.js

@@ -0,0 +1,139 @@
+const Finding = require('./Finding');
+const { ValidationError } = require('../errors');
+const AuditScorer = require('../services/AuditScorer');
+const AuditAnalyzer = require('../services/AuditAnalyzer');
+
+class AuditResult {
+    constructor(findings = []) {
+        this.findings = findings.filter(f => f instanceof Finding);
+        this.timestamp = new Date();
+        this.metadata = {
+            totalFiles: 0,
+            totalLines: 0,
+            platforms: []
+        };
+        this.scorer = new AuditScorer();
+        this.analyzer = new AuditAnalyzer(this.scorer);
+    }
+
+    addFinding(finding) {
+        if (!(finding instanceof Finding)) {
+            throw new ValidationError('Can only add Finding instances to AuditResult', 'finding', finding);
+        }
+        this.findings.push(finding);
+        return this;
+    }
+
+    addFindings(findings) {
+        if (!Array.isArray(findings)) {
+            throw new ValidationError('Findings must be an array', 'findings', findings);
+        }
+        findings.forEach(f => this.addFinding(f));
+        return this;
+    }
+
+    hasViolations() {
+        return this.findings.length > 0;
+    }
+
+    hasBlockingViolations() {
+        return this.findings.some(f => f.isBlockingLevel());
+    }
+
+    getTotalViolations() {
+        return this.findings.length;
+    }
+
+    getViolationsBySeverity() {
+        return this.analyzer.getViolationsBySeverity(this.findings);
+    }
+
+    getViolationsByPlatform() {
+        return this.analyzer.getViolationsByPlatform(this.findings);
+    }
+
+    getViolationsByRuleId() {
+        return this.analyzer.getViolationsByRuleId(this.findings);
+    }
+
+    getTechnicalDebtHours() {
+        return this.scorer.calculateTechnicalDebt(this.findings);
+    }
+
+    getMaintainabilityIndex() {
+        return this.scorer.calculateMaintainabilityIndex(this.findings);
+    }
+
+    getSummary() {
+        return {
+            timestamp: this.timestamp.toISOString(),
+            totalViolations: this.getTotalViolations(),
+            blockingViolations: this.findings.filter(f => f.isBlockingLevel()).length,
+            technicalDebtHours: this.getTechnicalDebtHours(),
+            maintainabilityIndex: this.getMaintainabilityIndex(),
+            bySeverity: this.getViolationsBySeverity(),
+            byPlatform: this.getViolationsByPlatform()
+        };
+    }
+
+    setMetadata(totalFilesOrMetadata = {}, totalLines, platforms) {
+        if (typeof totalFilesOrMetadata === 'number') {
+            this.metadata = {
+                ...this.metadata,
+                totalFiles: totalFilesOrMetadata,
+                totalLines: Number(totalLines) || 0,
+                platforms: Array.isArray(platforms) ? platforms : []
+            };
+            return this;
+        }
+
+        const metadata = totalFilesOrMetadata && typeof totalFilesOrMetadata === 'object'
+            ? totalFilesOrMetadata
+            : {};
+
+        this.metadata = {
+            ...this.metadata,
+            ...metadata
+        };
+        return this;
+    }
+
+    filterByFile(filePath) {
+        return new AuditResult(this.analyzer.filterByFile(this.findings, filePath))
+            .setMetadata(this.metadata);
+    }
+
+    filterBySeverity(severity) {
+        return new AuditResult(this.analyzer.filterBySeverity(this.findings, severity))
+            .setMetadata(this.metadata);
+    }
+
+    getTopViolatedRules(limit = 10) {
+        return this.analyzer.getTopViolatedRules(this.findings, limit);
+    }
+
+    getTopViolatedFiles(limit = 10) {
+        return this.analyzer.getTopViolatedFiles(this.findings, limit);
+    }
+
+    filterByPlatform(platform) {
+        return new AuditResult(this.analyzer.filterByPlatform(this.findings, platform))
+            .setMetadata(this.metadata);
+    }
+
+    getTopViolations(limit = 10) {
+        return this.analyzer.getTopViolatedRules(this.findings, limit);
+    }
+
+    toJSON() {
+        const AuditResultSerializer = require('../services/AuditResultSerializer');
+        return new AuditResultSerializer().toJSON(this);
+    }
+
+    static fromJSON(json) {
+        const AuditResultSerializer = require('../services/AuditResultSerializer');
+        return new AuditResultSerializer().fromJSON(json);
+    }
+}
+
+module.exports = AuditResult;

package/scripts/hooks-system/domain/entities/Finding.js

@@ -0,0 +1,116 @@
+
+const { ValidationError } = require('../errors');
+const Severity = require('../values/Severity');
+
+class Finding {
+  constructor(ruleId, severity, message, filePath, line, platform) {
+    this.validateInputs(ruleId, message, filePath);
+
+    this.ruleId = ruleId;
+    this._severity = new Severity(severity);
+    this.message = message;
+    this.filePath = filePath;
+    this.line = line || 1;
+    this.platform = (platform || 'unknown').toLowerCase();
+    this.timestamp = new Date();
+    this.id = this.generateId();
+    this.metadata = {};
+  }
+
+  validateInputs(ruleId, message, filePath) {
+    if (!ruleId || typeof ruleId !== 'string' || ruleId.trim().length === 0) {
+      throw new ValidationError('Finding requires valid ruleId (string)', 'ruleId', ruleId);
+    }
+    if (!message || typeof message !== 'string' || message.trim().length === 0) {
+      throw new ValidationError('Finding requires valid message (string)', 'message', message);
+    }
+    if (!filePath || typeof filePath !== 'string' || filePath.trim().length === 0) {
+      throw new ValidationError('Finding requires valid filePath (string)', 'filePath', filePath);
+    }
+  }
+
+  get severity() {
+    return this._severity.toString();
+  }
+
+  generateId() {
+    // Deterministic ID based on content, not timestamp, for better deduplication
+    const hashData = `${this.ruleId}:${this.filePath}:${this.line}:${this.message}:${this.platform}`;
+    return Buffer.from(hashData).toString('base64').substring(0, 16);
+  }
+
+  isCritical() { return this._severity.isCritical(); }
+  isHigh() { return this._severity.isHigh(); }
+  isMedium() { return this._severity.isMedium(); }
+  isLow() { return this._severity.isLow(); }
+  isInfo() { return this._severity.isInfo(); }
+  isBlockingLevel() { return this._severity.isBlocking(); }
+
+  belongsToPlatform(platform) {
+    if (!platform) return false;
+    return this.platform === platform.toLowerCase();
+  }
+
+  getSeverityWeight() {
+    return this._severity.getWeight();
+  }
+
+  getTechnicalDebtHours() {
+    return this._severity.getDebtHours();
+  }
+
+  getDisplayPath() {
+    return `${this.filePath}:${this.line}`;
+  }
+
+  getFormattedSummary() {
+    return `[${this._severity.toUpperCase()}] ${this.ruleId}: ${this.message} (${this.getDisplayPath()})`;
+  }
+
+  addMetadata(key, value) {
+    this.metadata[key] = value;
+    return this;
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      ruleId: this.ruleId,
+      severity: this.severity.toString(),
+      message: this.message,
+      filePath: this.filePath,
+      line: this.line,
+      platform: this.platform,
+      timestamp: this.timestamp.toISOString(),
+      technicalDebtHours: this.getTechnicalDebtHours(),
+      metadata: this.metadata
+    };
+  }
+
+  static fromJSON(json) {
+    const finding = new Finding(
+      json.ruleId,
+      json.severity,
+      json.message,
+      json.filePath,
+      json.line,
+      json.platform
+    );
+    if (json.timestamp) {
+      finding.timestamp = new Date(json.timestamp);
+    }
+    if (json.id) {
+      finding.id = json.id;
+    }
+    if (json.metadata) {
+      finding.metadata = json.metadata;
+    }
+    return finding;
+  }
+
+  toString() {
+    return this.getFormattedSummary();
+  }
+}
+
+module.exports = Finding;

package/scripts/hooks-system/domain/entities/SeverityConfig.js

@@ -0,0 +1,73 @@
+const SEVERITY_LEVELS = {
+    CRITICAL: 4,
+    HIGH: 3,
+    MEDIUM: 2,
+    LOW: 1
+};
+
+const SEVERITY_MAP = {
+    'CRITICAL': 'CRITICAL',
+    'HIGH': 'HIGH',
+    'MEDIUM': 'MEDIUM',
+    'LOW': 'LOW',
+    'error': 'HIGH',
+    'warning': 'MEDIUM',
+    'info': 'LOW',
+    'critical': 'CRITICAL',
+    'high': 'HIGH',
+    'medium': 'MEDIUM',
+    'low': 'LOW'
+};
+
+const SEVERITY_ICONS = {
+    CRITICAL: '🔴',
+    HIGH: '🟠',
+    MEDIUM: '🟡',
+    LOW: '🟢'
+};
+
+const SEVERITY_LABELS = {
+    CRITICAL: 'Critical',
+    HIGH: 'High',
+    MEDIUM: 'Medium',
+    LOW: 'Low'
+};
+
+class SeverityConfig {
+    static getSeverityValue(severity) {
+        return SEVERITY_MAP[severity] || 'MEDIUM';
+    }
+
+    static getSeverityIcon(severity) {
+        return SEVERITY_ICONS[this.getSeverityValue(severity)] || SEVERITY_ICONS.MEDIUM;
+    }
+
+    static getSeverityLabel(severity) {
+        return SEVERITY_LABELS[this.getSeverityValue(severity)] || SEVERITY_LABELS.MEDIUM;
+    }
+
+    static isBlocking(severity) {
+        const level = this.getSeverityValue(severity);
+        return level === 'CRITICAL' || level === 'HIGH';
+    }
+
+    static filterBySeverity(violations, severity) {
+        return violations.filter(v => this.getSeverityValue(v.severity) === severity);
+    }
+
+    static sortBySeverity(violations) {
+        return violations.sort((a, b) => {
+            const aLevel = SEVERITY_LEVELS[this.getSeverityValue(a.severity)] || 0;
+            const bLevel = SEVERITY_LEVELS[this.getSeverityValue(b.severity)] || 0;
+            return bLevel - aLevel;
+        });
+    }
+}
+
+module.exports = {
+    SEVERITY_LEVELS,
+    SEVERITY_MAP,
+    SEVERITY_ICONS,
+    SEVERITY_LABELS,
+    SeverityConfig
+};

package/scripts/hooks-system/domain/entities/SeverityConfig.ts

@@ -0,0 +1,90 @@
+export const SEVERITY_LEVELS = {
+    CRITICAL: 4,
+    HIGH: 3,
+    MEDIUM: 2,
+    LOW: 1
+} as const;
+
+export type SeverityLevel = keyof typeof SEVERITY_LEVELS;
+export type SeverityValue = typeof SEVERITY_LEVELS[SeverityLevel];
+
+export const SEVERITY_MAP: Record<string, string> = {
+    'CRITICAL': 'CRITICAL',
+    'HIGH': 'HIGH',
+    'MEDIUM': 'MEDIUM',
+    'LOW': 'LOW',
+    'error': 'HIGH',
+    'warning': 'MEDIUM',
+    'info': 'LOW',
+    'critical': 'CRITICAL',
+    'high': 'HIGH',
+    'medium': 'MEDIUM',
+    'low': 'LOW'
+};
+
+export const SEVERITY_ICONS: Record<string, string> = {
+    CRITICAL: '🔴',
+    HIGH: '🟠',
+    MEDIUM: '🟡',
+    LOW: '🟢'
+};
+
+export const SEVERITY_LABELS: Record<string, string> = {
+    CRITICAL: 'Critical',
+    HIGH: 'High',
+    MEDIUM: 'Medium',
+    LOW: 'Low'
+};
+
+export interface Violation {
+    severity: string;
+    message?: string;
+    file?: string;
+    line?: number;
+    rule?: string;
+}
+
+/**
+ * Severity Configuration Service
+ * Centralized severity mapping and utilities
+ */
+export class SeverityConfig {
+    static getSeverityValue(severity: string): string {
+        return SEVERITY_MAP[severity] || 'MEDIUM';
+    }
+
+    static getSeverityIcon(severity: string): string {
+        return SEVERITY_ICONS[this.getSeverityValue(severity)] || SEVERITY_ICONS.MEDIUM;
+    }
+
+    static getSeverityLabel(severity: string): string {
+        return SEVERITY_LABELS[this.getSeverityValue(severity)] || SEVERITY_LABELS.MEDIUM;
+    }
+
+    static isBlocking(severity: string): boolean {
+        const level = this.getSeverityValue(severity);
+        return level === 'CRITICAL' || level === 'HIGH';
+    }
+
+    static filterBySeverity(violations: Violation[], severity: string): Violation[] {
+        return violations.filter(v => this.getSeverityValue(v.severity) === severity);
+    }
+
+    static sortBySeverity(violations: Violation[]): Violation[] {
+        return violations.sort((a, b) => {
+            const aLevel = SEVERITY_LEVELS[this.getSeverityValue(a.severity) as SeverityLevel] || 0;
+            const bLevel = SEVERITY_LEVELS[this.getSeverityValue(b.severity) as SeverityLevel] || 0;
+            return bLevel - aLevel;
+        });
+    }
+
+    static getSeverityNumericValue(severity: string): number {
+        return SEVERITY_LEVELS[this.getSeverityValue(severity) as SeverityLevel] || 0;
+    }
+
+    static compareSeverity(a: string, b: string): number {
+        return this.getSeverityNumericValue(b) - this.getSeverityNumericValue(a);
+    }
+}
+
+export default SeverityConfig;