@waron97/prbot 1.1.1 → 2.0.0

package/README.md

@@ -1,6 +1,6 @@
 # prbot
 
-CLI tool for fetching Odoo workflow XML files from the RIP API, writing them into the addons repo, and committing the result.
+CLI tool for managing PRs, changelogs, and Odoo workflow XML files in the addons repo.
 
 ## Install
 
@@ -33,6 +33,15 @@ source ~/.bashrc
 | `KC_ID` | Keycloak client ID |
 | `KC_SECRET` | Keycloak client secret |
 | `RIP_URL` | RIP API base URL |
+| `TRIDENT_URL` | Trident (Odoo) instance URL |
+| `TRIDENT_UID` | Trident user ID |
+| `TRIDENT_TOKEN` | Trident API token |
+| `TRIDENT_DB` | Trident database name |
+| `DEVOPS_TOKEN` | Azure DevOps personal access token |
+| `DEVOPS_ORG` | Azure DevOps organization |
+| `DEVOPS_PROJECT` | Azure DevOps project |
+| `DEVOPS_REPO` | Azure DevOps repository name |
+| `AUTOPR_TARGET_BRANCH` | Target branch for auto-created PRs (default: `15.0-dev`) |
 
 ## Commands
 
@@ -62,6 +71,50 @@ Bumps the version in `__manifest__.py` for `<module>` and commits.
 prbot ver config_wf_contestazione --bump patch
 ```
 
+### `prbot changelog <pr>`
+
+Writes a changelog entry into `CHANGELOG.md` for a given PR number. Prompts to select the target section, detects existing indentation, and appends the entry with refs.
+
+```bash
+prbot changelog 42 -m "Fix invoice state race condition" -t 1234 -t 5678 -j TESTML-1 -j TESTML-2
+```
+
+Options:
+
+| Flag | Description |
+|------|-------------|
+| `-m, --message <text>` | Changelog entry message (prompted if omitted) |
+| `-t, --trident <code>` | Trident issue code (repeatable) |
+| `-j, --jira <code>` | JIRA issue code (repeatable) |
+
+### `prbot autopr`
+
+End-to-end PR automation: creates a branch, pushes it, opens a draft PR on Azure DevOps, appends the PR link to each Trident task's release checklist, writes a changelog entry, commits, and pushes.
+
+```bash
+# Single Trident task
+prbot autopr -t 1234
+
+# Multiple Trident tasks (all get PR link; first with work package drives section matching)
+prbot autopr -t 1234 -t 5678
+
+# Multiple Trident + multiple JIRA
+prbot autopr -t 1234 -t 5678 -j TESTML-1 -j TESTML-2
+
+# JIRA only — skips all Trident fetch/write operations
+prbot autopr -j JIRA-99 --branch my-branch
+```
+
+Options:
+
+| Flag | Description |
+|------|-------------|
+| `-t, --trident <id>` | Trident task ID (repeatable) |
+| `-j, --jira <code>` | JIRA issue code (repeatable) |
+| `-m, --message <text>` | Changelog entry message (prompted if omitted) |
+| `-b, --branch <name>` | Branch name (default: `autopr_<first-task-id>` or `autopr_<first-jira>`) |
+| `-n, --name <text>` | PR title (default: Trident task name) |
+
 ### `prbot init`
 
 Interactive setup: writes `~/.config/prbot/config` and installs shell completion.

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@waron97/prbot",
-  "version": "1.1.1",
+  "version": "2.0.0",
   "description": "",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "bin": {
-    "prbot": "index.js"
+    "prbot": "src/index.js"
   },
   "dependencies": {
-    "@waron97/prbot": "^1.0.0",
+    "@inquirer/search": "^2.0.1",
     "commander": "^14.0.2",
     "dotenv": "^17.2.3",
     "eslint-plugin-es5": "^1.5.0",

package/src/commands/autopr.js

@@ -0,0 +1,309 @@
+import fs from "fs/promises";
+import { readFileSync } from "fs";
+import fetch from "node-fetch";
+import inquirer from "inquirer";
+import search from "@inquirer/search";
+import { resolveAddonsPath } from "../lib/addons.js";
+import { execGit } from "../lib/git.js";
+import {
+  extractSections,
+  findSectionEndLine,
+  detectIndentation,
+  buildRefString,
+  findDuplicateLine,
+  appendPrToLine,
+} from "./changelog.js";
+
+function devopsHeaders() {
+  const token = Buffer.from(`:${process.env.DEVOPS_TOKEN}`).toString("base64");
+  return {
+    Authorization: `Basic ${token}`,
+    "Content-Type": "application/json",
+  };
+}
+
+async function fetchTask(taskId) {
+  const url = `${process.env.TRIDENT_URL}/jsonrpc`;
+  const body = {
+    jsonrpc: "2.0",
+    method: "call",
+    id: 1,
+    params: {
+      service: "object",
+      method: "execute_kw",
+      args: [
+        process.env.TRIDENT_DB,
+        parseInt(process.env.TRIDENT_UID, 10),
+        process.env.TRIDENT_TOKEN,
+        "project.task",
+        "read",
+        [[parseInt(taskId, 10)]],
+        {
+          fields: [
+            "name",
+            "x_subpackage_id",
+            "x_workflow",
+            "x_release_checklist",
+          ],
+        },
+      ],
+    },
+  };
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const data = await res.json();
+  if (data.error)
+    throw new Error(`Trident error: ${JSON.stringify(data.error)}`);
+  if (!data.result || !data.result[0])
+    throw new Error(`Task ${taskId} not found`);
+  return data.result[0];
+}
+
+function buildPrDescription(taskIds, jiras) {
+  const lines = taskIds.map(
+    (id) => `${process.env.TRIDENT_URL}/odoo/my-tasks/${id}`,
+  );
+  for (const jira of jiras ?? []) {
+    lines.push(`https://sorgenia.atlassian.net/browse/${jira}`);
+  }
+  return lines.join("\n");
+}
+
+async function createDevopsPR(branch, title, description) {
+  const { DEVOPS_ORG, DEVOPS_PROJECT, DEVOPS_REPO, AUTOPR_TARGET_BRANCH } =
+    process.env;
+  const apiUrl = `https://dev.azure.com/${DEVOPS_ORG}/${DEVOPS_PROJECT}/_apis/git/repositories/${DEVOPS_REPO}/pullrequests?api-version=7.0`;
+  const res = await fetch(apiUrl, {
+    method: "POST",
+    headers: devopsHeaders(),
+    body: JSON.stringify({
+      title,
+      description,
+      isDraft: true,
+      sourceRefName: `refs/heads/${branch}`,
+      targetRefName: `refs/heads/${AUTOPR_TARGET_BRANCH}`,
+    }),
+  });
+  const data = await res.json();
+  if (!res.ok)
+    throw new Error(`DevOps PR creation failed: ${JSON.stringify(data)}`);
+  const prUrl = `https://dev.azure.com/${DEVOPS_ORG}/${DEVOPS_PROJECT}/_git/${DEVOPS_REPO}/pullrequest/${data.pullRequestId}`;
+  return { id: data.pullRequestId, url: prUrl };
+}
+
+async function appendChecklistPrLink(taskId, currentChecklist, prUrl, prNumber) {
+  const link = `<a href="${prUrl}">${prUrl}</a><br/>`;
+  const updated = currentChecklist ? `${currentChecklist}\n${link}` : link;
+  const url = `${process.env.TRIDENT_URL}/jsonrpc`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      method: "call",
+      id: 2,
+      params: {
+        service: "object",
+        method: "execute_kw",
+        args: [
+          process.env.TRIDENT_DB,
+          parseInt(process.env.TRIDENT_UID, 10),
+          process.env.TRIDENT_TOKEN,
+          "project.task",
+          "write",
+          [[parseInt(taskId, 10)], { x_release_checklist: updated }],
+        ],
+      },
+    }),
+  });
+  const data = await res.json();
+  if (data.error)
+    throw new Error(`Trident write error: ${JSON.stringify(data.error)}`);
+}
+
+function scoreSections(sections, candidates) {
+  const results = [];
+  for (const section of sections) {
+    const heading = section.heading.replace(/^### /, "").toLowerCase().trim();
+    let score = 0;
+    for (const candidate of candidates) {
+      const lc = candidate.toLowerCase().trim();
+      if (heading === lc) {
+        score += 100;
+        continue;
+      }
+      if (heading.includes(lc) || lc.includes(heading)) {
+        score += 50;
+        continue;
+      }
+      // Match by first pipe-segment (e.g. "CROSS_31.1 - ML")
+      const candidatePrefix = lc.split("|")[0].trim();
+      const headingPrefix = heading.split("|")[0].trim();
+      if (
+        headingPrefix.includes(candidatePrefix) ||
+        candidatePrefix.includes(headingPrefix)
+      ) {
+        score += 20;
+        continue;
+      }
+      // Token fallback
+      const tokens = lc
+        .split(/[\s|_\-.]+/)
+        .filter((t) => t.length > 2);
+      for (const token of tokens) {
+        if (heading.includes(token)) score++;
+      }
+    }
+    if (score > 0) results.push({ ...section, score });
+  }
+  return results.sort((a, b) => b.score - a.score).slice(0, 3);
+}
+
+async function selectSection(sections, candidates) {
+  const scored = candidates.length > 0 ? scoreSections(sections, candidates) : [];
+
+  if (candidates.length > 0) {
+    console.log(`\nTask fields: ${candidates.join(" | ")}`);
+    if (scored.length === 0) console.log("No matching sections found.");
+  }
+
+  const scoredHeadings = new Set(scored.map((s) => s.heading));
+  const topChoices = scored.map((s) => ({
+    name: `${s.heading.replace(/^### /, "")}  ✓`,
+    value: s.heading,
+  }));
+  const restChoices = sections
+    .filter((s) => !scoredHeadings.has(s.heading))
+    .map((s) => ({ name: s.heading.replace(/^### /, ""), value: s.heading }));
+  const allChoices = [...topChoices, ...restChoices];
+
+  const selected = await search({
+    message: "Select changelog section:",
+    source: async (input) => {
+      if (!input) return allChoices;
+      return allChoices.filter((c) =>
+        c.value.toLowerCase().includes(input.toLowerCase()),
+      );
+    },
+  });
+  return sections.find((s) => s.heading === selected);
+}
+
+async function autopr(options) {
+  const ADDONS_PATH = resolveAddonsPath(process.env.ADDONS_PATH);
+  const changelogPath = `${ADDONS_PATH}/CHANGELOG.md`;
+
+  const ids = options.trident ?? [];
+  const hasTridents = ids.length > 0;
+
+  const tasks = hasTridents
+    ? await Promise.all(ids.map((id) => fetchTask(id)))
+    : [];
+  tasks.forEach((t) => console.log(`Task: ${t.name}`));
+
+  const content = readFileSync(changelogPath, "utf-8");
+
+  const duplicate = hasTridents
+    ? findDuplicateLine(content, ids, [])
+    : null;
+
+  let appendMode = false;
+  if (duplicate) {
+    console.log(`\nExisting entry (line ${duplicate.lineNumber + 1}):\n  ${duplicate.line}`);
+    const { confirm } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Append PR ref to existing entry?",
+        default: true,
+      },
+    ]);
+    appendMode = confirm;
+  }
+
+  const branch =
+    options.branch ??
+    (ids[0]
+      ? `autopr_${ids[0]}`
+      : options.jira?.[0]
+        ? `autopr_${options.jira[0]}`
+        : null);
+  if (!branch)
+    throw new Error(
+      "No branch name: provide --branch, a task ID, or --jira",
+    );
+
+  let message = null;
+  if (!appendMode) {
+    message = options.message;
+    if (!message) {
+      const answer = await inquirer.prompt([
+        { type: "input", name: "message", message: "Changelog entry message:" },
+      ]);
+      message = answer.message;
+    }
+  }
+
+  await execGit(["checkout", "-b", branch], ADDONS_PATH);
+  console.log(`Branch created: ${branch}`);
+  await execGit(["push", "-u", "origin", branch], ADDONS_PATH);
+
+  const prTitle = options.name ?? (tasks[0]?.name ?? branch);
+  const prDescription = buildPrDescription(ids, options.jira ?? []);
+  const { id: prNumber, url: prUrl } = await createDevopsPR(branch, prTitle, prDescription);
+  console.log(`PR opened: #${prNumber} — ${prUrl}`);
+
+  if (hasTridents) {
+    for (let i = 0; i < ids.length; i++) {
+      await appendChecklistPrLink(ids[i], tasks[i].x_release_checklist, prUrl, prNumber);
+    }
+    console.log("Checklist updated");
+  }
+
+  const lines = content.split("\n");
+
+  if (appendMode) {
+    lines[duplicate.lineNumber] = appendPrToLine(lines[duplicate.lineNumber], prNumber);
+  } else {
+    const sections = extractSections(content);
+    const candidates = [];
+    if (hasTridents) {
+      const anchor = tasks.find(
+        (t) =>
+          (Array.isArray(t.x_subpackage_id) && t.x_subpackage_id[1]) ||
+          (Array.isArray(t.x_workflow) && t.x_workflow[1]),
+      );
+      if (anchor) {
+        if (Array.isArray(anchor.x_subpackage_id) && anchor.x_subpackage_id[1])
+          candidates.push(anchor.x_subpackage_id[1]);
+        if (Array.isArray(anchor.x_workflow) && anchor.x_workflow[1])
+          candidates.push(anchor.x_workflow[1]);
+      }
+    }
+
+    const selectedSection = await selectSection(sections, candidates);
+    const endLine = findSectionEndLine(lines, selectedSection.startLine);
+    const indent = detectIndentation(lines, selectedSection.startLine, endLine);
+
+    const jiras = options.jira ?? [];
+    const refString = buildRefString(ids, jiras, prNumber);
+    const newEntry = `${indent}- ${message}${refString ? " " + refString : ""}`;
+    lines.splice(endLine + 1, 0, newEntry);
+  }
+
+  await fs.writeFile(changelogPath, lines.join("\n"));
+  console.log("Changelog entry written");
+
+  await execGit(["add", "CHANGELOG.md"], ADDONS_PATH);
+  await execGit(
+    ["commit", "-m", "[DOC][CHANGELOG] Changelog"],
+    ADDONS_PATH,
+  );
+  await execGit(["push"], ADDONS_PATH);
+  console.log("Changelog committed and pushed");
+}
+
+export { autopr };

package/src/commands/changelog.js

@@ -0,0 +1,189 @@
+import fs from "fs/promises";
+import { readFileSync } from "fs";
+import inquirer from "inquirer";
+import search from "@inquirer/search";
+import { resolveAddonsPath } from "../lib/addons.js";
+
+function buildRefString(tridents, jiras, prNumber) {
+  const refs = [];
+
+  if (tridents && tridents.length > 0) {
+    refs.push(`Trident ${tridents.map((t) => `#${t}`).join(", #")}`);
+  }
+
+  if (jiras && jiras.length > 0) {
+    refs.push(`JIRA ${jiras.join(", ")}`);
+  }
+
+  if (prNumber) {
+    refs.push(`PR sorgenia_addons #${prNumber}ADO`);
+  }
+
+  return refs.length > 0 ? `(${refs.join(", ")})` : "";
+}
+
+function appendPrToLine(line, prNumber) {
+  const parenMatch = line.match(/\(([^)]*)\)\s*$/);
+  if (parenMatch) {
+    const inner = parenMatch[1];
+    const suffix = inner.includes("PR sorgenia_addons")
+      ? `, #${prNumber}ADO`
+      : `, PR sorgenia_addons #${prNumber}ADO`;
+    return line.replace(/\(([^)]*)\)\s*$/, `(${inner}${suffix})`);
+  }
+  return `${line.trimEnd()} (PR sorgenia_addons #${prNumber}ADO)`;
+}
+
+function findDuplicateLine(content, tridents, jiras) {
+  const lines = content.split("\n");
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    if (tridents && tridents.length > 0) {
+      for (const t of tridents) {
+        if (line.includes(`Trident #${t}`)) {
+          return { lineNumber: i, line };
+        }
+      }
+    }
+
+    if (jiras && jiras.length > 0) {
+      for (const j of jiras) {
+        if (line.includes(j)) {
+          return { lineNumber: i, line };
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+function extractSections(content) {
+  const lines = content.split("\n");
+  const sections = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith("### ")) {
+      sections.push({
+        heading: lines[i],
+        startLine: i,
+      });
+    }
+  }
+
+  return sections;
+}
+
+function findSectionEndLine(lines, sectionStartLine) {
+  const nextSectionLine = lines.findIndex(
+    (l, i) => i > sectionStartLine && l.startsWith("### "),
+  );
+
+  if (nextSectionLine === -1) {
+    return lines.length - 1;
+  }
+
+  let endLine = nextSectionLine - 1;
+  while (endLine > sectionStartLine && lines[endLine].trim() === "") {
+    endLine--;
+  }
+
+  return endLine;
+}
+
+function detectIndentation(lines, sectionStartLine, sectionEndLine) {
+  for (let i = sectionStartLine + 1; i <= sectionEndLine; i++) {
+    const line = lines[i];
+    const match = line.match(/^(\s*)-\s/);
+    if (match) {
+      return match[1];
+    }
+  }
+  return "  ";
+}
+
+async function changelog(prNumber, options) {
+  const tridents = options.trident || [];
+  const jiras = options.jira || [];
+  let message = options.message;
+
+  let ADDONS_PATH = resolveAddonsPath(process.env.ADDONS_PATH);
+  const changelogPath = `${ADDONS_PATH}/CHANGELOG.md`;
+
+  const content = readFileSync(changelogPath, "utf-8");
+
+  const duplicate = findDuplicateLine(content, tridents, jiras);
+  let appendMode = false;
+  if (duplicate) {
+    console.log(`\nExisting entry (line ${duplicate.lineNumber + 1}):\n  ${duplicate.line}`);
+    const { confirm } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Append PR ref to existing entry?",
+        default: true,
+      },
+    ]);
+    appendMode = confirm;
+  }
+
+  if (appendMode) {
+    const lines = content.split("\n");
+    lines[duplicate.lineNumber] = appendPrToLine(lines[duplicate.lineNumber], prNumber);
+    await fs.writeFile(changelogPath, lines.join("\n"));
+    console.log("Updated existing line");
+    return;
+  }
+
+  if (!message) {
+    const answer = await inquirer.prompt([
+      {
+        type: "input",
+        name: "message",
+        message: "Changelog entry message:",
+      },
+    ]);
+    message = answer.message;
+  }
+
+  const sections = extractSections(content);
+  const sectionChoices = sections.map((s) => ({
+    name: s.heading.replace(/^## /, ""),
+    value: s.heading,
+  }));
+
+  const selectedSection = await search({
+    message: "Select section to add entry:",
+    source: async (input) => {
+      if (!input) {
+        return sectionChoices;
+      }
+
+      const filtered = sectionChoices.filter((choice) =>
+        choice.name.toLowerCase().includes(input.toLowerCase()),
+      );
+
+      return filtered;
+    },
+  });
+
+  const selectedSectionObj = sections.find(
+    (s) => s.heading === selectedSection,
+  );
+
+  const lines = content.split("\n");
+  const endLine = findSectionEndLine(lines, selectedSectionObj.startLine);
+  const indent = detectIndentation(lines, selectedSectionObj.startLine, endLine);
+
+  const refString = buildRefString(tridents, jiras, prNumber);
+  const newEntry = `${indent}- ${message}${refString ? " " + refString : ""}`;
+
+  lines.splice(endLine + 1, 0, newEntry);
+
+  await fs.writeFile(changelogPath, lines.join("\n"));
+  console.log("Changelog entry added");
+}
+
+export { changelog, extractSections, findSectionEndLine, detectIndentation, buildRefString, findDuplicateLine, appendPrToLine };

package/src/commands/init.js

@@ -0,0 +1,144 @@
+import { readFileSync, existsSync, mkdirSync, writeFileSync, appendFileSync } from "fs";
+import path from "path";
+import inquirer from "inquirer";
+import { CONFIG_DIR, CONFIG_FILE, COMPLETION_SCRIPT } from "../config.js";
+
+async function init(completion) {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+
+  const existing = existsSync(CONFIG_FILE)
+    ? Object.fromEntries(
+        readFileSync(CONFIG_FILE, "utf-8")
+          .split("\n")
+          .flatMap((line) => {
+            const m = line.match(/^([A-Z_]+)=(.*)$/);
+            return m ? [[m[1], m[2]]] : [];
+          }),
+      )
+    : {};
+
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "ADDONS_PATH",
+      message: "Addons path:",
+      default: existing.ADDONS_PATH ?? "~/codebase/sorgenia/addons",
+    },
+    {
+      type: "input",
+      name: "KC_URL",
+      message: "Keycloak URL:",
+      default: existing.KC_URL ?? "",
+    },
+    {
+      type: "input",
+      name: "KC_USER",
+      message: "Keycloak user:",
+      default: existing.KC_USER ?? "",
+    },
+    {
+      type: "password",
+      name: "KC_PASSWORD",
+      message: "Keycloak password:",
+      default: existing.KC_PASSWORD ?? "",
+      mask: "*",
+    },
+    {
+      type: "input",
+      name: "KC_ID",
+      message: "Keycloak client ID:",
+      default: existing.KC_ID ?? "",
+    },
+    {
+      type: "input",
+      name: "KC_SECRET",
+      message: "Keycloak client secret:",
+      default: existing.KC_SECRET ?? "",
+    },
+    {
+      type: "input",
+      name: "RIP_URL",
+      message: "RIP URL:",
+      default: existing.RIP_URL ?? "",
+    },
+    {
+      type: "input",
+      name: "TRIDENT_URL",
+      message: "Trident URL:",
+      default: existing.TRIDENT_URL ?? "",
+    },
+    {
+      type: "input",
+      name: "TRIDENT_UID",
+      message: "Trident UID:",
+      default: existing.TRIDENT_UID ?? "",
+    },
+    {
+      type: "input",
+      name: "TRIDENT_TOKEN",
+      message: "Trident token:",
+      default: existing.TRIDENT_TOKEN ?? "",
+    },
+    {
+      type: "input",
+      name: "DEVOPS_TOKEN",
+      message: "DevOps token:",
+      default: existing.DEVOPS_TOKEN ?? "",
+    },
+    {
+      type: "input",
+      name: "DEVOPS_ORG",
+      message: "DevOps org:",
+      default: existing.DEVOPS_ORG ?? "",
+    },
+    {
+      type: "input",
+      name: "DEVOPS_PROJECT",
+      message: "DevOps project:",
+      default: existing.DEVOPS_PROJECT ?? "",
+    },
+    {
+      type: "input",
+      name: "DEVOPS_REPO",
+      message: "DevOps repo:",
+      default: existing.DEVOPS_REPO ?? "",
+    },
+    {
+      type: "input",
+      name: "TRIDENT_DB",
+      message: "Trident DB name:",
+      default: existing.TRIDENT_DB ?? "",
+    },
+    {
+      type: "input",
+      name: "AUTOPR_TARGET_BRANCH",
+      message: "AutoPR target branch:",
+      default: existing.AUTOPR_TARGET_BRANCH ?? "15.0-dev",
+    },
+  ]);
+
+  writeFileSync(
+    CONFIG_FILE,
+    Object.entries(answers)
+      .map(([k, v]) => `${k}=${v}`)
+      .join("\n") + "\n",
+  );
+  console.log(`Config written to ${CONFIG_FILE}`);
+
+  writeFileSync(COMPLETION_SCRIPT, completion.generateCompletionCode());
+  console.log(`Completion script written to ${COMPLETION_SCRIPT}`);
+
+  const rcFile = path.join(process.env.HOME || "", ".bashrc");
+  const sourceLine = `source ${COMPLETION_SCRIPT}`;
+  const rcContent = existsSync(rcFile) ? readFileSync(rcFile, "utf-8") : "";
+  if (!rcContent.includes(sourceLine)) {
+    appendFileSync(rcFile, `\n# prbot completion\n${sourceLine}\n`);
+    console.log(`Registered completion in ${rcFile} — run: source ~/.bashrc`);
+  } else {
+    console.log("Completion already registered in ~/.bashrc");
+  }
+}
+
+export { init };

