agentic-qe 3.8.13 → 3.9.0

package/dist/workers/quality-daemon/index.js

@@ -0,0 +1,343 @@
+/**
+ * IMP-10: QE Quality Daemon — Orchestrator
+ *
+ * Central tick-loop that coordinates all daemon subsystems:
+ * - Priority queue processing
+ * - Git commit watching
+ * - Coverage delta analysis
+ * - CI/CD health monitoring
+ * - Test suggestion generation
+ * - Nightly consolidation (dream cycle)
+ * - Notification delivery
+ *
+ * Resource-aware: throttles when CPU > 70% or memory > 80%.
+ */
+import { cpus, freemem, totalmem, loadavg } from 'os';
+import { PriorityQueue } from './priority-queue';
+import { GitWatcher } from './git-watcher';
+import { CoverageDeltaAnalyzer } from './coverage-delta';
+import { CIMonitor } from './ci-monitor';
+import { TestSuggester } from './test-suggester';
+import { NightlyConsolidation } from './nightly-consolidation';
+import { NotificationService } from './notification-service';
+const DEFAULT_CONFIG = {
+    tickIntervalMs: 30_000,
+    ciPollIntervalMs: 5 * 60_000,
+    coverageCheckIntervalMs: 2 * 60_000,
+    cpuThreshold: 0.7,
+    memoryThreshold: 0.8,
+};
+export class QualityDaemon {
+    // Subsystems
+    queue;
+    gitWatcher;
+    coverageDelta;
+    ciMonitor;
+    testSuggester;
+    nightlyConsolidation;
+    notificationService;
+    // State
+    tickTimer;
+    _running = false;
+    _startedAt = 0;
+    _tickCount = 0;
+    _lastTickAt;
+    _throttled = false;
+    _commitsAnalyzed = 0;
+    _suggestionsGenerated = 0;
+    _ciHealth = 100;
+    _coverageHealth = 100;
+    _lastCICheck;
+    _lastCoverageCheck;
+    _memory;
+    // Config
+    config;
+    constructor(config) {
+        this.config = {
+            tickIntervalMs: config?.tickIntervalMs ?? DEFAULT_CONFIG.tickIntervalMs,
+            ciPollIntervalMs: config?.ciPollIntervalMs ?? DEFAULT_CONFIG.ciPollIntervalMs,
+            coverageCheckIntervalMs: config?.coverageCheckIntervalMs ?? DEFAULT_CONFIG.coverageCheckIntervalMs,
+            cpuThreshold: config?.cpuThreshold ?? DEFAULT_CONFIG.cpuThreshold,
+            memoryThreshold: config?.memoryThreshold ?? DEFAULT_CONFIG.memoryThreshold,
+        };
+        this.queue = new PriorityQueue();
+        this.gitWatcher = new GitWatcher(this.queue, config?.git);
+        this.coverageDelta = new CoverageDeltaAnalyzer(this.queue, config?.coverage);
+        this.ciMonitor = new CIMonitor(this.queue, config?.ci);
+        this.testSuggester = new TestSuggester(config?.suggestions);
+        this.nightlyConsolidation = new NightlyConsolidation(this.queue, config?.nightly);
+        this.notificationService = new NotificationService(config?.notifications);
+    }
+    get running() {
+        return this._running;
+    }
+    /**
+     * Start the quality daemon tick loop.
+     */
+    async start(memory) {
+        if (this._running)
+            return;
+        this._memory = memory;
+        this._running = true;
+        this._startedAt = Date.now();
+        // Initialize subsystems
+        this.notificationService.initialize();
+        await this.gitWatcher.start().catch((err) => {
+            console.debug('[QualityDaemon] Git watcher failed to start:', err);
+        });
+        // Start tick loop
+        this.scheduleTick();
+    }
+    /**
+     * Stop the quality daemon.
+     */
+    async stop() {
+        if (!this._running)
+            return;
+        this._running = false;
+        if (this.tickTimer) {
+            clearTimeout(this.tickTimer);
+            this.tickTimer = undefined;
+        }
+        this.gitWatcher.stop();
+        // Persist state
+        if (this._memory) {
+            await this._memory.set('quality-daemon:state', {
+                stoppedAt: Date.now(),
+                tickCount: this._tickCount,
+                commitsAnalyzed: this._commitsAnalyzed,
+                suggestionsGenerated: this._suggestionsGenerated,
+            });
+        }
+    }
+    /**
+     * Get daemon status.
+     */
+    getStatus() {
+        return {
+            running: this._running,
+            uptimeSeconds: this._running
+                ? Math.floor((Date.now() - this._startedAt) / 1000)
+                : 0,
+            tickCount: this._tickCount,
+            queueDepth: this.queue.depths,
+            lastTickAt: this._lastTickAt,
+            throttled: this._throttled,
+            commitsAnalyzed: this._commitsAnalyzed,
+            suggestionsGenerated: this._suggestionsGenerated,
+            notificationsSent: this.notificationService.sentCount,
+            ciHealth: this._ciHealth,
+            coverageHealth: this._coverageHealth,
+            lastCICheck: this._lastCICheck,
+            lastCoverageCheck: this._lastCoverageCheck,
+        };
+    }
+    // ============================================================================
+    // Tick Loop
+    // ============================================================================
+    scheduleTick() {
+        if (!this._running)
+            return;
+        this.tickTimer = setTimeout(() => this.tick(), this.config.tickIntervalMs);
+    }
+    async tick() {
+        if (!this._running || !this._memory)
+            return;
+        this._tickCount++;
+        this._lastTickAt = Date.now();
+        // Resource check
+        this._throttled = this.isResourceConstrained();
+        if (this._throttled) {
+            // Only process 'now' items when throttled
+            await this.processNowItems(this._memory);
+            this.scheduleTick();
+            return;
+        }
+        // Process queue items
+        await this.processQueue(this._memory);
+        // Periodic checks
+        await this.runPeriodicChecks(this._memory);
+        // Nightly consolidation
+        this.nightlyConsolidation.scheduleIfDue();
+        // Prune expired queue items
+        this.queue.pruneExpired();
+        this.scheduleTick();
+    }
+    async processQueue(memory) {
+        // Process up to 10 items per tick to avoid starving the loop
+        let processed = 0;
+        const maxPerTick = 10;
+        while (processed < maxPerTick && !this.queue.isEmpty) {
+            const item = this.queue.dequeue();
+            if (!item)
+                break;
+            await this.handleQueueItem(item, memory);
+            processed++;
+        }
+    }
+    async processNowItems(memory) {
+        const nowItems = this.queue.drainPriority('now');
+        for (const item of nowItems) {
+            await this.handleQueueItem(item, memory);
+        }
+    }
+    async handleQueueItem(item, memory) {
+        const payload = item.payload;
+        switch (payload.type) {
+            case 'git_commit':
+                this._commitsAnalyzed++;
+                // Trigger coverage analysis for changed files
+                const snapshot = await this.coverageDelta.buildSnapshot(memory);
+                if (snapshot) {
+                    const delta = await this.coverageDelta.analyze(snapshot, memory, payload.changedFiles);
+                    if (delta.regressionDetected) {
+                        await this.notificationService.send({
+                            type: 'coverage_drop',
+                            title: 'Coverage Regression Detected',
+                            message: `Line coverage delta: ${delta.overallDelta.line.toFixed(1)}% (${delta.affectedFiles.length} files affected)`,
+                            severity: 'high',
+                            metadata: { delta: delta.overallDelta, commit: payload.commitHash },
+                        });
+                    }
+                    if (delta.newGaps.length > 0) {
+                        const suggestions = await this.testSuggester.suggest(delta.newGaps, payload.changedFiles, memory);
+                        this._suggestionsGenerated += suggestions.length;
+                        if (suggestions.length > 0) {
+                            await this.notificationService.send({
+                                type: 'suggestion_available',
+                                title: 'New Test Suggestions Available',
+                                message: `${suggestions.length} test suggestions generated for uncovered code`,
+                                severity: 'info',
+                                metadata: { count: suggestions.length },
+                            });
+                        }
+                    }
+                }
+                break;
+            case 'coverage_delta': {
+                // coverage_delta items are enqueued by analyze() when regression/gaps
+                // are found. The analysis itself was already completed by the
+                // git_commit handler or periodic check that triggered it.
+                // Here we just ensure pending test suggestions are surfaced.
+                const pending = await this.testSuggester.getPending(memory);
+                if (pending.length > 0) {
+                    await this.notificationService.send({
+                        type: 'suggestion_available',
+                        title: 'Test Suggestions Pending',
+                        message: `${pending.length} test suggestions awaiting review`,
+                        severity: 'info',
+                        metadata: { count: pending.length },
+                    });
+                }
+                break;
+            }
+            case 'gate_failure':
+                await this.notificationService.send({
+                    type: 'gate_failure',
+                    title: `Quality Gate Failed: ${payload.gateName}`,
+                    message: `Score ${payload.score} below threshold ${payload.threshold}`,
+                    severity: 'critical',
+                    metadata: { gate: payload.gateName, score: payload.score, threshold: payload.threshold },
+                });
+                break;
+            case 'ci_failure':
+                await this.notificationService.send({
+                    type: 'ci_failure',
+                    title: `CI Failure: ${payload.workflowName}`,
+                    message: `Workflow ${payload.workflowName} run #${payload.runId} concluded: ${payload.conclusion}`,
+                    severity: 'high',
+                    metadata: { workflow: payload.workflowName, runId: payload.runId },
+                });
+                break;
+            case 'nightly': {
+                const stats = {
+                    coverageHealth: this._coverageHealth,
+                    ciHealth: this._ciHealth,
+                    commitsAnalyzed: this._commitsAnalyzed,
+                    suggestionsGenerated: this._suggestionsGenerated,
+                    notificationsSent: this.notificationService.sentCount,
+                    queueDepthAvg: this.queue.size,
+                    uptimeSeconds: Math.floor((Date.now() - this._startedAt) / 1000),
+                };
+                await this.nightlyConsolidation.execute(memory, stats);
+                break;
+            }
+            default: {
+                // Exhaustiveness check — TypeScript will error if a new payload type
+                // is added to DaemonTaskPayload without handling it here.
+                const _exhaustive = payload;
+                console.warn('[QualityDaemon] Unhandled payload type:', _exhaustive.type);
+            }
+        }
+    }
+    async runPeriodicChecks(memory) {
+        const now = Date.now();
+        // CI check
+        if (!this._lastCICheck ||
+            now - this._lastCICheck >= this.config.ciPollIntervalMs) {
+            try {
+                const report = await this.ciMonitor.check();
+                this._ciHealth = report.healthScore;
+                this._lastCICheck = now;
+                if (report.flakyWorkflows.length > 0) {
+                    await this.notificationService.send({
+                        type: 'flaky_detected',
+                        title: 'Flaky Workflows Detected',
+                        message: `${report.flakyWorkflows.length} workflows showing repeated failures: ${report.flakyWorkflows.join(', ')}`,
+                        severity: 'medium',
+                        metadata: { workflows: report.flakyWorkflows },
+                    });
+                }
+            }
+            catch {
+                // CI check failed, keep going
+            }
+        }
+        // Coverage health check — read-only metrics update.
+        // Full analysis is triggered by git commits; periodic check only updates
+        // the health score from the latest snapshot without re-running analyze()
+        // to avoid duplicate notifications.
+        if (!this._lastCoverageCheck ||
+            now - this._lastCoverageCheck >= this.config.coverageCheckIntervalMs) {
+            try {
+                const snapshot = await this.coverageDelta.buildSnapshot(memory);
+                if (snapshot) {
+                    this._coverageHealth = Math.round((snapshot.overall.line +
+                        snapshot.overall.branch +
+                        snapshot.overall.function +
+                        snapshot.overall.statement) /
+                        4);
+                    this._lastCoverageCheck = now;
+                }
+            }
+            catch {
+                // Coverage check failed, keep going
+            }
+        }
+    }
+    // ============================================================================
+    // Resource Awareness
+    // ============================================================================
+    isResourceConstrained() {
+        // Memory check
+        const memUsage = 1 - freemem() / totalmem();
+        if (memUsage > this.config.memoryThreshold)
+            return true;
+        // CPU check (rough heuristic via load average)
+        const cpuCount = cpus().length;
+        const load = cpuCount > 0 ? loadavg()[0] / cpuCount : 0;
+        if (load > this.config.cpuThreshold)
+            return true;
+        return false;
+    }
+}
+// Re-export subsystems
+export { PriorityQueue } from './priority-queue';
+export { GitWatcher } from './git-watcher';
+export { CoverageDeltaAnalyzer } from './coverage-delta';
+export { CIMonitor } from './ci-monitor';
+export { TestSuggester } from './test-suggester';
+export { NightlyConsolidation } from './nightly-consolidation';
+export { NotificationService } from './notification-service';
+export { PersistentWorkerMemory } from './persistent-memory';
+//# sourceMappingURL=index.js.map

