@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/templates/workflows/foreach.js

@@ -1,140 +0,0 @@
-/**
- * ForEach Batch Processing Template
- * Iterate over array items with scoped ports
- */
-export const foreachTemplate = {
-    id: 'foreach',
-    name: 'ForEach Batch',
-    description: 'Batch processing with iteration over arrays',
-    category: 'data-processing',
-    generate: (opts) => {
-        const { workflowName, async: isAsync } = opts;
-        const asyncKeyword = isAsync ? 'async ' : '';
-        const returnType = isAsync
-            ? 'Promise<{ onSuccess: boolean; onFailure: boolean; results: any[]; successCount: number; failedCount: number }>'
-            : '{ onSuccess: boolean; onFailure: boolean; results: any[]; successCount: number; failedCount: number }';
-        return `
-/**
- * Iterates over items and processes each one
- *
- * @flowWeaver nodeType
- * @label For Each Item
- * @input items [order:1] - Array of items to iterate
- * @input success scope:processItem [order:0] - From child onSuccess
- * @input failure scope:processItem [order:1] - From child onFailure
- * @input result scope:processItem [order:2] - Result from child
- * @input execute [order:0] - Execute
- * @output start scope:processItem [order:0] - Triggers child execute
- * @output item scope:processItem [order:1] - Current item to process
- * @output results [order:2] - Collected results after iteration
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure
- */
-function forEachItem(
-  execute: boolean,
-  items: any[],
-  processItem: (start: boolean, item: any) => { success: boolean; failure: boolean; result: any }
-): { onSuccess: boolean; onFailure: boolean; results: any[] } {
-  if (!execute) {
-    return { onSuccess: false, onFailure: false, results: [] };
-  }
-
-  const results: any[] = [];
-  for (const item of items) {
-    const r = processItem(true, item);
-    results.push(r.result);
-  }
-
-  return { onSuccess: true, onFailure: false, results };
-}
-
-/**
- * Processes a single item
- *
- * @flowWeaver nodeType
- * @label Process Item
- * @input item [order:1] - Item to process
- * @input execute [order:0] - Execute
- * @output result [order:2] - Processed result
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure
- */
-function processItem(
-  execute: boolean,
-  item: any
-): { onSuccess: boolean; onFailure: boolean; result: any } {
-  if (!execute) {
-    return { onSuccess: false, onFailure: false, result: null };
-  }
-
-  // TODO: Add your processing logic here
-  const result = { ...item, processed: true };
-
-  return { onSuccess: true, onFailure: false, result };
-}
-
-/**
- * Aggregates results from iteration
- *
- * @flowWeaver nodeType
- * @label Aggregate Results
- * @input results [order:1] - Array of processed results
- * @input execute [order:0] - Execute
- * @output successCount [order:2] - Number of successes
- * @output failedCount [order:3] - Number of failures
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure
- */
-function aggregateResults(
-  execute: boolean,
-  results: any[]
-): { onSuccess: boolean; onFailure: boolean; successCount: number; failedCount: number } {
-  if (!execute) {
-    return { onSuccess: false, onFailure: false, successCount: 0, failedCount: 0 };
-  }
-
-  const successCount = results.filter(r => r?.processed).length;
-  const failedCount = results.length - successCount;
-
-  return { onSuccess: true, onFailure: false, successCount, failedCount };
-}
-
-/**
- * @flowWeaver workflow
- * @node iterator forEachItem [position: -90 0] [color: "purple"] [icon: "repeat"] [suppress: "DESIGN_SCOPE_NO_FAILURE_EXIT"]
- * @node processor processItem iterator.processItem [color: "blue"] [icon: "settings"]
- * @node aggregator aggregateResults [position: 270 0] [color: "teal"] [icon: "inventory"]
- * @position Start -450 0
- * @position Exit 450 0
- * @connect Start.execute -> iterator.execute
- * @connect Start.items -> iterator.items
- * @connect iterator.start:processItem -> processor.execute
- * @connect iterator.item:processItem -> processor.item
- * @connect processor.result -> iterator.result:processItem
- * @connect processor.onSuccess -> iterator.success:processItem
- * @connect processor.onFailure -> iterator.failure:processItem
- * @connect iterator.results -> Exit.results
- * @connect iterator.results -> aggregator.results
- * @connect iterator.onSuccess -> aggregator.execute
- * @connect aggregator.successCount -> Exit.successCount
- * @connect aggregator.failedCount -> Exit.failedCount
- * @connect aggregator.onSuccess -> Exit.onSuccess
- * @connect aggregator.onFailure -> Exit.onFailure
- * @param execute [order:0] - Execute
- * @param items [order:1] - Array of items to process
- * @returns onSuccess [order:0] - On Success
- * @returns onFailure [order:1] - On Failure
- * @returns results [order:2] - Processed results
- * @returns successCount [order:3] - Number of successful items
- * @returns failedCount [order:4] - Number of failed items
- */
-export ${asyncKeyword}function ${workflowName}(
-  execute: boolean,
-  params: { items: any[] }
-): ${returnType} {
-  throw new Error("Compile with: fw compile <file>");
-}
-`.trim();
-    },
-};
-//# sourceMappingURL=foreach.js.map

