devvami 1.4.1 → 1.5.0

package/src/commands/dotfiles/sync.js

@@ -1,13 +1,13 @@
-import { Command, Flags, Args } from '@oclif/core'
+import {Command, Flags, Args} from '@oclif/core'
 import ora from 'ora'
 import chalk from 'chalk'
-import { confirm, input, select } from '@inquirer/prompts'
-import { detectPlatform } from '../../services/platform.js'
-import { isChezmoiInstalled, getChezmoiRemote, hasLocalChanges } from '../../services/dotfiles.js'
-import { loadConfig, saveConfig } from '../../services/config.js'
-import { exec, execOrThrow } from '../../services/shell.js'
-import { formatDotfilesSync } from '../../formatters/dotfiles.js'
-import { DvmiError } from '../../utils/errors.js'
+import {confirm, input, select} from '@inquirer/prompts'
+import {detectPlatform} from '../../services/platform.js'
+import {isChezmoiInstalled, getChezmoiRemote, hasLocalChanges} from '../../services/dotfiles.js'
+import {loadConfig, saveConfig} from '../../services/config.js'
+import {exec, execOrThrow} from '../../services/shell.js'
+import {formatDotfilesSync} from '../../formatters/dotfiles.js'
+import {DvmiError} from '../../utils/errors.js'
 
 /** @import { DotfilesSyncResult } from '../../types.js' */
 
