modestbench 0.1.0 → 0.2.0

package/src/cli/commands/history.ts

@@ -5,72 +5,94 @@
  * comparing, and cleaning historical data.
  */
 
-import type { HistoryQuery, RetentionPolicy } from '../../types/index.js';
+import type {
+  HistoryQuery,
+  HistoryStorage,
+  RetentionPolicy,
+} from '../../types/index.js';
 import type { CliContext } from '../index.js';
 
-import { InvalidDateFormatError } from '../../errors/index.js';
+import { HistoryCompareFormatter } from '../../formatters/history/compare.js';
+import { HistoryListFormatter } from '../../formatters/history/list.js';
+import { HistoryShowFormatter } from '../../formatters/history/show.js';
+import { HistoryTrendsFormatter } from '../../formatters/history/trends.js';
+import { ComparisonService } from '../../services/history/comparison.js';
+import {
+  HistoryQueryService,
+  parseDate,
+} from '../../services/history/query.js';
+import { TrendAnalysisService } from '../../services/history/trend-analysis.js';
 
 /**
- * History command options interface
+ * Base options shared by all history subcommands
  */
-interface HistoryOptions {
-  args?: string[] | undefined; // Additional arguments after subcommand
-  confirm?: boolean | undefined;
+interface BaseHistoryOptions {
   cwd: string;
-  format?: 'csv' | 'human' | 'json' | undefined;
-  limit?: number | undefined;
+  quiet?: boolean | undefined;
+  verbose?: boolean | undefined;
+}
+
+/**
+ * Options for history clean command
+ */
+interface HistoryCleanOptions extends BaseHistoryOptions {
+  confirm?: boolean | undefined;
   maxAge?: number | undefined;
   maxRuns?: number | undefined;
   maxSize?: number | undefined;
-  outputDir?: string | undefined;
+}
+
+/**
+ * Options for history compare command
+ */
+interface HistoryCompareOptions extends BaseHistoryOptions {
+  format?: 'human' | 'json' | undefined;
+  runId1: string;
+  runId2: string;
+}
+
+/**
+ * Options for history export command
+ */
+interface HistoryExportOptions extends BaseHistoryOptions {
+  format?: 'csv' | 'json' | undefined;
+  outputPath: string;
+  since?: string | undefined;
+  until?: string | undefined;
+}
+
+/**
+ * Options for history list command
+ */
+interface HistoryListOptions extends BaseHistoryOptions {
+  format?: 'csv' | 'human' | 'json' | undefined;
+  limit?: number | undefined;
   pattern?: string | undefined;
-  quiet?: boolean | undefined;
   since?: string | undefined;
-  subcommand: 'clean' | 'compare' | 'export' | 'list' | 'show' | 'trends';
   tags?: string[] | undefined;
   until?: string | undefined;
-  verbose?: boolean | undefined;
 }
 
 /**
- * Handle history command
+ * Options for history show command
  */
-export const handleHistoryCommand = async (
-  context: CliContext,
-  options: HistoryOptions,
-): Promise<number> => {
-  try {
-    // Get the subcommand
-    const subcommand = options.subcommand;
-
-    switch (subcommand) {
-      case 'clean':
-        return await handleCleanCommand(context, options);
-      case 'compare':
-        return await handleCompareCommand(context, options);
-      case 'export':
-        return await handleExportCommand(context, options);
-      case 'list':
-        return await handleListCommand(context, options);
-      case 'show':
-        return await handleShowCommand(context, options);
-      case 'trends':
-        return await handleTrendsCommand(context, options);
-      default:
-        console.error(`Unknown history subcommand: ${subcommand || '(none)'}`);
-        console.error(
-          'Available subcommands: list, show, compare, trends, clean, export',
-        );
-        return 2; // Config error
-    }
-  } catch (error) {
-    console.error(
-      'History command failed:',
-      error instanceof Error ? error.message : String(error),
-    );
-    return 2; // Configuration/runtime errors
-  }
-};
+interface HistoryShowOptions extends BaseHistoryOptions {
+  format?: 'csv' | 'human' | 'json' | undefined;
+  runId: string;
+}
+
+/**
+ * Options for history trends command
+ */
+interface HistoryTrendsOptions extends BaseHistoryOptions {
+  all?: boolean | undefined;
+  format?: 'human' | 'json' | undefined;
+  limit?: number | undefined;
+  pattern?: string | undefined;
+  since?: string | undefined;
+  tags?: string[] | undefined;
+  until?: string | undefined;
+}
 
 /**
  * Format bytes in human-readable format
@@ -88,12 +110,38 @@ const formatBytes = (bytes: number): string => {
   return `${size.toFixed(1)} ${units[unitIndex]}`;
 };
 
+/**
+ * Resolve a partial run ID to a full ID by checking prefix match
+ *
+ * Supports Git-style partial ID matching (e.g., "k3m" matches "k3m9x2p")
+ */
+const resolveRunId = async (
+  storage: HistoryStorage,
+  partialId: string,
+): Promise<null | string> => {
+  // First try exact match
+  const exactRun = await storage.loadRun(partialId);
+  if (exactRun) {
+    return partialId;
+  }
+
+  // Query all runs to find a prefix match
+  const allRuns = await storage.queryRuns({});
+
+  const prefixMatch = allRuns.find((run) => run.id.startsWith(partialId));
+  if (prefixMatch) {
+    return prefixMatch.id;
+  }
+
+  return null;
+};
+
 /**
  * Handle the clean subcommand
  */
-const handleCleanCommand = async (
+export const handleCleanCommand = async (
   context: CliContext,
-  options: HistoryOptions,
+  options: HistoryCleanOptions,
 ): Promise<number> => {
   try {
     // Build retention policy from arguments
@@ -160,69 +208,38 @@ const handleCleanCommand = async (
 /**
  * Handle the compare subcommand
  */
-const handleCompareCommand = async (
+export const handleCompareCommand = async (
   context: CliContext,
-  options: HistoryOptions,
+  options: HistoryCompareOptions,
 ): Promise<number> => {
   try {
-    // For compare command, IDs come from args after the subcommand
-    const id1 = options.args?.[0];
-    const id2 = options.args?.[1];
-
-    if (!id1 || !id2) {
-      console.error('Two run IDs are required for compare command');
-      console.error('Usage: modestbench history compare <run-id1> <run-id2>');
-      return 2;
-    }
-
     const [run1, run2] = await Promise.all([
-      context.historyStorage.loadRun(id1),
-      context.historyStorage.loadRun(id2),
+      context.historyStorage.loadRun(options.runId1),
+      context.historyStorage.loadRun(options.runId2),
     ]);
 
     if (!run1) {
-      console.error(`Run not found: ${id1}`);
+      console.error(`Run not found: ${options.runId1}`);
       return 1;
     }
 
     if (!run2) {
-      console.error(`Run not found: ${id2}`);
+      console.error(`Run not found: ${options.runId2}`);
       return 1;
     }
 
-    if (options.format === 'json') {
-      const comparison = {
-        run1: { id: run1.id, summary: run1.summary },
-        run2: { id: run2.id, summary: run2.summary },
-        // TODO: Add detailed comparison logic
-      };
-      console.log(JSON.stringify(comparison, null, 2));
-    } else {
-      // Human format comparison
-      console.log(`Comparing runs:`);
-      console.log(`  Run 1: ${run1.id} (${run1.startTime.toLocaleString()})`);
-      console.log(`  Run 2: ${run2.id} (${run2.startTime.toLocaleString()})`);
-      console.log();
-
-      console.log('Summary comparison:');
-      console.log(
-        `  Files: ${run1.summary.totalFiles} vs ${run2.summary.totalFiles}`,
-      );
-      console.log(
-        `  Tasks: ${run1.summary.totalTasks} vs ${run2.summary.totalTasks}`,
-      );
-      console.log(
-        `  Passed: ${run1.summary.passedTasks} vs ${run2.summary.passedTasks}`,
-      );
-      console.log(
-        `  Failed: ${run1.summary.failedTasks} vs ${run2.summary.failedTasks}`,
-      );
+    // Compare using service
+    const comparisonService = new ComparisonService();
+    const result = comparisonService.compareRuns(run1, run2);
 
-      // TODO: Add detailed performance comparison
-      console.log();
-      console.log('Note: Detailed performance comparison not yet implemented.');
-    }
+    // Format output
+    const formatter = new HistoryCompareFormatter();
+    const output =
+      options.format === 'json'
+        ? formatter.formatJson(result)
+        : formatter.formatHuman(result);
 
+    console.log(output);
     return 0;
   } catch (error) {
     console.error(
@@ -236,9 +253,9 @@ const handleCompareCommand = async (
 /**
  * Handle the export subcommand
  */
-const handleExportCommand = async (
+export const handleExportCommand = async (
   context: CliContext,
-  options: HistoryOptions,
+  options: HistoryExportOptions,
 ): Promise<number> => {
   try {
     const format = options.format || 'json';
@@ -249,21 +266,13 @@ const handleExportCommand = async (
       ...(options.until && { until: parseDate(options.until) }),
     } as Partial<HistoryQuery>;
 
-    const exportData = await context.historyStorage.export(
-      format as 'csv' | 'json',
-      query,
-    );
+    const exportData = await context.historyStorage.export(format, query);
 
-    if (options.outputDir) {
-      // Write to file
-      const fs = await import('node:fs/promises');
-      await fs.writeFile(options.outputDir, exportData, 'utf8');
-      if (!options.quiet) {
-        console.log(`Exported history to ${options.outputDir}`);
-      }
-    } else {
-      // Write to stdout
-      console.log(exportData);
+    // Write to file
+    const fs = await import('node:fs/promises');
+    await fs.writeFile(options.outputPath, exportData, 'utf8');
+    if (!options.quiet) {
+      console.log(`Exported history to ${options.outputPath}`);
     }
 
     return 0;
@@ -279,110 +288,39 @@ const handleExportCommand = async (
 /**
  * Handle the list subcommand
  */
-const handleListCommand = async (
+export const handleListCommand = async (
   context: CliContext,
-  options: HistoryOptions,
+  options: HistoryListOptions,
 ): Promise<number> => {
   try {
-    // Build query from command line arguments
-    let parsedSince: Date | undefined;
-    let parsedUntil: Date | undefined;
-
-    if (options.since) {
-      try {
-        parsedSince = parseDate(options.since);
-      } catch (error) {
-        console.error(
-          'Invalid since date:',
-          error instanceof Error ? error.message : String(error),
-        );
-        return 2; // Invalid date format
-      }
-    }
-
-    if (options.until) {
-      try {
-        parsedUntil = parseDate(options.until);
-      } catch (error) {
-        console.error(
-          'Invalid until date:',
-          error instanceof Error ? error.message : String(error),
-        );
-        return 2; // Invalid date format
-      }
-    }
-
-    const query = {
-      ...(parsedSince && { since: parsedSince }),
-      ...(parsedUntil && { until: parsedUntil }),
-      ...(options.pattern && { pattern: options.pattern }),
-      ...(options.tags && options.tags.length > 0 && { tags: options.tags }),
-      ...(options.limit && { limit: options.limit }),
-    } as Partial<HistoryQuery>;
+    // Query runs using service
+    const queryService = new HistoryQueryService(context.historyStorage);
+    const runs = await queryService.queryWithDateParsing(options);
+
+    // Transform to result format
+    const result = {
+      runs: runs.map((run) => ({
+        duration: run.duration,
+        id: run.id,
+        startTime: run.startTime,
+        summary: run.summary,
+      })),
+      totalCount: runs.length,
+    };
+
+    // Format output
+    const formatter = new HistoryListFormatter();
+    let output: string;
 
-    // Query historical runs
-    const runs = await context.historyStorage.queryRuns(query);
-
-    // Display results based on format
     if (options.format === 'json') {
-      if (runs.length === 0) {
-        console.log('[]'); // Empty JSON array for no data
-      } else {
-        console.log(
-          JSON.stringify(
-            runs.map((run) => ({
-              duration: run.duration,
-              failed: run.summary.failedTasks,
-              files: run.summary.totalFiles,
-              id: run.id,
-              passed: run.summary.passedTasks,
-              startTime: run.startTime,
-              tasks: run.summary.totalTasks,
-            })),
-            null,
-            2,
-          ),
-        );
-      }
+      output = formatter.formatJson(result);
     } else if (options.format === 'csv') {
-      console.log('id,startTime,duration,files,tasks,passed,failed');
-      if (runs.length > 0) {
-        for (const run of runs) {
-          console.log(
-            `${run.id},${run.startTime.toISOString()},${run.duration},${run.summary.totalFiles},${run.summary.totalTasks},${run.summary.passedTasks},${run.summary.failedTasks}`,
-          );
-        }
-      }
-      // For CSV, no additional message needed - header is sufficient
+      output = formatter.formatCsv(result);
     } else {
-      // Human format
-      if (runs.length === 0) {
-        if (!options.quiet) {
-          console.log('No historical data found matching criteria.');
-        }
-      } else {
-        console.log('Recent benchmark runs:');
-        console.log();
-
-        for (const run of runs) {
-          const dateStr = run.startTime.toLocaleString();
-          const durationStr = `${(run.duration / 1000).toFixed(1)}s`;
-          const statusStr =
-            run.summary.failedTasks > 0
-              ? `${run.summary.passedTasks} passed, ${run.summary.failedTasks} failed`
-              : `${run.summary.passedTasks} passed`;
-
-          console.log(
-            `  ${run.id.substring(0, 8)} - ${dateStr} (${durationStr})`,
-          );
-          console.log(
-            `    ${run.summary.totalFiles} files, ${run.summary.totalTasks} tasks: ${statusStr}`,
-          );
-          console.log();
-        }
-      }
+      output = formatter.formatHuman(result);
     }
 
+    console.log(output);
     return 0;
   } catch (error) {
     console.error(
@@ -396,68 +334,34 @@ const handleListCommand = async (
 /**
  * Handle the show subcommand
  */
-const handleShowCommand = async (
+export const handleShowCommand = async (
   context: CliContext,
-  options: HistoryOptions,
+  options: HistoryShowOptions,
 ): Promise<number> => {
   try {
-    // For show command, ID comes from the args after the subcommand
-    const runId = options.args?.[0];
+    // Resolve partial ID to full ID
+    const fullRunId = await resolveRunId(context.historyStorage, options.runId);
 
-    if (!runId) {
-      console.error('Run ID is required for show command');
-      console.error('Usage: modestbench history show <run-id>');
-      return 2;
+    if (!fullRunId) {
+      console.error(`Run not found: ${options.runId}`);
+      return 1;
     }
 
-    const run = await context.historyStorage.loadRun(runId);
+    const run = await context.historyStorage.loadRun(fullRunId);
 
     if (!run) {
-      console.error(`Run not found: ${runId}`);
+      console.error(`Run not found: ${options.runId}`);
       return 1;
     }
 
-    if (options.format === 'json') {
-      console.log(JSON.stringify(run, null, 2));
-    } else {
-      // Human format
-      console.log(`Benchmark Run: ${run.id}`);
-      console.log(`Date: ${run.startTime.toLocaleString()}`);
-      console.log(`Duration: ${(run.duration / 1000).toFixed(1)}s`);
-      console.log(
-        `Environment: Node.js ${run.environment.nodeVersion} on ${run.environment.platform}`,
-      );
-
-      if (run.git) {
-        console.log(`Git: ${run.git.branch}@${run.git.commit.substring(0, 8)}`);
-      }
-
-      console.log();
-      console.log('Summary:');
-      console.log(`  Files: ${run.summary.totalFiles}`);
-      console.log(`  Suites: ${run.summary.totalSuites}`);
-      console.log(`  Tasks: ${run.summary.totalTasks}`);
-      console.log(`  Passed: ${run.summary.passedTasks}`);
-      console.log(`  Failed: ${run.summary.failedTasks}`);
-
-      // TODO: Show detailed file/suite/task results
-      console.log();
-      console.log('Detailed results:');
-      for (const file of run.files) {
-        console.log(`  📁 ${file.filePath}`);
-        for (const suite of file.suites) {
-          console.log(`    📊 ${suite.name}`);
-          for (const task of suite.tasks) {
-            const status = task.error ? '❌' : '✅';
-            const timing = task.error
-              ? 'failed'
-              : `${(task.mean / 1000000).toFixed(2)}ms`;
-            console.log(`      ${status} ${task.name} - ${timing}`);
-          }
-        }
-      }
-    }
+    // Format output
+    const formatter = new HistoryShowFormatter();
+    const output =
+      options.format === 'json'
+        ? formatter.formatJson(run)
+        : formatter.formatHuman(run);
 
+    console.log(output);
     return 0;
   } catch (error) {
     console.error(
@@ -471,101 +375,49 @@ const handleShowCommand = async (
 /**
  * Handle the trends subcommand
  */
-const handleTrendsCommand = async (
+export const handleTrendsCommand = async (
   context: CliContext,
-  options: HistoryOptions,
+  options: HistoryTrendsOptions,
 ): Promise<number> => {
   try {
-    // Build query from command line arguments (same as list command)
-    let parsedSince: Date | undefined;
-    let parsedUntil: Date | undefined;
-
-    if (options.since) {
-      try {
-        parsedSince = parseDate(options.since);
-      } catch (error) {
-        console.error(
-          'Invalid since date:',
-          error instanceof Error ? error.message : String(error),
-        );
-        return 2; // Invalid date format
-      }
-    }
-
-    if (options.until) {
-      try {
-        parsedUntil = parseDate(options.until);
-      } catch (error) {
-        console.error(
-          'Invalid until date:',
-          error instanceof Error ? error.message : String(error),
-        );
-        return 2; // Invalid date format
-      }
-    }
-
-    // Get pattern from args or explicit pattern option
-    const pattern = options.args?.[0] || options.pattern;
-
-    const query = {
-      ...(parsedSince && { since: parsedSince }),
-      ...(parsedUntil && { until: parsedUntil }),
-      ...(pattern && { pattern }),
-      ...(options.tags && options.tags.length > 0 && { tags: options.tags }),
-      ...(options.limit && { limit: options.limit }),
-    } as Partial<HistoryQuery>;
-
-    // Query historical runs
-    const runs = await context.historyStorage.queryRuns(query);
+    // Query runs using service
+    const queryService = new HistoryQueryService(context.historyStorage);
+    const runs = await queryService.queryWithDateParsing({
+      limit: options.all ? undefined : options.limit,
+      pattern: options.pattern,
+      since: options.since,
+      tags: options.tags,
+      until: options.until,
+    });
 
     if (runs.length === 0) {
       if (!options.quiet) {
         console.log('No historical data found matching criteria');
       }
-      return 0; // Success - no data is not an error
+      return 0;
     }
 
-    if (options.format === 'json') {
-      // TODO: Generate trends data in JSON format
-      const trendsData = {
-        runs: runs.length,
-        timespan: {
-          end: runs[0]?.startTime,
-          start: runs[runs.length - 1]?.startTime,
-        },
-        // TODO: Add actual trend calculations
-      };
-      console.log(JSON.stringify(trendsData, null, 2));
-    } else {
-      // Human format trends
-      if (!options.quiet) {
-        console.log(`Performance trends for ${runs.length} runs:`);
-        console.log(
-          `Time range: ${runs[runs.length - 1]?.startTime} to ${runs[0]?.startTime}`,
-        );
-        // TODO: Add trend analysis and visualization
-        console.log('(Trend analysis not yet implemented)');
-      }
+    // Analyze trends using service
+    const analysisService = new TrendAnalysisService();
+    const result = analysisService.analyzeTrends(runs);
+
+    // Format output
+    const formatter = new HistoryTrendsFormatter();
+    const output =
+      options.format === 'json'
+        ? formatter.formatJson(result)
+        : formatter.formatHuman(result);
+
+    if (!options.quiet || options.format !== 'human') {
+      console.log(output);
     }
 
-    return 0; // Success
+    return 0;
   } catch (error) {
-    console.error('Error showing trends:', error);
-    return 3; // Runtime error
-  }
-};
-
-/**
- * Parse date string (ISO 8601 or relative)
- */
-const parseDate = (dateStr: string): Date => {
-  // Try parsing as ISO 8601 first
-  const isoDate = new Date(dateStr);
-  if (!isNaN(isoDate.getTime())) {
-    return isoDate;
+    console.error(
+      'Failed to show trends:',
+      error instanceof Error ? error.message : String(error),
+    );
+    return 5;
   }
-
-  // TODO: Parse relative dates like "1 week ago", "3 days ago", etc.
-  // For now, throw error for invalid dates
-  throw new InvalidDateFormatError(`Invalid date format: "${dateStr}"`);
 };