@waron97/prbot 3.1.4 → 3.2.0

package/src/agrippa/lib/pbPreview.js

@@ -0,0 +1,151 @@
+// Quick-and-dirty SVG render of a decomposed wizard's diagram, for eyeballing
+// the output of `pb format` during development. Not byte-faithful to the BPMN
+// renderer — it just draws each node by type (event=circle, gateway=diamond,
+// task=rounded rect, container=rect) and each edge as a waypoint polyline, from
+// the geometry in structure.yaml.
+
+import { CONTAINER, eachNode } from './pbEdit.js';
+
+const EVENT = new Set(['startEvent', 'endEvent', 'boundaryEvent']);
+
+function esc(s) {
+    return String(s ?? '')
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+
+function toSvg(structure) {
+    const leaves = [];
+    const containers = [];
+    const edges = [];
+    eachNode(structure.nodes, null, (n) => {
+        if (!n.layout) return;
+        if (CONTAINER.has(n.type)) containers.push(n);
+        else leaves.push(n);
+        for (const e of n.edges || []) if (e.waypoints?.length) edges.push(e);
+    });
+    const anns = (structure.annotations || []).filter((a) => a.layout);
+    const assocs = (structure.associations || []).filter((a) => a.waypoints?.length);
+
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    const ext = (x, y) => {
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+    };
+    for (const n of [...leaves, ...containers, ...anns]) {
+        const l = n.layout;
+        ext(l.x, l.y);
+        ext(l.x + l.width, l.y + l.height);
+    }
+    for (const e of [...edges, ...assocs]) for (const [x, y] of e.waypoints) ext(x, y);
+    if (!Number.isFinite(minX)) {
+        minX = 0;
+        minY = 0;
+        maxX = 100;
+        maxY = 100;
+    }
+
+    const pad = 40;
+    const W = Math.round(maxX - minX + pad * 2);
+    const H = Math.round(maxY - minY + pad * 2);
+    const ox = pad - minX;
+    const oy = pad - minY;
+
+    const out = [];
+    out.push(
+        `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}" viewBox="0 0 ${W} ${H}" font-family="sans-serif" font-size="11">`
+    );
+    out.push(
+        '<defs><marker id="arrow" markerWidth="10" markerHeight="10" refX="8" refY="3" orient="auto">' +
+            '<path d="M0,0 L8,3 L0,6 z" fill="#444"/></marker></defs>'
+    );
+    out.push('<rect width="100%" height="100%" fill="#fff"/>');
+
+    const label = (cx, cy, text) =>
+        text
+            ? `<text x="${cx}" y="${cy}" text-anchor="middle" dominant-baseline="middle">${esc(text)}</text>`
+            : '';
+
+    // containers behind everything
+    for (const n of containers) {
+        const l = n.layout;
+        const x = l.x + ox;
+        const y = l.y + oy;
+        out.push(
+            `<rect x="${x}" y="${y}" width="${l.width}" height="${l.height}" rx="8" fill="#f5f7fa" stroke="#9aa7b4"/>`
+        );
+        out.push(
+            `<text x="${x + 8}" y="${y + 16}" font-weight="bold">${esc(n.name || n.type)}</text>`
+        );
+    }
+    // edges
+    for (const e of edges) {
+        const pts = e.waypoints.map(([x, y]) => `${x + ox},${y + oy}`).join(' ');
+        out.push(
+            `<polyline points="${pts}" fill="none" stroke="#444" stroke-width="1.5" marker-end="url(#arrow)"/>`
+        );
+        if (e.name) {
+            const m = e.waypoints[Math.floor(e.waypoints.length / 2)];
+            out.push(
+                `<text x="${m[0] + ox}" y="${m[1] + oy - 4}" text-anchor="middle" fill="#666" font-size="9">${esc(e.name)}</text>`
+            );
+        }
+    }
+    for (const a of assocs) {
+        const pts = a.waypoints.map(([x, y]) => `${x + ox},${y + oy}`).join(' ');
+        out.push(
+            `<polyline points="${pts}" fill="none" stroke="#888" stroke-width="1" stroke-dasharray="3,3"/>`
+        );
+    }
+    // annotations
+    for (const a of anns) {
+        const l = a.layout;
+        const x = l.x + ox;
+        const y = l.y + oy;
+        out.push(
+            `<rect x="${x}" y="${y}" width="${l.width}" height="${l.height}" fill="#fffbe6" stroke="#d4b106"/>`
+        );
+        out.push(
+            `<text x="${x + 4}" y="${y + 14}" font-size="9">${esc((a.text || '').slice(0, 40))}</text>`
+        );
+    }
+    // leaf shapes on top
+    for (const n of leaves) {
+        const l = n.layout;
+        const x = l.x + ox;
+        const y = l.y + oy;
+        const cx = x + l.width / 2;
+        const cy = y + l.height / 2;
+        if (EVENT.has(n.type)) {
+            const sw = n.type === 'endEvent' ? 3 : 1.5;
+            out.push(
+                `<circle cx="${cx}" cy="${cy}" r="${l.width / 2}" fill="#fff" stroke="#333" stroke-width="${sw}"/>`
+            );
+            out.push(label(cx, y + l.height + 10, n.name));
+        } else if (n.type === 'exclusiveGateway') {
+            const p = `${cx},${y} ${x + l.width},${cy} ${cx},${y + l.height} ${x},${cy}`;
+            out.push(`<polygon points="${p}" fill="#fff" stroke="#333"/>`);
+            out.push(
+                `<text x="${cx}" y="${cy}" text-anchor="middle" dominant-baseline="middle" font-size="13">&#215;</text>`
+            );
+            out.push(label(cx, y + l.height + 10, n.name));
+        } else {
+            const fill =
+                n.type === 'userTask' ? '#e6f4ff' : n.type === 'serviceTask' ? '#f0ffe6' : '#fff';
+            out.push(
+                `<rect x="${x}" y="${y}" width="${l.width}" height="${l.height}" rx="8" fill="${fill}" stroke="#333"/>`
+            );
+            out.push(label(cx, cy, n.name));
+        }
+    }
+    out.push('</svg>');
+    return out.join('\n');
+}
+
+export { toSvg };

package/src/agrippa/lib/pbProject.js

@@ -0,0 +1,390 @@
+// Decompose a process-builder payload into editable files, and recompose it.
+//
+// Layout (see ai_tasks planning.md):
+//   process.yaml      editable scalar overlay (identity + flags)
+//   structure.yaml    the authoritative graph: nodes hold their own outgoing
+//                     edges and (for subProcess) nested child nodes; each node
+//                     carries its diagram layout {x,y,width,height}; each edge
+//                     its waypoints. scriptTask bodies are referenced by file.
+//   scripts/NNNN_*.js  one scriptTask body each, byte-exact
+//   pages/<formKey>.yml  one userTask page object each
+//   .agrippa-pb.json   manifest: all scalars verbatim, ns, full diagram, audit,
+//                     id<->file maps
+//
+// The manifest carries every top-level scalar and the full diagram verbatim, so
+// nothing is ever lost; process.yaml and the per-node layout/waypoints in
+// structure.yaml *override* the manifest on recompose (so edits flow through).
+
+import slugify from 'slugify';
+import { Document, visit, parse as yamlParse, stringify as yamlStringify } from 'yaml';
+import { computeChecksum } from './checksum.js';
+import { buildProcess, compareDiagram, compareProcess, diff, parseProcess } from './pbModel.js';
+
+const MANIFEST_FILE = '.agrippa-pb.json';
+const STRUCTURE_FILE = 'structure.yaml';
+const PROCESS_FILE = 'process.yaml';
+
+// Scalar fields surfaced in process.yaml (editable). Everything else lives in
+// the manifest. These override manifest scalars on recompose.
+const EDITABLE_SCALARS = [
+    'document_id',
+    'process_name',
+    'version',
+    'icon',
+    'short_description',
+    'status',
+    'active',
+    'is_linear',
+    'execute_save',
+    'progressbar_enabled',
+    'start_date',
+    'end_date',
+    'favorite',
+];
+
+// Container node types whose children nest under them in structure.yaml.
+const CONTAINER_TAGS = new Set(['subProcess', 'transaction']);
+
+// Type-specific node fields carried verbatim between the flat model and structure.yaml.
+const NODE_FIELDS = [
+    'attrs',
+    'class',
+    'fields',
+    'formKey',
+    'attachedToRef',
+    'errorEventDefinition',
+    'multiInstance',
+    'documentation',
+];
+
+function toSlug(name) {
+    return slugify(String(name ?? ''), { lower: true, strict: true }) || 'node';
+}
+function pad(n) {
+    return String(n).padStart(4, '0');
+}
+
+// Render structure.yaml with layout/waypoints as compact inline (flow) collections.
+function setFlowDeep(node) {
+    if (!node || !node.items) return;
+    node.flow = true;
+    for (const it of node.items) {
+        if (it?.items) setFlowDeep(it); // inner seq (e.g. a waypoint pair)
+        if (it?.value?.items) setFlowDeep(it.value);
+    }
+}
+function stringifyStructure(obj) {
+    const doc = new Document(obj);
+    visit(doc, {
+        Pair(_, pair) {
+            const key = pair.key?.value;
+            if (key === 'layout' || key === 'waypoints') setFlowDeep(pair.value);
+        },
+    });
+    return doc.toString({ lineWidth: 0 });
+}
+function pick(obj, keys) {
+    const o = {};
+    for (const k of keys) if (k in obj) o[k] = obj[k];
+    return o;
+}
+function omit(obj, keys) {
+    const set = new Set(keys);
+    const o = {};
+    for (const [k, v] of Object.entries(obj)) if (!set.has(k)) o[k] = v;
+    return o;
+}
+
+// ---------- geometry maps from a parsed diagram ----------
+
+function geometryMaps(diagram) {
+    const bounds = {};
+    const waypoints = {};
+    const expanded = {};
+    if (diagram) {
+        for (const s of diagram.shapes) {
+            if (s.bounds) bounds[s.attrs.bpmnElement] = { ...s.bounds };
+            if (s.attrs.isExpanded !== undefined)
+                expanded[s.attrs.bpmnElement] = s.attrs.isExpanded;
+        }
+        for (const e of diagram.edges)
+            if (e.waypoints?.length)
+                waypoints[e.attrs.bpmnElement] = e.waypoints.map((w) => [w.x, w.y]);
+    }
+    return { bounds, waypoints, expanded };
+}
+
+// ---------- nested structure.yaml (decompose side) ----------
+
+function structEdge(e, geo) {
+    const o = { id: e.id, target: e.target };
+    if (e.name !== undefined) o.name = e.name;
+    if (e.condition !== undefined) o.condition = e.condition;
+    if (e.conditionType !== undefined) o.conditionType = e.conditionType;
+    if (e.documentation !== undefined) o.documentation = e.documentation;
+    if (geo.waypoints[e.id]) o.waypoints = geo.waypoints[e.id];
+    return o;
+}
+
+function structNode(n, model, scriptsMap, geo) {
+    const out = { id: n.id, type: n.type };
+    if (n.name !== undefined) out.name = n.name;
+    for (const k of NODE_FIELDS) if (n[k] !== undefined) out[k] = n[k];
+    if (n.type === 'scriptTask') out.script = scriptsMap[n.id];
+    if (geo.bounds[n.id]) out.layout = geo.bounds[n.id];
+    if (geo.expanded[n.id] !== undefined) out.expanded = geo.expanded[n.id];
+    const outEdges = model.edges.filter((e) => e.source === n.id).map((e) => structEdge(e, geo));
+    if (outEdges.length) out.edges = outEdges;
+    if (CONTAINER_TAGS.has(n.type)) {
+        const kids = nestNodes(model, n.id, scriptsMap, geo);
+        if (kids.length) out.nodes = kids;
+    }
+    return out;
+}
+
+function nestNodes(model, parentId, scriptsMap, geo) {
+    return model.nodes
+        .filter((n) => (n.parent ?? null) === parentId)
+        .map((n) => structNode(n, model, scriptsMap, geo));
+}
+
+// ---------- flatten structure.yaml back to model (recompose side) ----------
+
+function flattenNodes(structNodes, parentId, model, read, geo) {
+    for (const sn of structNodes || []) {
+        const n = { id: sn.id, type: sn.type };
+        if (sn.name !== undefined) n.name = sn.name;
+        if (parentId) n.parent = parentId;
+        for (const k of NODE_FIELDS) if (sn[k] !== undefined) n[k] = sn[k];
+        if (sn.type === 'scriptTask') n.script = read(sn.script); // load body from file
+        if (sn.layout) geo.bounds[sn.id] = sn.layout;
+        if (sn.expanded !== undefined) geo.expanded[sn.id] = sn.expanded;
+        model.nodes.push(n);
+
+        for (const se of sn.edges || []) {
+            const e = { id: se.id, source: sn.id, target: se.target };
+            if (se.name !== undefined) e.name = se.name;
+            if (se.condition !== undefined) e.condition = se.condition;
+            if (se.conditionType !== undefined) e.conditionType = se.conditionType;
+            if (se.documentation !== undefined) e.documentation = se.documentation;
+            if (parentId) e.parent = parentId;
+            if (se.waypoints) geo.waypoints[se.id] = se.waypoints;
+            model.edges.push(e);
+        }
+        if (sn.nodes) flattenNodes(sn.nodes, sn.id, model, read, geo);
+    }
+}
+
+// ---------- decompose: payload -> { files, manifest } ----------
+
+function decompose(payload) {
+    const { ns, model, diagram } = parseProcess(payload.built_page);
+    const geo = geometryMaps(diagram);
+    const files = {};
+
+    // scripts — one file per scriptTask, document order, byte-exact body.
+    const scriptsMap = {};
+    let seq = 0;
+    const usedNames = new Set();
+    for (const n of model.nodes) {
+        if (n.type !== 'scriptTask') continue;
+        seq += 10;
+        let base = `${pad(seq)}_${toSlug(n.name || n.id)}`;
+        while (usedNames.has(base)) base += '_';
+        usedNames.add(base);
+        const path = `scripts/${base}.js`;
+        files[path] = n.script ?? '';
+        scriptsMap[n.id] = path;
+    }
+
+    // pages — one file per userTask page object; wrapper audit kept in manifest.
+    const pagesMap = {};
+    const usedPageNames = new Set();
+    for (const wrapper of payload.pages || []) {
+        const stepkey = wrapper.page?._id?.stepkey ?? wrapper.name;
+        const ut = model.nodes.find((x) => x.type === 'userTask' && x.id === stepkey);
+        let fname = toSlug(ut?.formKey || wrapper.name || stepkey);
+        while (usedPageNames.has(fname)) fname += '_';
+        usedPageNames.add(fname);
+        const path = `pages/${fname}.yml`;
+        files[path] = yamlStringify(wrapper.page, { lineWidth: 0 });
+        pagesMap[stepkey] = { file: path, wrapper: omit(wrapper, ['page']) };
+    }
+
+    // structure.yaml — nested graph: edges under their source node, subProcess
+    // children nested, layout/waypoints inline, scriptTask bodies by ref.
+    // Annotations/associations carry their own geometry too, so the diagram is
+    // fully regenerable from structure.yaml alone (the manifest is never read
+    // back for the diagram).
+    const structure = {
+        process: model.process,
+        errors: model.errors,
+        nodes: nestNodes(model, null, scriptsMap, geo),
+        annotations: model.annotations.map((a) =>
+            geo.bounds[a.id] ? { ...a, layout: geo.bounds[a.id] } : a
+        ),
+        associations: model.associations.map((a) =>
+            geo.waypoints[a.id] ? { ...a, waypoints: geo.waypoints[a.id] } : a
+        ),
+    };
+    files[STRUCTURE_FILE] = stringifyStructure(structure);
+
+    // process.yaml — editable scalar overlay.
+    files[PROCESS_FILE] = yamlStringify(pick(payload, EDITABLE_SCALARS), { lineWidth: 0 });
+
+    // manifest — scalars/audit/ns + id<->file maps. The diagram is NOT stored:
+    // it is regenerated from structure.yaml geometry on recompose.
+    const manifest = {
+        guid: payload.guid,
+        document_id: payload.document_id,
+        process_name: payload.process_name,
+        scalars: omit(payload, ['built_page', 'pages', 'process_structure']),
+        process_structure: payload.process_structure,
+        ns,
+        scripts: scriptsMap,
+        pages: pagesMap,
+    };
+    files[MANIFEST_FILE] = JSON.stringify(manifest, null, 2);
+
+    return { files, manifest };
+}
+
+// ---------- recompose: read(path)->content  ->  payload ----------
+
+function recompose(read) {
+    const manifest = JSON.parse(read(MANIFEST_FILE));
+    const structure = yamlParse(read(STRUCTURE_FILE));
+    const processOverlay = yamlParse(read(PROCESS_FILE)) || {};
+
+    const model = {
+        process: structure.process,
+        errors: structure.errors || [],
+        nodes: [],
+        edges: [],
+        annotations: structure.annotations || [],
+        associations: structure.associations || [],
+    };
+    const geo = { bounds: {}, waypoints: {}, expanded: {} };
+    flattenNodes(structure.nodes, null, model, read, geo);
+    // annotation/association geometry (top-level lists carry it inline)
+    for (const a of model.annotations) if (a.layout) geo.bounds[a.id] = a.layout;
+    for (const a of model.associations) if (a.waypoints) geo.waypoints[a.id] = a.waypoints;
+
+    const built_page = buildProcess({ ns: manifest.ns, model, geo });
+
+    const pages = [];
+    for (const info of Object.values(manifest.pages)) {
+        const pageObj = yamlParse(read(info.file));
+        pages.push({ ...info.wrapper, page: pageObj });
+    }
+
+    return {
+        ...manifest.scalars,
+        ...processOverlay,
+        built_page,
+        pages,
+        process_structure: manifest.process_structure,
+    };
+}
+
+// ---------- verify: decompose -> recompose -> semantic compare ----------
+//
+// 0-loss bar A: behavioral equivalence. Returns a list of human-readable
+// differences (empty array == lossless round-trip).
+
+function comparePayload(payload, rebuilt) {
+    const diffs = [];
+
+    // 1. logic graph (<process> subtree), formatting-insensitive
+    const procDiff = compareProcess(payload.built_page, rebuilt.built_page);
+    if (procDiff) diffs.push(`built_page <process>: ${procDiff}`);
+
+    // 2. diagram geometry — structural (drawing-order-insensitive, waypoints ordered)
+    const diaDiff = compareDiagram(payload.built_page, rebuilt.built_page);
+    if (diaDiff) diffs.push(`built_page <bpmndi>: ${diaDiff}`);
+
+    // 3. pages — deep-equal of page objects (jsonb semantics)
+    const pd = diff(payload.pages, rebuilt.pages, '$.pages');
+    if (pd) diffs.push(`pages: ${pd}`);
+
+    // 4. process_structure — verbatim
+    const psd = diff(payload.process_structure, rebuilt.process_structure, '$.process_structure');
+    if (psd) diffs.push(`process_structure: ${psd}`);
+
+    // 5. every other top-level scalar
+    const sd = diff(
+        omit(payload, ['built_page', 'pages', 'process_structure']),
+        omit(rebuilt, ['built_page', 'pages', 'process_structure']),
+        '$'
+    );
+    if (sd) diffs.push(`scalars: ${sd}`);
+
+    return diffs;
+}
+
+// ---------- push helpers ----------
+
+// Deterministic JSON (recursively sorted keys) for stable checksums.
+function stableStringify(value) {
+    if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+    if (value && typeof value === 'object') {
+        return `{${Object.keys(value)
+            .sort()
+            .map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value ?? null);
+}
+
+// Checksum of the recomposed payload — stable across runs, changes only when the
+// local files change. clonePb stores this as checksum_at_pull; push recomputes it.
+function localChecksum(read) {
+    return computeChecksum(stableStringify(recompose(read)));
+}
+
+// Enumerate the wizard's pages from the pages/*.yml files (the authoritative
+// local set). Each page links to its userTask via `page._id.stepkey`; the
+// manifest supplies the upstream page guid (absent => a locally-added page that
+// must be created). `pageFiles` is the list of relative page file paths.
+function enumeratePages(read, pageFiles) {
+    const manifest = JSON.parse(read(MANIFEST_FILE));
+    return pageFiles.map((file) => {
+        const page = yamlParse(read(file));
+        const stepkey = page?._id?.stepkey;
+        const info = manifest.pages?.[stepkey];
+        return {
+            stepkey,
+            file,
+            page,
+            guid: info?.wrapper?.guid ?? null,
+            wrapper: info?.wrapper ?? null,
+        };
+    });
+}
+
+// In-memory round-trip: decompose -> recompose from the produced file map -> compare.
+function verifyRoundTrip(payload) {
+    const { files } = decompose(payload);
+    const read = (p) => {
+        if (!(p in files)) throw new Error(`recompose read missing file: ${p}`);
+        return files[p];
+    };
+    return comparePayload(payload, recompose(read));
+}
+
+export {
+    decompose,
+    recompose,
+    comparePayload,
+    verifyRoundTrip,
+    stableStringify,
+    localChecksum,
+    enumeratePages,
+    stringifyStructure,
+    pad,
+    MANIFEST_FILE,
+    STRUCTURE_FILE,
+    PROCESS_FILE,
+    EDITABLE_SCALARS,
+    toSlug,
+};

package/src/agrippa/lib/pbWorkspace.js

@@ -0,0 +1,30 @@
+// Disk IO for a decomposed process-builder project.
+
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+
+// Write a { path -> content } file map under baseDir. Content is written
+// byte-exact (scripts must not be reformatted).
+function writeProject(baseDir, files) {
+    for (const [rel, content] of Object.entries(files)) {
+        const full = join(baseDir, rel);
+        mkdirSync(dirname(full), { recursive: true });
+        writeFileSync(full, content, 'utf-8');
+    }
+}
+
+// A reader bound to baseDir, suitable for recompose().
+function projectReader(baseDir) {
+    return (rel) => readFileSync(join(baseDir, rel), 'utf-8');
+}
+
+// Relative paths of the page files under <baseDir>/pages.
+function listPageFiles(baseDir) {
+    const dir = join(baseDir, 'pages');
+    if (!existsSync(dir)) return [];
+    return readdirSync(dir)
+        .filter((f) => f.endsWith('.yml') || f.endsWith('.yaml'))
+        .map((f) => `pages/${f}`);
+}
+
+export { writeProject, projectReader, listPageFiles };

package/src/agrippa/lib/workspace.js

@@ -1,6 +1,7 @@
-import slugify from 'slugify';
-import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { dirname } from 'path';
+import slugify from 'slugify';
+import { stringify as yamlStringify } from 'yaml';
 
 function toSlug(name) {
     return slugify(name, { lower: true, strict: true });
@@ -39,4 +40,23 @@ function fileExists(filePath) {
     return existsSync(filePath);
 }
 
-export { toSlug, defaultPhasePath, defaultMfaPath, ensureDir, writeCodeFile, readCodeFile, fileExists };
+// Auto-generated, read-only context: dumps the workflow graph returned by the
+// `agrippa_describe_workflow` MFA to `<dirPath>/workflow.yml`. Not tracked in the
+// workspace -- it is not pushable, it is regenerated on every clone/pull.
+function writeWorkflowDoc(dirPath, structure) {
+    const filePath = `${dirPath}/workflow.yml`;
+    ensureDir(filePath);
+    writeFileSync(filePath, yamlStringify(structure, { lineWidth: 0 }), 'utf-8');
+    return filePath;
+}
+
+export {
+    toSlug,
+    defaultPhasePath,
+    defaultMfaPath,
+    ensureDir,
+    writeCodeFile,
+    readCodeFile,
+    fileExists,
+    writeWorkflowDoc,
+};

package/src/commands/autopr.js

@@ -78,7 +78,8 @@ async function fetchActivePr(branch) {
     const res = await fetch(apiUrl, { headers: devopsHeaders() });
     const data = await res.json();
     if (!res.ok) throw new Error(`DevOps PR fetch failed: ${JSON.stringify(data)}`);
-    if (!data.value || data.value.length === 0) throw new Error(`No active PR found for branch: ${branch}`);
+    if (!data.value || data.value.length === 0)
+        throw new Error(`No active PR found for branch: ${branch}`);
     return data.value[0];
 }
 
@@ -251,7 +252,9 @@ async function autoprAmend(options) {
     const content = readFileSync(changelogPath, 'utf-8');
     const existing = findLineByPrNumber(content, prNumber);
     if (!existing) {
-        console.log(`Warning: no changelog line found for PR #${prNumber} — skipping changelog update`);
+        console.log(
+            `Warning: no changelog line found for PR #${prNumber} — skipping changelog update`
+        );
         return;
     }
     const lines = content.split('\n');

package/src/commands/changelog.js

@@ -199,7 +199,10 @@ function appendRefsToLine(line, tridentIds, jiras) {
             const rawCapture = tridentMatch[1];
             const trailing = rawCapture.match(/([,\s]+)$/)?.[1] ?? '';
             const existingTridents = rawCapture.replace(/[,\s]+$/, '');
-            result = result.replace(/Trident (#[\d, #]+)/, `Trident ${existingTridents}, ${suffix}${trailing}`);
+            result = result.replace(
+                /Trident (#[\d, #]+)/,
+                `Trident ${existingTridents}, ${suffix}${trailing}`
+            );
         } else {
             const parenMatch = result.match(/\(([^)]*)\)\s*$/);
             if (parenMatch) {

package/src/commands/export.js

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