pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/reporting/ReportPresenter.js

@@ -0,0 +1,86 @@
+class ReportPresenter {
+    formatText(report, gateResult) {
+        let text = `
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  AST INTELLIGENCE - VIOLATION REPORT
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Generated: ${report.meta.timestamp}
+Status: ${gateResult.passed ? '✅ PASSED' : '❌ FAILED'}
+${gateResult.blockedBy ? `Blocked by: ${gateResult.blockedBy} violations` : ''}
+
+📊 SUMMARY:
+  Total Violations: ${report.summary.total}
+  - 🚨 CRITICAL: ${report.summary.CRITICAL}
+  - ⚠️  HIGH: ${report.summary.HIGH}
+  - ⚡ MEDIUM: ${report.summary.MEDIUM}
+  - ℹ️  LOW: ${report.summary.LOW}
+
+`;
+
+        if (report.summary.intelligentlyEvaluated > 0) {
+            text += `
+🧠 INTELLIGENT SEVERITY EVALUATION:
+  - Evaluated: ${report.summary.intelligentlyEvaluated}/${report.summary.total} (${Math.round(report.summary.intelligentlyEvaluated / report.summary.total * 100)}%)
+  - Upgraded: ${report.summary.upgradedBySeverityIntelligence}
+  - Downgraded: ${report.summary.downgradedBySeverityIntelligence}
+  - Average Score: ${report.summary.averageSeverityScore}/100
+
+`;
+        }
+
+        if (report.impactAnalysis) {
+            text += `
+📊 IMPACT ANALYSIS:
+  Security:        ${report.impactAnalysis.averages.security}/100
+  Stability:       ${report.impactAnalysis.averages.stability}/100
+  Performance:     ${report.impactAnalysis.averages.performance}/100
+  Maintainability: ${report.impactAnalysis.averages.maintainability}/100
+
+  Dominant Impact: ${report.impactAnalysis.dominantImpact.toUpperCase()}
+  Risk Profile: ${report.impactAnalysis.riskProfile}
+
+`;
+        }
+
+        if (report.criticalIssues.length > 0) {
+            text += `
+🚨 CRITICAL ISSUES (MUST FIX):
+
+`;
+            report.criticalIssues.forEach((issue, idx) => {
+                text += `${idx + 1}. ${issue.ruleId}
+   File: ${issue.filePath}:${issue.line}
+   Score: ${issue.severityScore}/100
+   ${issue.message}
+
+`;
+            });
+        }
+
+        if (report.recommendations.length > 0) {
+            text += `
+💡 TOP RECOMMENDATIONS:
+
+`;
+            report.recommendations.slice(0, 5).forEach((rec, idx) => {
+                if (rec.type === 'CATEGORY_PATTERN') {
+                    text += `${idx + 1}. [${rec.category}] ${rec.action}\n`;
+                } else {
+                    text += `${idx + 1}. [Priority ${rec.priority}] ${rec.ruleId}
+   ${rec.filePath}:${rec.line}
+   Score: ${rec.severityScore}/100
+
+`;
+                }
+            });
+        }
+
+        text += `
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+
+        return text;
+    }
+}
+
+module.exports = ReportPresenter;

package/scripts/hooks-system/infrastructure/reporting/__tests__/reporting.spec.js

@@ -0,0 +1,15 @@
+describe('reporting', () => {
+  describe('report-generator', () => {
+    it('should export module', () => {
+      const mod = require('../report-generator');
+      expect(mod).toBeDefined();
+    });
+  });
+
+  describe('severity-tracker', () => {
+    it('should export module', () => {
+      const mod = require('../severity-tracker');
+      expect(mod).toBeDefined();
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/reporting/report-generator.js

@@ -0,0 +1,130 @@
+const fs = require('fs');
+const path = require('path');
+const ReportPresenter = require('./ReportPresenter');
+const ReportMetricsCalculator = require('./ReportMetricsCalculator');
+const ReportImpactAnalyzer = require('./ReportImpactAnalyzer');
+
+class ReportGenerator {
+    constructor() {
+        this.presenter = new ReportPresenter();
+        this.metricsCalculator = new ReportMetricsCalculator();
+        this.impactAnalyzer = new ReportImpactAnalyzer(this.metricsCalculator);
+    }
+
+    /**
+     * Generate comprehensive violation report
+     * @param {Array} violations - Enhanced violations with severity evaluation
+     * @param {Object} gateResult - Quality gate result
+     * @returns {Object} Report object
+     */
+    generate(violations, gateResult) {
+        const timestamp = new Date().toISOString();
+
+        return {
+            meta: {
+                timestamp,
+                generator: 'AST Intelligence v2.0',
+                totalViolations: violations.length,
+                intelligentEvaluationEnabled: violations.some(v => v.intelligentEvaluation),
+                gateStatus: gateResult.passed ? 'PASSED' : 'FAILED'
+            },
+
+            summary: this.generateSummary(violations),
+
+            bySeverity: this.metricsCalculator.groupBySeverity(violations),
+
+            byCategory: this.metricsCalculator.groupByCategory(violations),
+
+            byFile: this.metricsCalculator.groupByFile(violations),
+
+            criticalIssues: this.impactAnalyzer.extractCriticalIssues(violations),
+
+            impactAnalysis: this.impactAnalyzer.analyze(violations),
+
+            recommendations: this.impactAnalyzer.generateRecommendations(violations),
+
+            metrics: this.metricsCalculator.calculate(violations),
+
+            gateResult,
+
+            violations: violations.map(v => this.formatViolation(v))
+        };
+    }
+
+    generateSummary(violations) {
+        const grouped = this.metricsCalculator.groupBySeverity(violations);
+
+        const intelligentCount = violations.filter(v => v.intelligentEvaluation).length;
+        const upgradedCount = violations.filter(v =>
+            v.originalSeverity && v.severity !== v.originalSeverity &&
+            this.metricsCalculator.severityRank(v.severity) > this.metricsCalculator.severityRank(v.originalSeverity)
+        ).length;
+        const downgradedCount = violations.filter(v =>
+            v.originalSeverity && v.severity !== v.originalSeverity &&
+            this.metricsCalculator.severityRank(v.severity) < this.metricsCalculator.severityRank(v.originalSeverity)
+        ).length;
+
+        return {
+            total: violations.length,
+            CRITICAL: grouped.CRITICAL?.length || 0,
+            HIGH: grouped.HIGH?.length || 0,
+            MEDIUM: grouped.MEDIUM?.length || 0,
+            LOW: grouped.LOW?.length || 0,
+            intelligentlyEvaluated: intelligentCount,
+            upgradedBySeverityIntelligence: upgradedCount,
+            downgradedBySeverityIntelligence: downgradedCount,
+            averageSeverityScore: this.metricsCalculator.calculateAverageSeverityScore(violations)
+        };
+    }
+
+    formatViolation(v) {
+        return {
+            ruleId: v.ruleId,
+            severity: v.severity,
+            filePath: v.filePath,
+            line: v.line,
+            column: v.column,
+            message: v.message,
+            ...(v.intelligentEvaluation && {
+                originalSeverity: v.originalSeverity,
+                severityScore: v.severityScore,
+                baseScore: v.baseScore,
+                impactBreakdown: v.impactBreakdown,
+                context: v.context,
+                recommendation: v.recommendation
+            })
+        };
+    }
+
+    /**
+     * Save report to file
+     */
+    save(violations, gateResult, outputPath = '.audit_tmp/intelligent-report.json') {
+        const report = this.generate(violations, gateResult);
+
+        const dir = path.dirname(outputPath);
+        try {
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+        } catch (error) {
+            // Log directory creation error but proceed if possible
+            if (process.env.DEBUG) console.error(`Error creating report directory: ${error.message}`);
+        }
+
+        try {
+            fs.writeFileSync(outputPath, JSON.stringify(report, null, 2));
+
+            const textPath = outputPath.replace('.json', '.txt');
+            fs.writeFileSync(textPath, this.presenter.formatText(report, gateResult));
+
+            return { jsonPath: outputPath, textPath };
+        } catch (error) {
+            if (process.env.DEBUG) console.error(`Error saving report: ${error.message}`);
+            // Return null or partial paths if save fails
+            return { jsonPath: null, textPath: null, error: error.message };
+        }
+    }
+}
+
+module.exports = { ReportGenerator };

package/scripts/hooks-system/infrastructure/reporting/severity-tracker.js

@@ -0,0 +1,105 @@
+
+const fs = require('fs');
+const path = require('path');
+
+class SeverityTracker {
+  constructor(historyPath = '.audit_tmp/severity-history.jsonl') {
+    this.historyPath = historyPath;
+    this.ensureHistoryFile();
+  }
+
+  ensureHistoryFile() {
+    const dir = path.dirname(this.historyPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    if (!fs.existsSync(this.historyPath)) {
+      fs.writeFileSync(this.historyPath, '');
+    }
+  }
+
+  /**
+   * Record violations for this session
+   */
+  record(violations, gateResult) {
+    const entry = {
+      timestamp: new Date().toISOString(),
+      commit: this.getCurrentCommit(),
+      branch: this.getCurrentBranch(),
+      summary: {
+        total: violations.length,
+        CRITICAL: violations.filter(v => v.severity === 'CRITICAL').length,
+        HIGH: violations.filter(v => v.severity === 'HIGH').length,
+        MEDIUM: violations.filter(v => v.severity === 'MEDIUM').length,
+        LOW: violations.filter(v => v.severity === 'LOW').length
+      },
+      averageScore: this.calculateAverageScore(violations),
+      gatePassed: gateResult.passed,
+      blockedBy: gateResult.blockedBy
+    };
+
+    fs.appendFileSync(this.historyPath, JSON.stringify(entry) + '\n');
+
+    return entry;
+  }
+
+  /**
+   * Get trend analysis (last N sessions)
+   */
+  getTrend(limit = 10) {
+    const lines = fs.readFileSync(this.historyPath, 'utf8')
+      .split('\n')
+      .filter(l => l.trim())
+      .slice(-limit);
+
+    const history = lines.map(l => JSON.parse(l));
+
+    if (history.length < 2) {
+      return { trend: 'INSUFFICIENT_DATA', history };
+    }
+
+    const latest = history[history.length - 1];
+    const previous = history[history.length - 2];
+
+    const scoreDelta = latest.averageScore - previous.averageScore;
+    const totalDelta = latest.summary.total - previous.summary.total;
+
+    let trend = 'STABLE';
+    if (scoreDelta > 10 || totalDelta > 5) trend = 'WORSENING';
+    if (scoreDelta < -10 || totalDelta < -5) trend = 'IMPROVING';
+
+    return {
+      trend,
+      latest,
+      previous,
+      scoreDelta,
+      totalDelta,
+      history
+    };
+  }
+
+  getCurrentCommit() {
+    try {
+      return require('child_process').execSync('git rev-parse HEAD', { encoding: 'utf8' }).trim();
+    } catch {
+      return 'unknown';
+    }
+  }
+
+  getCurrentBranch() {
+    try {
+      return require('child_process').execSync('git branch --show-current', { encoding: 'utf8' }).trim();
+    } catch {
+      return 'unknown';
+    }
+  }
+
+  calculateAverageScore(violations) {
+    const withScores = violations.filter(v => v.severityScore);
+    if (withScores.length === 0) return 0;
+
+    return Math.round(withScores.reduce((sum, v) => sum + v.severityScore, 0) / withScores.length);
+  }
+}
+
+module.exports = { SeverityTracker };

package/scripts/hooks-system/infrastructure/repositories/CursorTokenRepository.js

@@ -0,0 +1,76 @@
+const path = require('path');
+const ICursorTokenRepository = require('../../domain/repositories/ICursorTokenRepository');
+const CursorApiDataSource = require('./datasources/CursorApiDataSource');
+const CursorFileDataSource = require('./datasources/CursorFileDataSource');
+
+const DEFAULT_MAX_TOKENS = 1_000_000;
+
+class CursorTokenRepository extends ICursorTokenRepository {
+    constructor({
+        usageFile = path.join(process.cwd(), '.audit_tmp', 'token-usage.jsonl'),
+        apiUrl = process.env.CURSOR_API_URL,
+        apiToken = process.env.CURSOR_API_TOKEN,
+        fetchImpl = typeof fetch === 'function' ? fetch.bind(globalThis) : null,
+        logger = console
+    } = {}) {
+        super();
+        this.apiDataSource = new CursorApiDataSource({ apiUrl, apiToken, fetchImpl, logger });
+        this.fileDataSource = new CursorFileDataSource({ usageFile, logger });
+        this.logger = logger;
+    }
+
+    /**
+     * Fetches token usage from API with exponential backoff retry policy.
+     */
+    async getUsageFromApi(maxRetries = 3, initialDelayMs = 1000) {
+        const payload = await this.apiDataSource.fetchUsage(maxRetries, initialDelayMs);
+        if (!payload) {
+            return null;
+        }
+        return this._normalizePayload(payload, 'api');
+    }
+
+    async getUsageFromFile() {
+        const payload = await this.fileDataSource.readUsage();
+        if (!payload) {
+            return null;
+        }
+        return this._normalizePayload(payload, 'file');
+    }
+
+    _normalizePayload(payload, defaultSource) {
+        const tokensUsed = this._coerceNumber(payload.tokensUsed) ?? 0;
+        const maxTokens = this._coerceNumber(payload.maxTokens) ?? DEFAULT_MAX_TOKENS;
+        const percentUsed = this._coerceNumber(payload.percentUsed) ?? (tokensUsed / maxTokens) * 100;
+        const timestamp = payload.timestamp || new Date().toISOString();
+
+        let source = defaultSource;
+        if (payload.source) {
+            source = payload.source === 'heuristic' ? 'heuristic' : payload.source;
+        }
+
+        return {
+            tokensUsed,
+            maxTokens,
+            percentUsed,
+            timestamp,
+            source,
+            untrusted: source === 'heuristic'
+        };
+    }
+
+    _coerceNumber(value) {
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            const parsed = Number(value);
+            if (Number.isFinite(parsed)) {
+                return parsed;
+            }
+        }
+        return null;
+    }
+}
+
+module.exports = CursorTokenRepository;

package/scripts/hooks-system/infrastructure/repositories/FileFindingsRepository.js

@@ -0,0 +1,88 @@
+
+const fs = require('fs').promises;
+const path = require('path');
+const IFindingsRepository = require('../../domain/repositories/IFindingsRepository');
+const Finding = require('../../domain/entities/Finding');
+const AuditResult = require('../../domain/entities/AuditResult');
+
+class FileFindingsRepository extends IFindingsRepository {
+  constructor(basePath = '.audit_tmp') {
+    super();
+    this.basePath = basePath;
+    this.findingsFile = path.join(basePath, 'findings.json');
+    this.auditResultFile = path.join(basePath, 'audit-result.json');
+  }
+
+  async ensureDirectory() {
+    try {
+      await fs.mkdir(this.basePath, { recursive: true });
+    } catch (error) {
+      if (error.code !== 'EEXIST') {
+        throw error;
+      }
+    }
+  }
+
+  async save(findings) {
+    await this.ensureDirectory();
+
+    const data = findings.map(f => f.toJSON());
+    const json = JSON.stringify(data, null, 2);
+
+    await fs.writeFile(this.findingsFile, json, 'utf-8');
+  }
+
+  async load() {
+    try {
+      const json = await fs.readFile(this.findingsFile, 'utf-8');
+      const data = JSON.parse(json);
+      return data.map(f => Finding.fromJSON(f));
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return [];
+      }
+      throw error;
+    }
+  }
+
+  async clear() {
+    try {
+      await fs.unlink(this.findingsFile);
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        throw error;
+      }
+    }
+  }
+
+  async exists() {
+    try {
+      await fs.access(this.findingsFile);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async saveAuditResult(auditResult) {
+    await this.ensureDirectory();
+
+    const json = JSON.stringify(auditResult.toJSON(), null, 2);
+    await fs.writeFile(this.auditResultFile, json, 'utf-8');
+  }
+
+  async loadAuditResult() {
+    try {
+      const json = await fs.readFile(this.auditResultFile, 'utf-8');
+      const data = JSON.parse(json);
+      return AuditResult.fromJSON(data);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return new AuditResult([]);
+      }
+      throw error;
+    }
+  }
+}
+
+module.exports = FileFindingsRepository;

package/scripts/hooks-system/infrastructure/repositories/__tests__/repositories.spec.js

@@ -0,0 +1,20 @@
+describe('infrastructure/repositories', () => {
+  describe('FileFindingsRepository', () => {
+    it('should export class', () => {
+      const FileFindingsRepository = require('../FileFindingsRepository');
+      expect(FileFindingsRepository).toBeDefined();
+    });
+
+    it('should be instantiable', () => {
+      const FileFindingsRepository = require('../FileFindingsRepository');
+      const instance = new FileFindingsRepository('/tmp');
+      expect(instance).toBeDefined();
+    });
+
+    it('should have save method', () => {
+      const FileFindingsRepository = require('../FileFindingsRepository');
+      const instance = new FileFindingsRepository('/tmp');
+      expect(typeof instance.save).toBe('function');
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/repositories/datasources/CursorApiDataSource.js

@@ -0,0 +1,73 @@
+const { DomainError } = require('../../../domain/errors');
+
+class CursorApiDataSource {
+    constructor({
+        apiUrl = process.env.CURSOR_API_URL,
+        apiToken = process.env.CURSOR_API_TOKEN,
+        fetchImpl = typeof fetch === 'function' ? fetch.bind(globalThis) : null,
+        logger = console
+    } = {}) {
+        this.apiUrl = apiUrl;
+        this.apiToken = apiToken;
+        this.fetch = fetchImpl;
+        this.logger = logger;
+    }
+
+    async fetchUsage(maxRetries = 3, initialDelayMs = 1000) {
+        if (!this.apiUrl || !this.fetch) {
+            return null;
+        }
+
+        const retryPolicy = { maxAttempts: maxRetries, backoff: 'exponential' };
+        const requestTimeoutMs = 30000;
+
+        for (let attempt = 0; attempt <= retryPolicy.maxAttempts; attempt++) {
+            try {
+                const abortController = typeof AbortController !== 'undefined' ? new AbortController() : null;
+                const timeoutId = abortController ? setTimeout(() => abortController.abort(), requestTimeoutMs) : null;
+
+                try {
+                    const response = await this.fetch(this.apiUrl, {
+                        headers: this.apiToken ? { Authorization: `Bearer ${this.apiToken}` } : {},
+                        signal: abortController?.signal
+                    });
+
+                    if (timeoutId) clearTimeout(timeoutId);
+
+                    if (!response.ok) {
+                        throw new DomainError(`Cursor API error: status ${response.status}`, 'API_ERROR');
+                    }
+
+                    const payload = await response.json();
+                    if (!payload) {
+                        return null;
+                    }
+
+                    return payload;
+                } catch (fetchError) {
+                    if (timeoutId) clearTimeout(timeoutId);
+                    if (fetchError.name === 'AbortError') {
+                        throw new DomainError(`Request timeout after ${requestTimeoutMs}ms`, 'TIMEOUT_ERROR');
+                    }
+                    throw fetchError;
+                }
+            } catch (error) {
+                const isLastAttempt = attempt === retryPolicy.maxAttempts;
+                if (isLastAttempt) {
+                    if (this.logger && this.logger.warn) {
+                        this.logger.warn('CURSOR_API_DATASOURCE_FAILED', { error: error.message, attempts: attempt + 1 });
+                    }
+                    return null;
+                }
+
+                if (retryPolicy.backoff === 'exponential') {
+                    const delayMs = initialDelayMs * Math.pow(2, attempt);
+                    await new Promise(resolve => setTimeout(resolve, delayMs));
+                }
+            }
+        }
+        return null;
+    }
+}
+
+module.exports = CursorApiDataSource;

package/scripts/hooks-system/infrastructure/repositories/datasources/CursorFileDataSource.js

@@ -0,0 +1,55 @@
+const fs = require('fs');
+
+class CursorFileDataSource {
+    constructor({
+        usageFile,
+        fsModule = fs,
+        logger = console
+    } = {}) {
+        this.usageFile = usageFile;
+        this.fs = fsModule;
+        this.logger = logger;
+    }
+
+    async readUsage() {
+        try {
+            await this.fs.promises.access(this.usageFile, this.fs.constants.F_OK);
+        } catch (error) {
+            if (this.logger && this.logger.debug) {
+                this.logger.debug('CURSOR_FILE_DATASOURCE_NOT_FOUND', { path: this.usageFile, error: error.message });
+            }
+            return null;
+        }
+
+        try {
+            const content = await this.fs.promises.readFile(this.usageFile, 'utf8');
+            const lines = content.trimEnd().split('\n');
+
+            // Read from end (latest)
+            for (let index = lines.length - 1; index >= 0; index -= 1) {
+                const line = lines[index].trim();
+                if (!line) {
+                    continue;
+                }
+                try {
+                    const parsed = JSON.parse(line);
+                    if (parsed && typeof parsed === 'object') {
+                        return parsed;
+                    }
+                } catch (error) {
+                    if (this.logger && this.logger.debug) {
+                        this.logger.debug('CURSOR_FILE_DATASOURCE_MALFORMED_LINE', { error: error.message });
+                    }
+                }
+            }
+            return null;
+        } catch (error) {
+            if (this.logger && this.logger.error) {
+                this.logger.error('CURSOR_FILE_DATASOURCE_READ_FAILED', { error: error.message });
+            }
+            return null;
+        }
+    }
+}
+
+module.exports = CursorFileDataSource;

package/scripts/hooks-system/infrastructure/severity/__tests__/severity-evaluator.spec.js

@@ -0,0 +1,18 @@
+describe('severity-evaluator', () => {
+  it('should export SeverityEvaluator class', () => {
+    const { SeverityEvaluator } = require('../severity-evaluator');
+    expect(SeverityEvaluator).toBeDefined();
+  });
+
+  it('should be instantiable', () => {
+    const { SeverityEvaluator } = require('../severity-evaluator');
+    const instance = new SeverityEvaluator();
+    expect(instance).toBeDefined();
+  });
+
+  it('should have evaluate method', () => {
+    const { SeverityEvaluator } = require('../severity-evaluator');
+    const instance = new SeverityEvaluator();
+    expect(typeof instance.evaluate).toBe('function');
+  });
+});