devvami 1.0.0

package/src/commands/init.js

@@ -0,0 +1,222 @@
+import { Command, Flags } from '@oclif/core'
+import chalk from 'chalk'
+import ora from 'ora'
+import { confirm, input, select } from '@inquirer/prompts'
+import { printBanner } from '../utils/banner.js'
+import { typewriterLine } from '../utils/typewriter.js'
+import { detectPlatform } from '../services/platform.js'
+import { exec, which } from '../services/shell.js'
+import { configExists, loadConfig, saveConfig, CONFIG_PATH } from '../services/config.js'
+import { oauthFlow, storeToken, validateToken, getTeams } from '../services/clickup.js'
+
+export default class Init extends Command {
+  static description = 'Setup completo ambiente di sviluppo locale'
+
+  static examples = [
+    '<%= config.bin %> init',
+    '<%= config.bin %> init --dry-run',
+    '<%= config.bin %> init --verbose',
+  ]
+
+  static enableJsonFlag = true
+
+  static flags = {
+    verbose: Flags.boolean({ description: 'Mostra output dettagliato', default: false }),
+    'dry-run': Flags.boolean({ description: 'Mostra cosa farebbe senza eseguire', default: false }),
+  }
+
+  async run() {
+    const { flags } = await this.parse(Init)
+    const isDryRun = flags['dry-run']
+    const isJson = flags.json
+
+    if (!isJson) await printBanner()
+
+    const platform = await detectPlatform()
+    const steps = []
+
+    // 1. Check prerequisites
+    const spinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Checking prerequisites...') }).start()
+    const prerequisites = [
+      { name: 'Node.js', cmd: 'node', args: ['--version'], required: true },
+      { name: 'nvm', cmd: 'nvm', args: ['--version'], required: false },
+      { name: 'npm', cmd: 'npm', args: ['--version'], required: true },
+      { name: 'Git', cmd: 'git', args: ['--version'], required: true },
+      { name: 'gh CLI', cmd: 'gh', args: ['--version'], required: true },
+      { name: 'Docker', cmd: 'docker', args: ['--version'], required: false },
+      { name: 'AWS CLI', cmd: 'aws', args: ['--version'], required: false },
+      { name: 'aws-vault', cmd: 'aws-vault', args: ['--version'], required: false },
+    ]
+
+    for (const prereq of prerequisites) {
+      const path = await which(prereq.cmd)
+      const status = path ? 'ok' : prereq.required ? 'fail' : 'warn'
+      steps.push({ name: prereq.name, status, action: path ? 'found' : 'missing' })
+      if (flags.verbose && !isJson) this.log(`  ${prereq.name}: ${path ?? 'not found'}`)
+    }
+    spinner?.succeed('Prerequisites checked')
+
+    // 2. Configure Git credential helper
+    const gitCredSpinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Configuring Git credential helper...') }).start()
+    if (!isDryRun) {
+      await exec('git', ['config', '--global', 'credential.helper', platform.credentialHelper])
+    }
+    steps.push({ name: 'git-credential', status: 'ok', action: isDryRun ? 'would configure' : 'configured' })
+    gitCredSpinner?.succeed(`Git credential helper: ${platform.credentialHelper}`)
+
+    // 3. Configure aws-vault (interactive if not configured)
+    const awsVaultInstalled = await which('aws-vault')
+    if (awsVaultInstalled) {
+      steps.push({ name: 'aws-vault', status: 'ok', action: 'found' })
+    } else {
+      steps.push({ name: 'aws-vault', status: 'warn', action: 'not installed' })
+      if (!isJson) this.log(chalk.yellow('  aws-vault not found. Install: brew install aws-vault'))
+    }
+
+    // 4. Create/update config
+    const configSpinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Creating config...') }).start()
+    let config = await loadConfig()
+
+     if (!configExists() && !isDryRun && !isJson) {
+       const useOrg = await confirm({ message: 'Do you use a GitHub organization? (y/n)', default: true })
+       let org = ''
+       if (useOrg) {
+         org = await input({ message: 'GitHub org name:', default: config.org || '' })
+       }
+       const awsProfile = await input({ message: 'AWS profile name:', default: config.awsProfile || 'default' })
+       const awsRegion = await input({ message: 'AWS region:', default: config.awsRegion || 'eu-west-1' })
+       config = { ...config, org, awsProfile, awsRegion, shell: platform.credentialHelper }
+     }
+
+    if (!isDryRun) {
+      await saveConfig(config)
+    }
+    steps.push({ name: 'config', status: 'ok', action: isDryRun ? 'would create' : 'created' })
+    configSpinner?.succeed(`Config: ${CONFIG_PATH}`)
+
+    // 5. ClickUp wizard (T008: interactive, T009: dry-run, T010: json)
+    if (isDryRun) {
+      // T009: In dry-run mode report what would happen without any network calls
+      steps.push({ name: 'clickup', status: 'would configure' })
+    } else if (isJson) {
+      // T010: In JSON mode skip wizard, report current ClickUp config status
+      config = await loadConfig()
+      steps.push({
+        name: 'clickup',
+        status: config.clickup?.teamId ? 'configured' : 'not_configured',
+        teamId: config.clickup?.teamId,
+        teamName: config.clickup?.teamName,
+        authMethod: config.clickup?.authMethod,
+      })
+    } else {
+      // T008: Full interactive wizard
+      const configureClickUp = await confirm({ message: 'Configure ClickUp integration?', default: true })
+       if (!configureClickUp) {
+         steps.push({ name: 'clickup', status: 'skipped' })
+         this.log(chalk.dim('  Skipped. Run `dvmi init` again to configure ClickUp later.'))
+       } else {
+        // Determine auth method
+        const clientId = process.env.CLICKUP_CLIENT_ID
+        const clientSecret = process.env.CLICKUP_CLIENT_SECRET
+        let authMethod = /** @type {'oauth'|'personal_token'} */ ('personal_token')
+
+        if (clientId && clientSecret) {
+          const choice = await select({
+            message: 'Select ClickUp authentication method:',
+            choices: [
+              { name: 'Personal API Token (paste from ClickUp Settings > Apps)', value: 'personal_token' },
+              { name: 'OAuth (opens browser)', value: 'oauth' },
+            ],
+          })
+          authMethod = /** @type {'oauth'|'personal_token'} */ (choice)
+        }
+
+        // Acquire token
+        if (authMethod === 'oauth') {
+          try {
+            this.log(chalk.dim('  Opening browser for OAuth authorization...'))
+            await oauthFlow(/** @type {string} */ (clientId), /** @type {string} */ (clientSecret))
+          } catch {
+            this.log(chalk.yellow('  OAuth failed. Falling back to Personal API Token.'))
+            authMethod = 'personal_token'
+          }
+        }
+
+        if (authMethod === 'personal_token') {
+          const token = await input({ message: 'Paste your ClickUp Personal API Token:' })
+          await storeToken(token)
+        }
+
+        // Validate token
+        const validateSpinner = ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Validating ClickUp credentials...') }).start()
+        let tokenValid = false
+        try {
+          const result = await validateToken()
+          tokenValid = result.valid
+          validateSpinner.succeed('ClickUp credentials validated')
+        } catch {
+          validateSpinner.fail('Failed to validate ClickUp credentials')
+        }
+
+        if (!tokenValid) {
+          this.log(chalk.yellow('  Invalid token. Check your ClickUp Personal API Token and try again.'))
+          const retry = await confirm({ message: 'Retry ClickUp configuration?', default: false })
+          if (!retry) {
+            steps.push({ name: 'clickup', status: 'skipped' })
+          } else {
+            const token = await input({ message: 'Paste your ClickUp Personal API Token:' })
+            await storeToken(token)
+            tokenValid = (await validateToken()).valid
+          }
+        }
+
+        if (tokenValid) {
+          // Fetch teams
+          let teamId = ''
+          let teamName = ''
+          const teamsSpinner = ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Fetching available teams...') }).start()
+          try {
+            const teams = await getTeams()
+            teamsSpinner.stop()
+            if (teams.length === 1) {
+              teamId = teams[0].id
+              teamName = teams[0].name
+              this.log(chalk.green('✓') + ` Auto-selected team: ${teamName} (${teamId})`)
+            } else if (teams.length > 1) {
+              const selected = await select({
+                message: 'Select your ClickUp team:',
+                choices: teams.map((t) => ({ name: `${t.name} (${t.id})`, value: t.id })),
+              })
+              teamId = selected
+              teamName = teams.find((t) => t.id === selected)?.name ?? ''
+            } else {
+              teamId = await input({ message: 'Enter ClickUp team ID:' })
+            }
+          } catch {
+            teamsSpinner.fail('Could not fetch teams')
+            teamId = await input({ message: 'Enter ClickUp team ID (find in ClickUp Settings > Spaces):' })
+          }
+
+          // Save ClickUp config
+          config = await loadConfig()
+          config = { ...config, clickup: { ...config.clickup, teamId, teamName, authMethod } }
+          await saveConfig(config)
+          this.log(chalk.green('✓') + ' ClickUp configured successfully!')
+          steps.push({ name: 'clickup', status: 'configured', teamId, teamName, authMethod })
+        }
+      }
+    }
+
+     // 6. Shell completions
+     steps.push({ name: 'shell-completions', status: 'ok', action: 'install via: dvmi autocomplete' })
+
+    const result = { steps, configPath: CONFIG_PATH }
+
+     if (isJson) return result
+
+     await typewriterLine('✓ Setup complete!')
+     this.log(chalk.dim('  Run `dvmi doctor` to verify your environment'))
+
+    return result
+  }
+}

