pumuki-ast-hooks 5.3.1

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

@@ -0,0 +1,77 @@
+const { recordMetric } = require('../../infrastructure/telemetry/metrics-logger');
+const HookSystemStateMachine = require('../state/HookSystemStateMachine');
+
+class HookSystemScheduler {
+  constructor({ orchestrator, contextEngine, intervalMs = 30000 }) {
+    this.orchestrator = orchestrator;
+    this.contextEngine = contextEngine;
+    this.intervalMs = intervalMs;
+    this.stateMachine = new HookSystemStateMachine();
+    this.timer = null;
+  }
+
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(() => this.tick(), this.intervalMs);
+  }
+
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  async tick() {
+    try {
+      if (this.stateMachine.getState() !== 'idle') {
+        return;
+      }
+
+      if (!this.orchestrator.shouldReanalyze()) {
+        return;
+      }
+
+      this.stateMachine.transition('analyze');
+      const start = Date.now();
+
+      const action = await this.orchestrator.analyzeContext();
+      this.stateMachine.transition('decide');
+
+      await this.executeAction(action);
+
+      this.stateMachine.transition('complete');
+      recordMetric({
+        hook: 'autonomous-orchestrator',
+        status: 'success',
+        durationMs: Date.now() - start,
+        action,
+      });
+    } catch (error) {
+      this.stateMachine.transition('error');
+      recordMetric({
+        hook: 'autonomous-orchestrator',
+        status: 'failure',
+        message: error.message,
+      });
+      this.stateMachine.transition('reset');
+      throw error;
+    }
+  }
+
+  async executeAction(action) {
+    if (!action || !action.action) {
+      return;
+    }
+
+    if (action.action === 'auto-execute') {
+      return;
+    }
+
+    if (action.action === 'ask') {
+      return;
+    }
+  }
+}
+
+module.exports = HookSystemScheduler;

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

@@ -0,0 +1,151 @@
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const FeatureDetector = require('./commit/FeatureDetector');
+const CommitMessageGenerator = require('./commit/CommitMessageGenerator');
+const UnifiedLogger = require('./logging/UnifiedLogger');
+
+class IntelligentCommitAnalyzer {
+    constructor({ repoRoot = process.cwd(), logger = null } = {}) {
+        this.repoRoot = repoRoot;
+        this.logger = logger || console;
+        this.featureDetector = new FeatureDetector(this.logger);
+        this.messageGenerator = new CommitMessageGenerator(this.logger);
+    }
+
+    detectFeature(filePath) {
+        return this.featureDetector.detectFeature(filePath);
+    }
+
+    detectModule(filePath) {
+        return this.featureDetector.detectModule(filePath);
+    }
+
+    detectPlatform(filePath) {
+        return this.featureDetector.detectPlatform(filePath);
+    }
+
+    isTestFile(filePath) {
+        return this.featureDetector.isTestFile(filePath);
+    }
+
+    generateCommitMessage(group) {
+        return this.messageGenerator.generate(group);
+    }
+
+    /**
+     * Group files by feature/module using intelligent analysis
+     * Only groups related files - ignores unrelated/config files
+     */
+    groupFilesByFeature(files) {
+        this.logger.debug('ANALYZING_FILES', { count: files.length });
+        const groups = new Map();
+        const ungrouped = [];
+
+        for (const file of files) {
+            const feature = this.featureDetector.detectFeature(file);
+
+            if (feature === null) {
+                ungrouped.push(file);
+                continue;
+            }
+
+            const module = this.featureDetector.detectModule(file);
+            const key = `${feature}:${module}`;
+
+            if (!groups.has(key)) {
+                groups.set(key, {
+                    feature,
+                    module,
+                    files: [],
+                    platform: this.featureDetector.detectPlatform(file),
+                    hasTests: false,
+                    hasImplementation: false
+                });
+            }
+
+            const group = groups.get(key);
+            group.files.push(file);
+
+            if (this.featureDetector.isTestFile(file)) {
+                group.hasTests = true;
+            } else {
+                group.hasImplementation = true;
+            }
+        }
+
+        const result = Array.from(groups.values());
+        const filtered = result.filter(g => g.files.length >= 2);
+
+        this.logger.info('ANALYSIS_COMPLETE', {
+            totalFiles: files.length,
+            groupsFound: filtered.length,
+            ungroupedCount: ungrouped.length
+        });
+
+        return filtered;
+    }
+
+    /**
+     * Verify tests pass for a feature group
+     * DISABLED: Too expensive and prone to false positives
+     * Only enable when explicitly requested
+     */
+    async verifyTests(group) {
+        return { passed: null, reason: 'test verification disabled' };
+    }
+
+    /**
+     * Verify project builds
+     * DISABLED: Too expensive and prone to false positives
+     * Only enable when explicitly requested
+     */
+    async verifyBuild(group) {
+        return { built: null, reason: 'build check disabled' };
+    }
+
+    /**
+     * Analyze files and suggest atomic commits
+     * Only groups related files - no build/test verification
+     */
+    async analyzeAndSuggestCommits(files) {
+        const groups = this.groupFilesByFeature(files);
+        const suggestions = [];
+
+        for (const group of groups) {
+            if (group.files.length < 2) {
+                continue;
+            }
+
+            const suggestion = {
+                feature: group.feature,
+                module: group.module,
+                platform: group.platform,
+                files: group.files,
+                fileCount: group.files.length,
+                hasTests: group.hasTests,
+                commitMessage: this.messageGenerator.generate(group)
+            };
+
+            suggestions.push(suggestion);
+        }
+
+        return suggestions;
+    }
+
+    /**
+     * Get ready-to-commit groups (all groups are ready - no verification)
+     */
+    getReadyCommits(suggestions) {
+        return suggestions;
+    }
+
+    /**
+     * Get groups that need attention (none - we don't verify)
+     */
+    getNeedsAttention(suggestions) {
+        return [];
+    }
+}
+
+module.exports = IntelligentCommitAnalyzer;

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