package/dist/cli/templates/workflows/sequential.js

@@ -1,200 +0,0 @@
-/**
- * Sequential Pipeline Template
- * Linear data processing: validate -> transform -> output
- */
-const configSchema = {
-    nodes: {
-        type: 'string',
-        label: 'Node Names',
-        description: 'Comma-separated list of node function names (e.g. "fetch,parse,store")',
-        placeholder: 'validateData,transformData,outputResult',
-    },
-    input: {
-        type: 'string',
-        label: 'Input Port Name',
-        description: 'Name of the input data port',
-        default: 'data',
-        placeholder: 'data',
-    },
-    output: {
-        type: 'string',
-        label: 'Output Port Name',
-        description: 'Name of the output data port',
-        default: 'result',
-        placeholder: 'result',
-    },
-};
-function generateDefaultTemplate(workflowName, asyncKeyword, returnType) {
-    return `
-// Use @expression for most functions, normal mode only for error-with-data or void side-effects
-
-/**
- * Validates input data
- * Normal mode: explicit error routing with data on failure
- *
- * @flowWeaver nodeType
- * @label Validate
- * @input data [order:1] - Data to validate
- * @input execute [order:0] - Execute
- * @output data [order:2] - Validated data
- * @output isValid [order:3] - Validation passed
- * @output error [order:4] - Validation error message
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure
- */
-function validateData(
-  execute: boolean,
-  data: any
-): { onSuccess: boolean; onFailure: boolean; data: any; isValid: boolean; error: string | null } {
-  if (!execute) {
-    return { onSuccess: false, onFailure: false, data: null, isValid: false, error: null };
-  }
-
-  // TODO: Add validation logic
-  if (!data) {
-    return { onSuccess: false, onFailure: true, data: null, isValid: false, error: "Data is required" };
-  }
-
-  return { onSuccess: true, onFailure: false, data, isValid: true, error: null };
-}
-
-/**
- * Transforms validated data
- *
- * @flowWeaver nodeType
- * @expression
- * @label Transform
- * @input data [order:0] - Data to transform
- * @output data [order:0] - Transformed data
- */
-function transformData(data: any): { data: any } {
-  // TODO: Add transformation logic
-  return { data: { ...data, processedAt: new Date().toISOString() } };
-}
-
-/**
- * Outputs the final result
- *
- * @flowWeaver nodeType
- * @expression
- * @label Output
- * @input data [order:0] - Data to output
- * @output result [order:0] - Final result
- */
-function outputResult(data: any): { result: any } {
-  return { result: data };
-}
-
-/**
- * @flowWeaver workflow
- * @node validator validateData [position: -300 0] [color: "green"] [icon: "verified"] [suppress: "UNUSED_OUTPUT_PORT"]
- * @node transformer transformData [position: 0 0] [color: "blue"] [icon: "sync"]
- * @node outputter outputResult [position: 300 0] [color: "cyan"] [icon: "inventory"]
- * @position Start -600 0
- * @position Exit 600 0
- * @path Start -> validator -> transformer -> outputter -> Exit
- * @connect outputter.result -> Exit.result
- * @connect validator.onFailure -> Exit.onFailure
- * @connect validator.error -> Exit.error
- * @param execute [order:0] - Execute
- * @param data [order:1] - Input data
- * @returns onSuccess [order:0] - On Success
- * @returns onFailure [order:1] - On Failure
- * @returns result [order:2] - Processed result
- * @returns error [order:3] - Error message if failed
- */
-export ${asyncKeyword}function ${workflowName}(
-  execute: boolean,
-  params: { data: any }
-): ${returnType} {
-  throw new Error("Compile with: fw compile <file>");
-}
-`.trim();
-}
-function generateCustomTemplate(workflowName, asyncKeyword, returnType, nodeNames, inputPort, outputPort) {
-    // Generate node type functions
-    const nodeTypeDefs = nodeNames.map((name, i) => {
-        const isFirst = i === 0;
-        const isLast = i === nodeNames.length - 1;
-        const inputPortName = isFirst ? inputPort : 'data';
-        const outputPortName = isLast ? outputPort : 'data';
-        return `/**
- * ${name} step
- *
- * @flowWeaver nodeType
- * @expression
- * @label ${name.charAt(0).toUpperCase() + name.slice(1)}
- * @input ${inputPortName} [order:0] - Input data
- * @output ${outputPortName} [order:0] - Output data
- */
-function ${name}(${inputPortName}: any): { ${outputPortName}: any } {
-  // TODO: Implement ${name} logic
-  return { ${outputPortName}: ${inputPortName} };
-}`;
-    });
-    // Generate workflow annotations
-    const spacing = 300;
-    const startX = -(nodeNames.length * (spacing / 2) + spacing / 2);
-    const stepColors = ['green', 'blue', 'cyan', 'orange', 'purple', 'teal', 'pink', 'yellow'];
-    const nodeAnnotations = nodeNames.map((name, i) => {
-        const x = startX + (i + 1) * spacing;
-        const color = stepColors[i % stepColors.length];
-        return ` * @node step${i} ${name} [position: ${x} 0] [color: "${color}"] [icon: "settings"]`;
-    }).join('\n');
-    const positionAnnotations = [
-        ` * @position Start ${startX} 0`,
-        ` * @position Exit ${startX + (nodeNames.length + 1) * spacing} 0`,
-    ].join('\n');
-    // Build connections using @path sugar
-    const pathNodes = ['Start', ...nodeNames.map((_, i) => `step${i}`), 'Exit'];
-    const connections = [];
-    connections.push(` * @path ${pathNodes.join(' -> ')}`);
-    connections.push(` * @connect step0.onFailure -> Exit.onFailure`);
-    return `${nodeTypeDefs.join('\n\n')}
-
-/**
- * @flowWeaver workflow
-${nodeAnnotations}
-${positionAnnotations}
-${connections.join('\n')}
- * @param execute [order:0] - Execute
- * @param ${inputPort} [order:1] - Input data
- * @returns onSuccess [order:0] - On Success
- * @returns onFailure [order:1] - On Failure
- * @returns ${outputPort} [order:2] - Processed result
- * @returns error [order:3] - Error message if failed
- */
-export ${asyncKeyword}function ${workflowName}(
-  execute: boolean,
-  params: { ${inputPort}: any }
-): ${returnType} {
-  throw new Error("Compile with: fw compile <file>");
-}`.trim();
-}
-export const sequentialTemplate = {
-    id: 'sequential',
-    name: 'Sequential Pipeline',
-    description: 'Linear pipeline: validate -> transform -> output',
-    category: 'data-processing',
-    configSchema,
-    generate: (opts) => {
-        const { workflowName, async: isAsync, config } = opts;
-        const asyncKeyword = isAsync ? 'async ' : '';
-        const returnType = isAsync
-            ? 'Promise<{ onSuccess: boolean; onFailure: boolean; result: any; error?: string }>'
-            : '{ onSuccess: boolean; onFailure: boolean; result: any; error?: string }';
-        // If custom nodes are provided, generate custom template
-        const customNodes = config?.nodes;
-        const inputPort = config?.input || 'data';
-        const outputPort = config?.output || 'result';
-        if (customNodes && Array.isArray(customNodes) && customNodes.length > 0) {
-            return generateCustomTemplate(workflowName, asyncKeyword, returnType, customNodes, inputPort, outputPort);
-        }
-        // If only input/output are customized but no custom nodes
-        if (inputPort !== 'data' || outputPort !== 'result') {
-            return generateCustomTemplate(workflowName, asyncKeyword, returnType, ['validateData', 'transformData', 'outputResult'], inputPort, outputPort);
-        }
-        return generateDefaultTemplate(workflowName, asyncKeyword, returnType);
-    },
-};
-//# sourceMappingURL=sequential.js.map

