agentic-qe 3.8.13 → 3.9.0

package/dist/workers/quality-daemon/coverage-delta.js

@@ -0,0 +1,135 @@
+/**
+ * IMP-10: QE Quality Daemon — Coverage Delta Analysis
+ *
+ * Compares current coverage with previous snapshot to identify:
+ * - Newly uncovered lines in changed files
+ * - Coverage regressions
+ * - Coverage gaps exceeding configurable thresholds
+ *
+ * Enqueues test suggestion tasks when gaps exceed threshold.
+ */
+const DEFAULTS = {
+    regressionThreshold: 2,
+    gapThreshold: 60,
+    memoryPrefix: 'quality-daemon:coverage',
+};
+export class CoverageDeltaAnalyzer {
+    queue;
+    options;
+    constructor(queue, options) {
+        this.queue = queue;
+        this.options = { ...DEFAULTS, ...options };
+    }
+    /**
+     * Analyze coverage delta between the current and previous snapshot.
+     * Stores the current snapshot and enqueues test suggestions if needed.
+     */
+    async analyze(current, memory, changedFiles) {
+        const previousRaw = await memory.get(`${this.options.memoryPrefix}:snapshot`);
+        // Store current snapshot for next comparison
+        await memory.set(`${this.options.memoryPrefix}:snapshot`, current);
+        if (!previousRaw) {
+            return {
+                regressionDetected: false,
+                overallDelta: { line: 0, branch: 0, function: 0, statement: 0 },
+                affectedFiles: [],
+                newGaps: [],
+            };
+        }
+        const previous = previousRaw;
+        const overallDelta = {
+            line: current.overall.line - previous.overall.line,
+            branch: current.overall.branch - previous.overall.branch,
+            function: current.overall.function - previous.overall.function,
+            statement: current.overall.statement - previous.overall.statement,
+        };
+        const regressionDetected = overallDelta.line < -this.options.regressionThreshold ||
+            overallDelta.branch < -this.options.regressionThreshold;
+        // Compute per-file deltas
+        const filesToCheck = changedFiles ?? Object.keys(current.files);
+        const affectedFiles = [];
+        const newGaps = [];
+        for (const file of filesToCheck) {
+            const curr = current.files[file];
+            const prev = previous.files[file];
+            if (!curr)
+                continue;
+            const lineDelta = prev ? curr.line - prev.line : 0;
+            const branchDelta = prev ? curr.branch - prev.branch : 0;
+            const newUncovered = prev
+                ? curr.uncoveredLines.filter((l) => !prev.uncoveredLines.includes(l))
+                : curr.uncoveredLines;
+            if (lineDelta !== 0 || branchDelta !== 0 || newUncovered.length > 0) {
+                affectedFiles.push({ file, lineDelta, branchDelta, newUncoveredLines: newUncovered });
+            }
+            if (curr.line < this.options.gapThreshold) {
+                const riskScore = this.computeRiskScore(curr, newUncovered.length);
+                newGaps.push({
+                    file,
+                    uncoveredLines: curr.uncoveredLines,
+                    currentCoverage: curr.line,
+                    riskScore,
+                });
+            }
+        }
+        // Enqueue test suggestion if regression or new gaps found
+        if (regressionDetected || newGaps.length > 0) {
+            this.enqueueTestSuggestion(current, previous, newGaps);
+        }
+        // Store delta result
+        await memory.set(`${this.options.memoryPrefix}:delta`, {
+            timestamp: Date.now(),
+            overallDelta,
+            regressionDetected,
+            affectedFileCount: affectedFiles.length,
+            gapCount: newGaps.length,
+        });
+        return { regressionDetected, overallDelta, affectedFiles, newGaps };
+    }
+    /**
+     * Build a CoverageSnapshot from raw lcov/istanbul data stored in memory.
+     */
+    async buildSnapshot(memory) {
+        const latest = await memory.get('coverage:latest');
+        if (!latest)
+            return undefined;
+        return {
+            timestamp: Date.now(),
+            overall: {
+                line: latest.line,
+                branch: latest.branch,
+                function: latest.function,
+                statement: latest.statement,
+            },
+            files: latest.files ?? {},
+        };
+    }
+    // ============================================================================
+    // Private
+    // ============================================================================
+    computeRiskScore(coverage, newUncoveredCount) {
+        // Higher risk = lower coverage + more new uncovered lines
+        // Clamp coverage to [0, 100] to prevent negative risk scores
+        const clampedCoverage = Math.min(100, Math.max(0, coverage.line));
+        const coverageFactor = 1 - clampedCoverage / 100;
+        const uncoveredFactor = Math.min(newUncoveredCount / 50, 1);
+        return Math.min(1, coverageFactor * 0.6 + uncoveredFactor * 0.4);
+    }
+    enqueueTestSuggestion(current, previous, gaps) {
+        const payload = {
+            type: 'coverage_delta',
+            previousSnapshot: `snapshot-${previous.timestamp}`,
+            currentSnapshot: `snapshot-${current.timestamp}`,
+        };
+        const item = {
+            id: `coverage-delta-${Date.now()}`,
+            priority: gaps.some((g) => g.riskScore > 0.8) ? 'now' : 'next',
+            payload,
+            createdAt: Date.now(),
+            source: 'coverage-delta',
+            ttlMs: 10 * 60 * 1000, // 10 min TTL
+        };
+        this.queue.enqueue(item);
+    }
+}
+//# sourceMappingURL=coverage-delta.js.map