package/src/commands/open.js

@@ -0,0 +1,75 @@
+import { Command, Args } from '@oclif/core'
+import chalk from 'chalk'
+import { exec } from '../services/shell.js'
+import { openBrowser } from '../utils/open-browser.js'
+import { loadConfig } from '../services/config.js'
+
+const VALID_TARGETS = ['repo', 'pr', 'actions', 'aws']
+
+export default class Open extends Command {
+  static description = 'Apri risorse nel browser (repo, pr, actions, aws)'
+
+  static examples = [
+    '<%= config.bin %> open repo',
+    '<%= config.bin %> open pr',
+    '<%= config.bin %> open actions',
+    '<%= config.bin %> open aws',
+    '<%= config.bin %> open repo --json',
+  ]
+
+  static enableJsonFlag = true
+
+  static args = {
+    target: Args.string({ description: 'Target: repo, pr, actions, aws', required: true }),
+  }
+
+  async run() {
+    const { args, flags } = await this.parse(Open)
+    const isJson = flags.json
+
+    if (!VALID_TARGETS.includes(args.target)) {
+      this.error(`Invalid target "${args.target}". Allowed: ${VALID_TARGETS.join(', ')}`)
+    }
+
+    let url = ''
+
+    if (args.target === 'aws') {
+      const config = await loadConfig()
+      const result = await exec('aws-vault', ['login', config.awsProfile, '--stdout'])
+      if (result.exitCode !== 0) this.error('AWS login failed. Run `dvmi auth login --aws`')
+      url = result.stdout
+    } else {
+      const remoteResult = await exec('git', ['remote', 'get-url', 'origin'])
+      if (remoteResult.exitCode !== 0) this.error('Not in a Git repository.')
+      const match = remoteResult.stdout.match(/github\.com[:/]([^/]+)\/([^/.]+?)(\.git)?$/)
+      if (!match) this.error('Could not detect GitHub repository.')
+      const [, owner, repo] = match
+      const baseUrl = `https://github.com/${owner}/${repo}`
+
+      if (args.target === 'repo') {
+        url = baseUrl
+      } else if (args.target === 'actions') {
+        url = `${baseUrl}/actions`
+      } else if (args.target === 'pr') {
+        const branchResult = await exec('git', ['rev-parse', '--abbrev-ref', 'HEAD'])
+        const branch = branchResult.stdout
+        // Try to find open PR for current branch
+        const prResult = await exec('gh', ['pr', 'view', '--json', 'url', '-H', branch])
+         if (prResult.exitCode === 0) {
+           url = JSON.parse(prResult.stdout).url
+         } else {
+           this.error(`No PR found for branch "${branch}". Create one with \`dvmi pr create\``)
+         }
+      }
+    }
+
+    const result = { target: args.target, url, opened: !isJson }
+
+    if (isJson) return result
+
+    await openBrowser(url)
+    this.log(chalk.green('✓') + ` Opened ${url}`)
+
+    return result
+  }
+}

