pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/.audit_tmp/severity-history.jsonl

@@ -0,0 +1 @@
+{"timestamp":"2025-12-25T22:29:39.634Z","commit":"cce11ed7eb1e70da937d1443853ccb86f718fe95","branch":"feature/meta-audit-insights","summary":{"total":556,"CRITICAL":257,"HIGH":0,"MEDIUM":99,"LOW":200},"averageScore":50,"gatePassed":false,"blockedBy":"CRITICAL"}

package/scripts/hooks-system/.audit_tmp/token-usage.jsonl

@@ -0,0 +1 @@
+{"timestamp":"2025-12-25T22:29:39.685Z","estimated":555199.75,"percentUsed":55.519975,"remaining":444800.25}

package/scripts/hooks-system/.hook-system/config.json

@@ -0,0 +1,8 @@
+{
+  "notification": {
+    "enabled": true
+  },
+  "recovery": {
+    "maxAttempts": 5
+  }
+}

package/scripts/hooks-system/application/CompositionRoot.js

@@ -0,0 +1,325 @@
+const MacOSNotificationAdapter = require('../infrastructure/adapters/MacOSNotificationAdapter');
+const FileEvidenceAdapter = require('../infrastructure/adapters/FileEvidenceAdapter');
+const GitQueryAdapter = require('../infrastructure/adapters/GitQueryAdapter');
+const GitCommandAdapter = require('../infrastructure/adapters/GitCommandAdapter');
+const GitHubCliAdapter = require('../infrastructure/adapters/GitHubCliAdapter');
+const AstAnalyzerAdapter = require('../infrastructure/adapters/AstAnalyzerAdapter');
+
+const AutonomousOrchestrator = require('./services/AutonomousOrchestrator');
+const ContextDetectionEngine = require('./services/ContextDetectionEngine');
+const PlatformDetectionService = require('./services/PlatformDetectionService');
+const AutoExecuteAIStartUseCase = require('./use-cases/AutoExecuteAIStartUseCase');
+
+// Services & Monitors
+const RealtimeGuardService = require('./services/RealtimeGuardService');
+const UnifiedLogger = require('./services/logging/UnifiedLogger');
+const NotificationCenterService = require('./services/notification/NotificationCenterService');
+const GitFlowService = require('./services/GitFlowService');
+const EvidenceMonitor = require('./services/monitoring/EvidenceMonitor');
+const GitTreeMonitor = require('./services/monitoring/GitTreeMonitor');
+const TokenMonitor = require('./services/monitoring/TokenMonitor');
+const ActivityMonitor = require('./services/monitoring/ActivityMonitor');
+const DevDocsMonitor = require('./services/monitoring/DevDocsMonitor');
+const AstMonitor = require('./services/monitoring/AstMonitor');
+
+const path = require('path');
+const fs = require('fs');
+
+class CompositionRoot {
+    constructor(repoRoot) {
+        this.repoRoot = repoRoot;
+        this.instances = new Map();
+
+        // Ensure audit directories exist
+        this.auditDir = path.join(repoRoot, '.audit-reports');
+        this.tempDir = path.join(repoRoot, '.audit_tmp');
+        this._ensureDirectories([this.auditDir, this.tempDir]);
+    }
+
+    _ensureDirectories(dirs) {
+        dirs.forEach(dir => {
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+        });
+    }
+
+    getLogger() {
+        if (!this.instances.has('logger')) {
+            this.instances.set('logger', new UnifiedLogger({
+                component: 'HookSystem',
+                file: {
+                    enabled: true,
+                    path: path.join(this.auditDir, 'guard-audit.jsonl'),
+                    level: process.env.HOOK_LOG_LEVEL || 'info'
+                },
+                console: {
+                    enabled: false,
+                    level: 'info'
+                }
+            }));
+        }
+        return this.instances.get('logger');
+    }
+
+    getNotificationService() {
+        if (!this.instances.has('notificationService')) {
+            const logger = this.getLogger();
+            this.instances.set('notificationService', new NotificationCenterService({
+                repoRoot: this.repoRoot,
+                logger
+            }));
+        }
+        return this.instances.get('notificationService');
+    }
+
+    // --- Infrastructure Adapters ---
+
+    getNotificationAdapter() {
+        if (!this.instances.has('notificationAdapter')) {
+            this.instances.set('notificationAdapter', new MacOSNotificationAdapter());
+        }
+        return this.instances.get('notificationAdapter');
+    }
+
+    getEvidenceAdapter() {
+        if (!this.instances.has('evidenceAdapter')) {
+            this.instances.set('evidenceAdapter', new FileEvidenceAdapter(this.repoRoot));
+        }
+        return this.instances.get('evidenceAdapter');
+    }
+
+    getGitQueryAdapter() {
+        if (!this.instances.has('gitQuery')) {
+            const logger = this.getLogger();
+            this.instances.set('gitQuery', new GitQueryAdapter({ repoRoot: this.repoRoot, logger }));
+        }
+        return this.instances.get('gitQuery');
+    }
+
+    getGitCommandAdapter() {
+        if (!this.instances.has('gitCommand')) {
+            const logger = this.getLogger();
+            this.instances.set('gitCommand', new GitCommandAdapter({ repoRoot: this.repoRoot, logger }));
+        }
+        return this.instances.get('gitCommand');
+    }
+
+    getGitHubAdapter() {
+        if (!this.instances.has('github')) {
+            const logger = this.getLogger();
+            this.instances.set('github', new GitHubCliAdapter(this.repoRoot, logger));
+        }
+        return this.instances.get('github');
+    }
+
+    getAstAdapter() {
+        if (!this.instances.has('ast')) {
+            this.instances.set('ast', new AstAnalyzerAdapter(this.repoRoot));
+        }
+        return this.instances.get('ast');
+    }
+
+    // --- Domain Services ---
+
+    getContextDetectionEngine() {
+        if (!this.instances.has('contextEngine')) {
+            const gitQuery = this.getGitQueryAdapter();
+            const logger = this.getLogger();
+            this.instances.set('contextEngine', new ContextDetectionEngine(gitQuery, logger));
+        }
+        return this.instances.get('contextEngine');
+    }
+
+    getPlatformDetectionService() {
+        if (!this.instances.has('platformDetector')) {
+            this.instances.set('platformDetector', new PlatformDetectionService());
+        }
+        return this.instances.get('platformDetector');
+    }
+
+    getOrchestrator() {
+        if (!this.instances.has('orchestrator')) {
+            const contextEngine = this.getContextDetectionEngine();
+            const platformDetector = this.getPlatformDetectionService();
+            const logger = this.getLogger();
+            // Note: RulesLoader is currently null in Factory, maintaining that behavior or adding if needed
+
+            this.instances.set('orchestrator', new AutonomousOrchestrator(
+                contextEngine,
+                platformDetector,
+                null,
+                logger
+            ));
+        }
+        return this.instances.get('orchestrator');
+    }
+
+    getAutoExecuteAIStartUseCase() {
+        if (!this.instances.has('autoExecuteAIStart')) {
+            const orchestrator = this.getOrchestrator();
+            const logger = this.getLogger();
+            this.instances.set('autoExecuteAIStart', new AutoExecuteAIStartUseCase(orchestrator, this.repoRoot, logger));
+        }
+        return this.instances.get('autoExecuteAIStart');
+    }
+
+    getBlockCommitUseCase() {
+        if (!this.instances.has('blockCommit')) {
+            const BlockCommitUseCase = require('./use-cases/BlockCommitUseCase');
+            this.instances.set('blockCommit', new BlockCommitUseCase());
+        }
+        return this.instances.get('blockCommit');
+    }
+
+    getMcpProtocolHandler(inputStream, outputStream) {
+        const McpProtocolHandler = require('../infrastructure/mcp/services/McpProtocolHandler');
+        const logger = this.getLogger();
+        return new McpProtocolHandler(inputStream, outputStream, logger);
+    }
+
+    // --- Monitors ---
+
+    getEvidenceMonitor() {
+        if (!this.instances.has('evidenceMonitor')) {
+            this.instances.set('evidenceMonitor', new EvidenceMonitor(this.repoRoot, {
+                staleThresholdMs: Number(process.env.HOOK_GUARD_EVIDENCE_STALE_THRESHOLD || 180000),
+                pollIntervalMs: Number(process.env.HOOK_GUARD_EVIDENCE_POLL_INTERVAL || 30000),
+                reminderIntervalMs: Number(process.env.HOOK_GUARD_EVIDENCE_REMINDER_INTERVAL || 60000)
+            }));
+        }
+        return this.instances.get('evidenceMonitor');
+    }
+
+    getGitTreeMonitor() {
+        if (!this.instances.has('gitTreeMonitor')) {
+            this.instances.set('gitTreeMonitor', new GitTreeMonitor(this.repoRoot, {
+                stagedThreshold: Number(process.env.HOOK_GUARD_DIRTY_TREE_STAGED_LIMIT || 10),
+                unstagedThreshold: Number(process.env.HOOK_GUARD_DIRTY_TREE_UNSTAGED_LIMIT || 15),
+                totalThreshold: Number(process.env.HOOK_GUARD_DIRTY_TREE_TOTAL_LIMIT || 20),
+                checkIntervalMs: Number(process.env.HOOK_GUARD_DIRTY_TREE_INTERVAL || 60000),
+                reminderMs: Number(process.env.HOOK_GUARD_DIRTY_TREE_REMINDER || 300000)
+            }));
+        }
+        return this.instances.get('gitTreeMonitor');
+    }
+
+    getTokenMonitor() {
+        if (!this.instances.has('tokenMonitor')) {
+            this.instances.set('tokenMonitor', new TokenMonitor(this.repoRoot));
+        }
+        return this.instances.get('tokenMonitor');
+    }
+
+    getGitFlowService() {
+        if (!this.instances.has('gitFlowService')) {
+            const logger = this.getLogger();
+            const gitQuery = this.getGitQueryAdapter();
+            const gitCommand = this.getGitCommandAdapter();
+            const github = this.getGitHubAdapter();
+
+            this.instances.set('gitFlowService', new GitFlowService(this.repoRoot, {
+                developBranch: process.env.HOOK_GUARD_GITFLOW_DEVELOP_BRANCH || 'develop',
+                mainBranch: process.env.HOOK_GUARD_GITFLOW_MAIN_BRANCH || 'main',
+                autoSyncEnabled: process.env.HOOK_GUARD_GITFLOW_AUTOSYNC !== 'false',
+                autoCleanEnabled: process.env.HOOK_GUARD_GITFLOW_AUTOCLEAN !== 'false',
+                requireClean: process.env.HOOK_GUARD_GITFLOW_REQUIRE_CLEAN !== 'false'
+            }, logger, gitQuery, gitCommand, github));
+        }
+        return this.instances.get('gitFlowService');
+    }
+
+    getActivityMonitor() {
+        if (!this.instances.has('activityMonitor')) {
+            const logger = this.getLogger();
+            this.instances.set('activityMonitor', new ActivityMonitor({
+                repoRoot: this.repoRoot,
+                inactivityGraceMs: Number(process.env.HOOK_GUARD_INACTIVITY_GRACE_MS || 420000),
+                logger
+            }));
+        }
+        return this.instances.get('activityMonitor');
+    }
+
+    getDevDocsMonitor() {
+        if (!this.instances.has('devDocsMonitor')) {
+            const logger = this.getLogger();
+            const notificationService = this.getNotificationService();
+            this.instances.set('devDocsMonitor', new DevDocsMonitor({
+                repoRoot: this.repoRoot,
+                checkIntervalMs: Number(process.env.HOOK_GUARD_DEV_DOCS_CHECK_INTERVAL || 300000),
+                staleThresholdMs: Number(process.env.HOOK_GUARD_DEV_DOCS_STALE_THRESHOLD || 86400000),
+                autoRefreshEnabled: process.env.HOOK_GUARD_DEV_DOCS_AUTO_REFRESH !== 'false',
+                logger,
+                notificationService
+            }));
+        }
+        return this.instances.get('devDocsMonitor');
+    }
+
+    getAstMonitor() {
+        if (!this.instances.has('astMonitor')) {
+            const logger = this.getLogger();
+            const notificationService = this.getNotificationService();
+            this.instances.set('astMonitor', new AstMonitor({
+                repoRoot: this.repoRoot,
+                debounceMs: Number(process.env.HOOK_AST_WATCH_DEBOUNCE || 8000),
+                cooldownMs: Number(process.env.HOOK_AST_WATCH_COOLDOWN || 30000),
+                enabled: process.env.HOOK_AST_WATCH !== 'false',
+                logger,
+                notificationService
+            }));
+        }
+        return this.instances.get('astMonitor');
+    }
+
+    getMonitors() {
+        return {
+            evidence: this.getEvidenceMonitor(),
+            gitTree: this.getGitTreeMonitor(),
+            token: this.getTokenMonitor(),
+            gitFlow: this.getGitFlowService(),
+            activity: this.getActivityMonitor(),
+            devDocs: this.getDevDocsMonitor(),
+            ast: this.getAstMonitor()
+        };
+    }
+
+    getRealtimeGuardService() {
+        if (!this.instances.has('guardService')) {
+            const logger = this.getLogger();
+            const notificationService = this.getNotificationService();
+            const monitors = this.getMonitors();
+            const orchestrator = this.getOrchestrator();
+            const config = {
+                debugLogPath: path.join(this.auditDir, 'guard-debug.log'),
+                repoRoot: this.repoRoot
+            };
+
+            this.instances.set('guardService', new RealtimeGuardService({
+                logger,
+                notificationService,
+                monitors,
+                orchestration: orchestrator,
+                config
+            }));
+        }
+        return this.instances.get('guardService');
+    }
+
+    static createForProduction(repoRoot) {
+        return new CompositionRoot(repoRoot);
+    }
+
+    static createForTesting(repoRoot, overrides = {}) {
+        const root = new CompositionRoot(repoRoot);
+        if (overrides) {
+            Object.entries(overrides).forEach(([key, value]) => {
+                root.instances.set(key, value);
+            });
+        }
+        return root;
+    }
+}
+
+module.exports = CompositionRoot;

