pumuki-ast-hooks 5.5.51 → 5.5.53

package/README.md

@@ -866,6 +866,15 @@ Automates the complete Git Flow cycle: commit → push → PR → merge, plus co
 
 For more details, see [MCP_SERVERS.md](./docs/MCP_SERVERS.md).
 
+#### Troubleshooting
+
+If `ai_gate_check` behaves inconsistently (stale branch name, missing rules, or intermittent transport errors), verify you are not running multiple `ast-intelligence-automation` servers across different repositories.
+
+- Prefer enabling a single MCP server for the repository you are working on.
+- Verify the active process points to this repository path:
+  - `.../ast-intelligence-hooks/scripts/hooks-system/infrastructure/mcp/ast-intelligence-automation.js`
+- If you detect multiple processes, stop the duplicates and restart your IDE/MCP servers.
+
 ---
 
 ## API Reference

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki-ast-hooks",
-  "version": "5.5.51",
+  "version": "5.5.53",
   "description": "Enterprise-grade AST Intelligence System with multi-platform support (iOS, Android, Backend, Frontend) and Feature-First + DDD + Clean Architecture enforcement. Includes dynamic violations API for intelligent querying.",
   "main": "index.js",
   "bin": {

package/scripts/hooks-system/.audit_tmp/hook-metrics.jsonl

@@ -158,3 +158,11 @@
 {"timestamp":1767782291627,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
 {"timestamp":1767782291627,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
 {"timestamp":1767782291627,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767784424360,"hook":"audit_logger","operation":"constructor","status":"started","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767784424360,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
+{"timestamp":1767784424360,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
+{"timestamp":1767784424360,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767784524038,"hook":"audit_logger","operation":"constructor","status":"started","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}
+{"timestamp":1767784524038,"hook":"audit_logger","operation":"ensure_dir","status":"started"}
+{"timestamp":1767784524038,"hook":"audit_logger","operation":"ensure_dir","status":"success"}
+{"timestamp":1767784524038,"hook":"audit_logger","operation":"constructor","status":"success","repoRoot":"/Users/juancarlosmerlosalbarracin/Developer/Projects/ast-intelligence-hooks/scripts/hooks-system"}

package/scripts/hooks-system/application/services/AutonomousOrchestrator.js

@@ -31,10 +31,47 @@ class AutonomousOrchestrator {
         }
     }
 
+    detectFromBranchKeywords(branchName) {
+        try {
+            const PlatformHeuristics = require('./platform/PlatformHeuristics');
+            const heuristics = new PlatformHeuristics(this.platformDetector);
+            return heuristics.detectFromBranchKeywords(branchName);
+        } catch (error) {
+            const msg = error && error.message ? error.message : String(error);
+            this.logger?.debug?.('ORCHESTRATOR_BRANCH_KEYWORDS_DETECTION_ERROR', { error: msg });
+            return [];
+        }
+    }
+
+    detectFromEvidenceFile() {
+        try {
+            const PlatformHeuristics = require('./platform/PlatformHeuristics');
+            const heuristics = new PlatformHeuristics(this.platformDetector);
+            return heuristics.detectFromEvidenceFile();
+        } catch (error) {
+            const msg = error && error.message ? error.message : String(error);
+            this.logger?.debug?.('ORCHESTRATOR_EVIDENCE_FILE_DETECTION_ERROR', { error: msg });
+            return [];
+        }
+    }
+
     detectFromASTSystemFilesLegacy(files) {
         return this.detectFromASTSystemFiles(files);
     }
 
+    async scoreConfidence(platforms) {
+        try {
+            const PlatformAnalysisService = require('./PlatformAnalysisService');
+            const analysisService = new PlatformAnalysisService(this.platformDetector);
+            const context = await this.contextEngine.detectContext();
+            return analysisService.analyzeConfidence(platforms || [], context || {});
+        } catch (error) {
+            const msg = error && error.message ? error.message : String(error);
+            this.logger?.debug?.('ORCHESTRATOR_SCORE_CONFIDENCE_ERROR', { error: msg });
+            return [];
+        }
+    }
+
     async analyzeContext() {
         const platforms = await this.detectActivePlatforms();
         const scores = await this.scoreConfidence(platforms);

package/scripts/hooks-system/application/services/monitoring/EvidenceMonitor.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
-const { EvidenceRefreshRunner } = require('./EvidenceRefreshRunner');
+const { execSync } = require('child_process');
+const { ConfigurationError, DomainError } = require('../../../domain/errors');
 const AuditLogger = require('../logging/AuditLogger');
 
 class EvidenceMonitor {
@@ -13,9 +14,98 @@ class EvidenceMonitor {
         this.lastStaleNotification = 0;
         this.pollTimer = null;
         this.evidencePath = path.join(repoRoot, '.AI_EVIDENCE.json');
-        this.refreshRunner = new EvidenceRefreshRunner(repoRoot, {
-            refreshTimeoutMs: options.refreshTimeoutMs
-        });
+        this.tempDir = path.join(repoRoot, '.audit_tmp');
+        this.updateScript = this.resolveUpdateEvidenceScript();
+        this.refreshInFlight = false;
+        this.refreshTimeoutMs = options.refreshTimeoutMs || 120000;
+        this.refreshLockFile = path.join(this.tempDir, 'evidence-refresh.lock');
+    }
+
+    isPidRunning(pid) {
+        if (!pid || !Number.isFinite(pid) || pid <= 0) return false;
+        try {
+            process.kill(pid, 0);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    acquireRefreshLock() {
+        try {
+            fs.mkdirSync(this.tempDir, { recursive: true });
+        } catch (error) {
+            console.warn('[EvidenceMonitor] Failed to ensure temp dir:', error.message);
+        }
+
+        try {
+            const fd = fs.openSync(this.refreshLockFile, 'wx');
+            const payload = JSON.stringify({ pid: process.pid, timestamp: new Date().toISOString() });
+            fs.writeFileSync(fd, payload, { encoding: 'utf8' });
+            fs.closeSync(fd);
+            return { acquired: true };
+        } catch (error) {
+            if (error && error.code !== 'EEXIST') {
+                return { acquired: false, reason: 'error', error };
+            }
+
+            try {
+                const raw = String(fs.readFileSync(this.refreshLockFile, 'utf8') || '').trim();
+                const data = raw ? JSON.parse(raw) : null;
+                const lockPid = data && Number(data.pid);
+                if (lockPid && this.isPidRunning(lockPid)) {
+                    return { acquired: false, reason: 'locked', pid: lockPid };
+                }
+            } catch (error) {
+                console.warn('[EvidenceMonitor] Failed to read refresh lock file:', error.message);
+            }
+
+            try {
+                fs.unlinkSync(this.refreshLockFile);
+            } catch (error) {
+                console.warn('[EvidenceMonitor] Failed to remove stale refresh lock:', error.message);
+            }
+
+            try {
+                const fd = fs.openSync(this.refreshLockFile, 'wx');
+                const payload = JSON.stringify({ pid: process.pid, timestamp: new Date().toISOString() });
+                fs.writeFileSync(fd, payload, { encoding: 'utf8' });
+                fs.closeSync(fd);
+                return { acquired: true };
+            } catch (retryError) {
+                return { acquired: false, reason: 'locked', error: retryError };
+            }
+        }
+    }
+
+    releaseRefreshLock() {
+        try {
+            if (!fs.existsSync(this.refreshLockFile)) return;
+            const raw = String(fs.readFileSync(this.refreshLockFile, 'utf8') || '').trim();
+            const data = raw ? JSON.parse(raw) : null;
+            const lockPid = data && Number(data.pid);
+            if (lockPid === process.pid) {
+                fs.unlinkSync(this.refreshLockFile);
+            }
+        } catch (error) {
+            console.warn('[EvidenceMonitor] Failed to release refresh lock:', error.message);
+        }
+    }
+
+    resolveUpdateEvidenceScript() {
+        const candidates = [
+            path.join(this.repoRoot, 'node_modules/@pumuki/ast-intelligence-hooks/bin/update-evidence.sh'),
+            path.join(this.repoRoot, 'scripts/hooks-system/bin/update-evidence.sh'),
+            path.join(this.repoRoot, 'bin/update-evidence.sh')
+        ];
+
+        for (const candidate of candidates) {
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+
+        return null;
     }
 
     isStale() {
@@ -33,7 +123,58 @@ class EvidenceMonitor {
     }
 
     async refresh() {
-        return this.refreshRunner.refresh();
+        if (!this.updateScript) {
+            throw new ConfigurationError('Update evidence script not found', 'updateScript');
+        }
+
+        if (this.refreshInFlight) {
+            return '';
+        }
+
+        const lock = this.acquireRefreshLock();
+        if (!lock.acquired) {
+            return '';
+        }
+
+        this.refreshInFlight = true;
+
+        return new Promise((resolve, reject) => {
+            const child = require('child_process').spawn('bash', [this.updateScript, '--auto', '--refresh-only'], {
+                cwd: this.repoRoot,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+
+            let output = '';
+            child.stdout.on('data', (data) => {
+                output += data.toString();
+            });
+
+            const timeoutId = setTimeout(() => {
+                try {
+                    child.kill('SIGKILL');
+                } catch (error) {
+                    console.warn('[EvidenceMonitor] Failed to kill timed-out refresh process:', error.message);
+                }
+            }, this.refreshTimeoutMs);
+
+            child.on('close', (code) => {
+                clearTimeout(timeoutId);
+                this.refreshInFlight = false;
+                this.releaseRefreshLock();
+                if (code === 0) {
+                    resolve(output);
+                } else {
+                    reject(new DomainError(`Evidence refresh failed with code ${code}`, 'EVIDENCE_REFRESH_FAILED'));
+                }
+            });
+
+            child.on('error', (err) => {
+                clearTimeout(timeoutId);
+                this.refreshInFlight = false;
+                this.releaseRefreshLock();
+                reject(err);
+            });
+        });
     }
 
     startPolling(onStale, onRefreshed) {

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

@@ -1,6 +1,7 @@
 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,
@@ -8,21 +9,13 @@ 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.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.sourceKittenPath = '/opt/homebrew/bin/sourcekitten';
+    this.isAvailable = this.checkSourceKitten();
+    this.hasSwiftSyntax = this.checkSwiftSyntax();
     this.fileContent = '';
     this.currentFilePath = '';
     this.godClassCandidates = [];
@@ -36,6 +29,99 @@ 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;
 
@@ -43,29 +129,53 @@ 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 });
 
-    const { parsePath, contentOverride } = stagedPreparer.prepare({
-      filePath,
-      stagedRelPath,
-      stagingOnly
-    });
+    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
+        }
+      }
+    }
 
     if (this.hasSwiftSyntax) {
-      this.swiftRunner.runSwiftSyntax(parsePath, displayPath, this.findings);
+      this.analyzeWithSwiftSyntax(parsePath, displayPath);
     }
 
-    const ast = this.swiftRunner.parseSourceKitten(parsePath);
+    const ast = this.parseFile(parsePath);
     if (!ast) return;
 
-    this.analysisOrchestrator.run({
-      analyzer: this,
-      ast,
-      parsePath,
-      displayPath,
-      contentOverride
-    });
+    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);
   }
 
   safeStringify(obj) {

package/scripts/hooks-system/application/services/monitoring/EvidenceRefreshRunner.js

@@ -1,161 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { spawn } = require('child_process');
-const { ConfigurationError, DomainError } = require('../../../domain/errors');
-
-class EvidenceRefreshRunner {
-    constructor(repoRoot, options = {}) {
-        this.repoRoot = repoRoot;
-        this.tempDir = path.join(repoRoot, '.audit_tmp');
-        this.refreshLockFile = path.join(this.tempDir, 'evidence-refresh.lock');
-        this.refreshTimeoutMs = options.refreshTimeoutMs || 120000;
-        this.refreshInFlight = false;
-        this.updateScript = this.resolveUpdateEvidenceScript();
-    }
-
-    resolveUpdateEvidenceScript() {
-        const candidates = [
-            path.join(this.repoRoot, 'node_modules/@pumuki/ast-intelligence-hooks/bin/update-evidence.sh'),
-            path.join(this.repoRoot, 'scripts/hooks-system/bin/update-evidence.sh'),
-            path.join(this.repoRoot, 'bin/update-evidence.sh')
-        ];
-
-        for (const candidate of candidates) {
-            if (fs.existsSync(candidate)) {
-                return candidate;
-            }
-        }
-
-        return null;
-    }
-
-    isPidRunning(pid) {
-        if (!pid || !Number.isFinite(pid) || pid <= 0) return false;
-        try {
-            process.kill(pid, 0);
-            return true;
-        } catch {
-            return false;
-        }
-    }
-
-    acquireRefreshLock() {
-        try {
-            fs.mkdirSync(this.tempDir, { recursive: true });
-        } catch (error) {
-            console.warn('[EvidenceRefreshRunner] Failed to ensure temp dir:', error.message);
-        }
-
-        try {
-            const fd = fs.openSync(this.refreshLockFile, 'wx');
-            const payload = JSON.stringify({ pid: process.pid, timestamp: new Date().toISOString() });
-            fs.writeFileSync(fd, payload, { encoding: 'utf8' });
-            fs.closeSync(fd);
-            return { acquired: true };
-        } catch (error) {
-            if (error && error.code !== 'EEXIST') {
-                return { acquired: false, reason: 'error', error };
-            }
-
-            try {
-                const raw = String(fs.readFileSync(this.refreshLockFile, 'utf8') || '').trim();
-                const data = raw ? JSON.parse(raw) : null;
-                const lockPid = data && Number(data.pid);
-                if (lockPid && this.isPidRunning(lockPid)) {
-                    return { acquired: false, reason: 'locked', pid: lockPid };
-                }
-            } catch (readError) {
-                console.warn('[EvidenceRefreshRunner] Failed to read refresh lock file:', readError.message);
-            }
-
-            try {
-                fs.unlinkSync(this.refreshLockFile);
-            } catch (removeError) {
-                console.warn('[EvidenceRefreshRunner] Failed to remove stale refresh lock:', removeError.message);
-            }
-
-            try {
-                const fd = fs.openSync(this.refreshLockFile, 'wx');
-                const payload = JSON.stringify({ pid: process.pid, timestamp: new Date().toISOString() });
-                fs.writeFileSync(fd, payload, { encoding: 'utf8' });
-                fs.closeSync(fd);
-                return { acquired: true };
-            } catch (retryError) {
-                return { acquired: false, reason: 'locked', error: retryError };
-            }
-        }
-    }
-
-    releaseRefreshLock() {
-        try {
-            if (!fs.existsSync(this.refreshLockFile)) return;
-            const raw = String(fs.readFileSync(this.refreshLockFile, 'utf8') || '').trim();
-            const data = raw ? JSON.parse(raw) : null;
-            const lockPid = data && Number(data.pid);
-            if (lockPid === process.pid) {
-                fs.unlinkSync(this.refreshLockFile);
-            }
-        } catch (error) {
-            console.warn('[EvidenceRefreshRunner] Failed to release refresh lock:', error.message);
-        }
-    }
-
-    async refresh() {
-        if (!this.updateScript) {
-            throw new ConfigurationError('Update evidence script not found', 'updateScript');
-        }
-
-        if (this.refreshInFlight) {
-            return '';
-        }
-
-        const lock = this.acquireRefreshLock();
-        if (!lock.acquired) {
-            return '';
-        }
-
-        this.refreshInFlight = true;
-
-        return new Promise((resolve, reject) => {
-            const child = spawn('bash', [this.updateScript, '--auto', '--refresh-only'], {
-                cwd: this.repoRoot,
-                stdio: ['pipe', 'pipe', 'pipe']
-            });
-
-            let output = '';
-            child.stdout.on('data', (data) => {
-                output += data.toString();
-            });
-
-            const timeoutId = setTimeout(() => {
-                try {
-                    child.kill('SIGKILL');
-                } catch (error) {
-                    console.warn('[EvidenceRefreshRunner] Failed to kill timed-out refresh process:', error.message);
-                }
-            }, this.refreshTimeoutMs);
-
-            const finalize = () => {
-                clearTimeout(timeoutId);
-                this.refreshInFlight = false;
-                this.releaseRefreshLock();
-            };
-
-            child.on('close', (code) => {
-                finalize();
-                if (code === 0) {
-                    resolve(output);
-                } else {
-                    reject(new DomainError(`Evidence refresh failed with code ${code}`, 'EVIDENCE_REFRESH_FAILED'));
-                }
-            });
-
-            child.on('error', (err) => {
-                finalize();
-                reject(err);
-            });
-        });
-    }
-}
-
-module.exports = { EvidenceRefreshRunner };

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

@@ -1,59 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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/iOSAstAnalysisOrchestrator.js

@@ -1,32 +0,0 @@
-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 };