devvami 1.0.0

package/src/commands/whoami.js

@@ -0,0 +1,85 @@
+import { Command } from '@oclif/core'
+import chalk from 'chalk'
+import ora from 'ora'
+import { createOctokit } from '../services/github.js'
+import { checkAWSAuth } from '../services/auth.js'
+import { getCurrentVersion } from '../services/version-check.js'
+import { CONFIG_PATH, loadConfig } from '../services/config.js'
+import { getUser, isAuthenticated } from '../services/clickup.js'
+
+export default class Whoami extends Command {
+  static description = 'Mostra la tua identita su GitHub, AWS e ClickUp'
+
+  static examples = [
+    '<%= config.bin %> whoami',
+    '<%= config.bin %> whoami --json',
+  ]
+
+  static enableJsonFlag = true
+
+  async run() {
+    const { flags } = await this.parse(Whoami)
+    const isJson = flags.json
+
+    const spinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Fetching identity...') }).start()
+
+    const [ghResult, awsResult, version, cuResult] = await Promise.allSettled([
+      (async () => {
+        const octokit = await createOctokit()
+        const { data: user } = await octokit.rest.users.getAuthenticated()
+        return { username: user.login, name: user.name ?? '', org: '', teams: [] }
+      })(),
+      checkAWSAuth(),
+      getCurrentVersion(),
+      (async () => {
+        if (!(await isAuthenticated())) return null
+        const [user, config] = await Promise.all([getUser(), loadConfig()])
+        return { username: user.username, teamName: config.clickup?.teamName ?? null }
+      })(),
+    ])
+
+    spinner?.stop()
+
+    const github =
+      ghResult.status === 'fulfilled'
+        ? ghResult.value
+        : { username: null, error: '[NOT AUTHENTICATED]' }
+
+    const aws =
+      awsResult.status === 'fulfilled' && awsResult.value.authenticated
+        ? { accountId: awsResult.value.account, role: awsResult.value.role }
+        : { accountId: null, error: '[NOT AUTHENTICATED]' }
+
+    const clickup =
+      cuResult.status === 'fulfilled' && cuResult.value
+        ? cuResult.value
+        : { username: null, teamName: null, error: '[NOT AUTHENTICATED]' }
+
+    const cli = {
+      version: version.status === 'fulfilled' ? version.value : '?',
+      configPath: CONFIG_PATH,
+    }
+
+    const result = { github, aws, clickup, cli }
+
+    if (isJson) return result
+
+    this.log(chalk.bold('\nGitHub'))
+    this.log(`  User: ${github.username ? chalk.cyan('@' + github.username) : chalk.red('[NOT AUTHENTICATED]')}`)
+    if (github.name) this.log(`  Name: ${github.name}`)
+
+    this.log(chalk.bold('\nAWS'))
+    this.log(`  Account: ${aws.accountId ?? chalk.red('[NOT AUTHENTICATED]')}`)
+    if (aws.role) this.log(`  Role: ${aws.role}`)
+
+    this.log(chalk.bold('\nClickUp'))
+    this.log(`  User: ${clickup.username ? chalk.cyan(clickup.username) : chalk.red('[NOT AUTHENTICATED]')}`)
+    if (clickup.teamName) this.log(`  Team: ${clickup.teamName}`)
+
+    this.log(chalk.bold('\nCLI'))
+    this.log(`  Version: ${cli.version}`)
+    this.log(`  Config:  ${cli.configPath}`)
+
+    return result
+  }
+}

package/src/formatters/cost.js

