@artemiskit/cli 0.1.4 → 0.1.6

package/src/commands/run.ts

@@ -9,16 +9,25 @@ import {
   runScenario,
 } from '@artemiskit/core';
 import chalk from 'chalk';
-import Table from 'cli-table3';
 import { Command } from 'commander';
-import ora from 'ora';
-import { loadConfig } from '../config/loader';
+import { loadConfig } from '../config/loader.js';
+import {
+  createSpinner,
+  icons,
+  renderError,
+  renderProgressBar,
+  renderSummaryPanel,
+  getProviderErrorContext,
+  formatDuration,
+  padText,
+  isTTY,
+} from '../ui/index.js';
 import {
   buildAdapterConfig,
   resolveModelWithSource,
   resolveProviderWithSource,
-} from '../utils/adapter';
-import { createStorage } from '../utils/storage';
+} from '../utils/adapter.js';
+import { createStorage } from '../utils/storage.js';
 
 interface RunOptions {
   provider?: string;
@@ -57,7 +66,8 @@ export function runCommand(): Command {
       'Custom redaction patterns (regex or built-in: email, phone, credit_card, ssn, api_key)'
     )
     .action(async (scenarioPath: string, options: RunOptions) => {
-      const spinner = ora('Loading configuration...').start();
+      const spinner = createSpinner('Loading configuration...');
+      spinner.start();
 
       try {
         // Load config file if present
@@ -122,6 +132,15 @@ export function runCommand(): Command {
           console.log();
         }
 
+        // Track progress
+        const totalCases = scenario.cases.length;
+        let completedCases = 0;
+
+        // Calculate max widths for alignment
+        const maxIdLength = Math.max(...scenario.cases.map((c) => c.id.length));
+        const maxScoreLength = 6; // "(100%)"
+        const maxDurationLength = 6; // "10.0s" or "999ms"
+
         // Run scenario using core runner
         const result = await runScenario({
           scenario,
@@ -134,9 +153,29 @@ export function runCommand(): Command {
           retries: options.retries ? Number.parseInt(String(options.retries)) : undefined,
           redaction,
           onCaseComplete: (caseResult) => {
-            const statusIcon = caseResult.ok ? chalk.green('✓') : chalk.red('✗');
+            completedCases++;
+
+            const statusIcon = caseResult.ok ? icons.passed : icons.failed;
             const scoreStr = `(${(caseResult.score * 100).toFixed(0)}%)`;
-            console.log(`${statusIcon} ${caseResult.id} ${chalk.dim(scoreStr)}`);
+            const durationStr = caseResult.latencyMs ? formatDuration(caseResult.latencyMs) : '';
+
+            // Pad columns for alignment
+            const paddedId = padText(caseResult.id, maxIdLength);
+            const paddedScore = padText(scoreStr, maxScoreLength, 'right');
+            const paddedDuration = padText(durationStr, maxDurationLength, 'right');
+
+            // Show result - with progress bar in TTY, simple format in CI/CD
+            if (isTTY) {
+              const progressBar = renderProgressBar(completedCases, totalCases, { width: 15 });
+              console.log(
+                `${statusIcon} ${paddedId}  ${chalk.dim(paddedScore)}  ${chalk.dim(paddedDuration)}  ${progressBar}`
+              );
+            } else {
+              // CI/CD friendly output - no progress bar, just count
+              console.log(
+                `${statusIcon} ${paddedId}  ${chalk.dim(paddedScore)}  ${chalk.dim(paddedDuration)}  [${completedCases}/${totalCases}]`
+              );
+            }
 
             if (!caseResult.ok && options.verbose) {
               console.log(chalk.dim(`   Reason: ${caseResult.reason}`));
@@ -149,9 +188,35 @@ export function runCommand(): Command {
           },
         });
 
-        // Display summary
+        // Display summary using enhanced panel
         console.log();
-        displaySummary(result.manifest.metrics, result.manifest.run_id, result.manifest.redaction);
+        const summaryData = {
+          passed: result.manifest.metrics.passed_cases,
+          failed: result.manifest.metrics.failed_cases,
+          skipped: 0,
+          successRate: result.manifest.metrics.success_rate * 100,
+          duration: result.manifest.duration_ms,
+          title: 'TEST RESULTS',
+        };
+        console.log(renderSummaryPanel(summaryData));
+
+        // Show additional metrics
+        console.log();
+        console.log(
+          chalk.dim(
+            `Run ID: ${result.manifest.run_id}  |  Median Latency: ${result.manifest.metrics.median_latency_ms}ms  |  Tokens: ${result.manifest.metrics.total_tokens.toLocaleString()}`
+          )
+        );
+
+        // Show redaction info if enabled
+        if (result.manifest.redaction?.enabled) {
+          const r = result.manifest.redaction;
+          console.log(
+            chalk.dim(
+              `Redactions: ${r.summary.totalRedactions} (${r.summary.promptsRedacted} prompts, ${r.summary.responsesRedacted} responses)`
+            )
+          );
+        }
 
         // Save results
         if (options.save) {
@@ -167,9 +232,18 @@ export function runCommand(): Command {
         }
       } catch (error) {
         spinner.fail('Error');
-        console.error(chalk.red('Error:'), (error as Error).message);
+
+        // Get provider from options or default
+        const provider = options.provider || 'unknown';
+
+        // Display enhanced error message
+        const errorContext = getProviderErrorContext(provider, error as Error);
+        console.log();
+        console.log(renderError(errorContext));
+
         if (options.verbose) {
-          console.error((error as Error).stack);
+          console.log();
+          console.error(chalk.dim((error as Error).stack));
         }
         process.exit(1);
       }
@@ -177,57 +251,3 @@ export function runCommand(): Command {
 
   return cmd;
 }
-
-function displaySummary(
-  metrics: {
-    success_rate: number;
-    total_cases: number;
-    passed_cases: number;
-    failed_cases: number;
-    median_latency_ms: number;
-    total_tokens: number;
-  },
-  runId: string,
-  redaction?: {
-    enabled: boolean;
-    summary: {
-      promptsRedacted: number;
-      responsesRedacted: number;
-      totalRedactions: number;
-    };
-  }
-): void {
-  const table = new Table({
-    head: [chalk.bold('Metric'), chalk.bold('Value')],
-    style: { head: [], border: [] },
-  });
-
-  const successColor =
-    metrics.success_rate >= 0.9
-      ? chalk.green
-      : metrics.success_rate >= 0.7
-        ? chalk.yellow
-        : chalk.red;
-
-  table.push(
-    ['Run ID', runId],
-    ['Success Rate', successColor(`${(metrics.success_rate * 100).toFixed(1)}%`)],
-    ['Passed', chalk.green(metrics.passed_cases.toString())],
-    ['Failed', metrics.failed_cases > 0 ? chalk.red(metrics.failed_cases.toString()) : '0'],
-    ['Median Latency', `${metrics.median_latency_ms}ms`],
-    ['Total Tokens', metrics.total_tokens.toLocaleString()]
-  );
-
-  // Add redaction info if enabled
-  if (redaction?.enabled) {
-    table.push(
-      ['Redaction', chalk.yellow('Enabled')],
-      [
-        'Redactions Made',
-        `${redaction.summary.totalRedactions} (${redaction.summary.promptsRedacted} prompts, ${redaction.summary.responsesRedacted} responses)`,
-      ]
-    );
-  }
-
-  console.log(table.toString());
-}

package/src/commands/stress.ts

@@ -17,17 +17,25 @@ import {
 } from '@artemiskit/core';
 import { generateJSONReport, generateStressHTMLReport } from '@artemiskit/reports';
 import chalk from 'chalk';
-import Table from 'cli-table3';
 import { Command } from 'commander';
 import { nanoid } from 'nanoid';
-import ora from 'ora';
-import { loadConfig } from '../config/loader';
+import { loadConfig } from '../config/loader.js';
+import {
+  createSpinner,
+  renderStressSummaryPanel,
+  renderError,
+  renderInfoBox,
+  renderProgressBar,
+  getProviderErrorContext,
+  isTTY,
+  colors,
+} from '../ui/index.js';
 import {
   buildAdapterConfig,
   resolveModelWithSource,
   resolveProviderWithSource,
-} from '../utils/adapter';
-import { createStorage } from '../utils/storage';
+} from '../utils/adapter.js';
+import { createStorage } from '../utils/storage.js';
 
 interface StressOptions {
   provider?: string;
@@ -66,7 +74,8 @@ export function stressCommand(): Command {
       'Custom redaction patterns (regex or built-in: email, phone, credit_card, ssn, api_key)'
     )
     .action(async (scenarioPath: string, options: StressOptions) => {
-      const spinner = ora('Loading configuration...').start();
+      const spinner = createSpinner('Loading configuration...');
+      spinner.start();
       const startTime = new Date();
 
       try {
@@ -132,21 +141,22 @@ export function stressCommand(): Command {
           redactor = new Redactor(redactionConfig);
         }
 
+        // Display configuration using info box
         console.log();
-        console.log(chalk.bold('Stress Test Configuration'));
-        console.log(chalk.dim(`Concurrency: ${concurrency}`));
-        console.log(chalk.dim(`Duration: ${durationSec}s`));
-        console.log(chalk.dim(`Ramp-up: ${rampUpSec}s`));
+        const configLines = [
+          `Concurrency: ${concurrency}`,
+          `Duration: ${durationSec}s`,
+          `Ramp-up: ${rampUpSec}s`,
+        ];
         if (maxRequests) {
-          console.log(chalk.dim(`Max requests: ${maxRequests}`));
+          configLines.push(`Max requests: ${maxRequests}`);
         }
         if (options.redact) {
-          console.log(
-            chalk.dim(
-              `Redaction: enabled${options.redactPatterns ? ` (${options.redactPatterns.join(', ')})` : ' (default patterns)'}`
-            )
+          configLines.push(
+            `Redaction: enabled${options.redactPatterns ? ` (${options.redactPatterns.join(', ')})` : ''}`
           );
         }
+        console.log(renderInfoBox('Stress Test Configuration', configLines));
         console.log();
 
         // Get test prompts from scenario cases
@@ -169,8 +179,13 @@ export function stressCommand(): Command {
           rampUpMs: rampUpSec * 1000,
           maxRequests,
           temperature: scenario.temperature,
-          onProgress: (completed, active) => {
-            spinner.text = `Running stress test... ${completed} completed, ${active} active`;
+          onProgress: (completed, active, _total) => {
+            if (isTTY) {
+              const progress = maxRequests
+                ? renderProgressBar(completed, maxRequests, { width: 15, showPercentage: true })
+                : `${completed} completed`;
+              spinner.update(`Running stress test... ${progress}, ${active} active`);
+            }
           },
           verbose: options.verbose,
         });
@@ -232,8 +247,24 @@ export function stressCommand(): Command {
           redaction: redactionInfo,
         };
 
-        // Display stats
-        displayStats(metrics, runId);
+        // Display summary using enhanced panel
+        const summaryData = {
+          totalRequests: metrics.total_requests,
+          successfulRequests: metrics.successful_requests,
+          failedRequests: metrics.failed_requests,
+          successRate: metrics.success_rate * 100,
+          duration: endTime.getTime() - startTime.getTime(),
+          avgLatency: metrics.avg_latency_ms,
+          p50Latency: metrics.p50_latency_ms,
+          p95Latency: metrics.p95_latency_ms,
+          p99Latency: metrics.p99_latency_ms,
+          throughput: metrics.requests_per_second,
+        };
+        console.log(renderStressSummaryPanel(summaryData));
+
+        // Show run ID
+        console.log();
+        console.log(chalk.dim(`Run ID: ${runId}`));
 
         // Display latency histogram if verbose
         if (options.verbose) {
@@ -269,7 +300,13 @@ export function stressCommand(): Command {
         }
       } catch (error) {
         spinner.fail('Error');
-        console.error(chalk.red('Error:'), (error as Error).message);
+
+        // Display enhanced error message
+        const provider = options.provider || 'unknown';
+        const errorContext = getProviderErrorContext(provider, error as Error);
+        console.log();
+        console.log(renderError(errorContext));
+
         process.exit(1);
       }
     });
@@ -290,7 +327,7 @@ interface StressTestOptions {
   rampUpMs: number;
   maxRequests?: number;
   temperature?: number;
-  onProgress?: (completed: number, active: number) => void;
+  onProgress?: (completed: number, active: number, total?: number) => void;
   verbose?: boolean;
 }
 
@@ -343,7 +380,7 @@ async function runStressTest(options: StressTestOptions): Promise<StressRequestR
     } finally {
       active--;
       completed++;
-      onProgress?.(completed, active);
+      onProgress?.(completed, active, maxRequests);
     }
   };
 
@@ -428,45 +465,6 @@ function sampleResults(results: StressRequestResult[], maxSamples: number): Stre
   return sampled;
 }
 
-function displayStats(metrics: StressMetrics, runId: string): void {
-  const table = new Table({
-    head: [chalk.bold('Metric'), chalk.bold('Value')],
-    style: { head: [], border: [] },
-  });
-
-  table.push(
-    ['Run ID', runId],
-    ['Total Requests', metrics.total_requests.toString()],
-    ['Successful', chalk.green(metrics.successful_requests.toString())],
-    ['Failed', metrics.failed_requests > 0 ? chalk.red(metrics.failed_requests.toString()) : '0'],
-    ['', ''],
-    ['Requests/sec', metrics.requests_per_second.toFixed(2)],
-    ['', ''],
-    ['Min Latency', `${metrics.min_latency_ms}ms`],
-    ['Max Latency', `${metrics.max_latency_ms}ms`],
-    ['Avg Latency', `${metrics.avg_latency_ms}ms`],
-    ['p50 Latency', `${metrics.p50_latency_ms}ms`],
-    ['p90 Latency', `${metrics.p90_latency_ms}ms`],
-    ['p95 Latency', `${metrics.p95_latency_ms}ms`],
-    ['p99 Latency', `${metrics.p99_latency_ms}ms`]
-  );
-
-  console.log(chalk.bold('Results'));
-  console.log(table.toString());
-
-  // Success rate
-  const successRate = metrics.success_rate * 100;
-
-  console.log();
-  if (successRate >= 99) {
-    console.log(chalk.green(`✓ Success rate: ${successRate.toFixed(2)}%`));
-  } else if (successRate >= 95) {
-    console.log(chalk.yellow(`⚠ Success rate: ${successRate.toFixed(2)}%`));
-  } else {
-    console.log(chalk.red(`✗ Success rate: ${successRate.toFixed(2)}%`));
-  }
-}
-
 function displayHistogram(results: StressRequestResult[]): void {
   const successful = results.filter((r) => r.success);
   if (successful.length === 0) return;
@@ -492,10 +490,10 @@ function displayHistogram(results: StressRequestResult[]): void {
     const rangeEnd = (i + 1) * bucketSize;
     const count = buckets[i];
     const barLength = maxCount > 0 ? Math.round((count / maxCount) * 30) : 0;
-    const bar = '█'.repeat(barLength);
+    const bar = colors.highlight('█'.repeat(barLength));
 
     console.log(
-      `${chalk.dim(`${rangeStart.toString().padStart(5)}-${rangeEnd.toString().padStart(5)}ms`)} │ ${chalk.cyan(bar)} ${count}`
+      `${chalk.dim(`${rangeStart.toString().padStart(5)}-${rangeEnd.toString().padStart(5)}ms`)} │ ${bar} ${count}`
     );
   }
 }

package/src/ui/colors.ts

@@ -0,0 +1,62 @@
+/**
+ * Consistent color scheme for CLI output
+ */
+
+import chalk from 'chalk';
+
+export const colors = {
+  // Status colors
+  success: chalk.green,
+  error: chalk.red,
+  warning: chalk.yellow,
+  info: chalk.blue,
+  muted: chalk.gray,
+
+  // Semantic colors for test results
+  passed: chalk.green,
+  failed: chalk.red,
+  skipped: chalk.gray,
+  running: chalk.blue,
+
+  // UI elements
+  border: chalk.gray,
+  highlight: chalk.cyan,
+  label: chalk.bold,
+  value: chalk.white,
+
+  // Percentage thresholds
+  percentGood: chalk.green, // >= 90%
+  percentWarn: chalk.yellow, // >= 70%
+  percentBad: chalk.red, // < 70%
+};
+
+/**
+ * Returns appropriate color function based on percentage value
+ */
+export function colorByPercentage(value: number): typeof chalk {
+  if (value >= 90) return colors.percentGood;
+  if (value >= 70) return colors.percentWarn;
+  return colors.percentBad;
+}
+
+/**
+ * Format a percentage value with appropriate coloring
+ */
+export function formatPercentage(value: number): string {
+  const color = colorByPercentage(value);
+  return color(`${value.toFixed(1)}%`);
+}
+
+/**
+ * Status icons with colors
+ */
+export const icons = {
+  passed: chalk.green('✓'),
+  failed: chalk.red('✗'),
+  skipped: chalk.gray('○'),
+  running: chalk.blue('◉'),
+  warning: chalk.yellow('⚠'),
+  info: chalk.blue('ℹ'),
+  arrow: chalk.cyan('→'),
+  bullet: chalk.gray('•'),
+};