@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/templates/index.js

@@ -1,123 +0,0 @@
-/**
- * Flow Weaver Template Registry
- * Central registry for workflow and node templates
- */
-// Import workflow templates
-import { sequentialTemplate } from './workflows/sequential.js';
-import { foreachTemplate } from './workflows/foreach.js';
-import { conditionalTemplate } from './workflows/conditional.js';
-import { aiAgentTemplate } from './workflows/ai-agent.js';
-import { aiReactTemplate } from './workflows/ai-react.js';
-import { aiRagTemplate } from './workflows/ai-rag.js';
-import { aiChatTemplate } from './workflows/ai-chat.js';
-import { aggregatorTemplate } from './workflows/aggregator.js';
-import { webhookTemplate } from './workflows/webhook.js';
-import { errorHandlerTemplate } from './workflows/error-handler.js';
-// Import node templates
-import { validatorNodeTemplate } from './nodes/validator.js';
-import { transformerNodeTemplate } from './nodes/transformer.js';
-import { httpNodeTemplate } from './nodes/http.js';
-import { aggregatorNodeTemplate } from './nodes/aggregator.js';
-// Import AI node templates
-import { llmCallNodeTemplate } from './nodes/llm-call.js';
-import { toolExecutorNodeTemplate } from './nodes/tool-executor.js';
-import { conversationMemoryNodeTemplate } from './nodes/conversation-memory.js';
-// Import agent node templates
-import { promptTemplateNodeTemplate } from './nodes/prompt-template.js';
-import { jsonExtractorNodeTemplate } from './nodes/json-extractor.js';
-import { humanApprovalNodeTemplate } from './nodes/human-approval.js';
-import { agentRouterNodeTemplate } from './nodes/agent-router.js';
-import { ragRetrieverNodeTemplate } from './nodes/rag-retriever.js';
-/**
- * All available workflow templates
- */
-export const workflowTemplates = [
-    sequentialTemplate,
-    foreachTemplate,
-    conditionalTemplate,
-    aiAgentTemplate,
-    aiReactTemplate,
-    aiRagTemplate,
-    aiChatTemplate,
-    aggregatorTemplate,
-    webhookTemplate,
-    errorHandlerTemplate,
-];
-/**
- * All available node templates
- */
-export const nodeTemplates = [
-    validatorNodeTemplate,
-    transformerNodeTemplate,
-    httpNodeTemplate,
-    aggregatorNodeTemplate,
-    llmCallNodeTemplate,
-    toolExecutorNodeTemplate,
-    conversationMemoryNodeTemplate,
-    promptTemplateNodeTemplate,
-    jsonExtractorNodeTemplate,
-    humanApprovalNodeTemplate,
-    agentRouterNodeTemplate,
-    ragRetrieverNodeTemplate,
-];
-/**
- * Get a workflow template by ID.
- * Checks both core templates and any dynamically loaded pack templates.
- */
-export function getWorkflowTemplate(id) {
-    return workflowTemplates.find((t) => t.id === id)
-        ?? packWorkflowTemplates.find((t) => t.id === id);
-}
-/**
- * Get a node template by ID
- */
-export function getNodeTemplate(id) {
-    return nodeTemplates.find((t) => t.id === id);
-}
-/**
- * Dynamically loaded pack templates. Populated by loadPackTemplates().
- */
-const packWorkflowTemplates = [];
-/**
- * Get all workflow templates including pack-contributed ones.
- */
-export function getAllWorkflowTemplates() {
-    return [...workflowTemplates, ...packWorkflowTemplates];
-}
-/**
- * Register workflow templates contributed by a built-in extension.
- * Unlike loadPackTemplates (which scans npm packages), this is for
- * in-tree extensions that register at bootstrap time.
- */
-export function registerWorkflowTemplates(templates) {
-    for (const tmpl of templates) {
-        if (!packWorkflowTemplates.some((t) => t.id === tmpl.id)) {
-            packWorkflowTemplates.push(tmpl);
-        }
-    }
-}
-// loadPackTemplates has been moved to ./pack-loader.ts to keep Node.js-only
-// imports (marketplace, fs, child_process) out of the browser bundle.
-/**
- * Convert a string to camelCase
- */
-export function toCamelCase(str) {
-    // Preserve leading underscores/dollar signs
-    const leadingMatch = str.match(/^[_$]+/);
-    const leading = leadingMatch ? leadingMatch[0] : '';
-    const rest = leading ? str.slice(leading.length) : str;
-    const result = rest
-        .replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
-        .replace(/^[^a-zA-Z_$]+/, '') // Strip leading non-identifier chars
-        .replace(/^./, (c) => c.toLowerCase());
-    const final = leading + result;
-    return final || '_' + str.replace(/[^a-zA-Z0-9_$]/g, '');
-}
-/**
- * Convert a string to PascalCase (for labels)
- */
-export function toPascalCase(str) {
-    const camel = toCamelCase(str);
-    return camel.charAt(0).toUpperCase() + camel.slice(1);
-}
-//# sourceMappingURL=index.js.map