@@ -0,0 +1,118 @@
+const IntelligentCommitAnalyzer = require('./IntelligentCommitAnalyzer');
+const { getGitTreeState } = require('./GitTreeState');
+
+class IntelligentGitTreeMonitor {
+    constructor({
+        repoRoot = process.cwd(),
+        notifier = console,
+        logger = console,
+        autoCommitEnabled = false
+    } = {}) {
+        this.repoRoot = repoRoot;
+        this.notifier = notifier;
+        this.logger = logger;
+        this.autoCommitEnabled = autoCommitEnabled;
+        this.analyzer = new IntelligentCommitAnalyzer({ repoRoot, logger });
+    }
+
+    /**
+     * Analyze git tree and suggest intelligent actions
+     */
+    async analyze() {
+        const state = getGitTreeState({ repoRoot: this.repoRoot });
+
+        if (state.uniqueCount === 0) {
+            return { action: 'clean', message: 'Git tree is clean' };
+        }
+
+        const allFiles = [...state.stagedFiles, ...state.workingFiles];
+
+        const suggestions = await this.analyzer.analyzeAndSuggestCommits(allFiles);
+        const readyCommits = this.analyzer.getReadyCommits(suggestions);
+        const needsAttention = this.analyzer.getNeedsAttention(suggestions);
+
+        if (readyCommits.length > 0) {
+            return {
+                action: 'suggest_commit',
+                readyCommits,
+                message: `Found ${readyCommits.length} feature(s) ready to commit`,
+                suggestions: readyCommits.map(c => ({
+                    files: c.files,
+                    fileCount: c.fileCount || c.files.length,
+                    message: c.commitMessage,
+                    feature: c.feature,
+                    module: c.module,
+                    platform: c.platform
+                }))
+            };
+        }
+
+        if (suggestions.length > 10) {
+            return {
+                action: 'too_many_features',
+                suggestions,
+                message: `Found ${suggestions.length} different features/modules. Consider splitting into separate commits.`,
+                groups: suggestions.map(s => ({
+                    feature: s.feature,
+                    fileCount: s.fileCount,
+                    files: s.files.slice(0, 3)
+                }))
+            };
+        }
+
+        return {
+            action: 'info',
+            suggestions,
+            message: `Analyzed ${state.uniqueCount} files, found ${suggestions.length} feature groups`,
+            groups: suggestions
+        };
+    }
+
+    /**
+     * Notify user with intelligent suggestions
+     */
+    async notify() {
+        const analysis = await this.analyze();
+
+        switch (analysis.action) {
+            case 'clean':
+                break;
+
+            case 'suggest_commit':
+                const featureList = analysis.suggestions
+                    .slice(0, 3)
+                    .map(s => {
+                        const count = s.fileCount || (s.files ? s.files.length : 0);
+                        return `${s.feature || 'unknown'} (${count} files)`;
+                    })
+                    .join(', ');
+                const moreText = analysis.suggestions.length > 3 ? ` +${analysis.suggestions.length - 3} more` : '';
+
+                this.notifier({
+                    title: '📦 Atomic Commit Suggestions',
+                    subtitle: `${analysis.readyCommits.length} feature group(s) detected`,
+                    message: `${featureList}${moreText}`,
+                    sound: 'Ping',
+                    action: 'suggest_commit',
+                    data: analysis.suggestions
+                });
+                break;
+
+            case 'too_many_features':
+                this.notifier({
+                    title: '📦 Multiple Features Detected',
+                    subtitle: `${analysis.suggestions.length} different features`,
+                    message: 'Consider splitting into separate atomic commits',
+                    sound: 'Submarine',
+                    action: 'too_many_features',
+                    data: analysis.groups
+                });
+                break;
+
+            default:
+                this.logger.info('Git tree analysis:', analysis);
+        }
+    }
+}
+
+module.exports = IntelligentGitTreeMonitor;

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

