modestbench 0.9.0 → 0.9.2

package/src/cli/commands/init.ts

@@ -51,7 +51,7 @@ const PROJECT_TEMPLATES = {
       outputDir: DEFAULT_OUTPUT_DIR,
       pattern: `${DEFAULT_BENCHMARK_DIR}/**/*.bench.{js,ts}`,
       reporters: ['human', 'json'],
-      time: 10000,
+      time: 10_000,
       warmup: 50,
     },
     description: 'Feature-rich setup with multiple reporters and configuration',
@@ -77,7 +77,7 @@ const PROJECT_TEMPLATES = {
       outputDir: DEFAULT_OUTPUT_DIR,
       pattern: `${DEFAULT_BENCHMARK_DIR}/**/*.bench.{js,ts}`,
       reporters: ['human', 'json'],
-      time: 15000,
+      time: 15_000,
       warmup: 100,
     },
     description: 'Optimized for library performance testing',

package/src/cli/commands/run.ts

@@ -46,7 +46,7 @@ import { hasErrorCode, isError } from '../../utils/type-guards.js';
  * arguments provide values. They represent sensible defaults for running
  * benchmarks.
  */
-export const RUN_COMMAND_DEFAULTS = {
+const RUN_COMMAND_DEFAULTS = {
   bail: false,
   quiet: false,
   reporters: ['human'],

package/src/cli/commands/test.ts

@@ -55,7 +55,7 @@ const getDefaultTestConfig = (
   tags: [],
   thresholds: {},
   time: 1000,
-  timeout: 30000,
+  timeout: 30_000,
   verbose,
   warmup,
 });

package/src/cli/context.ts

@@ -0,0 +1,117 @@
+/**
+ * CLI Context
+ *
+ * Provides dependency injection container for CLI commands, including
+ * configuration manager, benchmark engine, history storage, and reporters.
+ *
+ * @packageDocumentation
+ */
+
+import type { InferParserValues } from '@boneskull/bargs';
+
+import type {
+  BenchmarkEngine,
+  ConfigurationManager,
+  Engine,
+  HistoryStorage,
+  ProgressManager,
+  ReporterRegistry,
+} from '../types/index.js';
+import type { globalOptions } from './parsers/global.js';
+
+import { bootstrap } from '../bootstrap.js';
+import { DEFAULT_ENGINE, Engines, ExitCodes, Reporters } from '../constants.js';
+import { AccurateEngine, TinybenchEngine } from '../core/engines/index.js';
+import {
+  CsvReporter,
+  HumanReporter,
+  JsonReporter,
+  NyanReporter,
+  SimpleReporter,
+} from '../reporters/index.js';
+
+/**
+ * CLI context with initialized services
+ */
+export interface CliContext {
+  readonly abortController: AbortController;
+  readonly configManager: ConfigurationManager;
+  readonly engine: BenchmarkEngine;
+  readonly historyStorage: HistoryStorage;
+  readonly options: InferParserValues<typeof globalOptions>;
+  readonly progressManager: ProgressManager;
+  readonly reporterRegistry: ReporterRegistry;
+}
+
+/**
+ * Create CLI context with dependency injection
+ */
+export const createCliContext = async (
+  options: InferParserValues<typeof globalOptions>,
+  abortController: AbortController,
+  engineType: Engine = DEFAULT_ENGINE,
+): Promise<CliContext> => {
+  try {
+    const dependencies = bootstrap();
+
+    // Select engine based on type
+    const engine =
+      engineType === Engines.ACCURATE
+        ? new AccurateEngine(dependencies)
+        : new TinybenchEngine(dependencies);
+
+    // Register built-in reporters
+    engine.registerReporter(
+      Reporters.HUMAN,
+      new HumanReporter({
+        color: !options.noColor,
+        verbose: options.verbose,
+      }),
+    );
+
+    engine.registerReporter(
+      'json',
+      new JsonReporter({
+        prettyPrint: false,
+      }),
+    );
+
+    engine.registerReporter(
+      'csv',
+      new CsvReporter({
+        includeHeaders: true,
+        includeMetadata: true,
+      }),
+    );
+
+    engine.registerReporter(
+      'simple',
+      new SimpleReporter({
+        verbose: options.verbose,
+      }),
+    );
+
+    engine.registerReporter(
+      'nyan',
+      new NyanReporter({
+        color: !options.noColor,
+      }),
+    );
+
+    return {
+      abortController,
+      configManager: engine.configManager,
+      engine,
+      historyStorage: engine.historyStorage,
+      options,
+      progressManager: engine.progressManager,
+      reporterRegistry: engine.reporterRegistry,
+    };
+  } catch (error) {
+    console.error(
+      'Failed to initialize ModestBench:',
+      error instanceof Error ? error.message : String(error),
+    );
+    process.exit(ExitCodes.CONFIG_ERROR);
+  }
+};

package/src/cli/handlers.ts

@@ -0,0 +1,76 @@
+/**
+ * CLI Signal Handlers
+ *
+ * Handles process signals (SIGINT, SIGTERM, etc.) and uncaught errors for
+ * graceful shutdown of benchmark runs.
+ *
+ * @packageDocumentation
+ */
+
+import { ABORT_TIMEOUT, ExitCodes } from '../constants.js';
+import { isModestBenchError, UnknownError } from '../errors/index.js';
+import { isError } from '../utils/type-guards.js';
+
+/**
+ * Handle process signals gracefully
+ */
+export const setupSignalHandlers = (abortController: AbortController): void => {
+  let abortRequested = false;
+
+  const handleSignal = (signal: NodeJS.Signals) => {
+    if (abortRequested) {
+      // Second signal, force exit
+      console.log(`\nReceived ${signal} again, forcing exit...`);
+      process.exit(computeExitCode(signal));
+    }
+
+    console.log(`\nReceived ${signal}, aborting benchmarks...`);
+    abortRequested = true;
+    abortController.abort();
+
+    // Give a short grace period for cleanup, then exit
+    setTimeout(() => {
+      console.log('\nBenchmark aborted.');
+      process.exit(computeExitCode(signal));
+    }, ABORT_TIMEOUT);
+  };
+
+  process
+    .once('SIGINT', handleSignal)
+    .once('SIGQUIT', handleSignal)
+    .once('SIGTERM', handleSignal)
+    .once('uncaughtException', (error) => {
+      // Wrap non-ModestBench errors with UnknownError
+      const wrappedError: Error = isModestBenchError(error)
+        ? error
+        : new UnknownError(error.message, { cause: error });
+      console.error(`${wrappedError}`);
+      process.exit(ExitCodes.RUNTIME_ERROR);
+    })
+    .once('unhandledRejection', (reason) => {
+      const wrappedError: Error = isModestBenchError(reason)
+        ? reason
+        : new UnknownError(isError(reason) ? reason.message : String(reason), {
+            cause: reason,
+          });
+      console.error(`${wrappedError}`);
+      process.exit(ExitCodes.RUNTIME_ERROR);
+    });
+};
+
+/**
+ * Compute the exit code based on the signal
+ *
+ * @param signal - The signal that caused the exit
+ * @returns The exit code
+ */
+const computeExitCode = (signal: NodeJS.Signals): number => {
+  switch (signal) {
+    case 'SIGINT':
+      return 130; // 128 + 2
+    case 'SIGQUIT':
+      return 131; // 128 + 3
+    default:
+      return 143; // 128 + 15 (SIGTERM)
+  }
+};