agentic-qe 3.8.13 → 3.9.0

package/dist/workers/quality-daemon/notification-service.js

@@ -0,0 +1,178 @@
+/**
+ * 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
+ */
+import { writeFileSync, mkdirSync, readdirSync, readFileSync, unlinkSync } from 'fs';
+import { join, resolve } from 'path';
+const DEFAULTS = {
+    notificationsDir: resolve(process.cwd(), '.agentic-qe', 'notifications'),
+    maxNotifications: 200,
+};
+export class NotificationService {
+    notificationsDir;
+    maxNotifications;
+    webhookUrl;
+    urlValidator;
+    _sentCount = 0;
+    constructor(options) {
+        this.notificationsDir = options?.notificationsDir ?? DEFAULTS.notificationsDir;
+        this.maxNotifications = options?.maxNotifications ?? DEFAULTS.maxNotifications;
+        this.webhookUrl = options?.webhookUrl;
+        this.urlValidator = options?.urlValidator;
+    }
+    get sentCount() {
+        return this._sentCount;
+    }
+    /**
+     * Initialize the notifications directory.
+     */
+    initialize() {
+        mkdirSync(this.notificationsDir, { recursive: true });
+    }
+    /**
+     * Send a notification.
+     */
+    async send(notification) {
+        const full = {
+            ...notification,
+            id: `notif-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            timestamp: Date.now(),
+            read: false,
+        };
+        // File-based delivery
+        this.writeToFile(full);
+        // Webhook delivery (if configured)
+        if (this.webhookUrl) {
+            await this.sendWebhook(full);
+        }
+        this._sentCount++;
+        this.pruneOldNotifications();
+        return full;
+    }
+    /**
+     * List recent notifications.
+     */
+    list(options) {
+        const limit = options?.limit ?? 50;
+        try {
+            const files = readdirSync(this.notificationsDir)
+                .filter((f) => f.endsWith('.json'))
+                .sort()
+                .reverse(); // newest first
+            const notifications = [];
+            for (const file of files) {
+                if (notifications.length >= limit)
+                    break;
+                try {
+                    const content = readFileSync(join(this.notificationsDir, file), 'utf-8');
+                    const notif = JSON.parse(content);
+                    if (options?.unreadOnly && notif.read)
+                        continue;
+                    if (options?.type && notif.type !== options.type)
+                        continue;
+                    notifications.push(notif);
+                }
+                catch {
+                    // corrupt file, skip
+                }
+            }
+            return notifications;
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Mark a notification as read.
+     */
+    markRead(id) {
+        try {
+            // Exact suffix match to prevent substring collisions (Finding 4)
+            const files = readdirSync(this.notificationsDir).filter((f) => f.endsWith(`-${id}.json`));
+            if (files.length === 0)
+                return false;
+            const filePath = join(this.notificationsDir, files[0]);
+            const content = JSON.parse(readFileSync(filePath, 'utf-8'));
+            const updated = { ...content, read: true };
+            writeFileSync(filePath, JSON.stringify(updated, null, 2));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Clear all notifications.
+     */
+    clear() {
+        try {
+            const files = readdirSync(this.notificationsDir).filter((f) => f.endsWith('.json'));
+            for (const file of files) {
+                unlinkSync(join(this.notificationsDir, file));
+            }
+            return files.length;
+        }
+        catch {
+            return 0;
+        }
+    }
+    // ============================================================================
+    // Private
+    // ============================================================================
+    writeToFile(notification) {
+        try {
+            mkdirSync(this.notificationsDir, { recursive: true });
+            const filename = `${notification.timestamp}-${notification.id}.json`;
+            const filePath = join(this.notificationsDir, filename);
+            writeFileSync(filePath, JSON.stringify(notification, null, 2));
+        }
+        catch (err) {
+            console.debug('[NotificationService] Failed to write notification:', err);
+        }
+    }
+    async sendWebhook(notification) {
+        if (!this.webhookUrl)
+            return;
+        // IMP-07 SSRF guard: validate URL before sending
+        if (this.urlValidator && !this.urlValidator(this.webhookUrl)) {
+            console.warn('[NotificationService] Webhook URL blocked by SSRF guard:', this.webhookUrl);
+            return;
+        }
+        try {
+            const response = await fetch(this.webhookUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(notification),
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!response.ok) {
+                console.debug(`[NotificationService] Webhook returned ${response.status}`);
+            }
+        }
+        catch (err) {
+            console.debug('[NotificationService] Webhook delivery failed:', err);
+        }
+    }
+    pruneOldNotifications() {
+        try {
+            const files = readdirSync(this.notificationsDir)
+                .filter((f) => f.endsWith('.json'))
+                .sort();
+            if (files.length <= this.maxNotifications)
+                return;
+            const toRemove = files.slice(0, files.length - this.maxNotifications);
+            for (const file of toRemove) {
+                unlinkSync(join(this.notificationsDir, file));
+            }
+        }
+        catch {
+            // best-effort pruning
+        }
+    }
+}
+//# sourceMappingURL=notification-service.js.map

package/dist/workers/quality-daemon/persistent-memory.d.ts

@@ -0,0 +1,31 @@
+/**
+ * IMP-10: QE Quality Daemon — Persistent WorkerMemory Adapter
+ *
+ * Bridges the WorkerMemory interface to the unified SQLite persistence
+ * layer (UnifiedMemoryManager). All daemon state is persisted to the
+ * `quality-daemon` namespace in kv_store, surviving restarts.
+ *
+ * Resolves Finding 2: CLI daemon previously used throwaway in-memory Map.
+ */
+import type { WorkerMemory } from '../interfaces';
+/**
+ * Interface matching the subset of UnifiedMemoryManager we need,
+ * to avoid circular dependency on the full kernel module.
+ */
+export interface KVBackend {
+    kvGet<T>(key: string, namespace?: string): Promise<T | undefined>;
+    kvSet(key: string, value: unknown, namespace?: string, ttl?: number): Promise<void>;
+    kvSearch(pattern: string, namespace?: string, limit?: number): Promise<string[]>;
+}
+/**
+ * WorkerMemory backed by unified SQLite persistence.
+ * All keys are stored in the 'quality-daemon' namespace.
+ */
+export declare class PersistentWorkerMemory implements WorkerMemory {
+    private readonly backend;
+    constructor(backend: KVBackend);
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    search(pattern: string): Promise<string[]>;
+}
+//# sourceMappingURL=persistent-memory.d.ts.map

package/dist/workers/quality-daemon/persistent-memory.js

@@ -0,0 +1,30 @@
+/**
+ * IMP-10: QE Quality Daemon — Persistent WorkerMemory Adapter
+ *
+ * Bridges the WorkerMemory interface to the unified SQLite persistence
+ * layer (UnifiedMemoryManager). All daemon state is persisted to the
+ * `quality-daemon` namespace in kv_store, surviving restarts.
+ *
+ * Resolves Finding 2: CLI daemon previously used throwaway in-memory Map.
+ */
+const NAMESPACE = 'quality-daemon';
+/**
+ * WorkerMemory backed by unified SQLite persistence.
+ * All keys are stored in the 'quality-daemon' namespace.
+ */
+export class PersistentWorkerMemory {
+    backend;
+    constructor(backend) {
+        this.backend = backend;
+    }
+    async get(key) {
+        return this.backend.kvGet(key, NAMESPACE);
+    }
+    async set(key, value) {
+        await this.backend.kvSet(key, value, NAMESPACE);
+    }
+    async search(pattern) {
+        return this.backend.kvSearch(pattern, NAMESPACE);
+    }
+}
+//# sourceMappingURL=persistent-memory.js.map

package/dist/workers/quality-daemon/priority-queue.d.ts

@@ -0,0 +1,97 @@
+/**
+ * IMP-10: QE Quality Daemon — Priority Queue
+ *
+ * 3-level priority queue for daemon task scheduling:
+ * - 'now':   Quality gate failures, critical alerts (processed immediately)
+ * - 'next':  New commits, coverage changes (processed on next tick)
+ * - 'later': Nightly consolidation, pattern pruning (processed during idle)
+ */
+export type QueuePriority = 'now' | 'next' | 'later';
+export interface QueueItem<T = unknown> {
+    readonly id: string;
+    readonly priority: QueuePriority;
+    readonly payload: T;
+    readonly createdAt: number;
+    readonly source: string;
+    /** Max age in ms before the item is discarded as stale */
+    readonly ttlMs?: number;
+}
+/**
+ * Typed payloads for known daemon task types.
+ */
+export interface GitCommitPayload {
+    readonly type: 'git_commit';
+    readonly branch: string;
+    readonly commitHash: string;
+    readonly changedFiles: string[];
+}
+export interface CoverageDeltaPayload {
+    readonly type: 'coverage_delta';
+    readonly previousSnapshot: string;
+    readonly currentSnapshot: string;
+}
+export interface GateFailurePayload {
+    readonly type: 'gate_failure';
+    readonly gateName: string;
+    readonly score: number;
+    readonly threshold: number;
+}
+export interface NightlyPayload {
+    readonly type: 'nightly';
+    readonly tasks: string[];
+}
+export interface CIFailurePayload {
+    readonly type: 'ci_failure';
+    readonly workflowName: string;
+    readonly runId: number;
+    readonly conclusion: string;
+}
+export type DaemonTaskPayload = GitCommitPayload | CoverageDeltaPayload | GateFailurePayload | NightlyPayload | CIFailurePayload;
+/**
+ * A bounded, 3-level priority queue with optional TTL expiry.
+ */
+export declare class PriorityQueue<T = DaemonTaskPayload> {
+    private queues;
+    private _maxSize;
+    constructor(maxSize?: number);
+    /**
+     * Enqueue an item at the given priority level.
+     * Returns false if queue is full.
+     */
+    enqueue(item: QueueItem<T>): boolean;
+    /**
+     * Dequeue the highest-priority item.
+     * Within a priority level, FIFO order is maintained.
+     * Stale items (past TTL) are silently skipped.
+     */
+    dequeue(): QueueItem<T> | undefined;
+    /**
+     * Peek at the next item without removing it.
+     */
+    peek(): QueueItem<T> | undefined;
+    /**
+     * Drain all items at a specific priority level.
+     */
+    drainPriority(priority: QueuePriority): QueueItem<T>[];
+    /**
+     * Remove all expired items across all queues.
+     */
+    pruneExpired(): number;
+    /**
+     * Total number of items across all priority levels.
+     */
+    get size(): number;
+    /**
+     * Per-priority counts.
+     */
+    get depths(): Record<QueuePriority, number>;
+    /**
+     * Whether there are any items queued.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Clear all items.
+     */
+    clear(): void;
+}
+//# sourceMappingURL=priority-queue.d.ts.map

package/dist/workers/quality-daemon/priority-queue.js

@@ -0,0 +1,126 @@
+/**
+ * IMP-10: QE Quality Daemon — Priority Queue
+ *
+ * 3-level priority queue for daemon task scheduling:
+ * - 'now':   Quality gate failures, critical alerts (processed immediately)
+ * - 'next':  New commits, coverage changes (processed on next tick)
+ * - 'later': Nightly consolidation, pattern pruning (processed during idle)
+ */
+const PRIORITY_ORDER = {
+    now: 0,
+    next: 1,
+    later: 2,
+};
+/**
+ * A bounded, 3-level priority queue with optional TTL expiry.
+ */
+export class PriorityQueue {
+    queues = {
+        now: [],
+        next: [],
+        later: [],
+    };
+    _maxSize;
+    constructor(maxSize = 1000) {
+        this._maxSize = maxSize;
+    }
+    /**
+     * Enqueue an item at the given priority level.
+     * Returns false if queue is full.
+     */
+    enqueue(item) {
+        if (this.size >= this._maxSize) {
+            return false;
+        }
+        this.queues[item.priority].push(item);
+        return true;
+    }
+    /**
+     * Dequeue the highest-priority item.
+     * Within a priority level, FIFO order is maintained.
+     * Stale items (past TTL) are silently skipped.
+     */
+    dequeue() {
+        const now = Date.now();
+        for (const priority of ['now', 'next', 'later']) {
+            const queue = this.queues[priority];
+            while (queue.length > 0) {
+                const item = queue.shift();
+                if (item.ttlMs && now - item.createdAt > item.ttlMs) {
+                    continue; // expired, skip
+                }
+                return item;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Peek at the next item without removing it.
+     */
+    peek() {
+        const now = Date.now();
+        for (const priority of ['now', 'next', 'later']) {
+            const queue = this.queues[priority];
+            for (const item of queue) {
+                if (!item.ttlMs || now - item.createdAt <= item.ttlMs) {
+                    return item;
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Drain all items at a specific priority level.
+     */
+    drainPriority(priority) {
+        const items = this.queues[priority].splice(0);
+        const now = Date.now();
+        return items.filter((item) => !item.ttlMs || now - item.createdAt <= item.ttlMs);
+    }
+    /**
+     * Remove all expired items across all queues.
+     */
+    pruneExpired() {
+        let pruned = 0;
+        const now = Date.now();
+        for (const priority of ['now', 'next', 'later']) {
+            const before = this.queues[priority].length;
+            this.queues[priority] = this.queues[priority].filter((item) => !item.ttlMs || now - item.createdAt <= item.ttlMs);
+            pruned += before - this.queues[priority].length;
+        }
+        return pruned;
+    }
+    /**
+     * Total number of items across all priority levels.
+     */
+    get size() {
+        return (this.queues.now.length +
+            this.queues.next.length +
+            this.queues.later.length);
+    }
+    /**
+     * Per-priority counts.
+     */
+    get depths() {
+        return {
+            now: this.queues.now.length,
+            next: this.queues.next.length,
+            later: this.queues.later.length,
+        };
+    }
+    /**
+     * Whether there are any items queued.
+     */
+    get isEmpty() {
+        return this.size === 0;
+    }
+    /**
+     * Clear all items.
+     */
+    clear() {
+        this.queues.now = [];
+        this.queues.next = [];
+        this.queues.later = [];
+    }
+}
+//# sourceMappingURL=priority-queue.js.map

package/dist/workers/quality-daemon/test-suggester.d.ts

@@ -0,0 +1,50 @@
+/**
+ * IMP-10: QE Quality Daemon — Test Suggester
+ *
+ * Analyzes uncovered code from coverage delta and generates
+ * test case suggestions. Stores suggestions in memory for
+ * retrieval via MCP tools.
+ */
+import type { WorkerMemory } from '../interfaces';
+import type { CoverageGap } from './coverage-delta';
+export interface TestSuggestion {
+    readonly id: string;
+    readonly file: string;
+    readonly uncoveredLines: number[];
+    readonly suggestedTestType: 'unit' | 'integration' | 'e2e';
+    readonly description: string;
+    readonly priority: 'high' | 'medium' | 'low';
+    readonly estimatedEffort: 'small' | 'medium' | 'large';
+    readonly createdAt: number;
+    readonly status: 'pending' | 'accepted' | 'dismissed';
+}
+export interface TestSuggesterOptions {
+    /** Memory key prefix for storing suggestions */
+    memoryPrefix?: string;
+    /** Maximum suggestions to store */
+    maxSuggestions?: number;
+    /** Minimum risk score to generate a suggestion */
+    minRiskScore?: number;
+}
+export declare class TestSuggester {
+    private options;
+    constructor(options?: TestSuggesterOptions);
+    /**
+     * Generate test suggestions from coverage gaps.
+     */
+    suggest(gaps: CoverageGap[], changedFiles: string[], memory: WorkerMemory): Promise<TestSuggestion[]>;
+    /**
+     * Retrieve pending suggestions from memory.
+     */
+    getPending(memory: WorkerMemory): Promise<TestSuggestion[]>;
+    /**
+     * Update the status of a suggestion.
+     */
+    updateStatus(id: string, status: 'accepted' | 'dismissed', memory: WorkerMemory): Promise<boolean>;
+    private determinePriority;
+    private determineTestType;
+    private estimateEffort;
+    private generateDescription;
+    private storeSuggestions;
+}
+//# sourceMappingURL=test-suggester.d.ts.map

package/dist/workers/quality-daemon/test-suggester.js

@@ -0,0 +1,121 @@
+/**
+ * IMP-10: QE Quality Daemon — Test Suggester
+ *
+ * Analyzes uncovered code from coverage delta and generates
+ * test case suggestions. Stores suggestions in memory for
+ * retrieval via MCP tools.
+ */
+const DEFAULTS = {
+    memoryPrefix: 'quality-daemon:suggestions',
+    maxSuggestions: 100,
+    minRiskScore: 0.3,
+};
+export class TestSuggester {
+    options;
+    constructor(options) {
+        this.options = { ...DEFAULTS, ...options };
+    }
+    /**
+     * Generate test suggestions from coverage gaps.
+     */
+    async suggest(gaps, changedFiles, memory) {
+        const suggestions = [];
+        // Filter gaps by minimum risk score
+        const significantGaps = gaps.filter((g) => g.riskScore >= this.options.minRiskScore);
+        for (const gap of significantGaps) {
+            const isChanged = changedFiles.includes(gap.file);
+            const priority = this.determinePriority(gap, isChanged);
+            const testType = this.determineTestType(gap.file);
+            const effort = this.estimateEffort(gap);
+            suggestions.push({
+                id: `suggestion-${Date.now()}-${suggestions.length}`,
+                file: gap.file,
+                uncoveredLines: gap.uncoveredLines.slice(0, 50), // cap line list
+                suggestedTestType: testType,
+                description: this.generateDescription(gap, testType),
+                priority,
+                estimatedEffort: effort,
+                createdAt: Date.now(),
+                status: 'pending',
+            });
+        }
+        // Sort by priority (high first)
+        suggestions.sort((a, b) => {
+            const order = { high: 0, medium: 1, low: 2 };
+            return order[a.priority] - order[b.priority];
+        });
+        // Cap to max
+        const capped = suggestions.slice(0, this.options.maxSuggestions);
+        // Store in memory
+        await this.storeSuggestions(capped, memory);
+        return capped;
+    }
+    /**
+     * Retrieve pending suggestions from memory.
+     */
+    async getPending(memory) {
+        const stored = await memory.get(`${this.options.memoryPrefix}:list`);
+        return (stored ?? []).filter((s) => s.status === 'pending');
+    }
+    /**
+     * Update the status of a suggestion.
+     */
+    async updateStatus(id, status, memory) {
+        const stored = await memory.get(`${this.options.memoryPrefix}:list`);
+        if (!stored)
+            return false;
+        const idx = stored.findIndex((s) => s.id === id);
+        if (idx === -1)
+            return false;
+        // Create updated list (immutable pattern)
+        const updated = stored.map((s, i) => i === idx ? { ...s, status } : s);
+        await memory.set(`${this.options.memoryPrefix}:list`, updated);
+        return true;
+    }
+    // ============================================================================
+    // Private
+    // ============================================================================
+    determinePriority(gap, isRecentlyChanged) {
+        if (gap.riskScore > 0.8)
+            return 'high';
+        if (isRecentlyChanged || gap.riskScore > 0.5)
+            return 'medium';
+        return 'low';
+    }
+    determineTestType(file) {
+        if (file.includes('/api/') || file.includes('/routes/') || file.includes('/handlers/')) {
+            return 'integration';
+        }
+        if (file.includes('/e2e/') || file.includes('/pages/') || file.includes('/views/')) {
+            return 'e2e';
+        }
+        return 'unit';
+    }
+    estimateEffort(gap) {
+        if (gap.uncoveredLines.length <= 10)
+            return 'small';
+        if (gap.uncoveredLines.length <= 50)
+            return 'medium';
+        return 'large';
+    }
+    generateDescription(gap, testType) {
+        const lineCount = gap.uncoveredLines.length;
+        const coverage = Math.round(gap.currentCoverage);
+        return (`Add ${testType} tests for ${gap.file} ` +
+            `(${lineCount} uncovered lines, ${coverage}% coverage, ` +
+            `risk ${(gap.riskScore * 100).toFixed(0)}%)`);
+    }
+    async storeSuggestions(suggestions, memory) {
+        // Merge with existing suggestions (keep dismissed/accepted, replace pending)
+        const existing = await memory.get(`${this.options.memoryPrefix}:list`);
+        const kept = (existing ?? []).filter((s) => s.status !== 'pending');
+        const merged = [...kept, ...suggestions].slice(-this.options.maxSuggestions);
+        await memory.set(`${this.options.memoryPrefix}:list`, merged);
+        await memory.set(`${this.options.memoryPrefix}:count`, {
+            pending: suggestions.length,
+            total: merged.length,
+            lastUpdated: Date.now(),
+        });
+    }
+}
+//# sourceMappingURL=test-suggester.js.map

package/dist/workers/worker-manager.js

@@ -55,7 +55,8 @@ class InMemoryWorkerMemory {
         this.store.set(key, value);
     }
     async search(pattern) {
-        const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+        const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(escaped.replace(/\*/g, '.*'));
         return Array.from(this.store.keys()).filter((key) => regex.test(key));
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-qe",
-  "version": "3.8.13",
+  "version": "3.9.0",
   "description": "Agentic Quality Engineering V3 - Domain-Driven Design Architecture with 13 Bounded Contexts, O(log n) coverage analysis, ReasoningBank learning, 60 specialized QE agents, mathematical Coherence verification, deep Claude Flow integration",
   "type": "module",
   "main": "./dist/index.js",