package/scripts/hooks-system/application/__tests__/CompositionRoot.spec.js

@@ -0,0 +1,84 @@
+jest.mock('../../infrastructure/adapters/MacOSNotificationAdapter');
+jest.mock('../../infrastructure/adapters/FileEvidenceAdapter');
+jest.mock('../../infrastructure/adapters/GitQueryAdapter');
+jest.mock('../../infrastructure/adapters/GitCommandAdapter');
+jest.mock('../../infrastructure/adapters/GitHubCliAdapter');
+jest.mock('../../infrastructure/adapters/AstAnalyzerAdapter');
+jest.mock('../services/AutonomousOrchestrator');
+jest.mock('../services/ContextDetectionEngine');
+
+const CompositionRoot = require('../CompositionRoot');
+
+describe('CompositionRoot', () => {
+    const repoRoot = '/tmp/test-repo';
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('factory methods', () => {
+        it('creates production instance', () => {
+            const root = CompositionRoot.createForProduction(repoRoot);
+            expect(root).toBeInstanceOf(CompositionRoot);
+            expect(root.repoRoot).toBe(repoRoot);
+        });
+
+        it('creates testing instance with overrides', () => {
+            const mockNotification = { send: jest.fn() };
+            const root = CompositionRoot.createForTesting(repoRoot, {
+                notificationAdapter: mockNotification
+            });
+            expect(root.getNotificationAdapter()).toBe(mockNotification);
+        });
+    });
+
+    describe('lazy initialization', () => {
+        it('returns same instance on multiple calls (singleton behavior)', () => {
+            const root = new CompositionRoot(repoRoot);
+            const first = root.getEvidenceAdapter();
+            const second = root.getEvidenceAdapter();
+            expect(first).toBe(second);
+        });
+
+        it('creates git query adapter', () => {
+            const root = new CompositionRoot(repoRoot);
+            const adapter = root.getGitQueryAdapter();
+            expect(adapter).toBeDefined();
+        });
+
+        it('creates git command adapter', () => {
+            const root = new CompositionRoot(repoRoot);
+            const adapter = root.getGitCommandAdapter();
+            expect(adapter).toBeDefined();
+        });
+
+        it('creates ast adapter', () => {
+            const root = new CompositionRoot(repoRoot);
+            const adapter = root.getAstAdapter();
+            expect(adapter).toBeDefined();
+        });
+    });
+
+    describe('orchestrator', () => {
+        it('creates orchestrator with injected dependencies', () => {
+            const root = new CompositionRoot(repoRoot);
+            const orchestrator = root.getOrchestrator();
+            expect(orchestrator).toBeDefined();
+        });
+
+        it('returns same orchestrator instance', () => {
+            const root = new CompositionRoot(repoRoot);
+            const first = root.getOrchestrator();
+            const second = root.getOrchestrator();
+            expect(first).toBe(second);
+        });
+    });
+
+    describe('guard service', () => {
+        it('creates RealtimeGuardService', () => {
+            const root = new CompositionRoot(repoRoot);
+            const guard = root.getRealtimeGuardService();
+            expect(guard).toBeDefined();
+        });
+    });
+});

