@pipefy/pipefy-process-coder 0.1.0 → 0.1.1

package/bin/pipe.js

@@ -1,13 +1,34 @@
 #!/usr/bin/env node
 // Thin launcher so `pipe` works when the package is linked or installed
-// globally. Node >=22.18 strips the types in src/*.ts natively, so there is no
-// build step.
+// globally.
+//
+// Two trees, chosen by where this file actually lives. Node strips the types
+// in src/*.ts natively (>=22.18) but refuses to for anything under
+// node_modules, which is where `npm i -g` puts the package — so an install
+// runs dist/, emitted at pack time by scripts/build.ts. A clone or `npm link`
+// (a symlink, which Node resolves to the real path outside node_modules) runs
+// src/ directly with no build step. Deciding by location rather than by
+// "does dist/ exist" means a leftover local build can never shadow the source
+// someone is editing.
 //
 // The path must be converted to a file:// URL before import(): on Windows a
 // bare path like C:\...\src\cli.ts is rejected with
 // ERR_UNSUPPORTED_ESM_URL_SCHEME, since `C:` reads as a protocol.
+import { existsSync } from 'node:fs';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { dirname, join } from 'node:path';
+import { dirname, join, sep } from 'node:path';
 
 const here = dirname(fileURLToPath(import.meta.url));
-await import(pathToFileURL(join(here, '..', 'src', 'cli.ts')).href);
+const installed = here.split(sep).includes('node_modules');
+const entry = installed ? join(here, '..', 'dist', 'cli.js') : join(here, '..', 'src', 'cli.ts');
+
+if (!existsSync(entry)) {
+  console.error(
+    `pipe: ${entry} is missing. This package was installed without its build — ` +
+      'it is emitted at pack time (npm pack / npm publish run scripts/build.ts). ' +
+      'Reinstall from the registry, or run from a clone with `npm link`.',
+  );
+  process.exit(1);
+}
+
+await import(pathToFileURL(entry).href);

package/dist/apply/adopt.js

