@quenty/cli-output-helpers 1.10.0 → 1.11.0

package/src/reporting/github/annotations.ts

@@ -52,10 +52,7 @@ function _escapeProperty(value: string): string {
 
 /** Escape a workflow command message (data portion). */
 function _escapeMessage(value: string): string {
-  return value
-    .replace(/%/g, '%25')
-    .replace(/\r/g, '%0D')
-    .replace(/\n/g, '%0A');
+  return value.replace(/%/g, '%25').replace(/\r/g, '%0D').replace(/\n/g, '%0A');
 }
 
 // ── Annotation emission ─────────────────────────────────────────────────────
@@ -153,12 +150,12 @@ export function formatAnnotationSummaryMarkdown(
     );
   }
   if (summary.notices > 0) {
-    parts.push(
-      `${summary.notices} notice${summary.notices !== 1 ? 's' : ''}`
-    );
+    parts.push(`${summary.notices} notice${summary.notices !== 1 ? 's' : ''}`);
   }
 
-  md += `**${summary.total} issue${summary.total !== 1 ? 's' : ''}** across ${summary.fileCount} file${summary.fileCount !== 1 ? 's' : ''}: ${parts.join(', ')}\n\n`;
+  md += `**${summary.total} issue${summary.total !== 1 ? 's' : ''}** across ${
+    summary.fileCount
+  } file${summary.fileCount !== 1 ? 's' : ''}: ${parts.join(', ')}\n\n`;
 
   // Group diagnostics by file
   const byFile = new Map<string, Diagnostic[]>();
@@ -189,14 +186,16 @@ export function formatAnnotationSummaryMarkdown(
         d.severity === 'error'
           ? '`error`'
           : d.severity === 'warning'
-            ? '`warning`'
-            : '`notice`';
+          ? '`warning`'
+          : '`notice`';
       const escapedMsg = d.message.replace(/\|/g, '\\|').replace(/\n/g, ' ');
       md += `| ${d.line} | ${sev} | ${escapedMsg} |\n`;
     }
 
     if (diags.length > MAX_PER_FILE) {
-      md += `\n_... and ${diags.length - MAX_PER_FILE} more issue(s) in this file_\n`;
+      md += `\n_... and ${
+        diags.length - MAX_PER_FILE
+      } more issue(s) in this file_\n`;
     }
 
     md += '\n</details>\n\n';
@@ -226,7 +225,9 @@ export async function writeAnnotationSummaryAsync(
     OutputHelper.info('Written lint results to GitHub job summary.');
   } catch (err) {
     OutputHelper.warn(
-      `Failed to write job summary: ${err instanceof Error ? err.message : String(err)}`
+      `Failed to write job summary: ${
+        err instanceof Error ? err.message : String(err)
+      }`
     );
   }
 }

package/src/reporting/github/comment-table-reporter.ts

@@ -80,14 +80,14 @@ export class GithubCommentTableReporter extends BaseReporter {
     this._scheduleUpdate();
   }
 
