pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/application/use-cases/AnalyzeCodebaseUseCase.js

@@ -0,0 +1,54 @@
+const AuditResult = require('../../domain/entities/AuditResult');
+
+class AnalyzeCodebaseUseCase {
+  constructor(platformAnalyzers, findingsRepository, platformDetectionService) {
+    this.platformAnalyzers = platformAnalyzers;
+    this.findingsRepository = findingsRepository;
+    this.platformDetectionService = platformDetectionService;
+  }
+
+  async execute(targetPath, options = {}) {
+    try {
+      const platforms = await this.platformDetectionService.detectPlatforms(targetPath);
+
+      const allFindings = [];
+
+      for (const platform of platforms) {
+        const analyzer = this.platformAnalyzers[platform.toLowerCase()];
+
+        if (!analyzer) {
+          continue;
+        }
+        const platformFindings = await analyzer.analyze(targetPath, options);
+
+        if (platformFindings && platformFindings.length > 0) {
+          allFindings.push(...platformFindings);
+        }
+      }
+
+      const auditResult = new AuditResult(allFindings);
+
+      const metadata = await this.collectMetadata(targetPath, platforms);
+      auditResult.setMetadata(metadata.totalFiles, metadata.totalLines, platforms);
+
+      if (options.saveResults !== false) {
+        await this.findingsRepository.saveAuditResult(auditResult);
+      }
+
+      return auditResult;
+
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async collectMetadata(targetPath, platforms) {
+    return {
+      totalFiles: 0,
+      totalLines: 0,
+      platforms,
+    };
+  }
+}
+
+module.exports = AnalyzeCodebaseUseCase;

package/scripts/hooks-system/application/use-cases/AnalyzeStagedFilesUseCase.js

@@ -0,0 +1,61 @@
+
+const AuditResult = require('../../domain/entities/AuditResult');
+
+class AnalyzeStagedFilesUseCase {
+  constructor(platformAnalyzers, gitOperations, platformDetectionService) {
+    this.platformAnalyzers = platformAnalyzers;
+    this.gitOperations = gitOperations;
+    this.platformDetectionService = platformDetectionService;
+  }
+
+  async execute(options = {}) {
+    try {
+      const stagedFiles = await this.gitOperations.getStagedFiles();
+
+      if (stagedFiles.length === 0) {
+        return new AuditResult([]);
+      }
+
+      const filesByPlatform = this.groupFilesByPlatform(stagedFiles);
+      const allFindings = [];
+
+      for (const [platform, files] of Object.entries(filesByPlatform)) {
+        const analyzer = this.platformAnalyzers[platform.toLowerCase()];
+
+        if (!analyzer) {
+          continue;
+        }
+
+        const platformFindings = await analyzer.analyzeFiles(files, options);
+
+        if (platformFindings && platformFindings.length > 0) {
+          allFindings.push(...platformFindings);
+        }
+      }
+
+      const auditResult = new AuditResult(allFindings);
+      return auditResult;
+
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  groupFilesByPlatform(stagedFiles) {
+    const grouped = {};
+
+    stagedFiles.forEach(filePath => {
+      const platform = this.platformDetectionService.detectPlatformFromFile(filePath);
+
+      if (!grouped[platform]) {
+        grouped[platform] = [];
+      }
+
+      grouped[platform].push(filePath);
+    });
+
+    return grouped;
+  }
+}
+
+module.exports = AnalyzeStagedFilesUseCase;

package/scripts/hooks-system/application/use-cases/AutoExecuteAIStartUseCase.js

@@ -0,0 +1,123 @@
+const { execSync } = require('child_process');
+const path = require('path');
+const { ValidationError, ConfigurationError } = require('../../domain/errors');
+
+function resolveUpdateEvidenceScript(repoRoot) {
+  const candidates = [
+    path.join(repoRoot, 'scripts/hooks-system/bin/update-evidence.sh'),
+    path.join(repoRoot, 'node_modules/@pumuki/ast-intelligence-hooks/bin/update-evidence.sh'),
+    path.join(repoRoot, 'bin/update-evidence.sh')
+  ];
+
+  const fs = require('fs');
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+class AutoExecuteAIStartUseCase {
+  constructor(orchestrator, repoRoot, logger = console) {
+    this.orchestrator = orchestrator;
+    this.repoRoot = repoRoot || process.cwd();
+    this.logger = logger;
+    this.updateEvidenceScript = resolveUpdateEvidenceScript(this.repoRoot);
+  }
+
+  async execute(platforms, confidence) {
+    if (!platforms || platforms.length === 0) {
+      return {
+        success: false,
+        action: 'error',
+        message: 'No platforms provided'
+      };
+    }
+
+    if (confidence < 70) {
+      return {
+        success: true,
+        action: 'ignored',
+        confidence,
+        message: `Confidence too low (${confidence}%) - threshold is 70%`
+      };
+    }
+
+    if (confidence >= 90) {
+      return await this.autoExecute(platforms, confidence);
+    }
+
+    return {
+      success: true,
+      action: 'ask',
+      confidence,
+      platforms,
+      message: `Medium confidence (${confidence}%) - AI should ask user for confirmation`
+    };
+  }
+
+  async autoExecute(platforms, confidence) {
+    try {
+      const platformsStr = platforms
+        .map(p => {
+          if (!p) return null;
+          if (typeof p === 'object') return p.platform;
+          return p;
+        })
+        .filter(Boolean)
+        .join(',');
+
+      if (!platformsStr) {
+        throw new ValidationError('No valid platforms to execute', 'platforms');
+      }
+
+      if (!this.updateEvidenceScript) {
+        throw new ConfigurationError('update-evidence.sh not found', 'updateEvidenceScript');
+      }
+
+      const command = `bash "${this.updateEvidenceScript}" --auto --platforms "${platformsStr}"`;
+
+      this.logger.info(`[AutoExecuteAIStartUseCase] Executing AI Start`, { command, platforms: platformsStr });
+
+      const output = execSync(command, {
+        cwd: this.repoRoot,
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'pipe']
+      }).trim();
+
+      let parsedOutput;
+      try {
+        parsedOutput = JSON.parse(output);
+      } catch (e) {
+        parsedOutput = { raw: output };
+      }
+
+      this.logger.info(`[AutoExecuteAIStartUseCase] Execution successful`, { platforms: platformsStr });
+
+      return {
+        success: true,
+        action: 'auto-executed',
+        confidence,
+        platforms,
+        message: `AI Start executed automatically for: ${platformsStr}`,
+        output: parsedOutput
+      };
+
+    } catch (error) {
+      this.logger.error(`[AutoExecuteAIStartUseCase] Execution failed`, { error: error.message, platforms });
+
+      return {
+        success: false,
+        action: 'error',
+        confidence,
+        platforms,
+        message: `Failed to execute ai-start: ${error.message}`,
+        error: error.stderr || error.message
+      };
+    }
+  }
+}
+
+module.exports = AutoExecuteAIStartUseCase;

package/scripts/hooks-system/application/use-cases/BlockCommitUseCase.js

@@ -0,0 +1,90 @@
+
+const CommitBlockingRules = require('../../domain/rules/CommitBlockingRules');
+
+class BlockCommitUseCase {
+  constructor(commitBlockingRules) {
+    this.commitBlockingRules = commitBlockingRules || new CommitBlockingRules();
+  }
+
+  async execute(auditResult, options = {}) {
+    const strictMode = options.strictMode || false;
+    const blockOnlyCriticalHigh = options.blockOnlyCriticalHigh || false;
+    const useStagedOnly = options.useStagedOnly || false;
+
+    try {
+      let decision;
+
+      if (useStagedOnly && auditResult.findings) {
+        decision = this.commitBlockingRules.shouldBlockByStagedFiles(
+          auditResult.findings,
+          strictMode
+        );
+      } else {
+        decision = this.commitBlockingRules.shouldBlockCommit(
+          auditResult,
+          strictMode,
+          blockOnlyCriticalHigh
+        );
+      }
+
+      if (!decision.shouldBlock) {
+        const debtCheck = this.commitBlockingRules.calculateTechnicalDebtThreshold(auditResult);
+        decision.technicalDebt = debtCheck.currentDebt;
+        decision.debtMessage = debtCheck.message;
+
+        const maintainabilityGate = this.commitBlockingRules.getMaintainabilityGate(auditResult);
+        decision.maintainability = maintainabilityGate;
+      }
+
+      return decision;
+
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  formatDecisionMessage(decision) {
+    const lines = [];
+
+    if (decision.shouldBlock) {
+      lines.push('');
+      lines.push('❌ COMMIT BLOCKED');
+      lines.push('═'.repeat(60));
+      lines.push(`Reason: ${decision.reason}`);
+
+      if (decision.violations) {
+        lines.push('');
+        lines.push('Violations:');
+        Object.entries(decision.violations).forEach(([severity, count]) => {
+          if (count > 0) {
+            const emoji = severity === 'critical' ? '🔴' : '🟠';
+            lines.push(`  ${emoji} ${severity.toUpperCase()}: ${count}`);
+          }
+        });
+      }
+
+      lines.push('');
+      lines.push('🔧 Please fix these violations before committing.');
+      lines.push('💡 Use GIT_BYPASS_HOOK=1 for emergency bypass (not recommended).');
+      lines.push('');
+    } else {
+      lines.push('');
+      lines.push('✅ COMMIT ALLOWED');
+      lines.push('═'.repeat(60));
+      lines.push(`Reason: ${decision.reason}`);
+
+      if (decision.technicalDebt && decision.technicalDebt > 0) {
+        lines.push('');
+        lines.push('⚠️  Technical Debt Tracking:');
+        lines.push(`  ${decision.debtMessage}`);
+        lines.push(`  Maintainability: ${decision.maintainability.score.toFixed(1)}/100`);
+      }
+
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+}
+
+module.exports = BlockCommitUseCase;

package/scripts/hooks-system/application/use-cases/GenerateAuditReportUseCase.js

@@ -0,0 +1,184 @@
+
+class GenerateAuditReportUseCase {
+  constructor(outputFormatter, auditAnalyzer, auditScorer) {
+    this.outputFormatter = outputFormatter;
+    this.auditAnalyzer = auditAnalyzer; // Inject Analyzer
+    this.auditScorer = auditScorer;     // Inject Scorer
+  }
+
+  async execute(auditResult, options = {}) {
+    const reportType = options.reportType || 'console';
+    const includeSignature = options.includeSignature !== false;
+
+    try {
+      let report;
+
+      switch (reportType) {
+        case 'json':
+          report = this.generateJSONReport(auditResult);
+          break;
+        case 'html':
+          report = this.generateHTMLReport(auditResult);
+          break;
+        case 'console':
+        default:
+          report = this.generateConsoleReport(auditResult, includeSignature);
+          break;
+      }
+
+      return report;
+
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  generateJSONReport(auditResult) {
+    // AuditResult.toJSON already handles serialization via serializer
+    return JSON.stringify(auditResult.toJSON(), null, 2);
+  }
+
+  generateHTMLReport(auditResult) {
+    const json = auditResult.toJSON();
+    const summary = json.summary;
+
+    return `
+<!DOCTYPE html>
+<html lang="es">
+<head>
+  <meta charset="UTF-8">
+  <title>Audit Report</title>
+  <style>
+    body { font-family: Arial, sans-serif; padding: 20px; }
+    .summary { background: #f5f5f5; padding: 15px; border-radius: 5px; }
+    .critical { color: #d32f2f; }
+    .high { color: #f57c00; }
+    .medium { color: #fbc02d; }
+    .low { color: #388e3c; }
+  </style>
+</head>
+<body>
+  <h1>Professional Code Quality Audit Report</h1>
+  <div class="summary">
+    <h2>Summary</h2>
+    <p><strong>Total Violations:</strong> ${summary.totalViolations}</p>
+    <p><strong>Critical:</strong> <span class="critical">${summary.bySeverity.critical}</span></p>
+    <p><strong>High:</strong> <span class="high">${summary.bySeverity.high}</span></p>
+    <p><strong>Medium:</strong> <span class="medium">${summary.bySeverity.medium}</span></p>
+    <p><strong>Low:</strong> <span class="low">${summary.bySeverity.low}</span></p>
+    <p><strong>Technical Debt:</strong> ${summary.technicalDebtHours.toFixed(1)} hours</p>
+    <p><strong>Maintainability Index:</strong> ${summary.maintainabilityIndex.toFixed(1)}/100</p>
+  </div>
+</body>
+</html>`;
+  }
+
+  generateConsoleReport(auditResult, includeSignature) {
+    const lines = [];
+    const findings = auditResult.findings;
+
+    // Use injected analyzer/scorer or fallback to helpers if not injected (for backward compat/tests)
+    // Assuming for now they are passed or we use the ones attached to result if refactor isn't 100% complete in consumers
+    // But target is to decouple. Let's assume we use the methods on result which we are about to move?
+    // No, we are moving them OUT. So we must compute them here or use the helper.
+    // To properly decouple, we should use the Analyzer here.
+
+    // Fallback instantiation if not provided in DI (to keep robust)
+    const AuditAnalyzer = require('../../domain/services/AuditAnalyzer');
+    const AuditScorer = require('../../domain/services/AuditScorer');
+
+    const scorer = this.auditScorer || new AuditScorer();
+    const analyzer = this.auditAnalyzer || new AuditAnalyzer(scorer);
+
+    if (includeSignature) {
+      if (this.outputFormatter && this.outputFormatter.generateSignature) {
+        lines.push(this.outputFormatter.generateSignature());
+      } else {
+        lines.push(this.generateDefaultSignature());
+      }
+      lines.push('');
+    }
+
+    lines.push('📊 AUDIT SUMMARY');
+    lines.push('═'.repeat(60));
+    lines.push(`Total Violations: ${auditResult.getTotalViolations()}`);
+
+    const bySeverity = analyzer.getViolationsBySeverity(findings);
+    lines.push(`  🔴 CRITICAL: ${bySeverity.critical}`);
+    lines.push(`  🟠 HIGH:     ${bySeverity.high}`);
+    lines.push(`  🟡 MEDIUM:   ${bySeverity.medium}`);
+    lines.push(`  🟢 LOW:      ${bySeverity.low}`);
+    lines.push('');
+
+    const debt = scorer.calculateTechnicalDebt(findings);
+    const maintainability = scorer.calculateMaintainabilityIndex(findings);
+
+    lines.push(`⏱️  Technical Debt: ${debt.toFixed(1)} hours`);
+    lines.push(`📈 Maintainability Index: ${maintainability.toFixed(1)}/100`);
+    lines.push('');
+
+    const byPlatform = analyzer.getViolationsByPlatform(findings);
+    if (Object.keys(byPlatform).length > 0) {
+      lines.push('🔧 BY PLATFORM');
+      lines.push('─'.repeat(60));
+      Object.entries(byPlatform).forEach(([platform, stats]) => {
+        lines.push(`${platform.toUpperCase()}: ${stats.total} violations`);
+        lines.push(`  Critical: ${stats.critical}, High: ${stats.high}, Medium: ${stats.medium}, Low: ${stats.low}`);
+      });
+      lines.push('');
+    }
+
+    const topRules = analyzer.getTopViolatedRules(findings, 5);
+    if (topRules.length > 0) {
+      lines.push('🔝 TOP VIOLATED RULES');
+      lines.push('─'.repeat(60));
+      topRules.forEach((rule, index) => {
+        lines.push(`${index + 1}. ${rule.ruleId} (${rule.count}x) - Severity: ${rule.severity}`);
+      });
+      lines.push('');
+    }
+
+    const topFiles = analyzer.getTopViolatedFiles(findings, 5);
+    if (topFiles.length > 0) {
+      lines.push('📁 TOP VIOLATED FILES');
+      lines.push('─'.repeat(60));
+      topFiles.forEach((file, index) => {
+        const fileName = file.filePath.split('/').pop();
+        lines.push(`${index + 1}. ${fileName} (${file.count} violations)`);
+        lines.push(`   Critical: ${file.bySeverity.critical}, High: ${file.bySeverity.high}`);
+      });
+      lines.push('');
+    }
+
+    if (includeSignature) {
+      lines.push('');
+      lines.push('═'.repeat(60));
+      lines.push('');
+      lines.push('  🐈💚 PUMUKI TEAM® - Advanced Project Intelligence');
+      lines.push(`  Generated: ${new Date().toLocaleString('es-ES', { timeZone: 'Europe/Madrid' })}`);
+      lines.push(`  Project: ${this.getProjectName()}`);
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+
+  getProjectName() {
+    try {
+      const packageJson = require('../../../package.json');
+      return packageJson.name || 'unknown-project';
+    } catch {
+      return 'unknown-project';
+    }
+  }
+
+  generateDefaultSignature() {
+    return `
+╔═══════════════════════════════════════════════════════════╗
+║   🐈💚 PUMUKI TEAM® - ARCHITECTURE COMPLIANCE AUDIT       ║
+║   Generated: ${new Date().toLocaleString('es-ES', { timeZone: 'Europe/Madrid' })}    ║
+╚═══════════════════════════════════════════════════════════╝`;
+  }
+}
+
+module.exports = GenerateAuditReportUseCase;

package/scripts/hooks-system/application/use-cases/__tests__/AnalyzeCodebaseUseCase.spec.js

@@ -0,0 +1,156 @@
+const AnalyzeCodebaseUseCase = require('../AnalyzeCodebaseUseCase');
+const AuditResult = require('../../../domain/entities/AuditResult');
+const Finding = require('../../../domain/entities/Finding');
+
+describe('AnalyzeCodebaseUseCase', () => {
+  let useCase;
+  let mockPlatformAnalyzers;
+  let mockFindingsRepository;
+  let mockPlatformDetectionService;
+
+  beforeEach(() => {
+    mockPlatformAnalyzers = {
+      backend: {
+        analyze: jest.fn().mockResolvedValue([
+          new Finding('backend.rule1', 'high', 'Backend violation', 'backend/test.ts', 10, 'backend'),
+        ]),
+      },
+      frontend: {
+        analyze: jest.fn().mockResolvedValue([
+          new Finding('frontend.rule1', 'medium', 'Frontend violation', 'frontend/test.tsx', 20, 'frontend'),
+        ]),
+      },
+    };
+
+    mockFindingsRepository = {
+      saveAuditResult: jest.fn().mockResolvedValue(undefined),
+    };
+
+    mockPlatformDetectionService = {
+      detectPlatforms: jest.fn().mockResolvedValue(['backend', 'frontend']),
+    };
+
+    useCase = new AnalyzeCodebaseUseCase(
+      mockPlatformAnalyzers,
+      mockFindingsRepository,
+      mockPlatformDetectionService
+    );
+  });
+
+  describe('execute', () => {
+    it('should analyze codebase for all detected platforms', async () => {
+      const targetPath = '/path/to/project';
+      const options = {};
+
+      const result = await useCase.execute(targetPath, options);
+
+      expect(mockPlatformDetectionService.detectPlatforms).toHaveBeenCalledWith(targetPath);
+      expect(mockPlatformAnalyzers.backend.analyze).toHaveBeenCalledWith(targetPath, options);
+      expect(mockPlatformAnalyzers.frontend.analyze).toHaveBeenCalledWith(targetPath, options);
+      expect(result).toBeInstanceOf(AuditResult);
+      expect(result.getTotalViolations()).toBe(2);
+    });
+
+    it('should skip platforms without analyzers', async () => {
+      mockPlatformDetectionService.detectPlatforms.mockResolvedValue(['backend', 'ios', 'unknown']);
+      mockPlatformAnalyzers.ios = undefined;
+
+      const result = await useCase.execute('/path/to/project', {});
+
+      expect(mockPlatformAnalyzers.backend.analyze).toHaveBeenCalled();
+      expect(result.getTotalViolations()).toBe(1);
+    });
+
+    it('should save results to repository by default', async () => {
+      const targetPath = '/path/to/project';
+      const options = {};
+
+      await useCase.execute(targetPath, options);
+
+      expect(mockFindingsRepository.saveAuditResult).toHaveBeenCalled();
+      expect(mockFindingsRepository.saveAuditResult.mock.calls[0][0]).toBeInstanceOf(AuditResult);
+    });
+
+    it('should not save results when saveResults is false', async () => {
+      const targetPath = '/path/to/project';
+      const options = { saveResults: false };
+
+      await useCase.execute(targetPath, options);
+
+      expect(mockFindingsRepository.saveAuditResult).not.toHaveBeenCalled();
+    });
+
+    it('should set metadata on audit result', async () => {
+      const targetPath = '/path/to/project';
+      const options = {};
+
+      const result = await useCase.execute(targetPath, options);
+
+      expect(result.metadata.platforms).toEqual(['backend', 'frontend']);
+      expect(result.metadata.totalFiles).toBe(0);
+      expect(result.metadata.totalLines).toBe(0);
+    });
+
+    it('should handle empty findings from analyzers', async () => {
+      mockPlatformAnalyzers.backend.analyze.mockResolvedValue([]);
+      mockPlatformAnalyzers.frontend.analyze.mockResolvedValue([]);
+
+      const result = await useCase.execute('/path/to/project', {});
+
+      expect(result.getTotalViolations()).toBe(0);
+      expect(result).toBeInstanceOf(AuditResult);
+    });
+
+    it('should handle null findings from analyzers', async () => {
+      mockPlatformAnalyzers.backend.analyze.mockResolvedValue(null);
+      mockPlatformAnalyzers.frontend.analyze.mockResolvedValue(null);
+
+      const result = await useCase.execute('/path/to/project', {});
+
+      expect(result.getTotalViolations()).toBe(0);
+    });
+
+    it('should propagate errors from platform detection', async () => {
+      const error = new Error('Platform detection failed');
+      mockPlatformDetectionService.detectPlatforms.mockRejectedValue(error);
+
+      await expect(useCase.execute('/path/to/project', {})).rejects.toThrow('Platform detection failed');
+    });
+
+    it('should propagate errors from analyzers', async () => {
+      const error = new Error('Analysis failed');
+      mockPlatformAnalyzers.backend.analyze.mockRejectedValue(error);
+
+      await expect(useCase.execute('/path/to/project', {})).rejects.toThrow('Analysis failed');
+    });
+
+    it('should propagate errors from repository save', async () => {
+      const error = new Error('Save failed');
+      mockFindingsRepository.saveAuditResult.mockRejectedValue(error);
+
+      await expect(useCase.execute('/path/to/project', {})).rejects.toThrow('Save failed');
+    });
+
+    it('should handle case-insensitive platform names', async () => {
+      mockPlatformDetectionService.detectPlatforms.mockResolvedValue(['BACKEND', 'Frontend']);
+      mockPlatformAnalyzers.backend = mockPlatformAnalyzers.backend;
+      mockPlatformAnalyzers.frontend = mockPlatformAnalyzers.frontend;
+
+      const result = await useCase.execute('/path/to/project', {});
+
+      expect(result.getTotalViolations()).toBeGreaterThan(0);
+    });
+  });
+
+  describe('collectMetadata', () => {
+    it('should return metadata with platforms', async () => {
+      const platforms = ['backend', 'frontend', 'ios'];
+      const metadata = await useCase.collectMetadata('/path/to/project', platforms);
+
+      expect(metadata.platforms).toEqual(platforms);
+      expect(metadata.totalFiles).toBe(0);
+      expect(metadata.totalLines).toBe(0);
+    });
+  });
+});
+