package/src/commands/pr.js

@@ -0,0 +1,124 @@
+import fetch from "node-fetch";
+import fs from "fs/promises";
+import path from "path";
+import { execFile } from "child_process";
+import { resolveAddonsPath } from "../lib/addons.js";
+
+async function getToken() {
+  const url = process.env.KC_URL;
+  const payload = new URLSearchParams();
+
+  payload.append("username", process.env.KC_USER);
+  payload.append("password", process.env.KC_PASSWORD);
+  payload.append("client_id", process.env.KC_ID);
+  payload.append("client_secret", process.env.KC_SECRET);
+  payload.append("grant_type", "password");
+
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+    body: payload.toString(),
+  });
+
+  const json = await response.json();
+  return json.access_token;
+}
+
+async function getFiles(module_name, token) {
+  const url = `${process.env.RIP_URL}/ir.model/xml_prbot`;
+  const body = JSON.stringify({ module_name });
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+  };
+
+  const response = await fetch(url, { method: "POST", body, headers });
+  if (!response.ok) {
+    throw new Error(await response.text());
+  }
+  return await response.json();
+}
+
+async function main(module_name) {
+  const token = await getToken();
+  const files = await getFiles(module_name, token);
+
+  let ADDONS_PATH = resolveAddonsPath(process.env.ADDONS_PATH);
+
+  for (const file of files) {
+    const buffer = Buffer.from(file.data, "base64");
+    let content = buffer.toString();
+    const lines = content.split("\n");
+
+    const odooCloseIndex = lines.findIndex((l) => l.trim() === "</odoo>");
+    if (odooCloseIndex !== -1 && odooCloseIndex < lines.length - 1) {
+      const footer = lines.slice(odooCloseIndex + 1).join("\n");
+      const skippedMatch = footer.match(/Skipped records:\s*(\d+)/);
+      if (skippedMatch && parseInt(skippedMatch[1]) > 0) {
+        throw new Error(
+          `[${file.name}] Export contains skipped records:\n${footer.trim()}`,
+        );
+      }
+      const duplicatedMatch = footer.match(/Duplicated records:\s*(\d+)/);
+      if (duplicatedMatch && parseInt(duplicatedMatch[1]) > 0) {
+        throw new Error(
+          `[${file.name}] Export contains duplicated records:\n${footer.trim()}`,
+        );
+      }
+    }
+
+    if (lines.length > 2) {
+      lines.splice(-2);
+    }
+    content = lines.join("\n");
+    content = content.replace(
+      /<field name="bpmn_diagram"><!\[CDATA\[[\s\S]*?\]\]><\/field>/g,
+      "",
+    );
+
+    let destPath;
+    if (file.name.includes("Relazioni mancanti")) {
+      destPath = `${ADDONS_PATH}/config/${module_name}/data/workflow_missing_relations.xml`;
+    } else {
+      destPath = `${ADDONS_PATH}/config/${module_name}/data/workflow_configuration.xml`;
+    }
+
+    await fs.mkdir(path.dirname(destPath), { recursive: true });
+    await fs.writeFile(destPath, content);
+    console.log(`Processed: ${file.name} -> ${destPath}`);
+  }
+
+  const workflowDir = path.join(ADDONS_PATH, "config", module_name, "data");
+  const filesToAdd = [
+    path.join(workflowDir, "workflow_missing_relations.xml"),
+    path.join(workflowDir, "workflow_configuration.xml"),
+  ];
+
+  for (const filePath of filesToAdd) {
+    await new Promise((resolve, reject) => {
+      execFile("git", ["add", filePath], { cwd: ADDONS_PATH }, (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
+  const commitMessage = `[IMP][${module_name}] Update workflow`;
+  await new Promise((resolve, reject) => {
+    execFile(
+      "git",
+      ["commit", "-m", commitMessage],
+      { cwd: ADDONS_PATH },
+      (error) => {
+        if (error) reject(error);
+        else resolve();
+      },
+    );
+  });
+
+  console.log(`Committed with message: ${commitMessage}`);
+}
+
+export { main };

package/src/commands/ver.js

@@ -0,0 +1,83 @@
+import fs from "fs/promises";
+import path from "path";
+import { execFile } from "child_process";
+import { resolveAddonsPath } from "../lib/addons.js";
+
+async function verbot(module_name, level) {
+  if (!["major", "minor", "patch"].includes(level)) {
+    throw new Error("Level must be one of major, minor, patch");
+  }
+
+  let ADDONS_PATH = resolveAddonsPath(process.env.ADDONS_PATH);
+
+  let manifestPath = path.join(ADDONS_PATH, module_name, "__manifest__.py");
+  try {
+    await fs.access(manifestPath);
+  } catch {
+    manifestPath = path.join(
+      ADDONS_PATH,
+      "config",
+      module_name,
+      "__manifest__.py",
+    );
+    try {
+      await fs.access(manifestPath);
+    } catch {
+      throw new Error(`__manifest__.py not found for module ${module_name}`);
+    }
+  }
+
+  const content = await fs.readFile(manifestPath, "utf-8");
+  const versionMatch = content.match(/"version":\s*"(15\.0\.\d+\.\d+\.\d+)"/);
+  if (!versionMatch) {
+    throw new Error("Version not found in manifest");
+  }
+
+  const currentVersion = versionMatch[1];
+  const parts = currentVersion.split(".");
+  const base = `${parts[0]}.${parts[1]}`;
+  const major = parseInt(parts[2]);
+  const minor = parseInt(parts[3]);
+  const patch = parseInt(parts[4]);
+
+  let newVersion;
+  if (level === "patch") {
+    newVersion = `${base}.${major}.${minor}.${patch + 1}`;
+  } else if (level === "minor") {
+    newVersion = `${base}.${major}.${minor + 1}.0`;
+  } else if (level === "major") {
+    newVersion = `${base}.${major + 1}.0.0`;
+  }
+
+  const newContent = content.replace(
+    `"version": "${currentVersion}"`,
+    `"version": "${newVersion}"`,
+  );
+
+  await fs.writeFile(manifestPath, newContent);
+  console.log(`Updated version: ${currentVersion} -> ${newVersion}`);
+
+  await new Promise((resolve, reject) => {
+    execFile("git", ["add", manifestPath], { cwd: ADDONS_PATH }, (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+
+  const commitMessage = `[VER][${module_name}] Bump`;
+  await new Promise((resolve, reject) => {
+    execFile(
+      "git",
+      ["commit", "-m", commitMessage],
+      { cwd: ADDONS_PATH },
+      (error) => {
+        if (error) reject(error);
+        else resolve();
+      },
+    );
+  });
+
+  console.log(`Committed with message: ${commitMessage}`);
+}
+
+export { verbot };

package/src/config.js

@@ -0,0 +1,7 @@
+import path from "path";
+
+const CONFIG_DIR = path.join(process.env.HOME || "", ".config", "prbot");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config");
+const COMPLETION_SCRIPT = path.join(CONFIG_DIR, "completion.sh");
+
+export { CONFIG_DIR, CONFIG_FILE, COMPLETION_SCRIPT };

package/src/index.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+
+import { configDotenv } from "dotenv";
+import { readdirSync, readFileSync } from "fs";
+import path from "path";
+import { program } from "commander";
+import omelette from "omelette";
+import { CONFIG_FILE, COMPLETION_SCRIPT } from "./config.js";
+import { main as prMain } from "./commands/pr.js";
+import { verbot } from "./commands/ver.js";
+import { init } from "./commands/init.js";
+import { changelog } from "./commands/changelog.js";
+import { autopr } from "./commands/autopr.js";
+
+const completion = omelette("prbot <command> <module>");
+completion.on("command", ({ reply }) => {
+  reply(["pr", "ver", "init", "changelog", "autopr"]);
+});
+
+completion.on("module", ({ before, reply }) => {
+  if (["init", "changelog", "autopr"].includes(before)) {
+    reply([]);
+    return;
+  }
+  try {
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    const match = raw.match(/^ADDONS_PATH=(.+)$/m);
+    if (!match) {
+      reply([]);
+      return;
+    }
+    const addonsPath = match[1].trim().replace(/^~/, process.env.HOME || "");
+    reply(readdirSync(path.join(addonsPath, "config")));
+  } catch {
+    reply([]);
+  }
+});
+
+completion.init();
+
+const isCompletionMode =
+  process.argv.includes("--compbash") || process.argv.includes("--compzsh");
+
+if (!isCompletionMode) {
+  configDotenv({ path: CONFIG_FILE });
+}
+
+program
+  .command("pr <module>")
+  .option("-b, --bump <level>")
+  .action((module, opts) => {
+    prMain(module)
+      .then(() => {
+        if (opts.bump) {
+          return verbot(module, opts.bump);
+        }
+      })
+      .catch((err) => {
+        throw err;
+      });
+  });
+
+program
+  .command("ver <module>")
+  .option("-b, --bump <level>")
+  .action((module, opts) => {
+    if (!opts.bump) {
+      throw new Error("No bump level specified");
+    }
+    verbot(module, opts.bump);
+  });
+
+program
+  .command("init")
+  .description("Create config file and install shell completion")
+  .action(() => {
+    init(completion);
+  });
+
+const collect = (val, prev) => [...(prev ?? []), val];
+
+program
+  .command("changelog <pr>")
+  .option("-t, --trident <code>", "Trident issue codes (repeatable)", collect)
+  .option("-j, --jira <code>", "JIRA issue codes (repeatable)", collect)
+  .option("-m, --message <text>", "Changelog entry message")
+  .action((prNumber, opts) => {
+    changelog(prNumber, opts).catch((err) => {
+      throw err;
+    });
+  });
+
+program
+  .command("autopr")
+  .option("-t, --trident <id>", "Trident task IDs (repeatable)", collect)
+  .option("-j, --jira <code>", "JIRA issue codes (repeatable)", collect)
+  .option("-m, --message <text>", "Changelog entry message")
+  .option("-b, --branch <name>", "Branch name (default: autopr_<taskId>)")
+  .option("-n, --name <text>", "PR title (default: task name from Odoo)")
+  .action((opts) => {
+    autopr(opts).catch((err) => {
+      throw err;
+    });
+  });
+
+program.parse();

package/src/lib/addons.js

@@ -0,0 +1,8 @@
+function resolveAddonsPath(addonsPath) {
+  if (addonsPath.startsWith("~")) {
+    return addonsPath.replace("~", process.env.HOME);
+  }
+  return addonsPath;
+}
+
+export { resolveAddonsPath };

package/src/lib/git.js

@@ -0,0 +1,12 @@
+import { execFile } from "child_process";
+
+function execGit(args, cwd) {
+  return new Promise((resolve, reject) => {
+    execFile("git", args, { cwd }, (error, stdout) => {
+      if (error) reject(error);
+      else resolve(stdout);
+    });
+  });
+}
+
+export { execGit };