devvami 1.4.2 → 1.5.0

package/src/commands/init.js

@@ -1,34 +1,30 @@
-import { Command, Flags } from '@oclif/core'
+import {Command, Flags} from '@oclif/core'
 import chalk from 'chalk'
 import ora from 'ora'
-import { confirm, input, select } from '@inquirer/prompts'
-import { printWelcomeScreen } from '../utils/welcome.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'
-import { SUPPORTED_TOOLS } from '../services/prompts.js'
-import { isChezmoiInstalled, setupChezmoiInline } from '../services/dotfiles.js'
+import {confirm, input, select} from '@inquirer/prompts'
+import {printWelcomeScreen} from '../utils/welcome.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'
+import {SUPPORTED_TOOLS} from '../services/prompts.js'
+import {isChezmoiInstalled, setupChezmoiInline} from '../services/dotfiles.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 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 }),
+    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 {flags} = await this.parse(Init)
     const isDryRun = flags['dry-run']
     const isJson = flags.json
 
@@ -38,75 +34,82 @@ export default class Init extends Command {
     const steps = []
 
     // 1. Check prerequisites
-    const spinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Checking prerequisites...') }).start()
+    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 },
+      {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' })
+      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()
+    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' })
+    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' })
+      steps.push({name: 'aws-vault', status: 'ok', action: 'found'})
     } else {
-      steps.push({ name: 'aws-vault', status: 'warn', action: 'not installed' })
+      steps.push({name: 'aws-vault', status: 'warn', action: 'not installed'})
       if (!isJson) {
-        const installHint = platform.platform === 'macos'
-          ? 'brew install aws-vault'
-          : 'run `dvmi security setup` (Debian/Ubuntu/WSL2) or install aws-vault manually'
+        const installHint =
+          platform.platform === 'macos'
+            ? 'brew install aws-vault'
+            : 'run `dvmi security setup` (Debian/Ubuntu/WSL2) or install aws-vault manually'
         this.log(chalk.yellow(`  aws-vault not found. Install: ${installHint}`))
       }
     }
 
     // 4. Create/update config
-    const configSpinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Creating config...') }).start()
+    const configSpinner = isJson
+      ? null
+      : ora({spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Creating config...')}).start()
     let config = await loadConfig()
 
-     if (!configExists() && !isDryRun && !isJson) {
-       // Stop the spinner before interactive prompts to avoid TTY contention on macOS
-       configSpinner?.stop()
-       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 (!configExists() && !isDryRun && !isJson) {
+      // Stop the spinner before interactive prompts to avoid TTY contention on macOS
+      configSpinner?.stop()
+      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' })
+    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' })
+      steps.push({name: 'clickup', status: 'would configure'})
     } else if (isJson) {
       // T010: In JSON mode skip wizard, report current ClickUp config status
       config = await loadConfig()
@@ -119,11 +122,11 @@ export default class Init extends Command {
       })
     } 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 {
+      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
@@ -133,8 +136,8 @@ export default class Init extends Command {
           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' },
+              {name: 'Personal API Token (paste from ClickUp Settings > Apps)', value: 'personal_token'},
+              {name: 'OAuth (opens browser)', value: 'oauth'},
             ],
           })
           authMethod = /** @type {'oauth'|'personal_token'} */ (choice)
@@ -152,12 +155,16 @@ export default class Init extends Command {
         }
 
         if (authMethod === 'personal_token') {
-          const token = await input({ message: 'Paste your ClickUp Personal API 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()
+        const validateSpinner = ora({
+          spinner: 'arc',
+          color: false,
+          text: chalk.hex('#FF6B2B')('Validating ClickUp credentials...'),
+        }).start()
         let tokenValid = false
         try {
           const result = await validateToken()
@@ -169,11 +176,11 @@ export default class Init extends Command {
 
         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 })
+          const retry = await confirm({message: 'Retry ClickUp configuration?', default: false})
           if (!retry) {
-            steps.push({ name: 'clickup', status: 'skipped' })
+            steps.push({name: 'clickup', status: 'skipped'})
           } else {
-            const token = await input({ message: 'Paste your ClickUp Personal API Token:' })
+            const token = await input({message: 'Paste your ClickUp Personal API Token:'})
             await storeToken(token)
             tokenValid = (await validateToken()).valid
           }
@@ -183,7 +190,11 @@ export default class Init extends Command {
           // Fetch teams
           let teamId = ''
           let teamName = ''
-          const teamsSpinner = ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Fetching available teams...') }).start()
+          const teamsSpinner = ora({
+            spinner: 'arc',
+            color: false,
+            text: chalk.hex('#FF6B2B')('Fetching available teams...'),
+          }).start()
           try {
             const teams = await getTeams()
             teamsSpinner.stop()
@@ -194,97 +205,97 @@ export default class Init extends Command {
             } 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 })),
+                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:' })
+              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):' })
+            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 } }
+          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 })
+          steps.push({name: 'clickup', status: 'configured', teamId, teamName, authMethod})
         }
       }
     }
 
