agentic-qe 3.8.4 → 3.8.6

package/dist/cli/commands/hooks-handlers/command-hooks.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Agentic QE v3 - Command Hooks (guard, pre-command, post-command)
+ * ADR-021: QE ReasoningBank for Pattern Learning
+ *
+ * Handles file guardian and Bash command lifecycle hooks.
+ */
+import { Command } from 'commander';
+/**
+ * Register guard, pre-command, and post-command subcommands on the hooks command.
+ */
+export declare function registerCommandHooks(hooks: Command): void;
+//# sourceMappingURL=command-hooks.d.ts.map

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

@@ -0,0 +1,253 @@
+/**
+ * Agentic QE v3 - Command Hooks (guard, pre-command, post-command)
+ * ADR-021: QE ReasoningBank for Pattern Learning
+ *
+ * Handles file guardian and Bash command lifecycle hooks.
+ */
+import chalk from 'chalk';
+import path from 'node:path';
+import { QE_HOOK_EVENTS } from '../../../learning/qe-hooks.js';
+import { findProjectRoot } from '../../../kernel/unified-memory.js';
+import { getHooksSystem, createHybridBackendWithTimeout, incrementDreamExperience, persistCommandExperience, printJson, printSuccess, printError, } from './hooks-shared.js';
+/**
+ * Register guard, pre-command, and post-command subcommands on the hooks command.
+ */
+export function registerCommandHooks(hooks) {
+    // -------------------------------------------------------------------------
+    // guard: File guardian - block edits to protected files (PreToolUse)
+    // -------------------------------------------------------------------------
+    hooks
+        .command('guard')
+        .description('File guardian - block edits to protected files')
+        .requiredOption('-f, --file <path>', 'File path to check')
+        .option('--json', 'Output as JSON (required for hook API)')
+        .action(async (options) => {
+        try {
+            const filePath = options.file || '';
+            const normalizedPath = filePath.replace(/\\/g, '/');
+            // Protected file patterns
+            const protectedPatterns = [
+                { pattern: /^\.env($|\.)/, reason: 'Environment file contains secrets' },
+                { pattern: /\.env\.[a-zA-Z]+$/, reason: 'Environment file contains secrets' },
+                { pattern: /\.lock$/, reason: 'Lock files are auto-generated' },
+                { pattern: /(^|\/)node_modules\//, reason: 'node_modules is managed by package manager' },
+                { pattern: /(^|\/)\.agentic-qe\/memory\.db/, reason: 'AQE memory database must not be directly edited' },
+                { pattern: /(^|\/)\.agentic-qe\/memory\.db-wal$/, reason: 'AQE WAL file must not be directly edited' },
+                { pattern: /(^|\/)\.agentic-qe\/memory\.db-shm$/, reason: 'AQE shared memory file must not be directly edited' },
+            ];
+            const match = protectedPatterns.find(p => p.pattern.test(normalizedPath));
+            if (match) {
+                // Deny - use Claude Code hookSpecificOutput API format
+                if (options.json) {
+                    printJson({
+                        hookSpecificOutput: {
+                            hookEventName: 'PreToolUse',
+                            permissionDecision: 'deny',
+                            permissionDecisionReason: `Protected file: ${match.reason} (${filePath})`,
+                        },
+                    });
+                }
+                else {
+                    printError(`Blocked: ${match.reason} (${filePath})`);
+                }
+            }
+            else {
+                // Allow
+                if (options.json) {
+                    printJson({
+                        hookSpecificOutput: {
+                            hookEventName: 'PreToolUse',
+                            permissionDecision: 'allow',
+                        },
+                    });
+                }
+                else {
+                    printSuccess(`Allowed: ${filePath}`);
+                }
+            }
+            return;
+        }
+        catch (error) {
+            // On error, allow (fail-open for non-critical guard)
+            if (options.json) {
+                printJson({
+                    hookSpecificOutput: {
+                        hookEventName: 'PreToolUse',
+                        permissionDecision: 'allow',
+                    },
+                });
+            }
+            return;
+        }
+    });
+    // -------------------------------------------------------------------------
+    // pre-command: Get guidance before Bash command (called by PreToolUse hook)
+    // -------------------------------------------------------------------------
+    hooks
+        .command('pre-command')
+        .description('Get context before executing a Bash command')
+        .option('-c, --command <cmd>', 'Command to be executed')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const command = options.command || '';
+            // Dangerous command patterns that should be BLOCKED
+            const dangerousPatterns = [
+                { pattern: /rm\s+(-[a-zA-Z]*f[a-zA-Z]*\s+)?-[a-zA-Z]*r[a-zA-Z]*\s+\/(?!\w)/, reason: 'Recursive delete of root filesystem' },
+                { pattern: /rm\s+(-[a-zA-Z]*r[a-zA-Z]*\s+)?-[a-zA-Z]*f[a-zA-Z]*\s+\/(?!\w)/, reason: 'Recursive delete of root filesystem' },
+                { pattern: /rm\s+-rf\s+~/, reason: 'Recursive delete of home directory' },
+                { pattern: /DROP\s+(TABLE|DATABASE|SCHEMA)/i, reason: 'Destructive SQL operation' },
+                { pattern: /git\s+push\s+.*--force(?!-)/, reason: 'Force push can overwrite remote history' },
+                { pattern: /git\s+reset\s+--hard/, reason: 'Hard reset discards uncommitted changes' },
+                { pattern: />\s*\/dev\/sd[a-z]/, reason: 'Direct write to block device' },
+                { pattern: /dd\s+if=.*of=\/dev\/sd/, reason: 'Direct disk write via dd' },
+                { pattern: /chmod\s+777\s/, reason: 'World-writable permissions are a security risk' },
+                { pattern: /:\(\)\s*\{\s*:\|\s*:&\s*\}\s*;?\s*:/, reason: 'Fork bomb detected' },
+                { pattern: /mkfs\./, reason: 'Filesystem format operation' },
+                { pattern: />\s*\/dev\/null\s*2>&1\s*&\s*disown/, reason: 'Stealth background process' },
+            ];
+            // Warning patterns (inform but don't block)
+            const warningPatterns = [
+                { pattern: /\.agentic-qe.*rm/, reason: 'Deleting AQE data files' },
+                { pattern: /rm\s+-rf\s/, reason: 'Recursive force delete' },
+                { pattern: /git\s+clean\s+-[a-zA-Z]*f/, reason: 'Force cleaning untracked files' },
+            ];
+            const dangerMatch = dangerousPatterns.find(p => p.pattern.test(command));
+            const warnings = warningPatterns
+                .filter(p => p.pattern.test(command))
+                .map(p => p.reason);
+            if (dangerMatch) {
+                // BLOCK the command
+                if (options.json) {
+                    printJson({
+                        hookSpecificOutput: {
+                            hookEventName: 'PreToolUse',
+                            permissionDecision: 'deny',
+                            permissionDecisionReason: `Dangerous command blocked: ${dangerMatch.reason}`,
+                        },
+                    });
+                }
+                else {
+                    printError(`Blocked: ${dangerMatch.reason}`);
+                }
+            }
+            else {
+                // Allow (with optional warnings as context)
+                if (options.json) {
+                    const result = {
+                        hookSpecificOutput: {
+                            hookEventName: 'PreToolUse',
+                            permissionDecision: 'allow',
+                        },
+                    };
+                    if (warnings.length > 0) {
+                        result.hookSpecificOutput.additionalContext =
+                            `Warnings: ${warnings.join('; ')}`;
+                    }
+                    printJson(result);
+                }
+                else if (warnings.length > 0) {
+                    console.log(chalk.yellow('\n⚠️  Command Warnings:'));
+                    warnings.forEach(w => console.log(chalk.yellow(`  - ${w}`)));
+                }
+            }
+            return;
+        }
+        catch (error) {
+            // Fail-open on error
+            if (options.json) {
+                printJson({
+                    hookSpecificOutput: {
+                        hookEventName: 'PreToolUse',
+                        permissionDecision: 'allow',
+                    },
+                });
+            }
+            return;
+        }
+    });
+    // -------------------------------------------------------------------------
+    // post-command: Record command outcome (called by PostToolUse hook)
+    // -------------------------------------------------------------------------
+    hooks
+        .command('post-command')
+        .description('Record Bash command outcome')
+        .option('-c, --command <cmd>', 'Command that was executed')
+        .option('--success <bool>', 'Whether command succeeded', 'true')
+        .option('--exit-code <code>', 'Command exit code')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const success = options.success === 'true' || options.success === true;
+            const exitCode = options.exitCode ? parseInt(options.exitCode, 10) : (success ? 0 : 1);
+            const command = (options.command || '').substring(0, 200);
+            // Determine if this is a test/build/lint command for richer learning
+            const isTestCmd = /\b(test|vitest|jest|pytest|mocha)\b/i.test(command);
+            const isBuildCmd = /\b(build|compile|tsc)\b/i.test(command);
+            const isLintCmd = /\b(lint|eslint|prettier)\b/i.test(command);
+            let patternsLearned = 0;
+            let experienceRecorded = false;
+            try {
+                const { reasoningBank } = await getHooksSystem();
+                // For test commands, emit TestExecutionResult for pattern learning
+                if (isTestCmd) {
+                    const { hookRegistry } = await getHooksSystem();
+                    await hookRegistry.emit(QE_HOOK_EVENTS.TestExecutionResult, {
+                        runId: `cmd-${Date.now()}`,
+                        patternId: `cmd:test:${command.split(/\s+/).slice(0, 3).join('-')}`,
+                        passed: success ? 1 : 0,
+                        failed: success ? 0 : 1,
+                        duration: 0,
+                        flaky: false,
+                    });
+                }
+                // Record outcome for all commands
+                const cmdSlug = command.replace(/[^a-zA-Z0-9]/g, '-').slice(0, 80);
+                const domain = isTestCmd ? 'test-execution' : isBuildCmd ? 'code-intelligence' : isLintCmd ? 'quality-assessment' : 'code-intelligence';
+                await reasoningBank.recordOutcome({
+                    patternId: `cmd:${cmdSlug}`,
+                    success,
+                    metrics: { executionTimeMs: 0 },
+                    feedback: `Command: ${command}, exit: ${exitCode}`,
+                });
+                patternsLearned = 1;
+                // Persist as captured experience
+                await persistCommandExperience({
+                    task: `bash: ${command}`,
+                    agent: 'cli-hook',
+                    domain,
+                    success,
+                    source: 'cli-hook-post-command',
+                });
+                experienceRecorded = true;
+                // Increment dream experience counter
+                const projectRoot = findProjectRoot();
+                const dataDir = path.join(projectRoot, '.agentic-qe');
+                const memoryBackend = await createHybridBackendWithTimeout(dataDir);
+                await incrementDreamExperience(memoryBackend);
+            }
+            catch (initError) {
+                console.error(chalk.dim(`[hooks] post-command learning: ${initError instanceof Error ? initError.message : 'unknown'}`));
+            }
+            if (options.json) {
+                printJson({
+                    success: true,
+                    command: command.substring(0, 100),
+                    commandSuccess: success,
+                    exitCode,
+                    patternsLearned,
+                    experienceRecorded,
+                });
+            }
+            // Silent in non-JSON mode to avoid cluttering output
+            return;
+        }
+        catch (error) {
+            if (options.json) {
+                printJson({ success: false, error: error instanceof Error ? error.message : 'unknown' });
+            }
+            return;
+        }
+    });
+}
+//# sourceMappingURL=command-hooks.js.map