package/dist/workers/quality-daemon/nightly-consolidation.d.ts

@@ -0,0 +1,74 @@
+/**
+ * IMP-10: QE Quality Daemon — Nightly Consolidation
+ *
+ * Runs the learning dream cycle:
+ * - Consolidates patterns from the day's experiences
+ * - Prunes expired memory entries
+ * - Generates a daily quality report
+ * - Enqueues as 'later' priority (runs during idle)
+ */
+import type { WorkerMemory } from '../interfaces';
+import type { PriorityQueue } from './priority-queue';
+export interface ConsolidationResult {
+    readonly timestamp: number;
+    readonly patternsConsolidated: number;
+    readonly entriesPruned: number;
+    readonly reportGenerated: boolean;
+    readonly durationMs: number;
+}
+export interface DailyQualityReport {
+    readonly date: string;
+    readonly coverageHealth: number;
+    readonly ciHealth: number;
+    readonly commitsAnalyzed: number;
+    readonly suggestionsGenerated: number;
+    readonly notificationsSent: number;
+    readonly queueDepthAvg: number;
+    readonly daemonUptime: number;
+}
+export interface NightlyConsolidationOptions {
+    /** Memory key prefix */
+    memoryPrefix?: string;
+    /** Max age for memory entries before pruning (ms) */
+    maxEntryAge?: number;
+    /** Hour to run nightly tasks (0-23, default 2 = 2 AM) */
+    nightlyHour?: number;
+}
+export declare class NightlyConsolidation {
+    private readonly queue;
+    private options;
+    private lastRunDate;
+    constructor(queue: PriorityQueue, options?: NightlyConsolidationOptions);
+    /**
+     * Check if nightly consolidation should run.
+     */
+    shouldRun(): boolean;
+    /**
+     * Schedule nightly consolidation into the queue.
+     */
+    scheduleIfDue(): boolean;
+    /**
+     * Execute the nightly consolidation cycle.
+     */
+    execute(memory: WorkerMemory, stats: DaemonStats): Promise<ConsolidationResult>;
+    /**
+     * Get the last consolidation result.
+     */
+    getLastResult(memory: WorkerMemory): Promise<ConsolidationResult | undefined>;
+    private consolidatePatterns;
+    private pruneExpired;
+    private generateReport;
+}
+/**
+ * Runtime stats passed from the daemon orchestrator.
+ */
+export interface DaemonStats {
+    coverageHealth?: number;
+    ciHealth?: number;
+    commitsAnalyzed?: number;
+    suggestionsGenerated?: number;
+    notificationsSent?: number;
+    queueDepthAvg?: number;
+    uptimeSeconds?: number;
+}
+//# sourceMappingURL=nightly-consolidation.d.ts.map

