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

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,195 @@
+/**
+ * @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, FlowPosition } from '@memberjunction/ng-flow-editor';
+/**
+ * The shapes this canvas can DRAW.
+ *
+ * Three of the spec's seven `kind`s, and the choice is the canvas's: these are the shapes a person
+ * authors. `Prompt`, `ForEach`, `While` and `External` are expressible in the spec but have no
+ * authoring affordance here — a palette entry that cannot be configured would be worse than none.
+ *
+ * **Drawing and RENDERING are different questions**, which this type used to conflate. A run's
+ * graph is displayed on the same canvas, and it contains kinds nobody can draw — so mapping them
+ * all to `AgentTask` made a fully-configured ForEach render as "AGENT STEP · No agent chosen yet",
+ * which is not merely imprecise: it says the step is broken. See {@link TaskGraphRenderType}.
+ */
+export type TaskGraphNodeType = 'AgentTask' | 'ActionTask' | 'HumanTask';
+/**
+ * The shapes this canvas can SHOW — a superset of what it can draw.
+ *
+ * Display-only kinds exist because a task graph is rendered in two places: the editor, where a
+ * person builds one, and a run view, where one that already ran is shown. The second must be able
+ * to depict every kind the dispatcher can execute, whether or not the palette offers it.
+ */
+export type TaskGraphRenderType = TaskGraphNodeType | 'PromptTask' | 'ForEachTask' | 'WhileTask' | 'ExternalTask';
+/** A palette entry, pinned to one of the three authorable shapes. */
+export type TaskGraphNodeTypeConfig = FlowNodeTypeConfig & {
+    Type: TaskGraphNodeType;
+};
+/**
+ * Whether a shape is one a person can actually author here.
+ *
+ * The authoring paths — the palette, `NewTaskFromNodeType`, the properties panel — only handle the
+ * three drawable shapes. Rendering handles more. This is the seam between the two, stated as a type
+ * guard so the compiler enforces it rather than a cast pretending the distinction does not exist.
+ */
+export declare function IsAuthorableNodeType(type: TaskGraphRenderType): type is TaskGraphNodeType;
+/** A rendering entry — every shape the canvas can depict, authorable or not. */
+export type TaskGraphRenderTypeConfig = FlowNodeTypeConfig & {
+    Type: TaskGraphRenderType;
+};
+/** What the palette offers — one entry per assignment shape the spec supports. */
+export declare const TASK_GRAPH_NODE_TYPES: readonly TaskGraphNodeTypeConfig[];
+/**
+ * Everything the canvas can DEPICT: the palette, plus the kinds that only ever arrive from a run.
+ *
+ * Deliberately a superset rather than an extension of the palette — adding these to
+ * `TASK_GRAPH_NODE_TYPES` would put un-configurable entries in the authoring toolbox.
+ */
+export declare const TASK_GRAPH_RENDER_TYPES: readonly TaskGraphRenderTypeConfig[];
+/**
+ * The config for a node type, or null when the type is not one of ours.
+ *
+ * Searches the RENDER set, so a run's ForEach resolves to its own icon and label instead of
+ * silently falling back to the agent shape.
+ */
+export declare function GetNodeTypeConfig(type: string): TaskGraphRenderTypeConfig | null;
+/** 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.
+ *
+ * One field decides it now: spec v2 gives every node exactly one `kind`, so "is this a person's
+ * step" stopped being an inference over three optional flags and became a comparison.
+ */
+export declare function IsHumanTask(node: TaskGraphSpecNode): boolean;
+/**
+ * Which of the three shapes a node is, for rendering.
+ *
+ * An unassigned node (just added, nothing picked yet) reads as an agent step: it is the commonest
+ * intent, and the validator is already telling the author, in words, that it needs an assignee.
+ * Guessing "person" instead — which is what the old `!agentName` rule did — put a step in the
+ * graph that claimed to be waiting on someone when nobody had said so.
+ */
+export declare function GetTaskNodeType(node: TaskGraphSpecNode): TaskGraphRenderType;
+/**
+ * Builds the task a palette entry stands for.
+ *
+ * Pure, and here rather than in the component, because "what does clicking *Person Step* actually
+ * put in the graph" is a fact about the spec — testable without a TestBed, and the one place the
+ * assignment xor is honoured on creation.
+ *
+ * `defaultAgentName` / `defaultActionName` are what the host has to offer. When it has nothing, the
+ * step is created unassigned on purpose: inventing an agent name that may not exist would produce a
+ * graph that passes the canvas and fails at submission, whereas an unassigned step is reported
+ * immediately by the same validator the engine runs.
+ */
+export declare function NewTaskFromNodeType(spec: TaskGraphSpec, type: TaskGraphNodeType, defaults?: {
+    agentName?: string;
+    actionName?: string;
+}): TaskGraphSpecNode;
+/** 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.
+ */
+/**
+ * Projects the spec onto canvas nodes.
+ *
+ * `positions` carries geometry the spec cannot hold. `TaskGraphSpec` is an execution contract with
+ * no layout field, so without a caller-held map every re-projection would return every node to the
+ * origin — which is what previously forced a full re-arrange (and a viewport re-zoom) after every
+ * single edit. Unknown ids fall back to the origin, which is also the correct starting state for a
+ * graph that has never been laid out.
+ */
+export declare function SpecToNodes(spec: TaskGraphSpec, runtime?: TaskGraphRuntimeStatus, positions?: ReadonlyMap<string, FlowPosition>): FlowNode[];
+/**
+ * The one line under a node's name: who or what runs it.
+ *
+ * An unassigned step says so rather than showing nothing — a blank subtitle looks like a step that
+ * is fine, and this one is the reason the validation banner is complaining.
+ */
+export declare function TaskSubtitle(task: TaskGraphSpecNode, type?: TaskGraphRenderType): string;
+/**
+ * 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":"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"}

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

@@ -0,0 +1,380 @@
+/**
+ * @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 { ConfigOf, NormalizeDependency, TaskNode, } from '@memberjunction/ai-core-plus';
+/**
+ * Whether a shape is one a person can actually author here.
+ *
+ * The authoring paths — the palette, `NewTaskFromNodeType`, the properties panel — only handle the
+ * three drawable shapes. Rendering handles more. This is the seam between the two, stated as a type
+ * guard so the compiler enforces it rather than a cast pretending the distinction does not exist.
+ */
+export function IsAuthorableNodeType(type) {
+    return type === 'AgentTask' || type === 'ActionTask' || type === 'HumanTask';
+}
+const TASK_GRAPH_PORTS = [
+    { ID: 'in', Direction: 'input', Side: 'top', Multiple: true },
+    { ID: 'out', Direction: 'output', Side: 'bottom', Multiple: true },
+];
+/** What the palette offers — one entry per assignment shape the spec supports. */
+export const TASK_GRAPH_NODE_TYPES = [
+    {
+        Type: 'AgentTask',
+        Label: 'Agent Step',
+        Icon: 'fa-robot',
+        Color: '#4A6FA5',
+        Category: 'Steps',
+        DefaultPorts: TASK_GRAPH_PORTS,
+    },
+    {
+        Type: 'ActionTask',
+        Label: 'Action Step',
+        Icon: 'fa-bolt',
+        Color: '#3B82F6',
+        Category: 'Steps',
+        DefaultPorts: TASK_GRAPH_PORTS,
+    },
+    {
+        Type: 'HumanTask',
+        Label: 'Person Step',
+        Icon: 'fa-user-check',
+        Color: '#7B1FA2',
+        Category: 'Steps',
+        DefaultPorts: TASK_GRAPH_PORTS,
+    },
+];
+/**
+ * Everything the canvas can DEPICT: the palette, plus the kinds that only ever arrive from a run.
+ *
+ * Deliberately a superset rather than an extension of the palette — adding these to
+ * `TASK_GRAPH_NODE_TYPES` would put un-configurable entries in the authoring toolbox.
+ */
+export const TASK_GRAPH_RENDER_TYPES = [
+    ...TASK_GRAPH_NODE_TYPES,
+    { Type: 'PromptTask', Label: 'Prompt Step', Icon: 'fa-comment-dots', Color: '#8B5CF6', Category: 'Steps', DefaultPorts: TASK_GRAPH_PORTS },
+    { Type: 'ForEachTask', Label: 'For Each Step', Icon: 'fa-repeat', Color: '#D97706', Category: 'Steps', DefaultPorts: TASK_GRAPH_PORTS },
+    { Type: 'WhileTask', Label: 'While Step', Icon: 'fa-rotate', Color: '#D97706', Category: 'Steps', DefaultPorts: TASK_GRAPH_PORTS },
+    { Type: 'ExternalTask', Label: 'External Step', Icon: 'fa-arrow-up-right-from-square', Color: '#0891B2', Category: 'Steps', DefaultPorts: TASK_GRAPH_PORTS },
+];
+/**
+ * The config for a node type, or null when the type is not one of ours.
+ *
+ * Searches the RENDER set, so a run's ForEach resolves to its own icon and label instead of
+ * silently falling back to the agent shape.
+ */
+export function GetNodeTypeConfig(type) {
+    return TASK_GRAPH_RENDER_TYPES.find((c) => c.Type === type) ?? null;
+}
+/**
+ * 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.
+ *
+ * One field decides it now: spec v2 gives every node exactly one `kind`, so "is this a person's
+ * step" stopped being an inference over three optional flags and became a comparison.
+ */
+export function IsHumanTask(node) {
+    return node.kind === 'Human';
+}
+/**
+ * Which of the three shapes a node is, for rendering.
+ *
+ * An unassigned node (just added, nothing picked yet) reads as an agent step: it is the commonest
+ * intent, and the validator is already telling the author, in words, that it needs an assignee.
+ * Guessing "person" instead — which is what the old `!agentName` rule did — put a step in the
+ * graph that claimed to be waiting on someone when nobody had said so.
+ */
+export function GetTaskNodeType(node) {
+    switch (node.kind) {
+        case 'Human': return 'HumanTask';
+        case 'Action': return 'ActionTask';
+        case 'Prompt': return 'PromptTask';
+        case 'ForEach': return 'ForEachTask';
+        case 'While': return 'WhileTask';
+        case 'External': return 'ExternalTask';
+        // An unassigned node — just added, nothing picked — reads as an agent step: the commonest
+        // intent, and the validator is already saying in words that it needs an assignee.
+        default: return 'AgentTask';
+    }
+}
+/**
+ * Builds the task a palette entry stands for.
+ *
+ * Pure, and here rather than in the component, because "what does clicking *Person Step* actually
+ * put in the graph" is a fact about the spec — testable without a TestBed, and the one place the
+ * assignment xor is honoured on creation.
+ *
+ * `defaultAgentName` / `defaultActionName` are what the host has to offer. When it has nothing, the
+ * step is created unassigned on purpose: inventing an agent name that may not exist would produce a
+ * graph that passes the canvas and fails at submission, whereas an unassigned step is reported
+ * immediately by the same validator the engine runs.
+ */
+export function NewTaskFromNodeType(spec, type, defaults = {}) {
+    const base = {
+        tempId: NextTempId(spec),
+        name: NEW_TASK_NAMES[type],
+        description: '',
+        dependsOn: [],
+    };
+    switch (type) {
+        case 'HumanTask': return TaskNode.Human(base);
+        // A step created before the host has any names to offer is created with an empty one on
+        // purpose: the validator reports it immediately, whereas inventing a name would produce a
+        // graph that passes here and fails at submission.
+        case 'ActionTask': return TaskNode.Action(base, { actionName: defaults.actionName ?? '' });
+        default: return TaskNode.Agent(base, { agentName: defaults.agentName ?? '' });
+    }
+}
+/** Default step names, so a new box says what it is before the author renames it. */
+const NEW_TASK_NAMES = {
+    AgentTask: 'New agent step',
+    ActionTask: 'New action step',
+    HumanTask: 'New person step',
+};
+/** 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.
+ */
+/**
+ * Projects the spec onto canvas nodes.
+ *
+ * `positions` carries geometry the spec cannot hold. `TaskGraphSpec` is an execution contract with
+ * no layout field, so without a caller-held map every re-projection would return every node to the
+ * origin — which is what previously forced a full re-arrange (and a viewport re-zoom) after every
+ * single edit. Unknown ids fall back to the origin, which is also the correct starting state for a
+ * graph that has never been laid out.
+ */
+export function SpecToNodes(spec, runtime, positions) {
+    const entryIds = new Set(GetEntryTempIds(spec));
+    return (spec.tasks ?? []).map((task) => {
+        const type = GetTaskNodeType(task);
+        const known = positions?.get(task.tempId);
+        return {
+            ID: task.tempId,
+            Type: type,
+            Label: task.name,
+            Subtitle: TaskSubtitle(task, type),
+            Icon: GetNodeTypeConfig(type)?.Icon ?? 'fa-circle-nodes',
+            Status: RuntimeStateToNodeStatus(runtime?.[task.tempId]),
+            StatusMessage: task.description,
+            IsStartNode: entryIds.has(task.tempId),
+            Position: known ? { ...known } : { 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 },
+        };
+    });
+}
+/**
+ * The one line under a node's name: who or what runs it.
+ *
+ * An unassigned step says so rather than showing nothing — a blank subtitle looks like a step that
+ * is fine, and this one is the reason the validation banner is complaining.
+ */
+export function TaskSubtitle(task, type = GetTaskNodeType(task)) {
+    switch (type) {
+        case 'HumanTask': return 'Waiting on a person';
+        case 'ActionTask': return ConfigOf(task, 'Action')?.actionName || 'No action chosen yet';
+        case 'PromptTask': return ConfigOf(task, 'Prompt')?.promptName || 'No prompt chosen yet';
+        // A loop's subtitle is what it REPEATS — the one fact that makes the node readable.
+        case 'ForEachTask': return LoopBodyLabel(ConfigOf(task, 'ForEach')) ?? 'Repeats for each item';
+        case 'WhileTask': return LoopBodyLabel(ConfigOf(task, 'While')) ?? 'Repeats until its condition is false';
+        case 'ExternalTask': return ConfigOf(task, 'External')?.domain || 'Completed by an outside system';
+        // Only a genuinely unassigned node reaches this now. It used to catch Prompt, ForEach,
+        // While and External too — so a fully-configured loop displayed "No agent chosen yet",
+        // which reads as a broken step rather than an unrecognised one.
+        default: return ConfigOf(task, 'Agent')?.agentName || 'No agent chosen yet';
+    }
+}
+/** What a loop repeats, when it says. */
+function LoopBodyLabel(op) {
+    if (!op)
+        return null;
+    const body = op.action?.name ?? op.subAgent?.name ?? op.prompt?.name;
+    return body ? `Repeats: ${body}` : null;
+}
+/**
+ * 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