package/dist/cli/templates/nodes/agent-router.js

@@ -1,114 +0,0 @@
-import { toPascalCase } from '../index.js';
-export const agentRouterNodeTemplate = {
-    id: 'agent-router',
-    name: 'Agent Router',
-    description: 'Route to different handlers based on a classification result',
-    category: 'ai',
-    generate: (name) => {
-        const funcName = name || 'agentRouter';
-        const label = toPascalCase(funcName);
-        return `
-// ============================================================
-// ROUTE DEFINITIONS
-// ============================================================
-//
-// Define your routes here. The router matches the 'category' input
-// (from an upstream LLM call) against route names using case-insensitive
-// comparison. The last route is used as a default/fallback.
-//
-// Example wiring in a workflow:
-//   llmCall.content → agentRouter.category
-//   agentRouter.selectedRoute → (use for downstream branching)
-
-interface Route {
-  name: string;
-  description: string;
-}
-
-const DEFAULT_ROUTES: Route[] = [
-  { name: 'billing', description: 'Billing inquiries, invoices, payments' },
-  { name: 'technical', description: 'Technical support, bugs, troubleshooting' },
-  { name: 'general', description: 'General questions (default fallback)' },
-];
-
-/**
- * Route to different handlers based on a classification result.
- * Matches the category string against route names (case-insensitive).
- * Falls back to the last route if no match is found.
- *
- * @flowWeaver nodeType
- * @label ${label}
- * @color blue
- * @icon altRoute
- * @input execute [order:0] - Execute
- * @input category [order:1] - Classification result (from upstream LLM call)
- * @input routes [order:2] - Available routes with name and description (optional)
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure (no routes provided)
- * @output selectedRoute [order:2] - Name of the matched route
- * @output routeDescription [order:3] - Description of the matched route
- * @output isDefault [order:4] - Whether the default/fallback route was used
- */
-function ${funcName}(
-  execute: boolean,
-  category: string,
-  routes?: Route[]
-): {
-  onSuccess: boolean;
-  onFailure: boolean;
-  selectedRoute: string;
-  routeDescription: string;
-  isDefault: boolean;
-} {
-  if (!execute) {
-    return {
-      onSuccess: false,
-      onFailure: false,
-      selectedRoute: '',
-      routeDescription: '',
-      isDefault: false,
-    };
-  }
-
-  const activeRoutes = routes && routes.length > 0 ? routes : DEFAULT_ROUTES;
-
-  if (activeRoutes.length === 0) {
-    return {
-      onSuccess: false,
-      onFailure: true,
-      selectedRoute: '',
-      routeDescription: '',
-      isDefault: false,
-    };
-  }
-
-  // Case-insensitive match against route names
-  const normalized = (category || '').trim().toLowerCase();
-  const matched = activeRoutes.find(
-    (r) => r.name.toLowerCase() === normalized
-  );
-
-  if (matched) {
-    return {
-      onSuccess: true,
-      onFailure: false,
-      selectedRoute: matched.name,
-      routeDescription: matched.description,
-      isDefault: false,
-    };
-  }
-
-  // Fallback to last route as default
-  const fallback = activeRoutes[activeRoutes.length - 1];
-  return {
-    onSuccess: true,
-    onFailure: false,
-    selectedRoute: fallback.name,
-    routeDescription: fallback.description,
-    isDefault: true,
-  };
-}
-`.trim();
-    },
-};
-//# sourceMappingURL=agent-router.js.map

package/dist/cli/templates/nodes/aggregator.js

