@waron97/prbot 3.2.0 → 3.3.0

package/src/agrippa/commands/diff.js

@@ -47,19 +47,30 @@ async function diff(targetArg) {
     const token = await getToken();
 
     let diffCount = 0;
+    const chunks = [];
 
     if (codeEntries.length) {
         const remoteCodeMap = await fetchRemoteCode(token, process.env.RIP_URL, codeEntries);
-        diffCount += diffCodeEntries(codeEntries, remoteCodeMap);
+        const { diffCount: c, chunks: cs } = diffCodeEntries(codeEntries, remoteCodeMap);
+        diffCount += c;
+        chunks.push(...cs);
     }
 
     for (const entry of pbEntries) {
-        if (await diffPbEntry(token, entry)) diffCount++;
+        const { hasDiff, chunk } = await diffPbEntry(token, entry);
+        if (hasDiff) {
+            diffCount++;
+            chunks.push(chunk);
+        }
     }
 
     if (diffCount === 0) {
         console.log('No differences found — all tracked files match the remote.');
     } else {
+        const combined = Buffer.concat(chunks);
+        const pager = process.env.PAGER || 'less';
+        const pagerArgs = pager === 'less' ? ['-R', '-F'] : [];
+        spawnSync(pager, pagerArgs, { input: combined, stdio: ['pipe', 'inherit', 'inherit'] });
         console.log(`\n${diffCount} file(s) differ from remote.`);
     }
 }
@@ -68,6 +79,7 @@ async function diff(targetArg) {
 // hand both sides to `git diff --no-index`.
 function diffCodeEntries(entries, remoteCodeMap) {
     let diffCount = 0;
+    const chunks = [];
     const tmpFiles = [];
     try {
         for (const entry of entries) {
@@ -86,17 +98,17 @@ function diffCodeEntries(entries, remoteCodeMap) {
             writeFileSync(tmpPath, (remoteCode ?? '').trim() + '\n', 'utf-8');
             tmpFiles.push(tmpPath);
 
-            console.log(`\n=== ${entry.path}  [${entry.name}] ===`);
-
             const result = spawnSync(
                 'git',
                 ['diff', '--no-index', '--color=always', tmpPath, entry.path],
-                { stdio: ['ignore', 'inherit', 'inherit'] }
+                { stdio: ['ignore', 'pipe', 'pipe'] }
             );
             // exit code 1 means differences found (normal), 0 means identical, >1 means error
             if (result.status !== null && result.status > 1) {
                 console.error(`git diff failed for ${entry.path}`);
             }
+            const header = Buffer.from(`\n=== ${entry.path}  [${entry.name}] ===\n`);
+            chunks.push(Buffer.concat([header, result.stdout ?? Buffer.alloc(0)]));
             diffCount++;
         }
     } finally {
@@ -108,7 +120,7 @@ function diffCodeEntries(entries, remoteCodeMap) {
             }
         }
     }
-    return diffCount;
+    return { diffCount, chunks };
 }
 
 // Process-builder wizard: decompose the upstream payload into a throwaway
@@ -136,18 +148,19 @@ async function diffPbEntry(token, entry) {
         // and never matches the raw upstream xml byte-for-byte even when nothing
         // structural changed, so it'd otherwise look like a permanent false diff.
         if (localChecksum(projectReader(upstreamDir)) === localChecksum(projectReader(localDir)))
-            return false;
+            return { hasDiff: false };
 
-        console.log(`\n=== ${entry.path}  [${entry.name}] (process-builder) ===`);
         const result = spawnSync(
             'git',
             ['diff', '--no-index', '--color=always', 'upstream', 'local'],
-            { cwd: tmpRoot, stdio: ['ignore', 'inherit', 'inherit'] }
+            { cwd: tmpRoot, stdio: ['ignore', 'pipe', 'pipe'] }
         );
         if (result.status !== null && result.status > 1) {
             console.error(`git diff failed for ${entry.path}`);
         }
-        return true;
+        const header = Buffer.from(`\n=== ${entry.path}  [${entry.name}] (process-builder) ===\n`);
+        const chunk = Buffer.concat([header, result.stdout ?? Buffer.alloc(0)]);
+        return { hasDiff: true, chunk };
     } finally {
         rmSync(tmpRoot, { recursive: true, force: true });
     }

package/src/agrippa/commands/initPhase.js

@@ -100,27 +100,26 @@ async function initPhase() {
         return;
     }
 
-    const phase = await search({
-        message: 'Select a phase:',
-        source: (input) => {
-            const filtered = input ? phases.filter((p) => fuzzyMatch(p.name, input)) : phases;
-            return filtered.map((p) => ({ name: p.name, value: p }));
+    const { selectedPhases } = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'selectedPhases',
+            message: 'Select phases to initialize:',
+            choices: phases.map((p) => ({ name: p.name, value: p })),
+            loop: false,
         },
-    });
+    ]);
 
