pumuki-ast-hooks 5.3.1

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

@@ -0,0 +1,181 @@
+const crypto = require('crypto');
+
+class ContextDetectionEngine {
+    constructor(repoRootOrGitPort = null, logger = console) {
+        if (typeof repoRootOrGitPort === 'string') {
+            this.repoRoot = repoRootOrGitPort;
+            this.git = null;
+        } else {
+            this.git = repoRootOrGitPort;
+            this.repoRoot = repoRootOrGitPort?.repoRoot;
+        }
+
+        this.logger = logger;
+        this.cache = {
+            context: null,
+            timestamp: 0,
+            ttl: 10000
+        };
+    }
+
+    async detectContext() {
+        if (this.isCacheValid()) {
+            return this.cache.context;
+        }
+
+        const context = {
+            stagedFiles: this.getStagedFiles(),
+            stagedSignature: this.getStagedSignature(),
+            recentFiles: this.getRecentlyModifiedFiles(),
+            recentCommits: this.getRecentCommitPatterns(),
+            branchName: this.getCurrentBranch(),
+            openFiles: this.inferFromGitStatus(),
+            timestamp: Date.now()
+        };
+
+        this.logger.info('Context detected', {
+            branch: context.branchName,
+            stagedCount: context.stagedFiles.length,
+            recentCount: context.recentFiles.length
+        });
+
+        this.cache = {
+            context,
+            timestamp: Date.now(),
+            ttl: this.cache.ttl
+        };
+
+        return context;
+    }
+
+    isCacheValid() {
+        const age = Date.now() - this.cache.timestamp;
+        return this.cache.context && age < this.cache.ttl;
+    }
+
+    getStagedFiles() {
+        try {
+            return this.git.getStagedFiles();
+        } catch (error) {
+            this.logger.error('ContextDetectionEngine: Failed to get staged files', error);
+            return [];
+        }
+    }
+
+    getStagedSignature() {
+        try {
+            const patch = this.git.getDiff(true);
+            if (!patch) return '';
+            return crypto.createHash('sha1').update(patch).digest('hex');
+        } catch (error) {
+            return '';
+        }
+    }
+
+    getRecentlyModifiedFiles() {
+        try {
+            const output = this.git.getStatusShort();
+            if (!output) return [];
+
+            return output
+                .split('\n')
+                .filter(Boolean)
+                .map(line => line.trim().substring(2)) // Remove status code
+                .filter(file => !file.startsWith('.git'));
+        } catch (error) {
+            return [];
+        }
+    }
+
+    getRecentCommitPatterns() {
+        try {
+            const output = this.git.getLog(10);
+            if (!output) return [];
+
+            const commits = [];
+            const lines = output.split('\n');
+            let currentCommit = null;
+
+            for (const line of lines) {
+                if (line.includes('|')) {
+                    if (currentCommit) {
+                        commits.push(currentCommit);
+                    }
+                    const [hash, message] = line.split('|');
+                    currentCommit = {
+                        hash: hash.trim(),
+                        message: message.trim(),
+                        files: []
+                    };
+                } else if (line.trim() && currentCommit) {
+                    currentCommit.files.push(line.trim());
+                }
+            }
+
+            if (currentCommit) {
+                commits.push(currentCommit);
+            }
+
+            return commits.slice(0, 10);
+        } catch (error) {
+            return [];
+        }
+    }
+
+    getCurrentBranch() {
+        try {
+            return this.git.getCurrentBranch();
+        } catch (error) {
+            return 'unknown';
+        }
+    }
+
+    inferFromGitStatus() {
+        const staged = this.getStagedFiles();
+        const modified = this.getRecentlyModifiedFiles();
+
+        return [...new Set([...staged, ...modified])];
+    }
+
+    parseBranchContext() {
+        const branch = this.getCurrentBranch();
+
+        const platformPatterns = {
+            backend: ['backend', 'api', 'server'],
+            frontend: ['frontend', 'web', 'admin', 'dashboard'],
+            ios: ['ios', 'swift'],
+            android: ['android', 'kotlin']
+        };
+
+        for (const [platform, patterns] of Object.entries(platformPatterns)) {
+            if (patterns.some(pattern => branch.toLowerCase().includes(pattern))) {
+                return { platform, confidence: 80 };
+            }
+        }
+
+        return { platform: null, confidence: 0 };
+    }
+
+    hasContextChanged(previousContext) {
+        if (!previousContext) return true;
+
+        const current = this.cache.context;
+        if (!current) return true;
+
+        const stagedChanged = JSON.stringify(current.stagedFiles) !== JSON.stringify(previousContext.stagedFiles);
+        const signatureChanged = (current.stagedSignature || '') !== (previousContext.stagedSignature || '');
+        const branchChanged = current.branchName !== previousContext.branchName;
+
+        return stagedChanged || signatureChanged || branchChanged;
+    }
+
+    clearCache() {
+        this.cache = {
+            context: null,
+            timestamp: 0,
+            ttl: this.cache.ttl
+        };
+    }
+}
+
+module.exports = ContextDetectionEngine;

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