@@ -1,63 +0,0 @@
-/**
- * Aggregator Node Template
- * Combine multiple inputs into a single output
- */
-import { toPascalCase } from "../index.js";
-export const aggregatorNodeTemplate = {
-    id: "aggregator",
-    name: "Aggregator",
-    description: "Combine multiple inputs into a single output",
-    category: "data",
-    generate: (name) => {
-        const pascalName = toPascalCase(name);
-        return `
-/**
- * Combines multiple inputs into a single output
- *
- * @flowWeaver nodeType
- * @label ${pascalName}
- * @color orange
- * @icon callMerge
- * @input inputA [order:1] - First input
- * @input inputB [order:2] - Second input
- * @input inputC [order:3] - Third input (optional)
- * @input execute [order:0] - Execute
- * @output combined [order:2] - Combined result
- * @output count [order:3] - Number of non-null inputs combined
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure
- */
-function ${name}(
-  execute: boolean,
-  inputA: any,
-  inputB: any,
-  inputC: any
-): { onSuccess: boolean; onFailure: boolean; combined: any; count: number } {
-  if (!execute) {
-    return { onSuccess: false, onFailure: false, combined: null, count: 0 };
-  }
-
-  // TODO: Customize aggregation logic based on your data types
-  const inputs = [inputA, inputB, inputC].filter(x => x !== null && x !== undefined);
-  const count = inputs.length;
-
-  // Default: merge arrays or objects, or collect into array
-  let combined: any;
-
-  if (inputs.every(Array.isArray)) {
-    // Merge arrays
-    combined = inputs.flat();
-  } else if (inputs.every(x => typeof x === "object" && x !== null && !Array.isArray(x))) {
-    // Merge objects
-    combined = Object.assign({}, ...inputs);
-  } else {
-    // Collect as array
-    combined = inputs;
-  }
-
-  return { onSuccess: true, onFailure: false, combined, count };
-}
-`.trim();
-    },
-};
-//# sourceMappingURL=aggregator.js.map

package/dist/cli/templates/nodes/conversation-memory.js

@@ -1,85 +0,0 @@
-export const conversationMemoryNodeTemplate = {
-    id: 'conversation-memory',
-    name: 'Conversation Memory',
-    description: 'Stores and retrieves conversation history',
-    category: 'ai',
-    generate: (name) => {
-        const funcName = name || 'conversationMemory';
-        return `
-// LLM Types
-interface LLMMessage { role: 'system' | 'user' | 'assistant' | 'tool'; content: string; toolCallId?: string; }
-
-// In-memory store (replace with Redis, database, etc. for production)
-const conversations: Map<string, LLMMessage[]> = new Map();
-
-/**
- * Manages conversation history for stateful chat
- *
- * @flowWeaver nodeType
- * @label ${funcName}
- * @color blue
- * @icon database
- * @input conversationId [order:1] - Unique conversation identifier
- * @input newMessage [order:2] - New message to add (optional)
- * @input maxMessages [order:3] - Max messages to retain (optional, default 50)
- * @input execute [order:0] - Execute
- * @output messages [order:2] - Full conversation history
- * @output messageCount [order:3] - Number of messages
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure
- */
-function ${funcName}(
-  execute: boolean,
-  conversationId: string,
-  newMessage?: LLMMessage,
-  maxMessages?: number
-): {
-  onSuccess: boolean;
-  onFailure: boolean;
-  messages: LLMMessage[];
-  messageCount: number;
-} {
-  if (!execute) {
-    return {
-      onSuccess: false,
-      onFailure: false,
-      messages: [],
-      messageCount: 0
-    };
-  }
-
-  const limit = maxMessages ?? 50;
-
-  // Get or create conversation
-  if (!conversations.has(conversationId)) {
-    conversations.set(conversationId, []);
-  }
-
-  const history = conversations.get(conversationId)!;
-
-  // Add new message if provided
-  if (newMessage) {
-    history.push(newMessage);
-
-    // Trim to max length (keep system message if present)
-    while (history.length > limit) {
-      const firstNonSystem = history.findIndex(m => m.role !== 'system');
-      if (firstNonSystem > 0) {
-        history.splice(firstNonSystem, 1);
-      } else {
-        history.shift();
-      }
-    }
-  }
-
-  return {
-    onSuccess: true,
-    onFailure: false,
-    messages: [...history],
-    messageCount: history.length
-  };
-}
-`.trim();
-    },
-};
-//# sourceMappingURL=conversation-memory.js.map

package/dist/cli/templates/nodes/http.js