@@ -0,0 +1,54 @@
+/** @import { AWSCostEntry } from '../types.js' */
+
+/**
+ * Format a USD amount as currency string.
+ * @param {number} amount
+ * @returns {string}
+ */
+export function formatCurrency(amount) {
+  return `$${amount.toFixed(2)}`
+}
+
+/**
+ * Calculate total cost from entries.
+ * @param {AWSCostEntry[]} entries
+ * @returns {number}
+ */
+export function calculateTotal(entries) {
+  return entries.reduce((sum, e) => sum + e.amount, 0)
+}
+
+/**
+ * Format a trend percentage.
+ * @param {number} current
+ * @param {number} previous
+ * @returns {string}
+ */
+export function formatTrend(current, previous) {
+  if (previous === 0) return 'N/A'
+  const pct = ((current - previous) / previous) * 100
+  const sign = pct >= 0 ? '+' : ''
+  return `${sign}${pct.toFixed(1)}%`
+}
+
+/**
+ * Format cost entries as a printable table string.
+ * @param {AWSCostEntry[]} entries
+ * @param {string} serviceName
+ * @returns {string}
+ */
+export function formatCostTable(entries, serviceName) {
+  const total = calculateTotal(entries)
+  const rows = entries
+    .sort((a, b) => b.amount - a.amount)
+    .map((e) => `  ${e.serviceName.padEnd(40)} ${formatCurrency(e.amount)}`)
+    .join('\n')
+  const divider = '─'.repeat(50)
+  return [
+    `Costs for: ${serviceName}`,
+    divider,
+    rows,
+    divider,
+    `  ${'Total'.padEnd(40)} ${formatCurrency(total)}`,
+  ].join('\n')
+}

package/src/formatters/markdown.js

@@ -0,0 +1,108 @@
+import { marked } from 'marked'
+import chalk from 'chalk'
+import { deflate } from 'pako'
+
+// Custom terminal renderer — outputs ANSI-formatted text using chalk.
+// marked-terminal@7 is incompatible with all currently released versions of marked
+// due to an internal API break (this.o.text undefined).
+// This inline renderer has no external dependencies beyond chalk (already in deps).
+const terminalRenderer = {
+  heading(text, level) {
+    const stripped = text.replace(/<[^>]*>/g, '')
+    if (level === 1) return '\n' + chalk.bold.white(stripped) + '\n\n'
+    if (level === 2) return '\n' + chalk.bold(stripped) + '\n\n'
+    return '\n' + chalk.bold.dim(stripped) + '\n\n'
+  },
+  paragraph(text) {
+    return text + '\n\n'
+  },
+  strong(text) {
+    return chalk.bold(text)
+  },
+  em(text) {
+    return chalk.italic(text)
+  },
+  codespan(code) {
+    return chalk.bgGray.white(` ${code} `)
+  },
+  code(code, _lang) {
+    const lines = code.split('\n').map((l) => '  ' + chalk.gray(l))
+    return '\n' + lines.join('\n') + '\n\n'
+  },
+  blockquote(quote) {
+    return quote.split('\n').map((l) => chalk.dim('│ ') + chalk.italic(l)).join('\n') + '\n'
+  },
+  link(href, _title, text) {
+    return `${text} ${chalk.dim(`(${href})`)}`
+  },
+  image(href, _title, text) {
+    return `[image: ${text}] ${chalk.dim(`(${href})`)}`
+  },
+  list(body, _ordered) {
+    return body + '\n'
+  },
+  listitem(text) {
+    return '  • ' + text + '\n'
+  },
+  hr() {
+    return chalk.dim('─'.repeat(60)) + '\n\n'
+  },
+  br() {
+    return '\n'
+  },
+  del(text) {
+    return chalk.strikethrough(text)
+  },
+  text(text) {
+    return text
+  },
+  html(html) {
+    return html.replace(/<[^>]*>/g, '')
+  },
+}
+
+marked.use({ renderer: terminalRenderer })
+
+/**
+ * Render a markdown string as ANSI-formatted terminal output.
+ * @param {string} content - Raw markdown string
+ * @returns {string} ANSI-formatted string ready for terminal output
+ */
+export function renderMarkdown(content) {
+  return marked(content)
+}
+
+/**
+ * Extract all Mermaid diagram code blocks from a markdown string.
+ * @param {string} content - Raw markdown string
+ * @returns {string[]} Array of mermaid diagram source strings (without fences)
+ */
+export function extractMermaidBlocks(content) {
+  const regex = /```mermaid\n([\s\S]*?)```/g
+  const blocks = []
+  let match
+  while ((match = regex.exec(content)) !== null) {
+    blocks.push(match[1].trim())
+  }
+  return blocks
+}
+
+/**
+ * Encode a Mermaid diagram as a mermaid.live URL (pako-compressed).
+ * @param {string} diagramCode - Mermaid diagram source code
+ * @returns {string} Full mermaid.live view URL
+ */
+export function toMermaidLiveUrl(diagramCode) {
+  const state = JSON.stringify({
+    code: diagramCode,
+    mermaid: JSON.stringify({ theme: 'default' }),
+    updateDiagram: true,
+    grid: true,
+    panZoom: true,
+    rough: false,
+  })
+  const data = new TextEncoder().encode(state)
+  const compressed = deflate(data, { level: 9 })
+  const encoded = Buffer.from(compressed).toString('base64url')
+  return `https://mermaid.live/view#pako:${encoded}`
+}

