uva-cli 1.0.1 → 1.1.0

package/commands/branch.mjs

@@ -4,20 +4,20 @@ import { hasUncommittedChanges, checkout, pull, createBranch } from '../lib/git.
 import { COMMIT_TYPES } from '../lib/types.mjs'
 import { requireConfig } from '../lib/config.mjs'
 import { buildBranchName } from '../lib/format.mjs'
+import { getLocale } from '../lib/i18n.mjs'
 
 // Called by commander as runBranch(options, command)
 export async function runBranch(opts = {}) {
   bannerIntro('branch')
 
   const config = requireConfig()
+  const t = getLocale(config)
 
   if (hasUncommittedChanges()) {
-    const proceed = await confirm({
-      message: 'You have uncommitted changes. They will carry over to the new branch. Continue?',
-    })
+    const proceed = await confirm({ message: t.branch.uncommittedConfirm })
     if (isCancel(proceed) || !proceed) {
-      log.info('Tip: run `uva commit` first to commit pending changes.')
-      bannerCancelled()
+      log.info(t.branch.uncommittedTip)
+      bannerCancelled(t.common.cancelled)
       process.exit(0)
     }
   }
@@ -26,16 +26,16 @@ export async function runBranch(opts = {}) {
   let source
   if (opts.source) {
     if (!config.branch.sources.includes(opts.source)) {
-      log.warn(`"${opts.source}" is not in the configured source branches. Proceeding anyway.`)
+      log.warn(t.branch.sourceWarn(opts.source))
     }
     source = opts.source
   } else {
     source = await select({
-      message: 'Branch from',
+      message: t.branch.source,
       options: config.branch.sources.map((b) => ({ value: b, label: b })),
     })
     if (isCancel(source)) {
-      bannerCancelled()
+      bannerCancelled(t.common.cancelled)
       process.exit(0)
     }
   }
@@ -47,12 +47,12 @@ export async function runBranch(opts = {}) {
       ticket = opts.ticket
     } else {
       const input = await text({
-        message: 'Ticket',
+        message: t.branch.ticket,
         placeholder: config.commit.ticketPlaceholder,
-        validate: (v) => (v.trim() ? undefined : 'Ticket cannot be empty.'),
+        validate: (v) => (v.trim() ? undefined : t.branch.ticketError),
       })
       if (isCancel(input)) {
-        bannerCancelled()
+        bannerCancelled(t.common.cancelled)
         process.exit(0)
       }
       ticket = input.trim()
@@ -64,14 +64,14 @@ export async function runBranch(opts = {}) {
   if (opts.type) {
     const valid = COMMIT_TYPES.map((t) => t.value)
     if (!valid.includes(opts.type)) {
-      log.error(`Invalid --type "${opts.type}". Valid values: ${valid.join(', ')}`)
+      log.error(t.branch.invalidType(opts.type, valid.join(', ')))
       process.exit(1)
     }
     type = opts.type
   } else {
-    type = await select({ message: 'Branch type', options: COMMIT_TYPES })
+    type = await select({ message: t.branch.type, options: COMMIT_TYPES })
     if (isCancel(type)) {
-      bannerCancelled()
+      bannerCancelled(t.common.cancelled)
       process.exit(0)
     }
   }
@@ -82,12 +82,12 @@ export async function runBranch(opts = {}) {
     taskName = opts.name
   } else {
     const input = await text({
-      message: 'Task name',
-      placeholder: 'add login screen',
-      validate: (v) => (v.trim() ? undefined : 'Task name cannot be empty.'),
+      message: t.branch.name,
+      placeholder: t.branch.namePlaceholder,
+      validate: (v) => (v.trim() ? undefined : t.branch.nameError),
     })
     if (isCancel(input)) {
-      bannerCancelled()
+      bannerCancelled(t.common.cancelled)
       process.exit(0)
     }
     taskName = input.trim()
@@ -100,9 +100,9 @@ export async function runBranch(opts = {}) {
   const scripted = opts.source && opts.type && opts.name && ticketDone
 
   if (!scripted) {
-    const confirmed = await confirm({ message: `Create branch:\n  ${branchName}` })
+    const confirmed = await confirm({ message: t.branch.confirm(branchName) })
     if (isCancel(confirmed) || !confirmed) {
-      bannerCancelled()
+      bannerCancelled(t.common.cancelled)
       process.exit(0)
     }
   }
@@ -110,16 +110,14 @@ export async function runBranch(opts = {}) {
   try {
     checkout(source)
   } catch {
-    log.error(
-      `Could not switch to ${source}. Make sure the branch exists and there are no conflicts.`,
-    )
+    log.error(t.branch.checkoutError(source))
     process.exit(1)
   }
 
   try {
     pull()
   } catch {
-    log.error('Could not pull. Check your connection or resolve any conflicts.')
+    log.error(t.branch.pullError)
     process.exit(1)
   }
 
@@ -127,12 +125,12 @@ export async function runBranch(opts = {}) {
     createBranch(branchName)
   } catch (err) {
     if (err.stderr?.includes('already exists') || err.message?.includes('already exists')) {
-      log.error(`Branch "${branchName}" already exists. Choose a different name or ticket.`)
+      log.error(t.branch.branchExists(branchName))
     } else {
-      log.error('Could not create the branch. Check if the name is valid.')
+      log.error(t.branch.createError)
     }
     process.exit(1)
   }
 
-  bannerOutro(`Branch created: ${branchName}`)
+  bannerOutro(t.branch.done(branchName))
 }

package/commands/commit.mjs

@@ -4,16 +4,18 @@ import { getChangedFiles, addFiles, commit } from '../lib/git.mjs'
 import { COMMIT_TYPES } from '../lib/types.mjs'
 import { requireConfig } from '../lib/config.mjs'
 import { buildCommitMessage } from '../lib/format.mjs'
+import { getLocale } from '../lib/i18n.mjs'
 
 // Called by commander as runCommit(options, command)
 export async function runCommit(opts = {}) {
   bannerIntro('commit')
 
   const config = requireConfig()
+  const t = getLocale(config)
   const files = getChangedFiles()
 
   if (files.length === 0) {
-    log.info('Nothing to commit here.')
+    log.info(t.commit.nothingToCommit)
     process.exit(0)
   }
 
@@ -22,14 +24,14 @@ export async function runCommit(opts = {}) {
   if (opts.type) {
     const valid = COMMIT_TYPES.map((t) => t.value)
     if (!valid.includes(opts.type)) {
-      log.error(`Invalid --type "${opts.type}". Valid values: ${valid.join(', ')}`)
+      log.error(t.commit.invalidType(opts.type, valid.join(', ')))
       process.exit(1)
     }
     type = opts.type
   } else {
-    type = await select({ message: 'Commit type', options: COMMIT_TYPES })
+    type = await select({ message: t.commit.type, options: COMMIT_TYPES })
     if (isCancel(type)) {
-      bannerCancelled()
+      bannerCancelled(t.common.cancelled)
       process.exit(0)
     }
   }
@@ -41,12 +43,12 @@ export async function runCommit(opts = {}) {
       ticket = opts.ticket
     } else {
       const input = await text({
-        message: 'Ticket',
+        message: t.commit.ticket,
         placeholder: config.commit.ticketPlaceholder,
-        validate: (v) => (v.trim() ? undefined : 'Ticket cannot be empty.'),
+        validate: (v) => (v.trim() ? undefined : t.commit.ticketError),
       })
       if (isCancel(input)) {
-        bannerCancelled()
+        bannerCancelled(t.common.cancelled)
         process.exit(0)
       }
       ticket = input.trim()
@@ -64,21 +66,19 @@ export async function runCommit(opts = {}) {
       message = opts.message.trim().toLowerCase()
     } else {
       const input = await text({
-        message: 'Commit message',
-        placeholder: 'add login screen',
-        validate: (v) => (v.trim() ? undefined : 'Message cannot be empty.'),
+        message: t.commit.message,
+        placeholder: t.commit.messagePlaceholder,
+        validate: (v) => (v.trim() ? undefined : t.commit.messageError),
       })
       if (isCancel(input)) {
-        bannerCancelled()
+        bannerCancelled(t.common.cancelled)
         process.exit(0)
       }
       message = input.trim().toLowerCase()
     }
 
     if (message.length > 72) {
-      log.warn(
-        'Message is long (over 72 characters). Shorter messages are recommended, but you can continue.',
-      )
+      log.warn(t.commit.messageLong)
     }
 
     // Files
@@ -92,20 +92,30 @@ export async function runCommit(opts = {}) {
       const availablePaths = files.map((f) => f.path)
       const invalid = paths.filter((p) => !availablePaths.includes(p))
       if (invalid.length) {
-        log.error(`Unknown file(s): ${invalid.join(', ')}\nAvailable: ${availablePaths.join(', ')}`)
+        log.error(t.commit.unknownFiles(invalid.join(', '), availablePaths.join(', ')))
         process.exit(1)
       }
       selected = paths
     } else {
+      const fileOptions = files.map((f) => ({
+        value: f.path,
+        label: `${f.status.padEnd(2)}  ${f.path}`,
+      }))
+      if (files.length >= 5) {
+        fileOptions.unshift({ value: '__all__', label: t.commit.allFiles })
+      }
       selected = await multiselect({
-        message: 'Which files to include in the commit?',
-        options: files.map((f) => ({ value: f.path, label: `${f.status.padEnd(2)}  ${f.path}` })),
+        message: t.commit.files,
+        options: fileOptions,
         required: true,
       })
       if (isCancel(selected)) {
-        bannerCancelled()
+        bannerCancelled(t.common.cancelled)
         process.exit(0)
       }
+      if (selected.includes('__all__')) {
+        selected = files.map((f) => f.path)
+      }
     }
 
     finalMessage = buildCommitMessage(config.commit.format, { type, ticket, message })
@@ -114,23 +124,23 @@ export async function runCommit(opts = {}) {
     const scripted = opts.type && opts.message && (opts.all || opts.files)
     if (scripted) break
 
-    const confirmed = await confirm({ message: `Commit with message:\n  ${finalMessage}` })
+    const confirmed = await confirm({ message: t.commit.confirm(finalMessage) })
     if (isCancel(confirmed)) {
-      bannerCancelled()
+      bannerCancelled(t.common.cancelled)
       process.exit(0)
     }
     if (confirmed) break
 
     if (opts.message) break // message is fixed, can't retry
-    log.info("OK! Let's rewrite the message.")
+    log.info(t.commit.retry)
   }
 
   try {
     addFiles(selected)
     commit(finalMessage)
-    bannerOutro(`Committed: ${finalMessage}`)
+    bannerOutro(t.commit.done(finalMessage))
   } catch (e) {
-    log.error(`Commit failed: ${e.message}`)
+    log.error(t.commit.failed(e.message))
     process.exit(1)
   }
 }

package/commands/init.mjs

@@ -2,36 +2,48 @@ import { text, select, confirm, isCancel } from '@clack/prompts'
 import { bannerIntro, bannerOutro, bannerCancelled } from '../lib/banner.mjs'
 import { loadConfig, saveConfig } from '../lib/config.mjs'
 import { COMMIT_FORMATS, BRANCH_FORMATS } from '../lib/types.mjs'
+import { getLocale } from '../lib/i18n.mjs'
 
 export async function runInit() {
   bannerIntro('init')
 
+  // Language is always the first question — no config exists yet
+  const lang = await select({
+    message: 'Language / Idioma',
+    options: [
+      { value: 'en', label: 'English' },
+      { value: 'pt-br', label: 'Português (BR)' },
+    ],
+  })
+  if (isCancel(lang)) {
+    bannerCancelled()
+    process.exit(0)
+  }
+
+  const t = getLocale({ project: { lang } })
+
   const existing = loadConfig()
   if (existing) {
-    const overwrite = await confirm({
-      message: 'A configuration already exists. Do you want to overwrite it?',
-    })
+    const overwrite = await confirm({ message: t.init.overwriteConfirm })
     if (isCancel(overwrite) || !overwrite) {
-      bannerCancelled()
+      bannerCancelled(t.common.cancelled)
       process.exit(0)
     }
   }
 
   const projectName = await text({
-    message: 'Project name',
-    placeholder: 'My Awesome Project',
-    validate: (v) => (v.trim() ? undefined : 'Project name cannot be empty.'),
+    message: t.init.projectName,
+    placeholder: t.init.projectNamePlaceholder,
+    validate: (v) => (v.trim() ? undefined : t.init.projectNameError),
   })
   if (isCancel(projectName)) {
-    bannerCancelled()
+    bannerCancelled(t.common.cancelled)
     process.exit(0)
   }
 
-  const useTicket = await confirm({
-    message: 'Do you use a ticket/issue tracker? (e.g., Jira, Linear, GitHub Issues)',
-  })
+  const useTicket = await confirm({ message: t.init.ticketConfirm })
   if (isCancel(useTicket)) {
-    bannerCancelled()
+    bannerCancelled(t.common.cancelled)
     process.exit(0)
   }
 
@@ -40,12 +52,12 @@ export async function runInit() {
 
   if (useTicket) {
     const prefix = await text({
-      message: 'Ticket prefix',
-      placeholder: 'PROJ',
-      validate: (v) => (v.trim() ? undefined : 'Ticket prefix cannot be empty.'),
+      message: t.init.ticketPrefix,
+      placeholder: t.init.ticketPrefixPlaceholder,
+      validate: (v) => (v.trim() ? undefined : t.init.ticketPrefixError),
     })
     if (isCancel(prefix)) {
-      bannerCancelled()
+      bannerCancelled(t.common.cancelled)
       process.exit(0)
     }
     ticketPrefix = prefix.trim().toUpperCase()
@@ -55,33 +67,33 @@ export async function runInit() {
   let commitFormat = 'conventional'
   if (useTicket) {
     const selectedCommitFormat = await select({
-      message: 'Choose a commit message format',
+      message: t.init.commitFormat,
       options: COMMIT_FORMATS.map((f) => ({
         ...f,
         label: f.label.replace(/PROJ/g, ticketPrefix || 'PROJ'),
       })),
     })
     if (isCancel(selectedCommitFormat)) {
-      bannerCancelled()
+      bannerCancelled(t.common.cancelled)
       process.exit(0)
     }
     commitFormat = selectedCommitFormat
   }
 
   const sourcesInput = await text({
-    message: 'Branches to branch from (comma-separated)',
-    placeholder: 'main,develop',
+    message: t.init.sources,
+    placeholder: t.init.sourcesPlaceholder,
     initialValue: 'main,develop',
     validate: (v) => {
       const parts = v
         .split(',')
         .map((s) => s.trim())
         .filter(Boolean)
-      return parts.length > 0 ? undefined : 'At least one branch is required.'
+      return parts.length > 0 ? undefined : t.init.sourcesError
     },
   })
   if (isCancel(sourcesInput)) {
-    bannerCancelled()
+    bannerCancelled(t.common.cancelled)
     process.exit(0)
   }
   const sources = sourcesInput
@@ -92,44 +104,44 @@ export async function runInit() {
   let branchFormat = 'type-name'
   if (useTicket) {
     const selectedBranchFormat = await select({
-      message: 'Choose a branch naming format',
+      message: t.init.branchFormat,
       options: BRANCH_FORMATS.map((f) => ({
         ...f,
         label: f.label.replace(/PROJ/g, ticketPrefix || 'PROJ'),
       })),
     })
     if (isCancel(selectedBranchFormat)) {
-      bannerCancelled()
+      bannerCancelled(t.common.cancelled)
       process.exit(0)
     }
     branchFormat = selectedBranchFormat
   }
 
   const useArea = await confirm({
-    message: 'Do you want to categorize branches by area? (e.g., FE, BE, DOC)',
+    message: t.init.areaConfirm,
     initialValue: false,
   })
   if (isCancel(useArea)) {
-    bannerCancelled()
+    bannerCancelled(t.common.cancelled)
     process.exit(0)
   }
 
   let areas = []
   if (useArea) {
     const areasInput = await text({
-      message: 'Area labels (comma-separated)',
-      placeholder: 'FE,BE,DOC',
+      message: t.init.areaLabels,
+      placeholder: t.init.areaLabelsPlaceholder,
       initialValue: 'FE,BE,DOC',
       validate: (v) => {
         const parts = v
           .split(',')
           .map((s) => s.trim())
           .filter(Boolean)
-        return parts.length > 0 ? undefined : 'At least one area is required.'
+        return parts.length > 0 ? undefined : t.init.areaLabelsError
       },
     })
     if (isCancel(areasInput)) {
-      bannerCancelled()
+      bannerCancelled(t.common.cancelled)
       process.exit(0)
     }
     areas = areasInput
@@ -139,7 +151,7 @@ export async function runInit() {
   }
 
   const config = {
-    project: { name: projectName.trim() },
+    project: { name: projectName.trim(), lang },
     commit: {
       ticketEnabled: Boolean(useTicket),
       ticketPrefix,
@@ -156,5 +168,5 @@ export async function runInit() {
   }
 
   const configPath = saveConfig(config)
-  bannerOutro(`Configuration saved to ${configPath}`)
+  bannerOutro(t.init.saved(configPath))
 }

package/commands/push.mjs

@@ -1,20 +1,21 @@
 import { confirm, isCancel, log } from '@clack/prompts'
 import { bannerIntro, bannerOutro, bannerCancelled } from '../lib/banner.mjs'
 import { getCurrentBranch } from '../lib/git.mjs'
+import { loadConfig } from '../lib/config.mjs'
+import { getLocale } from '../lib/i18n.mjs'
 import { spawnSync } from 'child_process'
 
 // Called by commander as runPush(options, command)
 export async function runPush(opts = {}) {
   bannerIntro('push')
 
+  const t = getLocale(loadConfig())
   const branch = getCurrentBranch()
 
   if (!opts.yes) {
-    const confirmed = await confirm({
-      message: `Push current branch: ${branch}?`,
-    })
+    const confirmed = await confirm({ message: t.push.confirm(branch) })
     if (isCancel(confirmed) || !confirmed) {
-      bannerCancelled()
+      bannerCancelled(t.common.cancelled)
       process.exit(0)
     }
   }
@@ -23,9 +24,9 @@ export async function runPush(opts = {}) {
     stdio: ['pipe', 'inherit', 'inherit'],
   })
   if (result.status !== 0) {
-    log.error('Push failed — see the output above.')
+    log.error(t.push.failed)
     process.exit(1)
   }
 
-  bannerOutro(`Pushed: origin/${branch}`)
+  bannerOutro(t.push.done(branch))
 }

package/commands/start.mjs

@@ -1,6 +1,8 @@
 import { select, isCancel, intro, outro } from '@clack/prompts'
 import pc from 'picocolors'
 import { banner as brandBanner, uva, folha } from '../lib/colors.mjs'
+import { loadConfig } from '../lib/config.mjs'
+import { getLocale } from '../lib/i18n.mjs'
 import { runInit } from './init.mjs'
 import { runCommit } from './commit.mjs'
 import { runBranch } from './branch.mjs'
@@ -8,48 +10,51 @@ import { runNewFile } from './new-file.mjs'
 import { runPush } from './push.mjs'
 
 export async function runStart() {
+  const t = getLocale(loadConfig())
+
   intro(brandBanner('UVA CLI'))
 
   console.log('')
-  console.log(uva('  uva-cli') + pc.dim(' — Git workflow automation'))
+  console.log(uva('  uva-cli') + pc.dim(` ${t.start.tagline}`))
   console.log('')
-  console.log(pc.dim('  Guides your team through branch creation and commits'))
-  console.log(pc.dim('  following whatever conventions your project defines.'))
+  console.log(pc.dim(`  ${t.start.desc1}`))
+  console.log(pc.dim(`  ${t.start.desc2}`))
   console.log('')
 
+  const o = t.start.options
   const action = await select({
-    message: 'What do you want to do?',
+    message: t.start.prompt,
     options: [
       {
         value: 'init',
-        label: folha('uva init') + '     Set up UVA CLI for this project',
-        hint: 'configure commit and branch patterns',
+        label: folha('uva init') + '     ' + o.init.label,
+        hint: o.init.hint,
       },
       {
         value: 'commit',
-        label: uva('uva commit') + '   Create an interactive commit',
-        hint: 'select files, type, ticket and message',
+        label: uva('uva commit') + '   ' + o.commit.label,
+        hint: o.commit.hint,
       },
       {
         value: 'branch',
-        label: uva('uva branch') + '   Create a new branch',
-        hint: 'checks out source and pulls automatically',
+        label: uva('uva branch') + '   ' + o.branch.label,
+        hint: o.branch.hint,
       },
       {
         value: 'new-file',
-        label: uva('uva new-file') + ' Scaffold a file from a template',
-        hint: 'docs, frontend (React), or backend (Express)',
+        label: uva('uva new-file') + ' ' + o.newFile.label,
+        hint: o.newFile.hint,
       },
       {
         value: 'push',
-        label: uva('uva push') + '     Push the current branch to origin',
-        hint: 'confirms the branch and runs git push',
+        label: uva('uva push') + '     ' + o.push.label,
+        hint: o.push.hint,
       },
     ],
   })
 
   if (isCancel(action)) {
-    outro(pc.dim('Operation cancelled.'))
+    outro(pc.dim(t.common.cancelled))
     process.exit(0)
   }
 

package/lib/banner.mjs

@@ -10,6 +10,6 @@ export function bannerOutro(message) {
   outro(folha('+ ' + message))
 }
 
-export function bannerCancelled() {
-  outro(pc.dim('Operation cancelled.'))
+export function bannerCancelled(message = 'Operation cancelled.') {
+  outro(pc.dim(message))
 }

package/lib/git.mjs

@@ -51,7 +51,7 @@ export function addFiles(paths) {
     stdio: 'pipe',
   })
   if (result.status !== 0) {
-    throw new Error(result.stderr || 'git add falhou')
+    throw new Error(result.stderr || 'git add failed')
   }
 }
 
@@ -62,6 +62,6 @@ export function commit(message) {
     stdio: ['pipe', 'inherit', 'inherit'],
   })
   if (result.status !== 0) {
-    throw new Error('git commit falhou — veja a saída acima')
+    throw new Error('git commit failed — see output above')
   }
 }

package/lib/i18n.mjs

@@ -0,0 +1,9 @@
+import en from './locales/en.mjs'
+import ptBr from './locales/pt-br.mjs'
+
+const locales = { en, 'pt-br': ptBr }
+
+export function getLocale(config) {
+  const lang = config?.project?.lang ?? 'en'
+  return locales[lang] ?? en
+}

package/lib/locales/en.mjs

@@ -0,0 +1,96 @@
+export default {
+  init: {
+    langSelect: 'Language / Idioma',
+    overwriteConfirm: 'A configuration already exists. Do you want to overwrite it?',
+    projectName: 'Project name',
+    projectNamePlaceholder: 'My Awesome Project',
+    projectNameError: 'Project name cannot be empty.',
+    ticketConfirm: 'Do you use a ticket/issue tracker? (e.g., Jira, Linear, GitHub Issues)',
+    ticketPrefix: 'Ticket prefix',
+    ticketPrefixPlaceholder: 'PROJ',
+    ticketPrefixError: 'Ticket prefix cannot be empty.',
+    commitFormat: 'Choose a commit message format',
+    sources: 'Branches to branch from (comma-separated)',
+    sourcesPlaceholder: 'main,develop',
+    sourcesError: 'At least one branch is required.',
+    branchFormat: 'Choose a branch naming format',
+    areaConfirm: 'Do you want to categorize branches by area? (e.g., FE, BE, DOC)',
+    areaLabels: 'Area labels (comma-separated)',
+    areaLabelsPlaceholder: 'FE,BE,DOC',
+    areaLabelsError: 'At least one area is required.',
+    saved: (path) => `Configuration saved to ${path}`,
+  },
+  commit: {
+    nothingToCommit: 'Nothing to commit here.',
+    invalidType: (type, valid) => `Invalid --type "${type}". Valid values: ${valid}`,
+    unknownFiles: (invalid, available) => `Unknown file(s): ${invalid}\nAvailable: ${available}`,
+    type: 'Commit type',
+    ticket: 'Ticket',
+    ticketError: 'Ticket cannot be empty.',
+    message: 'Commit message',
+    messagePlaceholder: 'add login screen',
+    messageError: 'Message cannot be empty.',
+    messageLong:
+      'Message is long (over 72 characters). Shorter messages are recommended, but you can continue.',
+    files: 'Which files to include in the commit?',
+    allFiles: 'All files',
+    confirm: (msg) => `Commit with message:\n  ${msg}`,
+    retry: "OK! Let's rewrite the message.",
+    failed: (err) => `Commit failed: ${err}`,
+    done: (msg) => `Committed: ${msg}`,
+  },
+  branch: {
+    uncommittedConfirm:
+      'You have uncommitted changes. They will carry over to the new branch. Continue?',
+    uncommittedTip: 'Tip: run `uva commit` first to commit pending changes.',
+    source: 'Branch from',
+    sourceWarn: (src) => `"${src}" is not in the configured source branches. Proceeding anyway.`,
+    ticket: 'Ticket',
+    ticketError: 'Ticket cannot be empty.',
+    type: 'Branch type',
+    invalidType: (type, valid) => `Invalid --type "${type}". Valid values: ${valid}`,
+    name: 'Task name',
+    namePlaceholder: 'add login screen',
+    nameError: 'Task name cannot be empty.',
+    confirm: (name) => `Create branch:\n  ${name}`,
+    checkoutError: (src) =>
+      `Could not switch to ${src}. Make sure the branch exists and there are no conflicts.`,
+    pullError: 'Could not pull. Check your connection or resolve any conflicts.',
+    branchExists: (name) => `Branch "${name}" already exists. Choose a different name or ticket.`,
+    createError: 'Could not create the branch. Check if the name is valid.',
+    done: (name) => `Branch created: ${name}`,
+  },
+  push: {
+    confirm: (branch) => `Push current branch: ${branch}?`,
+    failed: 'Push failed — see the output above.',
+    done: (branch) => `Pushed: origin/${branch}`,
+  },
+  start: {
+    tagline: '— Git workflow automation',
+    desc1: 'Guides your team through branch creation and commits',
+    desc2: 'following whatever conventions your project defines.',
+    prompt: 'What do you want to do?',
+    options: {
+      init: {
+        label: 'Set up UVA CLI for this project',
+        hint: 'configure commit and branch patterns',
+      },
+      commit: {
+        label: 'Create an interactive commit',
+        hint: 'select files, type, ticket and message',
+      },
+      branch: { label: 'Create a new branch', hint: 'checks out source and pulls automatically' },
+      newFile: {
+        label: 'Scaffold a file from a template',
+        hint: 'docs and git workflow templates',
+      },
+      push: {
+        label: 'Push the current branch to origin',
+        hint: 'confirms the branch and runs git push',
+      },
+    },
+  },
+  common: {
+    cancelled: 'Operation cancelled.',
+  },
+}

package/lib/locales/pt-br.mjs

@@ -0,0 +1,101 @@
+export default {
+  init: {
+    langSelect: 'Language / Idioma',
+    overwriteConfirm: 'Já existe uma configuração. Deseja sobrescrever?',
+    projectName: 'Nome do projeto',
+    projectNamePlaceholder: 'Meu Projeto Incrível',
+    projectNameError: 'O nome do projeto não pode estar vazio.',
+    ticketConfirm: 'Você usa um rastreador de tickets? (ex.: Jira, Linear, GitHub Issues)',
+    ticketPrefix: 'Prefixo do ticket',
+    ticketPrefixPlaceholder: 'PROJ',
+    ticketPrefixError: 'O prefixo não pode estar vazio.',
+    commitFormat: 'Escolha o formato de mensagem de commit',
+    sources: 'Branches de origem (separados por vírgula)',
+    sourcesPlaceholder: 'main,develop',
+    sourcesError: 'Pelo menos um branch é obrigatório.',
+    branchFormat: 'Escolha o formato de nome de branch',
+    areaConfirm: 'Deseja categorizar os branches por área? (ex.: FE, BE, DOC)',
+    areaLabels: 'Áreas (separadas por vírgula)',
+    areaLabelsPlaceholder: 'FE,BE,DOC',
+    areaLabelsError: 'Pelo menos uma área é obrigatória.',
+    saved: (path) => `Configuração salva em ${path}`,
+  },
+  commit: {
+    nothingToCommit: 'Nada para commitar.',
+    invalidType: (type, valid) => `Tipo inválido "${type}". Valores válidos: ${valid}`,
+    unknownFiles: (invalid, available) =>
+      `Arquivo(s) desconhecido(s): ${invalid}\nDisponíveis: ${available}`,
+    type: 'Tipo do commit',
+    ticket: 'Ticket',
+    ticketError: 'O ticket não pode estar vazio.',
+    message: 'Mensagem do commit',
+    messagePlaceholder: 'adicionar tela de login',
+    messageError: 'A mensagem não pode estar vazia.',
+    messageLong:
+      'Mensagem longa (mais de 72 caracteres). Mensagens curtas são recomendadas, mas você pode continuar.',
+    files: 'Quais arquivos incluir no commit?',
+    allFiles: 'Todos os arquivos',
+    confirm: (msg) => `Commitar com a mensagem:\n  ${msg}`,
+    retry: 'Ok! Vamos reescrever a mensagem.',
+    failed: (err) => `Commit falhou: ${err}`,
+    done: (msg) => `Commitado: ${msg}`,
+  },
+  branch: {
+    uncommittedConfirm:
+      'Você tem alterações não commitadas. Elas serão levadas para o novo branch. Continuar?',
+    uncommittedTip: 'Dica: rode `uva commit` primeiro para commitar as alterações pendentes.',
+    source: 'Branch de origem',
+    sourceWarn: (src) =>
+      `"${src}" não está nos branches de origem configurados. Continuando mesmo assim.`,
+    ticket: 'Ticket',
+    ticketError: 'O ticket não pode estar vazio.',
+    type: 'Tipo do branch',
+    invalidType: (type, valid) => `Tipo inválido "${type}". Valores válidos: ${valid}`,
+    name: 'Nome da tarefa',
+    namePlaceholder: 'adicionar tela de login',
+    nameError: 'O nome da tarefa não pode estar vazio.',
+    confirm: (name) => `Criar branch:\n  ${name}`,
+    checkoutError: (src) =>
+      `Não foi possível mudar para ${src}. Verifique se o branch existe e não há conflitos.`,
+    pullError: 'Não foi possível fazer pull. Verifique sua conexão ou resolva conflitos.',
+    branchExists: (name) => `O branch "${name}" já existe. Escolha um nome ou ticket diferente.`,
+    createError: 'Não foi possível criar o branch. Verifique se o nome é válido.',
+    done: (name) => `Branch criado: ${name}`,
+  },
+  push: {
+    confirm: (branch) => `Fazer push do branch atual: ${branch}?`,
+    failed: 'Push falhou — veja a saída acima.',
+    done: (branch) => `Push realizado: origin/${branch}`,
+  },
+  start: {
+    tagline: '— Automação de workflow Git',
+    desc1: 'Guia seu time na criação de branches e commits',
+    desc2: 'seguindo as convenções definidas no seu projeto.',
+    prompt: 'O que você quer fazer?',
+    options: {
+      init: {
+        label: 'Configurar o UVA CLI para este projeto',
+        hint: 'configura padrões de commit e branch',
+      },
+      commit: {
+        label: 'Criar um commit interativo',
+        hint: 'selecione arquivos, tipo, ticket e mensagem',
+      },
+      branch: {
+        label: 'Criar um novo branch',
+        hint: 'faz checkout da origem e pull automaticamente',
+      },
+      newFile: {
+        label: 'Gerar um arquivo a partir de um template',
+        hint: 'templates de docs e workflow Git',
+      },
+      push: {
+        label: 'Fazer push do branch atual para a origin',
+        hint: 'confirma o branch e executa git push',
+      },
+    },
+  },
+  common: {
+    cancelled: 'Operação cancelada.',
+  },
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uva-cli",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "UVA CLI — Interactive Git workflow automation for teams",
   "type": "module",
   "bin": {