agentic-qe 3.9.15 → 3.9.16

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/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

package/dist/integrations/ruvector/brain-diff.js

@@ -0,0 +1,281 @@
+/**
+ * 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 { existsSync, readFileSync, statSync } from 'fs';
+import { join, resolve } from 'path';
+import { safeJsonParse } from '../../shared/safe-json.js';
+import { brainInfoFromRvf } from './brain-rvf-exporter.js';
+import { readJsonl, sha256, TABLE_CONFIGS, PK_COLUMNS, } from './brain-shared.js';
+// ============================================================================
+// Public API
+// ============================================================================
+/**
+ * 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 function diffBrains(pathA, pathB, options = {}) {
+    const resolvedA = resolve(pathA);
+    const resolvedB = resolve(pathB);
+    const formatA = detectFormat(resolvedA);
+    const formatB = detectFormat(resolvedB);
+    const manifestA = readManifestSummary(resolvedA, formatA);
+    const manifestB = readManifestSummary(resolvedB, formatB);
+    const recordLevel = formatA === 'jsonl' && formatB === 'jsonl';
+    const tableDiffs = computeTableDiffs({
+        pathA: resolvedA,
+        pathB: resolvedB,
+        manifestA,
+        manifestB,
+        recordLevel,
+        tableFilter: options.tableFilter,
+        maxIdsPerBucket: options.maxIdsPerBucket ?? 500,
+    });
+    const domainsA = new Set(manifestA.domains);
+    const domainsB = new Set(manifestB.domains);
+    const domainsOnlyInA = manifestA.domains.filter((d) => !domainsB.has(d));
+    const domainsOnlyInB = manifestB.domains.filter((d) => !domainsA.has(d));
+    const checksumMatch = manifestA.checksum === manifestB.checksum;
+    const versionMatch = manifestA.version === manifestB.version;
+    const identical = checksumMatch &&
+        versionMatch &&
+        tableDiffs.every((t) => t.delta === 0 &&
+            (t.added?.length ?? 0) === 0 &&
+            (t.removed?.length ?? 0) === 0 &&
+            (t.changed?.length ?? 0) === 0);
+    return {
+        pathA: resolvedA,
+        pathB: resolvedB,
+        formatA,
+        formatB,
+        manifestA,
+        manifestB,
+        checksumMatch,
+        versionMatch,
+        identical,
+        recordLevel,
+        tableDiffs,
+        domainsOnlyInA,
+        domainsOnlyInB,
+    };
+}
+// ============================================================================
+// Format detection + manifest reading
+// ============================================================================
+function detectFormat(path) {
+    if (!existsSync(path)) {
+        throw new Error(`Path not found: ${path}`);
+    }
+    if (path.endsWith('.rvf'))
+        return 'rvf';
+    const s = statSync(path);
+    if (s.isFile()) {
+        // Any single file that isn't .rvf is treated as an error — JSONL exports
+        // are directories.
+        throw new Error(`Unsupported brain export: ${path} (expected a .rvf file or a JSONL directory)`);
+    }
+    // Directory: assume JSONL
+    return 'jsonl';
+}
+function readManifestSummary(path, format) {
+    if (format === 'rvf') {
+        return readRvfManifestSummary(path);
+    }
+    return readJsonlManifestSummary(path);
+}
+function readJsonlManifestSummary(dir) {
+    const manifestPath = join(dir, 'manifest.json');
+    if (!existsSync(manifestPath)) {
+        throw new Error(`Manifest not found at ${manifestPath}`);
+    }
+    const raw = safeJsonParse(readFileSync(manifestPath, 'utf-8'));
+    return toManifestSummary(raw, 'jsonl');
+}
+function readRvfManifestSummary(rvfPath) {
+    // Delegate to the RVF exporter's info path so we honour its format handling.
+    const raw = brainInfoFromRvf(rvfPath);
+    return toManifestSummary(raw, 'rvf');
+}
+function toManifestSummary(raw, format) {
+    return {
+        format,
+        version: raw.version ?? 'unknown',
+        exportedAt: raw.exportedAt ?? 'unknown',
+        sourceDb: raw.sourceDb ?? 'unknown',
+        checksum: raw.checksum ?? '',
+        totalRecords: raw.stats?.totalRecords ?? 0,
+        domains: raw.domains ?? [],
+        tableRecordCounts: raw.tableRecordCounts ?? {},
+    };
+}
+function computeTableDiffs(input) {
+    const configs = input.tableFilter
+        ? TABLE_CONFIGS.filter((c) => c.tableName === input.tableFilter)
+        : TABLE_CONFIGS;
+    if (input.tableFilter && configs.length === 0) {
+        throw new Error(`Unknown table: ${input.tableFilter}`);
+    }
+    const diffs = [];
+    for (const config of configs) {
+        const countA = input.manifestA.tableRecordCounts[config.tableName] ?? 0;
+        const countB = input.manifestB.tableRecordCounts[config.tableName] ?? 0;
+        const delta = countB - countA;
+        let added;
+        let removed;
+        let changed;
+        if (input.recordLevel && hasIdentity(config)) {
+            const recordDiff = recordLevelDiff(join(input.pathA, config.fileName), join(input.pathB, config.fileName), config, input.maxIdsPerBucket);
+            added = recordDiff.added;
+            removed = recordDiff.removed;
+            changed = recordDiff.changed;
+        }
+        diffs.push({
+            tableName: config.tableName,
+            countA,
+            countB,
+            delta,
+            ...(added !== undefined ? { added } : {}),
+            ...(removed !== undefined ? { removed } : {}),
+            ...(changed !== undefined ? { changed } : {}),
+        });
+    }
+    return diffs;
+}
+function hasIdentity(_config) {
+    // PK tables always have identity; append-only tables can be deduped via
+    // their dedup columns, which is good enough to compute added/removed.
+    return true;
+}
+function pkFor(config) {
+    if (config.dedupColumns && config.dedupColumns.length > 0) {
+        // Composite identity — joined with a separator unlikely to occur in values.
+        return config.dedupColumns.join('
');
+    }
+    return PK_COLUMNS[config.tableName] ?? 'id';
+}
+function recordLevelDiff(fileA, fileB, config, maxIdsPerBucket) {
+    const mapA = buildIdentityMap(fileA, config);
+    const mapB = buildIdentityMap(fileB, config);
+    const added = [];
+    const removed = [];
+    const changed = [];
+    // In A but not in B → removed.
+    for (const [id, hashA] of mapA) {
+        const hashB = mapB.get(id);
+        if (hashB === undefined) {
+            if (removed.length < maxIdsPerBucket)
+                removed.push(id);
+        }
+        else if (hashB !== hashA) {
+            // Append-only tables use dedup columns as identity, so if the identity
+            // matches the record IS the same — guard via dedup flag.
+            if (config.dedupColumns && config.dedupColumns.length > 0)
+                continue;
+            if (changed.length < maxIdsPerBucket)
+                changed.push(id);
+        }
+    }
+    // In B but not in A → added.
+    for (const id of mapB.keys()) {
+        if (!mapA.has(id)) {
+            if (added.length < maxIdsPerBucket)
+                added.push(id);
+        }
+    }
+    added.sort();
+    removed.sort();
+    changed.sort();
+    return { added, removed, changed };
+}
+/**
+ * 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").
+ */
+function buildIdentityMap(filePath, config) {
+    const map = new Map();
+    if (!existsSync(filePath))
+        return map;
+    const rows = readJsonl(filePath, safeJsonParse);
+    for (const row of rows) {
+        const id = identityOf(row, config);
+        if (id === undefined)
+            continue;
+        // Stable content hash: JSON-stringify with sorted keys.
+        const content = stableStringify(row);
+        map.set(id, sha256Hex(content));
+    }
+    return map;
+}
+function identityOf(row, config) {
+    if (config.dedupColumns && config.dedupColumns.length > 0) {
+        const parts = [];
+        for (const col of config.dedupColumns) {
+            const v = row[col];
+            if (v === undefined || v === null)
+                return undefined;
+            parts.push(String(v));
+        }
+        return parts.join('
');
+    }
+    const pk = PK_COLUMNS[config.tableName] ?? 'id';
+    const v = row[pk];
+    if (v === undefined || v === null)
+        return undefined;
+    return String(v);
+}
+function stableStringify(obj) {
+    const keys = Object.keys(obj).sort();
+    const ordered = {};
+    for (const k of keys)
+        ordered[k] = obj[k];
+    return JSON.stringify(ordered);
+}
+function sha256Hex(s) {
+    // sha256() from brain-shared operates on utf-8 strings; both paths yield the
+    // same hash for the same input. Kept as a thin wrapper for readability.
+    return sha256(s);
+}
+export function summarizeDiff(result) {
+    let tablesChanged = 0;
+    let totalAdded = 0;
+    let totalRemoved = 0;
+    let totalChanged = 0;
+    for (const t of result.tableDiffs) {
+        const hasChange = t.delta !== 0 ||
+            (t.added && t.added.length > 0) ||
+            (t.removed && t.removed.length > 0) ||
+            (t.changed && t.changed.length > 0);
+        if (hasChange)
+            tablesChanged++;
+        totalAdded += t.added?.length ?? 0;
+        totalRemoved += t.removed?.length ?? 0;
+        totalChanged += t.changed?.length ?? 0;
+    }
+    return {
+        tablesChanged,
+        totalAdded,
+        totalRemoved,
+        totalChanged,
+        recordCountDelta: result.manifestB.totalRecords - result.manifestA.totalRecords,
+    };
+}
+// Export internal helpers for test access without widening the public API.
+export const __test__ = { stableStringify, identityOf, buildIdentityMap, pkFor };
+//# sourceMappingURL=brain-diff.js.map