@@ -0,0 +1,173 @@
+const path = require('path');
+const fs = require('fs');
+const PlatformHeuristics = require('./platform/PlatformHeuristics');
+
+class PlatformAnalysisService {
+    constructor(platformDetector) {
+        this.platformDetector = platformDetector;
+        this.heuristics = new PlatformHeuristics(platformDetector);
+    }
+
+    /**
+     * Identifies potential platforms based on the current context
+     * @param {Object} context - The context object from ContextDetectionEngine
+     * @returns {string[]} Array of detected platform names
+     */
+    identifyPotentialPlatforms(context) {
+        const detectedPlatforms = new Set();
+
+        if (context.stagedFiles && context.stagedFiles.length > 0) {
+            context.stagedFiles.forEach(file => {
+                const platform = this.platformDetector.detectPlatformFromFile(file);
+                if (platform && platform !== 'other') {
+                    detectedPlatforms.add(platform);
+                }
+            });
+        }
+
+        const platforms = this.heuristics.detectPlatforms(context);
+        platforms.forEach(p => detectedPlatforms.add(p));
+
+        if (context.stagedFiles && context.stagedFiles.includes('.AI_EVIDENCE.json')) {
+            const evidencePlatforms = this.heuristics.detectFromEvidenceFile();
+            evidencePlatforms.forEach(p => detectedPlatforms.add(p));
+        }
+
+        if (detectedPlatforms.size === 0 && context.recentFiles) {
+            context.recentFiles.forEach(file => {
+                const platform = this.platformDetector.detectPlatformFromFile(file);
+                if (platform && platform !== 'other') {
+                    detectedPlatforms.add(platform);
+                }
+            });
+        }
+
+        return Array.from(detectedPlatforms);
+    }
+
+    /**
+     * Analyzes confidence scores for each platform
+     * @param {string[]} platforms - List of potential platforms
+     * @param {Object} context - The context object
+     * @returns {Object[]} Array of score objects { platform, confidence, reasons }
+     */
+    analyzeConfidence(platforms, context) {
+        const scores = [];
+
+        for (const platform of platforms) {
+            const score = this.calculatePlatformScore(platform, context);
+            scores.push({
+                platform,
+                confidence: score,
+                reasons: this.getScoreReasons(platform, context)
+            });
+        }
+
+        return scores.sort((a, b) => b.confidence - a.confidence);
+    }
+
+    calculatePlatformScore(platform, context) {
+        let score = 0;
+        const weights = {
+            stagedFilesMatch: 25,
+            directoryUnambiguous: 20,
+            extensionSpecific: 15,
+            branchNameMatch: 5,
+            recentHistoryConsistent: 5,
+            astSystemFiles: 30,
+            branchKeywords: 20,
+            evidenceContent: 15
+        };
+
+        const neutralFilenames = new Set(['.AI_EVIDENCE.json', 'README.md']);
+        const relevantStagedFiles = (context.stagedFiles || []).filter(file => !neutralFilenames.has(file));
+
+        if (relevantStagedFiles.length > 0) {
+            const matchingFiles = relevantStagedFiles.filter(file =>
+                this.platformDetector.detectPlatformFromFile(file) === platform
+            );
+            const matchRatio = matchingFiles.length / relevantStagedFiles.length;
+            score += weights.stagedFilesMatch * matchRatio;
+        }
+
+        const isUnambiguous = this.heuristics.isDirectoryUnambiguous(context.stagedFiles, platform);
+        if (isUnambiguous) {
+            score += weights.directoryUnambiguous;
+        }
+
+        const hasSpecificExtension = this.heuristics.hasSpecificExtension(context.stagedFiles, platform);
+        if (hasSpecificExtension) {
+            score += weights.extensionSpecific;
+        }
+
+        if (context.branchName && context.branchName.includes(platform)) {
+            score += weights.branchNameMatch;
+        }
+
+        if (context.recentCommits) {
+            const platformFrequency = this.heuristics.getPlatformFrequencyInHistory(platform, context.recentCommits);
+            if (platformFrequency > 0.7) {
+                score += weights.recentHistoryConsistent;
+            }
+        }
+
+        if (this.heuristics.platformDetectedInASTSystemFiles(context.stagedFiles, platform)) {
+            score += weights.astSystemFiles;
+        }
+
+        if (this.heuristics.platformDetectedInBranchKeywords(context.branchName, platform)) {
+            score += weights.branchKeywords;
+        }
+
+        if (context.stagedFiles && context.stagedFiles.includes('.AI_EVIDENCE.json')) {
+            const evidencePlatforms = this.heuristics.detectFromEvidenceFile();
+            if (evidencePlatforms.includes(platform)) {
+                score += weights.evidenceContent;
+            }
+        }
+
+        return Math.min(100, Math.round(score));
+    }
+
+    getScoreReasons(platform, context) {
+        const reasons = [];
+
+        if (context.stagedFiles && context.stagedFiles.length > 0) {
+            const matchCount = context.stagedFiles.filter(f =>
+                this.platformDetector.detectPlatformFromFile(f) === platform
+            ).length;
+            if (matchCount > 0) {
+                reasons.push(`${matchCount}/${context.stagedFiles.length} staged files match`);
+            }
+        }
+
+        if (this.heuristics.isDirectoryUnambiguous(context.stagedFiles, platform)) {
+            reasons.push('Directory path unambiguous');
+        }
+
+        if (context.branchName && context.branchName.includes(platform)) {
+            reasons.push(`Branch name contains '${platform}'`);
+        }
+
+        const astPlatforms = this.heuristics.detectFromASTSystemFiles(context.stagedFiles);
+        if (astPlatforms.includes(platform)) {
+            reasons.push('AST system files detected');
+        }
+
+        const branchPlatforms = this.heuristics.detectFromBranchKeywords(context.branchName);
+        if (branchPlatforms.includes(platform)) {
+            reasons.push(`Branch keywords match '${platform}'`);
+        }
+
+        if (context.stagedFiles && context.stagedFiles.includes('.AI_EVIDENCE.json')) {
+            const evidencePlatforms = this.heuristics.detectFromEvidenceFile();
+            if (evidencePlatforms.includes(platform)) {
+                reasons.push('Evidence file references platform rules');
+            }
+        }
+
+        return reasons;
+    }
+}
+
+module.exports = PlatformAnalysisService;

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