@@ -26,18 +26,18 @@ export default class DotfilesSync extends Command {
   static enableJsonFlag = true
 
   static flags = {
-    help: Flags.help({ char: 'h' }),
-    push: Flags.boolean({ description: 'Push local changes to remote', default: false }),
-    pull: Flags.boolean({ description: 'Pull remote changes and apply', default: false }),
-    'dry-run': Flags.boolean({ description: 'Show what would change without applying', default: false }),
+    help: Flags.help({char: 'h'}),
+    push: Flags.boolean({description: 'Push local changes to remote', default: false}),
+    pull: Flags.boolean({description: 'Pull remote changes and apply', default: false}),
+    'dry-run': Flags.boolean({description: 'Show what would change without applying', default: false}),
   }
 
   static args = {
-    repo: Args.string({ description: 'Remote repository URL (for initial remote setup)', required: false }),
+    repo: Args.string({description: 'Remote repository URL (for initial remote setup)', required: false}),
   }
 
   async run() {
-    const { flags, args } = await this.parse(DotfilesSync)
+    const {flags, args} = await this.parse(DotfilesSync)
     const isJson = flags.json
     const isPush = flags.push
     const isPull = flags.pull
@@ -56,30 +56,27 @@ export default class DotfilesSync extends Command {
     const isCI = process.env.CI === 'true'
     const isNonInteractive = !process.stdout.isTTY
     if ((isCI || isNonInteractive) && !isJson) {
-      this.error(
-        'This command requires an interactive terminal (TTY). Run with --json for a non-interactive sync.',
-        { exit: 1 },
-      )
+      this.error('This command requires an interactive terminal (TTY). Run with --json for a non-interactive sync.', {
+        exit: 1,
+      })
     }
 
     const config = await loadConfig()
     if (!config.dotfiles?.enabled) {
-      throw new DvmiError(
-        'Chezmoi dotfiles management is not configured',
-        'Run `dvmi dotfiles setup` first',
-      )
+      throw new DvmiError('Chezmoi dotfiles management is not configured', 'Run `dvmi dotfiles setup` first')
     }
 
     const chezmoiInstalled = await isChezmoiInstalled()
     if (!chezmoiInstalled) {
       const platformInfo = await detectPlatform()
-      const hint = platformInfo.platform === 'macos'
-        ? 'Run `brew install chezmoi` or visit https://chezmoi.io/install'
-        : 'Run `sh -c "$(curl -fsLS get.chezmoi.io)"` or visit https://chezmoi.io/install'
+      const hint =
+        platformInfo.platform === 'macos'
+          ? 'Run `brew install chezmoi` or visit https://chezmoi.io/install'
+          : 'Run `sh -c "$(curl -fsLS get.chezmoi.io)"` or visit https://chezmoi.io/install'
       throw new DvmiError('chezmoi is not installed', hint)
     }
 
-    const remote = config.dotfiles?.repo ?? await getChezmoiRemote()
+    const remote = config.dotfiles?.repo ?? (await getChezmoiRemote())
 
     // --json mode: attempt push/pull or report status
     if (isJson) {
@@ -105,7 +102,13 @@ export default class DotfilesSync extends Command {
       }
 
       /** @type {DotfilesSyncResult} */
-      return { action: 'skipped', repo: effectiveRemote ?? null, status: 'skipped', message: 'No action specified', conflicts: [] }
+      return {
+        action: 'skipped',
+        repo: effectiveRemote ?? null,
+        status: 'skipped',
+        message: 'No action specified',
+        conflicts: [],
+      }
     }
 
     // ---------------------------------------------------------------------------
@@ -140,22 +143,29 @@ export default class DotfilesSync extends Command {
     const action = await select({
       message: 'What would you like to do?',
       choices: [
-        { name: 'Push local changes to remote', value: 'push' },
-        { name: 'Pull remote changes and apply', value: 'pull' },
-        { name: 'Cancel', value: 'cancel' },
+        {name: 'Push local changes to remote', value: 'push'},
+        {name: 'Pull remote changes and apply', value: 'pull'},
+        {name: 'Cancel', value: 'cancel'},
       ],
     })
 
     if (action === 'cancel') {
       /** @type {DotfilesSyncResult} */
-      const cancelResult = { action: 'skipped', repo: effectiveRemote ?? null, status: 'skipped', message: 'Cancelled by user', conflicts: [] }
+      const cancelResult = {
+        action: 'skipped',
+        repo: effectiveRemote ?? null,
+        status: 'skipped',
+        message: 'Cancelled by user',
+        conflicts: [],
+      }
       this.log(formatDotfilesSync(cancelResult))
       return cancelResult
     }
 
-    const result = action === 'push'
-      ? await this._push(effectiveRemote, isDryRun, false)
-      : await this._pull(effectiveRemote, isDryRun, false)
+    const result =
+      action === 'push'
+        ? await this._push(effectiveRemote, isDryRun, false)
+        : await this._pull(effectiveRemote, isDryRun, false)
 
     this.log(formatDotfilesSync(result))
     return result
@@ -174,25 +184,25 @@ export default class DotfilesSync extends Command {
     const choice = await select({
       message: 'Connect to an existing dotfiles repository or create a new one?',
       choices: [
-        { name: 'Connect to existing repository', value: 'existing' },
-        { name: 'Create new repository on GitHub', value: 'new' },
+        {name: 'Connect to existing repository', value: 'existing'},
+        {name: 'Create new repository on GitHub', value: 'new'},
       ],
     })
 
     let repoUrl = ''
 
     if (choice === 'existing') {
-      repoUrl = await input({ message: 'Repository URL (SSH or HTTPS):' })
+      repoUrl = await input({message: 'Repository URL (SSH or HTTPS):'})
     } else {
-      const repoName = await input({ message: 'Repository name:', default: 'dotfiles' })
-      const isPrivate = await confirm({ message: 'Make repository private?', default: true })
+      const repoName = await input({message: 'Repository name:', default: 'dotfiles'})
+      const isPrivate = await confirm({message: 'Make repository private?', default: true})
 
       if (!isDryRun) {
         try {
           const visFlag = isPrivate ? '--private' : '--public'
           await execOrThrow('gh', ['repo', 'create', repoName, visFlag, '--confirm'])
           // Get the SSH URL from the created repo
-          const { exec } = await import('../../services/shell.js')
+          const {exec} = await import('../../services/shell.js')
           const result = await exec('gh', ['repo', 'view', repoName, '--json', 'sshUrl', '--jq', '.sshUrl'])
           repoUrl = result.stdout.trim() || `git@github.com:${repoName}.git`
         } catch {
@@ -211,7 +221,7 @@ export default class DotfilesSync extends Command {
         await execOrThrow('chezmoi', ['git', '--', 'remote', 'add', 'origin', repoUrl])
         await execOrThrow('chezmoi', ['git', '--', 'push', '-u', 'origin', 'main'])
         // Save repo to dvmi config
-        config.dotfiles = { ...(config.dotfiles ?? { enabled: true }), repo: repoUrl }
+        config.dotfiles = {...(config.dotfiles ?? {enabled: true}), repo: repoUrl}
         await saveConfig(config)
       } catch (err) {
         /** @type {DotfilesSyncResult} */
@@ -232,7 +242,9 @@ export default class DotfilesSync extends Command {
       action: 'init-remote',
       repo: repoUrl,
       status: isDryRun ? 'skipped' : 'success',
-      message: isDryRun ? `Would configure remote: ${repoUrl}` : 'Remote repository configured and initial push completed',
+      message: isDryRun
+        ? `Would configure remote: ${repoUrl}`
+        : 'Remote repository configured and initial push completed',
       conflicts: [],
     }
     this.log(formatDotfilesSync(result))
@@ -271,7 +283,9 @@ export default class DotfilesSync extends Command {
       }
     }
 
-    const spinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Pushing to remote...') }).start()
+    const spinner = isJson
+      ? null
+      : ora({spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Pushing to remote...')}).start()
 
     try {
       // Stage all changes
@@ -282,7 +296,7 @@ export default class DotfilesSync extends Command {
       await execOrThrow('chezmoi', ['git', '--', 'push', 'origin', 'HEAD'])
       spinner?.succeed(chalk.green('Pushed to remote'))
 
-      return { action: 'push', repo: remote, status: 'success', message: 'Changes pushed to remote', conflicts: [] }
+      return {action: 'push', repo: remote, status: 'success', message: 'Changes pushed to remote', conflicts: []}
     } catch (err) {
       spinner?.fail(chalk.red('Push failed'))
       return {
@@ -327,7 +341,9 @@ export default class DotfilesSync extends Command {
       }
     }
 
-    const spinner = isJson ? null : ora({ spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Pulling from remote...') }).start()
+    const spinner = isJson
+      ? null
+      : ora({spinner: 'arc', color: false, text: chalk.hex('#FF6B2B')('Pulling from remote...')}).start()
 
     try {
       // Check if chezmoi init was done with this remote (first-time pull)
@@ -360,7 +376,7 @@ export default class DotfilesSync extends Command {
         }
       }
 
-      return { action: 'pull', repo: remote, status: 'success', message: 'Remote changes applied', conflicts: [] }
+      return {action: 'pull', repo: remote, status: 'success', message: 'Remote changes applied', conflicts: []}
     } catch (err) {
       spinner?.fail(chalk.red('Pull failed'))
       return {

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
   }