@eduardbar/drift 1.2.0 → 1.4.0

package/dist/benchmark.d.ts

@@ -0,0 +1,2 @@
+export declare function runBenchmarkCli(argv?: string[]): Promise<void>;
+//# sourceMappingURL=benchmark.d.ts.map

package/dist/benchmark.js

@@ -0,0 +1,204 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import * as path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { analyzeProject } from './analyzer.js';
+import { loadConfig } from './config.js';
+import { buildReport } from './reporter.js';
+import { generateReview } from './review.js';
+import { buildTrustReport } from './trust.js';
+import { cleanupTempDir, extractFilesAtRef } from './git.js';
+import { computeDiff } from './diff.js';
+const DEFAULT_SCAN_PATH = '.';
+const DEFAULT_REVIEW_PATH = '.';
+const DEFAULT_TRUST_PATH = '.';
+const DEFAULT_BASE_REF = 'HEAD~1';
+const DEFAULT_WARMUP_RUNS = 1;
+const DEFAULT_MEASURED_RUNS = 5;
+const TABLE_WIDTHS = {
+    task: 10,
+    warmup: 8,
+    runs: 6,
+    median: 13,
+    mean: 11,
+    min: 10,
+    max: 10,
+};
+const TABLE_COLUMNS = [
+    { key: 'task', header: 'task' },
+    { key: 'warmup', header: 'warmup' },
+    { key: 'runs', header: 'runs' },
+    { key: 'median', header: 'median(ms)' },
+    { key: 'mean', header: 'mean(ms)' },
+    { key: 'min', header: 'min(ms)' },
+    { key: 'max', header: 'max(ms)' },
+];
+function parseNumberFlag(value, flagName) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        throw new Error(`${flagName} must be a non-negative number, received '${value}'`);
+    }
+    return Math.floor(parsed);
+}
+function parseOptions(argv) {
+    const options = {
+        scanPath: DEFAULT_SCAN_PATH,
+        reviewPath: DEFAULT_REVIEW_PATH,
+        trustPath: DEFAULT_TRUST_PATH,
+        baseRef: DEFAULT_BASE_REF,
+        warmupRuns: DEFAULT_WARMUP_RUNS,
+        measuredRuns: DEFAULT_MEASURED_RUNS,
+    };
+    const handlers = {
+        '--scan-path': (value) => { options.scanPath = value; },
+        '--review-path': (value) => { options.reviewPath = value; },
+        '--trust-path': (value) => { options.trustPath = value; },
+        '--base': (value) => { options.baseRef = value; },
+        '--warmup': (value) => { options.warmupRuns = parseNumberFlag(value, '--warmup'); },
+        '--runs': (value) => { options.measuredRuns = parseNumberFlag(value, '--runs'); },
+        '--json-out': (value) => { options.jsonOut = value; },
+    };
+    for (let i = 0; i < argv.length; i += 2) {
+        const arg = argv[i];
+        const next = argv[i + 1];
+        const handler = handlers[arg];
+        if (!handler || !next)
+            throw new Error(`Unknown or incomplete argument: ${arg}`);
+        handler(next);
+    }
+    if (options.measuredRuns < 1) {
+        throw new Error('--runs must be at least 1');
+    }
+    return {
+        ...options,
+        scanPath: path.resolve(options.scanPath),
+        reviewPath: path.resolve(options.reviewPath),
+        trustPath: path.resolve(options.trustPath),
+        jsonOut: options.jsonOut ? path.resolve(options.jsonOut) : undefined,
+    };
+}
+function median(values) {
+    const sorted = [...values].sort((a, b) => a - b);
+    const middle = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 1)
+        return sorted[middle];
+    return (sorted[middle - 1] + sorted[middle]) / 2;
+}
+function formatMs(ms) {
+    return ms.toFixed(2);
+}
+async function runTask(name, warmupRuns, measuredRuns, task) {
+    for (let i = 0; i < warmupRuns; i += 1) {
+        await task();
+    }
+    const samplesMs = [];
+    for (let i = 0; i < measuredRuns; i += 1) {
+        const started = performance.now();
+        await task();
+        samplesMs.push(performance.now() - started);
+    }
+    const total = samplesMs.reduce((sum, sample) => sum + sample, 0);
+    return {
+        name,
+        warmupRuns,
+        measuredRuns,
+        samplesMs,
+        medianMs: median(samplesMs),
+        meanMs: total / samplesMs.length,
+        minMs: Math.min(...samplesMs),
+        maxMs: Math.max(...samplesMs),
+    };
+}
+function printTable(results) {
+    const headers = TABLE_COLUMNS.map((column) => column.header);
+    const widths = TABLE_COLUMNS.map((column) => TABLE_WIDTHS[column.key]);
+    const row = (values) => values
+        .map((value, index) => value.padEnd(widths[index], ' '))
+        .join(' ');
+    process.stdout.write('\n');
+    process.stdout.write(row(headers) + '\n');
+    process.stdout.write(row(widths.map((width) => '-'.repeat(width))) + '\n');
+    for (const result of results) {
+        process.stdout.write(row([
+            result.name,
+            String(result.warmupRuns),
+            String(result.measuredRuns),
+            formatMs(result.medianMs),
+            formatMs(result.meanMs),
+            formatMs(result.minMs),
+            formatMs(result.maxMs),
+        ]) + '\n');
+    }
+}
+async function runScan(scanPath) {
+    const config = await loadConfig(scanPath);
+    const files = analyzeProject(scanPath, config);
+    buildReport(scanPath, files);
+}
+async function runTrust(trustPath, baseRef) {
+    const config = await loadConfig(trustPath);
+    const files = analyzeProject(trustPath, config);
+    const report = buildReport(trustPath, files);
+    let tempDir;
+    let diff;
+    try {
+        tempDir = extractFilesAtRef(trustPath, baseRef);
+        const baseFiles = analyzeProject(tempDir, config);
+        const baseReport = buildReport(tempDir, baseFiles);
+        diff = computeDiff(baseReport, report, baseRef);
+    }
+    catch {
+        diff = undefined;
+    }
+    finally {
+        if (tempDir)
+            cleanupTempDir(tempDir);
+    }
+    buildTrustReport(report, { diff });
+}
+async function runReview(reviewPath, baseRef) {
+    await generateReview(reviewPath, baseRef);
+}
+async function main(argv) {
+    const options = parseOptions(argv);
+    const results = [
+        await runTask('scan', options.warmupRuns, options.measuredRuns, () => runScan(options.scanPath)),
+        await runTask('review', options.warmupRuns, options.measuredRuns, () => runReview(options.reviewPath, options.baseRef)),
+        await runTask('trust', options.warmupRuns, options.measuredRuns, () => runTrust(options.trustPath, options.baseRef)),
+    ];
+    const output = {
+        meta: {
+            scannedAt: new Date().toISOString(),
+            node: process.version,
+            platform: process.platform,
+            cwd: process.cwd(),
+        },
+        options,
+        results,
+    };
+    printTable(results);
+    process.stdout.write(`\n${JSON.stringify(output, null, 2)}\n`);
+    if (options.jsonOut) {
+        mkdirSync(path.dirname(options.jsonOut), { recursive: true });
+        writeFileSync(options.jsonOut, JSON.stringify(output, null, 2) + '\n', 'utf8');
+        process.stdout.write(`\nSaved benchmark JSON to ${options.jsonOut}\n`);
+    }
+}
+function isExecutedAsEntryPoint() {
+    const entryArg = process.argv[1];
+    if (!entryArg)
+        return false;
+    return import.meta.url === pathToFileURL(path.resolve(entryArg)).href;
+}
+export async function runBenchmarkCli(argv = process.argv.slice(2)) {
+    try {
+        await main(argv);
+    }
+    catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
+    }
+}
+if (isExecutedAsEntryPoint()) {
+    void runBenchmarkCli();
+}
+//# sourceMappingURL=benchmark.js.map