package/scripts/hooks-system/application/commands/index.js

@@ -0,0 +1,64 @@
+const path = require('path');
+const { NotFoundError } = require('../../domain/errors');
+
+class ValidateEvidenceCommand {
+    constructor(evidencePath) {
+        this.type = 'VALIDATE_EVIDENCE';
+        this.payload = { evidencePath };
+    }
+}
+
+class RunPreCommitCommand {
+    constructor(stagedFiles) {
+        this.type = 'RUN_PRE_COMMIT';
+        this.payload = { stagedFiles };
+    }
+}
+
+class CheckGitFlowCommand {
+    constructor(branch) {
+        this.type = 'CHECK_GITFLOW';
+        this.payload = { branch };
+    }
+}
+
+class UpdateEvidenceCommand {
+    constructor(data) {
+        this.type = 'UPDATE_EVIDENCE';
+        this.payload = data;
+    }
+}
+
+class RunAstAnalysisCommand {
+    constructor(files, platform) {
+        this.type = 'RUN_AST_ANALYSIS';
+        this.payload = { files, platform };
+    }
+}
+
+class CommandBus {
+    constructor() {
+        this.handlers = new Map();
+    }
+
+    register(commandType, handler) {
+        this.handlers.set(commandType, handler);
+    }
+
+    async execute(command) {
+        const handler = this.handlers.get(command.type);
+        if (!handler) {
+            throw new NotFoundError('Command handler', command.type);
+        }
+        return handler(command.payload);
+    }
+}
+
+module.exports = {
+    ValidateEvidenceCommand,
+    RunPreCommitCommand,
+    CheckGitFlowCommand,
+    UpdateEvidenceCommand,
+    RunAstAnalysisCommand,
+    CommandBus
+};

