@waron97/prbot 3.1.4 → 3.2.0

package/src/agrippa/commands/pb.js

@@ -0,0 +1,279 @@
+// `agrippa pb` — local editing helpers for a cloned process-builder wizard.
+//
+// All of these operate purely on the local decomposed project (no network):
+//   format      auto-lay-out the diagram (elkjs) → rewrite layout/waypoints
+//   add         add a node (+ scaffold script/page/manifest), stub geometry
+//   rm          remove a node, its edges, and its script/page files
+//   connect     add a sequenceFlow between two nodes
+//   disconnect  remove a sequenceFlow
+//   set-default mark an existing flow as the source gateway's default
+//   ls          list nodes/edges (so an agent can discover ids without the YAML)
+//
+// Mutations stub geometry; run `pb format` afterwards to finalize layout. The
+// project is resolved from the workspace by document_id (--pb), single-entry
+// auto-select, or a fuzzy prompt.
+
+import { existsSync, mkdirSync, readdirSync, unlinkSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import search from '@inquirer/search';
+import { parse as yamlParse } from 'yaml';
+import { fuzzyMatch } from '../../lib/fuzzy.js';
+import { readConfig } from '../lib/config.js';
+import {
+    addNode,
+    addNodeBetween,
+    connect,
+    disconnect,
+    eachNode,
+    lintGateways,
+    listGraph,
+    removeNode,
+    setDefault,
+} from '../lib/pbEdit.js';
+import { autoLayout } from '../lib/pbLayout.js';
+import { toSvg } from '../lib/pbPreview.js';
+import { MANIFEST_FILE, recompose, stringifyStructure, STRUCTURE_FILE } from '../lib/pbProject.js';
+import { projectReader } from '../lib/pbWorkspace.js';
+
+// ---------- project resolution ----------
+
+async function resolveProjectPath(opts) {
+    const config = readConfig();
+    const entries = (config.workspace || []).filter((e) => e.object_type === 'process_builder');
+    if (!entries.length) {
+        throw new Error(
+            'No process-builder wizards in this workspace. Clone one with `agrippa clone --pb`.'
+        );
+    }
+    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;
+    }
+    if (entries.length === 1) return entries[0].path;
+    const entry = await search({
+        message: 'Select a cloned wizard:',
+        source: (input) => {
+            const list = input
+                ? entries.filter(
+                      (e) => fuzzyMatch(e.name, input) || fuzzyMatch(e.document_id, input)
+                  )
+                : entries;
+            return list.map((e) => ({ name: `${e.name}  (${e.document_id})`, value: e }));
+        },
+    });
+    return entry.path;
+}
+
+// ---------- disk helpers ----------
+
+function loadProject(dir) {
+    const read = projectReader(dir);
+    const structure = yamlParse(read(STRUCTURE_FILE));
+    const manifest = JSON.parse(read(MANIFEST_FILE));
+    return { structure, manifest };
+}
+function saveStructure(dir, structure) {
+    writeFileSync(join(dir, STRUCTURE_FILE), stringifyStructure(structure), 'utf-8');
+}
+function saveManifest(dir, manifest) {
+    writeFileSync(join(dir, MANIFEST_FILE), JSON.stringify(manifest, null, 2), 'utf-8');
+}
+function applyEffects(dir, { writes, deletes }) {
+    for (const [rel, content] of Object.entries(writes || {})) {
+        const full = join(dir, rel);
+        mkdirSync(dirname(full), { recursive: true });
+        writeFileSync(full, content, 'utf-8');
+    }
+    for (const rel of deletes || []) {
+        const full = join(dir, rel);
+        if (existsSync(full)) unlinkSync(full);
+    }
+}
+function listScriptFiles(dir) {
+    const sdir = join(dir, 'scripts');
+    if (!existsSync(sdir)) return [];
+    return readdirSync(sdir)
+        .filter((f) => f.endsWith('.js'))
+        .map((f) => `scripts/${f}`);
+}
+// Confirm the project still recomposes (graph valid, diagram builds).
+function validate(dir) {
+    try {
+        recompose(projectReader(dir));
+    } catch (e) {
+        console.warn(`WARNING: project no longer recomposes cleanly: ${e.message}`);
+    }
+}
+
+// ---------- commands ----------
+
+async function pbFormat(opts) {
+    const dir = await resolveProjectPath(opts);
+    const { structure } = loadProject(dir);
+    await autoLayout(structure);
+    saveStructure(dir, structure);
+
+    let nodes = 0;
+    let missing = 0;
+    eachNode(structure.nodes, null, (n) => {
+        nodes++;
+        if (!n.layout) missing++;
+    });
+    validate(dir);
+    console.log(
+        `Formatted ${dir} (${nodes} node(s) laid out${missing ? `, ${missing} without layout` : ''}).`
+    );
+    const issues = lintGateways(structure);
+    if (issues.length) {
+        console.warn('Gateway issues (exclusiveGateway default/condition rule):');
+        for (const w of issues) console.warn(`  ! ${w}`);
+    }
+}
+
+async function pbAdd(opts) {
+    if (!opts.type)
+        throw new Error(
+            '--type is required (e.g. scriptTask, serviceTask, userTask, exclusiveGateway, subProcess, endEvent...)'
+        );
+    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 { structure, manifest } = loadProject(dir);
+    const ctx = { existingScripts: listScriptFiles(dir), documentId: manifest.document_id };
+
+    if (opts.from) {
+        const { writes, result } = addNodeBetween(
+            structure,
+            manifest,
+            { from: opts.from, to: opts.to, type: opts.type, name: opts.name },
+            ctx
+        );
+        applyEffects(dir, { writes, deletes: [] });
+        saveStructure(dir, structure);
+        saveManifest(dir, manifest);
+        validate(dir);
+        console.log(
+            `Added ${result.type} ${result.id}${result.file ? ` (${result.file})` : ''} between ${opts.from} → ${opts.to}.`
+        );
+        console.log(`  ${opts.from} → ${result.id}  (${result.edgeId}, retargeted)`);
+        console.log(`  ${result.id} → ${opts.to}  (${result.newEdgeId})`);
+        for (const w of result.warnings || []) console.warn(`  ! ${w}`);
+        console.log('Run `agrippa pb format` to lay it out.');
+        return;
+    }
+
+    const { writes, result } = addNode(
+        structure,
+        manifest,
+        { type: opts.type, name: opts.name, parentId: opts.parent },
+        ctx
+    );
+    applyEffects(dir, { writes, deletes: [] });
+    saveStructure(dir, structure);
+    saveManifest(dir, manifest);
+    validate(dir);
+    console.log(`Added ${result.type} ${result.id}${result.file ? ` (${result.file})` : ''}.`);
+    console.log(
+        'Connect it with `agrippa pb connect`, then run `agrippa pb format` to lay it out.'
+    );
+}
+
+async function pbRemove(opts) {
+    if (!opts.id) throw new Error('--id is required');
+    const dir = await resolveProjectPath(opts);
+    const { structure, manifest } = loadProject(dir);
+    const { deletes, result } = removeNode(structure, manifest, { id: opts.id });
+    applyEffects(dir, { writes: {}, deletes });
+    saveStructure(dir, structure);
+    saveManifest(dir, manifest);
+    validate(dir);
+    console.log(
+        `Removed ${result.removed.length} node(s) [${result.removed.join(', ')}], ` +
+            `${result.removedEdges} dangling edge(s), ${deletes.length} file(s).`
+    );
+}
+
+async function pbConnect(opts) {
+    if (!opts.from || !opts.to) throw new Error('--from and --to are required');
+    const dir = await resolveProjectPath(opts);
+    const { structure } = loadProject(dir);
+    const { result } = connect(structure, {
+        from: opts.from,
+        to: opts.to,
+        name: opts.name,
+        condition: opts.condition,
+        conditionType: opts.conditionType,
+        makeDefault: opts.default,
+    });
+    saveStructure(dir, structure);
+    validate(dir);
+    console.log(
+        `Connected ${result.from} → ${result.to} (${result.id})${opts.default ? ' [default]' : ''}.`
+    );
+    for (const w of result.warnings || []) console.warn(`  ! ${w}`);
+    console.log('Run `agrippa pb format` to route it.');
+}
+
+async function pbDisconnect(opts) {
+    if (!opts.id && !(opts.from && opts.to))
+        throw new Error('provide --id, or both --from and --to');
+    const dir = await resolveProjectPath(opts);
+    const { structure } = loadProject(dir);
+    const { result } = disconnect(structure, { id: opts.id, from: opts.from, to: opts.to });
+    saveStructure(dir, structure);
+    validate(dir);
+    console.log(`Removed ${result.removed} edge(s)${result.id ? ` (${result.id})` : ''}.`);
+}
+
+async function pbSetDefault(opts) {
+    if (!opts.id && !(opts.from && opts.to))
+        throw new Error('provide --id, or both --from and --to');
+    const dir = await resolveProjectPath(opts);
+    const { structure } = loadProject(dir);
+    const { result } = setDefault(structure, { id: opts.id, from: opts.from, to: opts.to });
+    saveStructure(dir, structure);
+    validate(dir);
+    console.log(
+        `Default flow on ${result.from} is now ${result.id} (→ ${result.to})` +
+            `${result.prev && result.prev !== result.id ? `, was ${result.prev}` : ''}.`
+    );
+    for (const w of result.warnings || []) console.warn(`  ! ${w}`);
+}
+
+async function pbList(opts) {
+    const dir = await resolveProjectPath(opts);
+    const { structure } = loadProject(dir);
+    const rows = listGraph(structure);
+    for (const r of rows) {
+        const where = r.parent ? `  [in ${r.parent}]` : '';
+        const label = r.name ? `  "${r.name}"` : '';
+        console.log(`${r.id}  (${r.type})${label}${where}`);
+        for (const e of r.edges) {
+            const tag = [
+                e.isDefault && '[default]',
+                e.name && `"${e.name}"`,
+                e.condition && `if ${e.condition}`,
+            ]
+                .filter(Boolean)
+                .join(' ');
+            console.log(`    → ${e.target}  (${e.id})${tag ? `  ${tag}` : ''}`);
+        }
+    }
+    console.log(`\n${rows.length} node(s).`);
+}
+
+async function pbPreview(opts) {
+    const dir = await resolveProjectPath(opts);
+    const { structure } = loadProject(dir);
+    const svg = toSvg(structure);
+    const out = opts.out || join(dir, 'preview.svg');
+    writeFileSync(out, svg, 'utf-8');
+    console.log(`Wrote ${out} (${svg.length} bytes).`);
+}
+
+export { pbFormat, pbAdd, pbRemove, pbConnect, pbDisconnect, pbSetDefault, pbList, pbPreview };

