@waron97/prbot 3.1.0 → 3.1.2

package/src/commands/exportLrp.js

@@ -5,10 +5,7 @@ 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';
-import { CONFIG_DIR } from '../config.js';
-
-const CACHE_FILE = path.join(CONFIG_DIR, 'lrp_processes_cache.json');
+import { log } from '../lib/logger.js';
 
 function getSymphonyBase() {
     const url = process.env.IMPORTEXPORT_URL;
@@ -17,13 +14,16 @@ function getSymphonyBase() {
     return `${parsed.protocol}//${parsed.host}`;
 }
 
-async function fetchProcessList(token, signal) {
+async function fetchProcesses(token, nameFilter, signal) {
     const base = getSymphonyBase();
-    const params = encodeURIComponent(JSON.stringify({ page: 1, size: 1000, sorters: [], filters: [] }));
+    const size = nameFilter ? 20 : 12;
+    const params = encodeURIComponent(
+        JSON.stringify({ page: 1, size, sorters: [], filters: [] })
+    );
     const otherfilters = encodeURIComponent(
         JSON.stringify([
             { field: 'id', type: '=', value: null },
-            { field: 'name', type: 'like', value: null },
+            { field: 'name', type: 'like', value: nameFilter ?? null },
             { field: 'tenantId', type: '=', value: null },
             { field: 'latestVersion', type: '=', value: true },
         ])
@@ -53,24 +53,6 @@ async function fetchProcessList(token, signal) {
     return items;
 }
 
-async function loadCache() {
-    try {
-        const data = await fs.readFile(CACHE_FILE, 'utf-8');
-        return JSON.parse(data);
-    } catch {
-        return null;
-    }
-}
-
-async function saveCache(items) {
-    try {
-        await fs.mkdir(path.dirname(CACHE_FILE), { recursive: true });
-        await fs.writeFile(CACHE_FILE, JSON.stringify(items));
-    } catch {
-        // non-fatal
-    }
-}
-
 async function fetchProcessDetail(id, token) {
     const base = getSymphonyBase();
     const url = `${base}/symphony/restInfo/ajax/tabulator/id/${id}?connector=SymphBpmnFileTabCon&modelroot=/management/development/edit`;
@@ -118,41 +100,30 @@ async function findExistingFile(baseDir, filename) {
 async function exportLrp(opts) {
     const token = await getToken();
 
-    // choices is a mutable ref so source() sees background updates live
-    let choices = [];
+    log('Fetching processes...');
+    const initialItems = await fetchProcesses(token, null);
+    const initialChoices = initialItems.map((p) => ({ name: p.name, value: p.id }));
 
-    const cached = await loadCache();
-
-    const bgController = new AbortController();
-
-    if (cached) {
-        choices = cached.map((p) => ({ name: p.name, value: p.id }));
-        console.log(`Loaded ${choices.length} processes from cache. Fetching fresh list in background (~1 min) — results update as you type.`);
-        fetchProcessList(token, bgController.signal)
-            .then(async (fresh) => {
-                await saveCache(fresh);
-                const updated = fresh.map((p) => ({ name: p.name, value: p.id }));
-                choices.length = 0;
-                choices.push(...updated);
-            })
-            .catch(() => {});
-    } else {
-        console.log('No cache found. Fetching process list (~1 min)...');
-        const items = await fetchProcessList(token);
-        await saveCache(items);
-        choices = items.map((p) => ({ name: p.name, value: p.id }));
-        console.log(`Loaded ${choices.length} processes.`);
-    }
+    let searchController = null;
 
     const selectedId = await search({
         message: 'Select LRP process to export:',
         source: async (input) => {
-            if (!input) return choices;
-            return choices.filter((c) => fuzzyMatch(c.name, input));
+            if (!input) return initialChoices;
+
+            if (searchController) searchController.abort();
+            searchController = new AbortController();
+
+            try {
+                const items = await fetchProcesses(token, input, searchController.signal);
+                return items.map((p) => ({ name: p.name, value: p.id }));
+            } catch {
+                return initialChoices;
+            }
         },
     });
 
-    console.log('Fetching process detail...');
+    log('Fetching process detail...');
     const jsText = await fetchProcessDetail(selectedId, token);
     const { xml, filename } = extractBpmnData(jsText);
     const bpmnFilename = `${filename.replace(/^B2WA_/, '')}.bpmn20.xml`;
@@ -165,21 +136,19 @@ async function exportLrp(opts) {
     if (existing) {
         savePath = existing;
         await fs.writeFile(savePath, xml, 'utf-8');
-        console.log(`Updated: ${savePath}`);
+        log(`Updated: ${savePath}`);
     } else {
         savePath = path.join(processesDir, 'all', bpmnFilename);
         await fs.mkdir(path.dirname(savePath), { recursive: true });
         await fs.writeFile(savePath, xml, 'utf-8');
-        console.log(`Created: ${savePath}`);
+        log(`Created: ${savePath}`);
     }
 
     if (opts.commit !== false) {
         await execGit(['add', savePath], ADDONS_PATH);
         await execGit(['commit', '-m', '[IMP][.cloudbuild] Update long running process'], ADDONS_PATH);
-        console.log('Committed.');
+        log('Committed.');
     }
-
-    bgController.abort();
 }
 
 export { exportLrp };

package/src/commands/exportPb.js

@@ -6,6 +6,7 @@ import { getToken } from '../lib/auth.js';
 import { execGit } from '../lib/git.js';
 import { resolveAddonsPath } from '../lib/addons.js';
 import { fuzzyMatch } from '../lib/fuzzy.js';
+import { log } from '../lib/logger.js';
 
 async function getProcessList(token) {
     const url = `${process.env.IMPORTEXPORT_URL}/object/process_builder?addLanguageParam=true`;
@@ -120,14 +121,14 @@ async function exportPb(opts) {
     const { guid, document_id } = selected;
     const filename = `${document_id}.zip`;
 
-    console.log(`Initiating export for ${document_id}...`);
+    log(`Initiating export for ${document_id}...`);
     const requestTime = Date.now();
     await initiateExport(guid, token);
 
-    console.log('Waiting for export to complete...');
+    log('Waiting for export to complete...');
     const requestId = await pollExportResult(guid, requestTime, token);
 
-    console.log(`Downloading ${filename}...`);
+    log(`Downloading ${filename}...`);
     const zipBuffer = await downloadZip(requestId, token);
 
     const ADDONS_PATH = resolveAddonsPath(process.env.ADDONS_PATH);
@@ -138,18 +139,18 @@ async function exportPb(opts) {
     if (existing) {
         savePath = existing;
         await fs.writeFile(savePath, zipBuffer);
-        console.log(`Updated existing file at ${savePath}`);
+        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}`);
+        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.');
+        log('Committed.');
     }
 }
 

package/src/commands/exportWorkflow.js

@@ -1,11 +1,19 @@
 import fs from 'fs/promises';
 import path from 'path';
 import search from '@inquirer/search';
-import { select } from '@inquirer/prompts';
+import { select, confirm } from '@inquirer/prompts';
 import { resolveAddonsPath } from '../lib/addons.js';
 import { fuzzyMatch } from '../lib/fuzzy.js';
+import { execGit } from '../lib/git.js';
+import { log, isSilent } from '../lib/logger.js';
 import { runPr } from './pr.js';
 import { verbot } from './ver.js';
+import {
+    readWorkflowMappings,
+    detectRenames,
+    computeMigrationVersion,
+    generatePreMigrateScript,
+} from '../lib/premigrate.js';
 
 async function getModuleChoices() {
     const ADDONS_PATH = resolveAddonsPath(process.env.ADDONS_PATH);
@@ -16,17 +24,46 @@ async function getModuleChoices() {
         .map((e) => ({ name: e.name, value: e.name }));
 }
 
+async function resolveManifestPath(module, ADDONS_PATH) {
+    for (const candidate of [
+        path.join(ADDONS_PATH, module, '__manifest__.py'),
+        path.join(ADDONS_PATH, 'config', module, '__manifest__.py'),
+    ]) {
+        try {
+            await fs.access(candidate);
+            return candidate;
+        } catch {
+            // try next
+        }
+    }
+    return null;
+}
+
 async function exportWorkflow(opts) {
-    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));
-        },
-    });
+    let module;
+    if (opts.module) {
+        module = opts.module;
+    } else {
+        const moduleChoices = await getModuleChoices();
+        module = await search({
+            message: 'Select module:',
+            source: async (input) => {
+                if (!input) return moduleChoices;
+                return moduleChoices.filter((c) => fuzzyMatch(c.name, input));
+            },
+        });
+    }
 
-    await runPr(module, opts);
+    const ADDONS_PATH = resolveAddonsPath(process.env.ADDONS_PATH);
+    const dataDir = path.join(ADDONS_PATH, 'config', module, 'data');
+
+    const oldMappings = await readWorkflowMappings(dataDir);
+
+    await runPr(module, { ...opts, commit: false });
+
+    const newMappings = await readWorkflowMappings(dataDir);
+    const renames = detectRenames(oldMappings, newMappings);
+    const hasRenames = renames.stateCodes.length > 0 || renames.phaseCodes.length > 0;
 
     let bumpLevel = opts.bump;
     if (!bumpLevel) {
@@ -41,6 +78,60 @@ async function exportWorkflow(opts) {
         });
     }
 
+    let preMigratePath = null;
+
+    if (hasRenames) {
+        if (renames.stateCodes.length > 0) {
+            log(`Renamed state_codes (${renames.stateCodes.length}): ${renames.stateCodes.join(', ')}`);
+        }
+        if (renames.phaseCodes.length > 0) {
+            log(`Renamed phase_codes (${renames.phaseCodes.length}): ${renames.phaseCodes.join(', ')}`);
+        }
+
+        let shouldGenerate = opts.autoPremigrate;
+        if (!shouldGenerate && !isSilent()) {
+            shouldGenerate = await confirm({
+                message: `Detected ${renames.stateCodes.length} renamed state_code(s) and ${renames.phaseCodes.length} renamed phase_code(s). Generate pre-migrate script?`,
+                default: true,
+            });
+        }
+
+        if (shouldGenerate) {
+            const manifestPath = await resolveManifestPath(module, ADDONS_PATH);
+            if (!manifestPath) {
+                log(`Warning: __manifest__.py not found for ${module}, skipping pre-migrate generation`);
+            } else {
+                const version = await computeMigrationVersion(manifestPath, bumpLevel);
+                const migrationDir = path.join(ADDONS_PATH, 'config', module, 'migrations', version);
+                preMigratePath = path.join(migrationDir, 'pre-migrate.py');
+                await fs.mkdir(migrationDir, { recursive: true });
+                await fs.writeFile(preMigratePath, generatePreMigrateScript(renames.stateCodes, renames.phaseCodes));
+                log(`Wrote pre-migrate: ${preMigratePath}`);
+            }
+        }
+    }
+
+    if (opts.commit === false) {
+        if (bumpLevel && bumpLevel !== 'none') {
+            await verbot(module, bumpLevel, { ...opts, commit: false });
+        }
+        return;
+    }
+
+    const filesToAdd = [
+        path.join(dataDir, 'workflow_missing_relations.xml'),
+        path.join(dataDir, 'workflow_configuration.xml'),
+    ];
+    if (preMigratePath) filesToAdd.push(preMigratePath);
+
+    for (const filePath of filesToAdd) {
+        await execGit(['add', filePath], ADDONS_PATH);
+    }
+
+    const commitMessage = `[IMP][${module}] Update workflow`;
+    await execGit(['commit', '-m', commitMessage], ADDONS_PATH);
+    log(`Committed with message: ${commitMessage}`);
+
     if (bumpLevel && bumpLevel !== 'none') {
         await verbot(module, bumpLevel, opts);
     }

package/src/commands/pr.js

@@ -1,9 +1,10 @@
-import { execFile } from 'child_process';
 import fs from 'fs/promises';
 import path from 'path';
 import fetch from 'node-fetch';
 import { resolveAddonsPath } from '../lib/addons.js';
 import { getToken } from '../lib/auth.js';
+import { execGit } from '../lib/git.js';
+import { log } from '../lib/logger.js';
 
 async function getFiles(module_name, token) {
     const url = `${process.env.RIP_URL}/ir.model/xml_prbot`;
@@ -66,7 +67,7 @@ async function runPr(module_name, opts = {}) {
 
         await fs.mkdir(path.dirname(destPath), { recursive: true });
         await fs.writeFile(destPath, content);
-        console.log(`Processed: ${file.name} -> ${destPath}`);
+        log(`Processed: ${file.name} -> ${destPath}`);
     }
 
     if (opts.commit === false) return;
@@ -78,23 +79,13 @@ async function runPr(module_name, opts = {}) {
     ];
 
     for (const filePath of filesToAdd) {
-        await new Promise((resolve, reject) => {
-            execFile('git', ['add', filePath], { cwd: ADDONS_PATH }, (error) => {
-                if (error) reject(error);
-                else resolve();
-            });
-        });
+        await execGit(['add', filePath], ADDONS_PATH);
     }
 
     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}`);
+    await execGit(['commit', '-m', commitMessage], ADDONS_PATH);
+
+    log(`Committed with message: ${commitMessage}`);
 }
 
 async function main(module_name) {

package/src/commands/routine.js

@@ -0,0 +1,99 @@
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import { parse } from 'yaml';
+import { select } from '@inquirer/prompts';
+import { CONFIG_DIR } from '../config.js';
+import { setSilent } from '../lib/logger.js';
+import { exportWorkflow } from './exportWorkflow.js';
+import { exportPb } from './exportPb.js';
+import { exportImperex } from './exportImperex.js';
+import { exportEmailTemplates } from './exportEmailTemplates.js';
+import { exportLrp } from './exportLrp.js';
+
+const ROUTINES_FILE = path.join(CONFIG_DIR, 'routines.yaml');
+const WORKSPACE_FILE = 'agrippa.yaml';
+
+const COMMAND_MAP = {
+    'export workflow': exportWorkflow,
+    'export pb': exportPb,
+    'export imperex': exportImperex,
+    'export lrp': exportLrp,
+    'export email-templates': exportEmailTemplates,
+};
+
+function loadRoutines() {
+    const routines = [];
+
+    if (existsSync(ROUTINES_FILE)) {
+        const config = parse(readFileSync(ROUTINES_FILE, 'utf-8'));
+        if (config?.routines) routines.push(...config.routines);
+    }
+
+    if (existsSync(WORKSPACE_FILE)) {
+        const config = parse(readFileSync(WORKSPACE_FILE, 'utf-8'));
+        if (config?.routines) routines.push(...config.routines);
+    }
+
+    return routines;
+}
+
+function stepOpts(step) {
+    const opts = { bump: step.bump ?? 'none' };
+    if (step.module) opts.module = step.module;
+    if (step.workflow) opts.workflow = step.workflow;
+    if (step.exclude) opts.exclude = step.exclude;
+    if (step.no_commit) opts.commit = false;
+    if (step.auto_premigrate) opts.autoPremigrate = true;
+    return opts;
+}
+
+function isNothingToCommit(err) {
+    return err?.gitOutput?.includes('nothing to commit');
+}
+
+async function runRoutine(routine) {
+    console.log(`Running Routine: ${routine.name}`);
+
+    for (const step of routine.steps) {
+        const label = `[${step.name}]`;
+        const fn = COMMAND_MAP[step.command];
+        if (!fn) {
+            console.log(`${label} Unknown command: ${step.command}`);
+            continue;
+        }
+
+        console.log(`${label} Job started`);
+        setSilent(true);
+
+        try {
+            await fn(stepOpts(step));
+            console.log(`${label} Done (committed)`);
+        } catch (err) {
+            if (isNothingToCommit(err)) {
+                console.log(`${label} Done (nothing to commit)`);
+            } else {
+                console.log(`${label} Failed: ${err.message}`);
+            }
+        } finally {
+            setSilent(false);
+        }
+    }
+}
+
+async function routine() {
+    const routines = loadRoutines();
+
+    if (!routines.length) {
+        console.log('No routines defined. Create ~/.config/prbot/routines.yaml or add routines: to agrippa.yaml.');
+        return;
+    }
+
+    const selected = await select({
+        message: 'Select routine:',
+        choices: routines.map((r) => ({ name: r.name, value: r })),
+    });
+
+    await runRoutine(selected);
+}
+
+export { routine };

package/src/commands/ver.js

@@ -1,7 +1,8 @@
-import { execFile } from 'child_process';
 import fs from 'fs/promises';
 import path from 'path';
 import { resolveAddonsPath } from '../lib/addons.js';
+import { execGit } from '../lib/git.js';
+import { log } from '../lib/logger.js';
 
 async function verbot(module_name, level, opts = {}) {
     if (!['major', 'minor', 'patch'].includes(level)) {
@@ -50,26 +51,16 @@ async function verbot(module_name, level, opts = {}) {
     );
 
     await fs.writeFile(manifestPath, newContent);
-    console.log(`Updated version: ${currentVersion} -> ${newVersion}`);
+    log(`Updated version: ${currentVersion} -> ${newVersion}`);
 
     if (opts.commit === false) return;
 
-    await new Promise((resolve, reject) => {
-        execFile('git', ['add', manifestPath], { cwd: ADDONS_PATH }, (error) => {
-            if (error) reject(error);
-            else resolve();
-        });
-    });
+    await execGit(['add', manifestPath], ADDONS_PATH);
 
     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();
-        });
-    });
+    await execGit(['commit', '-m', commitMessage], ADDONS_PATH);
 
-    console.log(`Committed with message: ${commitMessage}`);
+    log(`Committed with message: ${commitMessage}`);
 }
 
 export { verbot };

package/src/index.js

@@ -6,11 +6,13 @@ import { autopr } from './commands/autopr.js';
 import { changelog } from './commands/changelog.js';
 import { commit } from './commands/commit.js';
 import { exportPb, exportRip, exportImperex, exportEmailTemplates, exportWorkflow, exportLrp } from './commands/export.js';
+import { routine } from './commands/routine.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';
 import { checkForUpdate, currentVersion } from './lib/updateCheck.js';
+import { setSilent } from './lib/logger.js';
 
 configDotenv({ path: CONFIG_FILE, quiet: true });
 
@@ -75,6 +77,7 @@ program
     .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)')
+    .option('--amend', 'Amend existing PR on current branch with new trident/jira refs')
     .action((opts) => {
         autopr(opts).catch((err) => {
             throw err;
@@ -93,9 +96,13 @@ exportCmd
     .command('workflow')
     .option('--no-commit')
     .option('-b, --bump <level>', 'Version bump level (patch, minor, major)')
+    .option('-m, --module <id>', 'Module/workflow ID to export (skips interactive selection)')
+    .option('-s, --silent', 'Suppress all output and swallow errors')
+    .option('--auto-premigrate', 'Auto-generate pre-migrate script when XML ID renames are detected (no prompt)')
     .action((opts) => {
+        if (opts.silent) setSilent(true);
         exportWorkflow(opts).catch((err) => {
-            throw err;
+            if (!opts.silent) throw err;
         });
     });
 
@@ -104,42 +111,58 @@ exportCmd.command('rip').action(() => exportRip());
 exportCmd
     .command('pb')
     .option('--no-commit')
+    .option('-s, --silent', 'Suppress all output and swallow errors')
     .action((opts) => {
+        if (opts.silent) setSilent(true);
         exportPb(opts).catch((err) => {
-            throw err;
+            if (!opts.silent) throw err;
         });
     });
 
 exportCmd
     .command('imperex')
     .option('--no-commit')
+    .option('-s, --silent', 'Suppress all output and swallow errors')
     .action((opts) => {
+        if (opts.silent) setSilent(true);
         exportImperex(opts).catch((err) => {
-            throw err;
+            if (!opts.silent) throw err;
         });
     });
 
 exportCmd
     .command('lrp')
     .option('--no-commit')
+    .option('-s, --silent', 'Suppress all output and swallow errors')
     .action((opts) => {
+        if (opts.silent) setSilent(true);
         exportLrp(opts).catch((err) => {
-            throw err;
+            if (!opts.silent) throw err;
         });
     });
 
 exportCmd
     .command('email-templates')
     .option('--no-commit')
+    .option('-b, --bump <level>', 'Version bump level (patch, minor, major)')
     .option('-e, --exclude <value...>', 'exclude templates matching id, name, or template_code')
     .option('-m, --module <name>', 'module directory name (skip prompt)')
     .option('-w, --workflow <value>', 'workflow name or id (skip prompt)')
+    .option('-s, --silent', 'Suppress all output and swallow errors')
+    .option('--auto-premigrate', 'Auto-generate pre-migrate script when XML ID renames are detected (no prompt)')
     .action((opts) => {
+        if (opts.silent) setSilent(true);
         exportEmailTemplates(opts).catch((err) => {
-            throw err;
+            if (!opts.silent) throw err;
         });
     });
 
+program.command('routine').action(() => {
+    routine().catch((err) => {
+        throw err;
+    });
+});
+
 program.command('update').action(() => {
     console.log('Updating prbot...');
     execFile('npm', ['i', '-g', '@waron97/prbot'], (error, stdout, stderr) => {

package/src/lib/git.js

@@ -3,8 +3,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);
+            if (error) {
+                error.gitOutput = stdout;
+                reject(error);
+            } else {
+                resolve(stdout);
+            }
         });
     });
 }

package/src/lib/logger.js

@@ -0,0 +1,15 @@
+let silent = false;
+
+function setSilent(value) {
+    silent = value;
+}
+
+function isSilent() {
+    return silent;
+}
+
+function log(...args) {
+    if (!silent) console.log(...args);
+}
+
+export { setSilent, isSilent, log };