pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/domain/services/AuditScorer.js

@@ -0,0 +1,38 @@
+class AuditScorer {
+    calculateTechnicalDebt(findings) {
+        return findings.reduce((total, finding) => {
+            // Assuming finding.severity is an instance of Severity or finding has access to getDebtHours
+            // If finding.severity is a string (legacy), we might need to handle that, 
+            // but we are refactoring Finding to use Severity VO.
+            // However, if we access finding.getTechnicalDebtHours(), it delegates to Severity.
+            return total + finding.getTechnicalDebtHours();
+        }, 0);
+    }
+
+    calculateMaintainabilityIndex(findings) {
+        const baseScore = 100;
+
+        // Calculate counts directly to avoid coupling with AuditResult's aggregation methods
+        let critical = 0;
+        let high = 0;
+        let medium = 0;
+        let low = 0;
+
+        findings.forEach(f => {
+            if (f.isCritical()) critical++;
+            else if (f.isHigh()) high++;
+            else if (f.isMedium()) medium++;
+            else if (f.isLow()) low++;
+        });
+
+        const criticalPenalty = critical * 5;
+        const highPenalty = high * 2;
+        const mediumPenalty = medium * 1;
+        const lowPenalty = low * 0.5;
+
+        const score = baseScore - criticalPenalty - highPenalty - mediumPenalty - lowPenalty;
+        return Math.max(0, Math.min(100, score));
+    }
+}
+
+module.exports = AuditScorer;

package/scripts/hooks-system/domain/values/Severity.js

@@ -0,0 +1,93 @@
+const { ValidationError } = require('../errors');
+
+class Severity {
+    constructor(value) {
+        this.value = this.normalize(value);
+        if (!this.value) {
+            throw new ValidationError(`Invalid severity: ${value}`, 'severity', value);
+        }
+    }
+
+    static get LEVELS() {
+        return {
+            CRITICAL: 'critical',
+            HIGH: 'high',
+            MEDIUM: 'medium',
+            LOW: 'low',
+            INFO: 'info'
+        };
+    }
+
+    normalize(severity) {
+        if (!severity) return null;
+
+        const sev = severity.toLowerCase();
+        const map = {
+            'error': Severity.LEVELS.HIGH,
+            'warning': Severity.LEVELS.MEDIUM,
+            'critical': Severity.LEVELS.CRITICAL,
+            'high': Severity.LEVELS.HIGH,
+            'medium': Severity.LEVELS.MEDIUM,
+            'low': Severity.LEVELS.LOW,
+            'info': Severity.LEVELS.INFO
+        };
+
+        return map[sev] || null;
+    }
+
+    toString() {
+        return this.value;
+    }
+
+    toUpperCase() {
+        return this.value.toUpperCase();
+    }
+
+    isCritical() {
+        return this.value === Severity.LEVELS.CRITICAL;
+    }
+
+    isHigh() {
+        return this.value === Severity.LEVELS.HIGH;
+    }
+
+    isMedium() {
+        return this.value === Severity.LEVELS.MEDIUM;
+    }
+
+    isLow() {
+        return this.value === Severity.LEVELS.LOW;
+    }
+
+    isInfo() {
+        return this.value === Severity.LEVELS.INFO;
+    }
+
+    isBlocking() {
+        return this.isCritical() || this.isHigh();
+    }
+
+    getWeight() {
+        const weights = {
+            [Severity.LEVELS.CRITICAL]: 4,
+            [Severity.LEVELS.HIGH]: 3,
+            [Severity.LEVELS.MEDIUM]: 2,
+            [Severity.LEVELS.LOW]: 1,
+            [Severity.LEVELS.INFO]: 0
+        };
+        return weights[this.value] || 0;
+    }
+
+    getDebtHours() {
+        const hours = {
+            [Severity.LEVELS.CRITICAL]: 4,
+            [Severity.LEVELS.HIGH]: 2,
+            [Severity.LEVELS.MEDIUM]: 1,
+            [Severity.LEVELS.LOW]: 0.5,
+            [Severity.LEVELS.INFO]: 0
+        };
+        return hours[this.value] || 0;
+    }
+}
+
+module.exports = Severity;

package/scripts/hooks-system/index.js

