@memberjunction/ng-task-graph-editor 0.0.0 → 6.1.0-edge.1

package/LICENSE

@@ -0,0 +1,7 @@
+ISC License
+
+Copyright (c) 2023 MemberJunction
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/dist/lib/task-graph-canvas-adapter.d.ts

@@ -0,0 +1,98 @@
+/**
+ * @fileoverview Projects a `TaskGraphSpec` onto the generic canvas shapes, and back.
+ *
+ * **Kept pure and separate from the component on purpose.** Everything interesting about rendering a
+ * task graph — which node is an entry point, which edge is conditional, how a runtime status maps to
+ * a visual one, whether removing a node orphans an edge — is decidable from data alone. Putting it
+ * in a component would make it reachable only through a TestBed, and the resulting tests would be
+ * about Angular rather than about graphs.
+ *
+ * **The direction flip, again.** A `TaskGraphSpec` edge points *backwards* (`dependsOn`: "I wait for
+ * X"); a canvas connection points *forwards* (source → target). Same edge, opposite authoring
+ * convention — the graph is written by whoever knows the prerequisites, the canvas drawn by whoever
+ * follows the arrows. This is the second place in the program that inversion appears (Save as
+ * Workflow is the first), which is why it is stated rather than left implicit.
+ *
+ * @module @memberjunction/ng-task-graph-editor
+ */
+import { type TaskGraphSpec, type TaskGraphSpecNode, type TaskGraphDependency } from '@memberjunction/ai-core-plus';
+import type { FlowConnection, FlowNode, FlowNodeStatus, FlowNodeTypeConfig } from '@memberjunction/ng-flow-editor';
+/** Node types the palette offers. Two, because a task is either an agent's or a person's. */
+export declare const TASK_GRAPH_NODE_TYPES: FlowNodeTypeConfig[];
+/** Live per-task state for the runtime overlay, keyed by `tempId`. */
+export type TaskGraphRuntimeStatus = Record<string, TaskGraphRuntimeState>;
+/** What a task is doing right now, in the durable engine's own vocabulary. */
+export type TaskGraphRuntimeState = 'Pending' | 'In Progress' | 'Complete' | 'Failed' | 'Blocked' | 'Cancelled' | 'Deferred';
+/**
+ * Maps a durable task state onto the canvas's visual vocabulary.
+ *
+ * Two mappings are worth explaining. `Blocked` renders as a **warning**, not an error: nothing went
+ * wrong, the graph simply cannot reach it — showing it as a failure would send someone hunting for a
+ * bug that does not exist. `Deferred` renders as `pending` because, to the person watching, waiting
+ * on a schedule and waiting on a prerequisite look and mean the same thing.
+ */
+export declare function RuntimeStateToNodeStatus(state: TaskGraphRuntimeState | undefined): FlowNodeStatus;
+/** True when the node is a person's step rather than an agent's. */
+export declare function IsHumanTask(node: TaskGraphSpecNode): boolean;
+/** Entry points: nodes nothing else has to finish first. Same rule the traversal engine uses. */
+export declare function GetEntryTempIds(spec: TaskGraphSpec): string[];
+/** Every dependency of a node, in normalized object form. */
+export declare function GetDependencies(node: TaskGraphSpecNode): TaskGraphDependency[];
+/** The `tempId`s that depend on `tempId` — i.e. what breaks if it is removed. */
+export declare function GetDependents(spec: TaskGraphSpec, tempId: string): string[];
+/**
+ * Projects the spec onto canvas nodes.
+ *
+ * Positions are left at the origin: layout is the canvas's job (Dagre), and a spec carries no
+ * geometry precisely because a task graph is a *logical* structure. An agent that emitted one never
+ * had an opinion about where the boxes go.
+ */
+export declare function SpecToNodes(spec: TaskGraphSpec, runtime?: TaskGraphRuntimeStatus): FlowNode[];
+/**
+ * Projects the spec's dependencies onto canvas connections, reversing their direction.
+ *
+ * A conditional edge is drawn dashed and labeled with its condition, because the difference between
+ * "always" and "only sometimes" is the single most consequential thing about an edge and the one a
+ * reader is most likely to miss when scanning a diagram.
+ *
+ * Edges naming a task that is not in the graph are skipped rather than drawn dangling — the
+ * validator reports them as `UnknownDependency`, and rendering a connection to nowhere would be a
+ * second, worse way of saying the same thing.
+ */
+export declare function SpecToConnections(spec: TaskGraphSpec): FlowConnection[];
+/**
+ * Adds a dependency to the spec, returning a NEW spec.
+ *
+ * Immutable because the component emits the result to a host that may keep it, diff it, or reject
+ * it; mutating the input would let a canceled edit leak into the host's copy anyway. A duplicate
+ * edge is a no-op rather than an error — dragging the same connection twice is a slip, not a
+ * request to corrupt the graph.
+ */
+export declare function AddDependency(spec: TaskGraphSpec, fromTempId: string, toTempId: string, condition?: string): TaskGraphSpec;
+/** Removes a dependency, returning a NEW spec. */
+export declare function RemoveDependency(spec: TaskGraphSpec, fromTempId: string, toTempId: string): TaskGraphSpec;
+/**
+ * Removes a task AND every edge into it, returning a NEW spec.
+ *
+ * Severing the inbound edges is not a convenience — leaving them would produce a graph whose
+ * `dependsOn` names a task that no longer exists, which the validator rejects as
+ * `UnknownDependency`. Deleting a box on a canvas should not make the graph invalid.
+ */
+export declare function RemoveTask(spec: TaskGraphSpec, tempId: string): TaskGraphSpec;
+/** Adds a task, returning a NEW spec. */
+export declare function AddTask(spec: TaskGraphSpec, task: TaskGraphSpecNode): TaskGraphSpec;
+/** Replaces a task in place by `tempId`, returning a NEW spec. */
+export declare function UpdateTask(spec: TaskGraphSpec, tempId: string, next: TaskGraphSpecNode): TaskGraphSpec;
+/**
+ * Would adding `from → to` create a cycle?
+ *
+ * Answered before the edge exists, so the canvas can refuse it rather than create an invalid graph
+ * and report it afterwards. A self-edge is the degenerate case and is caught first.
+ *
+ * Iterative rather than recursive: the graph may come from an LLM, and a deeply-chained spec should
+ * produce a refusal, not a stack overflow.
+ */
+export declare function WouldCreateCycle(spec: TaskGraphSpec, fromTempId: string, toTempId: string): boolean;
+/** A unique `tempId` for a newly added task, stable and readable. */
+export declare function NextTempId(spec: TaskGraphSpec, prefix?: string): string;
+//# sourceMappingURL=task-graph-canvas-adapter.d.ts.map