package/dist/cli/commands/hooks-handlers/editing-hooks.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Agentic QE v3 - Editing Hooks (pre-edit, post-edit)
+ * ADR-021: QE ReasoningBank for Pattern Learning
+ *
+ * Handles file editing lifecycle hooks for pattern learning.
+ */
+import { Command } from 'commander';
+/**
+ * Register pre-edit and post-edit subcommands on the hooks command.
+ */
+export declare function registerEditingHooks(hooks: Command): void;
+//# sourceMappingURL=editing-hooks.d.ts.map

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

@@ -0,0 +1,161 @@
+/**
+ * Agentic QE v3 - Editing Hooks (pre-edit, post-edit)
+ * ADR-021: QE ReasoningBank for Pattern Learning
+ *
+ * Handles file editing lifecycle hooks for pattern learning.
+ */
+import chalk from 'chalk';
+import path from 'node:path';
+import { QE_HOOK_EVENTS } from '../../../learning/qe-hooks.js';
+import { findProjectRoot } from '../../../kernel/unified-memory.js';
+import { getHooksSystem, createHybridBackendWithTimeout, incrementDreamExperience, persistCommandExperience, printJson, printSuccess, printError, printGuidance, } from './hooks-shared.js';
+/**
+ * Register pre-edit and post-edit subcommands on the hooks command.
+ */
+export function registerEditingHooks(hooks) {
+    // -------------------------------------------------------------------------
+    // pre-edit: Get guidance before editing a file
+    // -------------------------------------------------------------------------
+    hooks
+        .command('pre-edit')
+        .description('Get context and guidance before editing a file')
+        .requiredOption('-f, --file <path>', 'File path to edit')
+        .option('-o, --operation <type>', 'Operation type: create, update, delete, refactor', 'update')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const { hookRegistry } = await getHooksSystem();
+            const results = await hookRegistry.emit(QE_HOOK_EVENTS.PreTestGeneration, {
+                targetFile: options.file,
+                testType: 'unit',
+                operation: options.operation,
+            });
+            const result = results[0] || { success: true, guidance: [], routing: null };
+            if (options.json) {
+                // Build additionalContext for Claude from guidance
+                const guidanceLines = result.guidance || [];
+                const agentHint = result.routing?.recommendedAgent
+                    ? `Recommended agent: ${result.routing.recommendedAgent} (${(result.routing.confidence * 100).toFixed(0)}% confidence).`
+                    : '';
+                const contextStr = [
+                    agentHint,
+                    ...guidanceLines.map((g) => g),
+                ].filter(Boolean).join(' ');
+                printJson({
+                    hookSpecificOutput: {
+                        hookEventName: 'PreToolUse',
+                        additionalContext: contextStr || undefined,
+                    },
+                    file: options.file,
+                    operation: options.operation,
+                    patterns: result.routing?.patterns?.length || 0,
+                });
+            }
+            else {
+                console.log(chalk.bold('\n📝 Pre-Edit Analysis'));
+                console.log(chalk.dim(`  File: ${options.file}`));
+                console.log(chalk.dim(`  Operation: ${options.operation}`));
+                if (result.routing) {
+                    console.log(chalk.bold('\n🎯 Recommended Agent:'), chalk.cyan(result.routing.recommendedAgent));
+                    console.log(chalk.dim(`  Confidence: ${(result.routing.confidence * 100).toFixed(1)}%`));
+                }
+                console.log(chalk.bold('\n💡 Guidance:'));
+                printGuidance(result.guidance || []);
+            }
+            return;
+        }
+        catch (error) {
+            printError(`pre-edit failed: ${error instanceof Error ? error.message : 'unknown'}`);
+            throw error;
+        }
+    });
+    // -------------------------------------------------------------------------
+    // post-edit: Record editing outcome for learning
+    // -------------------------------------------------------------------------
+    hooks
+        .command('post-edit')
+        .description('Record editing outcome for pattern learning')
+        .requiredOption('-f, --file <path>', 'File path that was edited')
+        .option('--success', 'Edit was successful')
+        .option('--failure', 'Edit failed')
+        .option('--pattern-id <id>', 'Pattern ID that was applied')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const { hookRegistry } = await getHooksSystem();
+            const success = options.success || !options.failure;
+            // Generate synthetic patternId from file path if none provided
+            const filePath = options.file || '';
+            const fileName = filePath.split('/').pop() || 'unknown';
+            const isTestFile = /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(fileName);
+            const domain = isTestFile ? 'test-generation' : 'code-intelligence';
+            const syntheticPatternId = options.patternId || `edit:${domain}:${fileName}`;
+            const results = await hookRegistry.emit(QE_HOOK_EVENTS.PostTestGeneration, {
+                targetFile: options.file,
+                success,
+                patternId: syntheticPatternId,
+                generatedTests: null,
+                testCount: 0,
+            });
+            const result = results[0] || { success: true, patternsLearned: 0 };
+            // Also explicitly call recordOutcome so qe_pattern_usage gets a row
+            try {
+                const { reasoningBank } = await getHooksSystem();
+                await reasoningBank.recordOutcome({
+                    patternId: syntheticPatternId,
+                    success,
+                    metrics: { executionTimeMs: 0 },
+                    feedback: `Edit ${success ? 'succeeded' : 'failed'}: ${filePath}`,
+                });
+            }
+            catch {
+                // best-effort
+            }
+            // Persist as captured experience
+            try {
+                await persistCommandExperience({
+                    task: `edit: ${filePath}`,
+                    agent: 'cli-hook',
+                    domain,
+                    success,
+                    source: 'cli-hook-post-edit',
+                });
+            }
+            catch {
+                // best-effort
+            }
+            // Record experience for dream scheduler
+            let dreamTriggered = false;
+            try {
+                const projectRoot = findProjectRoot();
+                const dataDir = path.join(projectRoot, '.agentic-qe');
+                const memoryBackend = await createHybridBackendWithTimeout(dataDir);
+                await incrementDreamExperience(memoryBackend);
+            }
+            catch {
+                // best-effort
+            }
+            if (options.json) {
+                printJson({
+                    success: true,
+                    file: options.file,
+                    editSuccess: success,
+                    patternsLearned: result.patternsLearned || 0,
+                    dreamTriggered,
+                });
+            }
+            else {
+                printSuccess(`Recorded edit outcome for ${options.file}`);
+                if (result.patternsLearned) {
+                    console.log(chalk.green(`  Patterns learned: ${result.patternsLearned}`));
+                }
+            }
+            return;
+        }
+        catch (error) {
+            printError(`post-edit failed: ${error instanceof Error ? error.message : 'unknown'}`);
+            throw error;
+        }
+    });
+}
+//# sourceMappingURL=editing-hooks.js.map

