pumuki-ast-hooks 5.5.51 → 5.5.52

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