-  override onPackagePhaseChange(
-    _name: string,
-    _phase: PackageStatus
-  ): void {
+  override onPackagePhaseChange(_name: string, _phase: PackageStatus): void {
     this._scheduleUpdate();
   }
 
-  override onPackageProgressUpdate(_name: string, _progress: ProgressSummary): void {
+  override onPackageProgressUpdate(
+    _name: string,
+    _progress: ProgressSummary
+  ): void {
     this._scheduleUpdate();
   }
 

package/src/reporting/github/formatting.ts

@@ -16,7 +16,11 @@ import {
   type IStateTracker,
   type PackageState,
 } from '../state/state-tracker.js';
-import { formatProgressInline, formatProgressResult, isEmptyTestRun } from '../progress-format.js';
+import {
+  formatProgressInline,
+  formatProgressResult,
+  isEmptyTestRun,
+} from '../progress-format.js';
 
 // ── Public types ────────────────────────────────────────────────────────────
 
@@ -111,7 +115,10 @@ const RUNNING_PHASE_LABELS: Record<string, string> = {
   executing: '🔄 Executing...',
 };
 
-export function formatRunningStatus(phase: PackageStatus, progress?: ProgressSummary): string {
+export function formatRunningStatus(
+  phase: PackageStatus,
+  progress?: ProgressSummary
+): string {
   const label = RUNNING_PHASE_LABELS[phase] ?? '🔄 Running...';
   if (progress) {
     const progressText = formatProgressInline(progress);
@@ -130,10 +137,10 @@ export function formatResultStatus(
   const empty = isEmptyTestRun(pkg.progressSummary);
 
   if (pkg.success) {
-    const label = progressText ? `${successLabel} ${progressText}` : successLabel;
-    return empty
-      ? `⚠️ ${label} (${duration})`
-      : `✅ ${label} (${duration})`;
+    const label = progressText
+      ? `${successLabel} ${progressText}`
+      : successLabel;
+    return empty ? `⚠️ ${label} (${duration})` : `✅ ${label} (${duration})`;
   }
 
   const failedPhase = pkg.failedPhase;
@@ -305,9 +312,7 @@ export function formatGithubTableBody(
     ).length;
     const running = packages.filter(
       (p) =>
-        p.status !== 'pending' &&
-        p.status !== 'passed' &&
-        p.status !== 'failed'
+        p.status !== 'pending' && p.status !== 'passed' && p.status !== 'failed'
     ).length;
     const pending = packages.filter((p) => p.status === 'pending').length;
     const parts: string[] = [];
@@ -330,14 +335,11 @@ export function formatGithubNoTestsBody(
   const actionsRunUrl = getActionsRunUrl();
   const heading = config.heading;
 
-  let body = config.commentMarker + '\n';
-  body += `## ${heading}\n\n`;
-  body += `ℹ️ **No tests to run**\n\n`;
-  body += `${message}\n`;
+  const logsPart = actionsRunUrl ? ` · [View logs](${actionsRunUrl})` : '';
 
-  if (actionsRunUrl) {
-    body += `\n[View logs](${actionsRunUrl})\n`;
-  }
+  let body = config.commentMarker + '\n';
+  body += `## ${heading}\n`;
+  body += `ℹ️ ${message}${logsPart}\n`;
 
   return body;
 }

package/src/reporting/github/job-summary-reporter.ts

@@ -79,7 +79,9 @@ export class GithubJobSummaryReporter extends BaseReporter {
       OutputHelper.info('Written results to GitHub job summary.');
     } catch (err) {
       OutputHelper.warn(
-        `Failed to write job summary: ${err instanceof Error ? err.message : String(err)}`
+        `Failed to write job summary: ${
+          err instanceof Error ? err.message : String(err)
+        }`
       );
     }
   }

package/src/reporting/grouped-reporter.ts

@@ -77,11 +77,15 @@ export class GroupedReporter extends BaseReporter {
     const empty = isEmptyTestRun(result.progressSummary);
 
     if (result.success) {
-      const label = progressText ? `${successLabel} ${progressText}` : successLabel;
+      const label = progressText
+        ? `${successLabel} ${progressText}`
+        : successLabel;
       const formatted = empty
         ? OutputHelper.formatWarning(`${label} ⚠`)
         : OutputHelper.formatSuccess(label);
-      const icon = empty ? OutputHelper.formatWarning('⚠') : OutputHelper.formatSuccess('✓');
+      const icon = empty
+        ? OutputHelper.formatWarning('⚠')
+        : OutputHelper.formatSuccess('✓');
       console.log(
         `  ${icon} ${formatted} ${OutputHelper.formatDim(`(${duration})`)}`
       );

package/src/reporting/index.ts

@@ -1,4 +1,4 @@
-// Core types and base class
+// Core types and base class — batch lifecycle (multi-package, phases, progress).
 export {
   BaseReporter,
   type Reporter,
@@ -12,6 +12,39 @@ export {
   type StepProgress,
 } from './reporter.js';
 
+// Single-result reporter — for one-shot or polled command output.
+export { BaseResultReporter, type ResultReporter } from './result-reporter.js';
+export {
+  StdoutResultReporter,
+  type StdoutResultReporterOptions,
+} from './stdout-result-reporter.js';
+export {
+  FileResultReporter,
+  type FileResultReporterOptions,
+} from './file-result-reporter.js';
+export {
+  WatchResultReporter,
+  type WatchResultReporterOptions,
+} from './watch-result-reporter.js';
+export { CompositeResultReporter } from './composite-result-reporter.js';
+export {
+  buildResultReporter,
+  type BuildResultReporterOptions,
+} from './build-result-reporter.js';
+
+// Output formatting primitives.
+export {
+  formatTable,
+  type TableColumn,
+  type TableOptions,
+} from './format-table.js';
+export { formatJson, type JsonOutputOptions } from './format-json.js';
+export {
+  createWatchRenderer,
+  type WatchRenderer,
+  type WatchRendererOptions,
+} from './watch-renderer.js';
+
 // Progress formatting helpers
 export {
   formatProgressInline,

package/src/reporting/json-file-reporter.ts

@@ -1,6 +1,7 @@
 import * as fs from 'fs/promises';
 import { OutputHelper } from '../outputHelper.js';
 import { BaseReporter } from './reporter.js';
+import { formatJson } from './format-json.js';
 import { type IStateTracker } from './state/state-tracker.js';
 
 /**
@@ -32,7 +33,7 @@ export class JsonFileReporter extends BaseReporter {
       },
     };
 
-    await fs.writeFile(this._outputPath, JSON.stringify(summary, null, 2));
+    await fs.writeFile(this._outputPath, formatJson(summary, { pretty: true }));
     OutputHelper.info(`Results written to ${this._outputPath}`);
   }
 }

package/src/reporting/progress-format.ts

@@ -20,7 +20,9 @@ export function formatProgressInline(progress?: ProgressSummary): string {
       return `(${progress.passed}/${progress.total})`;
     case 'bytes':
       if (progress.totalBytes > 0 && progress.transferredBytes > 0) {
-        return `(${_formatBytes(progress.transferredBytes)}/${_formatBytes(progress.totalBytes)})`;
+        return `(${_formatBytes(progress.transferredBytes)}/${_formatBytes(
+          progress.totalBytes
+        )})`;
       }
       return `(${_formatBytes(progress.totalBytes)})`;
     case 'steps':
@@ -79,7 +81,8 @@ export function summarizeFailure(
 
   if (error) {
     const firstLine = error.split('\n')[0];
-    const short = firstLine.length > 60 ? firstLine.slice(0, 57) + '...' : firstLine;
+    const short =
+      firstLine.length > 60 ? firstLine.slice(0, 57) + '...' : firstLine;
     if (parts.length > 0) {
       parts.push(`: ${short}`);
     } else {

package/src/reporting/reporter.ts

@@ -6,7 +6,17 @@
  */
 
 /** Execution phases a package can move through. */
-export type JobPhase = 'waiting' | 'building' | 'downloading' | 'merging' | 'combining' | 'uploading' | 'scheduling' | 'launching' | 'connecting' | 'executing';
+export type JobPhase =
+  | 'waiting'
+  | 'building'
+  | 'downloading'
+  | 'merging'
+  | 'combining'
+  | 'uploading'
+  | 'scheduling'
+  | 'launching'
+  | 'connecting'
+  | 'executing';
 
 /** Unified status for a package moving through the job lifecycle. */
 export type PackageStatus = 'pending' | JobPhase | 'passed' | 'failed';
@@ -94,7 +104,10 @@ export class BaseReporter implements Reporter {
   async startAsync(): Promise<void> {}
   onPackageStart(_packageName: string): void {}
   onPackagePhaseChange(_packageName: string, _phase: JobPhase): void {}
-  onPackageProgressUpdate(_packageName: string, _progress: ProgressSummary): void {}
+  onPackageProgressUpdate(
+    _packageName: string,
+    _progress: ProgressSummary
+  ): void {}
   onPackageResult(_result: PackageResult, _bufferedOutput?: string[]): void {}
   async stopAsync(): Promise<void> {}
 }

package/src/reporting/result-reporter.ts

@@ -0,0 +1,40 @@
+/**
+ * Single-result reporter — for commands that produce one result (or a polled
+ * series of results), as opposed to batch jobs with per-package lifecycle.
+ *
+ * Use this for any CLI command that:
+ *   - Runs once and prints a result to stdout
+ *   - Writes a result to a file via --output
+ *   - Polls a result on an interval and redraws (--watch)
+ *
+ * For batch jobs (multi-package, lifecycle phases, progress events), use the
+ * Reporter interface in reporter.ts instead.
+ */
+
+/**
+ * Lifecycle hooks for a single-result reporter. Implementations decide how
+ * to render the result (stdout, file, watch redraw, etc).
+ */
+export interface ResultReporter<T = unknown> {
+  /** Called once before any results are reported. */
+  startAsync(): Promise<void>;
+
+  /**
+   * Called when a result is available. May be called multiple times for
+   * watch mode (each tick produces a fresh result).
+   */
+  onResult(result: T): void;
+
+  /** Called once after the final result. */
+  stopAsync(): Promise<void>;
+}
+
+/**
+ * Base class with no-op defaults. Reporters extend this and override only
+ * the hooks they need.
+ */
+export class BaseResultReporter<T = unknown> implements ResultReporter<T> {
+  async startAsync(): Promise<void> {}
+  onResult(_result: T): void {}
+  async stopAsync(): Promise<void> {}
+}

package/src/reporting/simple-reporter.ts

@@ -40,7 +40,9 @@ export class SimpleReporter extends BaseReporter {
 
     const progressText = formatProgressResult(result.progressSummary);
     if (result.success) {
-      const msg = progressText ? `${this._successMessage} ${progressText}` : this._successMessage;
+      const msg = progressText
+        ? `${this._successMessage} ${progressText}`
+        : this._successMessage;
       OutputHelper.info(msg);
     } else {
       OutputHelper.error(this._failureMessage);

package/src/reporting/spinner-reporter.test.ts

@@ -13,12 +13,13 @@ function setup() {
   // Capture everything written to stdout
   const writes: string[] = [];
   const realWrite = process.stdout.write.bind(process.stdout);
-  vi.spyOn(process.stdout, 'write').mockImplementation(
-    ((chunk: any, ...args: any[]) => {
-      writes.push(typeof chunk === 'string' ? chunk : chunk.toString());
-      return true;
-    }) as any
-  );
+  vi.spyOn(process.stdout, 'write').mockImplementation(((
+    chunk: any,
+    ...args: any[]
+  ) => {
+    writes.push(typeof chunk === 'string' ? chunk : chunk.toString());
+    return true;
+  }) as any);
 
   // Suppress console.log (used by startAsync header)
   vi.spyOn(console, 'log').mockImplementation(() => {});

package/src/reporting/spinner-reporter.ts

@@ -2,7 +2,11 @@ import { OutputHelper } from '../outputHelper.js';
 import { formatDurationMs } from '../cli-utils.js';
 import { type PackageResult, BaseReporter } from './reporter.js';
 import { type IStateTracker } from './state/state-tracker.js';
-import { formatProgressInline, formatProgressResult, isEmptyTestRun } from './progress-format.js';
+import {
+  formatProgressInline,
+  formatProgressResult,
+  isEmptyTestRun,
+} from './progress-format.js';
 
 export interface SpinnerReporterOptions {
   showLogs: boolean;
@@ -122,8 +126,8 @@ export class SpinnerReporter extends BaseReporter {
       ? OutputHelper.formatSuccess('✓')
       : OutputHelper.formatError('✗');
     const status = result.success
-      ? (this._options.successLabel ?? 'Passed')
-      : (this._options.failureLabel ?? 'FAILED');
+      ? this._options.successLabel ?? 'Passed'
+      : this._options.failureLabel ?? 'FAILED';
     const formatted = result.success
       ? OutputHelper.formatSuccess(status)
       : OutputHelper.formatError(status);
@@ -172,10 +176,14 @@ export class SpinnerReporter extends BaseReporter {
           ? `${phaseLabel} ${progressText}`
           : phaseLabel;
         const statusText = OutputHelper.formatInfo(plain.padEnd(22));
-        line = `  ${icon} ${state.name.padEnd(30)} ${statusText} ${OutputHelper.formatDim(time)}`;
+        line = `  ${icon} ${state.name.padEnd(
+          30
+        )} ${statusText} ${OutputHelper.formatDim(time)}`;
       } else if (state.status === 'passed') {
         const icon = OutputHelper.formatSuccess('✓');
-        const progressText = formatProgressResult(state.result?.progressSummary);
+        const progressText = formatProgressResult(
+          state.result?.progressSummary
+        );
         const label = this._options.successLabel ?? 'Passed';
         const empty = isEmptyTestRun(state.result?.progressSummary);
         let plain = progressText ? `${label} ${progressText}` : label;
@@ -183,15 +191,19 @@ export class SpinnerReporter extends BaseReporter {
         const statusText = empty
           ? OutputHelper.formatWarning(plain.padEnd(22))
           : OutputHelper.formatSuccess(plain.padEnd(22));
-        line = `  ${icon} ${state.name.padEnd(30)} ${statusText} ${OutputHelper.formatDim(time)}`;
+        line = `  ${icon} ${state.name.padEnd(
+          30
+        )} ${statusText} ${OutputHelper.formatDim(time)}`;
       } else {
         const icon = OutputHelper.formatError('✗');
         const failedPhase = state.result?.failedPhase;
         const plain = failedPhase
           ? `${this._options.failureLabel ?? 'FAILED'} at ${failedPhase}`
-          : (this._options.failureLabel ?? 'FAILED');
+          : this._options.failureLabel ?? 'FAILED';
         const statusText = OutputHelper.formatError(plain.padEnd(22));
-        line = `  ${icon} ${state.name.padEnd(30)} ${statusText} ${OutputHelper.formatDim(time)}`;
+        line = `  ${icon} ${state.name.padEnd(
+          30
+        )} ${statusText} ${OutputHelper.formatDim(time)}`;
       }
 
       lines.push(line);

package/src/reporting/state/live-state-tracker.ts

@@ -1,4 +1,10 @@
-import { type PackageResult, type PackageStatus, type JobPhase, type ProgressSummary, BaseReporter } from '../reporter.js';
+import {
+  type PackageResult,
+  type PackageStatus,
+  type JobPhase,
+  type ProgressSummary,
+  BaseReporter,
+} from '../reporter.js';
 import { type IStateTracker, type PackageState } from './state-tracker.js';
 
 export type { PackageState } from './state-tracker.js';
@@ -8,10 +14,7 @@ export type { PackageState } from './state-tracker.js';
  * Extends BaseReporter to receive lifecycle hooks and mutate state.
  * Reporters read from it via the IStateTracker interface.
  */
-export class LiveStateTracker
-  extends BaseReporter
-  implements IStateTracker
-{
+export class LiveStateTracker extends BaseReporter implements IStateTracker {
   private _packages: Map<string, PackageState>;
   private _startTimeMs = 0;
   private _completed = 0;
@@ -77,7 +80,10 @@ export class LiveStateTracker
     state.progress = undefined; // clear progress on phase transition
   }
 
-  override onPackageProgressUpdate(name: string, progress: ProgressSummary): void {
+  override onPackageProgressUpdate(
+    name: string,
+    progress: ProgressSummary
+  ): void {
     const state = this._packages.get(name);
     if (!state) return;
     state.progress = progress;

package/src/reporting/state/loaded-state-tracker.ts

@@ -4,10 +4,7 @@ import {
   type PackageStatus,
   type BatchSummary,
 } from '../reporter.js';
-import {
-  type IStateTracker,
-  type PackageState,
-} from './state-tracker.js';
+import { type IStateTracker, type PackageState } from './state-tracker.js';
 
 /**
  * Batch state loaded from a previously-saved BatchSummary JSON file.
@@ -31,9 +28,7 @@ export class LoadedStateTracker implements IStateTracker {
     this._startTimeMs = startTimeMs;
   }
 
-  static async fromFileAsync(
-    filePath: string
-  ): Promise<LoadedStateTracker> {
+  static async fromFileAsync(filePath: string): Promise<LoadedStateTracker> {
     const raw = await fs.readFile(filePath, 'utf-8');
     const summary = JSON.parse(raw) as BatchSummary;
     return LoadedStateTracker.fromSummary(summary);

package/src/reporting/state/state-tracker.ts

@@ -1,4 +1,8 @@
-import { type PackageResult, type PackageStatus, type ProgressSummary } from '../reporter.js';
+import {
+  type PackageResult,
+  type PackageStatus,
+  type ProgressSummary,
+} from '../reporter.js';
 
 export interface PackageState {
   name: string;

package/src/reporting/stdout-result-reporter.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { StdoutResultReporter } from './stdout-result-reporter.js';
+
+describe('StdoutResultReporter', () => {
+  let logSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+  });
+
+  it('writes rendered result to stdout on each onResult', () => {
+    const reporter = new StdoutResultReporter<{ name: string }>({
+      render: (r) => `name=${r.name}`,
+    });
+
+    reporter.onResult({ name: 'first' });
+    reporter.onResult({ name: 'second' });
+
+    expect(logSpy).toHaveBeenCalledTimes(2);
+    expect(logSpy).toHaveBeenNthCalledWith(1, 'name=first');
+    expect(logSpy).toHaveBeenNthCalledWith(2, 'name=second');
+  });
+
+  it('startAsync and stopAsync are no-ops', async () => {
+    const reporter = new StdoutResultReporter<unknown>({ render: () => '' });
+    await reporter.startAsync();
+    await reporter.stopAsync();
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+});

package/src/reporting/stdout-result-reporter.ts

@@ -0,0 +1,23 @@
+/**
+ * Writes a rendered result to stdout. One-shot — calls render(result) and
+ * console.log(...) on each onResult.
+ */
+
+import { BaseResultReporter } from './result-reporter.js';
+
+export interface StdoutResultReporterOptions<T> {
+  render: (result: T) => string;
+}
+
+export class StdoutResultReporter<T = unknown> extends BaseResultReporter<T> {
+  private _render: (result: T) => string;
+
+  constructor(options: StdoutResultReporterOptions<T>) {
+    super();
+    this._render = options.render;
+  }
+
+  override onResult(result: T): void {
+    console.log(this._render(result));
+  }
+}

package/src/reporting/summary-table-reporter.ts

@@ -1,6 +1,7 @@
 import { OutputHelper } from '../outputHelper.js';
 import { formatDurationMs } from '../cli-utils.js';
-import { BaseReporter } from './reporter.js';
+import { BaseReporter, type PackageResult } from './reporter.js';
+import { formatTable, type TableColumn } from './format-table.js';
 import { type IStateTracker } from './state/state-tracker.js';
 import { formatProgressResult, isEmptyTestRun } from './progress-format.js';
 
@@ -39,44 +40,30 @@ export class SummaryTableReporter extends BaseReporter {
     const passed = results.length - failures.length;
     const durationMs = Date.now() - this._state.startTimeMs;
 
-    const STATUS_WIDTH = 26;
-
-    console.log('');
-    console.log('Package'.padEnd(40) + 'Status'.padEnd(STATUS_WIDTH) + 'Duration');
-    console.log('─'.repeat(40 + STATUS_WIDTH + 8));
-
     let emptyRunCount = 0;
-    for (const result of results) {
-      const progressText = formatProgressResult(result.progressSummary);
-      const empty = isEmptyTestRun(result.progressSummary);
-      if (empty) emptyRunCount++;
 
-      let label: string;
-      if (result.success) {
-        label = progressText ? `${this._successLabel} ${progressText}` : this._successLabel;
-      } else {
-        const failedPhase = result.failedPhase;
-        label = failedPhase
-          ? `${this._failureLabel} at ${failedPhase}`
-          : this._failureLabel;
-      }
+    const columns: TableColumn<PackageResult>[] = [
+      {
+        header: 'Package',
+        value: (r) => r.packageName,
+        minWidth: 40,
+      },
+      {
+        header: 'Status',
+        value: (r) => this._statusLabel(r),
+        format: (label, r) =>
+          this._colorStatus(label, r, () => emptyRunCount++),
+        minWidth: 26,
+      },
+      {
+        header: 'Duration',
+        value: (r) => formatDurationMs(r.durationMs),
+        format: (v) => OutputHelper.formatDim(v),
+      },
+    ];
 
-      // Pad the plain text BEFORE wrapping in ANSI so padEnd counts visible chars
-      const paddedLabel = label.padEnd(STATUS_WIDTH);
-      let status: string;
-      if (result.success) {
-        status = empty
-          ? OutputHelper.formatWarning(paddedLabel)
-          : OutputHelper.formatSuccess(paddedLabel);
-      } else {
-        status = OutputHelper.formatError(paddedLabel);
-      }
-
-      const duration = OutputHelper.formatDim(
-        formatDurationMs(result.durationMs)
-      );
-      console.log(result.packageName.padEnd(40) + status + duration);
-    }
+    console.log('');
+    console.log(formatTable(results, columns));
 
     console.log('');
     const passedText = OutputHelper.formatSuccess(`${passed} passed`);
@@ -99,4 +86,32 @@ export class SummaryTableReporter extends BaseReporter {
       );
     }
   }
+
+  private _statusLabel(result: PackageResult): string {
+    if (result.success) {
+      const progressText = formatProgressResult(result.progressSummary);
+      return progressText
+        ? `${this._successLabel} ${progressText}`
+        : this._successLabel;
+    }
+    const failedPhase = result.failedPhase;
+    return failedPhase
+      ? `${this._failureLabel} at ${failedPhase}`
+      : this._failureLabel;
+  }
+
+  private _colorStatus(
+    label: string,
+    result: PackageResult,
+    countEmpty: () => void
+  ): string {
+    if (result.success) {
+      const empty = isEmptyTestRun(result.progressSummary);
+      if (empty) countEmpty();
+      return empty
+        ? OutputHelper.formatWarning(label)
+        : OutputHelper.formatSuccess(label);
+    }
+    return OutputHelper.formatError(label);
+  }
 }