@@ -0,0 +1,49 @@
+/**
+ * @pumuki/ast-intelligence-hooks
+ *
+ * Enterprise-grade AST Intelligence System
+ * Multi-platform support: iOS, Android, Backend, Frontend
+ * Architecture enforcement: Feature-First + DDD + Clean Architecture
+ *
+ * @version 3.1.0
+ * @license MIT
+ */
+
+const { runASTIntelligence } = require('./infrastructure/ast/ast-intelligence');
+const { Finding } = require('./domain/entities/Finding');
+const { AuditResult } = require('./domain/entities/AuditResult');
+const { CommitBlockingRules } = require('./domain/rules/CommitBlockingRules');
+
+const { AnalyzeCodebaseUseCase } = require('./application/use-cases/AnalyzeCodebaseUseCase');
+const { AnalyzeStagedFilesUseCase } = require('./application/use-cases/AnalyzeStagedFilesUseCase');
+const { GenerateAuditReportUseCase } = require('./application/use-cases/GenerateAuditReportUseCase');
+const { BlockCommitUseCase } = require('./application/use-cases/BlockCommitUseCase');
+
+const { runBackendIntelligence } = require('./infrastructure/ast/backend/ast-backend');
+const { runFrontendIntelligence } = require('./infrastructure/ast/frontend/ast-frontend');
+const { runIOSIntelligence } = require('./infrastructure/ast/ios/ast-ios');
+const { runAndroidIntelligence } = require('./infrastructure/ast/android/ast-android');
+const { runCommonIntelligence } = require('./infrastructure/ast/common/ast-common');
+
+module.exports = {
+  runASTIntelligence,
+
+  Finding,
+  AuditResult,
+  CommitBlockingRules,
+
+  AnalyzeCodebaseUseCase,
+  AnalyzeStagedFilesUseCase,
+  GenerateAuditReportUseCase,
+  BlockCommitUseCase,
+
+  runBackendIntelligence,
+  runFrontendIntelligence,
+  runIOSIntelligence,
+  runAndroidIntelligence,
+  runCommonIntelligence,
+
+  version: '3.1.0',
+  platforms: ['ios', 'android', 'backend', 'frontend'],
+  totalRules: 798
+};

package/scripts/hooks-system/infrastructure/adapters/AstAnalyzerAdapter.js

@@ -0,0 +1,150 @@
+/**
+ * AstAnalyzerAdapter
+ *
+ * Infrastructure adapter implementing IAstPort.
+ * Wraps the existing AST intelligence modules.
+ */
+const path = require('path');
+const fs = require('fs');
+
+class AstAnalyzerAdapter {
+    constructor(config = {}) {
+        this.repoRoot = config.repoRoot || process.cwd();
+        this.astModulesPath = config.astModulesPath || path.join(__dirname, '../ast');
+
+        this.ignoredPatterns = [
+            'node_modules/',
+            '/.next/',
+            '/dist/',
+            '/.turbo/',
+            '/.vercel/',
+            '/coverage/',
+            '/build/',
+            '/out/',
+            '.d.ts',
+            '.map',
+            '.min.'
+        ];
+
+        this.platformExtensions = {
+            backend: ['.ts', '.js', '.mjs', '.cjs'],
+            frontend: ['.tsx', '.jsx'],
+            ios: ['.swift'],
+            android: ['.kt', '.java']
+        };
+    }
+
+    analyzeFile(filePath, platform) {
+        if (this.shouldIgnoreFile(filePath)) {
+            return [];
+        }
+
+        const findings = [];
+        try {
+            const astCore = require(path.join(this.astModulesPath, 'ast-core'));
+            const project = astCore.createProject([filePath]);
+
+            switch (platform) {
+                case 'backend':
+                    const { runBackendIntelligence } = require(path.join(this.astModulesPath, 'backend/ast-backend'));
+                    runBackendIntelligence(project, findings);
+                    break;
+                case 'frontend':
+                    const { runFrontendIntelligence } = require(path.join(this.astModulesPath, 'frontend/ast-frontend'));
+                    runFrontendIntelligence(project, findings);
+                    break;
+                case 'ios':
+                    const { runIOSIntelligence } = require(path.join(this.astModulesPath, 'ios/ast-ios'));
+                    runIOSIntelligence(project, findings);
+                    break;
+                case 'android':
+                    const { runAndroidIntelligence } = require(path.join(this.astModulesPath, 'android/ast-android'));
+                    runAndroidIntelligence(project, findings);
+                    break;
+            }
+
+            const { runCommonIntelligence } = require(path.join(this.astModulesPath, 'common/ast-common'));
+            runCommonIntelligence(project, findings);
+
+        } catch (error) {
+            console.error(`[AstAnalyzerAdapter] Error analyzing ${filePath}:`, error.message);
+        }
+
+        return findings.filter(f => f.filePath === filePath || f.filePath.includes(filePath));
+    }
+
+    analyzeFiles(filePaths, platform) {
+        const allFindings = [];
+        for (const filePath of filePaths) {
+            const findings = this.analyzeFile(filePath, platform);
+            allFindings.push(...findings);
+        }
+        return allFindings;
+    }
+
+    getRulesForPlatform(platform) {
+        const rulesPath = path.join(this.astModulesPath, `${platform}/ast-${platform}.js`);
+        if (!fs.existsSync(rulesPath)) {
+            return [];
+        }
+        return [];
+    }
+
+    shouldIgnoreFile(filePath) {
+        const normalized = filePath.replace(/\\/g, '/');
+        return this.ignoredPatterns.some(pattern => normalized.includes(pattern));
+    }
+
+    getBlockingFindings(findings) {
+        return findings.filter(f =>
+            f.severity === 'error' ||
+            f.severity === 'HIGH' ||
+            f.severity === 'CRITICAL' ||
+            (f.ruleId && f.ruleId.includes('security.')) ||
+            (f.ruleId && f.ruleId.includes('architecture.'))
+        );
+    }
+
+    formatFindings(findings) {
+        if (!findings || findings.length === 0) {
+            return 'No findings detected.';
+        }
+
+        const lines = [];
+        const grouped = {};
+
+        findings.forEach(f => {
+            const key = f.ruleId || 'unknown';
+            if (!grouped[key]) {
+                grouped[key] = [];
+            }
+            grouped[key].push(f);
+        });
+
+        Object.entries(grouped)
+            .sort((a, b) => b[1].length - a[1].length)
+            .forEach(([ruleId, items]) => {
+                const severity = items[0].severity || 'info';
+                const emoji = severity === 'error' || severity === 'HIGH' ? '🔴' :
+                    severity === 'warning' || severity === 'MEDIUM' ? '🟡' : '🔵';
+                lines.push(`${emoji} ${ruleId}: ${items.length} occurrence(s)`);
+            });
+
+        lines.push('');
+        lines.push(`Total: ${findings.length} finding(s)`);
+
+        return lines.join('\n');
+    }
+
+    detectPlatform(filePath) {
+        const ext = path.extname(filePath);
+        for (const [platform, extensions] of Object.entries(this.platformExtensions)) {
+            if (extensions.includes(ext)) {
+                return platform;
+            }
+        }
+        return 'backend';
+    }
+}
+
+module.exports = AstAnalyzerAdapter;