package/dist/workers/quality-daemon/git-watcher.d.ts

@@ -0,0 +1,51 @@
+/**
+ * IMP-10: QE Quality Daemon — Git Watcher
+ *
+ * Watches `.git/refs/heads/` for new commits via fs.watch.
+ * Parses git log to determine changed files and enqueues
+ * 'next' priority analysis tasks into the daemon queue.
+ */
+import type { PriorityQueue } from './priority-queue';
+export interface GitWatcherOptions {
+    /** Root of the git repository (defaults to cwd) */
+    repoRoot?: string;
+    /** Debounce interval for fs.watch events (ms) */
+    debounceMs?: number;
+    /** Maximum number of changed files to track per commit */
+    maxChangedFiles?: number;
+    /** Polling interval in ms for platforms without recursive fs.watch (e.g. Linux). Default: 5000 */
+    pollIntervalMs?: number;
+}
+/**
+ * Watches git refs for new commits and enqueues analysis tasks.
+ */
+export declare class GitWatcher {
+    private readonly queue;
+    private watcher;
+    private pollTimer;
+    private options;
+    private lastKnownHeads;
+    private debounceTimer;
+    private _running;
+    private _polling;
+    constructor(queue: PriorityQueue, options?: GitWatcherOptions);
+    get running(): boolean;
+    /**
+     * Start watching git refs for changes.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop watching.
+     */
+    stop(): void;
+    /**
+     * Manual poll — useful for platforms where fs.watch is unreliable.
+     * Compares current HEAD hashes with last known and enqueues changes.
+     */
+    poll(): Promise<string[]>;
+    private handleRefChange;
+    private processRefChange;
+    private enqueueCommitAnalysis;
+    private snapshotHeads;
+}
+//# sourceMappingURL=git-watcher.d.ts.map

package/dist/workers/quality-daemon/git-watcher.js

