groundswell 0.0.2 → 1.0.0

package/dist/core/workflow.d.ts

@@ -0,0 +1,543 @@
+import type { WorkflowNode, WorkflowStatus, WorkflowEvent, WorkflowObserver, SerializedWorkflowState, WorkflowError } from '../types/index.js';
+import type { WorkflowContext, WorkflowConfig, WorkflowResult } from '../types/workflow-context.js';
+import type { AgentResponse } from '../types/agent.js';
+import { z } from 'zod';
+import { WorkflowLogger } from './logger.js';
+/**
+ * Executor function type for functional workflows
+ */
+export type WorkflowExecutor<T = unknown> = (ctx: WorkflowContext) => Promise<T>;
+/**
+ * Options for restarting a step
+ */
+export interface RestartStepOptions {
+    /** Current retry count (will be incremented by 1 for the attempt) */
+    retryCount?: number;
+    /** Maximum number of retries allowed (overrides step default) */
+    maxRetries?: number;
+    /** Override state to restore (defaults to current snapshot) */
+    stateOverride?: SerializedWorkflowState;
+}
+/**
+ * Options for replaying historical events
+ */
+interface ReplayEventsOptions {
+    /** Only replay events after this timestamp (milliseconds since epoch) */
+    since?: number;
+    /** Maximum number of events to replay */
+    limit?: number;
+}
+/**
+ * Base class for all workflows
+ * Supports both class-based (subclass with run()) and functional (executor) patterns
+ *
+ * @example Class-based pattern:
+ * ```ts
+ * class MyWorkflow extends Workflow {
+ *   async run() {
+ *     this.setStatus('running');
+ *     // workflow logic
+ *     this.setStatus('completed');
+ *   }
+ * }
+ * ```
+ *
+ * @example Functional pattern:
+ * ```ts
+ * const workflow = new Workflow({ name: 'MyWorkflow' }, async (ctx) => {
+ *   await ctx.step('step1', async () => {
+ *     // step logic
+ *   });
+ * });
+ * await workflow.run();
+ * ```
+ */
+export declare class Workflow<T = unknown> {
+    #private;
+    /** Unique identifier for this workflow instance */
+    readonly id: string;
+    /** Parent workflow (null for root workflows) */
+    parent: Workflow | null;
+    /** Child workflows */
+    children: Workflow[];
+    /** Current execution status */
+    status: WorkflowStatus;
+    /** Logger instance for this workflow */
+    protected readonly logger: WorkflowLogger;
+    /** The node representation of this workflow */
+    readonly node: WorkflowNode;
+    /** Observers (only populated on root workflow) */
+    private observers;
+    /** Optional executor function for functional workflows */
+    private executor?;
+    /** Workflow configuration */
+    private config;
+    /** Error collection state for workflow-level error merge */
+    private collectedErrors;
+    /** Total operations count for error merge context */
+    private totalOperations;
+    /** Operation counter for error merge context */
+    private operationCounter;
+    /**
+     * Create a new workflow instance
+     *
+     * @overload Class-based pattern: constructor(name?: string, parent?: Workflow)
+     * @overload Functional pattern: constructor(config: WorkflowConfig, executor?: WorkflowExecutor)
+     * @param name For class-based pattern, human-readable name. Allowed characters: alphanumeric (a-z, A-Z, 0-9), spaces, hyphens (-), underscores (_). (default: class name).
+     * For functional pattern, config object with workflow settings.
+     * @param parentOrExecutor For class-based pattern, optional parent workflow.
+     * For functional pattern, executor function.
+     *
+     * @remarks Security validation rejects names containing control characters, HTML tags, JavaScript patterns, path traversal sequences (..), and file system special characters (/ \ : * ? " < > |). This prevents XSS attacks, injection attacks, and path traversal vulnerabilities.
+     */
+    constructor(name?: string | WorkflowConfig, parentOrExecutor?: Workflow | WorkflowExecutor<T>);
+    /**
+     * Get observers from the root workflow
+     * Traverses up the tree to find the root
+     * Uses cycle detection to prevent infinite loops from circular parent-child relationships
+     */
+    private getRootObservers;
+    /**
+     * Check if event history is enabled for this workflow
+     *
+     * @returns true if event history is enabled, false otherwise
+     */
+    private isEventHistoryEnabled;
+    /**
+     * Get event history configuration with defaults applied
+     *
+     * @returns Configuration object with all required fields populated
+     */
+    private getEventHistoryConfig;
+    /**
+     * Trim event history based on configuration
+     *
+     * Uses lazy trimming for performance:
+     * - Only trims when at least 1.5x over the maxEvents limit
+     * - Applies both count and age constraints
+     * - Uses slice() for efficiency (not shift())
+     *
+     * @remarks
+     * Lazy trimming reduces the number of trim operations by only trimming
+     * when the history is significantly over the limit (1.5x). This provides
+     * better performance for high-frequency event emission.
+     */
+    private trimEventHistory;
+    /**
+     * Check if this workflow is a descendant of the given ancestor workflow.
+     *
+     * Traverses the parent chain upward looking for the ancestor reference.
+     * Uses a visited Set to detect cycles during traversal. This method provides
+     * a convenient way to check workflow hierarchy relationships without manually
+     * traversing the parent chain.
+     *
+     * @remarks SECURITY WARNING: This method reveals workflow hierarchy information.
+     * If your application exposes workflows via an API, ensure you implement proper
+     * access control to prevent unauthorized topology discovery. Note that the parent
+     * and children properties are already public, so this method does not expose any
+     * new information beyond what is currently accessible.
+     *
+     * **Time Complexity**: O(d) where d is the depth of the hierarchy
+     * **Space Complexity**: O(d) for the visited Set in worst case (cycle detection)
+     *
+     * @example Check if a workflow belongs to a specific hierarchy
+     * ```typescript
+     * const root = new Workflow('root');
+     * const child = new Workflow('child', { parent: root });
+     *
+     * if (child.isDescendantOf(root)) {
+     *   console.log('Child is in root hierarchy');
+     * }
+     * ```
+     *
+     * @example Validate before attaching to prevent circular references
+     * ```typescript
+     * if (!newChild.isDescendantOf(parent)) {
+     *   parent.attachChild(newChild);
+     * } else {
+     *   throw new Error('Would create circular reference');
+     * }
+     * ```
+     *
+     * @example Check for ancestor relationship in conditional logic
+     * ```typescript
+     * const isInProductionBranch = workflow.isDescendantOf(productionRoot);
+     * if (isInProductionBranch) {
+     *   // Apply production-specific logic
+     * }
+     * ```
+     *
+     * @param ancestor - The potential ancestor workflow to check
+     * @returns true if ancestor is found in parent chain, false otherwise
+     * @throws {Error} If a cycle is detected during traversal (indicates corrupted tree structure)
+     */
+    isDescendantOf(ancestor: Workflow): boolean;
+    /**
+     * Get the root workflow
+     * Uses cycle detection to prevent infinite loops from circular parent-child relationships
+     */
+    protected getRoot(): Workflow;
+    /**
+     * Add an observer to this workflow (must be root)
+     * @throws Error if called on non-root workflow
+     * @side effects Adds observer to internal observers array for root workflows.
+     * Observers will receive notifications for workflow events.
+     */
+    addObserver(observer: WorkflowObserver): void;
+    /**
+     * Remove an observer from this workflow
+     */
+    removeObserver(observer: WorkflowObserver): void;
+    /**
+     * Attach a child workflow to this parent workflow.
+     *
+     * Validates that the child can be attached by checking:
+     * 1. Child is not already attached to this parent workflow
+     * 2. Child does not have a different parent (enforces single-parent invariant)
+     * 3. Child is not an ancestor of this parent (prevents circular references)
+     *
+     * **Structural Changes:**
+     * - Adds child to this.children array (workflow tree)
+     * - Adds child.node to this.node.children array (node tree)
+     * - Sets child.parent = this (workflow tree)
+     * - Sets child.node.parent = this.node (node tree)
+     * - Emits childAttached event to notify observers
+     * - Emits treeUpdated event to trigger tree debugger rebuild
+     *
+     * **Invariants Maintained:**
+     * - Single-parent rule: A workflow can only have one parent
+     * - 1:1 tree mirror: workflow tree and node tree stay synchronized
+     * - No cycles: A workflow cannot be its own ancestor
+     *
+     * **Cycle Detection:**
+     * - Uses isDescendantOf() helper with Set-based cycle detection
+     * - Throws immediately if circular reference would be created
+     *
+     * @param child - The child workflow to attach
+     * @throws {Error} If the child is already attached to this workflow
+     * @throws {Error} If the child already has a different parent (use detachChild() first for reparenting)
+     * @throws {Error} If the child is an ancestor of this parent (would create circular reference)
+     * @side effects Modifies workflow tree structure, emits childAttached event,
+     * and triggers treeUpdated event for debugger.
+     *
+     * @example
+     * ```ts
+     * const parent = new Workflow('Parent');
+     * const child = new Workflow('Child');
+     * parent.attachChild(child);
+     * // child.parent === parent
+     * // parent.children.includes(child) === true
+     * ```
+     *
+     * @example Reparenting workflow
+     * ```ts
+     * const parent1 = new Workflow('Parent1');
+     * const parent2 = new Workflow('Parent2');
+     * const child = new Workflow('Child', parent1); // Attached to parent1
+     *
+     * // Later, move child to parent2
+     * parent1.detachChild(child);
+     * parent2.attachChild(child);
+     * // child.parent === parent2
+     * ```
+     *
+     * @see detachChild - For detaching children (enables reparenting)
+     * @see isDescendantOf - Private helper for circular reference detection
+     */
+    attachChild(child: Workflow): void;
+    /**
+     * Detach a child workflow from this parent workflow.
+     *
+     * Removes the child from both the workflow tree (this.children) and
+     * the node tree (this.node.children), clears the child's parent reference,
+     * and emits a childDetached event to notify observers.
+     *
+     * Also emits treeUpdated event to trigger tree debugger rebuild.
+     *
+     * This enables reparenting workflows: oldParent.detachChild(child); newParent.attachChild(child);
+     *
+     * @param child - The child workflow to detach
+     * @throws {Error} If the child is not attached to this parent workflow
+     * @side effects Modifies workflow tree structure, emits childDetached event,
+     * and triggers treeUpdated event for debugger.
+     *
+     * @example
+     * ```ts
+     * const parent = new Workflow('Parent');
+     * const child = new Workflow('Child', parent);
+     *
+     * // Later, reparent to a different parent
+     * parent.detachChild(child);
+     * newParent.attachChild(child);
+     * ```
+     */
+    detachChild(child: Workflow): void;
+    /**
+     * Emit an event to all root observers
+     * @side effects Pushes event to node.events array and notifies all registered observers.
+     * May trigger treeUpdated notifications for specific event types.
+     */
+    emitEvent(event: WorkflowEvent): void;
+    /**
+     * Replay historical events to an observer
+     *
+     * **Strategy:**
+     * 1. Start with event history array
+     * 2. Filter by timestamp if `since` is provided
+     * 3. Limit events if `limit` is provided
+     * 4. Call observer.onEvent() for each event
+     * 5. Handle observer errors gracefully
+     *
+     * **Performance:** O(n) where n = number of events in history
+     *
+     * **Timestamp Handling:**
+     * - Events with timestamps: stepRetry, stepRestarted, invalidResponse
+     * - Events without timestamps: Always included (considered timeless)
+     * - Filter applies only to events with timestamp field
+     *
+     * **Order of Operations:** Filter first, then limit (more efficient)
+     *
+     * **Use Case:**
+     * - Catch up new observers to current state
+     * - Debug by replaying events to diagnostic observers
+     * - Test scenarios by replaying historical events
+     *
+     * @param observer - The observer to replay events to
+     * @param options - Optional replay configuration
+     * @param options.since - Only replay events after this timestamp (ms since epoch)
+     * @param options.limit - Maximum number of events to replay
+     *
+     * @example Replay all events to new observer
+     * ```ts
+     * const observer = {
+     *   onLog: () => {},
+     *   onEvent: (e) => console.log(e.type),
+     *   onStateUpdated: () => {},
+     *   onTreeChanged: () => {},
+     * };
+     * workflow.replayEvents(observer);
+     * ```
+     *
+     * @example Replay last 10 events
+     * ```ts
+     * workflow.replayEvents(observer, { limit: 10 });
+     * ```
+     *
+     * @example Replay events from last 5 minutes
+     * ```ts
+     * const fiveMinutesAgo = Date.now() - 5 * 60 * 1000;
+     * workflow.replayEvents(observer, { since: fiveMinutesAgo });
+     * ```
+     */
+    replayEvents(observer: WorkflowObserver, options?: ReplayEventsOptions): void;
+    /**
+     * Clear the event history array
+     *
+     * **Strategy:**
+     * - Reassign #eventHistory to empty array
+     * - Frees memory by discarding all stored events
+     * - Events in node.events are preserved
+     *
+     * **Use Case:**
+     * - Free memory after workflow completes
+     * - Reset history between test runs
+     * - Prevent memory leaks in long-running workflows
+     *
+     * **Side Effects:**
+     * - Frees memory for discarded events
+     * - Future replayEvents() calls will return empty
+     * - Does NOT affect node.events array
+     *
+     * @example Clear history after workflow completes
+     * ```ts
+     * await workflow.run();
+     * workflow.clearEventHistory();  // Free memory
+     * ```
+     */
+    clearEventHistory(): void;
+    /**
+     * Capture and emit a state snapshot
+     * @side effects Updates node.stateSnapshot, notifies observers via onStateUpdated callback,
+     * emits snapshot event, and triggers treeUpdated event for debugger.
+     */
+    snapshotState(): void;
+    /**
+     * Restart a specific step with state restoration and retry tracking
+     *
+     * This method enables manual step restart from parent workflows. It validates
+     * the step exists, checks retry limits, optionally restores state, re-executes
+     * the step method, and emits a stepRestarted event for observability.
+     *
+     * @param stepName - The name of the step method to restart
+     * @param options - Optional configuration for the restart attempt
+     * @returns The result of the step execution
+     * @throws {WorkflowError} When step is not found or max retries exceeded
+     *
+     * @example Restart a step with default retry tracking
+     * ```ts
+     * class MyWorkflow extends Workflow {
+     *   @Step({ restartable: true })
+     *   async myStep() { return 'result'; }
+     *
+     *   async run() {
+     *     const result = await this.restartStep('myStep');
+     *   }
+     * }
+     * ```
+     *
+     * @example Restart with explicit retry count and state override
+     * ```ts
+     * await this.restartStep('failingStep', {
+     *   retryCount: 1,
+     *   maxRetries: 3,
+     *   stateOverride: { counter: 5 }
+     * });
+     * ```
+     */
+    restartStep(stepName: string, options?: RestartStepOptions): Promise<unknown>;
+    /**
+     * Analyze a WorkflowError from a child workflow and determine restart action
+     *
+     * This method enables parent workflows to make intelligent decisions about child
+     * workflow failures by analyzing the error and step metadata to determine whether
+     * to retry the child, abort the parent, or rebuild the execution plan.
+     *
+     * **Analysis Flow:**
+     * 1. Check `error.original?.recoverable` - if false, return 'abort'
+     * 2. Extract stepName from error metadata (if available)
+     * 3. Retrieve step metadata from stepMetadata map (if exists)
+     * 4. Check if step is marked as restartable - if not, return 'abort'
+     * 5. Use `analyzeErrorForRestart` utility to check retry criteria
+     * 6. Return 'retry' if any criteria match, otherwise 'abort'
+     *
+     * **Integration with restartStep:**
+     * This method is designed to be used alongside `restartStep()`:
+     * - Call `analyzeError()` to get the decision
+     * - If 'retry', call `restartStep(stepName)` to execute
+     * - If 'abort', throw the error or return early
+     * - If 'rebuild', trigger plan rebuild logic
+     *
+     * @param error - The WorkflowError to analyze (typically from child workflow)
+     * @returns The recommended action: 'retry', 'abort', or 'rebuild'
+     *
+     * @example Parent workflow error handling
+     * ```ts
+     * class ParentWorkflow extends Workflow {
+     *   @Step({ restartable: true, retryOn: [{ code: 'TIMEOUT' }] })
+     *   async childWorkflow(): Promise<void> {
+     *     // Child logic that may fail
+     *   }
+     *
+     *   async run(): Promise<void> {
+     *     try {
+     *       await this.childWorkflow();
+     *     } catch (err) {
+     *       const error = err as WorkflowError;
+     *       const action = this.analyzeError(error);
+     *
+     *       if (action === 'retry') {
+     *         await this.restartStep('childWorkflow');
+     *       } else if (action === 'abort') {
+     *         throw error;
+     *       } else if (action === 'rebuild') {
+     *         // Trigger plan rebuild logic
+     *       }
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * @example Analyze error from child workflow event
+     * ```ts
+     * class ParentWorkflow extends Workflow {
+     *   private lastError: WorkflowError | null = null;
+     *
+     *   async run(): Promise<void> {
+     *     // Subscribe to error events
+     *     this.on('error', (event) => {
+     *       this.lastError = event.error;
+     *     });
+     *
+     *     // Later, analyze the error
+     *     if (this.lastError) {
+     *       const action = this.analyzeError(this.lastError);
+     *       // Take action based on decision
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * @remarks
+     * **Known Limitation:**
+     * The `stepMetadata` map is not yet populated by the `@Step` decorator.
+     * This method will return 'abort' if stepMetadata is not available or the step
+     * is not found. This will be improved in a future update to the decorator.
+     *
+     * **Error Metadata:**
+     * The stepName is extracted from `error.state?.stepName`. Ensure child
+     * workflows populate this field when creating WorkflowError instances.
+     *
+     * @see {@link restartStep} - For executing a retry after analysis
+     * @see {@link analyzeErrorForRestart} - For the underlying utility function
+     */
+    analyzeError(error: WorkflowError): 'retry' | 'abort' | 'rebuild';
+    /**
+     * Validate an agent response at the workflow level
+     *
+     * This method enables parent workflows to validate agent responses
+     * before processing them. It follows the same validation pattern as
+     * Agent.validateResponse() but emits events and creates WorkflowError
+     * for workflow-level error handling.
+     *
+     * @template T - The type of response data
+     * @param response - The AgentResponse to validate
+     * @param agentId - Identifier of the agent that produced the response
+     * @param dataSchema - Optional Zod schema for response data (defaults to z.unknown())
+     * @returns true if validation passes, false if validation fails
+     *
+     * @example Validate response from child workflow
+     * ```ts
+     * class ParentWorkflow extends Workflow {
+     *   @Step()
+     *   async processChildResult() {
+     *     const response = await this.childWorkflow.run();
+     *
+     *     if (!this.validateAgentResponse(response, this.childWorkflow.agent.id)) {
+     *       // Handle validation failure
+     *       const action = this.analyzeError(this.lastError);
+     *       if (action === 'retry') {
+     *         return await this.restartStep('processChildResult');
+     *       }
+     *     }
+     *
+     *     // Process valid response
+     *     return response.data;
+     *   }
+     * }
+     * ```
+     */
+    validateAgentResponse<T>(response: AgentResponse<T>, agentId: string, dataSchema?: z.ZodTypeAny): boolean;
+    /**
+     * Update workflow status and sync with node
+     */
+    setStatus(status: WorkflowStatus): void;
+    /**
+     * Get the node representation of this workflow
+     */
+    getNode(): WorkflowNode;
+    /**
+     * Run the workflow
+     *
+     * For functional workflows (created with executor), runs the executor function.
+     * For class-based workflows (subclasses), this should be overridden.
+     *
+     * @returns Workflow result
+     */
+    run(..._args: unknown[]): Promise<T | WorkflowResult<T>>;
+    /**
+     * Run a functional workflow with context
+     */
+    private runFunctional;
+}
+export {};
+//# sourceMappingURL=workflow.d.ts.map

package/dist/core/workflow.d.ts.map

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