devvami 1.2.0 → 1.3.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/help.js

@@ -58,14 +58,17 @@ const CATEGORIES = [
   {
     title: 'Tasks (ClickUp)',
     cmds: [
-      { id: 'tasks:list',  hint: '[--status] [--search]' },
-      { id: 'tasks:today', hint: '' },
+      { id: 'tasks:list',     hint: '[--status] [--search]' },
+      { id: 'tasks:today',    hint: '' },
+      { id: 'tasks:assigned', hint: '[--status] [--search]' },
     ],
   },
   {
     title: 'Cloud & Costi',
     cmds: [
-      { id: 'costs:get', hint: '[--period] [--profile]' },
+      { id: 'costs:get',   hint: '[SERVICE] [--period] [--group-by] [--tag-key]' },
+      { id: 'costs:trend', hint: '[--group-by] [--tag-key] [--line]' },
+      { id: 'logs',        hint: '[--group] [--filter] [--since] [--limit] [--region]' },
     ],
   },
   {
@@ -91,30 +94,12 @@ const CATEGORIES = [
       { id: 'doctor',     hint: '' },
       { id: 'auth:login', hint: '' },
       { id: 'whoami',     hint: '' },
+      { id: 'welcome',    hint: '' },
       { id: 'upgrade',    hint: '' },
     ],
   },
 ]
 
-// ─── Example commands shown at bottom of root help ──────────────────────────
-const EXAMPLES = [
-   { cmd: 'dvmi prompts list',                                    note: 'Sfoglia prompt AI dal tuo repository' },
-   { cmd: 'dvmi prompts list --filter refactor',                  note: 'Filtra prompt per parola chiave' },
-   { cmd: 'dvmi prompts download coding/refactor-prompt.md',      note: 'Scarica un prompt localmente' },
-   { cmd: 'dvmi prompts browse skills --query refactor',          note: 'Cerca skill su skills.sh' },
-   { cmd: 'dvmi prompts browse awesome --category agents',        note: 'Sfoglia awesome-copilot agents' },
-   { cmd: 'dvmi prompts run coding/refactor-prompt.md --tool opencode', note: 'Esegui un prompt con opencode' },
-   { cmd: 'dvmi docs read',                                       note: 'Leggi il README del repo corrente' },
-   { cmd: 'dvmi docs search "authentication"',                    note: 'Cerca nei docs del repo corrente' },
-   { cmd: 'dvmi repo list --search "api"',                        note: 'Filtra repository per nome' },
-   { cmd: 'dvmi pr status',                                       note: 'PR aperte e review in attesa' },
-   { cmd: 'dvmi pipeline status',                                 note: 'Ultimi workflow CI/CD' },
-   { cmd: 'dvmi tasks list --search "bug"',                       note: 'Cerca task ClickUp' },
-   { cmd: 'dvmi costs get --json',                                note: 'Costi AWS in formato JSON' },
-   { cmd: 'dvmi security setup --json',                          note: 'Controlla lo stato degli strumenti di sicurezza' },
-   { cmd: 'dvmi security setup',                                 note: 'Wizard interattivo: installa aws-vault e GCM' },
- ]
-
 // ─── Help class ─────────────────────────────────────────────────────────────
 
 /**
@@ -164,14 +149,41 @@ export default class CustomHelp extends Help {
 
   // ─── Private helpers ──────────────────────────────────────────────────────
 
-  /**
-   * Build the full categorized root help layout.
-   * @returns {string}
-   */
+   /**
+    * Build the full categorized root help layout.
+    * @returns {string}
+    */
   #buildRootLayout() {
     /** @type {Map<string, import('@oclif/core').Command.Cached>} */
     const cmdMap = new Map(this.config.commands.map((c) => [c.id, c]))
 
+    /** @type {Array<{cmd: string, note: string}>} */
+    const EXAMPLES = [
+      { cmd: 'dvmi prompts list',                                     note: 'Sfoglia prompt AI dal tuo repository' },
+      { cmd: 'dvmi prompts list --filter refactor',                   note: 'Filtra prompt per parola chiave' },
+      { cmd: 'dvmi prompts download coding/refactor-prompt.md',       note: 'Scarica un prompt localmente' },
+      { cmd: 'dvmi prompts browse skills --query refactor',           note: 'Cerca skill su skills.sh' },
+      { cmd: 'dvmi prompts browse awesome --category agents',         note: 'Sfoglia awesome-copilot agents' },
+      { cmd: 'dvmi prompts run coding/refactor-prompt.md --tool opencode', note: 'Esegui un prompt con opencode' },
+      { cmd: 'dvmi docs read',                                        note: 'Leggi il README del repo corrente' },
+      { cmd: 'dvmi docs search "authentication"',                     note: 'Cerca nei docs del repo corrente' },
+      { cmd: 'dvmi repo list --search "api"',                         note: 'Filtra repository per nome' },
+      { cmd: 'dvmi pr status',                                        note: 'PR aperte e review in attesa' },
+      { cmd: 'dvmi pipeline status',                                  note: 'Ultimi workflow CI/CD' },
+      { cmd: 'dvmi tasks list --search "bug"',                        note: 'Cerca task ClickUp' },
+      { cmd: 'dvmi tasks today',                                      note: 'Task in lavorazione oggi' },
+      { cmd: 'dvmi costs get --period mtd',                           note: 'Costi AWS mese corrente per servizio' },
+      { cmd: 'dvmi costs get --group-by tag --tag-key env',           note: 'Costi raggruppati per tag env' },
+      { cmd: 'dvmi costs trend --line',                               note: 'Trend costi 2 mesi (grafico lineare)' },
+      { cmd: 'dvmi costs get --json',                                 note: 'Costi AWS in formato JSON' },
+      { cmd: 'dvmi logs',                                             note: 'Sfoglia log CloudWatch in modo interattivo' },
+      { cmd: 'dvmi logs --group /aws/lambda/my-fn --since 24h',       note: 'Log Lambda ultimi 24h' },
+      { cmd: 'dvmi logs --group /aws/lambda/my-fn --filter "ERROR"',  note: 'Filtra eventi ERROR su un log group' },
+      { cmd: 'dvmi security setup --json',                            note: 'Controlla lo stato degli strumenti di sicurezza' },
+      { cmd: 'dvmi security setup',                                   note: 'Wizard interattivo: installa aws-vault e GCM' },
+      { cmd: 'dvmi welcome',                                          note: 'Dashboard missione dvmi con intro animata' },
+    ]
+
     const lines = []
 
      // ── Usage ──────────────────────────────────────────────────────────────