@@ -0,0 +1,209 @@
+/**
+ * IMP-10: QE Quality Daemon — Git Watcher
+ *
+ * Watches `.git/refs/heads/` for new commits via fs.watch.
+ * Parses git log to determine changed files and enqueues
+ * 'next' priority analysis tasks into the daemon queue.
+ */
+import { watch } from 'fs';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { resolve, join } from 'path';
+import { existsSync, readFileSync } from 'fs';
+const execFileAsync = promisify(execFile);
+const DEFAULTS = {
+    repoRoot: process.cwd(),
+    debounceMs: 500,
+    maxChangedFiles: 200,
+    pollIntervalMs: 5000,
+};
+/**
+ * Watches git refs for new commits and enqueues analysis tasks.
+ */
+export class GitWatcher {
+    queue;
+    watcher;
+    pollTimer;
+    options;
+    lastKnownHeads = new Map();
+    debounceTimer;
+    _running = false;
+    _polling = false;
+    constructor(queue, options) {
+        this.queue = queue;
+        this.options = { ...DEFAULTS, ...options };
+    }
+    get running() {
+        return this._running;
+    }
+    /**
+     * Start watching git refs for changes.
+     */
+    async start() {
+        if (this._running)
+            return;
+        const refsDir = resolve(this.options.repoRoot, '.git', 'refs', 'heads');
+        if (!existsSync(refsDir)) {
+            throw new Error(`Git refs directory not found: ${refsDir}`);
+        }
+        // Snapshot current HEADs
+        await this.snapshotHeads();
+        // fs.watch({ recursive: true }) only works on macOS and Windows.
+        // On Linux, fall back to polling (Finding 3).
+        const supportsRecursive = process.platform === 'darwin' || process.platform === 'win32';
+        if (supportsRecursive) {
+            this.watcher = watch(refsDir, { recursive: true }, (_event, filename) => {
+                if (!filename)
+                    return;
+                this.handleRefChange(filename);
+            });
+        }
+        else {
+            // Linux: use git-based polling instead of unreliable fs.watch
+            this.pollTimer = setInterval(() => {
+                this.poll().catch((err) => {
+                    console.debug('[GitWatcher] Poll error:', err);
+                });
+            }, this.options.pollIntervalMs);
+        }
+        this._running = true;
+    }
+    /**
+     * Stop watching.
+     */
+    stop() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = undefined;
+        }
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = undefined;
+        }
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = undefined;
+        }
+        this._running = false;
+    }
+    /**
+     * Manual poll — useful for platforms where fs.watch is unreliable.
+     * Compares current HEAD hashes with last known and enqueues changes.
+     */
+    async poll() {
+        // Guard against concurrent poll + watch race condition
+        if (this._polling)
+            return [];
+        this._polling = true;
+        const changedBranches = [];
+        try {
+            const { stdout } = await execFileAsync('git', [
+                'for-each-ref',
+                '--format=%(refname:short) %(objectname:short)',
+                'refs/heads/',
+            ], { cwd: this.options.repoRoot });
+            for (const line of stdout.trim().split('\n')) {
+                if (!line)
+                    continue;
+                const [branch, hash] = line.split(' ');
+                const lastHash = this.lastKnownHeads.get(branch);
+                if (lastHash && lastHash !== hash) {
+                    changedBranches.push(branch);
+                    await this.enqueueCommitAnalysis(branch, hash);
+                }
+                this.lastKnownHeads.set(branch, hash);
+            }
+        }
+        catch {
+            // git not available or not a repo — silently skip
+        }
+        finally {
+            this._polling = false;
+        }
+        return changedBranches;
+    }
+    // ============================================================================
+    // Private
+    // ============================================================================
+    handleRefChange(filename) {
+        // Debounce rapid fs events (git writes multiple times per commit)
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+            this.processRefChange(filename).catch((err) => {
+                console.debug('[GitWatcher] Error processing ref change:', err);
+            });
+        }, this.options.debounceMs);
+    }
+    async processRefChange(filename) {
+        const branch = filename.replace(/\\/g, '/');
+        const refsDir = resolve(this.options.repoRoot, '.git', 'refs', 'heads');
+        const refFile = join(refsDir, filename);
+        let newHash;
+        try {
+            newHash = readFileSync(refFile, 'utf-8').trim();
+        }
+        catch {
+            return; // ref deleted or unreadable
+        }
+        const lastHash = this.lastKnownHeads.get(branch);
+        if (lastHash === newHash)
+            return; // no change
+        this.lastKnownHeads.set(branch, newHash);
+        await this.enqueueCommitAnalysis(branch, newHash);
+    }
+    async enqueueCommitAnalysis(branch, commitHash) {
+        let changedFiles = [];
+        try {
+            const { stdout } = await execFileAsync('git', [
+                'diff-tree',
+                '--no-commit-id',
+                '--name-only',
+                '-r',
+                commitHash,
+            ], { cwd: this.options.repoRoot });
+            changedFiles = stdout
+                .trim()
+                .split('\n')
+                .filter(Boolean)
+                .slice(0, this.options.maxChangedFiles);
+        }
+        catch {
+            // fallback: empty changed files list
+        }
+        const payload = {
+            type: 'git_commit',
+            branch,
+            commitHash,
+            changedFiles,
+        };
+        const item = {
+            id: `git-${commitHash}-${Date.now()}`,
+            priority: 'next',
+            payload,
+            createdAt: Date.now(),
+            source: 'git-watcher',
+            ttlMs: 5 * 60 * 1000, // 5 min TTL
+        };
+        this.queue.enqueue(item);
+    }
+    async snapshotHeads() {
+        try {
+            const { stdout } = await execFileAsync('git', [
+                'for-each-ref',
+                '--format=%(refname:short) %(objectname:short)',
+                'refs/heads/',
+            ], { cwd: this.options.repoRoot });
+            for (const line of stdout.trim().split('\n')) {
+                if (!line)
+                    continue;
+                const [branch, hash] = line.split(' ');
+                this.lastKnownHeads.set(branch, hash);
+            }
+        }
+        catch {
+            // not a git repo or git not available
+        }
+    }
+}
+//# sourceMappingURL=git-watcher.js.map