@@ -0,0 +1,128 @@
+import { changeByKey } from "./types.js";
+export const adoptCreatedIds = (changeSet, plan, idMap) => {
+    const adopted = [];
+    for (const step of plan.steps) {
+        if (step.status !== 'done' || !step.produces)
+            continue;
+        const id = idMap.placeholderValue(step.produces.placeholder);
+        if (id === undefined)
+            continue;
+        const change = changeByKey(changeSet, step.changeKey);
+        if (!change || change.op !== 'create' || change.entity === 'repo' || !change.after)
+            continue;
+        const row = change.after;
+        if (Number(row['id']) === id && row['_new'] !== true)
+            continue; // a resumed step, already adopted
+        row['id'] = id;
+        delete row['_new'];
+        adopted.push({ entity: change.entity, label: change.label, id });
+    }
+    return adopted;
+};
+/**
+ * Where an adopted row belongs in a baseline tree — additive only.
+ *
+ * A created entity is pure addition: the previous baseline has no row for it
+ * at all, by definition, so there is nothing to overwrite and no unapplied
+ * edit to lose. `entity` and `id` are enough to find it in the already
+ * id-and-reference-resolved tree (`patched`, the output of `idMap.rewrite`),
+ * because the id this run just adopted is unique within its array.
+ */
+const findAdoptedRow = (patched, a) => {
+    switch (a.entity) {
+        case 'phases':
+            return patched.phases.find((p) => Number(p['id']) === a.id);
+        case 'fields':
+            return patched.phases.flatMap((p) => p.fields).find((f) => Number(f['id']) === a.id);
+        case 'automations':
+            return patched.automations.find((au) => Number(au['id']) === a.id);
+        case 'labels':
+            return patched.labels.find((l) => Number(l['id']) === a.id);
+        case 'field_conditions':
+            return patched.field_conditions.find((fc) => Number(fc['id']) === a.id);
+        case 'webhooks':
+            return patched.webhooks.find((w) => Number(w['id']) === a.id);
+        case 'pipe_relations':
+            return patched.pipe_relations.find((r) => Number(r['id']) === a.id);
+        default:
+            return undefined;
+    }
+};
+/**
+ * Merge every adopted row into a baseline tree, in the order they were
+ * adopted — a new field's phase must land in `baseline.phases` before the
+ * field itself is pushed into it, and `plan.steps` already runs creates in
+ * that order (registry/compile.ts), so `adopted` does too.
+ *
+ * Mutates and returns `baseline`. Never touches a row baseline already has
+ * an opinion about — this is append-only, which is what makes it safe without
+ * a live read: the alternative (replaying an update or delete too) would
+ * require knowing the *current* baseline row to update, which is exactly the
+ * information a network read would supply and this path does not have.
+ */
+export const mergeAdoptedIntoBaseline = (baseline, patched, adopted) => {
+    let changed = false;
+    for (const a of adopted) {
+        const row = findAdoptedRow(patched, a);
+        if (!row)
+            continue;
+        const clone = { ...row };
+        switch (a.entity) {
+            case 'phases':
+                if (baseline.phases.some((p) => Number(p['id']) === a.id))
+                    continue;
+                baseline.phases.push(clone);
+                break;
+            case 'fields': {
+                const phaseId = Number(clone['phase_id']);
+                const phase = baseline.phases.find((p) => Number(p['id']) === phaseId);
+                if (!phase || phase.fields.some((f) => Number(f['id']) === a.id))
+                    continue;
+                phase.fields.push(clone);
+                break;
+            }
+            case 'automations':
+                if (baseline.automations.some((au) => Number(au['id']) === a.id))
+                    continue;
+                baseline.automations.push(clone);
+                break;
+            case 'labels':
+                if (baseline.labels.some((l) => Number(l['id']) === a.id))
+                    continue;
+                baseline.labels.push(clone);
+                break;
+            case 'field_conditions':
+                if (baseline.field_conditions.some((fc) => Number(fc['id']) === a.id))
+                    continue;
+                baseline.field_conditions.push(clone);
+                break;
+            case 'webhooks':
+                if (baseline.webhooks.some((w) => Number(w['id']) === a.id))
+                    continue;
+                baseline.webhooks.push(clone);
+                break;
+            case 'pipe_relations':
+                if (baseline.pipe_relations.some((r) => Number(r['id']) === a.id))
+                    continue;
+                baseline.pipe_relations.push(clone);
+                break;
+            default:
+                continue;
+        }
+        changed = true;
+    }
+    return changed;
+};
+export const renderAdopted = (adopted) => {
+    if (!adopted.length)
+        return [];
+    const lines = [
+        `adopted ${adopted.length} server-assigned id${adopted.length === 1 ? '' : 's'} directly from the create ` +
+            `response(s) — no read-back needed, so a re-plan will not create them again`,
+    ];
+    for (const a of adopted.slice(0, 8))
+        lines.push(`   ${a.entity} ${a.label} → ${a.id}`);
+    if (adopted.length > 8)
+        lines.push(`   …and ${adopted.length - 8} more`);
+    return lines;
+};

package/dist/apply/agentops.js

@@ -0,0 +1,42 @@
+import { createAiAgent, updateAiAgent, deleteAiAgent } from "./mutations.js";
+export const compileAgents = async (client, cs) => {
+    const steps = [];
+    for (const [i, c] of cs.changes.entries()) {
+        const id = `a${String(i + 1).padStart(3, '0')}`;
+        if (c.op === 'create') {
+            steps.push({
+                id,
+                index: i,
+                changeKey: c.key,
+                op: 'create',
+                description: `createAiAgent — ${c.label}`,
+                request: await createAiAgent(client, c.after ?? {}, c.behaviors),
+                status: 'pending',
+            });
+        }
+        else if (c.op === 'update') {
+            steps.push({
+                id,
+                index: i,
+                changeKey: c.key,
+                op: 'update',
+                description: `updateAiAgent — ${c.label}`,
+                request: await updateAiAgent(client, String(c.before?.['uuid'] ?? ''), c.after ?? {}, c.behaviors),
+                status: 'pending',
+            });
+        }
+        else {
+            steps.push({
+                id,
+                index: i,
+                changeKey: c.key,
+                op: 'delete',
+                description: `deleteAiAgent — ${c.label}`,
+                destructive: true,
+                request: await deleteAiAgent(client, String(c.before?.['uuid'] ?? '')),
+                status: 'pending',
+            });
+        }
+    }
+    return { steps };
+};