@synergenius/flow-weaver 0.2.0

package/dist/cli/templates/ai/mock-provider.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Mock LLM provider for testing/development
+ * Replace with real provider (OpenAI, Anthropic, etc.)
+ */
+import type { LLMProvider } from './types.js';
+export declare const createMockProvider: () => LLMProvider;
+//# sourceMappingURL=mock-provider.d.ts.map

package/dist/cli/templates/ai/mock-provider.js

@@ -0,0 +1,64 @@
+export const createMockProvider = () => ({
+    async chat(messages, options) {
+        const lastMessage = messages[messages.length - 1];
+        // Simulate tool calling if tools provided
+        if (options?.tools && options.tools.length > 0) {
+            const shouldCallTool = lastMessage.content.toLowerCase().includes('search') ||
+                lastMessage.content.toLowerCase().includes('calculate');
+            if (shouldCallTool) {
+                return {
+                    content: null,
+                    toolCalls: [
+                        {
+                            id: `call_${Date.now()}`,
+                            name: options.tools[0].name,
+                            arguments: { query: lastMessage.content },
+                        },
+                    ],
+                    finishReason: 'tool_calls',
+                };
+            }
+        }
+        return {
+            content: `[Mock Response to: ${lastMessage.content.slice(0, 50)}...]`,
+            toolCalls: [],
+            finishReason: 'stop',
+        };
+    },
+});
+// Example real provider adapter (in comments for user reference)
+/*
+import OpenAI from 'openai';
+
+export const createOpenAIProvider = (apiKey: string): LLMProvider => {
+  const client = new OpenAI({ apiKey });
+
+  return {
+    async chat(messages, options) {
+      const response = await client.chat.completions.create({
+        model: options?.model ?? 'gpt-4',
+        messages: messages.map(m => ({ role: m.role, content: m.content })),
+        tools: options?.tools?.map(t => ({ type: 'function', function: t })),
+        temperature: options?.temperature,
+        max_tokens: options?.maxTokens,
+      });
+
+      const choice = response.choices[0];
+      return {
+        content: choice.message.content,
+        toolCalls: choice.message.tool_calls?.map(tc => ({
+          id: tc.id,
+          name: tc.function.name,
+          arguments: JSON.parse(tc.function.arguments)
+        })) ?? [],
+        finishReason: choice.finish_reason as any,
+        usage: response.usage ? {
+          promptTokens: response.usage.prompt_tokens,
+          completionTokens: response.usage.completion_tokens
+        } : undefined
+      };
+    }
+  };
+};
+*/
+//# sourceMappingURL=mock-provider.js.map

package/dist/cli/templates/ai/types.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Provider-agnostic LLM types for Flow Weaver AI templates
+ */
+export interface LLMMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    toolCallId?: string;
+}
+export interface LLMTool {
+    name: string;
+    description: string;
+    parameters: {
+        type: 'object';
+        properties: Record<string, {
+            type: string;
+            description?: string;
+            enum?: string[];
+        }>;
+        required?: string[];
+    };
+}
+export interface LLMToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface LLMResponse {
+    content: string | null;
+    toolCalls: LLMToolCall[];
+    finishReason: 'stop' | 'tool_calls' | 'length' | 'error';
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+}
+export interface LLMOptions {
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    tools?: LLMTool[];
+    systemPrompt?: string;
+}
+export interface LLMProvider {
+    chat(messages: LLMMessage[], options?: LLMOptions): Promise<LLMResponse>;
+}
+export type LLMProviderFactory = () => LLMProvider;
+//# sourceMappingURL=types.d.ts.map

package/dist/cli/templates/ai/types.js

@@ -0,0 +1,5 @@
+/**
+ * Provider-agnostic LLM types for Flow Weaver AI templates
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/cli/templates/approvals/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Approval Strategy Code Generators
+ * Generate approval provider implementation code for different strategies.
+ *
+ * Mirrors the LLM provider pattern in providers/index.ts.
+ */
+export declare function generateMockApproval(): string;
+export declare function generateCallbackApproval(): string;
+export declare function generateWebhookApproval(): string;
+/**
+ * Get approval provider code for a given strategy.
+ * Mirrors getProviderCode() from providers/index.ts.
+ */
+export declare function getApprovalCode(strategy: string): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/templates/approvals/index.js