package/scripts/hooks-system/application/queries/index.js

@@ -0,0 +1,60 @@
+const { NotFoundError } = require('../../domain/errors');
+
+class GetEvidenceStatusQuery {
+    constructor() {
+        this.type = 'GET_EVIDENCE_STATUS';
+    }
+}
+
+class GetViolationsQuery {
+    constructor(filters = {}) {
+        this.type = 'GET_VIOLATIONS';
+        this.filters = filters;
+    }
+}
+
+class GetBranchInfoQuery {
+    constructor() {
+        this.type = 'GET_BRANCH_INFO';
+    }
+}
+
+class GetPlatformQuery {
+    constructor(filePath) {
+        this.type = 'GET_PLATFORM';
+        this.payload = { filePath };
+    }
+}
+
+class GetStagedFilesQuery {
+    constructor() {
+        this.type = 'GET_STAGED_FILES';
+    }
+}
+
+class QueryBus {
+    constructor() {
+        this.handlers = new Map();
+    }
+
+    register(queryType, handler) {
+        this.handlers.set(queryType, handler);
+    }
+
+    async execute(query) {
+        const handler = this.handlers.get(query.type);
+        if (!handler) {
+            throw new NotFoundError('Query handler', query.type);
+        }
+        return handler(query);
+    }
+}
+
+module.exports = {
+    GetEvidenceStatusQuery,
+    GetViolationsQuery,
+    GetBranchInfoQuery,
+    GetPlatformQuery,
+    GetStagedFilesQuery,
+    QueryBus
+};

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