package/dist/workers/quality-daemon/index.d.ts

@@ -0,0 +1,119 @@
+/**
+ * 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 type { WorkerMemory } from '../interfaces';
+import { PriorityQueue } from './priority-queue';
+import { GitWatcher, type GitWatcherOptions } from './git-watcher';
+import { CoverageDeltaAnalyzer, type CoverageDeltaOptions } from './coverage-delta';
+import { CIMonitor, type CIMonitorOptions } from './ci-monitor';
+import { TestSuggester, type TestSuggesterOptions } from './test-suggester';
+import { NightlyConsolidation, type NightlyConsolidationOptions } from './nightly-consolidation';
+import { NotificationService, type NotificationServiceOptions } from './notification-service';
+export interface QualityDaemonConfig {
+    /** Tick interval in ms (default: 30s) */
+    tickIntervalMs?: number;
+    /** CI poll interval in ms (default: 5 min) */
+    ciPollIntervalMs?: number;
+    /** Coverage check interval in ms (default: 2 min) */
+    coverageCheckIntervalMs?: number;
+    /** CPU usage threshold to throttle (0-1, default: 0.7) */
+    cpuThreshold?: number;
+    /** Memory usage threshold to throttle (0-1, default: 0.8) */
+    memoryThreshold?: number;
+    /** Git watcher options */
+    git?: GitWatcherOptions;
+    /** Coverage delta options */
+    coverage?: CoverageDeltaOptions;
+    /** CI monitor options */
+    ci?: CIMonitorOptions;
+    /** Test suggester options */
+    suggestions?: TestSuggesterOptions;
+    /** Nightly consolidation options */
+    nightly?: NightlyConsolidationOptions;
+    /** Notification service options */
+    notifications?: NotificationServiceOptions;
+}
+export interface QualityDaemonStatus {
+    readonly running: boolean;
+    readonly uptimeSeconds: number;
+    readonly tickCount: number;
+    readonly queueDepth: {
+        now: number;
+        next: number;
+        later: number;
+    };
+    readonly lastTickAt: number | undefined;
+    readonly throttled: boolean;
+    readonly commitsAnalyzed: number;
+    readonly suggestionsGenerated: number;
+    readonly notificationsSent: number;
+    readonly ciHealth: number;
+    readonly coverageHealth: number;
+    readonly lastCICheck: number | undefined;
+    readonly lastCoverageCheck: number | undefined;
+}
+export declare class QualityDaemon {
+    readonly queue: PriorityQueue;
+    readonly gitWatcher: GitWatcher;
+    readonly coverageDelta: CoverageDeltaAnalyzer;
+    readonly ciMonitor: CIMonitor;
+    readonly testSuggester: TestSuggester;
+    readonly nightlyConsolidation: NightlyConsolidation;
+    readonly notificationService: NotificationService;
+    private tickTimer;
+    private _running;
+    private _startedAt;
+    private _tickCount;
+    private _lastTickAt;
+    private _throttled;
+    private _commitsAnalyzed;
+    private _suggestionsGenerated;
+    private _ciHealth;
+    private _coverageHealth;
+    private _lastCICheck;
+    private _lastCoverageCheck;
+    private _memory;
+    private config;
+    constructor(config?: QualityDaemonConfig);
+    get running(): boolean;
+    /**
+     * Start the quality daemon tick loop.
+     */
+    start(memory: WorkerMemory): Promise<void>;
+    /**
+     * Stop the quality daemon.
+     */
+    stop(): Promise<void>;
+    /**
+     * Get daemon status.
+     */
+    getStatus(): QualityDaemonStatus;
+    private scheduleTick;
+    private tick;
+    private processQueue;
+    private processNowItems;
+    private handleQueueItem;
+    private runPeriodicChecks;
+    private isResourceConstrained;
+}
+export { PriorityQueue } from './priority-queue';
+export type { QueueItem, QueuePriority, DaemonTaskPayload } 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.d.ts.map