package/dist/lib/task-graph-canvas-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-graph-canvas-adapter.d.ts","sourceRoot":"","sources":["../../src/lib/task-graph-canvas-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAEH,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EAC3B,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAEnH,6FAA6F;AAC7F,eAAO,MAAM,qBAAqB,EAAE,kBAAkB,EAuBrD,CAAC;AAEF,sEAAsE;AACtE,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;AAE3E,8EAA8E;AAC9E,MAAM,MAAM,qBAAqB,GAC3B,SAAS,GACT,aAAa,GACb,UAAU,GACV,QAAQ,GACR,SAAS,GACT,WAAW,GACX,UAAU,CAAC;AAEjB;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,qBAAqB,GAAG,SAAS,GAAG,cAAc,CAWjG;AAED,oEAAoE;AACpE,wBAAgB,WAAW,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAE5D;AAED,iGAAiG;AACjG,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,EAAE,CAE7D;AAED,6DAA6D;AAC7D,wBAAgB,eAAe,CAAC,IAAI,EAAE,iBAAiB,GAAG,mBAAmB,EAAE,CAE9E;AAED,iFAAiF;AACjF,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAI3E;AAOD;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,sBAAsB,GAAG,QAAQ,EAAE,CAsB7F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,GAAG,cAAc,EAAE,CA0BvE;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,aAAa,CAa1H;AAED,kDAAkD;AAClD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,aAAa,CASzG;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,aAAa,CAO7E;AAED,yCAAyC;AACzC,wBAAgB,OAAO,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,iBAAiB,GAAG,aAAa,CAEnF;AAED,kEAAkE;AAClE,wBAAgB,UAAU,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,GAAG,aAAa,CAEtG;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAmBnG;AAED,qEAAqE;AACrE,wBAAgB,UAAU,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,SAAS,GAAG,MAAM,CAKvE"}

package/dist/lib/task-graph-canvas-adapter.js

