@waron97/prbot 2.1.0 → 2.3.0

package/src/commands/changelog.js

@@ -1,189 +1,193 @@
-import fs from "fs/promises";
-import { readFileSync } from "fs";
-import inquirer from "inquirer";
-import search from "@inquirer/search";
-import { resolveAddonsPath } from "../lib/addons.js";
+import { readFileSync } from 'fs';
+import fs from 'fs/promises';
+import search from '@inquirer/search';
+import inquirer from 'inquirer';
+import { resolveAddonsPath } from '../lib/addons.js';
 
 function buildRefString(tridents, jiras, prNumber) {
-  const refs = [];
+    const refs = [];
 
-  if (tridents && tridents.length > 0) {
-    refs.push(`Trident ${tridents.map((t) => `#${t}`).join(", #")}`);
-  }
+    if (tridents && tridents.length > 0) {
+        refs.push(`Trident ${tridents.map((t) => `#${t}`).join(', #')}`);
+    }
 
-  if (jiras && jiras.length > 0) {
-    refs.push(`JIRA ${jiras.join(", ")}`);
-  }
+    if (jiras && jiras.length > 0) {
+        refs.push(`JIRA ${jiras.join(', ')}`);
+    }
 
-  if (prNumber) {
-    refs.push(`PR sorgenia_addons #${prNumber}ADO`);
-  }
+    if (prNumber) {
+        refs.push(`PR sorgenia_addons #${prNumber}ADO`);
+    }
 
-  return refs.length > 0 ? `(${refs.join(", ")})` : "";
+    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)`;
+    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");
+    const lines = content.split('\n');
 
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
+    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 (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 };
+        if (jiras && jiras.length > 0) {
+            for (const j of jiras) {
+                if (line.includes(j)) {
+                    return { lineNumber: i, line };
+                }
+            }
         }
-      }
     }
-  }
 
-  return null;
+    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,
-      });
+    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;
+    return sections;
 }
 
 function findSectionEndLine(lines, sectionStartLine) {
-  const nextSectionLine = lines.findIndex(
-    (l, i) => i > sectionStartLine && l.startsWith("### "),
-  );
+    const nextSectionLine = lines.findIndex((l, i) => i > sectionStartLine && l.startsWith('### '));
 
-  if (nextSectionLine === -1) {
-    return lines.length - 1;
-  }
+    if (nextSectionLine === -1) {
+        return lines.length - 1;
+    }
 
-  let endLine = nextSectionLine - 1;
-  while (endLine > sectionStartLine && lines[endLine].trim() === "") {
-    endLine--;
-  }
+    let endLine = nextSectionLine - 1;
+    while (endLine > sectionStartLine && lines[endLine].trim() === '') {
+        endLine--;
+    }
 
-  return 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];
+    for (let i = sectionStartLine + 1; i <= sectionEndLine; i++) {
+        const line = lines[i];
+        const match = line.match(/^(\s*)-\s/);
+        if (match) {
+            return match[1];
+        }
     }
-  }
-  return "  ";
+    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");
+    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 };
+export {
+    changelog,
+    extractSections,
+    findSectionEndLine,
+    detectIndentation,
+    buildRefString,
+    findDuplicateLine,
+    appendPrToLine,
+};

package/src/commands/commit.js

@@ -0,0 +1,146 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import searchList from 'inquirer-search-list';
+import { resolveAddonsPath } from '../lib/addons.js';
+import { execGit } from '../lib/git.js';
+
+inquirer.registerPrompt('search-list', searchList);
+
+const commitOperations = [
+    {
+        name: `✅ ADD ${chalk.gray('- Adding something that was previously missing')}`,
+        value: '[ADD]',
+    },
+    { name: `📖 DOC ${chalk.gray('- Documentation changes')}`, value: '[DOC]' },
+    { name: `🩹 FIX ${chalk.gray('- Bugfix or hotfix')}`, value: '[FIX]' },
+    { name: `🛠️ IMP ${chalk.gray('- Improvement of existing code')}`, value: '[IMP]' },
+    { name: `💬 I18N ${chalk.gray('- Translation changes')}`, value: '[I18N]' },
+    { name: `📦 MIG ${chalk.gray('- Module migration')}`, value: '[MIG]' },
+    { name: `🔄 REF ${chalk.gray('- Code refactoring')}`, value: '[REF]' },
+    { name: `🎉 REL ${chalk.gray('- Release commit')}`, value: '[REL]' },
+    { name: `🗑️ REM ${chalk.gray('- Removing unnecessary files')}`, value: '[REM]' },
+    { name: `✏️ REN ${chalk.gray('- Renaming files/variables/models/etc.')}`, value: '[REN]' },
+    { name: `🔙 REV ${chalk.gray('- Revert of an existing commit')}`, value: '[REV]' },
+    { name: `🧳 SUB ${chalk.gray('- Submodule adding/updating')}`, value: '[SUB]' },
+    { name: `#️⃣ VER ${chalk.gray('- Versioning')}`, value: '[VER]' },
+];
+
+const commitTypes = [
+    { name: '🔧 Workflow', value: 'workflow' },
+    { name: '📋 Module', value: 'module' },
+    { name: '👤 Wizard', value: 'wizard' },
+    { name: '⚙️  Symphony Process', value: 'symphony' },
+];
+
+async function commit() {
+    const ADDONS_PATH = resolveAddonsPath(process.env.ADDONS_PATH);
+
+    const unstagedChanges = await execGit(['diff', '--name-only'], ADDONS_PATH);
+    const stagedChanges = await execGit(['diff', '--cached', '--name-only'], ADDONS_PATH);
+
+    let stageFilesAnswers = [];
+
+    if (!stagedChanges.trim()) {
+        console.log(chalk.yellow('No staged changes found.'));
+        console.log(chalk.yellow('Unstaged changes:'));
+        console.log(unstagedChanges);
+
+        stageFilesAnswers = await inquirer.prompt([
+            {
+                message: 'Select unstaged files to stage for commit:',
+                type: 'checkbox',
+                name: 'filesToStage',
+                choices: unstagedChanges
+                    .trim()
+                    .split('\n')
+                    .map((file) => file),
+            },
+        ]);
+    } else {
+        console.log(chalk.green('Staged changes:'));
+        console.log(stagedChanges);
+    }
+
+    const answers = await inquirer.prompt([
+        {
+            type: 'search-list',
+            message: 'Select an operation:',
+            name: 'commitOperation',
+            choices: commitOperations,
+        },
+        {
+            type: 'search-list',
+            message: 'Select what has been changed:',
+            name: 'commitType',
+            choices: commitTypes,
+            when(answers) {
+                return answers.commitOperation !== '[DOC]';
+            },
+        },
+        {
+            type: 'input',
+            message(answers) {
+                return `Please enter the name of the ${answers.commitType}:`;
+            },
+            name: 'commitModule',
+            default: 'config_wf_',
+            when(answers) {
+                return answers.commitType === 'workflow' || answers.commitType === 'module';
+            },
+            filter(input) {
+                let value = input.trim();
+
+                if (!value.startsWith('[')) {
+                    value = `[${value}`;
+                }
+
+                if (!value.endsWith(']')) {
+                    value = `${value}]`;
+                }
+
+                return value;
+            },
+        },
+        {
+            type: 'input',
+            message: 'Please enter your message:',
+            name: 'commitMessage',
+            filter: (input) => input.trim(),
+            when(answers) {
+                return answers.commitOperation !== '[DOC]';
+            },
+        },
+    ]);
+
+    if (answers.commitOperation === '[DOC]') {
+        answers.commitModule = '[CHANGELOG]';
+        answers.commitMessage = 'Changelog';
+    }
+
+    if (answers.commitType === 'wizard') {
+        answers.commitModule = '[.cloudbuild/pb/B2WA/processes/all]';
+    }
+
+    if (answers.commitType === 'symphony') {
+        answers.commitModule = '[.cloudbuild/symphony/B2WA/processes/all]';
+    }
+
+    const commitMessage = `${answers.commitOperation}${answers.commitModule} ${answers.commitMessage}`;
+
+    const finalPrompt = await inquirer.prompt([
+        {
+            type: 'confirm',
+            message: `${chalk.red(commitMessage)}\nDo you want to proceed with this commit message?`,
+            name: 'confirmCommit',
+        },
+    ]);
+
+    if (finalPrompt.confirmCommit) {
+        if (stageFilesAnswers.filesToStage && stageFilesAnswers.filesToStage.length > 0) {
+            await execGit(['add', ...stageFilesAnswers.filesToStage], ADDONS_PATH);
+        }
+        await execGit(['commit', '-m', commitMessage], ADDONS_PATH);
+    }
+}
+
+export { commit };

package/src/commands/export.js

@@ -0,0 +1,7 @@
+import { exportPb } from './exportPb.js';
+
+function exportRip() {
+    console.log('Not implemented yet.');
+}
+
+export { exportPb, exportRip };

package/src/commands/exportPb.js

@@ -0,0 +1,156 @@
+import fs from 'fs/promises';
+import path from 'path';
+import fetch from 'node-fetch';
+import search from '@inquirer/search';
+import { getToken } from '../lib/auth.js';
+import { execGit } from '../lib/git.js';
+import { resolveAddonsPath } from '../lib/addons.js';
+
+async function getProcessList(token) {
+    const url = `${process.env.IMPORTEXPORT_URL}/object/process_builder?addLanguageParam=true`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({ page: 1, size: 999999, filters: [] }),
+    });
+    if (!response.ok) throw new Error(await response.text());
+    const json = await response.json();
+    return json.data;
+}
+
+async function initiateExport(guid, token) {
+    const url = `${process.env.IMPORTEXPORT_URL}/symphony/export`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify([{ object_guid: guid, object_type: 'process_builder' }]),
+    });
+    if (!response.ok) throw new Error(await response.text());
+}
+
+async function pollExportResult(guid, requestTime, token) {
+    const url = `${process.env.IMPORTEXPORT_URL}/export/info/processKey=ExportElement&subProcess=true&status=FAILED,COMPLETED&referenceId=process_builder`;
+    // Server createDate is offset -1hr from system time; subtract 1hr+5s buffer
+    const cutoff = requestTime - 3_605_000;
+
+    while (true) {
+        await new Promise((r) => setTimeout(r, 3000));
+
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({ page: 1, size: 7, sorters: [] }),
+        });
+        if (!response.ok) throw new Error(await response.text());
+
+        const { data } = await response.json();
+        const match = data.find(
+            (item) =>
+                item.customResponse?.guid === guid &&
+                new Date(item.createdDate).getTime() >= cutoff
+        );
+
+        if (!match) continue;
+        if (match.status === 'FAILED') throw new Error(`Export failed for guid ${guid}`);
+        return match.requestId;
+    }
+}
+
+async function downloadZip(requestId, token) {
+    const url = `${process.env.IMPORTEXPORT_URL}/export/${requestId}`;
+    const response = await fetch(url, {
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${token}`,
+        },
+    });
+    if (!response.ok) throw new Error(await response.text());
+    return Buffer.from(await response.arrayBuffer());
+}
+
+async function findExistingZip(baseDir, filename) {
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        } catch {
+            return null;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const found = await walk(full);
+                if (found) return found;
+            } else if (entry.name === filename) {
+                return full;
+            }
+        }
+        return null;
+    }
+    return walk(baseDir);
+}
+
+async function exportPb(opts) {
+    const token = await getToken();
+
+    const processes = await getProcessList(token);
+    const choices = processes.map((p) => ({
+        name: `${p.process_name} (${p.document_id})`,
+        value: { guid: p.guid, document_id: p.document_id },
+    }));
+
+    const selected = await search({
+        message: 'Select PB process to export:',
+        source: async (input) => {
+            if (!input) return choices;
+            const q = input.toLowerCase();
+            return choices.filter((c) => c.name.toLowerCase().includes(q));
+        },
+    });
+
+    const { guid, document_id } = selected;
+    const filename = `${document_id}.zip`;
+
+    console.log(`Initiating export for ${document_id}...`);
+    const requestTime = Date.now();
+    await initiateExport(guid, token);
+
+    console.log('Waiting for export to complete...');
+    const requestId = await pollExportResult(guid, requestTime, token);
+
+    console.log(`Downloading ${filename}...`);
+    const zipBuffer = await downloadZip(requestId, token);
+
+    const ADDONS_PATH = resolveAddonsPath(process.env.ADDONS_PATH);
+    const processesDir = path.join(ADDONS_PATH, '.cloudbuild', 'pb', 'B2WA', 'processes');
+
+    const existing = await findExistingZip(processesDir, filename);
+    let savePath;
+    if (existing) {
+        savePath = existing;
+        await fs.writeFile(savePath, zipBuffer);
+        console.log(`Updated existing file at ${savePath}`);
+    } else {
+        savePath = path.join(processesDir, 'all', filename);
+        await fs.mkdir(path.dirname(savePath), { recursive: true });
+        await fs.writeFile(savePath, zipBuffer);
+        console.log(`Created new file at ${savePath}`);
+    }
+
+    if (opts.commit !== false) {
+        await execGit(['add', savePath], ADDONS_PATH);
+        await execGit(['commit', '-m', '[IMP][.cloudbuild] Update wizard'], ADDONS_PATH);
+        console.log('Committed.');
+    }
+}
+
+export { exportPb };