@@ -1,80 +0,0 @@
-/**
- * HTTP Node Template
- * HTTP request with configurable method, headers, body
- */
-import { toPascalCase } from "../index.js";
-export const httpNodeTemplate = {
-    id: "http",
-    name: "HTTP Request",
-    description: "Make HTTP requests to external APIs",
-    category: "integration",
-    generate: (name) => {
-        const pascalName = toPascalCase(name);
-        return `
-/**
- * Makes an HTTP request
- *
- * @flowWeaver nodeType
- * @label ${pascalName}
- * @color blue
- * @icon api
- * @input url [order:1] - Request URL
- * @input method [order:2] - HTTP method (GET, POST, PUT, DELETE)
- * @input headers [order:3] - Request headers
- * @input body [order:4] - Request body
- * @input execute [order:0] - Execute
- * @output response [order:2] - Response data
- * @output statusCode [order:3] - HTTP status code
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure
- */
-async function ${name}(
-  execute: boolean,
-  url: string,
-  method: "GET" | "POST" | "PUT" | "DELETE",
-  headers: Record<string, string>,
-  body: any
-): Promise<{ onSuccess: boolean; onFailure: boolean; response: any; statusCode: number }> {
-  if (!execute) {
-    return { onSuccess: false, onFailure: false, response: null, statusCode: 0 };
-  }
-
-  try {
-    const options: RequestInit = {
-      method,
-      headers: {
-        "Content-Type": "application/json",
-        ...headers
-      }
-    };
-
-    if (method !== "GET" && body) {
-      options.body = JSON.stringify(body);
-    }
-
-    const res = await fetch(url, options);
-    const statusCode = res.status;
-
-    let response;
-    const contentType = res.headers.get("content-type");
-    if (contentType?.includes("application/json")) {
-      response = await res.json();
-    } else {
-      response = await res.text();
-    }
-
-    if (!res.ok) {
-      console.error("[${pascalName}] HTTP error:", statusCode, response);
-      return { onSuccess: false, onFailure: true, response, statusCode };
-    }
-
-    return { onSuccess: true, onFailure: false, response, statusCode };
-  } catch (err) {
-    console.error("[${pascalName}] Request failed:", err);
-    return { onSuccess: false, onFailure: true, response: null, statusCode: 0 };
-  }
-}
-`.trim();
-    },
-};
-//# sourceMappingURL=http.js.map

package/dist/cli/templates/nodes/human-approval.js

@@ -1,109 +0,0 @@
-import { toPascalCase } from '../index.js';
-import { APPROVAL_TYPES } from '../shared/approval-types.js';
-import { getApprovalCode } from '../approvals/index.js';
-const configSchema = {
-    strategy: {
-        type: 'select',
-        label: 'Approval Strategy',
-        description: 'How approval requests are handled',
-        default: 'mock',
-        options: [
-            { value: 'mock', label: 'Mock (Testing)' },
-            { value: 'callback', label: 'Callback (Promise-based)' },
-            { value: 'webhook', label: 'Webhook (HTTP handler)' },
-        ],
-    },
-};
-export const humanApprovalNodeTemplate = {
-    id: 'human-approval',
-    name: 'Human Approval',
-    description: 'Pause workflow and wait for human approval',
-    category: 'workflow',
-    configSchema,
-    generate: (name, config) => {
-        const funcName = name || 'humanApproval';
-        const label = toPascalCase(funcName);
-        const strategy = config?.strategy || 'mock';
-        const approvalCode = getApprovalCode(strategy);
-        return `
-// ============================================================
-// APPROVAL TYPES
-// ============================================================
-//
-// On durable targets, consider using the built-in waitForEvent node instead.
-// It maps to a platform-native durable pause for zero-cost waiting.
-
-${APPROVAL_TYPES}
-
-// ============================================================
-// APPROVAL PROVIDER
-// ============================================================
-
-${approvalCode}
-
-/**
- * Pause workflow and wait for human approval.
- * Returns whether the request was approved, along with the reviewer's response.
- *
- * @flowWeaver nodeType
- * @label ${label}
- * @color orange
- * @icon verified
- * @input execute [order:0] - Execute
- * @input prompt [order:1] - Approval prompt shown to reviewer
- * @input context [order:2] - Additional context for the reviewer (optional)
- * @input timeout [order:3] - Timeout duration e.g. "7d", "1h" (optional)
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure (timeout or error)
- * @output approved [order:2] - Whether the request was approved
- * @output response [order:3] - Reviewer's response text
- * @output reviewer [order:4] - Reviewer identifier
- */
-async function ${funcName}(
-  execute: boolean,
-  prompt: string,
-  context?: Record<string, unknown>,
-  timeout?: string
-): Promise<{
-  onSuccess: boolean;
-  onFailure: boolean;
-  approved: boolean;
-  response?: string;
-  reviewer?: string;
-}> {
-  if (!execute) {
-    return {
-      onSuccess: false,
-      onFailure: false,
-      approved: false,
-    };
-  }
-
-  try {
-    const result = await approvalProvider.requestApproval({
-      id: crypto.randomUUID(),
-      prompt,
-      context,
-      timeout,
-    });
-
-    return {
-      onSuccess: true,
-      onFailure: false,
-      approved: result.approved,
-      response: result.response,
-      reviewer: result.reviewer,
-    };
-  } catch (error) {
-    console.error('Approval request failed:', error);
-    return {
-      onSuccess: false,
-      onFailure: true,
-      approved: false,
-    };
-  }
-}
-`.trim();
-    },
-};
-//# sourceMappingURL=human-approval.js.map