@@ -0,0 +1,244 @@
+/**
+ * @fileoverview Projects a `TaskGraphSpec` onto the generic canvas shapes, and back.
+ *
+ * **Kept pure and separate from the component on purpose.** Everything interesting about rendering a
+ * task graph — which node is an entry point, which edge is conditional, how a runtime status maps to
+ * a visual one, whether removing a node orphans an edge — is decidable from data alone. Putting it
+ * in a component would make it reachable only through a TestBed, and the resulting tests would be
+ * about Angular rather than about graphs.
+ *
+ * **The direction flip, again.** A `TaskGraphSpec` edge points *backwards* (`dependsOn`: "I wait for
+ * X"); a canvas connection points *forwards* (source → target). Same edge, opposite authoring
+ * convention — the graph is written by whoever knows the prerequisites, the canvas drawn by whoever
+ * follows the arrows. This is the second place in the program that inversion appears (Save as
+ * Workflow is the first), which is why it is stated rather than left implicit.
+ *
+ * @module @memberjunction/ng-task-graph-editor
+ */
+import { NormalizeDependency, } from '@memberjunction/ai-core-plus';
+/** Node types the palette offers. Two, because a task is either an agent's or a person's. */
+export const TASK_GRAPH_NODE_TYPES = [
+    {
+        Type: 'AgentTask',
+        Label: 'Agent Step',
+        Icon: 'fa-robot',
+        Color: '#4A6FA5',
+        Category: 'Steps',
+        DefaultPorts: [
+            { ID: 'in', Direction: 'input', Side: 'top', Multiple: true },
+            { ID: 'out', Direction: 'output', Side: 'bottom', Multiple: true },
+        ],
+    },
+    {
+        Type: 'HumanTask',
+        Label: 'Person Step',
+        Icon: 'fa-user-check',
+        Color: '#7B1FA2',
+        Category: 'Steps',
+        DefaultPorts: [
+            { ID: 'in', Direction: 'input', Side: 'top', Multiple: true },
+            { ID: 'out', Direction: 'output', Side: 'bottom', Multiple: true },
+        ],
+    },
+];
+/**
+ * Maps a durable task state onto the canvas's visual vocabulary.
+ *
+ * Two mappings are worth explaining. `Blocked` renders as a **warning**, not an error: nothing went
+ * wrong, the graph simply cannot reach it — showing it as a failure would send someone hunting for a
+ * bug that does not exist. `Deferred` renders as `pending` because, to the person watching, waiting
+ * on a schedule and waiting on a prerequisite look and mean the same thing.
+ */
+export function RuntimeStateToNodeStatus(state) {
+    switch (state) {
+        case 'In Progress': return 'running';
+        case 'Complete': return 'success';
+        case 'Failed': return 'error';
+        case 'Blocked': return 'warning';
+        case 'Cancelled': return 'disabled';
+        case 'Deferred': return 'pending';
+        case 'Pending': return 'pending';
+        default: return 'default';
+    }
+}
+/** True when the node is a person's step rather than an agent's. */
+export function IsHumanTask(node) {
+    return !node.agentName;
+}
+/** Entry points: nodes nothing else has to finish first. Same rule the traversal engine uses. */
+export function GetEntryTempIds(spec) {
+    return (spec.tasks ?? []).filter((t) => (t.dependsOn ?? []).length === 0).map((t) => t.tempId);
+}
+/** Every dependency of a node, in normalized object form. */
+export function GetDependencies(node) {
+    return (node.dependsOn ?? []).map(NormalizeDependency);
+}
+/** The `tempId`s that depend on `tempId` — i.e. what breaks if it is removed. */
+export function GetDependents(spec, tempId) {
+    return (spec.tasks ?? [])
+        .filter((t) => GetDependencies(t).some((d) => d.tempId === tempId))
+        .map((t) => t.tempId);
+}
+/** Deterministic id for a canvas edge, so re-renders don't churn selection. */
+function edgeId(fromTempId, toTempId) {
+    return `${fromTempId}->${toTempId}`;
+}
+/**
+ * Projects the spec onto canvas nodes.
+ *
+ * Positions are left at the origin: layout is the canvas's job (Dagre), and a spec carries no
+ * geometry precisely because a task graph is a *logical* structure. An agent that emitted one never
+ * had an opinion about where the boxes go.
+ */
+export function SpecToNodes(spec, runtime) {
+    const entryIds = new Set(GetEntryTempIds(spec));
+    return (spec.tasks ?? []).map((task) => {
+        const human = IsHumanTask(task);
+        return {
+            ID: task.tempId,
+            Type: human ? 'HumanTask' : 'AgentTask',
+            Label: task.name,
+            Subtitle: human ? 'Waiting on a person' : task.agentName,
+            Icon: human ? 'fa-user-check' : 'fa-robot',
+            Status: RuntimeStateToNodeStatus(runtime?.[task.tempId]),
+            StatusMessage: task.description,
+            IsStartNode: entryIds.has(task.tempId),
+            Position: { X: 0, Y: 0 },
+            Ports: [
+                { ID: 'in', Direction: 'input', Side: 'top', Multiple: true },
+                { ID: 'out', Direction: 'output', Side: 'bottom', Multiple: true },
+            ],
+            Data: { TempId: task.tempId },
+        };
+    });
+}
+/**
+ * Projects the spec's dependencies onto canvas connections, reversing their direction.
+ *
+ * A conditional edge is drawn dashed and labeled with its condition, because the difference between
+ * "always" and "only sometimes" is the single most consequential thing about an edge and the one a
+ * reader is most likely to miss when scanning a diagram.
+ *
+ * Edges naming a task that is not in the graph are skipped rather than drawn dangling — the
+ * validator reports them as `UnknownDependency`, and rendering a connection to nowhere would be a
+ * second, worse way of saying the same thing.
+ */
+export function SpecToConnections(spec) {
+    const known = new Set((spec.tasks ?? []).map((t) => t.tempId));
+    const connections = [];
+    for (const task of spec.tasks ?? []) {
+        for (const dep of GetDependencies(task)) {
+            if (!known.has(dep.tempId))
+                continue;
+            const conditional = !!dep.condition?.trim();
+            connections.push({
+                ID: edgeId(dep.tempId, task.tempId),
+                // Reversed: dependsOn points back at the prerequisite, the drawn arrow points forward.
+                SourceNodeID: dep.tempId,
+                SourcePortID: 'out',
+                TargetNodeID: task.tempId,
+                TargetPortID: 'in',
+                Label: conditional ? 'if' : undefined,
+                LabelDetail: dep.condition ?? undefined,
+                LabelIcon: conditional ? 'fa-code-branch' : undefined,
+                Condition: dep.condition ?? undefined,
+                Style: conditional ? 'dashed' : 'solid',
+                Data: { FromTempId: dep.tempId, ToTempId: task.tempId },
+            });
+        }
+    }
+    return connections;
+}
+/**
+ * Adds a dependency to the spec, returning a NEW spec.
+ *
+ * Immutable because the component emits the result to a host that may keep it, diff it, or reject
+ * it; mutating the input would let a canceled edit leak into the host's copy anyway. A duplicate
+ * edge is a no-op rather than an error — dragging the same connection twice is a slip, not a
+ * request to corrupt the graph.
+ */
+export function AddDependency(spec, fromTempId, toTempId, condition) {
+    return {
+        ...spec,
+        tasks: (spec.tasks ?? []).map((task) => {
+            if (task.tempId !== toTempId)
+                return task;
+            const existing = GetDependencies(task);
+            if (existing.some((d) => d.tempId === fromTempId))
+                return task;
+            const next = condition?.trim()
+                ? { tempId: fromTempId, condition }
+                : fromTempId;
+            return { ...task, dependsOn: [...(task.dependsOn ?? []), next] };
+        }),
+    };
+}
+/** Removes a dependency, returning a NEW spec. */
+export function RemoveDependency(spec, fromTempId, toTempId) {
+    return {
+        ...spec,
+        tasks: (spec.tasks ?? []).map((task) => task.tempId !== toTempId
+            ? task
+            : { ...task, dependsOn: (task.dependsOn ?? []).filter((d) => NormalizeDependency(d).tempId !== fromTempId) }),
+    };
+}
+/**
+ * Removes a task AND every edge into it, returning a NEW spec.
+ *
+ * Severing the inbound edges is not a convenience — leaving them would produce a graph whose
+ * `dependsOn` names a task that no longer exists, which the validator rejects as
+ * `UnknownDependency`. Deleting a box on a canvas should not make the graph invalid.
+ */
+export function RemoveTask(spec, tempId) {
+    return {
+        ...spec,
+        tasks: (spec.tasks ?? [])
+            .filter((t) => t.tempId !== tempId)
+            .map((t) => ({ ...t, dependsOn: (t.dependsOn ?? []).filter((d) => NormalizeDependency(d).tempId !== tempId) })),
+    };
+}
+/** Adds a task, returning a NEW spec. */
+export function AddTask(spec, task) {
+    return { ...spec, tasks: [...(spec.tasks ?? []), task] };
+}
+/** Replaces a task in place by `tempId`, returning a NEW spec. */
+export function UpdateTask(spec, tempId, next) {
+    return { ...spec, tasks: (spec.tasks ?? []).map((t) => (t.tempId === tempId ? next : t)) };
+}
+/**
+ * Would adding `from → to` create a cycle?
+ *
+ * Answered before the edge exists, so the canvas can refuse it rather than create an invalid graph
+ * and report it afterwards. A self-edge is the degenerate case and is caught first.
+ *
+ * Iterative rather than recursive: the graph may come from an LLM, and a deeply-chained spec should
+ * produce a refusal, not a stack overflow.
+ */
+export function WouldCreateCycle(spec, fromTempId, toTempId) {
+    if (fromTempId === toTempId)
+        return true;
+    // A cycle appears iff `from` is already reachable from `to` by following dependsOn edges —
+    // i.e. `to` already (transitively) waits on `from`.
+    const dependenciesOf = new Map((spec.tasks ?? []).map((t) => [t.tempId, GetDependencies(t).map((d) => d.tempId)]));
+    const stack = [...(dependenciesOf.get(fromTempId) ?? [])];
+    const seen = new Set();
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === toTempId)
+            return true;
+        if (seen.has(current))
+            continue;
+        seen.add(current);
+        stack.push(...(dependenciesOf.get(current) ?? []));
+    }
+    return false;
+}
+/** A unique `tempId` for a newly added task, stable and readable. */
+export function NextTempId(spec, prefix = 'task') {
+    const taken = new Set((spec.tasks ?? []).map((t) => t.tempId));
+    let n = (spec.tasks ?? []).length + 1;
+    while (taken.has(`${prefix}${n}`))
+        n++;
+    return `${prefix}${n}`;
+}
+//# sourceMappingURL=task-graph-canvas-adapter.js.map

