@waron97/prbot 2.4.0 → 2.6.0

package/README.md

@@ -118,7 +118,7 @@ Options:
 
 ### `prbot commit`
 
-Interactive commit builder. Prompts for operation type (`[IMP]`, `[FIX]`, etc.), what changed (workflow, module, wizard, symphony process), and a message. If nothing is staged, shows unstaged files and lets you select which to stage first. Previews the final commit message before confirming.
+Interactive commit builder. Prompts for operation type (`[IMP]`, `[FIX]`, etc.), and a message. The destinatin module will be automatically detected. If nothing is staged, shows unstaged files and lets you select which to stage first. Previews the final commit message before confirming.
 
 ```bash
 prbot commit

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@waron97/prbot",
-    "version": "2.4.0",
+    "version": "2.6.0",
     "description": "",
     "main": "index.js",
     "scripts": {

package/src/commands/commit.js

@@ -13,133 +13,182 @@ const commitOperations = [
     },
     { 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: `🛠️  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: `🗑️  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]' },
+    { 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' },
-];
+function getModuleFromFile(file) {
+    const parts = file.split('/');
 
-async function commit() {
-    const ADDONS_PATH = resolveAddonsPath(process.env.ADDONS_PATH);
+    if (parts[0] === 'config') {
+        return parts[1];
+    }
 
-    const unstagedChanges = await execGit(['diff', '--name-only'], ADDONS_PATH);
-    const stagedChanges = await execGit(['diff', '--cached', '--name-only'], ADDONS_PATH);
+    if (parts[0] === '.cloudbuild') {
+        const allIndex = parts.indexOf('all');
 
-    let stageFilesAnswers = [];
+        if (allIndex !== -1) {
+            return parts.slice(0, allIndex + 1).join('/');
+        }
+    }
+
+    return parts[0];
+}
 
-    if (!stagedChanges.trim()) {
+function validateSameModule(files) {
+    const modules = files.map(getModuleFromFile);
+    const currentModule = `[${modules[0]}]`;
+
+    const allSameModule = modules.every((module) => `[${module}]` === currentModule);
+
+    if (!allSameModule) {
+        console.log(chalk.red('Selected files are not of the same module'));
+        return null;
+    }
+
+    return currentModule;
+}
+
+async function getFilesToCommit(stagedChanges, unstagedChanges) {
+    if (stagedChanges.trim()) {
+        console.log(chalk.green('Staged changes:'));
+        console.log(stagedChanges);
+
+        return {
+            filesToCheck: stagedChanges.trim().split('\n'),
+            filesToStage: [],
+        };
+    }
+
+    const unstagedFiles = unstagedChanges.trim().split('\n');
+
+    while (true) {
         console.log(chalk.yellow('No staged changes found.'));
         console.log(chalk.yellow('Unstaged changes:'));
         console.log(unstagedChanges);
 
-        stageFilesAnswers = await inquirer.prompt([
+        const answers = await inquirer.prompt([
             {
                 message: 'Select unstaged files to stage for commit:',
                 type: 'checkbox',
                 name: 'filesToStage',
-                choices: unstagedChanges
-                    .trim()
-                    .split('\n')
-                    .map((file) => file),
+                choices: unstagedFiles,
             },
         ]);
-    } else {
-        console.log(chalk.green('Staged changes:'));
-        console.log(stagedChanges);
+
+        const currentModule = validateSameModule(answers.filesToStage);
+
+        if (currentModule) {
+            return {
+                filesToCheck: answers.filesToStage,
+                filesToStage: answers.filesToStage,
+                currentModule,
+            };
+        }
     }
+}
 
-    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}:`;
+async function commit() {
+    const ADDONS_PATH = resolveAddonsPath(process.env.ADDONS_PATH);
+
+    while (true) {
+        const unstagedChanges = await execGit(['diff', '--name-only'], ADDONS_PATH);
+        const stagedChanges = await execGit(['diff', '--cached', '--name-only'], ADDONS_PATH);
+
+        if (!unstagedChanges.trim() && !stagedChanges.trim()) {
+            console.log(chalk.red('No changes found to commit.'));
+            return;
+        }
+
+        const {
+            filesToCheck,
+            filesToStage,
+            currentModule: selectedModule,
+        } = await getFilesToCommit(stagedChanges, unstagedChanges);
+
+        if (filesToCheck.length === 0) {
+            console.log(chalk.red('No files selected.'));
+            return;
+        }
+
+        let currentModule = selectedModule || validateSameModule(filesToCheck);
+
+        if (!currentModule) {
+            return;
+        }
+
+        const answers = await inquirer.prompt([
+            {
+                type: 'search-list',
+                message: 'Select an operation:',
+                name: 'commitOperation',
+                choices: commitOperations,
             },
-            name: 'commitModule',
-            default: 'config_wf_',
-            when(answers) {
-                return answers.commitType === 'workflow' || answers.commitType === 'module';
+            {
+                type: 'input',
+                message: 'Please enter your message:',
+                name: 'commitMessage',
+                filter: (input) => input.trim(),
+                when(answers) {
+                    return answers.commitOperation !== '[DOC]';
+                },
             },
-            filter(input) {
-                let value = input.trim();
+        ]);
 
-                if (!value.startsWith('[')) {
-                    value = `[${value}`;
-                }
+        if (answers.commitOperation === '[DOC]') {
+            currentModule = '[CHANGELOG]';
+            answers.commitMessage = 'Changelog';
+        }
 
-                if (!value.endsWith(']')) {
-                    value = `${value}]`;
-                }
+        const commitMessage = `${answers.commitOperation}${currentModule} ${answers.commitMessage}`;
 
-                return value;
-            },
-        },
-        {
-            type: 'input',
-            message: 'Please enter your message:',
-            name: 'commitMessage',
-            filter: (input) => input.trim(),
-            when(answers) {
-                return answers.commitOperation !== '[DOC]';
+        const finalPrompt = await inquirer.prompt([
+            {
+                type: 'confirm',
+                message: `${chalk.red(commitMessage)}\nDo you want to proceed with this commit message?`,
+                name: 'confirmCommit',
             },
-        },
-    ]);
+        ]);
 
-    if (answers.commitOperation === '[DOC]') {
-        answers.commitModule = '[CHANGELOG]';
-        answers.commitMessage = 'Changelog';
-    }
+        if (!finalPrompt.confirmCommit) {
+            return;
+        }
 
-    if (answers.commitType === 'wizard') {
-        answers.commitModule = '[.cloudbuild/pb/B2WA/processes/all]';
-    }
+        if (filesToStage.length > 0) {
+            await execGit(['add', ...filesToStage], ADDONS_PATH);
+        }
 
-    if (answers.commitType === 'symphony') {
-        answers.commitModule = '[.cloudbuild/symphony/B2WA/processes/all]';
-    }
+        await execGit(['commit', '-m', commitMessage], ADDONS_PATH);
+        console.log(chalk.green('Commit created successfully!'));
 
-    const commitMessage = `${answers.commitOperation}${answers.commitModule} ${answers.commitMessage}`;
+        const remainingUnstaged = await execGit(['diff', '--name-only'], ADDONS_PATH);
+        const remainingStaged = await execGit(['diff', '--cached', '--name-only'], ADDONS_PATH);
 
-    const finalPrompt = await inquirer.prompt([
-        {
-            type: 'confirm',
-            message: `${chalk.red(commitMessage)}\nDo you want to proceed with this commit message?`,
-            name: 'confirmCommit',
-        },
-    ]);
+        if (!remainingUnstaged.trim() && !remainingStaged.trim()) {
+            console.log(chalk.green('No more changes to commit.'));
+            break;
+        }
 
-    if (finalPrompt.confirmCommit) {
-        if (stageFilesAnswers.filesToStage && stageFilesAnswers.filesToStage.length > 0) {
-            await execGit(['add', ...stageFilesAnswers.filesToStage], ADDONS_PATH);
+        const { continueCommit } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'continueCommit',
+                message: 'Do you want to create another commit?',
+                default: true,
+            },
+        ]);
+
+        if (!continueCommit) {
+            break;
         }