@@ -0,0 +1,182 @@
+const fs = require('fs').promises;
+const path = require('path');
+
+class DynamicRulesLoader {
+    constructor(rulesDirectory, logger = console) {
+        this.rulesDirectory = rulesDirectory || null;
+        this.logger = logger;
+        this.rulesDirectories = this.resolveRulesDirectories();
+        this.rulesMap = {
+            backend: 'rulesbackend.mdc',
+            frontend: 'rulesfront.mdc',
+            ios: 'rulesios.mdc',
+            android: 'rulesandroid.mdc'
+        };
+        this.cache = {
+            rules: new Map(),
+            timestamp: 0,
+            ttl: 60000
+        };
+        this.lastLoadWarnings = [];
+    }
+
+    resolveRulesDirectories() {
+        const cwd = process.cwd();
+
+        if (this.rulesDirectory && typeof this.rulesDirectory === 'string') {
+            return [this.rulesDirectory];
+        }
+
+        const envRaw = process.env.AST_RULES_DIRECTORIES;
+        if (envRaw && typeof envRaw === 'string' && envRaw.trim().length > 0) {
+            return envRaw
+                .split(',')
+                .map(entry => entry.trim())
+                .filter(Boolean)
+                .map(entry => (path.isAbsolute(entry) ? entry : path.join(cwd, entry)));
+        }
+
+        return [
+            path.join(cwd, '.cursor', 'rules'),
+            path.join(cwd, '.windsurf', 'rules'),
+            path.join(cwd, '.ast-intelligence', 'rules'),
+            path.join(cwd, '.ast-intelligence', 'skills')
+        ];
+    }
+
+    async loadRulesForPlatforms(platforms) {
+        const rules = [];
+
+        for (const platformData of platforms) {
+            const platform = platformData.platform || platformData;
+            const rulePath = this.rulesMap[platform];
+
+            if (!rulePath) {
+                this.logger.warn(`[DynamicRulesLoader] No rules file mapped for platform: ${platform}`, { platform });
+                continue;
+            }
+
+            const ruleContent = await this.loadRule(rulePath);
+            if (ruleContent) {
+                rules.push({
+                    platform,
+                    content: ruleContent,
+                    path: rulePath
+                });
+            }
+        }
+
+        return rules;
+    }
+
+    async loadRule(ruleFileName) {
+        if (this.cache.rules.has(ruleFileName)) {
+            const cached = this.cache.rules.get(ruleFileName);
+            if (Date.now() - cached.timestamp < this.cache.ttl) {
+                return cached.content;
+            }
+        }
+
+        this.lastLoadWarnings = [];
+        const attempts = [];
+
+        for (const directory of this.rulesDirectories) {
+            const fullPath = path.join(directory, ruleFileName);
+            attempts.push(fullPath);
+            try {
+                const content = await fs.readFile(fullPath, 'utf-8');
+                this.cache.rules.set(ruleFileName, {
+                    content,
+                    timestamp: Date.now(),
+                    fullPath
+                });
+                return content;
+            } catch (error) {
+                this.lastLoadWarnings.push({
+                    file: ruleFileName,
+                    path: fullPath,
+                    error: error && error.message ? error.message : String(error)
+                });
+            }
+        }
+
+        this.logger.warn(
+            `[DynamicRulesLoader] Could not load ${ruleFileName}. Tried locations: ${attempts.join(', ')}`,
+            { ruleFileName, attempts }
+        );
+        return null;
+    }
+
+    aggregateRules(rules) {
+        if (rules.length === 0) {
+            return null;
+        }
+
+        if (rules.length === 1) {
+            return rules[0].content;
+        }
+
+        const header = `# Auto-Generated Multi-Platform Rules
+# Detected platforms: ${rules.map(r => r.platform).join(', ')}
+# Generated: ${new Date().toISOString()}
+# Pumuki Team®
+
+`;
+
+        const sections = rules.map((rule, index) => {
+            return `
+## Platform ${index + 1}: ${rule.platform.toUpperCase()}
+## Source: ${rule.path}
+
+${rule.content}
+
+---
+`;
+        }).join('\n');
+
+        return header + sections;
+    }
+
+    async generateDynamicContext(platforms, confidence) {
+        const rules = await this.loadRulesForPlatforms(platforms);
+        const aggregated = this.aggregateRules(rules);
+
+        const contextHeader = `---
+trigger: always_on
+description: Auto-generated context for detected platforms
+confidence: ${confidence}%
+platforms: ${platforms.map(p => p.platform || p).join(', ')}
+generated: ${new Date().toISOString()}
+---
+
+# Active Context - Confidence: ${confidence}%
+
+Detected platforms with high confidence. Rules loaded automatically.
+
+`;
+
+        return contextHeader + (aggregated || '');
+    }
+
+    async saveDynamicContext(content, outputPath) {
+        try {
+            const baseDir = this.rulesDirectory
+                || (Array.isArray(this.rulesDirectories) && this.rulesDirectories.length > 0 ? this.rulesDirectories[0] : null)
+                || path.join(process.cwd(), '.cursor', 'rules');
+            const fullPath = outputPath || path.join(baseDir, 'auto-context.mdc');
+            await fs.mkdir(path.dirname(fullPath), { recursive: true });
+            await fs.writeFile(fullPath, content, 'utf-8');
+            return fullPath;
+        } catch (error) {
+            this.logger.error(`[DynamicRulesLoader] Failed to save auto-context.mdc:`, { error: error.message });
+            throw error;
+        }
+    }
+
+    clearCache() {
+        this.cache.rules.clear();
+        this.cache.timestamp = Date.now();
+    }
+}
+
+module.exports = DynamicRulesLoader;

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