@@ -0,0 +1,130 @@
+const PlatformDetectionService = require('./PlatformDetectionService');
+const { execSync } = require('child_process');
+const path = require('path');
+const UnifiedLogger = require('./logging/UnifiedLogger');
+
+class AutonomousOrchestrator {
+    constructor(contextEngine, platformDetector, rulesLoader, logger = new UnifiedLogger()) {
+        this.contextEngine = contextEngine;
+        this.platformDetector = platformDetector || new PlatformDetectionService();
+        this.rulesLoader = rulesLoader;
+        this.logger = logger;
+        this.confidenceThresholds = {
+            autoExecute: 30,
+            ignore: 0
+        };
+        this.lastAnalysis = null;
+        this.lastAnalysisTime = 0;
+    }
+
+    detectFromASTSystemFiles(files) {
+        try {
+            const PlatformHeuristics = require('./platform/PlatformHeuristics');
+            const heuristics = new PlatformHeuristics(this.platformDetector);
+            return heuristics.detectFromASTSystemFiles(files);
+        } catch (error) {
+            const msg = error && error.message ? error.message : String(error);
+            this.logger?.debug?.('ORCHESTRATOR_AST_SYSTEM_FILES_DETECTION_ERROR', { error: msg });
+            return [];
+        }
+    }
+
+    detectFromASTSystemFilesLegacy(files) {
+        return this.detectFromASTSystemFiles(files);
+    }
+
+    async analyzeContext() {
+        const platforms = await this.detectActivePlatforms();
+        const scores = await this.scoreConfidence(platforms);
+        const action = this.decideAction(scores);
+
+        this.lastAnalysis = { platforms, scores, action };
+        this.lastAnalysisTime = Date.now();
+
+        if (action.action !== 'ignore') {
+            this.logger.info('Autonomous context analysis completed', {
+                platforms: platforms,
+                topScore: scores[0] || null,
+                decision: action.action
+            });
+        }
+
+        return action;
+    }
+
+    async detectActivePlatforms() {
+        const context = await this.contextEngine.detectContext();
+        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 astPlatforms = this.detectFromASTSystemFiles(context.stagedFiles);
+        astPlatforms.forEach(p => detectedPlatforms.add(p));
+
+        const branchPlatforms = this.detectFromBranchKeywords(context.branchName);
+        branchPlatforms.forEach(p => detectedPlatforms.add(p));
+
+        if (context.stagedFiles && context.stagedFiles.includes('.AI_EVIDENCE.json')) {
+            const evidencePlatforms = this.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);
+    }
+
+    decideAction(scores) {
+        if (scores.length === 0) {
+            return {
+                action: 'ignore',
+                confidence: 0,
+                platforms: [],
+                reason: 'No platforms detected'
+            };
+        }
+
+        const topScore = scores[0];
+
+        if (topScore.confidence >= this.confidenceThresholds.autoExecute) {
+            return {
+                action: 'auto-execute',
+                confidence: topScore.confidence,
+                platforms: scores.filter(s => s.confidence >= this.confidenceThresholds.autoExecute),
+                reason: `Platform detected (${topScore.confidence}%) - auto-executing with notification`
+            };
+        }
+
+        return {
+            action: 'ignore',
+            confidence: topScore.confidence,
+            platforms: [],
+            reason: `No code files detected (${topScore.confidence}%) - ignoring`
+        };
+    }
+
+    shouldReanalyze() {
+        const timeSinceLastAnalysis = Date.now() - this.lastAnalysisTime;
+        return timeSinceLastAnalysis > 30000;
+    }
+
+    getLastAnalysis() {
+        return this.lastAnalysis;
+    }
+}
+
+module.exports = AutonomousOrchestrator;