-     // 6. AI tool selection
-     if (isDryRun) {
-       steps.push({ name: 'ai-tool', status: 'would configure' })
-     } else if (isJson) {
-       config = await loadConfig()
-       steps.push({
-         name: 'ai-tool',
-         status: config.aiTool ? 'configured' : 'not_configured',
-         aiTool: config.aiTool,
-       })
-     } else {
-       const aiToolChoices = Object.keys(SUPPORTED_TOOLS).map((t) => ({ name: t, value: t }))
-       aiToolChoices.push({ name: 'none / skip', value: '' })
-       const aiTool = await select({
-         message: 'Select your preferred AI tool for `dvmi prompts run`:',
-         choices: aiToolChoices,
-       })
-       if (aiTool) {
-         config = { ...config, aiTool }
-         await saveConfig(config)
-         this.log(chalk.green(`✓ AI tool set to: ${aiTool}`))
-         steps.push({ name: 'ai-tool', status: 'configured', aiTool })
-       } else {
-         steps.push({ name: 'ai-tool', status: 'skipped' })
-       }
-     }
+    // 6. AI tool selection
+    if (isDryRun) {
+      steps.push({name: 'ai-tool', status: 'would configure'})
+    } else if (isJson) {
+      config = await loadConfig()
+      steps.push({
+        name: 'ai-tool',
+        status: config.aiTool ? 'configured' : 'not_configured',
+        aiTool: config.aiTool,
+      })
+    } else {
+      const aiToolChoices = Object.keys(SUPPORTED_TOOLS).map((t) => ({name: t, value: t}))
+      aiToolChoices.push({name: 'none / skip', value: ''})
+      const aiTool = await select({
+        message: 'Select your preferred AI tool for `dvmi prompts run`:',
+        choices: aiToolChoices,
+      })
+      if (aiTool) {
+        config = {...config, aiTool}
+        await saveConfig(config)
+        this.log(chalk.green(`✓ AI tool set to: ${aiTool}`))
+        steps.push({name: 'ai-tool', status: 'configured', aiTool})
+      } else {
+        steps.push({name: 'ai-tool', status: 'skipped'})
+      }
+    }
 
-     // 7. Chezmoi dotfiles setup
-     if (isDryRun) {
-       steps.push({ name: 'dotfiles', status: 'would configure' })
-     } else if (isJson) {
-       config = await loadConfig()
-       steps.push({
-         name: 'dotfiles',
-         status: config.dotfiles?.enabled ? 'configured' : 'not_configured',
-         enabled: config.dotfiles?.enabled ?? false,
-       })
-     } else {
-       const chezmoiInstalled = await isChezmoiInstalled()
-       if (!chezmoiInstalled) {
-         steps.push({ name: 'dotfiles', status: 'skipped', reason: 'chezmoi not installed' })
-       } else {
-         const setupDotfiles = await confirm({
-           message: 'Set up chezmoi dotfiles management with age encryption?',
-           default: false,
-         })
-         if (setupDotfiles) {
-           try {
-              const dotfilesResult = await setupChezmoiInline(platform.platform)
-             config = await loadConfig()
-             steps.push({ name: 'dotfiles', status: dotfilesResult.status, sourceDir: dotfilesResult.sourceDir })
-           } catch (err) {
-             steps.push({ name: 'dotfiles', status: 'failed', reason: err instanceof Error ? err.message : String(err) })
-           }
-         } else {
-           steps.push({ name: 'dotfiles', status: 'skipped', hint: 'Run `dvmi dotfiles setup` anytime to enable' })
-         }
-       }
-     }
+    // 7. Chezmoi dotfiles setup
+    if (isDryRun) {
+      steps.push({name: 'dotfiles', status: 'would configure'})
+    } else if (isJson) {
+      config = await loadConfig()
+      steps.push({
+        name: 'dotfiles',
+        status: config.dotfiles?.enabled ? 'configured' : 'not_configured',
+        enabled: config.dotfiles?.enabled ?? false,
+      })
+    } else {
+      const chezmoiInstalled = await isChezmoiInstalled()
+      if (!chezmoiInstalled) {
+        steps.push({name: 'dotfiles', status: 'skipped', reason: 'chezmoi not installed'})
+      } else {
+        const setupDotfiles = await confirm({
+          message: 'Set up chezmoi dotfiles management with age encryption?',
+          default: false,
+        })
+        if (setupDotfiles) {
+          try {
+            const dotfilesResult = await setupChezmoiInline(platform.platform)
+            config = await loadConfig()
+            steps.push({name: 'dotfiles', status: dotfilesResult.status, sourceDir: dotfilesResult.sourceDir})
+          } catch (err) {
+            steps.push({name: 'dotfiles', status: 'failed', reason: err instanceof Error ? err.message : String(err)})
+          }
+        } else {
+          steps.push({name: 'dotfiles', status: 'skipped', hint: 'Run `dvmi dotfiles setup` anytime to enable'})
+        }
+      }
+    }
 
-     // 8. Shell completions
-     steps.push({ name: 'shell-completions', status: 'ok', action: 'install via: dvmi autocomplete' })
+    // 8. Shell completions
+    steps.push({name: 'shell-completions', status: 'ok', action: 'install via: dvmi autocomplete'})
 
