@waron97/prbot 1.1.0 → 2.0.0

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 };