package/dist/lib/task-graph-canvas-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-graph-canvas-adapter.js","sourceRoot":"","sources":["../../src/lib/task-graph-canvas-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @fileoverview Projects a `TaskGraphSpec` onto the generic canvas shapes, and back.\n *\n * **Kept pure and separate from the component on purpose.** Everything interesting about rendering a\n * task graph — which node is an entry point, which edge is conditional, how a runtime status maps to\n * a visual one, whether removing a node orphans an edge — is decidable from data alone. Putting it\n * in a component would make it reachable only through a TestBed, and the resulting tests would be\n * about Angular rather than about graphs.\n *\n * **The direction flip, again.** A `TaskGraphSpec` edge points *backwards* (`dependsOn`: \"I wait for\n * X\"); a canvas connection points *forwards* (source → target). Same edge, opposite authoring\n * convention — the graph is written by whoever knows the prerequisites, the canvas drawn by whoever\n * follows the arrows. This is the second place in the program that inversion appears (Save as\n * Workflow is the first), which is why it is stated rather than left implicit.\n *\n * @module @memberjunction/ng-task-graph-editor\n */\nimport {\n    NormalizeDependency,\n    type TaskGraphSpec,\n    type TaskGraphSpecNode,\n    type TaskGraphDependency,\n} from '@memberjunction/ai-core-plus';\nimport type { FlowConnection, FlowNode, FlowNodeStatus, FlowNodeTypeConfig } from '@memberjunction/ng-flow-editor';\n\n/** Node types the palette offers. Two, because a task is either an agent's or a person's. */\nexport const TASK_GRAPH_NODE_TYPES: FlowNodeTypeConfig[] = [\n    {\n        Type: 'AgentTask',\n        Label: 'Agent Step',\n        Icon: 'fa-robot',\n        Color: '#4A6FA5',\n        Category: 'Steps',\n        DefaultPorts: [\n            { ID: 'in', Direction: 'input', Side: 'top', Multiple: true },\n            { ID: 'out', Direction: 'output', Side: 'bottom', Multiple: true },\n        ],\n    },\n    {\n        Type: 'HumanTask',\n        Label: 'Person Step',\n        Icon: 'fa-user-check',\n        Color: '#7B1FA2',\n        Category: 'Steps',\n        DefaultPorts: [\n            { ID: 'in', Direction: 'input', Side: 'top', Multiple: true },\n            { ID: 'out', Direction: 'output', Side: 'bottom', Multiple: true },\n        ],\n    },\n];\n\n/** Live per-task state for the runtime overlay, keyed by `tempId`. */\nexport type TaskGraphRuntimeStatus = Record<string, TaskGraphRuntimeState>;\n\n/** What a task is doing right now, in the durable engine's own vocabulary. */\nexport type TaskGraphRuntimeState =\n    | 'Pending'\n    | 'In Progress'\n    | 'Complete'\n    | 'Failed'\n    | 'Blocked'\n    | 'Cancelled'\n    | 'Deferred';\n\n/**\n * Maps a durable task state onto the canvas's visual vocabulary.\n *\n * Two mappings are worth explaining. `Blocked` renders as a **warning**, not an error: nothing went\n * wrong, the graph simply cannot reach it — showing it as a failure would send someone hunting for a\n * bug that does not exist. `Deferred` renders as `pending` because, to the person watching, waiting\n * on a schedule and waiting on a prerequisite look and mean the same thing.\n */\nexport function RuntimeStateToNodeStatus(state: TaskGraphRuntimeState | undefined): FlowNodeStatus {\n    switch (state) {\n        case 'In Progress': return 'running';\n        case 'Complete':    return 'success';\n        case 'Failed':      return 'error';\n        case 'Blocked':     return 'warning';\n        case 'Cancelled':   return 'disabled';\n        case 'Deferred':    return 'pending';\n        case 'Pending':     return 'pending';\n        default:            return 'default';\n    }\n}\n\n/** True when the node is a person's step rather than an agent's. */\nexport function IsHumanTask(node: TaskGraphSpecNode): boolean {\n    return !node.agentName;\n}\n\n/** Entry points: nodes nothing else has to finish first. Same rule the traversal engine uses. */\nexport function GetEntryTempIds(spec: TaskGraphSpec): string[] {\n    return (spec.tasks ?? []).filter((t) => (t.dependsOn ?? []).length === 0).map((t) => t.tempId);\n}\n\n/** Every dependency of a node, in normalized object form. */\nexport function GetDependencies(node: TaskGraphSpecNode): TaskGraphDependency[] {\n    return (node.dependsOn ?? []).map(NormalizeDependency);\n}\n\n/** The `tempId`s that depend on `tempId` — i.e. what breaks if it is removed. */\nexport function GetDependents(spec: TaskGraphSpec, tempId: string): string[] {\n    return (spec.tasks ?? [])\n        .filter((t) => GetDependencies(t).some((d) => d.tempId === tempId))\n        .map((t) => t.tempId);\n}\n\n/** Deterministic id for a canvas edge, so re-renders don't churn selection. */\nfunction edgeId(fromTempId: string, toTempId: string): string {\n    return `${fromTempId}->${toTempId}`;\n}\n\n/**\n * Projects the spec onto canvas nodes.\n *\n * Positions are left at the origin: layout is the canvas's job (Dagre), and a spec carries no\n * geometry precisely because a task graph is a *logical* structure. An agent that emitted one never\n * had an opinion about where the boxes go.\n */\nexport function SpecToNodes(spec: TaskGraphSpec, runtime?: TaskGraphRuntimeStatus): FlowNode[] {\n    const entryIds = new Set(GetEntryTempIds(spec));\n\n    return (spec.tasks ?? []).map((task) => {\n        const human = IsHumanTask(task);\n        return {\n            ID: task.tempId,\n            Type: human ? 'HumanTask' : 'AgentTask',\n            Label: task.name,\n            Subtitle: human ? 'Waiting on a person' : task.agentName,\n            Icon: human ? 'fa-user-check' : 'fa-robot',\n            Status: RuntimeStateToNodeStatus(runtime?.[task.tempId]),\n            StatusMessage: task.description,\n            IsStartNode: entryIds.has(task.tempId),\n            Position: { X: 0, Y: 0 },\n            Ports: [\n                { ID: 'in', Direction: 'input', Side: 'top', Multiple: true },\n                { ID: 'out', Direction: 'output', Side: 'bottom', Multiple: true },\n            ],\n            Data: { TempId: task.tempId },\n        };\n    });\n}\n\n/**\n * Projects the spec's dependencies onto canvas connections, reversing their direction.\n *\n * A conditional edge is drawn dashed and labeled with its condition, because the difference between\n * \"always\" and \"only sometimes\" is the single most consequential thing about an edge and the one a\n * reader is most likely to miss when scanning a diagram.\n *\n * Edges naming a task that is not in the graph are skipped rather than drawn dangling — the\n * validator reports them as `UnknownDependency`, and rendering a connection to nowhere would be a\n * second, worse way of saying the same thing.\n */\nexport function SpecToConnections(spec: TaskGraphSpec): FlowConnection[] {\n    const known = new Set((spec.tasks ?? []).map((t) => t.tempId));\n    const connections: FlowConnection[] = [];\n\n    for (const task of spec.tasks ?? []) {\n        for (const dep of GetDependencies(task)) {\n            if (!known.has(dep.tempId)) continue;\n\n            const conditional = !!dep.condition?.trim();\n            connections.push({\n                ID: edgeId(dep.tempId, task.tempId),\n                // Reversed: dependsOn points back at the prerequisite, the drawn arrow points forward.\n                SourceNodeID: dep.tempId,\n                SourcePortID: 'out',\n                TargetNodeID: task.tempId,\n                TargetPortID: 'in',\n                Label: conditional ? 'if' : undefined,\n                LabelDetail: dep.condition ?? undefined,\n                LabelIcon: conditional ? 'fa-code-branch' : undefined,\n                Condition: dep.condition ?? undefined,\n                Style: conditional ? 'dashed' : 'solid',\n                Data: { FromTempId: dep.tempId, ToTempId: task.tempId },\n            });\n        }\n    }\n    return connections;\n}\n\n/**\n * Adds a dependency to the spec, returning a NEW spec.\n *\n * Immutable because the component emits the result to a host that may keep it, diff it, or reject\n * it; mutating the input would let a canceled edit leak into the host's copy anyway. A duplicate\n * edge is a no-op rather than an error — dragging the same connection twice is a slip, not a\n * request to corrupt the graph.\n */\nexport function AddDependency(spec: TaskGraphSpec, fromTempId: string, toTempId: string, condition?: string): TaskGraphSpec {\n    return {\n        ...spec,\n        tasks: (spec.tasks ?? []).map((task) => {\n            if (task.tempId !== toTempId) return task;\n            const existing = GetDependencies(task);\n            if (existing.some((d) => d.tempId === fromTempId)) return task;\n            const next: TaskGraphDependency | string = condition?.trim()\n                ? { tempId: fromTempId, condition }\n                : fromTempId;\n            return { ...task, dependsOn: [...(task.dependsOn ?? []), next] };\n        }),\n    };\n}\n\n/** Removes a dependency, returning a NEW spec. */\nexport function RemoveDependency(spec: TaskGraphSpec, fromTempId: string, toTempId: string): TaskGraphSpec {\n    return {\n        ...spec,\n        tasks: (spec.tasks ?? []).map((task) =>\n            task.tempId !== toTempId\n                ? task\n                : { ...task, dependsOn: (task.dependsOn ?? []).filter((d) => NormalizeDependency(d).tempId !== fromTempId) },\n        ),\n    };\n}\n\n/**\n * Removes a task AND every edge into it, returning a NEW spec.\n *\n * Severing the inbound edges is not a convenience — leaving them would produce a graph whose\n * `dependsOn` names a task that no longer exists, which the validator rejects as\n * `UnknownDependency`. Deleting a box on a canvas should not make the graph invalid.\n */\nexport function RemoveTask(spec: TaskGraphSpec, tempId: string): TaskGraphSpec {\n    return {\n        ...spec,\n        tasks: (spec.tasks ?? [])\n            .filter((t) => t.tempId !== tempId)\n            .map((t) => ({ ...t, dependsOn: (t.dependsOn ?? []).filter((d) => NormalizeDependency(d).tempId !== tempId) })),\n    };\n}\n\n/** Adds a task, returning a NEW spec. */\nexport function AddTask(spec: TaskGraphSpec, task: TaskGraphSpecNode): TaskGraphSpec {\n    return { ...spec, tasks: [...(spec.tasks ?? []), task] };\n}\n\n/** Replaces a task in place by `tempId`, returning a NEW spec. */\nexport function UpdateTask(spec: TaskGraphSpec, tempId: string, next: TaskGraphSpecNode): TaskGraphSpec {\n    return { ...spec, tasks: (spec.tasks ?? []).map((t) => (t.tempId === tempId ? next : t)) };\n}\n\n/**\n * Would adding `from → to` create a cycle?\n *\n * Answered before the edge exists, so the canvas can refuse it rather than create an invalid graph\n * and report it afterwards. A self-edge is the degenerate case and is caught first.\n *\n * Iterative rather than recursive: the graph may come from an LLM, and a deeply-chained spec should\n * produce a refusal, not a stack overflow.\n */\nexport function WouldCreateCycle(spec: TaskGraphSpec, fromTempId: string, toTempId: string): boolean {\n    if (fromTempId === toTempId) return true;\n\n    // A cycle appears iff `from` is already reachable from `to` by following dependsOn edges —\n    // i.e. `to` already (transitively) waits on `from`.\n    const dependenciesOf = new Map<string, string[]>(\n        (spec.tasks ?? []).map((t) => [t.tempId, GetDependencies(t).map((d) => d.tempId)]),\n    );\n\n    const stack = [...(dependenciesOf.get(fromTempId) ?? [])];\n    const seen = new Set<string>();\n    while (stack.length > 0) {\n        const current = stack.pop()!;\n        if (current === toTempId) return true;\n        if (seen.has(current)) continue;\n        seen.add(current);\n        stack.push(...(dependenciesOf.get(current) ?? []));\n    }\n    return false;\n}\n\n/** A unique `tempId` for a newly added task, stable and readable. */\nexport function NextTempId(spec: TaskGraphSpec, prefix = 'task'): string {\n    const taken = new Set((spec.tasks ?? []).map((t) => t.tempId));\n    let n = (spec.tasks ?? []).length + 1;\n    while (taken.has(`${prefix}${n}`)) n++;\n    return `${prefix}${n}`;\n}\n"]}