package/dist/workers/quality-daemon/nightly-consolidation.js

@@ -0,0 +1,136 @@
+/**
+ * IMP-10: QE Quality Daemon — Nightly Consolidation
+ *
+ * Runs the learning dream cycle:
+ * - Consolidates patterns from the day's experiences
+ * - Prunes expired memory entries
+ * - Generates a daily quality report
+ * - Enqueues as 'later' priority (runs during idle)
+ */
+const DEFAULTS = {
+    memoryPrefix: 'quality-daemon:nightly',
+    maxEntryAge: 7 * 24 * 60 * 60 * 1000, // 7 days
+    nightlyHour: 2,
+};
+export class NightlyConsolidation {
+    queue;
+    options;
+    lastRunDate;
+    constructor(queue, options) {
+        this.queue = queue;
+        this.options = { ...DEFAULTS, ...options };
+    }
+    /**
+     * Check if nightly consolidation should run.
+     */
+    shouldRun() {
+        const now = new Date();
+        const todayDate = now.toISOString().split('T')[0];
+        // Already ran today
+        if (this.lastRunDate === todayDate)
+            return false;
+        // Only run at or after the configured hour
+        return now.getHours() >= this.options.nightlyHour;
+    }
+    /**
+     * Schedule nightly consolidation into the queue.
+     */
+    scheduleIfDue() {
+        if (!this.shouldRun())
+            return false;
+        const payload = {
+            type: 'nightly',
+            tasks: ['consolidate_patterns', 'prune_expired', 'generate_report'],
+        };
+        const item = {
+            id: `nightly-${Date.now()}`,
+            priority: 'later',
+            payload,
+            createdAt: Date.now(),
+            source: 'nightly-consolidation',
+            ttlMs: 12 * 60 * 60 * 1000, // 12 hour TTL
+        };
+        return this.queue.enqueue(item);
+    }
+    /**
+     * Execute the nightly consolidation cycle.
+     */
+    async execute(memory, stats) {
+        const startTime = Date.now();
+        const todayDate = new Date().toISOString().split('T')[0];
+        // 1. Consolidate patterns
+        const patternsConsolidated = await this.consolidatePatterns(memory);
+        // 2. Prune expired entries
+        const entriesPruned = await this.pruneExpired(memory);
+        // 3. Generate daily report
+        const report = this.generateReport(todayDate, stats);
+        await memory.set(`${this.options.memoryPrefix}:report:${todayDate}`, report);
+        this.lastRunDate = todayDate;
+        const result = {
+            timestamp: Date.now(),
+            patternsConsolidated,
+            entriesPruned,
+            reportGenerated: true,
+            durationMs: Date.now() - startTime,
+        };
+        await memory.set(`${this.options.memoryPrefix}:last-result`, result);
+        return result;
+    }
+    /**
+     * Get the last consolidation result.
+     */
+    async getLastResult(memory) {
+        return memory.get(`${this.options.memoryPrefix}:last-result`);
+    }
+    // ============================================================================
+    // Private
+    // ============================================================================
+    async consolidatePatterns(memory) {
+        // Find all daemon-generated patterns from today
+        const keys = await memory.search('quality-daemon:*');
+        let consolidated = 0;
+        // Consolidate suggestion stats
+        const suggestionCount = await memory.get('quality-daemon:suggestions:count');
+        if (suggestionCount) {
+            consolidated++;
+        }
+        // Consolidate coverage deltas
+        const delta = await memory.get('quality-daemon:coverage:delta');
+        if (delta) {
+            consolidated++;
+        }
+        return consolidated;
+    }
+    async pruneExpired(memory) {
+        const keys = await memory.search('quality-daemon:*');
+        let pruned = 0;
+        const now = Date.now();
+        for (const key of keys) {
+            // Skip critical keys
+            if (key.endsWith(':snapshot') || key.endsWith(':list'))
+                continue;
+            const value = await memory.get(key);
+            if (value &&
+                typeof value.timestamp === 'number' &&
+                now - value.timestamp > this.options.maxEntryAge) {
+                // Mark as pruned (set to null equivalent)
+                await memory.set(key, { pruned: true, prunedAt: now });
+                pruned++;
+            }
+        }
+        return pruned;
+    }
+    generateReport(date, stats) {
+        return {
+            date,
+            coverageHealth: stats.coverageHealth ?? 0,
+            ciHealth: stats.ciHealth ?? 0,
+            commitsAnalyzed: stats.commitsAnalyzed ?? 0,
+            suggestionsGenerated: stats.suggestionsGenerated ?? 0,
+            notificationsSent: stats.notificationsSent ?? 0,
+            queueDepthAvg: stats.queueDepthAvg ?? 0,
+            daemonUptime: stats.uptimeSeconds ?? 0,
+        };
+    }
+}
+//# sourceMappingURL=nightly-consolidation.js.map