package/src/agrippa/commands/pull.js

@@ -1,17 +1,28 @@
-import inquirer from 'inquirer';
 import { dirname } from 'path';
-import { readConfig, writeConfig, loadEffectiveEnv } from '../lib/config.js';
-import { getPhasesByIds, getPhasesByWorkflow, listMfas } from '../lib/api.js';
+import inquirer from 'inquirer';
 import { getToken } from '../../lib/auth.js';
+import { describeWorkflow, getPhasesByIds, getPhasesByWorkflow, listMfas } from '../lib/api.js';
 import { computeChecksum } from '../lib/checksum.js';
-import { readCodeFile, writeCodeFile, fileExists, toSlug } from '../lib/workspace.js';
+import { loadEffectiveEnv, readConfig, writeConfig } from '../lib/config.js';
+import { getProcess } from '../lib/pbApi.js';
+import { localChecksum } from '../lib/pbProject.js';
+import { projectReader } from '../lib/pbWorkspace.js';
+import {
+    fileExists,
+    readCodeFile,
+    toSlug,
+    writeCodeFile,
+    writeWorkflowDoc,
+} from '../lib/workspace.js';
+import { pullPbEntry } from './pullPb.js';
 
 async function pull() {
     const config = readConfig();
     loadEffectiveEnv(config);
 
     const ripUrl = process.env.RIP_URL;
-    if (!ripUrl) throw new Error('RIP_URL is not configured. Run `prbot init` or set it in agrippa.yaml.');
+    if (!ripUrl)
+        throw new Error('RIP_URL is not configured. Run `prbot init` or set it in agrippa.yaml.');
 
     // Stale-file check
     const stale = config.workspace.filter((e) => !fileExists(e.path));
@@ -34,12 +45,19 @@ async function pull() {
 
     const token = await getToken();
 
+    // workflow_ids whose phase code changed this run -> their workflow.yml is
+    // refreshed (the graph fetch is skipped for untouched workflows).
+    const changedWorkflowIds = new Set();
+
     // ── pull existing tracked entries ─────────────────────────────────────────
-    if (config.workspace.length) {
+    // process_builder wizards are refreshed separately (different checksum model);
+    // see pullPbEntries below.
+    const pullable = config.workspace.filter((e) => e.object_type !== 'process_builder');
+    if (pullable.length) {
         console.log('Fetching remote code...');
-        const remoteCodeMap = await fetchRemoteCode(token, ripUrl, config.workspace);
+        const remoteCodeMap = await fetchRemoteCode(token, ripUrl, pullable);
 
-        const classified = config.workspace.map((entry) => {
+        const classified = pullable.map((entry) => {
             const key = `${entry.object_type}:${entry.id}`;
             const remoteCode = remoteCodeMap.get(key) ?? null;
             const localCode = readCodeFile(entry.path);
@@ -72,8 +90,11 @@ async function pull() {
             } else {
                 for (const entry of selected) {
                     writeCodeFile(entry.path, entry.remoteCode);
+                    if (entry.object_type === 'phase' && entry.workflow_id) {
+                        changedWorkflowIds.add(entry.workflow_id);
+                    }
                     const idx = config.workspace.findIndex(
-                        (e) => e.id === entry.id && e.object_type === entry.object_type,
+                        (e) => e.id === entry.id && e.object_type === entry.object_type
                     );
                     if (idx !== -1) {
                         config.workspace[idx].checksum_at_pull = computeChecksum(entry.remoteCode);
@@ -87,15 +108,86 @@ async function pull() {
         console.log('No tracked resources. Run `agrippa clone` first.');
     }
 
+    // ── refresh tracked process-builder wizards ───────────────────────────────
+    await pullPbEntries(token, config);
+
     // ── discover new phases on tracked workflows ──────────────────────────────
-    await discoverNewPhases(token, ripUrl, config);
+    await discoverNewPhases(token, ripUrl, config, changedWorkflowIds);
 }
 
-async function discoverNewPhases(token, ripUrl, config) {
+// 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
+async function pullPbEntries(token, config) {
+    const entries = config.workspace.filter((e) => e.object_type === 'process_builder');
+    if (!entries.length) return;
+    if (!process.env.PB_URL)
+        throw new Error('PB_URL is not configured. Run `prbot init` or set it in agrippa.yaml.');
+
+    console.log('Checking process-builder wizards...');
+    const classified = [];
+    for (const entry of entries) {
+        let upstream = null;
+        try {
+            upstream = await getProcess(token, entry.guid);
+        } catch {
+            upstream = null;
+        }
+        if (!upstream) {
+            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;
+        let status;
+        if (!remoteChanged) status = 'unchanged';
+        else status = localChanged ? 'conflict' : 'fast-forward';
+        classified.push({ ...entry, upstream, status });
+    }
+
+    const changed = classified.filter((e) => e.status !== 'unchanged');
+    if (!changed.length) {
+        console.log('Wizards are up to date.');
+        return;
+    }
+
+    const selected = await selectEntries(changed, 'pull (overwrites local wizard files)');
+    if (!selected.length) {
+        console.log('No wizards selected.');
+        return;
+    }
+
+    const backupTs = new Date().toISOString().replace(/:/g, '-').replace('T', '_').slice(0, 19);
+    for (const entry of selected) {
+        const res = await pullPbEntry(token, entry, '.backup', backupTs);
+        const idx = config.workspace.findIndex(
+            (e) => e.object_type === 'process_builder' && e.guid === entry.guid
+        );
+        if (idx !== -1) {
+            config.workspace[idx].checksum_at_pull = res.newChecksum;
+            if (res.newUpdatedDate) config.workspace[idx].updated_date = res.newUpdatedDate;
+            if (res.newStatus) config.workspace[idx].status = res.newStatus;
+        }
+        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} wizard(s). 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();
     for (const entry of config.workspace) {
-        if (entry.object_type === 'phase' && entry.workflow_id && !workflows.has(entry.workflow_id)) {
+        if (
+            entry.object_type === 'phase' &&
+            entry.workflow_id &&
+            !workflows.has(entry.workflow_id)
+        ) {
             workflows.set(entry.workflow_id, {
                 name: entry.workflow_name,
                 basePath: dirname(entry.path),
@@ -106,12 +198,13 @@ async function discoverNewPhases(token, ripUrl, config) {
     if (!workflows.size) return;
 
     const trackedIds = new Set(
-        config.workspace.filter((e) => e.object_type === 'phase').map((e) => e.id),
+        config.workspace.filter((e) => e.object_type === 'phase').map((e) => e.id)
     );
 
     let newCount = 0;
     for (const [wfId, { name: wfName, basePath }] of workflows) {
         const phases = await getPhasesByWorkflow(token, ripUrl, wfId, { fromCode: true });
+        let wfChanged = changedWorkflowIds.has(wfId);
         for (const phase of phases) {
             if (trackedIds.has(phase.id)) continue;
             const filePath = `${basePath}/${toSlug(phase.name)}.py`;
@@ -127,6 +220,19 @@ async function discoverNewPhases(token, ripUrl, config) {
             });
             console.log(`  new phase: ${filePath}`);
             newCount++;
+            wfChanged = true;
+        }
+
+        // Refresh the read-only workflow graph only when this workflow's code
+        // changed this run, or when its doc is missing (one-time backfill).
+        // Skips the per-workflow graph fetch for untouched workflows.
+        if (wfChanged || !fileExists(`${basePath}/workflow.yml`)) {
+            try {
+                const structure = await describeWorkflow(token, ripUrl, wfId);
+                writeWorkflowDoc(basePath, structure);
+            } catch (err) {
+                console.warn(`  could not refresh workflow.yml for ${wfName}: ${err.message}`);
+            }
         }
     }
 

package/src/agrippa/commands/pullPb.js

@@ -0,0 +1,54 @@
+import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { computeChecksum } from '../lib/checksum.js';
+import { getProcess } from '../lib/pbApi.js';
+import { comparePayload, decompose, recompose, stableStringify } from '../lib/pbProject.js';
+import { projectReader, writeProject } from '../lib/pbWorkspace.js';
+
+// Delete files under <baseDir>/<sub> that are not in the fresh decompose map, so
+// a refresh that renames/removes scripts or pages doesn't leave orphans behind.
+function pruneOrphans(baseDir, sub, files) {
+    const dir = join(baseDir, sub);
+    if (!existsSync(dir)) return;
+    for (const f of readdirSync(dir)) {
+        if (!(`${sub}/${f}` in files)) rmSync(join(dir, f));
+    }
+}
+
+// Refresh one cloned wizard from upstream (the pull counterpart of pushPbEntry):
+// back up the current local state, re-decompose the upstream payload, overwrite
+// local files (pruning orphans), and verify the round-trip. `entry.upstream` is
+// the payload fetched during classification; refetched if absent.
+async function pullPbEntry(token, entry, backupDir, backupTs) {
+    const upstream = entry.upstream ?? (await getProcess(token, entry.guid));
+    if (!upstream) throw new Error(`could not fetch upstream wizard ${entry.guid}`);
+
+    // 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);
+    pruneOrphans(entry.path, 'scripts', files);
+    pruneOrphans(entry.path, 'pages', files);
+    writeProject(entry.path, files);
+
+    // 3. Verify the freshly-written project reconstructs the upstream payload.
+    const rebuilt = recompose(projectReader(entry.path));
+    const diffs = comparePayload(upstream, rebuilt);
+
+    return {
+        newChecksum: computeChecksum(stableStringify(rebuilt)),
+        newUpdatedDate: upstream.updated_date,
+        newStatus: upstream.status,
+        diffs,
+    };
+}
+
+export { pullPbEntry };