@@ -0,0 +1,156 @@
+const { execSync, spawnSync } = require('child_process');
+const { ConfigurationError } = require('../../domain/errors');
+
+class GitFlowService {
+    constructor(repoRoot, options = {}, logger = console, gitQuery = null, gitCommand = null, githubAdapter = null) {
+        this.repoRoot = repoRoot;
+        this.logger = logger;
+        this.gitQuery = gitQuery;
+        this.gitCommand = gitCommand || (gitQuery && gitQuery.commandAdapter ? gitQuery : null);
+        this.github = githubAdapter;
+
+        this.developBranch = options.developBranch || 'develop';
+        this.mainBranch = options.mainBranch || 'main';
+        this.autoSyncEnabled = options.autoSyncEnabled !== false;
+        this.autoCleanEnabled = options.autoCleanEnabled !== false;
+        this.requireClean = options.requireClean !== false;
+
+        this._validateDependencies();
+    }
+
+    _validateDependencies() {
+        if (!this.gitQuery) this.logger.warn('GitFlowService: gitQuery adapter missing');
+        if (!this.gitCommand) this.logger.warn('GitFlowService: gitCommand adapter missing');
+        if (!this.github) this.logger.warn('GitFlowService: githubAdapter missing');
+    }
+
+    getCurrentBranch() {
+        if (this.gitQuery) {
+            return this.gitQuery.getCurrentBranch();
+        }
+        return 'unknown';
+    }
+
+    isClean() {
+        if (this.gitQuery) {
+            const changes = this.gitQuery.getUncommittedChanges();
+            return !changes || changes.length === 0;
+        }
+        return false;
+    }
+
+    syncBranches() {
+        if (!this.autoSyncEnabled) {
+            return { success: false, message: 'Auto-sync disabled' };
+        }
+
+        if (!this.isClean()) {
+            this.logger.warn('Skipping sync: working directory not clean');
+            return { success: false, message: 'Working directory not clean' };
+        }
+
+        try {
+            const current = this.getCurrentBranch();
+            this.logger.info('Starting branch synchronization', { currentBranch: current });
+
+            if (this.gitCommand) {
+                this.gitCommand.fetchRemote('origin');
+
+                this.gitCommand.checkout(this.developBranch);
+                this.gitCommand.pull('origin', this.developBranch);
+
+                this.gitCommand.checkout(this.mainBranch);
+                this.gitCommand.pull('origin', this.mainBranch);
+
+                this.gitCommand.checkout(current);
+            } else {
+                throw new ConfigurationError('GitCommandAdapter is required for branch synchronization', 'gitCommand');
+            }
+
+            this.logger.info('Branches synchronized successfully', {
+                branches: [this.developBranch, this.mainBranch]
+            });
+            return { success: true, message: 'Branches synchronized' };
+        } catch (error) {
+            this.logger.error('Branch synchronization failed', { error: error.message });
+            return { success: false, message: error.message };
+        }
+    }
+
+    createPullRequest(sourceBranch, targetBranch, title, body) {
+        if (!this.github) {
+            this.logger.error('GitHub adapter not available');
+            return null;
+        }
+
+        try {
+            this.logger.info('Creating Pull Request', { source: sourceBranch, target: targetBranch, title });
+
+            const prUrl = this.github.createPullRequest(targetBranch, sourceBranch, title, body);
+
+            if (prUrl) {
+                this.logger.info('Pull Request created successfully', { prUrl });
+            } else {
+                this.logger.warn('Pull Request creation failed or returned no URL');
+            }
+
+            return prUrl;
+        } catch (error) {
+            this.logger.error('[GitFlowService] Failed to create PR:', { error: error.message });
+            return null;
+        }
+    }
+
+    mergeDevelopToMain() {
+        if (!this.isClean()) {
+            this.logger.warn('Skipping merge: working directory not clean');
+            return { success: false, message: 'Working directory not clean' };
+        }
+
+        try {
+            this.logger.info('Starting merge process: develop -> main');
+
+            // Ensure branches are up to date
+            this.syncBranches();
+
+            // Create PR from develop to main
+            const prUrl = this.createPullRequest(
+                this.developBranch,
+                this.mainBranch,
+                `Merge ${this.developBranch} into ${this.mainBranch}`,
+                'Automated merge from develop to main'
+            );
+
+            if (!prUrl) {
+                return { success: false, message: 'Failed to create PR' };
+            }
+
+            // Merge the PR
+            if (this.github) {
+                this.logger.info('Merging Pull Request', { prUrl });
+                this.github.mergePullRequest(prUrl);
+            } else {
+                throw new ConfigurationError('GitHub adapter required for merging PR', 'github');
+            }
+
+            // Clean up merged branch
+            if (this.autoCleanEnabled) {
+                this.logger.info('Cleaning up branches', { branch: this.developBranch });
+                // Note: Branch deletion should be implemented in GitCommandAdapter if strictly needed.
+                // Currently skipped to avoid direct child_process usage.
+            }
+
+            this.logger.info('Successfully merged develop to main');
+            return { success: true, message: 'Successfully merged develop to main' };
+        } catch (error) {
+            this.logger.error('Merge process failed', { error: error.message });
+            return { success: false, message: error.message };
+        }
+    }
+
+    isGitHubAvailable() {
+        return this.github ? this.github.isAvailable() : false;
+    }
+}
+
+module.exports = GitFlowService;

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