package/dist/cli/commands/hooks-handlers/hooks-dream-learning.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Agentic QE v3 - Hooks Dream Scheduler & Learning Persistence
+ *
+ * Dream cycle scheduling, experience recording, and experience-to-pattern
+ * consolidation. Extracted from hooks-shared.ts to keep files under 500 lines.
+ */
+import type { MemoryBackend } from '../../../kernel/interfaces.js';
+export declare const DREAM_STATE_KEY = "dream-scheduler:hook-state";
+export declare const DREAM_INTERVAL_MS = 3600000;
+export declare const DREAM_EXPERIENCE_THRESHOLD = 20;
+export declare const DREAM_MIN_GAP_MS = 300000;
+export interface DreamHookState {
+    lastDreamTime: string | null;
+    experienceCount: number;
+    sessionStartTime: string;
+    totalDreamsThisSession: number;
+}
+/**
+ * Check if a dream cycle should be triggered and run it if so.
+ * Called from post-task hook after recording each experience.
+ *
+ * Trigger conditions (any of):
+ * 1. Time-based: >1hr since last dream
+ * 2. Experience-based: >20 experiences since last dream
+ *
+ * Guard: minimum 5 minutes between dreams
+ */
+export declare function checkAndTriggerDream(memoryBackend: MemoryBackend): Promise<{
+    triggered: boolean;
+    reason?: string;
+    insightsGenerated?: number;
+}>;
+/**
+ * Increment the experience counter in dream state.
+ * Called from post-task hook.
+ */
+export declare function incrementDreamExperience(memoryBackend: MemoryBackend): Promise<number>;
+/**
+ * Persist a command/edit experience directly to the captured_experiences table.
+ * CLI hooks cannot use the MCP middleware wrapper, so they write directly.
+ */
+export declare function persistCommandExperience(opts: {
+    task: string;
+    agent: string;
+    domain: string;
+    success: boolean;
+    durationMs?: number;
+    source: string;
+}): Promise<void>;
+/**
+ * Lightweight experience-to-pattern consolidation.
+ * Aggregates captured_experiences by domain+agent, and for clusters that meet
+ * quality thresholds, creates new qe_patterns entries.
+ * Called at session-end so patterns grow with each session.
+ */
+export declare function consolidateExperiencesToPatterns(): Promise<number>;
+//# sourceMappingURL=hooks-dream-learning.d.ts.map