package/dist/cli/templates/workflows/webhook.js

@@ -1,158 +0,0 @@
-/**
- * Webhook Template
- * HTTP-triggered workflow entry point
- */
-export const webhookTemplate = {
-    id: "webhook",
-    name: "Webhook Handler",
-    description: "HTTP-triggered workflow with request/response handling",
-    category: "integration",
-    generate: (opts) => {
-        const { workflowName, async: isAsync } = opts;
-        const asyncKeyword = isAsync ? "async " : "";
-        const returnType = isAsync
-            ? "Promise<{ onSuccess: boolean; onFailure: boolean; statusCode: number; body: any }>"
-            : "{ onSuccess: boolean; onFailure: boolean; statusCode: number; body: any }";
-        return `
-/**
- * Validates incoming webhook request
- *
- * @flowWeaver nodeType
- * @label Validate Request
- * @input headers [order:1] - Request headers
- * @input body [order:2] - Request body
- * @input execute [order:0] - Execute
- * @output isValid [order:2] - Whether request is valid
- * @output validatedData [order:3] - Validated request data
- * @output error [order:4] - Validation error message
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure
- */
-function validateRequest(
-  execute: boolean,
-  headers: Record<string, string>,
-  body: any
-): { onSuccess: boolean; onFailure: boolean; isValid: boolean; validatedData: any; error: string } {
-  if (!execute) {
-    return { onSuccess: false, onFailure: false, isValid: false, validatedData: null, error: "" };
-  }
-
-  // TODO: Add your validation logic
-  // Example: Check API key, validate body schema, etc.
-  const apiKey = headers["x-api-key"] || headers["authorization"];
-
-  if (!apiKey) {
-    return { onSuccess: false, onFailure: true, isValid: false, validatedData: null, error: "Missing API key" };
-  }
-
-  return { onSuccess: true, onFailure: false, isValid: true, validatedData: body, error: "" };
-}
-
-/**
- * Processes the webhook payload
- *
- * @flowWeaver nodeType
- * @label Process Payload
- * @input data [order:1] - Validated payload data
- * @input execute [order:0] - Execute
- * @output result [order:2] - Processing result
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure
- */
-function processPayload(
-  execute: boolean,
-  data: any
-): { onSuccess: boolean; onFailure: boolean; result: any } {
-  if (!execute) {
-    return { onSuccess: false, onFailure: false, result: null };
-  }
-
-  // TODO: Add your business logic
-  const result = {
-    processed: true,
-    timestamp: new Date().toISOString(),
-    data
-  };
-
-  return { onSuccess: true, onFailure: false, result };
-}
-
-/**
- * Formats the HTTP response
- *
- * @flowWeaver nodeType
- * @label Format Response
- * @input result [order:1] - Processing result
- * @input error [order:2] - Error message if any
- * @input isSuccess [order:3] - Whether processing succeeded
- * @input execute [order:0] - Execute
- * @output statusCode [order:2] - HTTP status code
- * @output body [order:3] - Response body
- * @output onSuccess [order:0] - On Success
- * @output onFailure [order:1] - On Failure
- */
-function formatResponse(
-  execute: boolean,
-  result: any,
-  error: string,
-  isSuccess: boolean
-): { onSuccess: boolean; onFailure: boolean; statusCode: number; body: any } {
-  if (!execute) {
-    return { onSuccess: false, onFailure: false, statusCode: 0, body: null };
-  }
-
-  if (isSuccess) {
-    return {
-      onSuccess: true,
-      onFailure: false,
-      statusCode: 200,
-      body: { success: true, data: result }
-    };
-  } else {
-    return {
-      onSuccess: true,
-      onFailure: false,
-      statusCode: 400,
-      body: { success: false, error: error || "Processing failed" }
-    };
-  }
-}
-
-/**
- * @flowWeaver workflow
- * @node validator validateRequest [position: -180 0] [color: "green"] [icon: "verified"]
- * @node processor processPayload [position: 90 -60] [color: "blue"] [icon: "settings"]
- * @node responder formatResponse [position: 270 0] [color: "cyan"] [icon: "send"]
- * @position Start -450 0
- * @position Exit 450 0
- * @connect Start.execute -> validator.execute
- * @connect Start.headers -> validator.headers
- * @connect Start.body -> validator.body
- * @connect validator.onSuccess -> processor.execute
- * @connect validator.validatedData -> processor.data
- * @connect validator.error -> responder.error
- * @connect processor.onSuccess -> responder.execute
- * @connect processor.result -> responder.result
- * @connect validator.isValid -> responder.isSuccess
- * @connect responder.statusCode -> Exit.statusCode
- * @connect responder.body -> Exit.body
- * @connect responder.onSuccess -> Exit.onSuccess
- * @connect responder.onFailure -> Exit.onFailure
- * @param execute [order:0] - Execute
- * @param headers [order:1] - HTTP request headers
- * @param body [order:2] - HTTP request body
- * @returns onSuccess [order:0] - On Success
- * @returns onFailure [order:1] - On Failure
- * @returns statusCode [order:2] - HTTP response status code
- * @returns body [order:3] - HTTP response body
- */
-export ${asyncKeyword}function ${workflowName}(
-  execute: boolean,
-  params: { headers: Record<string, string>; body: any }
-): ${returnType} {
-  throw new Error("Compile with: fw compile <file>");
-}
-`.trim();
-    },
-};
-//# sourceMappingURL=webhook.js.map

