agentic-qe 3.9.15 → 3.9.17

package/dist/cli/handlers/brain-handler.d.ts

@@ -16,6 +16,8 @@ export declare class BrainHandler implements ICommandHandler {
     private executeExport;
     private executeImport;
     private executeInfo;
+    private executeDiff;
+    private executeSearch;
     private executeWitnessBackfill;
     getHelp(): string;
 }

package/dist/cli/handlers/brain-handler.js

@@ -6,7 +6,7 @@
  */
 import path from 'path';
 import chalk from 'chalk';
-import { exportBrain, importBrain, brainInfo, witnessBackfill, } from '../brain-commands.js';
+import { exportBrain, importBrain, brainInfo, brainDiff, brainSearch, witnessBackfill, } from '../brain-commands.js';
 // ============================================================================
 // Brain Handler
 // ============================================================================
@@ -56,6 +56,32 @@ export class BrainHandler {
             .action(async (options) => {
             await this.executeWitnessBackfill(options);
         });
+        brain
+            .command('diff')
+            .description('Compare two brain exports (JSONL directory or .rvf file)')
+            .argument('<a>', 'Path to first brain export')
+            .argument('<b>', 'Path to second brain export')
+            .option('--table <name>', 'Restrict comparison to a single table')
+            .option('--verbose', 'Show the IDs of added/removed/changed records', false)
+            .option('--json', 'Emit the diff as JSON to stdout', false)
+            .action(async (a, b, options) => {
+            await this.executeDiff(a, b, options);
+        });
+        brain
+            .command('search')
+            .description('Search a JSONL brain export with filters')
+            .requiredOption('-i, --input <path>', 'Path to brain export directory (JSONL)')
+            .option('--table <name>', 'Table to search (default: qe_patterns)')
+            .option('--domain <name...>', 'Restrict to one or more domains')
+            .option('--pattern-type <type>', 'Restrict to a specific pattern_type (qe_patterns only)')
+            .option('--since <iso>', 'Include rows with timestamp ≥ <iso>')
+            .option('--until <iso>', 'Include rows with timestamp ≤ <iso>')
+            .option('-q, --query <text>', 'Substring match across name + description (case-insensitive)')
+            .option('-l, --limit <n>', 'Maximum results to return', '20')
+            .option('--json', 'Emit results as JSON to stdout', false)
+            .action(async (options) => {
+            await this.executeSearch(options);
+        });
     }
     async executeExport(options) {
         try {
@@ -224,6 +250,51 @@ export class BrainHandler {
             await this.cleanupAndExit(1);
         }
     }
+    async executeDiff(a, b, options) {
+        try {
+            const result = await brainDiff(path.resolve(a), path.resolve(b), {
+                tableFilter: options.table,
+            });
+            if (options.json) {
+                process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                await this.cleanupAndExit(result.identical ? 0 : 1);
+                return;
+            }
+            renderDiff(result, options.verbose);
+            // Exit code convention: 0 when identical, 1 when differences exist.
+            await this.cleanupAndExit(result.identical ? 0 : 1);
+        }
+        catch (error) {
+            console.error(chalk.red('\n  Brain diff failed:'), error);
+            await this.cleanupAndExit(2);
+        }
+    }
+    async executeSearch(options) {
+        try {
+            const limit = parseLimit(options.limit);
+            const domains = normalizeDomainOption(options.domain);
+            const result = await brainSearch(path.resolve(options.input), {
+                table: options.table,
+                domains,
+                patternType: options.patternType,
+                since: options.since,
+                until: options.until,
+                query: options.query,
+                limit,
+            });
+            if (options.json) {
+                process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                await this.cleanupAndExit(result.totalMatched > 0 ? 0 : 3);
+                return;
+            }
+            renderSearch(result);
+            await this.cleanupAndExit(result.totalMatched > 0 ? 0 : 3);
+        }
+        catch (error) {
+            console.error(chalk.red('\n  Brain search failed:'), error);
+            await this.cleanupAndExit(2);
+        }
+    }
     async executeWitnessBackfill(options) {
         try {
             console.log(chalk.blue('\n  Running witness chain backfill...\n'));
@@ -258,6 +329,8 @@ Subcommands:
   export    Export brain state to a portable .rvf file or JSONL directory
   import    Import a brain export into the local database
   info      Show manifest metadata for an existing brain export
+  diff      Compare two brain exports (manifest always; record-level for JSONL)
+  search    Filtered search over a JSONL brain export
 
 Examples:
   aqe brain export -o .agentic-qe/brain.rvf
@@ -266,6 +339,9 @@ Examples:
   aqe brain import -i .agentic-qe/brain.rvf --strategy latest-wins
   aqe brain import -i .agentic-qe/brain.rvf --dry-run
   aqe brain info -i .agentic-qe/brain.rvf
+  aqe brain diff ./brain-a ./brain-b --verbose
+  aqe brain search -i ./brain-export --query oauth --domain test-generation
+  aqe brain search -i ./brain-export --since 2026-03-01 --limit 50 --json
 `;
     }
 }
@@ -285,6 +361,150 @@ function formatBytes(bytes) {
         return `${(bytes / 1024).toFixed(1)} KB`;
     return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
+function parseLimit(raw) {
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || n < 1)
+        return 20;
+    return n;
+}
+function normalizeDomainOption(value) {
+    if (value === undefined)
+        return undefined;
+    const arr = Array.isArray(value) ? value : [value];
+    const out = [];
+    for (const raw of arr) {
+        for (const part of raw.split(',')) {
+            const trimmed = part.trim();
+            if (trimmed)
+                out.push(trimmed);
+        }
+    }
+    return out.length > 0 ? out : undefined;
+}
+function renderDiff(result, verbose) {
+    console.log(chalk.blue('\n  Brain Diff\n'));
+    console.log(`  A:            ${chalk.cyan(result.pathA)}  (${result.formatA})`);
+    console.log(`  B:            ${chalk.cyan(result.pathB)}  (${result.formatB})`);
+    console.log(`  Versions:     ${chalk.cyan(result.manifestA.version)} → ${chalk.cyan(result.manifestB.version)}` +
+        (result.versionMatch ? chalk.gray(' (match)') : chalk.yellow(' (differ)')));
+    console.log(`  Checksums:    ${chalk.gray(result.manifestA.checksum.slice(0, 12))}… → ` +
+        `${chalk.gray(result.manifestB.checksum.slice(0, 12))}…` +
+        (result.checksumMatch ? chalk.gray(' (match)') : chalk.yellow(' (differ)')));
+    console.log(`  Exported:     ${chalk.gray(result.manifestA.exportedAt)} → ${chalk.gray(result.manifestB.exportedAt)}`);
+    console.log(`  Records:      ${chalk.cyan(result.manifestA.totalRecords)} → ${chalk.cyan(result.manifestB.totalRecords)} ` +
+        formatDelta(result.manifestB.totalRecords - result.manifestA.totalRecords));
+    if (result.domainsOnlyInA.length > 0 || result.domainsOnlyInB.length > 0) {
+        console.log(chalk.blue('\n  Domains:'));
+        if (result.domainsOnlyInA.length > 0) {
+            console.log(`    Only in A: ${chalk.yellow(result.domainsOnlyInA.join(', '))}`);
+        }
+        if (result.domainsOnlyInB.length > 0) {
+            console.log(`    Only in B: ${chalk.yellow(result.domainsOnlyInB.join(', '))}`);
+        }
+    }
+    if (!result.recordLevel) {
+        console.log(chalk.gray('\n  Note: record-level diff is only available when both sides are JSONL exports.\n' +
+            '        Per-table counts shown below; re-export with --format jsonl for added/removed/changed IDs.'));
+    }
+    console.log(chalk.blue('\n  Tables:'));
+    const changed = result.tableDiffs.filter(tableHasChange);
+    if (changed.length === 0) {
+        console.log(chalk.gray('    (no differences)'));
+    }
+    else {
+        for (const t of changed) {
+            console.log(`    ${t.tableName.padEnd(28)} ${chalk.cyan(String(t.countA).padStart(7))} → ` +
+                `${chalk.cyan(String(t.countB).padStart(7))} ${formatDelta(t.delta)}` +
+                formatRecordBuckets(t, verbose));
+            if (verbose) {
+                if (t.added && t.added.length > 0)
+                    printIdBucket('added', t.added);
+                if (t.removed && t.removed.length > 0)
+                    printIdBucket('removed', t.removed);
+                if (t.changed && t.changed.length > 0)
+                    printIdBucket('changed', t.changed);
+            }
+        }
+    }
+    console.log('');
+    if (result.identical) {
+        console.log(chalk.green('  Result: identical\n'));
+    }
+    else {
+        console.log(chalk.yellow('  Result: differences found\n'));
+    }
+}
+function tableHasChange(t) {
+    if (t.delta !== 0)
+        return true;
+    if (t.added && t.added.length > 0)
+        return true;
+    if (t.removed && t.removed.length > 0)
+        return true;
+    if (t.changed && t.changed.length > 0)
+        return true;
+    return false;
+}
+function formatDelta(delta) {
+    if (delta === 0)
+        return chalk.gray('(±0)');
+    if (delta > 0)
+        return chalk.green(`(+${delta})`);
+    return chalk.red(`(${delta})`);
+}
+function formatRecordBuckets(t, verbose) {
+    const parts = [];
+    if (t.added && t.added.length > 0)
+        parts.push(chalk.green(`+${t.added.length}`));
+    if (t.removed && t.removed.length > 0)
+        parts.push(chalk.red(`-${t.removed.length}`));
+    if (t.changed && t.changed.length > 0)
+        parts.push(chalk.yellow(`~${t.changed.length}`));
+    if (parts.length === 0)
+        return '';
+    if (verbose)
+        return '  ' + parts.join(' ');
+    return '  ' + chalk.gray('[') + parts.join(' ') + chalk.gray(']');
+}
+function printIdBucket(label, ids) {
+    const preview = ids.slice(0, 10).join(', ');
+    const suffix = ids.length > 10 ? chalk.gray(` …(+${ids.length - 10} more)`) : '';
+    console.log(`      ${chalk.gray(label + ':')} ${preview}${suffix}`);
+}
+function renderSearch(result) {
+    console.log(chalk.blue('\n  Brain Search\n'));
+    console.log(`  Input:      ${chalk.cyan(result.inputPath)}`);
+    console.log(`  Table:      ${chalk.cyan(result.table)}`);
+    console.log(`  Scanned:    ${chalk.cyan(result.totalScanned)}    ` +
+        `Matched: ${chalk.cyan(result.totalMatched)}    ` +
+        `Shown: ${chalk.cyan(result.hits.length)}` +
+        (result.truncated ? chalk.yellow(` (truncated to limit ${result.limit})`) : ''));
+    if (result.hits.length === 0) {
+        console.log(chalk.yellow('\n  No matching rows.\n'));
+        return;
+    }
+    console.log('');
+    for (const hit of result.hits) {
+        const header = chalk.cyan(hit.id) +
+            (hit.display.patternType ? chalk.gray(`  ${hit.display.patternType}`) : '') +
+            (hit.display.domain ? chalk.gray(`  [${hit.display.domain}]`) : '') +
+            (hit.display.confidence !== undefined
+                ? chalk.gray(`  conf=${hit.display.confidence.toFixed(2)}`)
+                : '');
+        console.log(`  ${header}`);
+        if (hit.display.name)
+            console.log(`    ${chalk.bold(hit.display.name)}`);
+        if (hit.display.description) {
+            const desc = hit.display.description.length > 200
+                ? hit.display.description.slice(0, 200) + '…'
+                : hit.display.description;
+            console.log(`    ${chalk.gray(desc)}`);
+        }
+        if (hit.display.updatedAt)
+            console.log(`    ${chalk.gray(hit.display.updatedAt)}`);
+        console.log('');
+    }
+}
 // ============================================================================
 // Factory
 // ============================================================================

package/dist/cli/index.js

@@ -47,7 +47,6 @@ console.log = (...args) => {
     originalConsoleLog(...args);
 };
 // Also redirect timestamped INFO/WARN/ERROR log lines (e.g. "[07:12:24.372] [INFO ]")
-const originalConsoleInfo = console.info.bind(console);
 console.info = (...args) => {
     process.stderr.write(args.map(String).join(' ') + '\n');
 };
@@ -249,6 +248,11 @@ registerLazyCommand(program, {
     description: 'Generate shell completions for aqe',
     factory: () => import('./commands/completions.js').then(m => m.createCompletionsCommand(cleanupAndExit)),
 });
+registerLazyCommand(program, {
+    name: 'upgrade',
+    description: 'Detect optional native bindings and recommend install / flag changes',
+    factory: () => import('./commands/upgrade.js').then(m => m.createUpgradeCommand(cleanupAndExit)),
+});
 registerLazyCommand(program, {
     name: 'fleet',
     description: 'Fleet operations with multi-agent progress tracking',

package/dist/init/init-wizard-hooks.js

@@ -131,8 +131,11 @@ export async function configureHooks(projectRoot, config) {
             {
                 hooks: [
                     {
+                        // Claude Code delivers the prompt body on stdin as JSON
+                        // (e.g. {"prompt":"..."}). $PROMPT is NOT exposed as an env
+                        // var, so we let the CLI read stdin directly.
                         type: 'command',
-                        command: 'npx agentic-qe hooks route --task "$PROMPT" --json',
+                        command: 'npx agentic-qe hooks route --json',
                         timeout: 5000,
                         continueOnError: true,
                     },

package/dist/init/phases/07-hooks.js

@@ -489,8 +489,11 @@ if (process.argv.includes('--json')) process.stdout.write(JSON.stringify(result)
                 {
                     hooks: [
                         {
+                            // Claude Code delivers the prompt body on stdin as JSON
+                            // (e.g. {"prompt":"..."}). $PROMPT is NOT exposed as an env
+                            // var, so we let the CLI read stdin directly.
                             type: 'command',
-                            command: 'npx agentic-qe hooks route --task "$PROMPT" --json',
+                            command: 'npx agentic-qe hooks route --json',
                             timeout: 5000,
                             continueOnError: true,
                         },

package/dist/integrations/ruvector/brain-diff.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Brain Export Diff
+ *
+ * Compares two brain exports (JSONL directory or RVF file) and returns a
+ * structured diff.
+ *
+ * Two levels of comparison:
+ *   - Manifest-level (always available): version, checksum, per-table record
+ *     counts, exported_at, domain list delta.
+ *   - Record-level (JSONL exports only): for each table with a PK, the set of
+ *     added / removed / changed record IDs. For append-only tables only counts
+ *     are reported.
+ *
+ * For RVF exports, record-level diff is not supported by this module (the
+ * kernel is opaque without @ruvector/rvf-node). Export as JSONL for full diff.
+ */
+import { type TableExportConfig } from './brain-shared.js';
+export type ExportFormat = 'rvf' | 'jsonl';
+export interface ManifestSummary {
+    readonly format: ExportFormat;
+    readonly version: string;
+    readonly exportedAt: string;
+    readonly sourceDb: string;
+    readonly checksum: string;
+    readonly totalRecords: number;
+    readonly domains: readonly string[];
+    readonly tableRecordCounts: Record<string, number>;
+}
+export interface TableDiff {
+    readonly tableName: string;
+    readonly countA: number;
+    readonly countB: number;
+    readonly delta: number;
+    /** Only populated for JSONL↔JSONL record-level diffs on PK tables. */
+    readonly added?: readonly string[];
+    readonly removed?: readonly string[];
+    readonly changed?: readonly string[];
+}
+export interface BrainDiffResult {
+    readonly pathA: string;
+    readonly pathB: string;
+    readonly formatA: ExportFormat;
+    readonly formatB: ExportFormat;
+    readonly manifestA: ManifestSummary;
+    readonly manifestB: ManifestSummary;
+    readonly checksumMatch: boolean;
+    readonly versionMatch: boolean;
+    readonly identical: boolean;
+    readonly recordLevel: boolean;
+    readonly tableDiffs: readonly TableDiff[];
+    readonly domainsOnlyInA: readonly string[];
+    readonly domainsOnlyInB: readonly string[];
+}
+export interface BrainDiffOptions {
+    /** Restrict comparison to a single table (by table name). */
+    readonly tableFilter?: string;
+    /** Cap on the number of IDs retained per added/removed/changed list. */
+    readonly maxIdsPerBucket?: number;
+}
+/**
+ * Compute the diff between two brain exports.
+ *
+ * Both paths may be JSONL directories or `.rvf` files. Record-level diff is
+ * only available when both sides are JSONL.
+ */
+export declare function diffBrains(pathA: string, pathB: string, options?: BrainDiffOptions): BrainDiffResult;
+declare function pkFor(config: TableExportConfig): string;
+/**
+ * Read a JSONL file and build a Map<identity, contentHash>.
+ *
+ * For PK tables the identity is the PK column value. For append-only tables
+ * the identity is a concatenation of the dedup columns (collisions are
+ * treated as "same record").
+ */
+declare function buildIdentityMap(filePath: string, config: TableExportConfig): Map<string, string>;
+declare function identityOf(row: Record<string, unknown>, config: TableExportConfig): string | undefined;
+declare function stableStringify(obj: Record<string, unknown>): string;
+export interface DiffSummary {
+    readonly tablesChanged: number;
+    readonly totalAdded: number;
+    readonly totalRemoved: number;
+    readonly totalChanged: number;
+    readonly recordCountDelta: number;
+}
+export declare function summarizeDiff(result: BrainDiffResult): DiffSummary;
+export declare const __test__: {
+    stableStringify: typeof stableStringify;
+    identityOf: typeof identityOf;
+    buildIdentityMap: typeof buildIdentityMap;
+    pkFor: typeof pkFor;
+};
+export {};
+//# sourceMappingURL=brain-diff.d.ts.map