devvami 1.2.0 → 1.4.0

package/src/commands/logs/index.js

@@ -0,0 +1,190 @@
+import { Command, Flags } from '@oclif/core'
+import ora from 'ora'
+import { search, input } from '@inquirer/prompts'
+import { listLogGroups, filterLogEvents, sinceToEpochMs } from '../../services/cloudwatch-logs.js'
+import { loadConfig } from '../../services/config.js'
+import { DvmiError } from '../../utils/errors.js'
+
+const SINCE_OPTIONS = ['1h', '24h', '7d']
+
+export default class Logs extends Command {
+  static description = 'Browse and query CloudWatch log groups interactively'
+
+  static examples = [
+    '<%= config.bin %> logs',
+    '<%= config.bin %> logs --group /aws/lambda/my-fn',
+    '<%= config.bin %> logs --group /aws/lambda/my-fn --filter "ERROR" --since 24h',
+    '<%= config.bin %> logs --group /aws/lambda/my-fn --limit 50 --json',
+  ]
+
+  static enableJsonFlag = true
+
+  static flags = {
+    group: Flags.string({
+      description: 'Log group name — bypasses interactive picker',
+      char: 'g',
+    }),
+    filter: Flags.string({
+      description: 'CloudWatch filter pattern (empty = all events)',
+      char: 'f',
+      default: '',
+    }),
+    since: Flags.string({
+      description: 'Time window: 1h, 24h, 7d',
+      default: '1h',
+    }),
+    limit: Flags.integer({
+      description: 'Max log events to return (1–10000)',
+      default: 100,
+    }),
+    region: Flags.string({
+      description: 'AWS region (defaults to project config awsRegion)',
+      char: 'r',
+    }),
+  }
+
+  async run() {
+    const { flags } = await this.parse(Logs)
+    const isJson = flags.json
+
+    // Validate --limit
+    if (flags.limit < 1 || flags.limit > 10_000) {
+      throw new DvmiError('--limit must be between 1 and 10000.', '')
+    }
+
+    // Validate --since
+    if (!SINCE_OPTIONS.includes(flags.since)) {
+      throw new DvmiError('--since must be one of: 1h, 24h, 7d.', '')
+    }
+
+    const config = await loadConfig()
+    const region = flags.region ?? config.awsRegion ?? 'eu-west-1'
+
+    let logGroupName = flags.group
+    let filterPattern = flags.filter
+
+    // Interactive mode: pick log group + filter pattern
+    if (!logGroupName) {
+      const spinner = ora('Loading log groups...').start()
+      let groups
+      try {
+        groups = await listLogGroups(region)
+      } catch (err) {
+        spinner.stop()
+        this._handleAwsError(err, region)
+        throw err
+      }
+      spinner.stop()
+
+      if (groups.length === 0) {
+        this.log(`No log groups found in region ${region}. Check your AWS credentials and region.`)
+        return
+      }
+
+      try {
+        logGroupName = await search({
+          message: 'Select a log group',
+          source: async (input) => {
+            const term = (input ?? '').toLowerCase()
+            return groups
+              .filter((g) => g.name.toLowerCase().includes(term))
+              .map((g) => ({ name: g.name, value: g.name }))
+          },
+        })
+
+        filterPattern = await input({
+          message: 'Filter pattern (leave empty for all events)',
+          default: '',
+        })
+      } catch {
+        // Ctrl+C — clean exit with code 130
+        process.exit(130)
+      }
+    }
+
+    const { startTime, endTime } = sinceToEpochMs(/** @type {'1h'|'24h'|'7d'} */ (flags.since))
+
+    const fetchSpinner = isJson ? null : ora('Fetching log events...').start()
+
+    let result
+    try {
+      result = await filterLogEvents(logGroupName, filterPattern, startTime, endTime, flags.limit, region)
+    } catch (err) {
+      fetchSpinner?.stop()
+      this._handleAwsError(err, region, logGroupName)
+      throw err
+    }
+    fetchSpinner?.stop()
+
+    if (isJson) {
+      // NDJSON to stdout, summary to stderr
+      for (const event of result.events) {
+        this.log(
+          JSON.stringify({
+            eventId: event.eventId,
+            logStreamName: event.logStreamName,
+            timestamp: event.timestamp,
+            message: event.message,
+          }),
+        )
+      }
+      process.stderr.write(
+        JSON.stringify({
+          logGroupName: result.logGroupName,
+          filterPattern: result.filterPattern,
+          startTime: result.startTime,
+          endTime: result.endTime,
+          truncated: result.truncated,
+          count: result.events.length,
+        }) + '\n',
+      )
+      return
+    }
+
+    // Table output
+    const startIso = new Date(startTime).toISOString()
+    const endIso = new Date(endTime).toISOString()
+    const divider = '─'.repeat(74)
+
+    this.log(`Log Group: ${logGroupName}`)
+    this.log(`Period: last ${flags.since}  (${startIso} → ${endIso})`)
+    this.log(`Filter: ${filterPattern ? `"${filterPattern}"` : '(none)'}`)
+    this.log(divider)
+
+    for (const event of result.events) {
+      const ts = new Date(event.timestamp).toISOString()
+      const msg = event.message.length > 200 ? event.message.slice(0, 200) + '…' : event.message
+      this.log(`  ${ts}  ${event.logStreamName.slice(-20).padEnd(20)}  ${msg}`)
+    }
+
+    this.log(divider)
+    const truncationNotice = result.truncated ? '  [Truncated — use --limit or a narrower --since to see more]' : ''
+    this.log(`  ${result.events.length} events shown${truncationNotice}`)
+  }
+
+  /**
+   * Handle common AWS errors and throw DvmiError with spec-defined messages.
+   * @param {unknown} err
+   * @param {string} _region
+   * @param {string} [_logGroupName]
+   */
+  _handleAwsError(err, _region, _logGroupName) {
+    const msg = String(err)
+    if (msg.includes('AccessDenied') || msg.includes('UnauthorizedAccess')) {
+      this.error(
+        'Access denied. Ensure your role has logs:DescribeLogGroups and logs:FilterLogEvents permissions.',
+      )
+    }
+    if (msg.includes('ResourceNotFoundException')) {
+      this.error(
+        `Log group not found. Check the name and confirm you are using the correct region (--region).`,
+      )
+    }
+    if (msg.includes('InvalidParameterException')) {
+      this.error('Invalid filter pattern or parameter. Check the pattern syntax and time range.')
+    }
+    if (msg.includes('CredentialsProviderError') || msg.includes('No credentials')) {
+      this.error('No AWS credentials. Configure aws-vault and run `dvmi init` to set up your profile.')
+    }
+  }
+}