package/dist/cli/templates/nodes/json-extractor.js

@@ -1,119 +0,0 @@
-import { toPascalCase } from '../index.js';
-export const jsonExtractorNodeTemplate = {
-    id: 'json-extractor',
-    name: 'JSON Extractor',
-    description: 'Extract structured JSON from LLM text output',
-    category: 'ai',
-    generate: (name) => {
-        const funcName = name || 'jsonExtractor';
-        const label = toPascalCase(funcName);
-        return `
-/**
- * Extract structured JSON from LLM text output.
- * Handles markdown code fences, leading/trailing text, and optional schema validation.
- *
- * Strips \\\`\\\`\\\`json ... \\\`\\\`\\\` fences, finds the first valid JSON object or array,
- * and optionally validates that expected field names are present.
- *
- * @flowWeaver nodeType
- * @expression
- * @label ${label}
- * @color cyan
- * @icon dataObject
- * @input text [order:0] - Raw text potentially containing JSON
- * @input schema [order:1] - Expected field names for validation (optional)
- * @output extracted [order:0] - Parsed JSON object (null if extraction failed)
- * @output valid [order:1] - Whether extraction and validation succeeded
- * @output raw [order:2] - The raw JSON string that was found
- */
-function ${funcName}(
-  text: string,
-  schema?: string[]
-): {
-  extracted: Record<string, unknown> | null;
-  valid: boolean;
-  raw: string;
-} {
-  if (!text || typeof text !== 'string') {
-    return { extracted: null, valid: false, raw: '' };
-  }
-
-  // Strip markdown code fences
-  let cleaned = text;
-  const fenceMatch = cleaned.match(/\\\`\\\`\\\`(?:json)?\\s*([\\s\\S]*?)\\\`\\\`\\\`/);
-  if (fenceMatch) {
-    cleaned = fenceMatch[1].trim();
-  }
-
-  // Find first JSON object or array via brace/bracket matching
-  const startChar = cleaned.indexOf('{') !== -1 && (cleaned.indexOf('[') === -1 || cleaned.indexOf('{') < cleaned.indexOf('['))
-    ? '{'
-    : '[';
-  const endChar = startChar === '{' ? '}' : ']';
-  const startIdx = cleaned.indexOf(startChar);
-
-  if (startIdx === -1) {
-    return { extracted: null, valid: false, raw: '' };
-  }
-
-  // Walk forward to find the matching closing brace/bracket
-  let depth = 0;
-  let inString = false;
-  let escape = false;
-  let endIdx = -1;
-
-  for (let i = startIdx; i < cleaned.length; i++) {
-    const ch = cleaned[i];
-
-    if (escape) {
-      escape = false;
-      continue;
-    }
-
-    if (ch === '\\\\') {
-      escape = true;
-      continue;
-    }
-
-    if (ch === '"') {
-      inString = !inString;
-      continue;
-    }
-
-    if (inString) continue;
-
-    if (ch === startChar) depth++;
-    if (ch === endChar) depth--;
-
-    if (depth === 0) {
-      endIdx = i;
-      break;
-    }
-  }
-
-  if (endIdx === -1) {
-    return { extracted: null, valid: false, raw: '' };
-  }
-
-  const raw = cleaned.slice(startIdx, endIdx + 1);
-
-  try {
-    const parsed = JSON.parse(raw);
-
-    // Validate schema if provided
-    if (schema && schema.length > 0 && typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
-      const missingFields = schema.filter(field => !(field in parsed));
-      if (missingFields.length > 0) {
-        return { extracted: parsed, valid: false, raw };
-      }
-    }
-
-    return { extracted: parsed, valid: true, raw };
-  } catch {
-    return { extracted: null, valid: false, raw };
-  }
-}
-`.trim();
-    },
-};
-//# sourceMappingURL=json-extractor.js.map