@@ -0,0 +1,241 @@
+/**
+ * Approval Strategy Code Generators
+ * Generate approval provider implementation code for different strategies.
+ *
+ * Mirrors the LLM provider pattern in providers/index.ts.
+ */
+export function generateMockApproval() {
+    return `/* ============================================================
+ * MOCK APPROVAL PROVIDER (For Testing)
+ * Auto-approves all requests. Replace with a real strategy for production.
+ * ============================================================ */
+
+const _defaultApprovalProvider: ApprovalProvider = {
+  async requestApproval(request) {
+    console.log('[Mock Approval] Auto-approving:', request.prompt);
+    return {
+      approved: true,
+      response: 'Auto-approved (mock)',
+      reviewer: 'system',
+    };
+  },
+};
+
+const approvalProvider: ApprovalProvider = (globalThis as unknown as { __fw_approval_provider__?: ApprovalProvider }).__fw_approval_provider__ ?? _defaultApprovalProvider;`;
+}
+export function generateCallbackApproval() {
+    return `/* ============================================================
+ * CALLBACK APPROVAL PROVIDER
+ *
+ * Pauses the workflow on a Promise. Call resolveApproval() from
+ * your HTTP handler, webhook, or external system to resume.
+ *
+ * Example integration:
+ *   app.post('/approve/:id', (req, res) => {
+ *     resolveApproval(req.params.id, true, req.body.response, req.body.reviewer);
+ *     res.json({ ok: true });
+ *   });
+ * ============================================================ */
+
+const _pendingApprovals = new Map<string, {
+  resolve: (result: ApprovalResult) => void;
+  request: ApprovalRequest;
+  createdAt: number;
+}>();
+
+/**
+ * Resolve a pending approval. Call this from your HTTP handler or external system.
+ * Returns true if the approval was found and resolved, false if not found.
+ */
+function resolveApproval(
+  id: string,
+  approved: boolean,
+  response?: string,
+  reviewer?: string,
+): boolean {
+  const pending = _pendingApprovals.get(id);
+  if (!pending) return false;
+  pending.resolve({ approved, response, reviewer });
+  _pendingApprovals.delete(id);
+  return true;
+}
+
+/** Get all currently pending approval requests */
+function getPendingApprovals(): Array<{ id: string; request: ApprovalRequest; createdAt: number }> {
+  return [..._pendingApprovals.entries()].map(([id, entry]) => ({
+    id,
+    request: entry.request,
+    createdAt: entry.createdAt,
+  }));
+}
+
+const _defaultApprovalProvider: ApprovalProvider = {
+  async requestApproval(request) {
+    const id = request.id || crypto.randomUUID();
+    console.log(\`[Approval] Waiting for approval: \${id} — "\${request.prompt}"\`);
+
+    return new Promise<ApprovalResult>((resolve) => {
+      _pendingApprovals.set(id, { resolve, request, createdAt: Date.now() });
+
+      // Set up timeout if specified
+      if (request.timeout) {
+        const ms = parseTimeout(request.timeout);
+        if (ms > 0) {
+          setTimeout(() => {
+            if (_pendingApprovals.has(id)) {
+              _pendingApprovals.delete(id);
+              resolve({ approved: false, response: 'Timed out' });
+            }
+          }, ms);
+        }
+      }
+    });
+  },
+};
+
+/** Parse timeout string like "7d", "24h", "30m" to milliseconds */
+function parseTimeout(timeout: string): number {
+  const match = timeout.match(/^(\\d+)\\s*(ms|s|m|h|d)$/);
+  if (!match) return 0;
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  const multipliers: Record<string, number> = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
+  return value * (multipliers[unit] ?? 0);
+}
+
+const approvalProvider: ApprovalProvider = (globalThis as unknown as { __fw_approval_provider__?: ApprovalProvider }).__fw_approval_provider__ ?? _defaultApprovalProvider;`;
+}
+export function generateWebhookApproval() {
+    return `/* ============================================================
+ * WEBHOOK APPROVAL PROVIDER
+ *
+ * Extends the callback pattern with a ready-made request handler.
+ * Mount createApprovalHandler() in your HTTP framework:
+ *
+ *   Express:  app.use('/approvals', createApprovalHandler());
+ *   Hono:     app.route('/approvals', createApprovalHandler());
+ *   Node.js:  http.createServer(createApprovalHandler());
+ *
+ * Endpoints:
+ *   POST /approve/:id  — Approve a request  (body: { response?, reviewer? })
+ *   POST /reject/:id   — Reject a request   (body: { response?, reviewer? })
+ *   GET  /pending       — List pending approvals
+ * ============================================================ */
+
+const _pendingApprovals = new Map<string, {
+  resolve: (result: ApprovalResult) => void;
+  request: ApprovalRequest;
+  createdAt: number;
+}>();
+
+function resolveApproval(
+  id: string,
+  approved: boolean,
+  response?: string,
+  reviewer?: string,
+): boolean {
+  const pending = _pendingApprovals.get(id);
+  if (!pending) return false;
+  pending.resolve({ approved, response, reviewer });
+  _pendingApprovals.delete(id);
+  return true;
+}
+
+function getPendingApprovals(): Array<{ id: string; request: ApprovalRequest; createdAt: number }> {
+  return [..._pendingApprovals.entries()].map(([id, entry]) => ({
+    id,
+    request: entry.request,
+    createdAt: entry.createdAt,
+  }));
+}
+
+/** Parse timeout string like "7d", "24h", "30m" to milliseconds */
+function parseTimeout(timeout: string): number {
+  const match = timeout.match(/^(\\d+)\\s*(ms|s|m|h|d)$/);
+  if (!match) return 0;
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  const multipliers: Record<string, number> = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
+  return value * (multipliers[unit] ?? 0);
+}
+
+/**
+ * Creates an HTTP request handler for approval webhooks.
+ * Returns a function compatible with Node.js http.createServer(),
+ * or mount it as middleware in Express/Hono/Fastify.
+ */
+function createApprovalHandler(): (req: { method?: string; url?: string; }, res: { writeHead: (status: number, headers?: Record<string, string>) => void; end: (body?: string) => void; }) => Promise<void> {
+  return async (req, res) => {
+    const url = req.url ?? '';
+    const method = req.method ?? 'GET';
+
+    // GET /pending
+    if (method === 'GET' && url.match(/\\/pending\\/?$/)) {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ pending: getPendingApprovals() }));
+      return;
+    }
+
+    // POST /approve/:id or POST /reject/:id
+    const match = url.match(/\\/(approve|reject)\\/([^/?]+)/);
+    if (method === 'POST' && match) {
+      const [, action, id] = match;
+      const resolved = resolveApproval(
+        id,
+        action === 'approve',
+        undefined,
+        undefined,
+      );
+      res.writeHead(resolved ? 200 : 404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ resolved, id, action }));
+      return;
+    }
+
+    res.writeHead(404);
+    res.end('Not found');
+  };
+}
+
+const _defaultApprovalProvider: ApprovalProvider = {
+  async requestApproval(request) {
+    const id = request.id || crypto.randomUUID();
+    console.log(\`[Approval Webhook] Waiting for approval: \${id} — "\${request.prompt}"\`);
+    console.log(\`  POST /approve/\${id}  to approve\`);
+    console.log(\`  POST /reject/\${id}   to reject\`);
+
+    return new Promise<ApprovalResult>((resolve) => {
+      _pendingApprovals.set(id, { resolve, request, createdAt: Date.now() });
+
+      if (request.timeout) {
+        const ms = parseTimeout(request.timeout);
+        if (ms > 0) {
+          setTimeout(() => {
+            if (_pendingApprovals.has(id)) {
+              _pendingApprovals.delete(id);
+              resolve({ approved: false, response: 'Timed out' });
+            }
+          }, ms);
+        }
+      }
+    });
+  },
+};
+
+const approvalProvider: ApprovalProvider = (globalThis as unknown as { __fw_approval_provider__?: ApprovalProvider }).__fw_approval_provider__ ?? _defaultApprovalProvider;`;
+}
+/**
+ * Get approval provider code for a given strategy.
+ * Mirrors getProviderCode() from providers/index.ts.
+ */
+export function getApprovalCode(strategy) {
+    switch (strategy) {
+        case 'callback':
+            return generateCallbackApproval();
+        case 'webhook':
+            return generateWebhookApproval();
+        case 'mock':
+        default:
+            return generateMockApproval();
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/cli/templates/index.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Flow Weaver Template Registry
+ * Central registry for workflow and node templates
+ */
+/**
+ * Configuration field types
+ */
+export type ConfigFieldType = 'select' | 'string' | 'boolean' | 'number';
+/**
+ * A configuration field definition
+ */
+export interface ConfigField {
+    type: ConfigFieldType;
+    label: string;
+    description?: string;
+    default?: unknown;
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+    placeholder?: string;
+    dependsOn?: {
+        field: string;
+        values: string[];
+    };
+}
+/**
+ * Configuration schema for a template
+ */
+export interface ConfigSchema {
+    [fieldName: string]: ConfigField;
+}
+/**
+ * Options for generating a workflow template
+ */
+export interface WorkflowTemplateOptions {
+    /** Name for the workflow function */
+    workflowName: string;
+    /** Whether to generate an async workflow */
+    async?: boolean;
+    /** Configuration values for the template */
+    config?: Record<string, unknown>;
+}
+/**
+ * A workflow template definition
+ */
+export interface WorkflowTemplate {
+    /** Unique template ID (used in CLI) */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Brief description of the template */
+    description: string;
+    /** Category for grouping */
+    category: 'data-processing' | 'automation' | 'ai' | 'integration' | 'utility';
+    /** Configuration schema for the template */
+    configSchema?: ConfigSchema;
+    /** Generate the template code */
+    generate: (options: WorkflowTemplateOptions) => string;
+}
+/**
+ * A node type template definition
+ */
+export interface NodeTemplate {
+    /** Unique template ID */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Brief description */
+    description: string;
+    /** Category for grouping */
+    category: 'ai' | 'validation' | 'data' | 'integration' | 'workflow';
+    /** Configuration schema for the template (optional) */
+    configSchema?: ConfigSchema;
+    /** Generate the template code */
+    generate: (name: string, config?: Record<string, unknown>) => string;
+}
+/**
+ * All available workflow templates
+ */
+export declare const workflowTemplates: WorkflowTemplate[];
+/**
+ * All available node templates
+ */
+export declare const nodeTemplates: NodeTemplate[];
+/**
+ * Get a workflow template by ID
+ */
+export declare function getWorkflowTemplate(id: string): WorkflowTemplate | undefined;
+/**
+ * Get a node template by ID
+ */
+export declare function getNodeTemplate(id: string): NodeTemplate | undefined;
+/**
+ * Convert a string to camelCase
+ */
+export declare function toCamelCase(str: string): string;
+/**
+ * Convert a string to PascalCase (for labels)
+ */
+export declare function toPascalCase(str: string): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/templates/index.js

@@ -0,0 +1,101 @@
+/**
+ * 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 { aiAgentDurableTemplate } from './workflows/ai-agent-durable.js';
+import { aiPipelineDurableTemplate } from './workflows/ai-pipeline-durable.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,
+    aiAgentDurableTemplate,
+    aiPipelineDurableTemplate,
+];
+/**
+ * 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
+ */
+export function getWorkflowTemplate(id) {
+    return workflowTemplates.find((t) => t.id === id);
+}
+/**
+ * Get a node template by ID
+ */
+export function getNodeTemplate(id) {
+    return nodeTemplates.find((t) => t.id === id);
+}
+/**
+ * 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.d.ts

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