@synergenius/flow-weaver 0.2.0

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

@@ -0,0 +1,114 @@
+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.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Aggregator Node Template
+ * Combine multiple inputs into a single output
+ */
+import type { NodeTemplate } from "../index.js";
+export declare const aggregatorNodeTemplate: NodeTemplate;
+//# sourceMappingURL=aggregator.d.ts.map

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

@@ -0,0 +1,63 @@
+/**
+ * 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.d.ts

@@ -0,0 +1,3 @@
+import type { NodeTemplate } from '../index.js';
+export declare const conversationMemoryNodeTemplate: NodeTemplate;
+//# sourceMappingURL=conversation-memory.d.ts.map

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

@@ -0,0 +1,85 @@
+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.d.ts

@@ -0,0 +1,7 @@
+/**
+ * HTTP Node Template
+ * HTTP request with configurable method, headers, body
+ */
+import type { NodeTemplate } from "../index.js";
+export declare const httpNodeTemplate: NodeTemplate;
+//# sourceMappingURL=http.d.ts.map

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

@@ -0,0 +1,80 @@
+/**
+ * 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.d.ts

@@ -0,0 +1,3 @@
+import type { NodeTemplate } from '../index.js';
+export declare const humanApprovalNodeTemplate: NodeTemplate;
+//# sourceMappingURL=human-approval.d.ts.map

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

@@ -0,0 +1,110 @@
+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 Inngest targets, consider using the built-in waitForEvent node instead —
+// it maps to step.waitForEvent() for zero-cost durable pauses.
+// See: https://www.inngest.com/docs/reference/functions/step-wait-for-event
+
+${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.d.ts

@@ -0,0 +1,3 @@
+import type { NodeTemplate } from '../index.js';
+export declare const jsonExtractorNodeTemplate: NodeTemplate;
+//# sourceMappingURL=json-extractor.d.ts.map

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

@@ -0,0 +1,119 @@
+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

package/dist/cli/templates/nodes/llm-call.d.ts

@@ -0,0 +1,3 @@
+import type { NodeTemplate } from '../index.js';
+export declare const llmCallNodeTemplate: NodeTemplate;
+//# sourceMappingURL=llm-call.d.ts.map