package/dist/cli/utils/cli-helpers.d.ts

@@ -1,44 +0,0 @@
-/**
- * Shared CLI utilities for consistent UX across all commands.
- */
-import { loadCredentials } from '../config/credentials.js';
-import { PlatformClient } from '../config/platform-client.js';
-export declare function isUuid(value: string): boolean;
-export interface LoginContext {
-    creds: NonNullable<ReturnType<typeof loadCredentials>>;
-    client: PlatformClient;
-}
-/**
- * Require login. Exits with code 1 and a helpful message if not logged in.
- * Returns both the stored credentials and a PlatformClient instance.
- */
-export declare function requireLogin(): LoginContext;
-/**
- * Read a line from stdin. Returns the trimmed input.
- * In non-TTY environments (piped input, CI), returns null instead of hanging.
- * Handles Ctrl+C / readline close gracefully by resolving null.
- */
-export declare function readLine(prompt: string): Promise<string | null>;
-/**
- * Ask for confirmation. Returns true only if user types 'y'.
- * In non-TTY environments, returns false (safe default).
- */
-export declare function confirm(prompt: string): Promise<boolean>;
-export declare const fmt: {
-    ok: (msg: string) => string;
-    err: (msg: string) => string;
-    dim: (msg: string) => string;
-    bold: (msg: string) => string;
-    cyan: (msg: string) => string;
-    yellow: (msg: string) => string;
-};
-/**
- * Extract a user-friendly error message. Maps common HTTP status codes
- * to actionable messages.
- */
-export declare function formatError(err: unknown, fallback: string): string;
-/**
- * Log an error and exit with code 1.
- */
-export declare function exitWithError(err: unknown, fallback: string): never;
-//# sourceMappingURL=cli-helpers.d.ts.map