-        await execGit(['commit', '-m', commitMessage], ADDONS_PATH);
     }
 }
 

package/src/commands/export.js

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

package/src/commands/exportEmailTemplates.js

@@ -0,0 +1,142 @@
+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';
+import { fuzzyMatch } from '../lib/fuzzy.js';
+
+async function getWorkflows(token) {
+    const url = `${process.env.RIP_URL}/symple.workflow/*`;
+    const response = await fetch(url, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!response.ok) throw new Error(await response.text());
+    return await response.json();
+}
+
+async function getEmailTemplates(workflowId, token) {
+    const url = `${process.env.RIP_URL}/symple.workflow/get_email_templates`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
+        body: JSON.stringify({ workflow_id: workflowId }),
+    });
+    if (!response.ok) throw new Error(await response.text());
+    return await response.json();
+}
+
+const VOID_ELEMENTS = /^(area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)$/i;
+
+function sanitizeBodyHtml(html) {
+    // Convert bare void-element tags to self-closing so the XML stays valid.
+    // Also replace   which is not a predefined XML entity.
+    return html
+        .replace(/ /g, ' ')
+        .replace(/<([a-zA-Z]+)(\s[^>]*[^/]|[^/>]*)>/g, (match, tag, attrs) => {
+            if (!VOID_ELEMENTS.test(tag)) return match;
+            return `<${tag}${attrs ?? ''}/>`;
+        });
+}
+
+function toXmlId(name) {
+    return name.replace(/[^a-zA-Z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+}
+
+function escapeXml(str) {
+    return String(str ?? '')
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+
+function generateXml(templates) {
+    const records = templates
+        .map((t) => {
+            const id = toXmlId(t.name);
+            const modelRef = Object.values(t.model_id)[0];
+            return `        <record id="${id}" model="mail.template">
+            <field name="name">${escapeXml(t.name)}</field>
+            <field name="model_id" ref="${modelRef}"/>
+            <field name="template_code">${escapeXml(t.template_code)}</field>
+            <field name="subject">${escapeXml(t.subject)}</field>
+            <field name="email_from">${escapeXml(t.email_from)}</field>
+            <field name="email_to">${escapeXml(t.email_to)}</field>
+            <field name="body_html" type="html">
+                ${sanitizeBodyHtml(t.body_html)}
+            </field>
+        </record>`;
+        })
+        .join('\n');
+
+    return `<?xml version="1.0" encoding="utf-8"?>
+<odoo>
+    <data noupdate="1">
+${records}
+    </data>
+</odoo>
+`;
+}
+
+async function getModuleChoices() {
+    const ADDONS_PATH = resolveAddonsPath(process.env.ADDONS_PATH);
+    const configDir = path.join(ADDONS_PATH, 'config');
+    const entries = await fs.readdir(configDir, { withFileTypes: true });
+    return entries
+        .filter((e) => e.isDirectory())
+        .map((e) => ({ name: e.name, value: e.name }));
+}
+
+async function exportEmailTemplates(opts) {
+    const token = await getToken();
+
+    const moduleChoices = await getModuleChoices();
+    const module = await search({
+        message: 'Select module:',
+        source: async (input) => {
+            if (!input) return moduleChoices;
+            return moduleChoices.filter((c) => fuzzyMatch(c.name, input));
+        },
+    });
+
+    console.log('Fetching workflows...');
+    const workflows = await getWorkflows(token);
+    const choices = workflows.map((w) => ({ name: w.name, value: w.id }));
+
+    const workflowId = await search({
+        message: 'Select workflow:',
+        source: async (input) => {
+            if (!input) return choices;
+            return choices.filter((c) => fuzzyMatch(c.name, input));
+        },
+    });
+
+    console.log(`Fetching email templates for workflow ${workflowId}...`);
+    const templates = await getEmailTemplates(workflowId, token);
+
+    if (!templates.length) {
+        console.log('No email templates found for this workflow.');
+        return;
+    }
+
+    const ADDONS_PATH = resolveAddonsPath(process.env.ADDONS_PATH);
+    const dataDir = path.join(ADDONS_PATH, 'config', module, 'data');
+    await fs.mkdir(dataDir, { recursive: true });
+
+    const outPath = path.join(dataDir, 'mail_templates.xml');
+    await fs.writeFile(outPath, generateXml(templates), 'utf-8');
+    console.log(`Written: ${outPath}`);
+
+    if (opts.commit !== false) {
+        await execGit(['add', outPath], ADDONS_PATH);
+        await execGit(
+            ['commit', '-m', `[IMP][${module}] Export email templates`],
+            ADDONS_PATH,
+        );
+        console.log('Committed.');
+    }
+}
+
+export { exportEmailTemplates };

package/src/index.js

@@ -8,34 +8,51 @@ import omelette from 'omelette';
 import { autopr } from './commands/autopr.js';
 import { changelog } from './commands/changelog.js';
 import { commit } from './commands/commit.js';
-import { exportPb, exportRip, exportImperex } from './commands/export.js';
+import { exportPb, exportRip, exportImperex, exportEmailTemplates } from './commands/export.js';
 import { init } from './commands/init.js';
 import { main as prMain } from './commands/pr.js';
 import { verbot } from './commands/ver.js';
 import { CONFIG_FILE } from './config.js';
 
-const completion = omelette('prbot <command> <module>');
-completion.on('command', ({ reply }) => {
-    reply(['pr', 'ver', 'init', 'changelog', 'autopr', 'commit']);
-});
+const EXPORT_SUBCOMMANDS = ['workflow', 'email-templates', 'pb', 'imperex', 'rip'];
 
-completion.on('module', ({ before, reply }) => {
-    if (['init', 'changelog', 'autopr'].includes(before)) {
-        reply([]);
-        return;
-    }
+function replyModules(reply) {
     try {
         const raw = readFileSync(CONFIG_FILE, 'utf-8');
         const match = raw.match(/^ADDONS_PATH=(.+)$/m);
-        if (!match) {
-            reply([]);
-            return;
-        }
+        if (!match) { reply([]); return; }
         const addonsPath = match[1].trim().replace(/^~/, process.env.HOME || '');
         reply(readdirSync(path.join(addonsPath, 'config')));
     } catch {
         reply([]);
     }
+}
+
+const completion = omelette('prbot <command> <subOrModule> <module>');
+completion.on('command', ({ reply }) => {
+    reply(['pr', 'ver', 'init', 'changelog', 'autopr', 'commit', 'export']);
+});
+
+// 2nd token: export subcommands or module (for non-export commands)
+completion.on('subOrModule', ({ before, reply }) => {
+    if (before === 'export') {
+        reply(EXPORT_SUBCOMMANDS);
+        return;
+    }
+    if (['init', 'changelog', 'autopr'].includes(before)) {
+        reply([]);
+        return;
+    }
+    replyModules(reply);
+});
+
+// 3rd token: module (only relevant for export subcommands that take one)
+completion.on('module', ({ before, reply }) => {
+    if (['workflow'].includes(before)) {
+        replyModules(reply);
+    } else {
+        reply([]);
+    }
 });
 
 completion.init();
@@ -147,6 +164,15 @@ exportCmd
         });
     });
 
+exportCmd
+    .command('email-templates')
+    .option('--no-commit')
+    .action((opts) => {
+        exportEmailTemplates(opts).catch((err) => {
+            throw err;
+        });
+    });
+
 program.command('update').action(() => {
     console.log('Updating prbot...');
     execFile('npm', ['i', '-g', '@waron97/prbot'], (error, stdout, stderr) => {