yaml-flow 2.0.0 → 2.1.0

package/dist/index.d.cts

@@ -4,3 +4,5 @@ export { A as AgentActionEvent, C as COMPLETION_STRATEGIES, a as CONFLICT_STRATE
 export { MemoryStore } from './stores/memory.cjs';
 export { LocalStorageStore } from './stores/localStorage.cjs';
 export { FileStore } from './stores/file.cjs';
+export { BatchItemResult, BatchOptions, BatchProgress, BatchResult, batch } from './batch/index.cjs';
+export { ConfigTemplates, Variables, resolveConfigTemplates, resolveVariables } from './config/index.cjs';

package/dist/index.d.ts

@@ -4,3 +4,5 @@ export { A as AgentActionEvent, C as COMPLETION_STRATEGIES, a as CONFLICT_STRATE
 export { MemoryStore } from './stores/memory.js';
 export { LocalStorageStore } from './stores/localStorage.js';
 export { FileStore } from './stores/file.js';
+export { BatchItemResult, BatchOptions, BatchProgress, BatchResult, batch } from './batch/index.js';
+export { ConfigTemplates, Variables, resolveConfigTemplates, resolveVariables } from './config/index.js';

package/dist/index.js

@@ -1513,6 +1513,184 @@ var FileStore = class {
   }
 };
 
-export { COMPLETION_STRATEGIES, CONFLICT_STRATEGIES, DEFAULTS, EXECUTION_MODES, EXECUTION_STATUS, FileStore, StepMachine as FlowEngine, LocalStorageStore, MemoryStore, StepMachine, TASK_STATUS, addDynamicTask, apply, applyAll, applyStepResult, checkCircuitBreaker, computeAvailableOutputs, computeStepInput, createDefaultTaskState, createStepMachine as createEngine, createInitialExecutionState, createInitialState, createStepMachine, detectStuckState, extractReturnData, getAllTasks, getCandidateTasks, getProvides, getRequires, getTask, hasTask, isExecutionComplete, isNonActiveTask, isRepeatableTask, isTaskCompleted, isTaskRunning, loadStepFlow, next, validateStepFlowConfig };
+// src/batch/runner.ts
+async function batch(items, options) {
+  const {
+    concurrency = 5,
+    processor,
+    onItemComplete,
+    onItemError,
+    onProgress,
+    signal
+  } = options;
+  const total = items.length;
+  const results = new Array(total);
+  const batchStart = Date.now();
+  let completed = 0;
+  let failed = 0;
+  let nextIndex = 0;
+  function makeProgress(active) {
+    const done = completed + failed;
+    return {
+      completed,
+      failed,
+      active,
+      pending: total - done - active,
+      total,
+      percent: total === 0 ? 100 : Math.round(done / total * 100),
+      elapsedMs: Date.now() - batchStart
+    };
+  }
+  if (total === 0) {
+    return { items: [], completed: 0, failed: 0, total: 0, durationMs: 0 };
+  }
+  return new Promise((resolve) => {
+    let active = 0;
+    function tryStartNext() {
+      while (active < concurrency && nextIndex < total) {
+        if (signal?.aborted) {
+          while (nextIndex < total) {
+            const idx2 = nextIndex++;
+            results[idx2] = {
+              item: items[idx2],
+              index: idx2,
+              status: "failed",
+              error: new Error("Batch aborted"),
+              durationMs: 0
+            };
+            failed++;
+          }
+          if (active === 0 && completed + failed === total) {
+            resolve({
+              items: results,
+              completed,
+              failed,
+              total,
+              durationMs: Date.now() - batchStart
+            });
+          }
+          break;
+        }
+        const idx = nextIndex++;
+        const item = items[idx];
+        active++;
+        const itemStart = Date.now();
+        processor(item, idx).then((result) => {
+          results[idx] = {
+            item,
+            index: idx,
+            status: "completed",
+            result,
+            durationMs: Date.now() - itemStart
+          };
+          completed++;
+          onItemComplete?.(item, result, idx);
+        }).catch((err) => {
+          const error = err instanceof Error ? err : new Error(String(err));
+          results[idx] = {
+            item,
+            index: idx,
+            status: "failed",
+            error,
+            durationMs: Date.now() - itemStart
+          };
+          failed++;
+          onItemError?.(item, error, idx);
+        }).finally(() => {
+          active--;
+          onProgress?.(makeProgress(active));
+          if (completed + failed === total) {
+            resolve({
+              items: results,
+              completed,
+              failed,
+              total,
+              durationMs: Date.now() - batchStart
+            });
+          } else {
+            tryStartNext();
+          }
+        });
+      }
+    }
+    tryStartNext();
+  });
+}
+
+// src/config/resolve-variables.ts
+function interpolateString(template, vars) {
+  return template.replace(/\$\{([^}]+)\}/g, (match, key) => {
+    const value = vars[key.trim()];
+    return value !== void 0 ? String(value) : match;
+  });
+}
+function walkAndInterpolate(value, vars) {
+  if (typeof value === "string") {
+    return interpolateString(value, vars);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => walkAndInterpolate(item, vars));
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = walkAndInterpolate(v, vars);
+    }
+    return result;
+  }
+  return value;
+}
+function resolveVariables(config, variables) {
+  return walkAndInterpolate(config, variables);
+}
+
+// src/config/resolve-config-templates.ts
+function mergeConfigs(template, taskConfig) {
+  const merged = { ...template };
+  for (const [key, value] of Object.entries(taskConfig)) {
+    if (key === "config-template") continue;
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && merged[key] !== null && typeof merged[key] === "object" && !Array.isArray(merged[key])) {
+      merged[key] = {
+        ...merged[key],
+        ...value
+      };
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+function resolveConfigTemplates(config) {
+  const templates = config["configTemplates"] ?? config["config-templates"] ?? {};
+  const tasksKey = "tasks" in config ? "tasks" : "steps" in config ? "steps" : null;
+  if (!tasksKey) return config;
+  const tasks = config[tasksKey];
+  if (!tasks || typeof tasks !== "object") return config;
+  const resolvedTasks = {};
+  for (const [name, task] of Object.entries(tasks)) {
+    const taskConfig = task["config"];
+    const templateName = taskConfig?.["config-template"];
+    if (!templateName || !taskConfig) {
+      resolvedTasks[name] = task;
+      continue;
+    }
+    const template = templates[templateName];
+    if (!template) {
+      const { "config-template": _, ...rest } = taskConfig;
+      resolvedTasks[name] = { ...task, config: rest };
+      continue;
+    }
+    resolvedTasks[name] = {
+      ...task,
+      config: mergeConfigs(template, taskConfig)
+    };
+  }
+  const result = { ...config, [tasksKey]: resolvedTasks };
+  delete result["configTemplates"];
+  delete result["config-templates"];
+  return result;
+}
+
+export { COMPLETION_STRATEGIES, CONFLICT_STRATEGIES, DEFAULTS, EXECUTION_MODES, EXECUTION_STATUS, FileStore, StepMachine as FlowEngine, LocalStorageStore, MemoryStore, StepMachine, TASK_STATUS, addDynamicTask, apply, applyAll, applyStepResult, batch, checkCircuitBreaker, computeAvailableOutputs, computeStepInput, createDefaultTaskState, createStepMachine as createEngine, createInitialExecutionState, createInitialState, createStepMachine, detectStuckState, extractReturnData, getAllTasks, getCandidateTasks, getProvides, getRequires, getTask, hasTask, isExecutionComplete, isNonActiveTask, isRepeatableTask, isTaskCompleted, isTaskRunning, loadStepFlow, next, resolveConfigTemplates, resolveVariables, validateStepFlowConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map