pumuki-ast-hooks 5.5.49 → 5.5.51

package/scripts/hooks-system/infrastructure/ast/ast-core.js

@@ -45,6 +45,18 @@ function getRepoRoot() {
  */
 function shouldIgnore(file) {
   const p = file.replace(/\\/g, "/");
+  try {
+    const configPaths = loadExclusions()?.exclusions?.paths;
+    if (configPaths && typeof configPaths === 'object') {
+      for (const [key, enabled] of Object.entries(configPaths)) {
+        if (enabled && p.includes(key)) return true;
+      }
+    }
+  } catch (error) {
+    if (process.env.DEBUG) {
+      console.debug(`[ast-core] Failed to load exclusions for shouldIgnore: ${error.message || String(error)}`);
+    }
+  }
   if (p.includes("node_modules/")) return true;
   if (p.includes("/.next/")) return true;
   if (p.includes("/dist/")) return true;
@@ -125,7 +137,7 @@ let exclusionsConfig = null;
 function loadExclusions() {
   if (exclusionsConfig) return exclusionsConfig;
   try {
-    const configPath = path.join(__dirname, '../../config/ast-exclusions.json');
+    const configPath = path.join(getRepoRoot(), 'config', 'ast-exclusions.json');
     if (fs.existsSync(configPath)) {
       exclusionsConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
     }

package/scripts/hooks-system/infrastructure/ast/ast-intelligence.js

@@ -22,7 +22,7 @@ function formatLocalTimestamp(date = new Date()) {
 }
 
 const astModulesPath = __dirname;
-const { createProject, platformOf, mapToLevel } = require(path.join(astModulesPath, "ast-core"));
+const { createProject, platformOf, mapToLevel, shouldIgnore: coreShouldIgnore } = require(path.join(astModulesPath, "ast-core"));
 const MacOSNotificationAdapter = require(path.join(__dirname, '../adapters/MacOSNotificationAdapter'));
 const { runBackendIntelligence } = require(path.join(astModulesPath, "backend/ast-backend"));
 const { runFrontendIntelligence } = require(path.join(astModulesPath, "frontend/ast-frontend"));
@@ -138,8 +138,6 @@ function runProjectHardcodedThresholdAudit(root, allFiles, findings) {
     if (p.includes('/build/')) return true;
     if (p.includes('/coverage/')) return true;
     if (p.includes('/.audit_tmp/')) return true;
-    if (p.includes('/infrastructure/ast/')) return true;
-    if (p.includes('/scripts/hooks-system/')) return true;
     return false;
   };
 
@@ -706,6 +704,7 @@ function listSourceFiles(root) {
  */
 function shouldIgnore(file) {
   const p = file.replace(/\\/g, "/");
+  if (typeof coreShouldIgnore === 'function' && coreShouldIgnore(p)) return true;
   if (p.includes("node_modules/")) return true;
   if (p.includes("/.cursor/")) return true;
   if (/\.bak/i.test(p)) return true;

package/scripts/hooks-system/infrastructure/ast/backend/ast-backend.js

@@ -126,13 +126,10 @@ function runBackendIntelligence(project, findings, platform) {
         return;
       }
       // NO excluir archivos AST - la librería debe auto-auditarse
-      if (isTestFile(filePath)) return;
-
       sf.getDescendantsOfKind(SyntaxKind.ClassDeclaration).forEach((cls) => {
         const className = cls.getName() || '';
         const isValueObject = /Metrics|ValueObject|VO$|Dto$|Entity$/.test(className);
-        const isTestClass = /Spec$|Test$|Mock/.test(className);
-        if (isValueObject || isTestClass) return;
+        if (isValueObject) return;
 
         const methodsCount = cls.getMethods().length;
         const propertiesCount = cls.getProperties().length;

package/scripts/hooks-system/infrastructure/ast/backend/detectors/god-class-detector.js

@@ -7,8 +7,7 @@ function analyzeGodClasses(sourceFile, findings, { SyntaxKind, pushFinding, godC
     sourceFile.getDescendantsOfKind(SyntaxKind.ClassDeclaration).forEach((cls) => {
         const className = cls.getName() || '';
         const isValueObject = /Metrics|ValueObject|VO$|Dto$|Entity$/.test(className);
-        const isTestClass = /Spec$|Test$|Mock/.test(className);
-        if (isValueObject || isTestClass) return;
+        if (isValueObject) return;
 
         const methodsCount = cls.getMethods().length;
         const propertiesCount = cls.getProperties().length;

package/scripts/hooks-system/infrastructure/ast/ios/analyzers/StagedSwiftFilePreparer.js

@@ -0,0 +1,59 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { execSync } = require('child_process');
+
+class StagedSwiftFilePreparer {
+    constructor({ repoRoot, auditTmpDir }) {
+        this.repoRoot = repoRoot;
+        this.auditTmpDir = auditTmpDir || path.join(repoRoot, '.audit_tmp');
+    }
+
+    safeTempFilePath(displayPath) {
+        const hash = crypto.createHash('sha1').update(String(displayPath)).digest('hex').slice(0, 10);
+        const base = path.basename(displayPath, '.swift');
+        const filename = `${base}.${hash}.staged.swift`;
+        return path.join(this.auditTmpDir, filename);
+    }
+
+    readStagedFileContent(relPath) {
+        try {
+            return execSync(`git show :"${relPath}"`, {
+                encoding: 'utf8',
+                cwd: this.repoRoot,
+                stdio: ['ignore', 'pipe', 'pipe']
+            });
+        } catch (error) {
+            if (process.env.DEBUG) {
+                console.debug(`[StagedSwiftFilePreparer] Failed to read staged file ${relPath}: ${error.message}`);
+            }
+            return null;
+        }
+    }
+
+    prepare({ filePath, stagedRelPath, stagingOnly }) {
+        let parsePath = filePath;
+        let contentOverride = null;
+
+        if (stagingOnly && stagedRelPath) {
+            const stagedContent = this.readStagedFileContent(stagedRelPath);
+            if (typeof stagedContent === 'string') {
+                const tmpPath = this.safeTempFilePath(stagedRelPath);
+                try {
+                    fs.mkdirSync(path.dirname(tmpPath), { recursive: true });
+                    fs.writeFileSync(tmpPath, stagedContent, 'utf8');
+                    parsePath = tmpPath;
+                    contentOverride = stagedContent;
+                } catch (error) {
+                    if (process.env.DEBUG) {
+                        console.debug(`[StagedSwiftFilePreparer] Failed to write temp staged file ${tmpPath}: ${error.message}`);
+                    }
+                }
+            }
+        }
+
+        return { parsePath, contentOverride };
+    }
+}
+
+module.exports = { StagedSwiftFilePreparer };

package/scripts/hooks-system/infrastructure/ast/ios/analyzers/SwiftAstRunner.js

@@ -0,0 +1,51 @@
+const { execSync } = require('child_process');
+
+class SwiftAstRunner {
+    constructor({ toolchain }) {
+        this.toolchain = toolchain;
+    }
+
+    runSwiftSyntax(filePath, displayPath, findings) {
+        if (!this.toolchain.swiftSyntaxPath) return;
+
+        try {
+            const result = execSync(`"${this.toolchain.swiftSyntaxPath}" "${filePath}"`, {
+                encoding: 'utf8',
+                timeout: 30000,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            const violations = JSON.parse(result);
+            violations.forEach(v => {
+                findings.push({
+                    ruleId: v.ruleId,
+                    severity: String(v.severity || '').toUpperCase(),
+                    filePath: displayPath || filePath,
+                    line: v.line,
+                    column: v.column,
+                    message: v.message,
+                });
+            });
+        } catch (error) {
+            console.error('[SwiftAstRunner] Error parsing file with SwiftSyntax:', error.message);
+        }
+    }
+
+    parseSourceKitten(filePath) {
+        if (!this.toolchain.checkSourceKitten()) return null;
+
+        try {
+            const result = execSync(
+                `${this.toolchain.sourceKittenPath} structure --file "${filePath}"`,
+                { encoding: 'utf8', timeout: 30000, stdio: ['pipe', 'pipe', 'pipe'] }
+            );
+            return JSON.parse(result);
+        } catch (error) {
+            if (process.env.DEBUG) {
+                console.debug(`[SwiftAstRunner] SourceKitten parse failed for ${filePath}: ${error.message}`);
+            }
+            return null;
+        }
+    }
+}
+
+module.exports = { SwiftAstRunner };

package/scripts/hooks-system/infrastructure/ast/ios/analyzers/SwiftToolchainResolver.js

@@ -0,0 +1,57 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const env = require(path.join(__dirname, '../../../../config/env'));
+
+class SwiftToolchainResolver {
+    constructor(options = {}) {
+        this.sourceKittenPath = options.sourceKittenPath || '/opt/homebrew/bin/sourcekitten';
+        this.projectRoot = options.projectRoot || this.detectRepoRoot();
+        this.swiftSyntaxPath = this.findSwiftSyntaxBinary(this.projectRoot);
+    }
+
+    detectRepoRoot() {
+        try {
+            return execSync('git rev-parse --show-toplevel', { encoding: 'utf-8' }).trim();
+        } catch {
+            return process.cwd();
+        }
+    }
+
+    resolveAuditTmpDir(repoRoot) {
+        const configured = String(env.get('AUDIT_TMP', '') || '').trim();
+        if (configured.length > 0) {
+            return path.isAbsolute(configured) ? configured : path.join(repoRoot, configured);
+        }
+        return path.join(repoRoot, '.audit_tmp');
+    }
+
+    checkSourceKitten() {
+        try {
+            execSync(`${this.sourceKittenPath} version`, { stdio: 'pipe' });
+            return true;
+        } catch (error) {
+            if (process.env.DEBUG) {
+                console.debug(`[SwiftToolchainResolver] SourceKitten not available at ${this.sourceKittenPath}: ${error.message}`);
+            }
+            return false;
+        }
+    }
+
+    findSwiftSyntaxBinary(projectRoot) {
+        const possiblePaths = [
+            path.join(__dirname, '../../../../../CustomLintRules/.build/debug/swift-ast-analyzer'),
+            path.join(projectRoot, 'CustomLintRules/.build/debug/swift-ast-analyzer'),
+            path.join(projectRoot, '.build/debug/swift-ast-analyzer'),
+        ];
+
+        for (const p of possiblePaths) {
+            if (fs.existsSync(p)) {
+                return p;
+            }
+        }
+        return null;
+    }
+}
+
+module.exports = { SwiftToolchainResolver };

package/scripts/hooks-system/infrastructure/ast/ios/analyzers/iOSASTIntelligentAnalyzer.js

@@ -1,7 +1,6 @@
 const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
-const crypto = require('crypto');
 const env = require(path.join(__dirname, '../../../../config/env'));
 const {
   resetCollections,
@@ -9,13 +8,21 @@ const {
   analyzeCollectedNodes,
   finalizeGodClassDetection,
 } = require('../detectors/ios-ast-intelligent-strategies');
+const { SwiftToolchainResolver } = require('./SwiftToolchainResolver');
+const { StagedSwiftFilePreparer } = require('./StagedSwiftFilePreparer');
+const { SwiftAstRunner } = require('./SwiftAstRunner');
+const { iOSAstAnalysisOrchestrator } = require('./iOSAstAnalysisOrchestrator');
 
 class iOSASTIntelligentAnalyzer {
   constructor(findings) {
     this.findings = findings;
-    this.sourceKittenPath = '/opt/homebrew/bin/sourcekitten';
-    this.isAvailable = this.checkSourceKitten();
-    this.hasSwiftSyntax = this.checkSwiftSyntax();
+    this.toolchain = new SwiftToolchainResolver();
+    this.sourceKittenPath = this.toolchain.sourceKittenPath;
+    this.isAvailable = this.toolchain.checkSourceKitten();
+    this.swiftSyntaxPath = this.toolchain.swiftSyntaxPath;
+    this.hasSwiftSyntax = Boolean(this.swiftSyntaxPath);
+    this.swiftRunner = new SwiftAstRunner({ toolchain: this.toolchain });
+    this.analysisOrchestrator = new iOSAstAnalysisOrchestrator();
     this.fileContent = '';
     this.currentFilePath = '';
     this.godClassCandidates = [];
@@ -29,99 +36,6 @@ class iOSASTIntelligentAnalyzer {
     this.closures = [];
   }
 
-  resolveAuditTmpDir(repoRoot) {
-    const configured = String(env.get('AUDIT_TMP', '') || '').trim();
-    if (configured.length > 0) {
-      return path.isAbsolute(configured) ? configured : path.join(repoRoot, configured);
-    }
-    return path.join(repoRoot, '.audit_tmp');
-  }
-
-  safeTempFilePath(repoRoot, displayPath) {
-    const tmpDir = this.resolveAuditTmpDir(repoRoot);
-    const hash = crypto.createHash('sha1').update(String(displayPath)).digest('hex').slice(0, 10);
-    const base = path.basename(displayPath, '.swift');
-    const filename = `${base}.${hash}.staged.swift`;
-    return path.join(tmpDir, filename);
-  }
-
-  readStagedFileContent(repoRoot, relPath) {
-    try {
-      return execSync(`git show :"${relPath}"`, { encoding: 'utf8', cwd: repoRoot, stdio: ['ignore', 'pipe', 'pipe'] });
-    } catch (error) {
-      if (process.env.DEBUG) {
-        console.debug(`[iOSASTIntelligentAnalyzer] Failed to read staged file ${relPath}: ${error.message}`);
-      }
-      return null;
-    }
-  }
-
-  checkSourceKitten() {
-    try {
-      execSync(`${this.sourceKittenPath} version`, { stdio: 'pipe' });
-      return true;
-    } catch (error) {
-      if (process.env.DEBUG) {
-        console.debug(`[iOSASTIntelligentAnalyzer] SourceKitten not available at ${this.sourceKittenPath}: ${error.message}`);
-      }
-      return false;
-    }
-  }
-
-  checkSwiftSyntax() {
-    const projectRoot = require('child_process')
-      .execSync('git rev-parse --show-toplevel', { encoding: 'utf-8' })
-      .trim();
-
-    const possiblePaths = [
-      path.join(__dirname, '../../../../../CustomLintRules/.build/debug/swift-ast-analyzer'),
-      path.join(projectRoot, 'CustomLintRules/.build/debug/swift-ast-analyzer'),
-      path.join(projectRoot, '.build/debug/swift-ast-analyzer')
-    ];
-    for (const p of possiblePaths) {
-      if (fs.existsSync(p)) {
-        this.swiftSyntaxPath = p;
-        return true;
-      }
-    }
-    return false;
-  }
-
-  analyzeWithSwiftSyntax(filePath, displayPath = null) {
-    if (!this.swiftSyntaxPath) return;
-    try {
-      const result = execSync(`"${this.swiftSyntaxPath}" "${filePath}"`, {
-        encoding: 'utf8', timeout: 30000, stdio: ['pipe', 'pipe', 'pipe']
-      });
-      const violations = JSON.parse(result);
-      for (const v of violations) {
-        const reportedPath = displayPath || filePath;
-        this.findings.push({
-          ruleId: v.ruleId, severity: v.severity, filePath: reportedPath,
-          line: v.line, column: v.column, message: v.message
-        });
-      }
-    } catch (error) {
-      console.error('[iOSASTIntelligentAnalyzer] Error parsing file:', error.message);
-    }
-  }
-
-  parseFile(filePath) {
-    if (!this.isAvailable) return null;
-    try {
-      const result = execSync(
-        `${this.sourceKittenPath} structure --file "${filePath}"`,
-        { encoding: 'utf8', timeout: 30000, stdio: ['pipe', 'pipe', 'pipe'] }
-      );
-      return JSON.parse(result);
-    } catch (error) {
-      if (process.env.DEBUG) {
-        console.debug(`[iOSASTIntelligentAnalyzer] SourceKitten parse failed for ${filePath}: ${error.message}`);
-      }
-      return null;
-    }
-  }
-
   analyzeFile(filePath, options = {}) {
     if (!filePath || !String(filePath).endsWith('.swift')) return;
 
@@ -129,53 +43,29 @@ class iOSASTIntelligentAnalyzer {
     const displayPath = options.displayPath || filePath;
     const stagedRelPath = options.stagedRelPath || null;
     const stagingOnly = env.get('STAGING_ONLY_MODE', '0') === '1';
+    const auditTmpDir = this.toolchain.resolveAuditTmpDir(repoRoot);
+    const stagedPreparer = new StagedSwiftFilePreparer({ repoRoot, auditTmpDir });
 
-    let parsePath = filePath;
-    let contentOverride = null;
-
-    if (stagingOnly && stagedRelPath) {
-      const stagedContent = this.readStagedFileContent(repoRoot, stagedRelPath);
-      if (typeof stagedContent === 'string') {
-        const tmpPath = this.safeTempFilePath(repoRoot, stagedRelPath);
-        try {
-          fs.mkdirSync(path.dirname(tmpPath), { recursive: true });
-          fs.writeFileSync(tmpPath, stagedContent, 'utf8');
-          parsePath = tmpPath;
-          contentOverride = stagedContent;
-        } catch (error) {
-          if (process.env.DEBUG) {
-            console.debug(`[iOSASTIntelligentAnalyzer] Failed to write temp staged file ${tmpPath}: ${error.message}`);
-          }
-          // Fall back to working tree file
-        }
-      }
-    }
+    const { parsePath, contentOverride } = stagedPreparer.prepare({
+      filePath,
+      stagedRelPath,
+      stagingOnly
+    });
 
     if (this.hasSwiftSyntax) {
-      this.analyzeWithSwiftSyntax(parsePath, displayPath);
+      this.swiftRunner.runSwiftSyntax(parsePath, displayPath, this.findings);
     }
 
-    const ast = this.parseFile(parsePath);
+    const ast = this.swiftRunner.parseSourceKitten(parsePath);
     if (!ast) return;
 
-    this.currentFilePath = displayPath;
-    resetCollections(this);
-
-    try {
-      this.fileContent = typeof contentOverride === 'string'
-        ? contentOverride
-        : fs.readFileSync(parsePath, 'utf8');
-    } catch (error) {
-      if (process.env.DEBUG) {
-        console.debug(`[iOSASTIntelligentAnalyzer] Failed to read file content ${parsePath}: ${error.message}`);
-      }
-      this.fileContent = '';
-    }
-
-    const substructure = ast['key.substructure'] || [];
-
-    collectAllNodes(this, substructure, null);
-    analyzeCollectedNodes(this, displayPath);
+    this.analysisOrchestrator.run({
+      analyzer: this,
+      ast,
+      parsePath,
+      displayPath,
+      contentOverride
+    });
   }
 
   safeStringify(obj) {

package/scripts/hooks-system/infrastructure/ast/ios/analyzers/iOSAstAnalysisOrchestrator.js

@@ -0,0 +1,32 @@
+const fs = require('fs');
+const {
+    resetCollections,
+    collectAllNodes,
+    analyzeCollectedNodes,
+} = require('../detectors/ios-ast-intelligent-strategies');
+
+class iOSAstAnalysisOrchestrator {
+    run({ analyzer, ast, parsePath, displayPath, contentOverride }) {
+        if (!ast || !analyzer) return;
+
+        analyzer.currentFilePath = displayPath;
+        resetCollections(analyzer);
+
+        try {
+            analyzer.fileContent = typeof contentOverride === 'string'
+                ? contentOverride
+                : fs.readFileSync(parsePath, 'utf8');
+        } catch (error) {
+            if (process.env.DEBUG) {
+                console.debug(`[iOSAstAnalysisOrchestrator] Failed to read file content ${parsePath}: ${error.message}`);
+            }
+            analyzer.fileContent = '';
+        }
+
+        const substructure = ast['key.substructure'] || [];
+        collectAllNodes(analyzer, substructure, null);
+        analyzeCollectedNodes(analyzer, displayPath);
+    }
+}
+
+module.exports = { iOSAstAnalysisOrchestrator };