azure-pr-manager 1.0.0

package/src/index.js

@@ -0,0 +1,860 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import ora from "ora";
+import { AzureDevOpsApi } from "./api.js";
+import { loadConfig, saveConfig, getDefaultConfig } from "./config.js";
+import * as git from "./git.js";
+
+const program = new Command();
+
+program
+  .name("azure-pr")
+  .description("CLI para criar Pull Requests no Azure DevOps automaticamente")
+  .version("1.0.0");
+
+// ==================== INIT ====================
+program
+  .command("init")
+  .description("Inicializa a configuracao do projeto (.prmanager.json)")
+  .action(async () => {
+    console.log(chalk.cyan("\n  Azure PR Manager - Configuracao\n"));
+
+    const existing = await loadConfig();
+    const defaults = existing || getDefaultConfig();
+
+    // ── Organization ──
+    console.log(chalk.gray("  ┌─────────────────────────────────────────────────────"));
+    console.log(chalk.gray("  │") + chalk.white(" Como encontrar a Organization:"));
+    console.log(chalk.gray("  │") + " A organization esta na URL do seu Azure DevOps:");
+    console.log(chalk.gray("  │") + chalk.cyan(" https://dev.azure.com/") + chalk.yellow("SUA-ORGANIZATION") + chalk.cyan("/..."));
+    console.log(chalk.gray("  │") + " Tambem aparece no canto superior esquerdo ao logar.");
+    console.log(chalk.gray("  └─────────────────────────────────────────────────────\n"));
+
+    const { organization } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "organization",
+        message: "Organization:",
+        default: defaults.organization || undefined,
+        validate: (v) => (v.trim() ? true : "Obrigatorio"),
+      },
+    ]);
+
+    // ── Project ──
+    console.log(chalk.gray("\n  ┌─────────────────────────────────────────────────────"));
+    console.log(chalk.gray("  │") + chalk.white(" Como encontrar o Project:"));
+    console.log(chalk.gray("  │") + " O project e o segundo trecho da URL, logo apos a org:");
+    console.log(chalk.gray("  │") + chalk.cyan(" https://dev.azure.com/" + organization + "/") + chalk.yellow("SEU-PROJETO") + chalk.cyan("/..."));
+    console.log(chalk.gray("  │") + " Na home da org, voce ve a lista de projetos disponiveis.");
+    console.log(chalk.gray("  └─────────────────────────────────────────────────────\n"));
+
+    const { project } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "project",
+        message: "Project:",
+        default: defaults.project || undefined,
+        validate: (v) => (v.trim() ? true : "Obrigatorio"),
+      },
+    ]);
+
+    // ── Token ──
+    console.log(chalk.gray("\n  ┌─────────────────────────────────────────────────────"));
+    console.log(chalk.gray("  │") + chalk.white(" Como criar o Personal Access Token (PAT):"));
+    console.log(chalk.gray("  │"));
+    console.log(chalk.gray("  │") + " 1. Acesse " + chalk.cyan("dev.azure.com") + " e faca login");
+    console.log(chalk.gray("  │") + " 2. Clique no seu avatar (canto superior direito)");
+    console.log(chalk.gray("  │") + " 3. Selecione " + chalk.white("Personal access tokens"));
+    console.log(chalk.gray("  │") + " 4. Clique em " + chalk.white("+ New Token"));
+    console.log(chalk.gray("  │") + " 5. De um nome, ex: " + chalk.yellow("\"PR Manager CLI\""));
+    console.log(chalk.gray("  │") + " 6. Selecione a org: " + chalk.yellow(organization));
+    console.log(chalk.gray("  │") + " 7. Em Scopes, marque:");
+    console.log(chalk.gray("  │") + chalk.green("    ✓ Code > Read & Write"));
+    console.log(chalk.gray("  │") + chalk.green("    ✓ Identity > Read"));
+    console.log(chalk.gray("  │") + chalk.green("    ✓ Member Entitlement Management > Read"));
+    console.log(chalk.gray("  │") + " 8. Clique em Create e copie o token gerado");
+    console.log(chalk.gray("  │"));
+    console.log(chalk.gray("  │") + chalk.red(" O token so aparece uma vez! Salve em lugar seguro."));
+    console.log(chalk.gray("  └─────────────────────────────────────────────────────\n"));
+
+    const { token } = await inquirer.prompt([
+      {
+        type: "password",
+        name: "token",
+        message: "Personal Access Token (PAT):",
+        mask: "*",
+        validate: (v) => (v.trim() ? true : "Obrigatorio"),
+      },
+    ]);
+
+    // Testar conexao e listar repos
+    const spinner = ora("Testando conexao...").start();
+    const api = new AzureDevOpsApi({
+      organization: organization,
+      project: project,
+      repository: "",
+      token: token,
+    });
+
+    const test = await api.testConnection();
+    if (!test.success) {
+      spinner.fail("Falha na conexao: " + test.error);
+      process.exit(1);
+    }
+
+    spinner.succeed(`Conectado! ${test.repos} repositorio(s) encontrado(s)`);
+
+    // Selecionar repositorio
+    console.log(chalk.gray("\n  ┌─────────────────────────────────────────────────────"));
+    console.log(chalk.gray("  │") + chalk.white(" Selecione o repositorio:"));
+    console.log(chalk.gray("  │") + " Estes sao os repos Git encontrados no projeto");
+    console.log(chalk.gray("  │") + chalk.cyan(` ${project}`) + ". Escolha o que voce usa para criar PRs.");
+    console.log(chalk.gray("  └─────────────────────────────────────────────────────\n"));
+
+    const repos = await api.getRepositories();
+    const { repository } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "repository",
+        message: "Selecione o repositorio:",
+        choices: repos.map((r) => ({
+          name: `${r.name} (default: ${r.defaultBranch || "N/A"})`,
+          value: r.name,
+        })),
+      },
+    ]);
+
+    // Formato do titulo
+    console.log(chalk.gray("\n  ┌─────────────────────────────────────────────────────"));
+    console.log(chalk.gray("  │") + chalk.white(" Formato do titulo do PR:"));
+    console.log(chalk.gray("  │") + " O titulo sera gerado automaticamente com base nas");
+    console.log(chalk.gray("  │") + " branches. Use variaveis:");
+    console.log(chalk.gray("  │") + chalk.cyan("   {source}") + " = branch de origem (ex: feature/login)");
+    console.log(chalk.gray("  │") + chalk.cyan("   {target}") + " = branch de destino (ex: develop)");
+    console.log(chalk.gray("  │") + " Resultado: " + chalk.yellow("feature/login -> develop"));
+    console.log(chalk.gray("  └─────────────────────────────────────────────────────\n"));
+
+    const { titleFormat } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "titleFormat",
+        message: "Formato do titulo do PR:",
+        choices: [
+          { name: "{source} -> {target}", value: "{source} -> {target}" },
+          {
+            name: "{source} => {target}",
+            value: "{source} => {target}",
+          },
+          {
+            name: "[{source}] {target}",
+            value: "[{source}] {target}",
+          },
+          { name: "Personalizado", value: "_custom" },
+        ],
+        default: defaults.titleFormat,
+      },
+    ]);
+
+    let finalTitleFormat = titleFormat;
+    if (titleFormat === "_custom") {
+      const { custom } = await inquirer.prompt([
+        {
+          type: "input",
+          name: "custom",
+          message: "Formato personalizado (use {source} e {target}):",
+          default: "{source} -> {target}",
+        },
+      ]);
+      finalTitleFormat = custom;
+    }
+
+    // Reviewers
+    console.log(chalk.gray("\n  ┌─────────────────────────────────────────────────────"));
+    console.log(chalk.gray("  │") + chalk.white(" Required Reviewers:"));
+    console.log(chalk.gray("  │") + " Pessoas que PRECISAM aprovar o PR para ele ser completado.");
+    console.log(chalk.gray("  │") + " Use o email corporativo de cada pessoa (o mesmo que usam");
+    console.log(chalk.gray("  │") + " pra logar no Azure DevOps). Separe multiplos por virgula.");
+    console.log(chalk.gray("  │") + chalk.yellow(" Ex: joao@empresa.com, maria@empresa.com"));
+    console.log(chalk.gray("  │") + " Deixe vazio se nao quiser required reviewers.");
+    console.log(chalk.gray("  └─────────────────────────────────────────────────────\n"));
+
+    const { requiredEmails } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "requiredEmails",
+        message:
+          "Required reviewers (emails separados por virgula, ou vazio):",
+        default: (defaults.requiredReviewers || []).join(", "),
+      },
+    ]);
+
+    console.log(chalk.gray("\n  ┌─────────────────────────────────────────────────────"));
+    console.log(chalk.gray("  │") + chalk.white(" Optional Reviewers:"));
+    console.log(chalk.gray("  │") + " Pessoas que serao notificadas mas NAO precisam aprovar.");
+    console.log(chalk.gray("  │") + " Mesmo formato: emails separados por virgula.");
+    console.log(chalk.gray("  └─────────────────────────────────────────────────────\n"));
+
+    const { optionalEmails } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "optionalEmails",
+        message:
+          "Optional reviewers (emails separados por virgula, ou vazio):",
+        default: (defaults.optionalReviewers || []).join(", "),
+      },
+    ]);
+
+    // Defaults
+    console.log(chalk.gray("\n  ┌─────────────────────────────────────────────────────"));
+    console.log(chalk.gray("  │") + chalk.white(" Opcoes padrao para novos PRs:"));
+    console.log(chalk.gray("  │") + chalk.cyan(" Draft") + " = PR criado como rascunho (nao pode ser completado");
+    console.log(chalk.gray("  │") + "   ate voce publicar).");
+    console.log(chalk.gray("  │") + chalk.cyan(" Auto-complete") + " = quando todos aprovarem e policies passarem,");
+    console.log(chalk.gray("  │") + "   o PR e completado automaticamente (squash + delete branch).");
+    console.log(chalk.gray("  └─────────────────────────────────────────────────────\n"));
+
+    const defaultOpts = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "isDraft",
+        message: "Criar PRs como draft por padrao?",
+        default: defaults.defaults?.isDraft || false,
+      },
+      {
+        type: "confirm",
+        name: "autoComplete",
+        message: "Ativar auto-complete por padrao?",
+        default: defaults.defaults?.autoComplete || false,
+      },
+    ]);
+
+    const config = {
+      organization: organization,
+      project: project,
+      repository,
+      token: token,
+      titleFormat: finalTitleFormat,
+      requiredReviewers: requiredEmails
+        .split(",")
+        .map((e) => e.trim())
+        .filter(Boolean),
+      optionalReviewers: optionalEmails
+        .split(",")
+        .map((e) => e.trim())
+        .filter(Boolean),
+      defaults: {
+        isDraft: defaultOpts.isDraft,
+        autoComplete: defaultOpts.autoComplete,
+        deleteSourceBranch: true,
+      },
+    };
+
+    const configPath = await saveConfig(config);
+    console.log(
+      chalk.green(`\n  Configuracao salva em: ${configPath}`)
+    );
+    console.log(
+      chalk.yellow(
+        "  Adicione .prmanager.json ao .gitignore (contem seu token)!\n"
+      )
+    );
+  });
+
+// ==================== CREATE ====================
+program
+  .command("create")
+  .description("Cria um Pull Request (com fluxo git completo)")
+  .option("-t, --target <branch>", "Branch de destino")
+  .option("--title <title>", "Titulo customizado")
+  .option("--draft", "Criar como draft")
+  .option("--auto-complete", "Ativar auto-complete")
+  .option("--skip-git", "Pular verificacoes git (ir direto para criacao da PR)")
+  .action(async (opts) => {
+    const config = await loadConfig();
+    if (!config) {
+      console.log(
+        chalk.red(
+          "\n  Configuracao nao encontrada. Execute: azure-pr init\n"
+        )
+      );
+      process.exit(1);
+    }
+
+    console.log(chalk.cyan("\n  Azure PR Manager - Criar Pull Request\n"));
+
+    // ── ETAPA 1: Verificar repositorio git ──
+    if (!git.isGitRepo()) {
+      console.log(
+        chalk.red(
+          "  Voce nao esta dentro de um repositorio git.\n" +
+            "  Execute este comando na raiz do seu projeto.\n"
+        )
+      );
+      process.exit(1);
+    }
+
+    const currentBranch = git.getCurrentBranch();
+    if (!currentBranch || currentBranch === "HEAD") {
+      console.log(
+        chalk.red(
+          "  Nao foi possivel detectar a branch atual (detached HEAD?).\n" +
+            "  Faca checkout de uma branch antes de criar o PR.\n"
+        )
+      );
+      process.exit(1);
+    }
+
+    console.log(
+      chalk.white("  Branch atual: ") + chalk.cyan(currentBranch)
+    );
+
+    const sourceBranch = currentBranch;
+
+    if (!opts.skipGit) {
+      // ── ETAPA 2: Verificar alteracoes pendentes ──
+      const status = git.getWorkingTreeStatus();
+
+      if (!status.clean) {
+        console.log();
+        console.log(
+          chalk.yellow("  Existem alteracoes pendentes no seu repositorio:")
+        );
+
+        if (status.stagedFiles.length > 0) {
+          console.log(
+            chalk.green(`    Staged:    ${status.stagedFiles.length} arquivo(s)`)
+          );
+          status.stagedFiles.forEach((f) =>
+            console.log(chalk.green(`      + ${f}`))
+          );
+        }
+        if (status.modifiedFiles.length > 0) {
+          console.log(
+            chalk.red(
+              `    Modificados: ${status.modifiedFiles.length} arquivo(s)`
+            )
+          );
+          status.modifiedFiles.forEach((f) =>
+            console.log(chalk.red(`      ~ ${f}`))
+          );
+        }
+        if (status.untrackedFiles.length > 0) {
+          console.log(
+            chalk.gray(
+              `    Nao rastreados: ${status.untrackedFiles.length} arquivo(s)`
+            )
+          );
+          status.untrackedFiles.forEach((f) =>
+            console.log(chalk.gray(`      ? ${f}`))
+          );
+        }
+
+        console.log();
+
+        const { action } = await inquirer.prompt([
+          {
+            type: "list",
+            name: "action",
+            message: "O que deseja fazer com as alteracoes pendentes?",
+            choices: [
+              {
+                name: "Adicionar tudo e fazer commit (git add -A && git commit)",
+                value: "commit",
+              },
+              {
+                name: "Continuar sem commitar (alteracoes ficam pendentes)",
+                value: "skip",
+              },
+              {
+                name: "Cancelar",
+                value: "cancel",
+              },
+            ],
+          },
+        ]);
+
+        if (action === "cancel") {
+          console.log(chalk.yellow("\n  Cancelado.\n"));
+          process.exit(0);
+        }
+
+        if (action === "commit") {
+          console.log(
+            chalk.gray(
+              "\n  ┌─────────────────────────────────────────────────────"
+            )
+          );
+          console.log(
+            chalk.gray("  │") +
+              chalk.white(" Mensagem de commit:")
+          );
+          console.log(
+            chalk.gray("  │") +
+              " Escreva uma mensagem descritiva sobre o que foi alterado."
+          );
+          console.log(
+            chalk.gray("  │") +
+              " Boas praticas: comece com verbo no imperativo."
+          );
+          console.log(
+            chalk.gray("  │") +
+              chalk.yellow(' Ex: "Adiciona validacao no formulario de login"')
+          );
+          console.log(
+            chalk.gray(
+              "  └─────────────────────────────────────────────────────\n"
+            )
+          );
+
+          const { commitMessage } = await inquirer.prompt([
+            {
+              type: "input",
+              name: "commitMessage",
+              message: "Mensagem do commit:",
+              validate: (v) =>
+                v.trim() ? true : "A mensagem de commit e obrigatoria",
+            },
+          ]);
+
+          const commitSpinner = ora("Commitando alteracoes...").start();
+          try {
+            git.stageAll();
+            git.commit(commitMessage);
+            commitSpinner.succeed(
+              `Commit realizado: "${commitMessage}"`
+            );
+          } catch (err) {
+            commitSpinner.fail("Erro ao commitar: " + err.message);
+            process.exit(1);
+          }
+        }
+      } else {
+        console.log(chalk.green("  Working tree limpa - nenhuma alteracao pendente"));
+      }
+
+      // ── ETAPA 3: Verificar remote e push ──
+      if (!git.hasRemoteOrigin()) {
+        console.log(
+          chalk.red(
+            "\n  Nenhum remote 'origin' configurado.\n" +
+              '  Configure com: git remote add origin <url>\n'
+          )
+        );
+        process.exit(1);
+      }
+
+      const fetchSpinner = ora("Sincronizando com remote...").start();
+      git.fetchOrigin();
+      fetchSpinner.succeed("Refs atualizadas");
+
+      const existsOnRemote = git.branchExistsOnRemote(currentBranch);
+
+      if (!existsOnRemote) {
+        // Branch nao existe no remote - precisa publicar
+        console.log();
+        console.log(
+          chalk.yellow(
+            `  A branch "${currentBranch}" ainda nao existe no remote.`
+          )
+        );
+
+        const { shouldPublish } = await inquirer.prompt([
+          {
+            type: "confirm",
+            name: "shouldPublish",
+            message: `Publicar branch "${currentBranch}" no remote (git push -u origin ${currentBranch})?`,
+            default: true,
+          },
+        ]);
+
+        if (!shouldPublish) {
+          console.log(
+            chalk.yellow(
+              "\n  Cancelado. A branch precisa estar no remote para criar o PR.\n"
+            )
+          );
+          process.exit(0);
+        }
+
+        const pushSpinner = ora(
+          `Publicando branch "${currentBranch}"...`
+        ).start();
+        try {
+          git.publishBranch(currentBranch);
+          pushSpinner.succeed(
+            `Branch "${currentBranch}" publicada no remote`
+          );
+        } catch (err) {
+          pushSpinner.fail("Erro ao publicar branch: " + err.message);
+          process.exit(1);
+        }
+      } else {
+        // Branch existe no remote - verificar commits pendentes
+        const unpushedCount = git.getUnpushedCommitCount(currentBranch);
+
+        if (unpushedCount > 0) {
+          const unpushedCommits = git.getUnpushedCommits(currentBranch);
+          console.log();
+          console.log(
+            chalk.yellow(
+              `  ${unpushedCount} commit(s) pendente(s) para push:`
+            )
+          );
+          unpushedCommits.forEach((c) =>
+            console.log(chalk.gray(`    ${c}`))
+          );
+
+          const { shouldPush } = await inquirer.prompt([
+            {
+              type: "confirm",
+              name: "shouldPush",
+              message: "Enviar commits para o remote (git push)?",
+              default: true,
+            },
+          ]);
+
+          if (shouldPush) {
+            const pushSpinner = ora("Enviando commits...").start();
+            try {
+              git.push();
+              pushSpinner.succeed(
+                `${unpushedCount} commit(s) enviado(s) ao remote`
+              );
+            } catch (err) {
+              pushSpinner.fail("Erro ao enviar commits: " + err.message);
+              process.exit(1);
+            }
+          } else {
+            console.log(
+              chalk.yellow(
+                "  Continuando sem push. O PR sera criado com base no que ja esta no remote.\n"
+              )
+            );
+          }
+        } else {
+          console.log(
+            chalk.green("  Branch sincronizada com remote - nenhum commit pendente")
+          );
+        }
+      }
+    }
+
+    // ── ETAPA 4: Selecionar branch de destino e criar PR ──
+    console.log();
+
+    const api = new AzureDevOpsApi(config);
+
+    // Buscar branches do Azure DevOps
+    const branchSpinner = ora("Buscando branches do repositorio...").start();
+    let branches;
+    try {
+      branches = await api.getBranches();
+      branchSpinner.succeed(`${branches.length} branches encontradas`);
+    } catch (err) {
+      branchSpinner.fail("Erro ao buscar branches: " + err.message);
+      process.exit(1);
+    }
+
+    const branchNames = branches.map((b) => b.name);
+
+    // Verificar se a source branch existe no Azure DevOps
+    if (!branchNames.includes(sourceBranch)) {
+      console.log(
+        chalk.red(
+          `\n  A branch "${sourceBranch}" nao foi encontrada no repositorio "${config.repository}" do Azure DevOps.\n` +
+            "  Verifique se voce fez push da branch e se o repositorio esta correto.\n"
+        )
+      );
+      process.exit(1);
+    }
+
+    // Selecionar target
+    let targetBranch = opts.target;
+    if (!targetBranch) {
+      const targetChoices = branchNames.filter((b) => b !== sourceBranch);
+
+      console.log(
+        chalk.gray(
+          "\n  ┌─────────────────────────────────────────────────────"
+        )
+      );
+      console.log(
+        chalk.gray("  │") + chalk.white(" Branch de destino (target):")
+      );
+      console.log(
+        chalk.gray("  │") +
+          " A branch para onde suas alteracoes serao mescladas."
+      );
+      console.log(
+        chalk.gray("  │") +
+          " Geralmente e " +
+          chalk.cyan("main") +
+          ", " +
+          chalk.cyan("master") +
+          " ou " +
+          chalk.cyan("develop") +
+          "."
+      );
+      console.log(
+        chalk.gray(
+          "  └─────────────────────────────────────────────────────\n"
+        )
+      );
+
+      const { target } = await inquirer.prompt([
+        {
+          type: "list",
+          name: "target",
+          message: "Branch de destino (target):",
+          choices: targetChoices,
+          default: targetChoices.includes("main")
+            ? "main"
+            : targetChoices.includes("master")
+              ? "master"
+              : targetChoices.includes("develop")
+                ? "develop"
+                : undefined,
+          loop: false,
+          pageSize: 15,
+        },
+      ]);
+      targetBranch = target;
+    }
+
+    // Titulo
+    let title = opts.title;
+    if (!title) {
+      const autoTitle = config.titleFormat
+        .replace(/\{source\}/g, sourceBranch)
+        .replace(/\{target\}/g, targetBranch);
+
+      const { finalTitle } = await inquirer.prompt([
+        {
+          type: "input",
+          name: "finalTitle",
+          message: "Titulo do PR:",
+          default: autoTitle,
+        },
+      ]);
+      title = finalTitle;
+    }
+
+    // Descricao
+    console.log(
+      chalk.gray(
+        "\n  ┌─────────────────────────────────────────────────────"
+      )
+    );
+    console.log(
+      chalk.gray("  │") + chalk.white(" Descricao do PR:")
+    );
+    console.log(
+      chalk.gray("  │") +
+        " Descreva o que foi feito neste PR. Pode usar Markdown."
+    );
+    console.log(
+      chalk.gray("  │") +
+        " Deixe vazio e pressione Enter para pular."
+    );
+    console.log(
+      chalk.gray(
+        "  └─────────────────────────────────────────────────────\n"
+      )
+    );
+
+    const { description } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "description",
+        message: "Descricao do PR (ou Enter para vazio):",
+        default: "",
+      },
+    ]);
+
+    // Draft / Auto-complete
+    const isDraft =
+      opts.draft !== undefined
+        ? opts.draft
+        : config.defaults?.isDraft || false;
+    const autoComplete =
+      opts.autoComplete !== undefined
+        ? opts.autoComplete
+        : config.defaults?.autoComplete || false;
+
+    // Resolver reviewers
+    const resolvedRequired = [];
+    const resolvedOptional = [];
+
+    if (config.requiredReviewers?.length > 0) {
+      const s = ora("Resolvendo required reviewers...").start();
+      try {
+        const resolved = await api.resolveReviewers(
+          config.requiredReviewers
+        );
+        resolvedRequired.push(...resolved);
+        s.succeed(
+          `${resolved.length} required reviewer(s): ${resolved.map((r) => r.displayName).join(", ")}`
+        );
+      } catch (err) {
+        s.warn("Erro ao resolver required reviewers: " + err.message);
+      }
+    }
+
+    if (config.optionalReviewers?.length > 0) {
+      const s = ora("Resolvendo optional reviewers...").start();
+      try {
+        const resolved = await api.resolveReviewers(
+          config.optionalReviewers
+        );
+        resolvedOptional.push(...resolved);
+        s.succeed(
+          `${resolved.length} optional reviewer(s): ${resolved.map((r) => r.displayName).join(", ")}`
+        );
+      } catch (err) {
+        s.warn("Erro ao resolver optional reviewers: " + err.message);
+      }
+    }
+
+    // Confirmacao
+    console.log(chalk.cyan("\n  ╔═══════════════════════════════════════════"));
+    console.log(chalk.cyan("  ║") + chalk.white("  Resumo do PR"));
+    console.log(chalk.cyan("  ╠═══════════════════════════════════════════"));
+    console.log(
+      chalk.cyan("  ║") +
+        `  ${chalk.gray("Source:")}  ${chalk.green(sourceBranch)}`
+    );
+    console.log(
+      chalk.cyan("  ║") +
+        `  ${chalk.gray("Target:")}  ${chalk.yellow(targetBranch)}`
+    );
+    console.log(
+      chalk.cyan("  ║") + `  ${chalk.gray("Titulo:")}  ${title}`
+    );
+    if (description) {
+      console.log(
+        chalk.cyan("  ║") +
+          `  ${chalk.gray("Descricao:")} ${description.substring(0, 50)}${description.length > 50 ? "..." : ""}`
+      );
+    }
+    console.log(
+      chalk.cyan("  ║") +
+        `  ${chalk.gray("Draft:")}   ${isDraft ? "Sim" : "Nao"}`
+    );
+    console.log(
+      chalk.cyan("  ║") +
+        `  ${chalk.gray("Auto-complete:")} ${autoComplete ? "Sim" : "Nao"}`
+    );
+    if (resolvedRequired.length > 0) {
+      console.log(
+        chalk.cyan("  ║") +
+          `  ${chalk.gray("Required:")} ${resolvedRequired.map((r) => r.displayName).join(", ")}`
+      );
+    }
+    if (resolvedOptional.length > 0) {
+      console.log(
+        chalk.cyan("  ║") +
+          `  ${chalk.gray("Optional:")} ${resolvedOptional.map((r) => r.displayName).join(", ")}`
+      );
+    }
+    console.log(chalk.cyan("  ╚═══════════════════════════════════════════\n"));
+
+    const { confirm } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Criar este PR?",
+        default: true,
+      },
+    ]);
+
+    if (!confirm) {
+      console.log(chalk.yellow("\n  Cancelado.\n"));
+      process.exit(0);
+    }
+
+    // Criar PR
+    const createSpinner = ora("Criando Pull Request...").start();
+    try {
+      const pr = await api.createPullRequest({
+        sourceBranch,
+        targetBranch,
+        title,
+        description: description || "",
+        reviewers: resolvedRequired,
+        optionalReviewers: resolvedOptional,
+        isDraft,
+        autoComplete,
+      });
+
+      const prUrl = `https://dev.azure.com/${config.organization}/${config.project}/_git/${config.repository}/pullrequest/${pr.pullRequestId}`;
+      createSpinner.succeed("Pull Request criado com sucesso!");
+      console.log(chalk.green(`\n  PR #${pr.pullRequestId}: ${title}`));
+      console.log(chalk.blue(`  ${prUrl}\n`));
+    } catch (err) {
+      createSpinner.fail("Erro ao criar PR: " + err.message);
+      process.exit(1);
+    }
+  });
+
+// ==================== LIST ====================
+program
+  .command("branches")
+  .description("Lista as branches do repositorio")
+  .action(async () => {
+    const config = await loadConfig();
+    if (!config) {
+      console.log(
+        chalk.red(
+          "\n  Configuracao nao encontrada. Execute: azure-pr init\n"
+        )
+      );
+      process.exit(1);
+    }
+
+    const api = new AzureDevOpsApi(config);
+    const spinner = ora("Buscando branches...").start();
+
+    try {
+      const branches = await api.getBranches();
+      spinner.succeed(`${branches.length} branches:`);
+      branches.forEach((b) => {
+        console.log(`  ${chalk.gray("-")} ${b.name}`);
+      });
+      console.log();
+    } catch (err) {
+      spinner.fail("Erro: " + err.message);
+    }
+  });
+
+// ==================== TEST ====================
+program
+  .command("test")
+  .description("Testa a conexao com o Azure DevOps")
+  .action(async () => {
+    const config = await loadConfig();
+    if (!config) {
+      console.log(
+        chalk.red(
+          "\n  Configuracao nao encontrada. Execute: azure-pr init\n"
+        )
+      );
+      process.exit(1);
+    }
+
+    const api = new AzureDevOpsApi(config);
+    const spinner = ora("Testando conexao...").start();
+
+    const result = await api.testConnection();
+    if (result.success) {
+      spinner.succeed(
+        `Conexao OK! ${result.repos} repositorio(s) encontrado(s)`
+      );
+    } else {
+      spinner.fail("Falha: " + result.error);
+    }
+  });
+
+program.parse();