agentic-qe 3.8.13 → 3.9.0

package/dist/cli/commands/daemon.js

@@ -0,0 +1,224 @@
+/**
+ * Agentic QE v3 - Daemon CLI Commands (IMP-10)
+ *
+ * Commands for managing the QE Quality Daemon:
+ *   aqe daemon start [--detached]
+ *   aqe daemon stop
+ *   aqe daemon status
+ *   aqe daemon notifications [--unread] [--limit N] [--type TYPE]
+ *   aqe daemon clear-notifications
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { QualityDaemon } from '../../workers/quality-daemon';
+import { PersistentWorkerMemory } from '../../workers/quality-daemon/persistent-memory';
+import { isPrivateIp } from '../../hooks/security/ssrf-guard';
+// In-process daemon instance (non-detached mode)
+let activeDaemon;
+export function createDaemonCommand() {
+    const daemon = new Command('daemon')
+        .description('Manage the QE Quality Daemon')
+        .addHelpText('after', `
+Examples:
+  aqe daemon start               Start daemon in foreground
+  aqe daemon stop                Stop running daemon
+  aqe daemon status              Show daemon health and queue depth
+  aqe daemon notifications       List recent notifications
+  aqe daemon clear-notifications Clear all notifications
+`);
+    // --- start ---
+    daemon
+        .command('start')
+        .description('Start the QE Quality Daemon')
+        .option('--tick-interval <ms>', 'Tick interval in milliseconds', '30000')
+        .option('--ci-interval <ms>', 'CI poll interval in milliseconds', '300000')
+        .action(async (options) => {
+        if (activeDaemon?.running) {
+            console.log(chalk.yellow('Daemon is already running'));
+            const status = activeDaemon.getStatus();
+            console.log(chalk.gray(`  Uptime: ${status.uptimeSeconds}s, Ticks: ${status.tickCount}`));
+            return;
+        }
+        const config = {
+            tickIntervalMs: parseInt(options.tickInterval, 10),
+            ciPollIntervalMs: parseInt(options.ciInterval, 10),
+            notifications: {
+                // IMP-07 SSRF guard for webhook URLs (Finding 5)
+                urlValidator: (url) => {
+                    try {
+                        const parsed = new URL(url);
+                        const hostname = parsed.hostname.replace(/^\[|\]$/g, '');
+                        return !isPrivateIp(hostname);
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+            },
+        };
+        activeDaemon = new QualityDaemon(config);
+        // Use persistent SQLite-backed memory when available, fall back to in-memory
+        let memory;
+        try {
+            const { UnifiedMemoryManager } = await import('../../kernel/unified-memory.js');
+            const unifiedMemory = await UnifiedMemoryManager.getInstanceAsync();
+            memory = new PersistentWorkerMemory(unifiedMemory);
+            console.log(chalk.gray('  Storage: SQLite (persistent)'));
+        }
+        catch {
+            // Fallback for environments where kernel isn't available
+            const store = new Map();
+            memory = {
+                async get(key) { return store.get(key); },
+                async set(key, value) { store.set(key, value); },
+                async search(pattern) {
+                    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+                    const regex = new RegExp(escaped.replace(/\*/g, '.*'));
+                    return Array.from(store.keys()).filter((k) => regex.test(k));
+                },
+            };
+            console.log(chalk.yellow('  Storage: in-memory (no SQLite available, state will not persist)'));
+        }
+        console.log(chalk.green('Starting QE Quality Daemon...'));
+        await activeDaemon.start(memory);
+        console.log(chalk.green('QE Quality Daemon started'));
+        console.log(chalk.gray(`  Tick interval: ${config.tickIntervalMs}ms`));
+        console.log(chalk.gray(`  CI poll interval: ${config.ciPollIntervalMs}ms`));
+        console.log(chalk.gray(`  PID: ${process.pid}`));
+        console.log(chalk.gray('\n  Press Ctrl+C to stop'));
+        // Keep process alive
+        const keepAlive = setInterval(() => {
+            if (!activeDaemon?.running) {
+                clearInterval(keepAlive);
+            }
+        }, 5000);
+        // Graceful shutdown
+        const shutdown = async () => {
+            console.log(chalk.yellow('\nStopping QE Quality Daemon...'));
+            await activeDaemon?.stop();
+            clearInterval(keepAlive);
+            console.log(chalk.green('Daemon stopped'));
+            process.exit(0);
+        };
+        process.once('SIGINT', shutdown);
+        process.once('SIGTERM', shutdown);
+    });
+    // --- stop ---
+    daemon
+        .command('stop')
+        .description('Stop the QE Quality Daemon')
+        .action(async () => {
+        if (!activeDaemon?.running) {
+            console.log(chalk.yellow('No running daemon found'));
+            return;
+        }
+        await activeDaemon.stop();
+        console.log(chalk.green('Daemon stopped'));
+        activeDaemon = undefined;
+    });
+    // --- status ---
+    daemon
+        .command('status')
+        .description('Show daemon health and queue status')
+        .action(() => {
+        if (!activeDaemon) {
+            console.log(chalk.yellow('No daemon instance (start with: aqe daemon start)'));
+            return;
+        }
+        const s = activeDaemon.getStatus();
+        console.log(chalk.bold('\nQE Quality Daemon Status'));
+        console.log(chalk.gray('─'.repeat(40)));
+        console.log(`  Running:     ${s.running ? chalk.green('yes') : chalk.red('no')}`);
+        console.log(`  Uptime:      ${formatUptime(s.uptimeSeconds)}`);
+        console.log(`  Ticks:       ${s.tickCount}`);
+        console.log(`  Throttled:   ${s.throttled ? chalk.yellow('yes') : chalk.green('no')}`);
+        console.log(chalk.bold('\n  Queue Depth'));
+        console.log(`    Now:       ${s.queueDepth.now}`);
+        console.log(`    Next:      ${s.queueDepth.next}`);
+        console.log(`    Later:     ${s.queueDepth.later}`);
+        console.log(chalk.bold('\n  Health'));
+        console.log(`    CI:        ${healthColor(s.ciHealth)}${s.ciHealth}%${chalk.reset('')}`);
+        console.log(`    Coverage:  ${healthColor(s.coverageHealth)}${s.coverageHealth}%${chalk.reset('')}`);
+        console.log(chalk.bold('\n  Activity'));
+        console.log(`    Commits:   ${s.commitsAnalyzed}`);
+        console.log(`    Suggestions: ${s.suggestionsGenerated}`);
+        console.log(`    Notifications: ${s.notificationsSent}`);
+        console.log();
+    });
+    // --- notifications ---
+    daemon
+        .command('notifications')
+        .description('List recent notifications')
+        .option('--unread', 'Show only unread notifications')
+        .option('--limit <n>', 'Maximum notifications to show', '20')
+        .option('--type <type>', 'Filter by type (gate_failure, coverage_drop, flaky_detected, etc.)')
+        .action((options) => {
+        if (!activeDaemon) {
+            console.log(chalk.yellow('No daemon instance'));
+            return;
+        }
+        const notifications = activeDaemon.notificationService.list({
+            unreadOnly: options.unread,
+            limit: parseInt(options.limit, 10),
+            type: options.type,
+        });
+        if (notifications.length === 0) {
+            console.log(chalk.gray('No notifications'));
+            return;
+        }
+        console.log(chalk.bold(`\nNotifications (${notifications.length})`));
+        console.log(chalk.gray('─'.repeat(60)));
+        for (const n of notifications) {
+            const icon = severityIcon(n.severity);
+            const time = new Date(n.timestamp).toLocaleString();
+            const readMark = n.read ? chalk.gray('✓') : chalk.yellow('●');
+            console.log(`${readMark} ${icon} ${chalk.bold(n.title)}`);
+            console.log(`    ${n.message}`);
+            console.log(chalk.gray(`    ${time} [${n.type}]`));
+            console.log();
+        }
+    });
+    // --- clear-notifications ---
+    daemon
+        .command('clear-notifications')
+        .description('Clear all notifications')
+        .action(() => {
+        if (!activeDaemon) {
+            console.log(chalk.yellow('No daemon instance'));
+            return;
+        }
+        const count = activeDaemon.notificationService.clear();
+        console.log(chalk.green(`Cleared ${count} notifications`));
+    });
+    return daemon;
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+function formatUptime(seconds) {
+    if (seconds < 60)
+        return `${seconds}s`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    return `${h}h ${m}m`;
+}
+function healthColor(score) {
+    if (score >= 80)
+        return chalk.green('');
+    if (score >= 60)
+        return chalk.yellow('');
+    return chalk.red('');
+}
+function severityIcon(severity) {
+    switch (severity) {
+        case 'critical': return chalk.red('!!');
+        case 'high': return chalk.red('!');
+        case 'medium': return chalk.yellow('~');
+        case 'low': return chalk.blue('-');
+        case 'info': return chalk.gray('i');
+        default: return ' ';
+    }
+}
+//# sourceMappingURL=daemon.js.map