-    const result = { steps, configPath: CONFIG_PATH }
+    const result = {steps, configPath: CONFIG_PATH}
 
-     if (isJson) return result
+    if (isJson) return result
 
-     await typewriterLine('✓ Setup complete!')
-     this.log(chalk.dim('  Run `dvmi doctor` to verify your environment'))
+    await typewriterLine('✓ Setup complete!')
+    this.log(chalk.dim('  Run `dvmi doctor` to verify your environment'))
 
     return result
   }

package/src/commands/logs/index.js

@@ -1,9 +1,9 @@
-import { Command, Flags } from '@oclif/core'
+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'
+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']
 
@@ -44,7 +44,7 @@ export default class Logs extends Command {
   }
 
   async run() {
-    const { flags } = await this.parse(Logs)
+    const {flags} = await this.parse(Logs)
     const isJson = flags.json
 
     // Validate --limit
@@ -86,9 +86,7 @@ export default class Logs extends Command {
           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 }))
+            return groups.filter((g) => g.name.toLowerCase().includes(term)).map((g) => ({name: g.name, value: g.name}))
           },
         })
 
@@ -102,7 +100,7 @@ export default class Logs extends Command {
       }
     }
 
-    const { startTime, endTime } = sinceToEpochMs(/** @type {'1h'|'24h'|'7d'} */ (flags.since))
+    const {startTime, endTime} = sinceToEpochMs(/** @type {'1h'|'24h'|'7d'} */ (flags.since))
 
     const fetchSpinner = isJson ? null : ora('Fetching log events...').start()
 
@@ -171,14 +169,10 @@ export default class Logs extends Command {
   _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.',
-      )
+      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).`,
-      )
+      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.')

package/src/commands/open.js

@@ -1,8 +1,8 @@
-import { Command, Args } from '@oclif/core'
+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'
+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']
 
@@ -20,11 +20,11 @@ export default class Open extends Command {
   static enableJsonFlag = true
 
   static args = {
-    target: Args.string({ description: 'Target: repo, pr, actions, aws', required: true }),
+    target: Args.string({description: 'Target: repo, pr, actions, aws', required: true}),
   }
 
   async run() {
-    const { args, flags } = await this.parse(Open)
+    const {args, flags} = await this.parse(Open)
     const isJson = flags.json
 
     if (!VALID_TARGETS.includes(args.target)) {
@@ -55,15 +55,15 @@ export default class Open extends Command {
         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\``)
-         }
+        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 }
+    const result = {target: args.target, url, opened: !isJson}
 
     if (isJson) return result
 

package/src/commands/pipeline/logs.js

@@ -1,26 +1,23 @@
-import { Command, Args, Flags } from '@oclif/core'
-import { exec } from '../../services/shell.js'
+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 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 }),
+    'run-id': Args.integer({description: 'ID del workflow run', required: true}),
   }
 
   static flags = {
-    job: Flags.string({ description: 'Filtra per job name' }),
+    job: Flags.string({description: 'Filtra per job name'}),
   }
 
   async run() {
-    const { args, flags } = await this.parse(PipelineLogs)
+    const {args, flags} = await this.parse(PipelineLogs)
     const isJson = flags.json
 
     const ghArgs = ['run', 'view', String(args['run-id']), '--log']
@@ -32,10 +29,10 @@ export default class PipelineLogs extends Command {
     }
 
     if (isJson) {
-      return { runId: args['run-id'], log: result.stdout }
+      return {runId: args['run-id'], log: result.stdout}
     }
 
     this.log(result.stdout)
-    return { runId: args['run-id'], log: result.stdout }
+    return {runId: args['run-id'], log: result.stdout}
   }
 }

package/src/commands/pipeline/rerun.js

@@ -1,12 +1,12 @@
-import { Command, Flags } from '@oclif/core'
+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'
+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 description = "Rilancia l'ultimo workflow fallito"
 
   static examples = [
     '<%= config.bin %> pipeline rerun',
@@ -17,12 +17,12 @@ export default class PipelineRerun extends Command {
   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 }),
+    '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 {flags} = await this.parse(PipelineRerun)
     const isJson = flags.json
 
     const remoteResult = await exec('git', ['remote', 'get-url', 'origin'])
@@ -34,7 +34,7 @@ export default class PipelineRerun extends Command {
     let runId = flags['run-id']
 
     if (!runId) {
-      const runs = await listWorkflowRuns(owner, repo, { limit: 10 })
+      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.'))
@@ -47,19 +47,24 @@ export default class PipelineRerun extends Command {
     }
 
     if (!isJson) {
-      const ok = await confirm({ message: `Rerun workflow #${runId}?` })
-      if (!ok) { this.log('Aborted.'); return }
+      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()
+    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' } }
+    const result = {rerun: {id: runId, failedOnly: flags['failed-only'], status: 'queued'}}
 
-     if (!isJson) {
-       this.log(chalk.dim('Track with `dvmi pipeline status`'))
-     }
+    if (!isJson) {
+      this.log(chalk.dim('Track with `dvmi pipeline status`'))
+    }
 
     return result
   }