azure-pr-manager 1.0.0

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "azure-pr-manager",
+  "version": "1.0.0",
+  "description": "CLI para criar Pull Requests no Azure DevOps automaticamente, com fluxo git completo (commit, push, publish branch)",
+  "main": "src/index.js",
+  "bin": {
+    "azure-pr": "src/index.js",
+    "apr": "src/index.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "init": "node src/index.js init"
+  },
+  "keywords": [
+    "azure-devops",
+    "pull-request",
+    "pr",
+    "cli",
+    "automation",
+    "git",
+    "devops",
+    "azure"
+  ],
+  "author": "Higor Santos",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/higorsantos/azure-pr-manager"
+  },
+  "homepage": "https://github.com/higorsantos/azure-pr-manager#readme",
+  "bugs": {
+    "url": "https://github.com/higorsantos/azure-pr-manager/issues"
+  },
+  "files": [
+    "src/"
+  ],
+  "dependencies": {
+    "inquirer": "^9.2.12",
+    "chalk": "^5.3.0",
+    "node-fetch": "^3.3.2",
+    "ora": "^7.0.1",
+    "commander": "^11.1.0"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/api.js

@@ -0,0 +1,274 @@
+/**
+ * Azure DevOps REST API client
+ * Docs: https://learn.microsoft.com/en-us/rest/api/azure/devops/
+ */
+
+export class AzureDevOpsApi {
+  constructor(config) {
+    this.organization = config.organization;
+    this.project = config.project;
+    this.repository = config.repository;
+    this.token = config.token;
+    this.baseUrl = `https://dev.azure.com/${this.organization}/${this.project}/_apis`;
+    this.authHeader =
+      "Basic " + Buffer.from(":" + this.token).toString("base64");
+  }
+
+  async request(path, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      Authorization: this.authHeader,
+      "Content-Type": "application/json",
+      ...options.headers,
+    };
+
+    const response = await fetch(url, { ...options, headers });
+
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `Azure DevOps API error (${response.status}): ${body}`
+      );
+    }
+
+    return response.json();
+  }
+
+  /**
+   * Lista todas as branches do repositorio
+   */
+  async getBranches() {
+    const data = await this.request(
+      `/git/repositories/${this.repository}/refs?filter=heads/&api-version=7.1`
+    );
+    return data.value.map((ref) => ({
+      name: ref.name.replace("refs/heads/", ""),
+      objectId: ref.objectId,
+    }));
+  }
+
+  /**
+   * Lista os repositorios do projeto
+   */
+  async getRepositories() {
+    const data = await this.request(
+      `/git/repositories?api-version=7.1`
+    );
+    return data.value.map((repo) => ({
+      id: repo.id,
+      name: repo.name,
+      defaultBranch: (repo.defaultBranch || "").replace("refs/heads/", ""),
+    }));
+  }
+
+  /**
+   * Busca usuario por email via Identity Picker API (mesmo endpoint que a UI usa).
+   * Retorna o localId que e o GUID aceito pelo endpoint de PR.
+   */
+  async resolveUserByEmail(email) {
+    // Primeiro: Identity Picker (mais confiavel, retorna localId)
+    try {
+      const url = `https://dev.azure.com/${this.organization}/_apis/IdentityPicker/Identities?api-version=7.1-preview.1`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: this.authHeader,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          query: email,
+          identityTypes: ["user"],
+          operationScopes: ["ims", "source"],
+          options: { MinResults: 1, MaxResults: 5 },
+          properties: [
+            "DisplayName",
+            "Mail",
+            "ScopeName",
+          ],
+        }),
+      });
+
+      if (response.ok) {
+        const data = await response.json();
+        const results = data.results?.[0]?.identities;
+        if (results && results.length > 0) {
+          // Procurar match exato por email primeiro
+          const emailLower = email.toLowerCase();
+          const exact = results.find(
+            (r) =>
+              (r.mail || "").toLowerCase() === emailLower ||
+              (r.signInAddress || "").toLowerCase() === emailLower
+          );
+          const identity = exact || results[0];
+
+          if (identity.localId) {
+            return {
+              id: identity.localId,
+              displayName: identity.displayName,
+              uniqueName: identity.signInAddress || email,
+            };
+          }
+        }
+      }
+    } catch {
+      // continue to fallback
+    }
+
+    // Fallback: Graph Members API (busca por email no escopo do projeto)
+    try {
+      const url = `https://vsaex.dev.azure.com/${this.organization}/_apis/userentitlements?$filter=name eq '${encodeURIComponent(email)}'&api-version=7.1-preview.3`;
+      const response = await fetch(url, {
+        headers: {
+          Authorization: this.authHeader,
+          "Content-Type": "application/json",
+        },
+      });
+
+      if (response.ok) {
+        const data = await response.json();
+        if (data.members && data.members.length > 0) {
+          const member = data.members[0];
+          // O campo member.id e o GUID correto da entitlement
+          return {
+            id: member.id,
+            displayName: member.user.displayName,
+            uniqueName: member.user.principalName || email,
+          };
+        }
+      }
+    } catch {
+      // continue to last fallback
+    }
+
+    // Last fallback: Identities API
+    const url = `https://dev.azure.com/${this.organization}/_apis/identities?searchFilter=General&filterValue=${encodeURIComponent(email)}&queryMembership=None&api-version=7.1`;
+    const response = await fetch(url, {
+      headers: {
+        Authorization: this.authHeader,
+        "Content-Type": "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Nao foi possivel resolver o usuario: ${email}`);
+    }
+
+    const data = await response.json();
+    if (data.value && data.value.length > 0) {
+      const identity = data.value[0];
+      return {
+        id: identity.id,
+        displayName: identity.providerDisplayName || identity.displayName,
+        uniqueName: identity.properties?.Account?.$value || email,
+      };
+    }
+
+    throw new Error(`Usuario nao encontrado: ${email}`);
+  }
+
+  /**
+   * Resolve multiplos emails para IDs
+   */
+  async resolveReviewers(emails) {
+    const results = [];
+    for (const email of emails) {
+      try {
+        const user = await this.resolveUserByEmail(email);
+        results.push(user);
+      } catch (err) {
+        console.warn(`  Aviso: ${err.message}`);
+      }
+    }
+    return results;
+  }
+
+  /**
+   * Cria um Pull Request
+   */
+  async createPullRequest({
+    sourceBranch,
+    targetBranch,
+    title,
+    description = "",
+    reviewers = [],
+    optionalReviewers = [],
+    isDraft = false,
+    autoComplete = false,
+  }) {
+    // Formatar refs
+    const sourceRef = sourceBranch.startsWith("refs/heads/")
+      ? sourceBranch
+      : `refs/heads/${sourceBranch}`;
+    const targetRef = targetBranch.startsWith("refs/heads/")
+      ? targetBranch
+      : `refs/heads/${targetBranch}`;
+
+    // Montar lista de reviewers
+    const allReviewers = [
+      ...reviewers.map((r) => ({
+        id: r.id,
+        isRequired: true,
+      })),
+      ...optionalReviewers.map((r) => ({
+        id: r.id,
+        isRequired: false,
+      })),
+    ];
+
+    const body = {
+      sourceRefName: sourceRef,
+      targetRefName: targetRef,
+      title,
+      description,
+      reviewers: allReviewers,
+      isDraft,
+    };
+
+    const pr = await this.request(
+      `/git/repositories/${this.repository}/pullrequests?api-version=7.1`,
+      {
+        method: "POST",
+        body: JSON.stringify(body),
+      }
+    );
+
+    if (autoComplete && pr.createdBy) {
+      try {
+        await this.request(
+          `/git/repositories/${this.repository}/pullrequests/${pr.pullRequestId}?api-version=7.1`,
+          {
+            method: "PATCH",
+            body: JSON.stringify({
+              autoCompleteSetBy: { id: pr.createdBy.id },
+              completionOptions: {
+                mergeStrategy: "squash",
+                deleteSourceBranch: true,
+              },
+            }),
+          }
+        );
+      } catch {
+        // auto-complete is optional, don't fail the PR creation
+      }
+    }
+
+    return pr;
+  }
+
+  /**
+   * Verifica se a conexao/token esta funcionando
+   */
+  async testConnection() {
+    try {
+      const data = await this.request(
+        `/git/repositories?api-version=7.1`
+      );
+      return {
+        success: true,
+        repos: data.count || data.value?.length || 0,
+      };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+}

package/src/config.js

@@ -0,0 +1,78 @@
+import { readFile, writeFile, access } from "fs/promises";
+import { join } from "path";
+
+const CONFIG_FILE = ".prmanager.json";
+
+const DEFAULT_CONFIG = {
+  organization: "",
+  project: "",
+  repository: "",
+  token: "",
+  titleFormat: "{source} -> {target}",
+  requiredReviewers: [],
+  optionalReviewers: [],
+  defaults: {
+    isDraft: false,
+    autoComplete: false,
+    deleteSourceBranch: true,
+  },
+};
+
+/**
+ * Encontra o arquivo de config no diretorio atual ou acima
+ */
+export async function findConfigPath(startDir = process.cwd()) {
+  let dir = startDir;
+  const root =
+    process.platform === "win32" ? dir.split("\\")[0] + "\\" : "/";
+
+  while (true) {
+    const configPath = join(dir, CONFIG_FILE);
+    try {
+      await access(configPath);
+      return configPath;
+    } catch {
+      const parent =
+        process.platform === "win32"
+          ? join(dir, "..")
+          : join(dir, "..");
+      if (parent === dir || dir === root) break;
+      dir = parent;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Carrega a configuracao
+ */
+export async function loadConfig() {
+  const configPath = await findConfigPath();
+  if (!configPath) return null;
+
+  try {
+    const raw = await readFile(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    return { ...DEFAULT_CONFIG, ...config, _path: configPath };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Salva a configuracao
+ */
+export async function saveConfig(config, dir = process.cwd()) {
+  const { _path, ...data } = config;
+  const configPath = _path || join(dir, CONFIG_FILE);
+  await writeFile(configPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  return configPath;
+}
+
+/**
+ * Retorna a config padrao
+ */
+export function getDefaultConfig() {
+  return { ...DEFAULT_CONFIG };
+}

package/src/git.js

@@ -0,0 +1,174 @@
+/**
+ * Git operations utility module
+ * Wraps child_process.execSync for common git commands
+ */
+
+import { execSync } from "child_process";
+
+/**
+ * Executa um comando git e retorna o output
+ * @param {string} args - Argumentos do git
+ * @returns {string} Output do comando
+ */
+function exec(args) {
+  return execSync(`git ${args}`, { encoding: "utf-8" }).trim();
+}
+
+/**
+ * Verifica se estamos dentro de um repositorio git
+ */
+export function isGitRepo() {
+  try {
+    exec("rev-parse --is-inside-work-tree");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Retorna o nome da branch atual
+ */
+export function getCurrentBranch() {
+  try {
+    return exec("rev-parse --abbrev-ref HEAD");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Verifica se existem alteracoes nao commitadas (staged ou unstaged)
+ * @returns {{ hasUnstaged: boolean, hasStaged: boolean, untrackedFiles: string[], modifiedFiles: string[], stagedFiles: string[] }}
+ */
+export function getWorkingTreeStatus() {
+  const status = exec("status --porcelain");
+  const lines = status ? status.split("\n").filter(Boolean) : [];
+
+  const untrackedFiles = [];
+  const modifiedFiles = [];
+  const stagedFiles = [];
+
+  for (const line of lines) {
+    const index = line[0];
+    const worktree = line[1];
+    const file = line.slice(3);
+
+    if (index === "?" && worktree === "?") {
+      untrackedFiles.push(file);
+    } else {
+      if (worktree === "M" || worktree === "D") {
+        modifiedFiles.push(file);
+      }
+      if (index === "M" || index === "A" || index === "D" || index === "R") {
+        stagedFiles.push(file);
+      }
+    }
+  }
+
+  return {
+    hasUnstaged: modifiedFiles.length > 0 || untrackedFiles.length > 0,
+    hasStaged: stagedFiles.length > 0,
+    untrackedFiles,
+    modifiedFiles,
+    stagedFiles,
+    clean: lines.length === 0,
+  };
+}
+
+/**
+ * Faz git add -A (stage all)
+ */
+export function stageAll() {
+  exec("add -A");
+}
+
+/**
+ * Faz git commit com a mensagem fornecida
+ * @param {string} message
+ */
+export function commit(message) {
+  // Escape double quotes in message for shell
+  const escaped = message.replace(/"/g, '\\"');
+  exec(`commit -m "${escaped}"`);
+}
+
+/**
+ * Verifica se o remote 'origin' existe
+ */
+export function hasRemoteOrigin() {
+  try {
+    const remotes = exec("remote");
+    return remotes.split("\n").includes("origin");
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Verifica se a branch existe no remote
+ * @param {string} branch
+ */
+export function branchExistsOnRemote(branch) {
+  try {
+    const result = exec(`ls-remote --heads origin refs/heads/${branch}`);
+    return result.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Verifica se existem commits locais nao enviados ao remote
+ * @param {string} branch
+ * @returns {number} Numero de commits pendentes
+ */
+export function getUnpushedCommitCount(branch) {
+  try {
+    const count = exec(`rev-list --count origin/${branch}..HEAD`);
+    return parseInt(count, 10) || 0;
+  } catch {
+    // Se origin/branch nao existe, todos os commits sao "unpushed"
+    return -1;
+  }
+}
+
+/**
+ * Lista os commits nao pushados (resumo)
+ * @param {string} branch
+ * @returns {string[]}
+ */
+export function getUnpushedCommits(branch) {
+  try {
+    const log = exec(`log origin/${branch}..HEAD --oneline`);
+    return log ? log.split("\n").filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Publica a branch no remote (git push -u origin branch)
+ * @param {string} branch
+ */
+export function publishBranch(branch) {
+  exec(`push -u origin ${branch}`);
+}
+
+/**
+ * Push simples (branch ja existe no remote)
+ */
+export function push() {
+  exec("push");
+}
+
+/**
+ * Faz fetch do remote para garantir refs atualizadas
+ */
+export function fetchOrigin() {
+  try {
+    exec("fetch origin --prune");
+  } catch {
+    // fetch pode falhar se nao tiver acesso, prosseguir
+  }
+}