modestbench 0.1.0 → 0.3.0

package/src/reporters/profile-human.ts

@@ -0,0 +1,204 @@
+/**
+ * Profile Human Reporter
+ *
+ * Human-readable reporter for profile command. Uses modestbench's synthwave
+ * ANSI theme to display profiled functions in an attractive, color-coded
+ * format.
+ *
+ * @packageDocumentation
+ */
+
+import path from 'node:path';
+
+import type { FilteredProfileData } from '../types/profiler.js';
+
+import { ansiChars, colors } from '../utils/ansi.js';
+
+/**
+ * Reporter options
+ */
+interface ProfileReporterOptions {
+  /** Enable color output */
+  color?: boolean;
+
+  /** Group by file */
+  groupByFile?: boolean;
+}
+
+/**
+ * Human-readable profile reporter
+ */
+export class ProfileHumanReporter {
+  private readonly groupByFile: boolean;
+
+  private readonly useColor: boolean;
+
+  constructor(options: ProfileReporterOptions = {}) {
+    this.useColor =
+      options.color ??
+      (process.stdout.isTTY &&
+        process.env.FORCE_COLOR !== '0' &&
+        process.env.NO_COLOR == null);
+
+    this.groupByFile = options.groupByFile ?? false;
+  }
+
+  /**
+   * Generate and print profile report
+   */
+  report(data: FilteredProfileData): void {
+    this.printHeader(data);
+    this.printLine();
+
+    if (this.groupByFile && data.groupedByFile) {
+      this.printGroupedResults(data);
+    } else {
+      this.printFlatResults(data);
+    }
+  }
+
+  private colorize(color: keyof typeof colors, text: string): string {
+    if (!this.useColor) {
+      return text;
+    }
+    return `${colors[color]}${text}${colors.reset}`;
+  }
+
+  /**
+   * Format file path - show relative path if within CWD, otherwise absolute
+   */
+  private formatPath(filePath: string): string {
+    const cwd = process.cwd();
+    const absolutePath = path.resolve(filePath);
+
+    // Check if the file is within the current working directory
+    if (absolutePath.startsWith(cwd + path.sep) || absolutePath === cwd) {
+      return path.relative(cwd, absolutePath);
+    }
+
+    return absolutePath;
+  }
+
+  private getPercentColor(percent: number): keyof typeof colors {
+    if (percent >= 10) {
+      return 'brightRed';
+    }
+    if (percent >= 5) {
+      return 'brightYellow';
+    }
+    if (percent >= 2) {
+      return 'brightCyan';
+    }
+    return 'white';
+  }
+
+  private printFlatResults(data: FilteredProfileData): void {
+    const header = `${this.colorize('magenta', ansiChars.block.full.repeat(2))} ${this.colorize('brightWhite', this.colorize('bold', 'Benchmark Candidates'))}`;
+    this.printLine(header);
+    this.printLine();
+    this.printLine('Top functions by execution time:');
+    this.printLine();
+
+    for (const fn of data.functions) {
+      // Function name and percentage
+      const percentColor = this.getPercentColor(fn.percentage);
+      const percent = `${fn.percentage.toFixed(1)}%`;
+      const ticks = `(${fn.ticks.toLocaleString()} ticks)`;
+
+      this.printLine(
+        `  ${this.colorize('brightWhite', fn.name).padEnd(60)} ${this.colorize(percentColor, percent.padStart(6))}  ${this.colorize('dim', ticks)}`,
+      );
+
+      // File and line
+      const displayPath = this.formatPath(fn.file);
+      const lineInfo = fn.line ? `:${fn.line}` : '';
+      this.printLine(
+        `  ${this.colorize('brightMagenta', this.colorize('bold', displayPath + lineInfo))}`,
+      );
+      this.printLine();
+    }
+
+    this.printSummary(data);
+  }
+
+  private printGroupedResults(data: FilteredProfileData): void {
+    if (!data.groupedByFile) {
+      return;
+    }
+
+    const header = `${this.colorize('magenta', ansiChars.block.full.repeat(2))} ${this.colorize('brightWhite', this.colorize('bold', 'Grouped by File'))}`;
+    this.printLine(header);
+    this.printLine();
+
+    // Sort files by total percentage
+    const sortedFiles = Array.from(data.groupedByFile.entries()).sort(
+      (a, b) => {
+        const aTotal = a[1].reduce((sum, fn) => sum + fn.percentage, 0);
+        const bTotal = b[1].reduce((sum, fn) => sum + fn.percentage, 0);
+        return bTotal - aTotal;
+      },
+    );
+
+    for (const [file, functions] of sortedFiles) {
+      const totalPercent = functions.reduce(
+        (sum, fn) => sum + fn.percentage,
+        0,
+      );
+      const totalTicks = functions.reduce((sum, fn) => sum + fn.ticks, 0);
+
+      const percentColor = this.getPercentColor(totalPercent);
+      const percent = `${totalPercent.toFixed(1)}%`;
+      const ticks = `(${totalTicks.toLocaleString()} ticks)`;
+
+      // File header
+      const displayPath = this.formatPath(file);
+      this.printLine(
+        `${this.colorize('magenta', ansiChars.block.dark)} ${this.colorize('brightMagenta', this.colorize('bold', displayPath)).padEnd(60)} ${this.colorize(percentColor, percent.padStart(6))}  ${this.colorize('dim', ticks)}`,
+      );
+
+      // Functions in this file
+      for (const fn of functions) {
+        const fnPercent = `${fn.percentage.toFixed(1)}%`;
+        const fnTicks = `(${fn.ticks.toLocaleString()} ticks)`;
+        const lineInfo = fn.line ? `:${fn.line}` : '';
+
+        this.printLine(
+          `  ${this.colorize('magenta', ansiChars.smallSquare)} ${this.colorize('brightWhite', fn.name).padEnd(58)} ${this.colorize(this.getPercentColor(fn.percentage), fnPercent.padStart(6))}  ${this.colorize('dim', fnTicks.padEnd(15))} ${this.colorize('dim', lineInfo)}`,
+        );
+      }
+
+      this.printLine();
+    }
+
+    this.printSummary(data);
+  }
+
+  private printHeader(data: FilteredProfileData): void {
+    const header = `${this.colorize('magenta', ansiChars.block.full.repeat(2))} ${this.colorize('brightWhite', this.colorize('bold', 'Profile Analysis'))}`;
+    this.printLine(header);
+    this.printLine();
+
+    if (data.command) {
+      this.printLine(`Command: ${this.colorize('cyan', data.command)}`);
+    }
+
+    if (data.duration) {
+      const durationSec = (data.duration / 1000).toFixed(1);
+      this.printLine(`Duration: ${this.colorize('cyan', `${durationSec}s`)}`);
+    }
+
+    this.printLine(
+      `Total Ticks: ${this.colorize('cyan', data.totalTicks.toLocaleString())}`,
+    );
+  }
+
+  private printLine(text = ''): void {
+    console.log(text);
+  }
+
+  private printSummary(data: FilteredProfileData): void {
+    this.printLine(
+      `${this.colorize('dim', `... (showing top ${data.totalShown} of ${data.totalFiltered} user functions)`)}`,
+    );
+  }
+}