package/dist/cli/utils/cli-helpers.js

@@ -1,99 +0,0 @@
-/**
- * Shared CLI utilities for consistent UX across all commands.
- */
-import * as readline from 'node:readline';
-import { loadCredentials } from '../config/credentials.js';
-import { PlatformClient } from '../config/platform-client.js';
-// ---------------------------------------------------------------------------
-// UUID detection
-// ---------------------------------------------------------------------------
-const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-export function isUuid(value) {
-    return UUID_RE.test(value);
-}
-/**
- * Require login. Exits with code 1 and a helpful message if not logged in.
- * Returns both the stored credentials and a PlatformClient instance.
- */
-export function requireLogin() {
-    const creds = loadCredentials();
-    if (!creds) {
-        console.error('  \x1b[31m✗\x1b[0m Not logged in. Run: fw login');
-        process.exit(1);
-    }
-    return { creds, client: new PlatformClient(creds) };
-}
-// ---------------------------------------------------------------------------
-// Interactive input
-// ---------------------------------------------------------------------------
-/**
- * Read a line from stdin. Returns the trimmed input.
- * In non-TTY environments (piped input, CI), returns null instead of hanging.
- * Handles Ctrl+C / readline close gracefully by resolving null.
- */
-export function readLine(prompt) {
-    if (!process.stdin.isTTY) {
-        return Promise.resolve(null);
-    }
-    const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
-    return new Promise((resolve) => {
-        let answered = false;
-        rl.question(prompt, (answer) => {
-            answered = true;
-            rl.close();
-            resolve(answer.trim());
-        });
-        rl.on('close', () => {
-            if (!answered)
-                resolve(null);
-        });
-    });
-}
-/**
- * Ask for confirmation. Returns true only if user types 'y'.
- * In non-TTY environments, returns false (safe default).
- */
-export async function confirm(prompt) {
-    const answer = await readLine(prompt);
-    if (answer === null)
-        return false;
-    return answer.toLowerCase() === 'y';
-}
-// ---------------------------------------------------------------------------
-// Output formatting
-// ---------------------------------------------------------------------------
-export const fmt = {
-    ok: (msg) => `  \x1b[32m✓\x1b[0m ${msg}`,
-    err: (msg) => `  \x1b[31m✗\x1b[0m ${msg}`,
-    dim: (msg) => `\x1b[2m${msg}\x1b[0m`,
-    bold: (msg) => `\x1b[1m${msg}\x1b[0m`,
-    cyan: (msg) => `\x1b[36m${msg}\x1b[0m`,
-    yellow: (msg) => `\x1b[33m${msg}\x1b[0m`,
-};
-// ---------------------------------------------------------------------------
-// Error handling
-// ---------------------------------------------------------------------------
-/**
- * Extract a user-friendly error message. Maps common HTTP status codes
- * to actionable messages.
- */
-export function formatError(err, fallback) {
-    if (!(err instanceof Error))
-        return fallback;
-    const msg = err.message;
-    if (msg.includes('401') || msg.includes('Auth failed')) {
-        return 'Session expired. Run: fw login';
-    }
-    if (msg.includes('403') || msg.includes('Forbidden')) {
-        return msg; // Pass through — 403 errors usually have specific messages like "requires Pro plan"
-    }
-    return msg;
-}
-/**
- * Log an error and exit with code 1.
- */
-export function exitWithError(err, fallback) {
-    console.error(fmt.err(formatError(err, fallback)));
-    process.exit(1);
-}
-//# sourceMappingURL=cli-helpers.js.map