@arbidocs/blocks 0.4.72 → 0.4.73

package/dist/workflow-canvas/WorkflowBuilder.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Build a workflow visually: what starts it (the trigger node), its named steps (forms, uploads,
+ * agent steps running a skill or an instruction, branches, a person's approval), wired on a
+ * canvas, each set in the inspector; and a preview of a run (the real runner with a stand-in
+ * agent). The value saves as a workflow (`builderToWorkflowRequest`): every firing is a work
+ * thread that runs the steps.
+ */
+import { type ReactNode } from 'react';
+import { type AgentOption, type StepComposeOptions, type WorkflowDefinition, type WorkflowGraphProblem } from '../agents';
+import { type StepInspectorLabels } from './StepInspector';
+import { type TriggerInspectorLabels } from './TriggerInspector';
+import type { WorkflowBuilderValue } from './trigger';
+import { type WorkflowCanvasLabels } from './WorkflowCanvas';
+export interface WorkflowBuilderLabels {
+    addStep: string;
+    tidy: string;
+    settings: string;
+    closePanel: string;
+    design: string;
+    preview: string;
+    /** The trigger node's heading. */
+    start: string;
+    /** What the preview's stand-in agent answers; `{prompt}` is replaced. */
+    previewAnswer: string;
+    problems: Record<WorkflowGraphProblem['code'], string>;
+}
+export declare const DEFAULT_WORKFLOW_BUILDER_LABELS: WorkflowBuilderLabels;
+export interface WorkflowBuilderProps extends Pick<StepComposeOptions, 'compose'> {
+    value: WorkflowBuilderValue;
+    onChange: (value: WorkflowBuilderValue) => void;
+    /** What agent steps can run (skills and other workflows); the preview composes from them. */
+    workflows?: WorkflowDefinition[];
+    /** Who can run it. */
+    agents?: AgentOption[];
+    /** The workspace events it can start on. */
+    eventKinds?: Array<{
+        value: string;
+        label: string;
+    }>;
+    /** Tasks it can wait on. */
+    tasks?: Array<{
+        value: string;
+        label: string;
+    }>;
+    renderIcon?: (key: string) => ReactNode;
+    /** The host's buttons (save, run). */
+    actions?: ReactNode;
+    labels?: Partial<WorkflowBuilderLabels>;
+    canvasLabels?: Partial<WorkflowCanvasLabels>;
+    inspectorLabels?: Partial<StepInspectorLabels>;
+    triggerLabels?: Partial<TriggerInspectorLabels>;
+    testId?: string;
+    className?: string;
+}
+export declare function WorkflowBuilder({ value, onChange, workflows, agents, eventKinds, tasks, compose, renderIcon, actions, labels, canvasLabels, inspectorLabels, triggerLabels, testId, className, }: WorkflowBuilderProps): import("react").JSX.Element;

package/dist/workflow-canvas/WorkflowCanvas.d.ts

@@ -0,0 +1,65 @@
+/**
+ * A workflow as a graph on a canvas: its start, then each step a card, each "waits for" an edge.
+ * Build by clicking "+" on a card (the next step lands beside it), drag to arrange, draw from a
+ * card's right handle to another's left to make it wait, select and press Delete to remove.
+ * Read-only with live `phases` it shows a run's progress on the same graph.
+ */
+import { type ReactNode } from 'react';
+import { type WorkflowDefinition, type WorkflowStepPhase } from '../agents';
+import { type WorkflowStepKind } from './edit';
+export interface WorkflowCanvasLabels {
+    form: string;
+    upload: string;
+    agent: string;
+    review: string;
+    /** An agent step that runs on a branch and delivers its result to the thread. */
+    branch: string;
+    /** What each kind is for, in the "+" menu. */
+    kindHints: Record<WorkflowStepKind, string>;
+    addNext: string;
+    /** Summaries on the cards. */
+    runs: string;
+    instruction: string;
+    fields: string;
+    noFields: string;
+    approvedBy: string;
+    emptyTitle: string;
+    emptyHint: string;
+}
+export declare const DEFAULT_WORKFLOW_CANVAS_LABELS: WorkflowCanvasLabels;
+export interface WorkflowCanvasProps {
+    workflow: WorkflowDefinition;
+    /** Edits (move, connect, disconnect, delete). Absent = read-only. */
+    onChange?: (workflow: WorkflowDefinition) => void;
+    selected?: string | null;
+    onSelect?: (stepId: string | null) => void;
+    /** Add a step after this one (`TRIGGER_NODE`: one that starts with the run). Absent = no "+". */
+    onAddAfter?: (stepId: string, kind: WorkflowStepKind) => void;
+    /** A run's progress, by step id: colours the nodes. */
+    phases?: Record<string, WorkflowStepPhase>;
+    /** Names the workflow an agent step runs (its card's summary). */
+    workflowTitle?: (id: string) => string | undefined;
+    /**
+     * The workflow's start, drawn as the first node (id `TRIGGER_NODE`): an edge from it into each
+     * step that starts with the run. Drawing one from it into a step makes that step start the run.
+     */
+    trigger?: {
+        title: string;
+        summary: string;
+    };
+    renderIcon?: (key: string) => ReactNode;
+    labels?: Partial<WorkflowCanvasLabels>;
+    className?: string;
+    /** Pixels on the right covered by a floating panel: the opening view keeps clear of them. */
+    reserveRight?: number;
+    testId?: string;
+}
+/** The id of the trigger node (selecting it selects the workflow's start). */
+export declare const TRIGGER_NODE = "__trigger";
+export declare const STEP_KIND_ICONS: {
+    readonly form: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly upload: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly agent: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly review: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+};
+export declare function WorkflowCanvas({ workflow, onChange, selected, onSelect, onAddAfter, phases, workflowTitle, trigger, renderIcon, labels, className, reserveRight, testId, }: WorkflowCanvasProps): import("react").JSX.Element;

package/dist/workflow-canvas/edit.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Editing a stepped workflow as a graph: the designer's operations, pure so they are tested on
+ * their own. Every result keeps the steps in dependency order with every edge written out
+ * (`after`), so a reordering never changes what a step waits for.
+ */
+import { type WorkflowDefinition, type WorkflowStep } from '../agents';
+type Steps = Extract<WorkflowDefinition['run'], {
+    kind: 'steps';
+}>;
+export type WorkflowLayout = NonNullable<Steps['layout']>;
+export type WorkflowStepKind = WorkflowStep['kind'];
+/** A new, empty stepped workflow. */
+export declare function newSteppedWorkflow(id: string, title: string): WorkflowDefinition;
+/** A step id from a title: lowercase words joined by hyphens, unique within the workflow. */
+export declare function stepIdFor(steps: WorkflowStep[], title: string): string;
+/**
+ * Add a step. With `after`, it waits for that step (the usual "add the next step"); otherwise it
+ * starts with the run. Resolves with the workflow and the new step's id.
+ */
+export declare function addStep(workflow: WorkflowDefinition, kind: WorkflowStepKind, options?: {
+    after?: string;
+    title?: string;
+    position?: {
+        x: number;
+        y: number;
+    };
+}): {
+    workflow: WorkflowDefinition;
+    id: string;
+};
+/** Remove a step; what waited for it waits for what it waited for instead (the chain holds). */
+export declare function removeStep(workflow: WorkflowDefinition, id: string): WorkflowDefinition;
+/** `to` now waits for `from`. Refused (unchanged) when that would make a cycle. */
+export declare function connectSteps(workflow: WorkflowDefinition, from: string, to: string): WorkflowDefinition;
+export declare const wouldCycle: (workflow: WorkflowDefinition, from: string, to: string) => boolean;
+/** `to` no longer waits for `from`. */
+export declare function disconnectSteps(workflow: WorkflowDefinition, from: string, to: string): WorkflowDefinition;
+/** Change a step's settings (its id and kind stay). */
+export declare function updateStep(workflow: WorkflowDefinition, id: string, patch: Partial<WorkflowStep>): WorkflowDefinition;
+/**
+ * A run input renamed (a form field's code following its label): every step that reads it is
+ * updated, so the workflow keeps working.
+ */
+export declare function renameInput(workflow: WorkflowDefinition, from: string, to: string): WorkflowDefinition;
+/** Where a step sits on the canvas. */
+export declare function moveStep(workflow: WorkflowDefinition, id: string, position: {
+    x: number;
+    y: number;
+}): WorkflowDefinition;
+/** Positions by depth: columns left to right, parallel steps stacked. */
+export declare function autoLayout(steps: WorkflowStep[]): WorkflowLayout;
+/** The workflow's layout, with any unplaced step placed by depth. */
+export declare function layoutWithDefaults(workflow: WorkflowDefinition): WorkflowLayout;
+export {};