package/src/formatters/charts.js

@@ -0,0 +1,205 @@
+import chalk from 'chalk'
+
+/** @import { ChartSeries } from '../types.js' */
+
+// Colour palette for multi-series charts (cycles if more than 8 series)
+const PALETTE = [
+  chalk.cyan,
+  chalk.yellow,
+  chalk.green,
+  chalk.magenta,
+  chalk.blue,
+  chalk.red,
+  chalk.white,
+  chalk.gray,
+]
+
+/**
+ * Get the terminal width, falling back to 80 columns.
+ * @returns {number}
+ */
+function terminalWidth() {
+  return process.stdout.columns ?? 80
+}
+
+/**
+ * Scale a value to a bar width in characters.
+ * @param {number} value
+ * @param {number} max
+ * @param {number} maxWidth
+ * @returns {number}
+ */
+function scaleBar(value, max, maxWidth) {
+  if (max === 0) return 0
+  return Math.round((value / max) * maxWidth)
+}
+
+/**
+ * Render a single-series or stacked ASCII bar chart.
+ *
+ * Each series contributes a coloured segment to each bar. With a single series
+ * the bars are monochrome cyan. Labels on the x-axis are sampled to avoid
+ * overlap at ~10-column intervals.
+ *
+ * @param {ChartSeries[]} series - One or more data series
+ * @param {{ title?: string, width?: number }} [options]
+ * @returns {string}
+ */
+export function barChart(series, options = {}) {
+  if (!series.length) return '(no data)'
+
+  const width = options.width ?? Math.min(terminalWidth() - 2, 120)
+  const labelColWidth = 12 // space reserved for y-axis labels ($xx.xx)
+  const chartWidth = Math.max(width - labelColWidth - 2, 10)
+
+  // Combine all series into per-label totals for scaling
+  const allLabels = series[0]?.labels ?? []
+  const totals = allLabels.map((_, i) =>
+    series.reduce((sum, s) => sum + (s.values[i] ?? 0), 0),
+  )
+  const maxTotal = Math.max(...totals, 0)
+
+  const lines = []
+
+  if (options.title) {
+    lines.push(chalk.bold(options.title))
+    lines.push('─'.repeat(width))
+  }
+
+  // Bar rows: one per time label
+  const BAR_HEIGHT = 8
+
+  // Build chart column by column (one char per day)
+  // We render it as a 2D grid: rows = height levels, cols = days
+  const grid = Array.from({ length: BAR_HEIGHT }, () => Array(allLabels.length).fill(' '))
+
+  for (let col = 0; col < allLabels.length; col++) {
+    const total = totals[col]
+    const barLen = scaleBar(total, maxTotal, BAR_HEIGHT)
+
+    // Determine colour per series for stacked effect (simplified: colour by dominant series)
+    let dominantIdx = 0
+    let dominantVal = 0
+    for (let si = 0; si < series.length; si++) {
+      if ((series[si].values[col] ?? 0) > dominantVal) {
+        dominantVal = series[si].values[col] ?? 0
+        dominantIdx = si
+      }
+    }
+    const colour = PALETTE[dominantIdx % PALETTE.length]
+
+    for (let row = 0; row < barLen; row++) {
+      grid[BAR_HEIGHT - 1 - row][col] = colour('█')
+    }
+  }
+
+  // Render grid rows with y-axis labels on the leftmost and rightmost rows
+  for (let row = 0; row < BAR_HEIGHT; row++) {
+    let yLabel = '            '
+    if (row === 0) {
+      yLabel = `$${maxTotal.toFixed(2)}`.padStart(labelColWidth)
+    } else if (row === BAR_HEIGHT - 1) {
+      yLabel = '$0.00'.padStart(labelColWidth)
+    }
+
+    // Sample columns to fit chartWidth (one char per label, spaced if needed)
+    const step = Math.max(1, Math.ceil(allLabels.length / chartWidth))
+    const rowStr = grid[row].filter((_, i) => i % step === 0).join('')
+    lines.push(`${yLabel} ${rowStr}`)
+  }
+
+  // X-axis date labels (sample every ~10 positions)
+  const step = Math.max(1, Math.ceil(allLabels.length / Math.floor(chartWidth / 10)))
+  const xLabels = allLabels
+    .filter((_, i) => i % step === 0)
+    .map((l) => l.slice(5)) // "MM-DD"
+  lines.push(' '.repeat(labelColWidth + 1) + xLabels.join('         '))
+
+  // Legend for multi-series
+  if (series.length > 1) {
+    lines.push('')
+    lines.push(chalk.dim('Legend:'))
+    for (let i = 0; i < series.length; i++) {
+      const colour = PALETTE[i % PALETTE.length]
+      lines.push(`  ${colour('█')}  ${series[i].name}`)
+    }
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * Render an ASCII line chart. Each series is drawn as a distinct coloured line.
+ * Values are plotted on a fixed-height canvas using half-block characters.
+ *
+ * @param {ChartSeries[]} series - One or more data series
+ * @param {{ title?: string, width?: number }} [options]
+ * @returns {string}
+ */
+export function lineChart(series, options = {}) {
+  if (!series.length) return '(no data)'
+
+  const width = options.width ?? Math.min(terminalWidth() - 2, 120)
+  const labelColWidth = 12
+  const chartWidth = Math.max(width - labelColWidth - 2, 10)
+  const chartHeight = 10
+
+  const allLabels = series[0]?.labels ?? []
+  const allValues = series.flatMap((s) => s.values)
+  const maxVal = Math.max(...allValues, 0)
+
+  const lines = []
+
+  if (options.title) {
+    lines.push(chalk.bold(options.title))
+    lines.push('─'.repeat(width))
+  }
+
+  // Build a 2D canvas: rows = chartHeight, cols = chartWidth
+  const canvas = Array.from({ length: chartHeight }, () =>
+    Array(chartWidth).fill(' '),
+  )
+
+  const step = Math.max(1, Math.ceil(allLabels.length / chartWidth))
+
+  for (let si = 0; si < series.length; si++) {
+    const colour = PALETTE[si % PALETTE.length]
+    const sampledValues = series[si].values.filter((_, i) => i % step === 0)
+
+    for (let col = 0; col < Math.min(sampledValues.length, chartWidth); col++) {
+      const val = sampledValues[col] ?? 0
+      const row = maxVal === 0 ? chartHeight - 1 : chartHeight - 1 - Math.round((val / maxVal) * (chartHeight - 1))
+      canvas[Math.max(0, Math.min(row, chartHeight - 1))][col] = colour('●')
+    }
+  }
+
+  // Render rows with y-axis labels
+  for (let row = 0; row < chartHeight; row++) {
+    let yLabel = '            '
+    if (row === 0) {
+      yLabel = `$${maxVal.toFixed(2)}`.padStart(labelColWidth)
+    } else if (row === chartHeight - 1) {
+      yLabel = '$0.00'.padStart(labelColWidth)
+    }
+    lines.push(`${yLabel} ${canvas[row].join('')}`)
+  }
+
+  // X-axis date labels
+  const xStep = Math.max(1, Math.ceil(allLabels.length / Math.floor(chartWidth / 10)))
+  const xLabels = allLabels
+    .filter((_, i) => i % xStep === 0)
+    .map((l) => l.slice(5))
+  lines.push(' '.repeat(labelColWidth + 1) + xLabels.join('         '))
+
+  // Legend
+  if (series.length > 0) {
+    lines.push('')
+    lines.push(chalk.dim('Legend:'))
+    for (let i = 0; i < series.length; i++) {
+      const colour = PALETTE[i % PALETTE.length]
+      lines.push(`  ${colour('●')}  ${series[i].name}`)
+    }
+  }
+
+  return lines.join('\n')
+}

package/src/formatters/cost.js

@@ -1,4 +1,4 @@
-/** @import { AWSCostEntry } from '../types.js' */
+/** @import { AWSCostEntry, CostGroupMode } from '../types.js' */
 
 /**
  * Format a USD amount as currency string.
@@ -31,21 +31,34 @@ export function formatTrend(current, previous) {
   return `${sign}${pct.toFixed(1)}%`
 }
 
+/**
+ * Derive the display row label for a cost entry based on the grouping mode.
+ * @param {AWSCostEntry} entry
+ * @param {CostGroupMode} groupBy
+ * @returns {string}
+ */
+export function rowLabel(entry, groupBy) {
+  if (groupBy === 'tag') return entry.tagValue ?? entry.serviceName
+  if (groupBy === 'both') return `${entry.serviceName} / ${entry.tagValue ?? '(untagged)'}`
+  return entry.serviceName
+}
+
 /**
  * Format cost entries as a printable table string.
  * @param {AWSCostEntry[]} entries
- * @param {string} serviceName
+ * @param {string} label - Display label for the header
+ * @param {CostGroupMode} [groupBy] - Grouping mode (default: 'service')
  * @returns {string}
  */
-export function formatCostTable(entries, serviceName) {
+export function formatCostTable(entries, label, groupBy = 'service') {
   const total = calculateTotal(entries)
   const rows = entries
     .sort((a, b) => b.amount - a.amount)
-    .map((e) => `  ${e.serviceName.padEnd(40)} ${formatCurrency(e.amount)}`)
+    .map((e) => `  ${rowLabel(e, groupBy).padEnd(40)} ${formatCurrency(e.amount)}`)
     .join('\n')
   const divider = '─'.repeat(50)
   return [
-    `Costs for: ${serviceName}`,
+    `Costs for: ${label}`,
     divider,
     rows,
     divider,

package/src/formatters/dotfiles.js

@@ -0,0 +1,259 @@
+import chalk from 'chalk'
+
+/** @import { DotfilesSetupResult, DotfilesStatusResult, DotfilesAddResult, DotfilesSyncResult, DotfileEntry } from '../types.js' */
+
+const BORDER = chalk.dim('─'.repeat(60))
+
+// ---------------------------------------------------------------------------
+// formatDotfilesSetup (T020)
+// ---------------------------------------------------------------------------
+
+/**
+ * Format the output of `dvmi dotfiles setup` completion.
+ * @param {DotfilesSetupResult} result
+ * @returns {string}
+ */
+export function formatDotfilesSetup(result) {
+  const lines = [
+    '',
+    BORDER,
+    chalk.bold('  Dotfiles Setup — Summary'),
+    BORDER,
+    '',
+    chalk.bold(`  Platform:    ${chalk.cyan(result.platform)}`),
+    chalk.bold(`  Status:      ${result.status === 'success' ? chalk.green('success') : result.status === 'skipped' ? chalk.dim('skipped') : chalk.red('failed')}`),
+  ]
+
+  if (result.sourceDir) {
+    lines.push(chalk.white(`  Source dir:  ${chalk.cyan(result.sourceDir)}`))
+  }
+
+  if (result.publicKey) {
+    lines.push('')
+    lines.push(chalk.white(`  Age public key:`))
+    lines.push(chalk.cyan(`    ${result.publicKey}`))
+    lines.push('')
+    lines.push(chalk.yellow('  IMPORTANT: Back up your age key!'))
+    lines.push(chalk.dim(`    Key file: ~/.config/chezmoi/key.txt`))
+    lines.push(chalk.dim('    Without this key you cannot decrypt your dotfiles on a new machine.'))
+  }
+
+  if (result.status === 'success') {
+    lines.push('')
+    lines.push(chalk.bold.green('  Chezmoi configured with age encryption!'))
+    lines.push(chalk.dim('  Run `dvmi dotfiles add` to start tracking files'))
+  } else if (result.status === 'failed') {
+    lines.push('')
+    lines.push(chalk.bold.red('  Setup failed.'))
+    if (result.message) lines.push(chalk.dim(`  → ${result.message}`))
+  } else if (result.status === 'skipped') {
+    lines.push('')
+    if (result.message) lines.push(chalk.dim(`  ${result.message}`))
+  }
+
+  lines.push(BORDER)
+  return lines.join('\n')
+}
+
+// ---------------------------------------------------------------------------
+// formatDotfilesSummary (T012)
+// ---------------------------------------------------------------------------
+
+/**
+ * Format the file count summary line.
+ * @param {{ total: number, encrypted: number, plaintext: number }} summary
+ * @returns {string}
+ */
+export function formatDotfilesSummary(summary) {
+  return `${summary.total} total: ${summary.plaintext} plaintext, ${summary.encrypted} encrypted`
+}
+
+// ---------------------------------------------------------------------------
+// formatDotfilesStatus (T012 / T032)
+// ---------------------------------------------------------------------------
+
+/**
+ * Infer a display category from a file path.
+ * @param {string} filePath
+ * @returns {string}
+ */
+function inferCategory(filePath) {
+  const lower = filePath.toLowerCase()
+  if (lower.includes('.ssh') || lower.includes('.gnupg') || lower.includes('gpg') || lower.includes('secret') || lower.includes('credential') || lower.includes('token') || lower.includes('password')) return 'Security'
+  if (lower.includes('.gitconfig') || lower.includes('.gitignore') || lower.includes('.git')) return 'Git'
+  if (lower.includes('zshrc') || lower.includes('bashrc') || lower.includes('bash_profile') || lower.includes('zprofile') || lower.includes('fish')) return 'Shell'
+  if (lower.includes('vim') || lower.includes('nvim') || lower.includes('emacs') || lower.includes('vscode') || lower.includes('cursor')) return 'Editor'
+  if (lower.includes('brew') || lower.includes('npm') || lower.includes('yarn') || lower.includes('pip') || lower.includes('gem')) return 'Package'
+  return 'Other'
+}
+
+/**
+ * Format the full `dvmi dotfiles status` interactive output.
+ * @param {DotfilesStatusResult} result
+ * @returns {string}
+ */
+export function formatDotfilesStatus(result) {
+  const lines = [
+    '',
+    BORDER,
+    chalk.bold('  Dotfiles Status'),
+    BORDER,
+    '',
+    chalk.white(`  Platform:    ${chalk.cyan(result.platform)}`),
+  ]
+
+  if (result.sourceDir) {
+    lines.push(chalk.white(`  Source dir:  ${chalk.cyan(result.sourceDir)}`))
+  }
+
+  const encLabel = result.encryptionConfigured ? chalk.green('age (configured)') : chalk.dim('not configured')
+  lines.push(chalk.white(`  Encryption:  ${encLabel}`))
+
+  if (result.repo) {
+    lines.push(chalk.white(`  Remote:      ${chalk.cyan(result.repo)}`))
+  } else {
+    lines.push(chalk.white(`  Remote:      ${chalk.dim('not configured')}`))
+  }
+
+  if (!result.enabled) {
+    lines.push('')
+    lines.push(chalk.dim('  Dotfiles management not configured.'))
+    lines.push(chalk.dim('  Run `dvmi dotfiles setup` to get started.'))
+    lines.push(BORDER)
+    return lines.join('\n')
+  }
+
+  // Group files by category
+  /** @type {Record<string, DotfileEntry[]>} */
+  const grouped = {}
+  for (const file of result.files) {
+    const category = inferCategory(file.path)
+    if (!grouped[category]) grouped[category] = []
+    grouped[category].push(file)
+  }
+
+  const summaryLine = formatDotfilesSummary(result.summary)
+  lines.push('')
+  lines.push(chalk.bold(`  Managed Files (${summaryLine})`))
+  lines.push(BORDER)
+
+  for (const [category, files] of Object.entries(grouped)) {
+    const catLabel = category === 'Security' ? `  ${category} 🔒` : `  ${category}`
+    lines.push('')
+    lines.push(chalk.bold(catLabel))
+    for (const file of files) {
+      const encTag = file.encrypted ? chalk.dim('  encrypted') : ''
+      lines.push(`    ${file.path}${encTag}`)
+    }
+  }
+
+  if (result.files.length === 0) {
+    lines.push('')
+    lines.push(chalk.dim('  No files managed yet. Run `dvmi dotfiles add` to start tracking files.'))
+  }
+
+  lines.push('')
+  lines.push(BORDER)
+  return lines.join('\n')
+}
+
+// ---------------------------------------------------------------------------
+// formatDotfilesAdd (T027)
+// ---------------------------------------------------------------------------
+
+/**
+ * Format the output of `dvmi dotfiles add` completion.
+ * @param {DotfilesAddResult} result
+ * @returns {string}
+ */
+export function formatDotfilesAdd(result) {
+  const lines = [
+    '',
+    BORDER,
+    chalk.bold('  Dotfiles Add — Summary'),
+    BORDER,
+    '',
+  ]
+
+  if (result.added.length > 0) {
+    lines.push(chalk.bold(`  Added (${result.added.length}):`))
+    for (const item of result.added) {
+      const encTag = item.encrypted ? chalk.dim(' [encrypted]') : ''
+      lines.push(chalk.green(`    ✔ ${item.path}${encTag}`))
+    }
+    lines.push('')
+  }
+
+  if (result.skipped.length > 0) {
+    lines.push(chalk.bold(`  Skipped (${result.skipped.length}):`))
+    for (const item of result.skipped) {
+      lines.push(chalk.dim(`    ─ ${item.path}  ${item.reason}`))
+    }
+    lines.push('')
+  }
+
+  if (result.rejected.length > 0) {
+    lines.push(chalk.bold(`  Rejected (${result.rejected.length}):`))
+    for (const item of result.rejected) {
+      lines.push(chalk.red(`    ✗ ${item.path}  ${item.reason}`))
+    }
+    lines.push('')
+  }
+
+  if (result.added.length === 0 && result.skipped.length === 0 && result.rejected.length === 0) {
+    lines.push(chalk.dim('  No files processed.'))
+    lines.push('')
+  }
+
+  lines.push(BORDER)
+  return lines.join('\n')
+}
+
+// ---------------------------------------------------------------------------
+// formatDotfilesSync (T039 / T044)
+// ---------------------------------------------------------------------------
+
+/**
+ * Format the output of `dvmi dotfiles sync` completion.
+ * @param {DotfilesSyncResult} result
+ * @returns {string}
+ */
+export function formatDotfilesSync(result) {
+  const actionLabel = {
+    push: 'Push',
+    pull: 'Pull',
+    'init-remote': 'Remote Setup',
+    skipped: 'Skipped',
+  }[result.action] ?? result.action
+
+  const lines = [
+    '',
+    BORDER,
+    chalk.bold(`  Dotfiles Sync — ${actionLabel}`),
+    BORDER,
+    '',
+    chalk.white(`  Action:  ${chalk.cyan(actionLabel)}`),
+    chalk.white(`  Status:  ${result.status === 'success' ? chalk.green('success') : result.status === 'skipped' ? chalk.dim('skipped') : chalk.red('failed')}`),
+  ]
+
+  if (result.repo) {
+    lines.push(chalk.white(`  Remote:  ${chalk.cyan(result.repo)}`))
+  }
+
+  if (result.message) {
+    lines.push('')
+    lines.push(chalk.white(`  ${result.message}`))
+  }
+
+  if (result.conflicts && result.conflicts.length > 0) {
+    lines.push('')
+    lines.push(chalk.bold.red(`  Conflicts (${result.conflicts.length}):`))
+    for (const conflict of result.conflicts) {
+      lines.push(chalk.red(`    ✗ ${conflict}`))
+    }
+    lines.push(chalk.dim('  Resolve conflicts manually and run `chezmoi apply` to continue.'))
+  }
+
+  lines.push(BORDER)
+  return lines.join('\n')
+}