package/src/formatters/openapi.js

@@ -0,0 +1,146 @@
+import { load } from 'js-yaml'
+
+/** @import { APIEndpoint, AsyncChannel } from '../types.js' */
+
+/**
+ * Parse a YAML or JSON string, returning null on error.
+ * @param {string} content
+ * @returns {Record<string, unknown>|null}
+ */
+export function parseYamlOrJson(content) {
+  try {
+    return JSON.parse(content)
+  } catch {
+    try {
+      return /** @type {Record<string, unknown>} */ (load(content))
+    } catch {
+      return null
+    }
+  }
+}
+
+/**
+ * Check whether a parsed document is an OpenAPI (3.x) or Swagger (2.0) spec.
+ * @param {Record<string, unknown>} doc
+ * @returns {boolean}
+ */
+export function isOpenApi(doc) {
+  return Boolean(doc?.openapi || doc?.swagger)
+}
+
+/**
+ * Check whether a parsed document is an AsyncAPI spec (2.x or 3.x).
+ * @param {Record<string, unknown>} doc
+ * @returns {boolean}
+ */
+export function isAsyncApi(doc) {
+  return Boolean(doc?.asyncapi)
+}
+
+/**
+ * Parse an OpenAPI/Swagger document into a list of APIEndpoints.
+ * @param {string} content - Raw YAML or JSON string
+ * @returns {{ endpoints: APIEndpoint[], error: string|null }}
+ */
+export function parseOpenApi(content) {
+  const doc = parseYamlOrJson(content)
+  if (!doc || !isOpenApi(doc)) {
+    return { endpoints: [], error: 'Not a valid OpenAPI/Swagger document' }
+  }
+
+  /** @type {APIEndpoint[]} */
+  const endpoints = []
+  const paths = /** @type {Record<string, Record<string, unknown>>} */ (doc.paths ?? {})
+
+  for (const [path, methods] of Object.entries(paths)) {
+    if (!methods || typeof methods !== 'object') continue
+    for (const [method, op] of Object.entries(methods)) {
+      if (!['get', 'post', 'put', 'patch', 'delete', 'head', 'options'].includes(method)) continue
+      const operation = /** @type {Record<string, unknown>} */ (op)
+      const rawParams = /** @type {Array<Record<string, unknown>>} */ (operation.parameters ?? [])
+      const parameters = rawParams
+        .map((p) => (p.required ? `${p.name}*` : String(p.name)))
+        .join(', ')
+      endpoints.push({
+        method: method.toUpperCase(),
+        path,
+        summary: String(operation.summary ?? ''),
+        parameters,
+      })
+    }
+  }
+
+  return { endpoints, error: null }
+}
+
+/**
+ * Parse an AsyncAPI document (2.x or 3.x) into a list of AsyncChannels.
+ * @param {string} content - Raw YAML or JSON string
+ * @returns {{ channels: AsyncChannel[], error: string|null }}
+ */
+export function parseAsyncApi(content) {
+  const doc = parseYamlOrJson(content)
+  if (!doc || !isAsyncApi(doc)) {
+    return { channels: [], error: 'Not a valid AsyncAPI document' }
+  }
+
+  /** @type {AsyncChannel[]} */
+  const channels = []
+  const version = String(doc.asyncapi ?? '')
+  const rawChannels = /** @type {Record<string, unknown>} */ (doc.channels ?? {})
+
+  if (version.startsWith('3')) {
+    // AsyncAPI 3.x: channels + operations
+    const rawOps = /** @type {Record<string, Record<string, unknown>>} */ (doc.operations ?? {})
+    for (const [channelName] of Object.entries(rawChannels)) {
+      const matchingOps = Object.values(rawOps).filter((op) => {
+        const ch = /** @type {Record<string, unknown>} */ (op.channel ?? {})
+        return String(ch.$ref ?? '').includes(channelName) || String(ch ?? '') === channelName
+      })
+      if (matchingOps.length === 0) {
+        channels.push({ channel: channelName, operation: '—', summary: '', message: '—' })
+      }
+      for (const op of matchingOps) {
+        const msgTitle = resolveMessageTitle(op.messages)
+        channels.push({
+          channel: channelName,
+          operation: String(op.action ?? '—'),
+          summary: String(op.summary ?? ''),
+          message: msgTitle,
+        })
+      }
+    }
+  } else {
+    // AsyncAPI 2.x: channels[name].publish / .subscribe
+    for (const [channelName, channelDef] of Object.entries(rawChannels)) {
+      const def = /** @type {Record<string, unknown>} */ (channelDef ?? {})
+      for (const op of ['publish', 'subscribe']) {
+        if (!def[op]) continue
+        const opDef = /** @type {Record<string, unknown>} */ (def[op])
+        const msgDef = /** @type {Record<string, unknown>} */ (opDef.message ?? {})
+        const msgTitle = String(msgDef.name ?? msgDef.title ?? '—')
+        channels.push({
+          channel: channelName,
+          operation: op,
+          summary: String(opDef.summary ?? ''),
+          message: msgTitle,
+        })
+      }
+    }
+  }
+
+  return { channels, error: null }
+}
+
+/**
+ * Resolve a message title from an AsyncAPI 3.x messages ref list.
+ * @param {unknown} messages
+ * @returns {string}
+ */
+function resolveMessageTitle(messages) {
+  if (!messages || typeof messages !== 'object') return '—'
+  const msgs = Object.values(/** @type {Record<string, unknown>} */ (messages))
+  if (msgs.length === 0) return '—'
+  const first = /** @type {Record<string, unknown>} */ (msgs[0])
+  return String(first.name ?? first.title ?? '—')
+}