package/src/reporters/simple.ts

@@ -9,13 +9,13 @@ import path from 'node:path';
 
 import type {
   BenchmarkRun,
+  BudgetSummary,
   FileResult,
-  ProgressState,
   SuiteResult,
   TaskResult,
 } from '../types/index.js';
 
-import { BaseReporter } from './registry.js';
+import { BaseReporter } from '../services/reporter-registry.js';
 
 /**
  * Basic symbols for plain text output
@@ -62,6 +62,78 @@ export class SimpleReporter extends BaseReporter {
     this.quiet = options.quiet ?? false;
   }
 
+  /**
+   * Format bytes in human-readable format
+   */
+  private static formatBytes(this: void, bytes: number): string {
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    let size = bytes;
+    let unitIndex = 0;
+
+    while (size >= 1024 && unitIndex < units.length - 1) {
+      size /= 1024;
+      unitIndex++;
+    }
+
+    return `${size.toFixed(1)} ${units[unitIndex]}`;
+  }
+
+  /**
+   * Format file path - show relative path if within CWD, otherwise absolute
+   */
+  private static formatPath(this: void, filePath: string): string {
+    const cwd = process.cwd();
+    const absolutePath = path.resolve(filePath);
+
+    // Check if the file is within the current working directory
+    if (absolutePath.startsWith(cwd + path.sep) || absolutePath === cwd) {
+      return path.relative(cwd, absolutePath);
+    }
+
+    return absolutePath;
+  }
+
+  /**
+   * Simple pluralization helper
+   */
+  private static pluralize(this: void, str: string, count: number): string {
+    return count === 1 ? str : `${str}s`;
+  }
+
+  onBudgetResult(summary: BudgetSummary): void {
+    if (summary.total === 0 || this.quiet) {
+      return;
+    }
+
+    console.log('== Performance Budgets');
+    console.log();
+
+    for (const result of summary.results) {
+      const icon = result.passed ? symbols.checkmark : symbols.cross;
+      console.log(`  ${icon} ${result.taskId}`);
+
+      if (!result.passed && result.violations.length > 0) {
+        for (const violation of result.violations) {
+          console.log(`      ${violation.message}`);
+        }
+      }
+    }
+
+    console.log();
+
+    if (summary.failed === 0) {
+      console.log(
+        `  ${symbols.checkmark} All ${summary.total} budget(s) passed`,
+      );
+    } else {
+      console.log(
+        `  ${symbols.cross} ${summary.failed} of ${summary.total} budget(s) failed`,
+      );
+    }
+
+    console.log();
+  }
+
   onEnd(run: BenchmarkRun): void {
     if (this.quiet) {
       return;
@@ -97,7 +169,7 @@ export class SimpleReporter extends BaseReporter {
     console.log(`- Files: ${totalFiles}`);
     console.log(`- Suites: ${totalSuites}`);
     console.log(
-      `${symbols.approx} Duration: ${this.formatDuration(duration * 1e6)}`,
+      `${symbols.approx} Duration: ${BaseReporter.formatDuration(duration * 1e6)}`,
     );
     console.log();
 
@@ -111,7 +183,7 @@ export class SimpleReporter extends BaseReporter {
         console.log();
 
         for (const failure of this.failures) {
-          const displayPath = this.formatPath(failure.file);
+          const displayPath = SimpleReporter.formatPath(failure.file);
           console.log(`  ${displayPath} > ${failure.suite} > ${failure.task}`);
           console.log(`    ${failure.error}`);
           console.log();
@@ -155,7 +227,7 @@ export class SimpleReporter extends BaseReporter {
       );
     } else {
       console.log(
-        ` ${symbols.checkmark} ${totalPassed > 1 ? 'All ' : ''}${totalPassed} ${this.pluralize('task', totalPassed)} passed`,
+        ` ${symbols.checkmark} ${totalPassed > 1 ? 'All ' : ''}${totalPassed} ${SimpleReporter.pluralize('task', totalPassed)} passed`,
       );
     }
 
@@ -169,15 +241,10 @@ export class SimpleReporter extends BaseReporter {
       return;
     }
 
-    const displayPath = this.formatPath(file);
+    const displayPath = SimpleReporter.formatPath(file);
     console.log(`-- ${displayPath}`);
   }
 
-  onProgress(_state: ProgressState): void {
-    // Simple reporter does not display progress bars
-    return;
-  }
-
   onStart(run: BenchmarkRun): void {
     this.startTime = Date.now();
     this.failures = []; // Reset failures for new run
@@ -197,7 +264,9 @@ export class SimpleReporter extends BaseReporter {
       console.log(
         `  cpu: ${run.environment.cpu.model} (${run.environment.cpu.cores} cores)`,
       );
-      console.log(`  mem: ${this.formatBytes(run.environment.memory.total)}`);
+      console.log(
+        `  mem: ${SimpleReporter.formatBytes(run.environment.memory.total)}`,
+      );
       console.log();
     }
 
@@ -231,7 +300,7 @@ export class SimpleReporter extends BaseReporter {
       console.log(`  ${symbols.cross} ${failed} failed, ${passed} passed`);
     } else {
       console.log(
-        `  ${symbols.checkmark} ${passed} ${this.pluralize('task', passed)} passed`,
+        `  ${symbols.checkmark} ${passed} ${SimpleReporter.pluralize('task', passed)} passed`,
       );
     }
     console.log();
@@ -275,44 +344,6 @@ export class SimpleReporter extends BaseReporter {
     }
   }
 
-  /**
-   * Format bytes in human-readable format
-   */
-  private formatBytes(bytes: number): string {
-    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
-    let size = bytes;
-    let unitIndex = 0;
-
-    while (size >= 1024 && unitIndex < units.length - 1) {
-      size /= 1024;
-      unitIndex++;
-    }
-
-    return `${size.toFixed(1)} ${units[unitIndex]}`;
-  }
-
-  /**
-   * Format file path - show relative path if within CWD, otherwise absolute
-   */
-  private formatPath(filePath: string): string {
-    const cwd = process.cwd();
-    const absolutePath = path.resolve(filePath);
-
-    // Check if the file is within the current working directory
-    if (absolutePath.startsWith(cwd + path.sep) || absolutePath === cwd) {
-      return path.relative(cwd, absolutePath);
-    }
-
-    return absolutePath;
-  }
-
-  /**
-   * Simple pluralization helper
-   */
-  private pluralize(str: string, count: number): string {
-    return count === 1 ? str : `${str}s`;
-  }
-
   /**
    * Print all task results in a suite with aligned columns
    */
@@ -364,9 +395,9 @@ export class SimpleReporter extends BaseReporter {
         };
       }
 
-      const duration = this.formatDuration(result.mean * 1e9);
-      const opsPerSec = this.formatOpsPerSecond(result.opsPerSecond);
-      const rme = this.formatPercentage(result.marginOfError * 100);
+      const duration = BaseReporter.formatDuration(result.mean * 1e9);
+      const opsPerSec = BaseReporter.formatOpsPerSecond(result.opsPerSecond);
+      const rme = BaseReporter.formatPercentage(result.marginOfError * 100);
 
       return {
         durationLen: duration.length,

package/src/services/baseline-storage.ts

@@ -0,0 +1,199 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import type {
+  BaselineReference,
+  BaselineStorage,
+  BaselineSummaryData,
+  BenchmarkRun,
+  TaskId,
+} from '../types/core.js';
+
+import { validateBaselineStorage } from '../config/budget-schema.js';
+import { StorageError } from '../errors/storage.js';
+import { createTaskId } from '../types/core.js';
+
+/**
+ * Service for managing named baselines
+ *
+ * @packageDocumentation
+ */
+export class BaselineStorageService {
+  private readonly storageDir: string;
+
+  private readonly storageFile: string;
+
+  constructor(storageDir: string = '.') {
+    this.storageDir = storageDir;
+    this.storageFile = join(storageDir, '.modestbench.baselines.json');
+  }
+
+  /**
+   * Delete a baseline
+   */
+  async deleteBaseline(name: string): Promise<void> {
+    let storage = await this.loadStorage();
+
+    if (storage.baselines[name]) {
+      delete storage.baselines[name];
+
+      // Clear default if it was the deleted baseline
+      if (storage.default === name) {
+        storage = { ...storage, default: undefined };
+      }
+
+      await this.saveStorage(storage);
+    }
+  }
+
+  /**
+   * Get a baseline by name
+   */
+  async getBaseline(name: string): Promise<BaselineReference | null> {
+    const storage = await this.loadStorage();
+    return storage.baselines[name] ?? null;
+  }
+
+  /**
+   * Get default baseline name
+   */
+  async getDefault(): Promise<null | string> {
+    const storage = await this.loadStorage();
+    return storage.default ?? null;
+  }
+
+  /**
+   * List all baselines
+   */
+  async listBaselines(): Promise<BaselineReference[]> {
+    const storage = await this.loadStorage();
+    return Object.values(storage.baselines).sort(
+      (a, b) => b.date.getTime() - a.date.getTime(),
+    );
+  }
+
+  /**
+   * Resolve baseline name (use provided or fall back to default)
+   */
+  async resolveBaselineName(name?: string): Promise<null | string> {
+    if (name) {
+      return name;
+    }
+
+    return await this.getDefault();
+  }
+
+  /**
+   * Save a benchmark run as a named baseline
+   */
+  async saveBaseline(
+    name: string,
+    run: BenchmarkRun,
+    metadata?: {
+      branch?: string;
+      commit?: string;
+    },
+  ): Promise<void> {
+    const storage = await this.loadStorage();
+
+    const baseline: BaselineReference = {
+      branch: metadata?.branch,
+      commit: metadata?.commit,
+      date:
+        run.startTime instanceof Date ? run.startTime : new Date(run.startTime),
+      name,
+      runId: run.id,
+      summary: this.extractSummary(run),
+    };
+
+    storage.baselines[name] = baseline;
+
+    await this.saveStorage(storage);
+  }
+
+  /**
+   * Set default baseline
+   */
+  async setDefault(name: string): Promise<void> {
+    let storage = await this.loadStorage();
+
+    if (!storage.baselines[name]) {
+      throw new StorageError(
+        `Baseline "${name}" does not exist. Cannot set as default.`,
+      );
+    }
+
+    storage = { ...storage, default: name };
+    await this.saveStorage(storage);
+  }
+
+  /**
+   * Extract task summary from benchmark run
+   */
+  private extractSummary(
+    run: BenchmarkRun,
+  ): Record<TaskId, BaselineSummaryData> {
+    const summary: Record<TaskId, BaselineSummaryData> = {};
+
+    for (const file of run.files) {
+      for (const suite of file.suites) {
+        for (const task of suite.tasks) {
+          if (!task.error) {
+            const taskId = createTaskId(file.filePath, suite.name, task.name);
+            summary[taskId] = {
+              mean: task.mean,
+              opsPerSecond: task.opsPerSecond,
+              p99: task.p99,
+            };
+          }
+        }
+      }
+    }
+
+    return summary;
+  }
+
+  /**
+   * Load baseline storage from disk
+   */
+  private async loadStorage(): Promise<BaselineStorage> {
+    if (!existsSync(this.storageFile)) {
+      return {
+        baselines: {},
+        version: '1.0.0',
+      };
+    }
+
+    try {
+      const content = await readFile(this.storageFile, 'utf-8');
+      const data = JSON.parse(content) as unknown;
+      return validateBaselineStorage(data);
+    } catch (error) {
+      throw new StorageError(
+        `Failed to load baseline storage from ${this.storageFile}`,
+        { cause: error },
+      );
+    }
+  }
+
+  /**
+   * Save baseline storage to disk
+   */
+  private async saveStorage(storage: BaselineStorage): Promise<void> {
+    try {
+      // Ensure directory exists
+      if (!existsSync(this.storageDir)) {
+        await mkdir(this.storageDir, { recursive: true });
+      }
+
+      const content = JSON.stringify(storage, null, 2);
+      await writeFile(this.storageFile, content, 'utf-8');
+    } catch (error) {
+      throw new StorageError(
+        `Failed to save baseline storage to ${this.storageFile}`,
+        { cause: error },
+      );
+    }
+  }
+}