package/src/commands/pipeline/logs.js

@@ -0,0 +1,41 @@
+import { Command, Args, Flags } from '@oclif/core'
+import { exec } from '../../services/shell.js'
+
+export default class PipelineLogs extends Command {
+  static description = 'Log di un workflow run specifico'
+
+  static examples = [
+    '<%= config.bin %> pipeline logs 12345',
+    '<%= config.bin %> pipeline logs 12345 --job test',
+  ]
+
+  static enableJsonFlag = true
+
+  static args = {
+    'run-id': Args.integer({ description: 'ID del workflow run', required: true }),
+  }
+
+  static flags = {
+    job: Flags.string({ description: 'Filtra per job name' }),
+  }
+
+  async run() {
+    const { args, flags } = await this.parse(PipelineLogs)
+    const isJson = flags.json
+
+    const ghArgs = ['run', 'view', String(args['run-id']), '--log']
+    if (flags.job) ghArgs.push('--job', flags.job)
+
+    const result = await exec('gh', ghArgs)
+    if (result.exitCode !== 0) {
+      this.error(`Run #${args['run-id']} not found or access denied.\n${result.stderr}`)
+    }
+
+    if (isJson) {
+      return { runId: args['run-id'], log: result.stdout }
+    }
+
+    this.log(result.stdout)
+    return { runId: args['run-id'], log: result.stdout }
+  }
+}