package/src/formatters/status.js

@@ -0,0 +1,48 @@
+import chalk from 'chalk'
+import { colorStatus } from './table.js'
+
+/** @import { DoctorCheck } from '../types.js' */
+
+/**
+ * Format a DoctorCheck for terminal output.
+ * @param {DoctorCheck} check
+ * @returns {string}
+ */
+export function formatDoctorCheck(check) {
+  const badge = colorStatus(check.status)
+  const version = check.version ? chalk.gray(`  ${check.version}`) : ''
+  const hint = check.status !== 'ok' && check.hint ? chalk.dim(`\n    → ${check.hint}`) : ''
+  return `${badge}  ${check.name}${version}${hint}`
+}
+
+/**
+ * Format a summary line for doctor output.
+ * @param {{ ok: number, warn: number, fail: number }} summary
+ * @returns {string}
+ */
+export function formatDoctorSummary(summary) {
+  const parts = [
+    chalk.green(`${summary.ok} ok`),
+    chalk.yellow(`${summary.warn} warnings`),
+    chalk.red(`${summary.fail} failures`),
+  ]
+  return parts.join(', ')
+}
+
+/**
+ * Format a CI status badge.
+ * @param {'pass'|'fail'|'pending'|string} status
+ * @returns {string}
+ */
+export function formatCIStatus(status) {
+  return colorStatus(status)
+}
+
+/**
+ * Format a review status badge.
+ * @param {'approved'|'changes_requested'|'pending'|string} status
+ * @returns {string}
+ */
+export function formatReviewStatus(status) {
+  return colorStatus(status)
+}

