pumuki-ast-hooks 5.5.50 → 5.5.51

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 };