@@ -0,0 +1,140 @@
+const { execSync } = require('child_process');
+
+const extractFilePath = line => {
+    if (!line) {
+        return '';
+    }
+    if (line.startsWith('??')) {
+        return line.slice(3).trim();
+    }
+    return line.length > 3 ? line.slice(3).trim() : line.trim();
+};
+
+const buildStateFromStatus = (statusOutput = '') => {
+    const lines = statusOutput
+        .split('\n')
+        .map(entry => entry.replace(/\r$/, ''))
+        .filter(entry => entry && entry.length >= 3);
+
+    const stagedSet = new Set();
+    const workingSet = new Set();
+
+    lines.forEach(line => {
+        if (line.startsWith('??')) {
+            const file = extractFilePath(line);
+            if (file) {
+                workingSet.add(file);
+            }
+            return;
+        }
+
+        const stagedFlag = line[0];
+        const workingFlag = line[1];
+        const file = extractFilePath(line);
+
+        if (file) {
+            if (stagedFlag && stagedFlag !== ' ') {
+                stagedSet.add(file);
+            }
+            if (workingFlag && workingFlag !== ' ') {
+                workingSet.add(file);
+            }
+        }
+    });
+
+    const uniqueSet = new Set([...stagedSet, ...workingSet]);
+
+    return {
+        stagedFiles: Array.from(stagedSet),
+        workingFiles: Array.from(workingSet),
+        stagedCount: stagedSet.size,
+        workingCount: workingSet.size,
+        uniqueCount: uniqueSet.size
+    };
+};
+
+const getGitTreeState = ({ repoRoot = process.cwd() } = {}) => {
+    try {
+        const statusOutput = execSync('git status --porcelain', {
+            cwd: repoRoot,
+            encoding: 'utf8'
+        });
+        return buildStateFromStatus(statusOutput);
+    } catch (error) {
+        return {
+            stagedFiles: [],
+            workingFiles: [],
+            stagedCount: 0,
+            workingCount: 0,
+            uniqueCount: 0,
+            error: error.message
+        };
+    }
+};
+
+const isTreeBeyondLimit = (state, limits) => {
+    if (!state) {
+        return false;
+    }
+    
+    if (typeof limits === 'number') {
+        const limit = limits;
+        if (!Number.isFinite(limit) || limit <= 0) {
+            return false;
+        }
+        return (
+            state.stagedCount > limit ||
+            state.workingCount > limit ||
+            state.uniqueCount > limit
+        );
+    }
+    
+    const { stagedLimit = 10, unstagedLimit = 15, totalLimit = 20 } = limits || {};
+    
+    const stagedExceeded = Number.isFinite(stagedLimit) && stagedLimit > 0 && state.stagedCount > stagedLimit;
+    const unstagedExceeded = Number.isFinite(unstagedLimit) && unstagedLimit > 0 && state.workingCount > unstagedLimit;
+    const totalExceeded = Number.isFinite(totalLimit) && totalLimit > 0 && state.uniqueCount > totalLimit;
+    
+    return stagedExceeded || unstagedExceeded || totalExceeded;
+};
+
+const summarizeTreeState = (state, limits) => {
+    if (!state) {
+        return 'no data';
+    }
+    const parts = [
+        `staged ${state.stagedCount}`,
+        `working ${state.workingCount}`,
+        `unique ${state.uniqueCount}`
+    ];
+    
+    if (typeof limits === 'number') {
+        const limit = limits;
+        if (Number.isFinite(limit) && limit > 0) {
+            parts.push(`limit ${limit}`);
+        }
+    } else if (limits && typeof limits === 'object') {
+        const { stagedLimit = 10, unstagedLimit = 15, totalLimit = 20 } = limits;
+        const limitParts = [];
+        if (Number.isFinite(stagedLimit) && stagedLimit > 0) {
+            limitParts.push(`staged limit ${stagedLimit}`);
+        }
+        if (Number.isFinite(unstagedLimit) && unstagedLimit > 0) {
+            limitParts.push(`unstaged limit ${unstagedLimit}`);
+        }
+        if (Number.isFinite(totalLimit) && totalLimit > 0) {
+            limitParts.push(`total limit ${totalLimit}`);
+        }
+        if (limitParts.length > 0) {
+            parts.push(`(${limitParts.join(', ')})`);
+        }
+    }
+    return parts.join(', ');
+};
+
+module.exports = {
+    getGitTreeState,
+    isTreeBeyondLimit,
+    summarizeTreeState,
+    buildStateFromStatus
+};