package/dist/lib/task-graph-editor-events.d.ts

@@ -0,0 +1,137 @@
+/**
+ * @fileoverview The component's upward contract.
+ *
+ * Follows MJ's `Before*` / `After*` cancelable pattern (see `guides/UI_LAYERING_GUIDE.md` §6),
+ * already used by `ng-base-forms`, `ng-trees`, `ng-entity-viewer` and `ng-conversations`.
+ *
+ * **Why the args are classes and not payload interfaces.** `Cancel` has to travel *back*. Angular's
+ * `EventEmitter` is synchronous for synchronous listeners, so the emitting component reads the
+ * mutated object after `.emit()` returns — that is the entire veto mechanism. A frozen payload
+ * cannot carry a veto, and a class additionally gives one place for defaults and future fields.
+ *
+ * **A `Before*` handler must not be `async`.** An `await` inside it returns control to the emitter
+ * before the handler sets `Cancel`, so the veto silently does nothing. Where a host genuinely needs
+ * to await — a confirmation dialog — the component exposes the action as a public method the host
+ * calls *after* its own await, rather than pretending the veto is asynchronous.
+ *
+ * @module @memberjunction/ng-task-graph-editor
+ */
+import type { TaskGraphSpec, TaskGraphSpecNode, TaskGraphValidationError } from '@memberjunction/ai-core-plus';
+/**
+ * Base for every cancelable graph event.
+ *
+ * A listener flips `Cancel = true` to halt the default behavior; the matching `After*` event will
+ * then **not** fire. That is a contract hosts rely on, not a suggestion.
+ */
+export declare class CancellableTaskGraphEventArgs {
+    Cancel: boolean;
+    CancelReason?: string;
+}
+/** Fired BEFORE a task is added. Cancel to block it (e.g. the host caps graph size). */
+export declare class BeforeTaskAddedEventArgs extends CancellableTaskGraphEventArgs {
+    readonly Task: TaskGraphSpecNode;
+    constructor(Task: TaskGraphSpecNode);
+}
+/** Fired AFTER a task was added. NOT fired when the Before was canceled. */
+export declare class AfterTaskAddedEventArgs {
+    readonly Task: TaskGraphSpecNode;
+    readonly Spec: TaskGraphSpec;
+    constructor(Task: TaskGraphSpecNode, Spec: TaskGraphSpec);
+}
+/**
+ * Fired BEFORE a task is removed. Cancel to block it.
+ *
+ * `DependentTempIds` is supplied because removing a node also severs every edge into it, and a host
+ * deciding whether to veto needs to know the blast radius — not just which node was clicked.
+ */
+export declare class BeforeTaskRemovedEventArgs extends CancellableTaskGraphEventArgs {
+    readonly Task: TaskGraphSpecNode;
+    readonly DependentTempIds: readonly string[];
+    constructor(Task: TaskGraphSpecNode, DependentTempIds: readonly string[]);
+}
+/** Fired AFTER a task was removed. NOT fired when the Before was canceled. */
+export declare class AfterTaskRemovedEventArgs {
+    readonly Task: TaskGraphSpecNode;
+    readonly Spec: TaskGraphSpec;
+    constructor(Task: TaskGraphSpecNode, Spec: TaskGraphSpec);
+}
+/** Fired BEFORE a task's properties change. Cancel to block the edit. */
+export declare class BeforeTaskUpdatedEventArgs extends CancellableTaskGraphEventArgs {
+    readonly Previous: TaskGraphSpecNode;
+    readonly Next: TaskGraphSpecNode;
+    constructor(Previous: TaskGraphSpecNode, Next: TaskGraphSpecNode);
+}
+/** Fired AFTER a task's properties changed. NOT fired when the Before was canceled. */
+export declare class AfterTaskUpdatedEventArgs {
+    readonly Task: TaskGraphSpecNode;
+    readonly Spec: TaskGraphSpec;
+    constructor(Task: TaskGraphSpecNode, Spec: TaskGraphSpec);
+}
+/**
+ * Fired BEFORE a dependency edge is created. Cancel to block it.
+ *
+ * `WouldCreateCycle` is computed before emitting so a host can veto on that alone without
+ * re-deriving it. The component refuses a cycle regardless — the flag exists so the host can
+ * explain *why* rather than watch an edge silently fail to appear.
+ */
+export declare class BeforeDependencyAddedEventArgs extends CancellableTaskGraphEventArgs {
+    readonly FromTempId: string;
+    readonly ToTempId: string;
+    readonly WouldCreateCycle: boolean;
+    constructor(FromTempId: string, ToTempId: string, WouldCreateCycle: boolean);
+}
+/** Fired AFTER a dependency edge was created. NOT fired when the Before was canceled. */
+export declare class AfterDependencyAddedEventArgs {
+    readonly FromTempId: string;
+    readonly ToTempId: string;
+    readonly Spec: TaskGraphSpec;
+    constructor(FromTempId: string, ToTempId: string, Spec: TaskGraphSpec);
+}
+/** Fired BEFORE a dependency edge is removed. Cancel to block it. */
+export declare class BeforeDependencyRemovedEventArgs extends CancellableTaskGraphEventArgs {
+    readonly FromTempId: string;
+    readonly ToTempId: string;
+    constructor(FromTempId: string, ToTempId: string);
+}
+/** Fired AFTER a dependency edge was removed. NOT fired when the Before was canceled. */
+export declare class AfterDependencyRemovedEventArgs {
+    readonly FromTempId: string;
+    readonly ToTempId: string;
+    readonly Spec: TaskGraphSpec;
+    constructor(FromTempId: string, ToTempId: string, Spec: TaskGraphSpec);
+}
+/** The spec changed for any reason. Hosts persist from here. */
+export declare class TaskGraphSpecChangedEventArgs {
+    readonly Spec: TaskGraphSpec;
+    readonly Reason: 'TaskAdded' | 'TaskRemoved' | 'TaskUpdated' | 'DependencyAdded' | 'DependencyRemoved' | 'LayoutApplied';
+    constructor(Spec: TaskGraphSpec, Reason: 'TaskAdded' | 'TaskRemoved' | 'TaskUpdated' | 'DependencyAdded' | 'DependencyRemoved' | 'LayoutApplied');
+}
+/** Selection changed. `Task` is null when the selection was cleared. */
+export declare class TaskGraphSelectionChangedEventArgs {
+    readonly Task: TaskGraphSpecNode | null;
+    constructor(Task: TaskGraphSpecNode | null);
+}
+/**
+ * Validation ran.
+ *
+ * Errors come from the engine's own `ValidateTaskGraphSpec`, not from a second implementation here —
+ * so a graph that looks valid on the canvas cannot fail a different check at submission.
+ */
+export declare class TaskGraphValidationChangedEventArgs {
+    readonly Valid: boolean;
+    readonly Errors: readonly TaskGraphValidationError[];
+    constructor(Valid: boolean, Errors: readonly TaskGraphValidationError[]);
+}
+/** The user asked to open the agent behind a task. The host navigates. */
+export declare class AgentOpenRequestedEventArgs {
+    readonly AgentName: string;
+    readonly Task: TaskGraphSpecNode;
+    constructor(AgentName: string, Task: TaskGraphSpecNode);
+}
+/** The user asked to open a record referenced by the graph. The host navigates. */
+export declare class RecordOpenRequestedEventArgs {
+    readonly EntityName: string;
+    readonly RecordID: string;
+    constructor(EntityName: string, RecordID: string);
+}
+//# sourceMappingURL=task-graph-editor-events.d.ts.map

package/dist/lib/task-graph-editor-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-graph-editor-events.d.ts","sourceRoot":"","sources":["../../src/lib/task-graph-editor-events.ts"],"names":[],"mappings":"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"}