@synergenius/flow-weaver-pack-weaver 0.9.138 → 0.9.140

package/src/workflows/weaver-bot.ts

@@ -24,9 +24,401 @@ import { weaverCtxMerge } from '../node-types/ctx-merge.js';
 // DO NOT EDIT - This section is auto-generated by Flow Weaver
 // ============================================================================
 
-import { GeneratedExecutionContext, CancellationError } from '@synergenius/flow-weaver/runtime';
-import type { TDebugger, TDebugController } from '@synergenius/flow-weaver/runtime';
+// ============================================================================
+// Runtime Types
+// ============================================================================
+
+type TStatusType =
+  | "RUNNING"
+  | "SCHEDULED"
+  | "SUCCEEDED"
+  | "FAILED"
+  | "CANCELLED"
+  | "PENDING";
+
+type TVariableIdentification = {
+  nodeTypeName: string;
+  id: string;
+  scope?: string | undefined;
+  side?: "start" | "exit" | undefined;
+  portName: string;
+  executionIndex: number;
+  key?: string | undefined;
+};
+
+type TStatusChangedEvent = {
+  type: "STATUS_CHANGED";
+  nodeTypeName: string;
+  id: string;
+  scope?: string;
+  side?: "start" | "exit";
+  executionIndex: number;
+  status: TStatusType;
+  innerFlowInvocation?: boolean;
+};
+
+type TVariableSetEvent = {
+  type: "VARIABLE_SET";
+  identifier: TVariableIdentification;
+  value?: unknown;
+  innerFlowInvocation?: boolean;
+};
+
+type TErrorLogEvent = {
+  type: "LOG_ERROR";
+  nodeTypeName: string;
+  id: string;
+  scope?: string;
+  side?: "start" | "exit";
+  executionIndex: number;
+  error: string;
+  innerFlowInvocation?: boolean;
+};
+
+type TWorkflowCompletedEvent = {
+  type: "WORKFLOW_COMPLETED";
+  executionIndex: number;
+  status: "SUCCEEDED" | "FAILED" | "CANCELLED";
+  result?: unknown;
+  innerFlowInvocation?: boolean;
+};
+
+type TEvent =
+  | TStatusChangedEvent
+  | TVariableSetEvent
+  | TErrorLogEvent
+  | TWorkflowCompletedEvent;
+
+type TDebugger = {
+  sendEvent: (event: TEvent) => void | Promise<void>;
+  innerFlowInvocation: boolean;
+  sessionId?: string;
+};
+
 declare const __flowWeaverDebugger__: TDebugger | undefined;