package/dist/cli/commands/hooks-handlers/hooks-shared.js

@@ -165,7 +165,8 @@ export function createInMemoryBackend() {
         },
         has: async (key) => store.has(key),
         search: async (pattern, _limit) => {
-            const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+            const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+            const regex = new RegExp(escaped.replace(/\*/g, '.*'));
             return Array.from(store.keys()).filter((k) => regex.test(k));
         },
         vectorSearch: async (_embedding, _k) => {

package/dist/cli/commands/plugin.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Agentic QE v3 - Plugin CLI Commands (IMP-09)
+ *
+ * Commands for managing external QE domain plugins:
+ *   aqe plugin install <location> [--source local|github|npm]
+ *   aqe plugin list
+ *   aqe plugin remove <name> [--version <ver>]
+ *   aqe plugin info <name>
+ */
+import { Command } from 'commander';
+export declare function createPluginCommand(): Command;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/cli/commands/plugin.js

@@ -0,0 +1,135 @@
+/**
+ * Agentic QE v3 - Plugin CLI Commands (IMP-09)
+ *
+ * Commands for managing external QE domain plugins:
+ *   aqe plugin install <location> [--source local|github|npm]
+ *   aqe plugin list
+ *   aqe plugin remove <name> [--version <ver>]
+ *   aqe plugin info <name>
+ */
+import { Command } from 'commander';
+import { PluginLifecycleManager } from '../../plugins/lifecycle';
+import { PluginCache } from '../../plugins/cache';
+import { GitHubPluginSource } from '../../plugins/sources/github';
+import { NpmPluginSource } from '../../plugins/sources/npm';
+// ============================================================================
+// Plugin Command
+// ============================================================================
+export function createPluginCommand() {
+    const manager = createManager();
+    const plugin = new Command('plugin')
+        .description('Manage external QE domain plugins')
+        .addHelpText('after', `
+Examples:
+  aqe plugin install ./my-plugin          Install from local directory
+  aqe plugin install owner/repo --source github   Install from GitHub
+  aqe plugin install aqe-plugin-sap --source npm  Install from npm
+  aqe plugin list                         List installed plugins
+  aqe plugin remove my-plugin             Remove a plugin
+  aqe plugin info my-plugin               Show plugin details
+`);
+    // --- install ---
+    plugin
+        .command('install <location>')
+        .description('Install a QE plugin from a local directory, GitHub repo, or npm package')
+        .option('-s, --source <type>', 'Source type: local, github, npm', 'local')
+        .action(async (location, options) => {
+        try {
+            console.log(`Installing plugin from ${options.source}: ${location}...`);
+            const result = await manager.install(location, options.source);
+            if (result.success) {
+                console.log(`\n  Plugin installed successfully!`);
+                console.log(`  Name:    ${result.manifest.name}`);
+                console.log(`  Version: ${result.manifest.version}`);
+                console.log(`  Domains: ${result.manifest.domains.join(', ')}`);
+                console.log(`  Cache:   ${result.cachePath}\n`);
+            }
+            else {
+                console.error(`\n  Installation failed:`);
+                for (const err of result.errors) {
+                    console.error(`    - ${err}`);
+                }
+                if (result.securityViolations.length > 0) {
+                    console.error(`\n  Security violations:`);
+                    for (const v of result.securityViolations) {
+                        console.error(`    - ${v}`);
+                    }
+                }
+                process.exitCode = 1;
+            }
+        }
+        catch (err) {
+            console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+            process.exitCode = 1;
+        }
+    });
+    // --- list ---
+    plugin
+        .command('list')
+        .description('List installed QE plugins')
+        .action(() => {
+        const plugins = manager.list();
+        if (plugins.length === 0) {
+            console.log('\n  No plugins installed.\n');
+            console.log('  Install one with: aqe plugin install <location>\n');
+            return;
+        }
+        console.log(`\n  Installed plugins (${plugins.length}):\n`);
+        for (const p of plugins) {
+            console.log(`  ${p.name}@${p.version}`);
+            console.log(`    ${p.description}`);
+            console.log(`    Domains: ${p.domains.join(', ')}`);
+            console.log('');
+        }
+    });
+    // --- remove ---
+    plugin
+        .command('remove <name>')
+        .description('Remove an installed QE plugin')
+        .option('-v, --version <version>', 'Remove specific version (default: all)')
+        .action((name, options) => {
+        const removed = manager.remove(name, options.version);
+        if (removed) {
+            const versionStr = options.version ? `@${options.version}` : ' (all versions)';
+            console.log(`\n  Removed: ${name}${versionStr}\n`);
+        }
+        else {
+            console.log(`\n  Plugin not found: ${name}\n`);
+            process.exitCode = 1;
+        }
+    });
+    // --- info ---
+    plugin
+        .command('info <name>')
+        .description('Show detailed info about an installed plugin')
+        .action((name) => {
+        const plugins = manager.list().filter(p => p.name === name);
+        if (plugins.length === 0) {
+            console.log(`\n  Plugin not found: ${name}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        const p = plugins[0];
+        console.log(`\n  Plugin: ${p.name}`);
+        console.log(`  Version:     ${p.version}`);
+        console.log(`  Description: ${p.description}`);
+        console.log(`  Domains:     ${p.domains.join(', ')}`);
+        console.log(`  Source:      ${p.source}`);
+        console.log(`  Cache:       ${p.cachePath}\n`);
+    });
+    return plugin;
+}
+// ============================================================================
+// Internal
+// ============================================================================
+function createManager() {
+    const cache = new PluginCache();
+    return new PluginLifecycleManager({
+        cache,
+        sources: [
+            new GitHubPluginSource(),
+            new NpmPluginSource(),
+        ],
+    });
+}
+//# sourceMappingURL=plugin.js.map

package/dist/cli/commands/workflow.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Agentic QE v3 - Workflow Command (ADR-041)
+ *
+ * Extracted from index.ts to enable lazy loading.
+ * Manages QE workflows and pipelines.
+ */
+import { Command } from 'commander';
+import { CLIContext } from '../handlers/interfaces.js';
+export declare function createWorkflowCommand(context: CLIContext, cleanupAndExit: (code: number) => Promise<never>, ensureInitialized: () => Promise<boolean>): Command;
+//# sourceMappingURL=workflow.d.ts.map