package/src/commands/pipeline/rerun.js

@@ -0,0 +1,66 @@
+import { Command, Flags } from '@oclif/core'
+import chalk from 'chalk'
+import ora from 'ora'
+import { confirm } from '@inquirer/prompts'
+import { listWorkflowRuns, rerunWorkflow } from '../../services/github.js'
+import { exec } from '../../services/shell.js'
+
+export default class PipelineRerun extends Command {
+  static description = 'Rilancia l\'ultimo workflow fallito'
+
+  static examples = [
+    '<%= config.bin %> pipeline rerun',
+    '<%= config.bin %> pipeline rerun --failed-only',
+    '<%= config.bin %> pipeline rerun --run-id 12345',
+  ]
+
+  static enableJsonFlag = true
+
+  static flags = {
+    'run-id': Flags.integer({ description: 'ID specifico del run' }),
+    'failed-only': Flags.boolean({ description: 'Rilancia solo i job falliti', default: false }),
+  }
+
+  async run() {
+    const { flags } = await this.parse(PipelineRerun)
+    const isJson = flags.json
+
+    const remoteResult = await exec('git', ['remote', 'get-url', 'origin'])
+    if (remoteResult.exitCode !== 0) this.error('Not in a Git repository.')
+    const match = remoteResult.stdout.match(/github\.com[:/]([^/]+)\/([^/.]+)/)
+    if (!match) this.error('Could not detect GitHub repository.')
+    const [, owner, repo] = match
+
+    let runId = flags['run-id']
+
+    if (!runId) {
+      const runs = await listWorkflowRuns(owner, repo, { limit: 10 })
+      const failed = runs.find((r) => r.conclusion === 'failure')
+      if (!failed) {
+        this.log(chalk.green('No failed runs found.'))
+        return
+      }
+      runId = failed.id
+      if (!isJson) {
+        this.log(`Last failed run: ${chalk.bold(failed.name)} (#${failed.id}) on ${failed.branch}`)
+      }
+    }
+
+    if (!isJson) {
+      const ok = await confirm({ message: `Rerun workflow #${runId}?` })
+      if (!ok) { this.log('Aborted.'); return }
+    }
+
+    const spinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Relaunching workflow...') }).start()
+    await rerunWorkflow(owner, repo, runId, flags['failed-only'])
+    spinner?.succeed(`Workflow #${runId} rerun started`)
+
+    const result = { rerun: { id: runId, failedOnly: flags['failed-only'], status: 'queued' } }
+
+     if (!isJson) {
+       this.log(chalk.dim('Track with `dvmi pipeline status`'))
+     }
+
+    return result
+  }
+}