-    // Resolve result objects — API may return IDs or full objects
-    let results = phase.allowed_phase_result_ids || [];
-    if (results.length > 0 && typeof results[0] === 'number') {
-        results = await getPhaseResults(token, ripUrl, results);
+    if (!selectedPhases.length) {
+        console.log('No phases selected. Aborted.');
+        return;
     }
 
-    const code = generateCode(results);
-
     const { confirm } = await inquirer.prompt([
         {
             type: 'confirm',
             name: 'confirm',
-            message: `Initialize phase "${phase.name}"? This will overwrite existing code.`,
+            message: `Initialize ${selectedPhases.length} phase(s)? This will overwrite existing code.`,
             default: true,
         },
     ]);
@@ -130,29 +129,40 @@ async function initPhase() {
         return;
     }
 
-    // Delete existing configurator records for this phase
-    const existing = await getPhaseConfigurators(token, ripUrl, phase.id);
-    for (const cfg of existing) {
-        await deleteConfigurator(token, ripUrl, cfg.id);
+    for (const phase of selectedPhases) {
+        // Resolve result objects — API may return IDs or full objects
+        let results = phase.allowed_phase_result_ids || [];
+        if (results.length > 0 && typeof results[0] === 'number') {
+            results = await getPhaseResults(token, ripUrl, results);
+        }
+
+        const code = generateCode(results);
+
+        // Delete existing configurator records for this phase
+        const existing = await getPhaseConfigurators(token, ripUrl, phase.id);
+        for (const cfg of existing) {
+            await deleteConfigurator(token, ripUrl, cfg.id);
+        }
+
+        // Update phase code + set_result_automatically
+        await initPhaseRemote(token, ripUrl, phase.id, code);
+
+        // Create new configurator records for each result
+        const vars = results.map((_, i) => `RES${i + 1}`);
+        for (let i = 0; i < results.length; i++) {
+            await createConfigurator(token, ripUrl, {
+                result_value: vars[i],
+                code_phase_id: phase.id,
+                triplet_phase_result_id: results[i].id,
+            });
+        }
+
+        console.log(`Initialized phase "${phase.name}".`);
+        if (results.length > 0) {
+            console.log(`  ${results.length} configurator(s) created: ${vars.join(', ')}`);
+        }
     }
 
-    // Update phase code + set_result_automatically
-    await initPhaseRemote(token, ripUrl, phase.id, code);
-
-    // Create new configurator records for each result
-    const vars = results.map((_, i) => `RES${i + 1}`);
-    for (let i = 0; i < results.length; i++) {
-        await createConfigurator(token, ripUrl, {
-            result_value: vars[i],
-            code_phase_id: phase.id,
-            triplet_phase_result_id: results[i].id,
-        });
-    }
-
-    console.log(`Initialized phase "${phase.name}".`);
-    if (results.length > 0) {
-        console.log(`  ${results.length} configurator(s) created: ${vars.join(', ')}`);
-    }
     console.log(
         `Run 'agrippa pull' in workspaces that track this workflow to fetch the updated code.`
     );

package/src/agrippa/commands/pb.js

@@ -25,7 +25,7 @@ import {
     connect,
     disconnect,
     eachNode,
-    lintGateways,
+    lintAll,
     listGraph,
     removeNode,
     setDefault,
@@ -37,32 +37,49 @@ import { projectReader } from '../lib/pbWorkspace.js';
 
 // ---------- project resolution ----------
 
-async function resolveProjectPath(opts) {
+// Resolves against both process-builder wizards and long-running processes —
+// `structure.yaml`-level editing is identical for both (see pbEdit.js). PBs
+// select by --pb/--name matched against document_id; LRPs have no document_id
+// so the same flag matches against name instead.
+async function resolveProjectEntry(opts) {
     const config = readConfig();
-    const entries = (config.workspace || []).filter((e) => e.object_type === 'process_builder');
+    const entries = (config.workspace || []).filter(
+        (e) => e.object_type === 'process_builder' || e.object_type === 'long_running_process'
+    );
     if (!entries.length) {
         throw new Error(
-            'No process-builder wizards in this workspace. Clone one with `agrippa clone --pb`.'
+            'No process-builder wizards or long-running processes in this workspace. ' +
+                'Clone one with `agrippa clone --pb` or `agrippa clone --lrp`.'
         );
     }
     const sel = opts.pb || opts.name;
     if (sel) {
-        const entry = entries.find((e) => e.document_id === sel);
-        if (!entry) throw new Error(`No cloned wizard with document_id "${sel}"`);
-        return entry.path;
+        const entry = entries.find((e) => e.document_id === sel || e.name === sel);
+        if (!entry) throw new Error(`No cloned project with document_id/name "${sel}"`);
+        return entry;
     }
-    if (entries.length === 1) return entries[0].path;
+    if (entries.length === 1) return entries[0];
     const entry = await search({
-        message: 'Select a cloned wizard:',
+        message: 'Select a cloned project:',
         source: (input) => {
             const list = input
                 ? entries.filter(
-                      (e) => fuzzyMatch(e.name, input) || fuzzyMatch(e.document_id, input)
+                      (e) =>
+                          fuzzyMatch(e.name, input) ||
+                          (e.document_id && fuzzyMatch(e.document_id, input))
                   )
                 : entries;
-            return list.map((e) => ({ name: `${e.name}  (${e.document_id})`, value: e }));
+            return list.map((e) => ({
+                name: e.document_id ? `${e.name}  (${e.document_id})` : e.name,
+                value: e,
+            }));
         },
     });
+    return entry;
+}
+
+async function resolveProjectPath(opts) {
+    const entry = await resolveProjectEntry(opts);
     return entry.path;
 }
 
@@ -125,9 +142,9 @@ async function pbFormat(opts) {
     console.log(
         `Formatted ${dir} (${nodes} node(s) laid out${missing ? `, ${missing} without layout` : ''}).`
     );
-    const issues = lintGateways(structure);
+    const issues = lintAll(structure);
     if (issues.length) {
-        console.warn('Gateway issues (exclusiveGateway default/condition rule):');
+        console.warn('Diagram issues:');
         for (const w of issues) console.warn(`  ! ${w}`);
     }
 }
@@ -135,14 +152,20 @@ async function pbFormat(opts) {
 async function pbAdd(opts) {
     if (!opts.type)
         throw new Error(
-            '--type is required (e.g. scriptTask, serviceTask, userTask, exclusiveGateway, subProcess, endEvent...)'
+            '--type is required (e.g. scriptTask, serviceTask, userTask, exclusiveGateway, subProcess, endEvent, callActivity...)'
         );
     if ((opts.from || opts.to) && !(opts.from && opts.to))
         throw new Error('--from and --to must be used together');
     if (opts.from && opts.parent)
         throw new Error('--parent is implied by --from/--to; pass only one');
 
-    const dir = await resolveProjectPath(opts);
+    const projectEntry = await resolveProjectEntry(opts);
+    if (opts.type === 'userTask' && projectEntry.object_type === 'long_running_process') {
+        throw new Error(
+            'userTask is not valid on a long-running process — LRPs have no pages (user tasks are a process-builder-only concept).'
+        );
+    }
+    const dir = projectEntry.path;
     const { structure, manifest } = loadProject(dir);
     const ctx = { existingScripts: listScriptFiles(dir), documentId: manifest.document_id };
 
@@ -276,4 +299,26 @@ async function pbPreview(opts) {
     console.log(`Wrote ${out} (${svg.length} bytes).`);
 }
 
-export { pbFormat, pbAdd, pbRemove, pbConnect, pbDisconnect, pbSetDefault, pbList, pbPreview };
+async function pbLint(opts) {
+    const dir = await resolveProjectPath(opts);
+    const { structure } = loadProject(dir);
+    const issues = lintAll(structure);
+    if (!issues.length) {
+        console.log('No issues.');
+    } else {
+        for (const w of issues) console.warn(`  ! ${w}`);
+        process.exitCode = 1;
+    }
+}
+
+export {
+    pbFormat,
+    pbAdd,
+    pbRemove,
+    pbConnect,
+    pbDisconnect,
+    pbSetDefault,
+    pbList,
+    pbPreview,
+    pbLint,
+};

package/src/agrippa/commands/pull.js

@@ -4,8 +4,9 @@ import { getToken } from '../../lib/auth.js';
 import { describeWorkflow, getPhasesByIds, getPhasesByWorkflow, listMfas } from '../lib/api.js';
 import { computeChecksum } from '../lib/checksum.js';
 import { loadEffectiveEnv, readConfig, writeConfig } from '../lib/config.js';
+import { fetchUpstream } from '../lib/lrpApi.js';
 import { getProcess } from '../lib/pbApi.js';
-import { localChecksum } from '../lib/pbProject.js';
+import { localChecksum, remoteChecksumPb } from '../lib/pbProject.js';
 import { projectReader } from '../lib/pbWorkspace.js';
 import {
     fileExists,
@@ -14,6 +15,7 @@ import {
     writeCodeFile,
     writeWorkflowDoc,
 } from '../lib/workspace.js';
+import { pullLrpEntry } from './pullLrp.js';
 import { pullPbEntry } from './pullPb.js';
 
 async function pull() {
@@ -50,9 +52,11 @@ async function pull() {
     const changedWorkflowIds = new Set();
 
     // ── pull existing tracked entries ─────────────────────────────────────────
-    // process_builder wizards are refreshed separately (different checksum model);
-    // see pullPbEntries below.
-    const pullable = config.workspace.filter((e) => e.object_type !== 'process_builder');
+    // process_builder wizards and LRPs are refreshed separately (different
+    // checksum/identity model); see pullPbEntries/pullLrpEntries below.
+    const pullable = config.workspace.filter(
+        (e) => e.object_type !== 'process_builder' && e.object_type !== 'long_running_process'
+    );
     if (pullable.length) {
         console.log('Fetching remote code...');
         const remoteCodeMap = await fetchRemoteCode(token, ripUrl, pullable);
@@ -63,13 +67,13 @@ async function pull() {
             const localCode = readCodeFile(entry.path);
 
             const remoteChecksum = computeChecksum(remoteCode ?? '');
-            const localChecksum = computeChecksum(localCode ?? '');
+            const localChecksumVal = computeChecksum(localCode ?? '');
             const pullChecksum = entry.checksum_at_pull;
 
             let status;
-            if (pullChecksum === localChecksum && pullChecksum === remoteChecksum) {
+            if (localChecksumVal === remoteChecksum) {
                 status = 'unchanged';
-            } else if (pullChecksum === localChecksum) {
+            } else if (pullChecksum === localChecksumVal) {
                 status = 'fast-forward';
             } else {
                 status = 'conflict';
@@ -111,16 +115,18 @@ async function pull() {
     // ── refresh tracked process-builder wizards ───────────────────────────────
     await pullPbEntries(token, config);
 
+    // ── refresh tracked long-running processes ────────────────────────────────
+    await pullLrpEntries(token, config);
+
     // ── discover new phases on tracked workflows ──────────────────────────────
     await discoverNewPhases(token, ripUrl, config, changedWorkflowIds);
 }
 
 // Refresh tracked wizards from upstream. Pull concern (inverted from push):
-// overwriting *local* edits. Status per entry from three states —
-// checksum_at_pull, current local (recomposed), upstream updated_date:
-//   unchanged    remote not advanced → nothing to bring down
-//   fast-forward remote advanced, local untouched since pull → safe overwrite
-//   conflict     remote advanced AND local diverged → overwrite loses local work
+// overwriting *local* edits. Status per entry:
+//   unchanged    local === remote semantically → nothing to do
+//   fast-forward remote changed, local untouched since pull → safe overwrite
+//   conflict     local diverged from checksum_at_pull → overwrite loses local work
 async function pullPbEntries(token, config) {
     const entries = config.workspace.filter((e) => e.object_type === 'process_builder');
     if (!entries.length) return;
@@ -140,12 +146,13 @@ async function pullPbEntries(token, config) {
             console.warn(`  ${entry.name}: could not fetch upstream, skipping`);
             continue;
         }
-        const local = localChecksum(projectReader(entry.path));
-        const localChanged = entry.checksum_at_pull !== local;
-        const remoteChanged = upstream.updated_date !== entry.updated_date;
+        const localSemantic = localChecksum(projectReader(entry.path));
+        const remoteSemantic = remoteChecksumPb(upstream);
+        const pullChecksum = entry.checksum_at_pull;
         let status;
-        if (!remoteChanged) status = 'unchanged';
-        else status = localChanged ? 'conflict' : 'fast-forward';
+        if (localSemantic === remoteSemantic) status = 'unchanged';
+        else if (pullChecksum === localSemantic) status = 'fast-forward';
+        else status = 'conflict';
         classified.push({ ...entry, upstream, status });
     }
 
@@ -179,6 +186,75 @@ async function pullPbEntries(token, config) {
     console.log(`\nPulled ${selected.length} wizard(s). Local backups in .backup/${backupTs}/`);
 }
 
+// Refresh tracked long-running processes from upstream. Same classification
+// concern as pullPbEntries, but entries are located by NAME (the tabulator id
+// changes on every save/version — never a stable key).
+async function pullLrpEntries(token, config) {
+    const entries = config.workspace.filter((e) => e.object_type === 'long_running_process');
+    if (!entries.length) return;
+    if (!process.env.IMPORTEXPORT_URL)
+        throw new Error(
+            'IMPORTEXPORT_URL is not configured. Run `prbot init` or set it in agrippa.yaml.'
+        );
+
+    console.log('Checking long-running processes...');
+    const classified = [];
+    for (const entry of entries) {
+        let upstream = null;
+        try {
+            upstream = await fetchUpstream(token, entry.name);
+        } catch {
+            upstream = null;
+        }
+        if (!upstream) {
+            console.warn(`  ${entry.name}: could not fetch upstream, skipping`);
+            continue;
+        }
+        const localSemantic = localChecksum(projectReader(entry.path));
+        const remoteSemantic = remoteChecksumPb(upstream.payload);
+        const pullChecksum = entry.checksum_at_pull;
+        let status;
+        if (localSemantic === remoteSemantic) status = 'unchanged';
+        else if (pullChecksum === localSemantic) status = 'fast-forward';
+        else status = 'conflict';
+        classified.push({ ...entry, upstream, status });
+    }
+
+    const changed = classified.filter((e) => e.status !== 'unchanged');
+    if (!changed.length) {
+        console.log('Long-running processes are up to date.');
+        return;
+    }
+
+    const selected = await selectEntries(changed, 'pull (overwrites local LRP files)');
+    if (!selected.length) {
+        console.log('No long-running processes selected.');
+        return;
+    }
+
+    const backupTs = new Date().toISOString().replace(/:/g, '-').replace('T', '_').slice(0, 19);
+    for (const entry of selected) {
+        const res = await pullLrpEntry(token, entry, '.backup', backupTs);
+        const idx = config.workspace.findIndex(
+            (e) => e.object_type === 'long_running_process' && e.name === entry.name
+        );
+        if (idx !== -1) {
+            config.workspace[idx].checksum_at_pull = res.newChecksum;
+            config.workspace[idx].tenant_id = res.newRow.tenantId;
+            config.workspace[idx].svg = res.newRow.bpmnFileSvg;
+            config.workspace[idx].description = res.newRow.description;
+            config.workspace[idx].version = res.newRow.version;
+            config.workspace[idx].status = res.newRow.status;
+        }
+        const note = res.diffs.length ? ` (WARNING: ${res.diffs.length} round-trip diff(s))` : '';
+        console.log(`  ${entry.name} → refreshed${note}`);
+    }
+    writeConfig(config);
+    console.log(
+        `\nPulled ${selected.length} long-running process(es). Local backups in .backup/${backupTs}/`
+    );
+}
+
 async function discoverNewPhases(token, ripUrl, config, changedWorkflowIds = new Set()) {
     // Build map of workflow_id → { workflow_name, basePath } from existing phase entries
     const workflows = new Map();

package/src/agrippa/commands/pullLrp.js

@@ -0,0 +1,55 @@
+import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { computeChecksum } from '../lib/checksum.js';
+import { fetchUpstream } from '../lib/lrpApi.js';
+import { comparePayload, decompose, recompose, stableStringify } from '../lib/pbProject.js';
+import { projectReader, writeProject } from '../lib/pbWorkspace.js';
+
+// Delete files under <baseDir>/scripts that are not in the fresh decompose
+// map, so a refresh that renames/removes scripts doesn't leave orphans behind
+// (LRPs have no pages/ dir — no user tasks).
+function pruneOrphans(baseDir, files) {
+    const dir = join(baseDir, 'scripts');
+    if (!existsSync(dir)) return;
+    for (const f of readdirSync(dir)) {
+        if (!(`scripts/${f}` in files)) rmSync(join(dir, f));
+    }
+}
+
+// Refresh one cloned LRP from upstream (the pull counterpart of
+// pushLrpEntry): back up the current local state, re-decompose the upstream
+// XML, overwrite local files (pruning orphans), and verify the round-trip.
+// `entry.upstream` is the {row, payload} fetched during classification;
+// re-resolved by name if absent (id may have changed since the last pull).
+async function pullLrpEntry(token, entry, backupDir, backupTs) {
+    const upstream = entry.upstream ?? (await fetchUpstream(token, entry.name));
+    if (!upstream) throw new Error(`could not fetch upstream LRP "${entry.name}"`);
+
+    // 1. Backup the current local state (recomposed payload) before overwriting.
+    try {
+        const localPayload = recompose(projectReader(entry.path));
+        const backupPath = join(backupDir, backupTs, entry.path, 'local.json');
+        mkdirSync(dirname(backupPath), { recursive: true });
+        writeFileSync(backupPath, JSON.stringify(localPayload, null, 2), 'utf-8');
+    } catch {
+        // local files unreadable (e.g. mid-edit) — nothing safe to back up, proceed.
+    }
+
+    // 2. Decompose upstream → fresh file map; prune orphans; write.
+    const { files } = decompose(upstream.payload);
+    pruneOrphans(entry.path, files);
+    writeProject(entry.path, files);
+
+    // 3. Verify the freshly-written project reconstructs the upstream XML.
+    // (pages diff is expected noise for LRPs — see cloneLrp.js.)
+    const rebuilt = recompose(projectReader(entry.path));
+    const diffs = comparePayload(upstream.payload, rebuilt).filter((d) => !d.startsWith('pages:'));
+
+    return {
+        newChecksum: computeChecksum(stableStringify(rebuilt)),
+        newRow: upstream.row,
+        diffs,
+    };
+}
+
+export { pullLrpEntry };