@artemiskit/cli 0.1.4 → 0.1.6

package/src/ui/errors.ts

@@ -0,0 +1,248 @@
+/**
+ * Enhanced error display formatting
+ */
+
+import chalk from 'chalk';
+import { isTTY, padText, truncate } from './utils.js';
+
+export interface ErrorContext {
+  /** Main error title */
+  title: string;
+  /** Reason for the error */
+  reason: string;
+  /** Actionable suggestions for the user */
+  suggestions?: string[];
+  /** Additional context details */
+  details?: Record<string, string>;
+  /** Error code (if applicable) */
+  code?: string;
+}
+
+/**
+ * Render an enhanced error panel with context and suggestions
+ *
+ * @example
+ * renderError({
+ *   title: 'Failed to connect to Azure OpenAI',
+ *   reason: 'Invalid API key or resource not found',
+ *   suggestions: [
+ *     'Check AZURE_OPENAI_API_KEY is set correctly',
+ *     'Verify resource name: my-openai-resource',
+ *     "Run 'artemiskit init' to reconfigure"
+ *   ]
+ * })
+ */
+export function renderError(ctx: ErrorContext): string {
+  const width = 60;
+
+  if (!isTTY) {
+    // Plain text format for CI/CD
+    const lines = [`ERROR: ${ctx.title}`, `Reason: ${ctx.reason}`];
+
+    if (ctx.code) {
+      lines.push(`Code: ${ctx.code}`);
+    }
+
+    if (ctx.details) {
+      for (const [key, value] of Object.entries(ctx.details)) {
+        lines.push(`${key}: ${value}`);
+      }
+    }
+
+    if (ctx.suggestions?.length) {
+      lines.push('Suggestions:');
+      for (const suggestion of ctx.suggestions) {
+        lines.push(`  - ${suggestion}`);
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  const innerWidth = width - 4;
+  const lines: string[] = [];
+
+  // Top border with ERROR label
+  const topBorder = '─'.repeat(width - 10);
+  lines.push(chalk.red(`┌─ ERROR ${topBorder}┐`));
+  lines.push(chalk.red('│') + ' '.repeat(width - 2) + chalk.red('│'));
+
+  // Title
+  lines.push(chalk.red('│') + padText(`  ${chalk.bold(ctx.title)}`, width - 2) + chalk.red('│'));
+  lines.push(chalk.red('│') + ' '.repeat(width - 2) + chalk.red('│'));
+
+  // Reason
+  const reasonText = truncate(ctx.reason, innerWidth - 10);
+  lines.push(chalk.red('│') + padText(`  Reason: ${reasonText}`, width - 2) + chalk.red('│'));
+
+  // Code (if present)
+  if (ctx.code) {
+    lines.push(
+      chalk.red('│') + padText(`  Code: ${chalk.dim(ctx.code)}`, width - 2) + chalk.red('│')
+    );
+  }
+
+  // Details (if present)
+  if (ctx.details && Object.keys(ctx.details).length > 0) {
+    lines.push(chalk.red('│') + ' '.repeat(width - 2) + chalk.red('│'));
+    for (const [key, value] of Object.entries(ctx.details)) {
+      const detailText = truncate(`${key}: ${value}`, innerWidth);
+      lines.push(
+        chalk.red('│') + padText(`  ${chalk.dim(detailText)}`, width - 2) + chalk.red('│')
+      );
+    }
+  }
+
+  // Suggestions
+  if (ctx.suggestions?.length) {
+    lines.push(chalk.red('│') + ' '.repeat(width - 2) + chalk.red('│'));
+    lines.push(chalk.red('│') + padText('  Suggestions:', width - 2) + chalk.red('│'));
+    for (const suggestion of ctx.suggestions) {
+      const suggestionText = truncate(suggestion, innerWidth - 4);
+      lines.push(
+        chalk.red('│') +
+          padText(`  ${chalk.yellow('•')} ${suggestionText}`, width - 2) +
+          chalk.red('│')
+      );
+    }
+  }
+
+  // Bottom border
+  lines.push(chalk.red('│') + ' '.repeat(width - 2) + chalk.red('│'));
+  lines.push(chalk.red(`└${'─'.repeat(width - 2)}┘`));
+
+  return lines.join('\n');
+}
+
+/**
+ * Render a warning panel (less severe than error)
+ */
+export function renderWarning(title: string, message: string, suggestions?: string[]): string {
+  const width = 60;
+
+  if (!isTTY) {
+    const lines = [`WARNING: ${title}`, message];
+    if (suggestions?.length) {
+      lines.push('Suggestions:');
+      for (const suggestion of suggestions) {
+        lines.push(`  - ${suggestion}`);
+      }
+    }
+    return lines.join('\n');
+  }
+
+  const innerWidth = width - 4;
+  const lines: string[] = [];
+
+  const topBorder = '─'.repeat(width - 12);
+  lines.push(chalk.yellow(`┌─ WARNING ${topBorder}┐`));
+  lines.push(chalk.yellow('│') + ' '.repeat(width - 2) + chalk.yellow('│'));
+  lines.push(chalk.yellow('│') + padText(`  ${chalk.bold(title)}`, width - 2) + chalk.yellow('│'));
+  lines.push(chalk.yellow('│') + ' '.repeat(width - 2) + chalk.yellow('│'));
+
+  // Word wrap message if needed
+  const words = message.split(' ');
+  let currentLine = '  ';
+  for (const word of words) {
+    if (currentLine.length + word.length + 1 <= innerWidth) {
+      currentLine += (currentLine.length > 2 ? ' ' : '') + word;
+    } else {
+      lines.push(chalk.yellow('│') + padText(currentLine, width - 2) + chalk.yellow('│'));
+      currentLine = '  ' + word;
+    }
+  }
+  if (currentLine.length > 2) {
+    lines.push(chalk.yellow('│') + padText(currentLine, width - 2) + chalk.yellow('│'));
+  }
+
+  if (suggestions?.length) {
+    lines.push(chalk.yellow('│') + ' '.repeat(width - 2) + chalk.yellow('│'));
+    for (const suggestion of suggestions) {
+      const suggestionText = truncate(suggestion, innerWidth - 4);
+      lines.push(
+        chalk.yellow('│') +
+          padText(`  ${chalk.dim('•')} ${suggestionText}`, width - 2) +
+          chalk.yellow('│')
+      );
+    }
+  }
+
+  lines.push(chalk.yellow('│') + ' '.repeat(width - 2) + chalk.yellow('│'));
+  lines.push(chalk.yellow(`└${'─'.repeat(width - 2)}┘`));
+
+  return lines.join('\n');
+}
+
+/**
+ * Format provider-specific error messages with suggestions
+ */
+export function getProviderErrorContext(provider: string, error: Error): ErrorContext {
+  const errorMessage = error.message.toLowerCase();
+
+  // OpenAI errors
+  if (provider === 'openai') {
+    if (errorMessage.includes('api key') || errorMessage.includes('authentication')) {
+      return {
+        title: 'OpenAI Authentication Failed',
+        reason: error.message,
+        suggestions: [
+          'Check that OPENAI_API_KEY is set correctly',
+          'Verify the API key is valid and not expired',
+          "Run 'artemiskit init' to reconfigure",
+        ],
+      };
+    }
+    if (errorMessage.includes('rate limit')) {
+      return {
+        title: 'OpenAI Rate Limit Exceeded',
+        reason: error.message,
+        suggestions: [
+          'Wait a moment and try again',
+          'Reduce concurrency with --concurrency flag',
+          'Consider upgrading your OpenAI plan',
+        ],
+      };
+    }
+  }
+
+  // Azure OpenAI errors
+  if (provider === 'azure-openai') {
+    if (errorMessage.includes('resource') || errorMessage.includes('deployment')) {
+      return {
+        title: 'Azure OpenAI Resource Error',
+        reason: error.message,
+        suggestions: [
+          'Verify AZURE_OPENAI_RESOURCE_NAME is correct',
+          'Check AZURE_OPENAI_DEPLOYMENT_NAME matches your deployment',
+          'Ensure the deployment exists in your Azure portal',
+        ],
+      };
+    }
+  }
+
+  // Anthropic errors
+  if (provider === 'anthropic') {
+    if (errorMessage.includes('api key') || errorMessage.includes('authentication')) {
+      return {
+        title: 'Anthropic Authentication Failed',
+        reason: error.message,
+        suggestions: [
+          'Check that ANTHROPIC_API_KEY is set correctly',
+          'Verify the API key is valid',
+          "Run 'artemiskit init' to reconfigure",
+        ],
+      };
+    }
+  }
+
+  // Generic fallback
+  return {
+    title: `${provider} Error`,
+    reason: error.message,
+    suggestions: [
+      'Check your provider configuration',
+      'Verify environment variables are set correctly',
+      "Run 'artemiskit init' to reconfigure",
+    ],
+  };
+}

package/src/ui/index.ts

@@ -0,0 +1,42 @@
+/**
+ * CLI UI Components
+ *
+ * Centralized UI utilities for consistent CLI output formatting.
+ */
+
+// Color scheme and icons
+export { colors, icons, colorByPercentage, formatPercentage } from './colors.js';
+
+// Utility functions
+export {
+  isTTY,
+  getTerminalWidth,
+  renderConditional,
+  centerText,
+  padText,
+  stripAnsi,
+  truncate,
+  formatDuration,
+  formatNumber,
+} from './utils.js';
+
+// Progress bars
+export { renderProgressBar, ProgressBar, renderInlineProgress } from './progress.js';
+export type { ProgressBarOptions } from './progress.js';
+
+// Summary panels
+export {
+  renderSummaryPanel,
+  renderStressSummaryPanel,
+  renderRedteamSummaryPanel,
+  renderInfoBox,
+} from './panels.js';
+export type { SummaryData, StressSummaryData, RedteamSummaryData } from './panels.js';
+
+// Error display
+export { renderError, renderWarning, getProviderErrorContext } from './errors.js';
+export type { ErrorContext } from './errors.js';
+
+// Live status tracking
+export { LiveTestStatus, Spinner, createSpinner } from './live-status.js';
+export type { TestStatus } from './live-status.js';

package/src/ui/live-status.ts

@@ -0,0 +1,259 @@
+/**
+ * Real-time test status updates
+ */
+
+import chalk from 'chalk';
+import ora, { type Ora } from 'ora';
+import { isTTY } from './utils.js';
+import { icons } from './colors.js';
+import { renderProgressBar } from './progress.js';
+
+export type TestStatus = 'pending' | 'running' | 'passed' | 'failed' | 'skipped';
+
+interface TestResult {
+  name: string;
+  status: TestStatus;
+  duration?: number;
+  error?: string;
+}
+
+/**
+ * Live test status tracker with real-time updates
+ */
+export class LiveTestStatus {
+  private spinner: Ora;
+  private results: Map<string, TestResult> = new Map();
+  private total: number;
+  private startTime: number = Date.now();
+
+  constructor(total: number) {
+    this.total = total;
+    this.spinner = ora({
+      spinner: 'dots',
+      color: 'cyan',
+    });
+  }
+
+  /**
+   * Start tracking a test
+   */
+  start(testId: string, testName: string): void {
+    this.results.set(testId, { name: testName, status: 'running' });
+
+    if (isTTY) {
+      this.spinner.start(this.formatStatus());
+    } else {
+      console.log(`Running: ${testName}`);
+    }
+  }
+
+  /**
+   * Mark a test as passed
+   */
+  pass(testId: string, duration?: number): void {
+    const result = this.results.get(testId);
+    if (result) {
+      result.status = 'passed';
+      result.duration = duration;
+    }
+    this.updateSpinner();
+  }
+
+  /**
+   * Mark a test as failed
+   */
+  fail(testId: string, error?: string, duration?: number): void {
+    const result = this.results.get(testId);
+    if (result) {
+      result.status = 'failed';
+      result.error = error;
+      result.duration = duration;
+    }
+    this.updateSpinner();
+  }
+
+  /**
+   * Mark a test as skipped
+   */
+  skip(testId: string): void {
+    const result = this.results.get(testId);
+    if (result) {
+      result.status = 'skipped';
+    }
+    this.updateSpinner();
+  }
+
+  /**
+   * Update spinner text
+   */
+  private updateSpinner(): void {
+    if (isTTY) {
+      this.spinner.text = this.formatStatus();
+    }
+  }
+
+  /**
+   * Format current status line
+   */
+  private formatStatus(): string {
+    const passed = this.countByStatus('passed');
+    const failed = this.countByStatus('failed');
+    const running = this.countByStatus('running');
+    const completed = passed + failed + this.countByStatus('skipped');
+
+    const progressBar = renderProgressBar(completed, this.total, {
+      width: 15,
+      showPercentage: false,
+      showCount: false,
+    });
+
+    return `${progressBar} ${chalk.green(passed)} passed, ${chalk.red(failed)} failed, ${chalk.blue(running)} running`;
+  }
+
+  /**
+   * Count results by status
+   */
+  private countByStatus(status: TestStatus): number {
+    return [...this.results.values()].filter((r) => r.status === status).length;
+  }
+
+  /**
+   * Complete tracking and print final status
+   */
+  complete(): void {
+    if (isTTY) {
+      this.spinner.stop();
+    }
+    this.printFinalStatus();
+  }
+
+  /**
+   * Print final status for all tests
+   */
+  private printFinalStatus(): void {
+    console.log('');
+
+    for (const [_, result] of this.results) {
+      const icon = this.getStatusIcon(result.status);
+      const duration = result.duration ? chalk.dim(` (${result.duration.toFixed(0)}ms)`) : '';
+      console.log(`${icon} ${result.name}${duration}`);
+
+      if (result.status === 'failed' && result.error) {
+        console.log(chalk.red(`    ${result.error}`));
+      }
+    }
+
+    console.log('');
+  }
+
+  /**
+   * Get icon for status
+   */
+  private getStatusIcon(status: TestStatus): string {
+    switch (status) {
+      case 'passed':
+        return icons.passed;
+      case 'failed':
+        return icons.failed;
+      case 'skipped':
+        return icons.skipped;
+      case 'running':
+        return icons.running;
+      default:
+        return chalk.gray('○');
+    }
+  }
+
+  /**
+   * Get summary statistics
+   */
+  getSummary(): { passed: number; failed: number; skipped: number; duration: number } {
+    return {
+      passed: this.countByStatus('passed'),
+      failed: this.countByStatus('failed'),
+      skipped: this.countByStatus('skipped'),
+      duration: Date.now() - this.startTime,
+    };
+  }
+}
+
+/**
+ * Simple spinner wrapper with consistent styling
+ */
+export class Spinner {
+  private spinner: Ora;
+
+  constructor(text?: string) {
+    this.spinner = ora({
+      text,
+      spinner: 'dots',
+      color: 'cyan',
+    });
+  }
+
+  start(text?: string): this {
+    if (isTTY) {
+      this.spinner.start(text);
+    } else if (text) {
+      console.log(text);
+    }
+    return this;
+  }
+
+  update(text: string): this {
+    if (isTTY) {
+      this.spinner.text = text;
+    }
+    return this;
+  }
+
+  succeed(text?: string): this {
+    if (isTTY) {
+      this.spinner.succeed(text);
+    } else if (text) {
+      console.log(`${icons.passed} ${text}`);
+    }
+    return this;
+  }
+
+  fail(text?: string): this {
+    if (isTTY) {
+      this.spinner.fail(text);
+    } else if (text) {
+      console.log(`${icons.failed} ${text}`);
+    }
+    return this;
+  }
+
+  warn(text?: string): this {
+    if (isTTY) {
+      this.spinner.warn(text);
+    } else if (text) {
+      console.log(`${icons.warning} ${text}`);
+    }
+    return this;
+  }
+
+  info(text?: string): this {
+    if (isTTY) {
+      this.spinner.info(text);
+    } else if (text) {
+      console.log(`${icons.info} ${text}`);
+    }
+    return this;
+  }
+
+  stop(): this {
+    if (isTTY) {
+      this.spinner.stop();
+    }
+    return this;
+  }
+}
+
+/**
+ * Create a new spinner instance
+ */
+export function createSpinner(text?: string): Spinner {
+  return new Spinner(text);
+}