package/dist/workers/quality-daemon/notification-service.d.ts

@@ -0,0 +1,67 @@
+/**
+ * IMP-10: QE Quality Daemon — Notification Service
+ *
+ * Delivers notifications via:
+ * - File-based: JSON files in `.agentic-qe/notifications/`
+ * - Webhook: POST to configured URL (with IMP-07 SSRF protection)
+ *
+ * Notification types: gate_failure, coverage_drop, flaky_detected, suggestion_available
+ */
+export type NotificationType = 'gate_failure' | 'coverage_drop' | 'flaky_detected' | 'suggestion_available' | 'ci_failure' | 'daemon_health';
+export interface Notification {
+    readonly id: string;
+    readonly type: NotificationType;
+    readonly title: string;
+    readonly message: string;
+    readonly severity: 'critical' | 'high' | 'medium' | 'low' | 'info';
+    readonly timestamp: number;
+    readonly metadata?: Record<string, unknown>;
+    readonly read: boolean;
+}
+export interface NotificationServiceOptions {
+    /** Directory for file-based notifications */
+    notificationsDir?: string;
+    /** Maximum stored notifications (oldest pruned) */
+    maxNotifications?: number;
+    /** Webhook URL for push notifications (optional) */
+    webhookUrl?: string;
+    /** URL validator function (IMP-07 SSRF guard) */
+    urlValidator?: (url: string) => boolean;
+}
+export declare class NotificationService {
+    private notificationsDir;
+    private maxNotifications;
+    private webhookUrl;
+    private urlValidator;
+    private _sentCount;
+    constructor(options?: NotificationServiceOptions);
+    get sentCount(): number;
+    /**
+     * Initialize the notifications directory.
+     */
+    initialize(): void;
+    /**
+     * Send a notification.
+     */
+    send(notification: Omit<Notification, 'id' | 'timestamp' | 'read'>): Promise<Notification>;
+    /**
+     * List recent notifications.
+     */
+    list(options?: {
+        unreadOnly?: boolean;
+        limit?: number;
+        type?: NotificationType;
+    }): Notification[];
+    /**
+     * Mark a notification as read.
+     */
+    markRead(id: string): boolean;
+    /**
+     * Clear all notifications.
+     */
+    clear(): number;
+    private writeToFile;
+    private sendWebhook;
+    private pruneOldNotifications;
+}
+//# sourceMappingURL=notification-service.d.ts.map