@@ -0,0 +1,168 @@
+
+const fs = require('fs').promises;
+const path = require('path');
+
+class PlatformDetectionService {
+  constructor() {
+    this.cache = {
+      detections: new Map(),
+      timestamp: 0,
+      ttl: 30000
+    };
+
+    this.platformIndicators = {
+      backend: [
+        'nest-cli.json',
+        'tsconfig.server.json',
+        '/apps/backend/',
+        '/services/',
+        '/functions/',
+      ],
+      frontend: [
+        'next.config.js',
+        'next.config.ts',
+        '/apps/web-app/',
+        '/apps/admin-dashboard/',
+        '/apps/admin/',
+        'package.json',
+      ],
+      ios: [
+        '.xcodeproj',
+        '.xcworkspace',
+        'Podfile',
+        'Package.swift',
+        '/apps/ios/',
+        '*.swift',
+      ],
+      android: [
+        'build.gradle',
+        'settings.gradle',
+        'AndroidManifest.xml',
+        '/apps/android/',
+        '*.kt',
+        '*.java',
+      ],
+    };
+  }
+
+  async detectPlatforms(targetPath) {
+    const platforms = new Set();
+
+    try {
+      for (const [platform, indicators] of Object.entries(this.platformIndicators)) {
+        for (const indicator of indicators) {
+          if (await this.checkIndicator(targetPath, indicator)) {
+            platforms.add(platform);
+            break;
+          }
+        }
+      }
+
+      return Array.from(platforms);
+
+    } catch (error) {
+      return [];
+    }
+  }
+
+  async checkIndicator(targetPath, indicator) {
+    try {
+      if (indicator.startsWith('/')) {
+        const dirPath = path.join(targetPath, indicator);
+        const stat = await fs.stat(dirPath);
+        return stat.isDirectory();
+      } else if (indicator.includes('*')) {
+        const ext = indicator.replace('*', '');
+        return await this.hasFilesWithExtension(targetPath, ext);
+      } else {
+        const filePath = path.join(targetPath, indicator);
+        await fs.access(filePath);
+        return true;
+      }
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async hasFilesWithExtension(targetPath, extension) {
+    try {
+      const files = await fs.readdir(targetPath);
+      return files.some(file => file.endsWith(extension));
+    } catch (error) {
+      return false;
+    }
+  }
+
+  detectPlatformFromFile(filePath) {
+    if (this.cache.detections.has(filePath)) {
+      const cached = this.cache.detections.get(filePath);
+      if (Date.now() - cached.timestamp < this.cache.ttl) {
+        return cached.platform;
+      }
+    }
+
+    const platform = this._detectPlatformUncached(filePath);
+
+    this.cache.detections.set(filePath, {
+      platform,
+      timestamp: Date.now()
+    });
+
+    return platform;
+  }
+
+  _detectPlatformUncached(filePath) {
+    const lowerPath = filePath.toLowerCase();
+
+    if (lowerPath.includes('apps/backend/') || lowerPath.includes('scripts/hooks-system/') || lowerPath.includes('/services/') || lowerPath.includes('services/') || lowerPath.includes('/functions/') || lowerPath.includes('functions/')) {
+      return 'backend';
+    }
+    if (lowerPath.includes('apps/web-app/') || lowerPath.includes('apps/admin')) {
+      return 'frontend';
+    }
+    if (lowerPath.includes('apps/ios/') || filePath.endsWith('.swift')) {
+      return 'ios';
+    }
+    if (lowerPath.includes('apps/android/') || filePath.endsWith('.kt') || filePath.endsWith('.java')) {
+      return 'android';
+    }
+
+    const ext = path.extname(filePath);
+
+    if (ext === '.swift') return 'ios';
+    if (ext === '.kt' || ext === '.java') return 'android';
+    if (ext === '.ts' || ext === '.tsx') {
+      if (lowerPath.includes('server') || lowerPath.includes('api') || lowerPath.includes('backend')) {
+        return 'backend';
+      }
+      return 'frontend';
+    }
+
+    return 'other';
+  }
+
+  getAmbiguityScore(filePath) {
+    const platform = this._detectPlatformUncached(filePath);
+    const lowerPath = filePath.toLowerCase();
+    const ext = path.extname(filePath);
+
+    if (ext === '.swift') return 0;
+    if (ext === '.kt' || ext === '.kts') return 0;
+
+    if (lowerPath.includes('/apps/backend/')) return 10;
+    if (lowerPath.includes('/apps/ios/')) return 10;
+    if (lowerPath.includes('/apps/android/')) return 10;
+
+    if (ext === '.ts' || ext === '.tsx') return 60;
+    if (ext === '.js' || ext === '.jsx') return 70;
+
+    return 100;
+  }
+
+  clearCache() {
+    this.cache.detections.clear();
+    this.cache.timestamp = Date.now();
+  }
+}
+
+module.exports = PlatformDetectionService;