+
+type TDebugController = {
+  beforeNode(nodeId: string, ctx: GeneratedExecutionContext): Promise<boolean> | boolean;
+  afterNode(nodeId: string, ctx: GeneratedExecutionContext): Promise<void> | void;
+};
+
+declare const __abortSignal__: AbortSignal | undefined;
+
+interface VariableAddress {
+  id: string;
+  portName: string;
+  executionIndex: number;
+  nodeTypeName?: string | undefined;
+  scope?: string | undefined;
+  side?: 'start' | 'exit' | undefined;
+}
+
+interface ExecutionInfo {
+  id: string;
+  index: number;
+  parentIndex?: number | undefined;
+  scopeName?: string | undefined;
+}
+
+type VariableValue = unknown | (() => unknown) | (() => Promise<unknown>);
+
+// ============================================================================
+// Cancellation Error
+// ============================================================================
+
+class CancellationError extends Error {
+  public readonly executionIndex: number;
+  public readonly nodeId?: string;
+  public readonly timestamp: number;
+
+  constructor(
+    message: string = 'Workflow execution cancelled',
+    executionIndex: number = 0,
+    nodeId?: string,
+    timestamp: number = Date.now()
+  ) {
+    super(message);
+    this.name = 'CancellationError';
+    this.executionIndex = executionIndex;
+    this.nodeId = nodeId;
+    this.timestamp = timestamp;
+  }
+
+  static isCancellationError(error: unknown): error is CancellationError {
+    return (
+      error instanceof CancellationError ||
+      (error instanceof Error && error.name === 'CancellationError')
+    );
+  }
+}
+
+// ============================================================================
+// Execution Context
+// ============================================================================
+
+class GeneratedExecutionContext {
+  private variables: Map<string, VariableValue> = new Map();
+  private executions: Map<string, ExecutionInfo> = new Map();
+  private executionCounter: number = 0;
+  private nodeExecutionCounts: Map<string, number> = new Map();
+  private isAsync: boolean;
+  private flowWeaverDebugger?: TDebugger | undefined;
+  private pullExecutors: Map<string, () => void | Promise<void>> = new Map();
+  private nodeExecutionIndices: Map<string, number> = new Map();
+  private abortSignal?: AbortSignal | undefined;
+
+  constructor(isAsync: boolean = true, flowWeaverDebugger?: TDebugger, abortSignal?: AbortSignal) {
+    this.isAsync = isAsync;
+    this.flowWeaverDebugger = flowWeaverDebugger;
+    this.abortSignal = abortSignal;
+  }
+
+  registerPullExecutor(id: string, executor: () => void | Promise<void>): void {
+    this.pullExecutors.set(id, executor);
+  }
+
+  addExecution(id: string, parentIndex?: number, scopeName?: string): number {
+    // Use per-node execution counter (each node starts at 0)
+    const currentCount = this.nodeExecutionCounts.get(id) || 0;
+    const index = currentCount;
+    this.nodeExecutionCounts.set(id, currentCount + 1);
+    this.executionCounter++;
+    this.executions.set(this.getExecutionKey(id, index), {
+      id,
+      index,
+      parentIndex,
+      scopeName,
+    });
+    this.nodeExecutionIndices.set(id, index);
+    return index;
+  }
+
+  setVariable(address: VariableAddress, value: VariableValue): void | Promise<void> {
+    const key = this.getVariableKey(address);
+    this.variables.set(key, value);
+    if (this.flowWeaverDebugger) {
+      const actualValue = typeof value === "function" ? value() : value;
+      this.sendVariableSetEvent({
+        identifier: {
+          nodeTypeName: address.nodeTypeName || "unknown",
+          id: address.id,
+          portName: address.portName,
+          executionIndex: address.executionIndex,
+          key: "default",
+          ...(address.scope && { scope: address.scope }),
+          ...(address.side && { side: address.side }),
+        },
+        value: actualValue,
+      });
+    }
+    return this.isAsync ? Promise.resolve() : undefined;
+  }
+
+  getVariable(address: VariableAddress): unknown | Promise<unknown> {
+    const executor = this.pullExecutors.get(address.id);
+    if (executor) {
+      if (!this.hasVariable(address)) {
+        const result = executor();
+        // Handle async executor (returns Promise)
+        if (result instanceof Promise) {
+          return result.then(() => {
+            const trackedIndex = this.nodeExecutionIndices.get(address.id);
+            const finalAddress = trackedIndex !== undefined
+              ? { ...address, executionIndex: trackedIndex }
+              : address;
+            return this.retrieveVariable(finalAddress);
+          });
+        }
+        // Handle sync executor (returns void)
+        const trackedIndex = this.nodeExecutionIndices.get(address.id);
+        const finalAddress = trackedIndex !== undefined
+          ? { ...address, executionIndex: trackedIndex }
+          : address;
+        return this.retrieveVariable(finalAddress);
+      }
+    }
+    return this.retrieveVariable(address);
+  }
+
+  private retrieveVariable(address: VariableAddress): unknown | Promise<unknown> {
+    const key = this.getVariableKey(address);
+    if (!this.variables.has(key)) {
+      throw new Error(`Variable not found: ${address.id}.${address.portName}[${address.executionIndex}]`);
+    }
+    const value = this.variables.get(key);
+    if (typeof value === "function") {
+      const result = value();
+      if (result instanceof Promise) {
+        return result;
+      }
+      return this.isAsync ? Promise.resolve(result) : result;
+    }
+    return this.isAsync ? Promise.resolve(value) : value;
+  }
+
+  hasVariable(address: VariableAddress): boolean {
+    const key = this.getVariableKey(address);
+    return this.variables.has(key);
+  }
+
+  getExecution(id: string, index: number): ExecutionInfo | undefined {
+    return this.executions.get(this.getExecutionKey(id, index));
+  }
+
+  createScope(_parentNodeName: string, _parentIndex: number, _scopeName: string, cleanScope: boolean = false, isAsyncOverride?: boolean): GeneratedExecutionContext {
+    const effectiveIsAsync = isAsyncOverride !== undefined ? isAsyncOverride : this.isAsync;
+    const scopedContext = new GeneratedExecutionContext(effectiveIsAsync, this.flowWeaverDebugger, this.abortSignal);
+    // For per-port function scopes (cleanScope=true), start with empty variables
+    // For node-level scopes (cleanScope=false), inherit parent variables
+    scopedContext.variables = cleanScope ? new Map() : new Map(this.variables);
+    scopedContext.executions = new Map(this.executions);
+    scopedContext.executionCounter = this.executionCounter;
+    scopedContext.nodeExecutionCounts = new Map(this.nodeExecutionCounts);
+    return scopedContext;
+  }
+
+  mergeScope(scopedContext: GeneratedExecutionContext): void {
+    scopedContext.executions.forEach((info, key) => {
+      this.executions.set(key, info);
+    });
+    scopedContext.variables.forEach((value, key) => {
+      this.variables.set(key, value);
+    });
+    this.executionCounter = Math.max(this.executionCounter, scopedContext.executionCounter);
+    scopedContext.nodeExecutionCounts.forEach((count, id) => {
+      const currentCount = this.nodeExecutionCounts.get(id) || 0;
+      this.nodeExecutionCounts.set(id, Math.max(currentCount, count));
+    });
+  }
+
+  private getVariableKey(address: VariableAddress): string {
+    return `${address.id}:${address.portName}:${address.executionIndex}`;
+  }
+
+  private getExecutionKey(id: string, index: number): string {
+    return `${id}:${index}`;
+  }
+
+  getExecutionCount(): number {
+    return this.executionCounter;
+  }
+
+  reset(): void {
+    this.variables.clear();
+    this.executions.clear();
+    this.executionCounter = 0;
+    this.nodeExecutionCounts.clear();
+  }
+
+  isAborted(): boolean {
+    return this.abortSignal?.aborted ?? false;
+  }
+
+  checkAborted(nodeId?: string): void {
+    if (this.abortSignal?.aborted) {
+      throw new CancellationError(
+        `Workflow execution cancelled${nodeId ? ` at ${nodeId}` : ''}`,
+        this.executionCounter,
+        nodeId
+      );
+    }
+  }
+
+  async sendStatusChangedEvent(args: {
+    nodeTypeName: string;
+    id: string;
+    scope?: string;
+    side?: "start" | "exit";
+    executionIndex: number;
+    status: TStatusType;
+  }): Promise<void> {
+    if (this.flowWeaverDebugger) {
+      await this.flowWeaverDebugger.sendEvent({
+        type: "STATUS_CHANGED",
+        ...args,
+        innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation,
+      });
+    }
+  }
+
+  private async sendVariableSetEvent(args: {
+    identifier: TVariableIdentification;
+    value: unknown;
+  }): Promise<void> {
+    if (this.flowWeaverDebugger) {
+      await this.flowWeaverDebugger.sendEvent({
+        type: "VARIABLE_SET",
+        ...args,
+        innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation,
+      });
+    }
+  }
+
+  async sendLogErrorEvent(args: {
+    nodeTypeName: string;
+    id: string;
+    scope?: string;
+    side?: "start" | "exit";
+    executionIndex: number;
+    error: string;
+  }): Promise<void> {
+    if (this.flowWeaverDebugger) {
+      await this.flowWeaverDebugger.sendEvent({
+        type: "LOG_ERROR",
+        ...args,
+        innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation,
+      });
+    }
+  }
+
+  async sendWorkflowCompletedEvent(args: {
+    executionIndex: number;
+    status: "SUCCEEDED" | "FAILED" | "CANCELLED";
+    result?: unknown;
+  }): Promise<void> {
+    if (this.flowWeaverDebugger) {
+      await this.flowWeaverDebugger.sendEvent({
+        type: "WORKFLOW_COMPLETED",
+        ...args,
+        innerFlowInvocation: this.flowWeaverDebugger.innerFlowInvocation,
+      });
+    }
+  }
+
+  serialize(): {
+    variables: Record<string, unknown>;
+    executions: Record<string, ExecutionInfo>;
+    executionCounter: number;
+    nodeExecutionCounts: Record<string, number>;
+  } {
+    const vars: Record<string, unknown> = {};
+    for (const [key, value] of this.variables) {
+      if (typeof value === "function") {
+        try { vars[key] = (value as () => unknown)(); } catch { vars[key] = value; }
+      } else {
+        vars[key] = value;
+      }
+    }
+    const execs: Record<string, ExecutionInfo> = {};
+    for (const [key, info] of this.executions) { execs[key] = { ...info }; }
+    const nodeCounts: Record<string, number> = {};
+    for (const [key, count] of this.nodeExecutionIndices) { nodeCounts[key] = count; }
+    return { variables: vars, executions: execs, executionCounter: this.executionCounter, nodeExecutionCounts: nodeCounts };
+  }
+
+  restore(data: {
+    variables: Record<string, unknown>;
+    executions: Record<string, ExecutionInfo>;
+    executionCounter: number;
+    nodeExecutionCounts: Record<string, number>;
+  }): void {
+    this.variables = new Map(Object.entries(data.variables));
+    this.executions = new Map(Object.entries(data.executions));
+    this.executionCounter = data.executionCounter;
+    this.nodeExecutionIndices = new Map(Object.entries(data.nodeExecutionCounts));
+  }
+}
+
 // @flow-weaver-runtime-end
 
 /**
@@ -76,6 +468,7 @@ declare const __flowWeaverDebugger__: TDebugger | undefined;
  * @connect gitOps.ctx -> report.mainCtx
  * @connect readWf.ctx -> report.readCtx
  * @connect abort.ctx -> report.abortCtx
+ * @connect execRetry.ctx -> report.failCtx
  * @connect report.summary -> Exit.summary
  * @param execute [order:-1] - Execute
  * @param taskJson [order:0] - TaskJson
@@ -1731,7 +2124,9 @@ export async function weaverBot(
         await ctx.setVariable({ id: 'report', portName: 'readCtx', executionIndex: reportIdx, nodeTypeName: 'weaverBotReport' }, report_readCtx);
         const report_abortCtx = abortIdx !== undefined ? await ctx.getVariable({ id: 'abort', portName: 'ctx', executionIndex: abortIdx }) as string : undefined;
         await ctx.setVariable({ id: 'report', portName: 'abortCtx', executionIndex: reportIdx, nodeTypeName: 'weaverBotReport' }, report_abortCtx);
-        const reportResult = await weaverBotReport(report_execute, report_mainCtx, report_readCtx, report_abortCtx);
+        const report_failCtx = execRetryIdx !== undefined ? await ctx.getVariable({ id: 'execRetry', portName: 'ctx', executionIndex: execRetryIdx }) as string : undefined;
+        await ctx.setVariable({ id: 'report', portName: 'failCtx', executionIndex: reportIdx, nodeTypeName: 'weaverBotReport' }, report_failCtx);
+        const reportResult = await weaverBotReport(report_execute, report_mainCtx, report_readCtx, report_abortCtx, report_failCtx);
         await ctx.setVariable({ id: 'report', portName: 'summary', executionIndex: reportIdx, nodeTypeName: 'weaverBotReport' }, reportResult.summary);
         await ctx.setVariable({ id: 'report', portName: 'reportJson', executionIndex: reportIdx, nodeTypeName: 'weaverBotReport' }, reportResult.reportJson);
         await ctx.setVariable({ id: 'report', portName: 'onFailure', executionIndex: reportIdx, nodeTypeName: 'weaverBotReport' }, reportResult.onFailure);