package/scripts/hooks-system/infrastructure/adapters/FileEvidenceAdapter.js

@@ -0,0 +1,140 @@
+/**
+ * FileEvidenceAdapter
+ *
+ * Infrastructure adapter implementing IEvidencePort using file system.
+ */
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { 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')
+    ];
+
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+
+    return null;
+}
+
+class FileEvidenceAdapter {
+    constructor(config = {}) {
+        this.repoRoot = config.repoRoot || process.cwd();
+        this.evidencePath = config.evidencePath || path.join(this.repoRoot, '.AI_EVIDENCE.json');
+        this.updateScriptPath = config.updateScriptPath || resolveUpdateEvidenceScript(this.repoRoot);
+        this.staleThreshold = config.staleThreshold || 180;
+    }
+
+    read() {
+        try {
+            if (!this.exists()) {
+                return null;
+            }
+            const content = fs.readFileSync(this.evidencePath, 'utf-8');
+            return JSON.parse(content);
+        } catch (error) {
+            console.error('[FileEvidenceAdapter] Error reading evidence:', error.message);
+            return null;
+        }
+    }
+
+    write(evidence) {
+        try {
+            const content = JSON.stringify(evidence, null, 2);
+            fs.writeFileSync(this.evidencePath, content, 'utf-8');
+            return true;
+        } catch (error) {
+            console.error('[FileEvidenceAdapter] Error writing evidence:', error.message);
+            return false;
+        }
+    }
+
+    exists() {
+        return fs.existsSync(this.evidencePath);
+    }
+
+    getAgeSeconds() {
+        try {
+            if (!this.exists()) {
+                return Infinity;
+            }
+            const stats = fs.statSync(this.evidencePath);
+            const now = Date.now();
+            const mtime = stats.mtime.getTime();
+            return Math.floor((now - mtime) / 1000);
+        } catch (error) {
+            console.error('[FileEvidenceAdapter] Error getting age:', error.message);
+            return Infinity;
+        }
+    }
+
+    isStale(thresholdSeconds = this.staleThreshold) {
+        return this.getAgeSeconds() > thresholdSeconds;
+    }
+
+    refresh(options = {}) {
+        try {
+            const platforms = options.platforms || 'backend';
+            const mode = options.mode || '--auto';
+
+            if (!this.updateScriptPath || !fs.existsSync(this.updateScriptPath)) {
+                throw new ConfigurationError('update-evidence.sh not found', 'updateScriptPath');
+            }
+
+            execSync(`bash "${this.updateScriptPath}" ${mode} --platforms ${platforms}`, {
+                cwd: this.repoRoot,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+
+            return true;
+        } catch (error) {
+            console.error('[FileEvidenceAdapter] Error refreshing evidence:', error.message);
+            return false;
+        }
+    }
+
+    getSession() {
+        const evidence = this.read();
+        return evidence?.session || null;
+    }
+
+    getPlatforms() {
+        const evidence = this.read();
+        if (!evidence?.platforms_detected) {
+            return [];
+        }
+        return Object.keys(evidence.platforms_detected).filter(
+            p => evidence.platforms_detected[p] === true
+        );
+    }
+
+    getModifiedFiles() {
+        const evidence = this.read();
+        return evidence?.files_modified || [];
+    }
+
+    getTimestamp() {
+        const evidence = this.read();
+        return evidence?.timestamp || null;
+    }
+
+    getRulesRead() {
+        const evidence = this.read();
+        return evidence?.rules_read || {};
+    }
+
+    getAstSummary() {
+        const evidence = this.read();
+        return evidence?.ast_summary || null;
+    }
+}
+
+module.exports = FileEvidenceAdapter;

package/scripts/hooks-system/infrastructure/adapters/GitCliAdapter.js

@@ -0,0 +1,16 @@
+const GitCommandRunner = require('./git/GitCommandRunner');
+
+class GitCliAdapter {
+    constructor(config = {}) {
+        this.repoRoot = config.repoRoot || process.cwd();
+        this.logger = config.logger || console;
+        this.protectedBranches = config.protectedBranches || ['main', 'master', 'develop'];
+        this.runner = new GitCommandRunner(this.repoRoot, this.logger);
+    }
+
+    exec(command, options = {}) {
+        return this.runner.exec(command, options);
+    }
+}
+
+module.exports = GitCliAdapter;

package/scripts/hooks-system/infrastructure/adapters/GitCommandAdapter.js

@@ -0,0 +1,68 @@
+const IGitCommandPort = require('../../domain/ports/IGitCommandPort');
+const GitCommandRunner = require('./git/GitCommandRunner');
+const GitCommandService = require('./git/GitCommandService');
+
+class GitCommandAdapter extends IGitCommandPort {
+    constructor(config = {}) {
+        super();
+        this.repoRoot = config.repoRoot || process.cwd();
+        this.logger = config.logger || console;
+
+        this.runner = new GitCommandRunner(this.repoRoot, this.logger);
+        this.commandService = new GitCommandService(this.runner);
+    }
+
+    createBranch(branchName) {
+        return this.commandService.createBranch(branchName);
+    }
+
+    checkout(branchName) {
+        return this.commandService.checkout(branchName);
+    }
+
+    stageFiles(files) {
+        return this.commandService.stageFiles(files);
+    }
+
+    stageAll() {
+        return this.commandService.stageAll();
+    }
+
+    commit(message) {
+        return this.commandService.commit(message);
+    }
+
+    push(remote = 'origin', branch = null) {
+        return this.commandService.push(remote, branch);
+    }
+
+    pushWithUpstream(remote = 'origin', branch) {
+        return this.commandService.pushWithUpstream(remote, branch);
+    }
+
+    fetchRemote(remote = 'origin') {
+        return this.commandService.fetchRemote(remote);
+    }
+
+    pull(remote = 'origin', branch = null) {
+        return this.commandService.pull(remote, branch);
+    }
+
+    stash(message = 'WIP') {
+        return this.commandService.stash(message);
+    }
+
+    stashPop() {
+        return this.commandService.stashPop();
+    }
+
+    fetchRemote(remote = 'origin') {
+        return this.commandService.fetchRemote(remote);
+    }
+
+    pull(remote = 'origin', branch = null) {
+        return this.commandService.pull(remote, branch);
+    }
+}
+
+module.exports = GitCommandAdapter;

package/scripts/hooks-system/infrastructure/adapters/GitHubCliAdapter.js

@@ -0,0 +1,85 @@
+const { execSync } = require('child_process');
+
+class GitHubCliAdapter {
+    constructor(repoRoot, logger = console, options = {}) {
+        this.repoRoot = repoRoot;
+        this.logger = logger;
+        this.options = {
+            timeout: options.timeout || 30000,
+            maxRetries: options.maxRetries || 3,
+            retryDelay: options.retryDelay || 1000
+        };
+    }
+
+    createPullRequest(base, head, title, body) {
+        const command = `gh pr create --base ${base} --head ${head} --title "${title}" --body "${body}"`;
+        const output = this._execWithRetry(command);
+
+        if (!output) return null;
+
+        const urlMatch = output.match(/https:\/\/github\.com\/.*\/pull\/\d+/);
+        return urlMatch ? urlMatch[0] : null;
+    }
+
+    mergePullRequest(prUrl) {
+        const prNumber = prUrl.split('/').pop();
+        const command = `gh pr merge ${prNumber} --merge`;
+        return this._execWithRetry(command) !== null;
+    }
+
+    isAvailable() {
+        return this._execWithRetry('gh auth status', { retries: 0 }) !== null; // Don't retry auth check too much
+    }
+
+    _execWithRetry(command, options = {}) {
+        const timeout = this.options.timeout;
+        const maxRetries = options.retries !== undefined ? options.retries : this.options.maxRetries;
+        let attempt = 0;
+
+        while (attempt <= maxRetries) {
+            try {
+                if (this.logger.debug) {
+                    this.logger.debug('GH_EXEC', { command, attempt: attempt + 1 });
+                }
+
+                return execSync(command, {
+                    cwd: this.repoRoot,
+                    encoding: 'utf-8',
+                    timeout: timeout,
+                    stdio: ['pipe', 'pipe', 'pipe']
+                }).trim();
+            } catch (error) {
+                if (this.logger.warn) {
+                    this.logger.warn('GH_EXEC_FAILED', { command, error: error.message, attempt: attempt + 1 });
+                }
+
+                // If it's a logic error (e.g. branch not found, auth failed), don't retry?
+                // For now, simple retry for network flakes.
+                // gh often returns exit code 1 for logic errors.
+                // We might want to stop if it says "unknown command" or "not logged in".
+                if (this._isFatalError(error.message)) {
+                    break;
+                }
+
+                if (attempt >= maxRetries) break;
+
+                this._sleep(this.options.retryDelay * Math.pow(2, attempt));
+                attempt++;
+            }
+        }
+        return null;
+    }
+
+    _isFatalError(message) {
+        return message.includes('not logged in') ||
+            message.includes('unknown command') ||
+            message.includes('pull request already exists');
+    }
+
+    _sleep(ms) {
+        const start = Date.now();
+        while (Date.now() - start < ms) { }
+    }
+}
+
+module.exports = GitHubCliAdapter;

package/scripts/hooks-system/infrastructure/adapters/GitQueryAdapter.js

@@ -0,0 +1,58 @@
+const IGitQueryPort = require('../../domain/ports/IGitQueryPort');
+const GitCommandRunner = require('./git/GitCommandRunner');
+const GitQueryService = require('./git/GitQueryService');
+
+class GitQueryAdapter extends IGitQueryPort {
+    constructor(config = {}) {
+        super();
+        this.repoRoot = config.repoRoot || process.cwd();
+        this.logger = config.logger || console;
+        this.protectedBranches = config.protectedBranches || ['main', 'master', 'develop'];
+
+        this.runner = new GitCommandRunner(this.repoRoot, this.logger);
+        this.queryService = new GitQueryService(this.runner);
+    }
+
+    getCurrentBranch() {
+        return this.queryService.getCurrentBranch();
+    }
+
+    isProtectedBranch() {
+        const current = this.getCurrentBranch();
+        return this.protectedBranches.includes(current);
+    }
+
+    getUncommittedChanges() {
+        return this.queryService.getUncommittedChanges();
+    }
+
+    getStagedFiles() {
+        return this.queryService.getStagedFiles();
+    }
+
+    hasUncommittedChanges() {
+        return this.queryService.hasUncommittedChanges();
+    }
+
+    hasStagedChanges() {
+        return this.queryService.hasStagedChanges();
+    }
+
+    getRecentCommits(count = 5) {
+        return this.queryService.getRecentCommits(count);
+    }
+
+    getDiff(cached = false) {
+        return this.queryService.getDiff(cached);
+    }
+
+    getStatusShort() {
+        return this.queryService.getStatusShort();
+    }
+
+    getLog(count = 10) {
+        return this.queryService.getLog(count);
+    }
+}
+
+module.exports = GitQueryAdapter;