package/src/formatters/table.js

@@ -0,0 +1,87 @@
+import chalk from 'chalk'
+
+/**
+ * @typedef {Object} TableColumn
+ * @property {string} header - Column header text
+ * @property {string} key - Key to extract from row object
+ * @property {number} [width] - Fixed max column width (truncates with … if exceeded)
+ * @property {function(*): string} [format] - Custom cell formatter (plain text, used for width calc)
+ * @property {function(string): string} [colorize] - Chalk color applied to formatted value at render time
+ */
+
+/**
+ * Truncate a string to max length, appending … if needed.
+ * @param {string} str
+ * @param {number} max
+ * @returns {string}
+ */
+function truncate(str, max) {
+  if (str.length <= max) return str
+  return str.slice(0, max - 1) + '…'
+}
+
+/**
+ * Get the plain (no ANSI) formatted value for a cell.
+ * @param {TableColumn} col
+ * @param {*} rawVal
+ * @returns {string}
+ */
+function plainCell(col, rawVal) {
+  const formatted = col.format ? col.format(rawVal) : String(rawVal ?? '')
+  return col.width ? truncate(formatted, col.width) : formatted
+}
+
+/**
+ * Render a list of objects as a terminal table.
+ * @param {Record<string, unknown>[]} rows
+ * @param {TableColumn[]} columns
+ * @returns {string}
+ */
+export function renderTable(rows, columns) {
+  if (rows.length === 0) return ''
+
+  // Calculate column widths from plain text (ANSI-safe)
+  const widths = columns.map((col) => {
+    if (col.width) return col.width
+    const headerLen = col.header.length
+    const maxDataLen = rows.reduce((max, row) => {
+      return Math.max(max, plainCell(col, row[col.key]).length)
+    }, 0)
+    return Math.max(headerLen, maxDataLen)
+  })
+
+  // Header row
+  const header = columns
+    .map((col, i) => chalk.bold.white(col.header.padEnd(widths[i])))
+    .join('  ')
+
+  // Divider
+  const divider = chalk.dim(widths.map((w) => '─'.repeat(w)).join('  '))
+
+  // Data rows
+  const dataRows = rows.map((row) =>
+    columns
+      .map((col, i) => {
+        const plain = plainCell(col, row[col.key])
+        const padding = ' '.repeat(Math.max(0, widths[i] - plain.length))
+        const colored = col.colorize ? col.colorize(plain) : plain
+        return colored + padding
+      })
+      .join('  '),
+  )
+
+  return [header, divider, ...dataRows].join('\n')
+}
+
+/**
+ * Format a status value with color.
+ * @param {'ok'|'warn'|'fail'|'pass'|'success'|'failure'|string} status
+ * @returns {string}
+ */
+export function colorStatus(status) {
+  const s = status?.toLowerCase() ?? ''
+  if (['ok', 'pass', 'success', 'approved'].includes(s)) return chalk.green('✓')
+  if (['warn', 'pending', 'in_progress', 'queued'].includes(s)) return chalk.yellow('⚠')
+  if (['fail', 'failure', 'error', 'changes_requested'].includes(s)) return chalk.red('✗')
+  return chalk.gray('○')
+}