package/src/commands/pipeline/status.js

@@ -0,0 +1,62 @@
+import { Command, Flags } from '@oclif/core'
+import chalk from 'chalk'
+import ora from 'ora'
+import { listWorkflowRuns } from '../../services/github.js'
+import { exec } from '../../services/shell.js'
+import { renderTable, colorStatus } from '../../formatters/table.js'
+
+export default class PipelineStatus extends Command {
+  static description = 'Stato GitHub Actions per il repo corrente'
+
+  static examples = [
+    '<%= config.bin %> pipeline status',
+    '<%= config.bin %> pipeline status --branch main',
+    '<%= config.bin %> pipeline status --limit 20 --json',
+  ]
+
+  static enableJsonFlag = true
+
+  static flags = {
+    branch: Flags.string({ description: 'Filtra per branch' }),
+    limit: Flags.integer({ description: 'Numero di run da mostrare', default: 10 }),
+  }
+
+  async run() {
+    const { flags } = await this.parse(PipelineStatus)
+    const isJson = flags.json
+
+     // Detect repo from git remote
+     const remoteResult = await exec('git', ['remote', 'get-url', 'origin'])
+     if (remoteResult.exitCode !== 0) {
+       this.error('Not in a Git repository. Navigate to a repo or use `dvmi repo list`')
+     }
+    const match = remoteResult.stdout.match(/github\.com[:/]([^/]+)\/([^/.]+)/)
+    if (!match) this.error('Could not detect GitHub repository.')
+    const [, owner, repo] = match
+
+    const spinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Fetching pipeline runs...') }).start()
+    const runs = await listWorkflowRuns(owner, repo, {
+      branch: flags.branch,
+      limit: flags.limit,
+    })
+    spinner?.stop()
+
+    if (isJson) return { runs }
+
+    if (runs.length === 0) {
+      this.log(chalk.dim('No workflow runs found.'))
+      return { runs: [] }
+    }
+
+    this.log(chalk.bold('\nGitHub Actions runs:\n'))
+    this.log(renderTable(runs, [
+      { header: 'Status', key: 'conclusion', width: 10, format: (v) => colorStatus(v ? String(v) : 'pending') },
+      { header: 'Workflow', key: 'name', width: 25 },
+      { header: 'Branch', key: 'branch', width: 20 },
+      { header: 'Duration', key: 'duration', width: 10, format: (v) => `${v}s` },
+      { header: 'Actor', key: 'actor', width: 15 },
+    ]))
+
+    return { runs }
+  }
+}

package/src/commands/pr/create.js

@@ -0,0 +1,114 @@
+import { Command, Flags } from '@oclif/core'
+import chalk from 'chalk'
+import ora from 'ora'
+import { confirm, input } from '@inquirer/prompts'
+import { createPR } from '../../services/github.js'
+import { exec } from '../../services/shell.js'
+import { readFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+
+/**
+ * @param {string} branchName
+ * @returns {string}
+ */
+function titleFromBranch(branchName) {
+  const [type, ...rest] = branchName.split('/')
+  const desc = rest.join('/').replace(/-/g, ' ')
+  const typeMap = { feature: 'Feature', fix: 'Fix', chore: 'Chore', hotfix: 'Hotfix' }
+  return `${typeMap[type] ?? type}: ${desc}`
+}
+
+/**
+ * @param {string} branchType
+ * @returns {string[]}
+ */
+function labelFromType(branchType) {
+  const map = { feature: ['feature'], fix: ['bug'], chore: ['chore'], hotfix: ['critical'] }
+  return map[branchType] ?? []
+}
+
+export default class PRCreate extends Command {
+  static description = 'Apri Pull Request precompilata con template, label e reviewer'
+
+  static examples = [
+    '<%= config.bin %> pr create',
+    '<%= config.bin %> pr create --draft',
+    '<%= config.bin %> pr create --title "My PR" --dry-run',
+  ]
+
+  static enableJsonFlag = true
+
+  static flags = {
+    title: Flags.string({ description: 'Titolo PR (default: auto-generated)' }),
+    draft: Flags.boolean({ description: 'Crea come draft', default: false }),
+    'dry-run': Flags.boolean({ description: 'Preview senza eseguire', default: false }),
+  }
+
+  async run() {
+    const { flags } = await this.parse(PRCreate)
+    const isJson = flags.json
+    const isDryRun = flags['dry-run']
+    // Get current branch
+    const branchResult = await exec('git', ['rev-parse', '--abbrev-ref', 'HEAD'])
+    if (branchResult.exitCode !== 0) this.error('Not in a Git repository.')
+    const branch = branchResult.stdout
+
+     if (['main', 'master', 'develop'].includes(branch)) {
+       this.error(`You're on the default branch "${branch}". Create a feature branch first with \`dvmi branch create\``)
+     }
+
+    // Check for commits
+    const repoUrl = await exec('git', ['remote', 'get-url', 'origin'])
+    const repoMatch = repoUrl.stdout.match(/github\.com[:/]([^/]+)\/([^/.]+)/)
+    if (!repoMatch) this.error('Could not detect GitHub repository from git remote.')
+    const [, owner, repo] = repoMatch
+
+    // Push branch if needed
+    const pushSpinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Pushing branch...') }).start()
+    await exec('git', ['push', '-u', 'origin', branch])
+    pushSpinner?.stop()
+
+    // Get PR template
+    let body = ''
+    const templatePaths = ['.github/pull_request_template.md', '.github/PULL_REQUEST_TEMPLATE.md']
+    for (const tp of templatePaths) {
+      if (existsSync(tp)) {
+        body = await readFile(tp, 'utf8')
+        break
+      }
+    }
+
+    // Generate title
+    const autoTitle = titleFromBranch(branch)
+    const title = flags.title ?? (isJson ? autoTitle : await input({ message: 'PR title:', default: autoTitle }))
+    const branchType = branch.split('/')[0]
+    const labels = labelFromType(branchType)
+
+    const preview = { branch, base: 'main', title, labels, draft: flags.draft }
+    if (isDryRun) {
+      if (isJson) return { pr: preview }
+      this.log(chalk.bold('Dry run — would create PR:'))
+      this.log(JSON.stringify(preview, null, 2))
+      return { pr: preview }
+    }
+
+    if (!isJson) {
+      const ok = await confirm({ message: `Create PR "${title}"?` })
+      if (!ok) { this.log('Aborted.'); return }
+    }
+
+    const spinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Creating PR...') }).start()
+    const pr = await createPR({
+      owner, repo, title, body,
+      head: branch, base: 'main',
+      draft: flags.draft, labels, reviewers: [],
+    })
+    spinner?.succeed(`PR created: ${pr.htmlUrl}`)
+
+    const result = { pr: { number: pr.number, title, url: pr.htmlUrl, labels, draft: flags.draft } }
+
+    if (isJson) return result
+    this.log(chalk.green('✓') + ' ' + pr.htmlUrl)
+    return result
+  }
+}

package/src/commands/pr/detail.js

@@ -0,0 +1,83 @@
+import { Command, Args, Flags } from '@oclif/core'
+import chalk from 'chalk'
+import ora from 'ora'
+import { getPRDetail } from '../../services/github.js'
+import { exec } from '../../services/shell.js'
+
+export default class PRDetail extends Command {
+  static description = 'Dettaglio PR con commenti QA e checklist degli step'
+
+  static examples = [
+    '<%= config.bin %> pr detail 42',
+    '<%= config.bin %> pr detail 42 --repo devvami/my-api',
+    '<%= config.bin %> pr detail 42 --json',
+  ]
+
+  static enableJsonFlag = true
+
+  static args = {
+    number: Args.integer({ description: 'Numero della PR', required: true }),
+  }
+
+  static flags = {
+    repo: Flags.string({ description: 'Repository nel formato owner/repo (default: rilevato da git remote)' }),
+  }
+
+  async run() {
+    const { args, flags } = await this.parse(PRDetail)
+    const isJson = flags.json
+
+    let owner, repo
+    if (flags.repo) {
+      const parts = flags.repo.split('/')
+      if (parts.length !== 2) this.error('--repo deve essere nel formato owner/repo')
+      ;[owner, repo] = parts
+    } else {
+      const repoUrl = await exec('git', ['remote', 'get-url', 'origin'])
+      const match = repoUrl.stdout.match(/github\.com[:/]([^/]+)\/([^/.]+)/)
+      if (!match) this.error('Impossibile rilevare il repository GitHub dal git remote. Usa --repo owner/repo')
+      ;[, owner, repo] = match
+    }
+
+    const spinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Caricamento PR...') }).start()
+    const detail = await getPRDetail(owner, repo, args.number)
+    spinner?.stop()
+
+    if (isJson) return detail
+
+    this.log(chalk.bold(`\nPR #${detail.number}: ${detail.title}`))
+    this.log(chalk.dim(`${detail.htmlUrl}\n`))
+
+    const stateColor = detail.state === 'open' ? chalk.green : chalk.red
+    this.log(`Stato:    ${stateColor(detail.state)}${detail.isDraft ? chalk.dim(' (draft)') : ''}`)
+    this.log(`Autore:   ${detail.author}`)
+    this.log(`Branch:   ${detail.headBranch} → ${detail.baseBranch}`)
+    if (detail.labels.length) this.log(`Label:    ${detail.labels.join(', ')}`)
+    if (detail.reviewers.length) this.log(`Reviewer: ${detail.reviewers.join(', ')}`)
+
+    if (detail.qaSteps.length > 0) {
+      this.log(chalk.bold('\n── QA Steps ─────────────────────'))
+      for (const step of detail.qaSteps) {
+        const icon = step.checked ? chalk.green('✓') : chalk.yellow('○')
+        this.log(`  ${icon}  ${step.text}`)
+      }
+    }
+
+    if (detail.qaComments.length > 0) {
+      this.log(chalk.bold('\n── QA Comments ──────────────────'))
+      for (const comment of detail.qaComments) {
+        this.log(chalk.dim(`@${comment.author} [${comment.createdAt.slice(0, 10)}]:`))
+        const lines = comment.body.split('\n').slice(0, 5)
+        this.log(lines.map((l) => `  ${l}`).join('\n'))
+        if (comment.body.split('\n').length > 5) this.log(chalk.dim('  ...'))
+        this.log('')
+      }
+    }
+
+    if (detail.qaComments.length === 0 && detail.qaSteps.length === 0) {
+      this.log(chalk.dim('\nNessun commento o step QA trovato.'))
+    }
+
+    return detail
+  }
+}