@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/flow-weaver-chunk-MMV2XGD3.mjs

@@ -0,0 +1,3291 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+
+// src/cli/templates/shared/case.ts
+function toCamelCase(str) {
+  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_$]+/, "").replace(/^./, (c) => c.toLowerCase());
+  const final = leading + result;
+  return final || "_" + str.replace(/[^a-zA-Z0-9_$]/g, "");
+}
+function toPascalCase(str) {
+  const camel = toCamelCase(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+
+// src/cli/templates/workflows/sequential.ts
+var 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 [color: "green"] [icon: "verified"] [suppress: "UNUSED_OUTPUT_PORT"]
+ * @node transformer transformData [color: "blue"] [icon: "sync"]
+ * @node outputter outputResult [color: "cyan"] [icon: "inventory"]
+ * @path Start -> validator -> transformer -> outputter -> Exit
+ * @path Start -> validator:fail -> Exit
+ * @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) {
+  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} };
+}`;
+  });
+  const stepColors = ["green", "blue", "cyan", "orange", "purple", "teal", "pink", "yellow"];
+  const nodeAnnotations = nodeNames.map((name, i) => {
+    const color = stepColors[i % stepColors.length];
+    return ` * @node step${i} ${name} [color: "${color}"] [icon: "settings"]`;
+  }).join("\n");
+  const pathNodes = ["Start", ...nodeNames.map((_, i) => `step${i}`), "Exit"];
+  const connections = [];
+  connections.push(` * @path ${pathNodes.join(" -> ")}`);
+  connections.push(` * @path Start -> step0:fail -> Exit`);
+  return `${nodeTypeDefs.join("\n\n")}
+
+/**
+ * @flowWeaver workflow
+${nodeAnnotations}
+${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
+ */
+export ${asyncKeyword}function ${workflowName}(
+  execute: boolean,
+  params: { ${inputPort}: any }
+): ${returnType} {
+  throw new Error("Compile with: fw compile <file>");
+}`.trim();
+}
+var 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 returnTypeFor = (outputPort2, withError) => {
+      const body = `onSuccess: boolean, onFailure: boolean, ${outputPort2}: any${withError ? ", error: string | null" : ""}`;
+      return isAsync ? `Promise<{ ${body} }>` : `{ ${body} }`;
+    };
+    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,
+        returnTypeFor(outputPort, false),
+        customNodes,
+        inputPort,
+        outputPort
+      );
+    }
+    if (inputPort !== "data" || outputPort !== "result") {
+      return generateCustomTemplate(
+        workflowName,
+        asyncKeyword,
+        returnTypeFor(outputPort, false),
+        ["validateData", "transformData", "outputResult"],
+        inputPort,
+        outputPort
+      );
+    }
+    return generateDefaultTemplate(workflowName, asyncKeyword, returnTypeFor("result", true));
+  }
+};
+
+// src/cli/templates/workflows/foreach.ts
+var 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.
+ * Normal mode on purpose: a scope owner drives its child through scoped STEP ports.
+ *
+ * @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. A throw here aborts the whole batch with that
+ * error; to record a per-item failure instead, return it as part of the result.
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Process Item
+ * @input item - Item to process
+ * @output result - Processed result
+ */
+function processItem(item: any): { result: any } {
+  // TODO: Add your processing logic here
+  return { result: { ...item, processed: true } };
+}
+
+/**
+ * Aggregates results from iteration
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Aggregate Results
+ * @input results - Array of processed results
+ * @output successCount - Number of successes
+ * @output failedCount - Number of failures
+ */
+function aggregateResults(results: any[]): { successCount: number; failedCount: number } {
+  const successCount = results.filter(r => r?.processed).length;
+  return { successCount, failedCount: results.length - successCount };
+}
+
+/**
+ * @flowWeaver workflow
+ * @node iterator forEachItem [color: "purple"] [icon: "repeat"] [suppress: "DESIGN_SCOPE_NO_FAILURE_EXIT"]
+ * @node processor processItem iterator.processItem [color: "blue"] [icon: "settings"]
+ * @node aggregator aggregateResults [color: "teal"] [icon: "inventory"]
+ * @path Start -> iterator -> aggregator -> Exit
+ * @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
+ * @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();
+  }
+};
+
+// src/cli/templates/workflows/conditional.ts
+var conditionalTemplate = {
+  id: "conditional",
+  name: "Conditional Router",
+  description: "Route data based on conditions with branching paths",
+  category: "automation",
+  generate: (opts) => {
+    const { workflowName, async: isAsync } = opts;
+    const asyncKeyword = isAsync ? "async " : "";
+    const returnType = isAsync ? "Promise<{ onSuccess: boolean; onFailure: boolean; successResult?: any; failureResult?: any }>" : "{ onSuccess: boolean; onFailure: boolean; successResult?: any; failureResult?: any }";
+    return `
+/**
+ * Evaluates condition and routes data.
+ * onSuccess = condition met (true path), onFailure = condition not met (false path).
+ * Errors are caught internally and returned via the onFailure path.
+ *
+ * @flowWeaver nodeType
+ * @label Evaluate Condition
+ * @input data [order:1] - Data to evaluate
+ * @input execute [order:0] - Execute
+ * @output conditionTrue [order:2] - Data if condition passed
+ * @output conditionFalse [order:3] - Data if condition failed
+ * @output conditionMet [order:4] - Whether condition was met
+ * @output onSuccess [order:0] - Condition passed (routes to success handler)
+ * @output onFailure [order:1] - Condition not met (routes to failure handler)
+ */
+function evaluateCondition(
+  execute: boolean,
+  data: any
+): { onSuccess: boolean; onFailure: boolean; conditionTrue: any; conditionFalse: any; conditionMet: boolean } {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, conditionTrue: null, conditionFalse: null, conditionMet: false };
+  }
+
+  try {
+    // TODO: Define your condition logic
+    const conditionMet = Boolean(data && data.isValid);
+
+    if (conditionMet) {
+      return { onSuccess: true, onFailure: false, conditionTrue: data, conditionFalse: null, conditionMet: true };
+    } else {
+      return { onSuccess: false, onFailure: true, conditionTrue: null, conditionFalse: data, conditionMet: false };
+    }
+  } catch (err) {
+    // On error, route to failure path with the original data
+    return { onSuccess: false, onFailure: true, conditionTrue: null, conditionFalse: data, conditionMet: false };
+  }
+}
+
+/**
+ * Handles success path
+ *
+ * @flowWeaver nodeType
+ * @label Handle Success
+ * @input data [order:1] - Data from success path
+ * @input execute [order:0] - Execute
+ * @output result [order:2] - Success result
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+function handleSuccess(
+  execute: boolean,
+  data: any
+): { onSuccess: boolean; onFailure: boolean; result: any } {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, result: null };
+  }
+
+  // TODO: Handle success case
+  return { onSuccess: true, onFailure: false, result: { status: "success", data } };
+}
+
+/**
+ * Handles failure path
+ *
+ * @flowWeaver nodeType
+ * @label Handle Failure
+ * @input data [order:1] - Data from failure path
+ * @input execute [order:0] - Execute
+ * @output result [order:2] - Failure result
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+function handleFailure(
+  execute: boolean,
+  data: any
+): { onSuccess: boolean; onFailure: boolean; result: any } {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, result: null };
+  }
+
+  // TODO: Handle failure case
+  return { onSuccess: true, onFailure: false, result: { status: "failure", data } };
+}
+
+/**
+ * @flowWeaver workflow
+ * @node router evaluateCondition [color: "orange"] [icon: "altRoute"] [suppress: "UNUSED_OUTPUT_PORT"]
+ * @node successHandler handleSuccess [color: "green"] [icon: "checkCircle"]
+ * @node failureHandler handleFailure [color: "red"] [icon: "error"]
+ * @connect Start.execute -> router.execute
+ * @connect Start.data -> router.data
+ * @connect router.onSuccess -> successHandler.execute
+ * @connect router.conditionTrue -> successHandler.data
+ * @connect router.onFailure -> failureHandler.execute
+ * @connect router.conditionFalse -> failureHandler.data
+ * @connect successHandler.result -> Exit.successResult
+ * @connect successHandler.onSuccess -> Exit.onSuccess
+ * @connect failureHandler.result -> Exit.failureResult
+ * @connect failureHandler.onSuccess -> Exit.onFailure
+ * @param execute [order:0] - Execute
+ * @param data [order:1] - Input data to route
+ * @returns onSuccess [order:0] - Success path completed
+ * @returns onFailure [order:1] - Failure path completed
+ * @returns successResult [order:2] - Result from success path
+ * @returns failureResult [order:3] - Result from failure path
+ */
+export ${asyncKeyword}function ${workflowName}(
+  execute: boolean,
+  params: { data: any }
+): ${returnType} {
+  throw new Error("Compile with: fw compile <file>");
+}
+`.trim();
+  }
+};
+
+// src/cli/templates/providers/index.ts
+function generateOpenAIProvider(opts) {
+  const model = opts.model || "gpt-4o";
+  const apiKey = opts.apiKeyEnvVar || "OPENAI_API_KEY";
+  return `
+/* ============================================================
+ * OPENAI PROVIDER
+ * Set ${apiKey} environment variable before running
+ * ============================================================ */
+
+const ${apiKey} = process.env.${apiKey};
+if (!${apiKey}) {
+  throw new Error('Missing ${apiKey} environment variable');
+}
+
+const _defaultLlmProvider: LLMProvider = {
+  async chat(messages, options) {
+    const response = await fetch('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Authorization': \`Bearer \${${apiKey}}\`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: options?.model ?? '${model}',
+        messages: messages.map(m => ({
+          role: m.role,
+          content: m.content,
+          ...(m.toolCallId && { tool_call_id: m.toolCallId }),
+        })),
+        tools: options?.tools?.map(t => ({
+          type: 'function',
+          function: { name: t.name, description: t.description, parameters: t.parameters },
+        })),
+        temperature: options?.temperature,
+        max_tokens: options?.maxTokens,
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(\`OpenAI API error: \${response.status} \${error}\`);
+    }
+
+    const data = await response.json();
+    const choice = data.choices[0];
+
+    return {
+      content: choice.message.content,
+      toolCalls: choice.message.tool_calls?.map((tc: any) => ({
+        id: tc.id,
+        name: tc.function.name,
+        arguments: JSON.parse(tc.function.arguments),
+      })) ?? [],
+      finishReason: choice.finish_reason === 'tool_calls' ? 'tool_calls' : 'stop',
+    };
+  },
+};
+
+const llmProvider: LLMProvider = _defaultLlmProvider;
+`;
+}
+function generateAnthropicProvider(opts) {
+  const model = opts.model || "claude-3-5-sonnet-20241022";
+  const apiKey = opts.apiKeyEnvVar || "ANTHROPIC_API_KEY";
+  return `
+/* ============================================================
+ * ANTHROPIC PROVIDER
+ * Set ${apiKey} environment variable before running
+ * ============================================================ */
+
+const ${apiKey} = process.env.${apiKey};
+if (!${apiKey}) {
+  throw new Error('Missing ${apiKey} environment variable');
+}
+
+const _defaultLlmProvider: LLMProvider = {
+  async chat(messages, options) {
+    // Separate system message (Anthropic handles it differently)
+    const systemMessage = messages.find(m => m.role === 'system');
+    const chatMessages = messages.filter(m => m.role !== 'system');
+
+    const response = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'x-api-key': ${apiKey},
+        'anthropic-version': '2023-06-01',
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: options?.model ?? '${model}',
+        max_tokens: options?.maxTokens ?? 4096,
+        system: systemMessage?.content ?? options?.systemPrompt,
+        messages: chatMessages.map(m => {
+          if (m.role === 'tool') {
+            return {
+              role: 'user',
+              content: [{ type: 'tool_result', tool_use_id: m.toolCallId, content: m.content }],
+            };
+          }
+          return { role: m.role, content: m.content };
+        }),
+        tools: options?.tools?.map(t => ({
+          name: t.name,
+          description: t.description,
+          input_schema: { type: 'object', properties: t.parameters.properties, required: t.parameters.required },
+        })),
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(\`Anthropic API error: \${response.status} \${error}\`);
+    }
+
+    const data = await response.json();
+
+    let content: string | null = null;
+    const toolCalls: LLMToolCall[] = [];
+
+    for (const block of data.content) {
+      if (block.type === 'text') content = block.text;
+      if (block.type === 'tool_use') {
+        toolCalls.push({ id: block.id, name: block.name, arguments: block.input });
+      }
+    }
+
+    return {
+      content,
+      toolCalls,
+      finishReason: data.stop_reason === 'tool_use' ? 'tool_calls' : 'stop',
+    };
+  },
+};
+
+const llmProvider: LLMProvider = _defaultLlmProvider;
+`;
+}
+function generateOllamaProvider(opts) {
+  const model = opts.model || "llama3.2";
+  return `
+/* ============================================================
+ * OLLAMA PROVIDER (Local)
+ * Ensure Ollama is running: ollama serve
+ * Pull model first: ollama pull ${model}
+ * ============================================================ */
+
+const OLLAMA_BASE_URL = process.env.OLLAMA_BASE_URL ?? 'http://localhost:11434';
+
+const _defaultLlmProvider: LLMProvider = {
+  async chat(messages, options) {
+    const response = await fetch(\`\${OLLAMA_BASE_URL}/api/chat\`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: options?.model ?? '${model}',
+        messages: messages.map(m => ({ role: m.role, content: m.content })),
+        stream: false,
+        options: {
+          temperature: options?.temperature,
+          num_predict: options?.maxTokens,
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(\`Ollama error: \${response.status} \${error}\`);
+    }
+
+    const data = await response.json();
+
+    return {
+      content: data.message?.content ?? null,
+      toolCalls: [], // Ollama tool support varies by model
+      finishReason: 'stop',
+    };
+  },
+};
+
+const llmProvider: LLMProvider = _defaultLlmProvider;
+`;
+}
+function generateMockProvider() {
+  return `
+/* ============================================================
+ * MOCK PROVIDER (For Testing)
+ * Replace with real provider for production use
+ * ============================================================ */
+
+const _defaultLlmProvider: LLMProvider = {
+  async chat(messages, options) {
+    const last = messages[messages.length - 1];
+
+    // Simulate tool call if message contains "search"
+    if (options?.tools && last.content.toLowerCase().includes('search')) {
+      return {
+        content: null,
+        toolCalls: [{
+          id: 'call_' + Date.now(),
+          name: 'search',
+          arguments: { query: last.content },
+        }],
+        finishReason: 'tool_calls',
+      };
+    }
+
+    return {
+      content: '[Mock response] ' + last.content,
+      toolCalls: [],
+      finishReason: 'stop',
+    };
+  },
+};
+
+const llmProvider: LLMProvider = _defaultLlmProvider;
+`;
+}
+function getProviderCode(provider, model) {
+  const opts = { model: model || "" };
+  switch (provider) {
+    case "openai":
+      return generateOpenAIProvider({ ...opts, model: model || "gpt-4o" });
+    case "anthropic":
+      return generateAnthropicProvider({
+        ...opts,
+        model: model || "claude-3-5-sonnet-20241022"
+      });
+    case "ollama":
+      return generateOllamaProvider({ ...opts, model: model || "llama3.2" });
+    case "mock":
+    default:
+      return generateMockProvider();
+  }
+}
+
+// src/cli/templates/shared/llm-types.ts
+var LLM_CORE_TYPES = `interface LLMMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string;
+  toolCallId?: string;
+}
+
+interface LLMResponse {
+  content: string | null;
+  toolCalls: LLMToolCall[];
+  finishReason: 'stop' | 'tool_calls' | 'length' | 'error';
+  usage?: { promptTokens: number; completionTokens: number };
+}
+
+interface LLMToolCall {
+  id: string;
+  name: string;
+  arguments: Record<string, unknown>;
+}
+
+interface LLMTool {
+  name: string;
+  description: string;
+  parameters: {
+    type: 'object';
+    properties: Record<string, { type: string }>;
+    required?: string[];
+  };
+}
+
+interface LLMProvider {
+  chat(
+    messages: LLMMessage[],
+    options?: { tools?: LLMTool[]; systemPrompt?: string; model?: string; temperature?: number; maxTokens?: number }
+  ): Promise<LLMResponse>;
+}`;
+var LLM_SIMPLE_TYPES = `interface LLMMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string;
+  toolCallId?: string;
+}
+
+interface LLMToolCall {
+  id: string;
+  name: string;
+  arguments: Record<string, unknown>;
+}
+
+interface LLMResponse {
+  content: string | null;
+  toolCalls: LLMToolCall[];
+  finishReason: 'stop' | 'tool_calls' | 'length' | 'error';
+  usage?: { promptTokens: number; completionTokens: number };
+}
+
+interface LLMProvider {
+  chat(messages: LLMMessage[], options?: { systemPrompt?: string; model?: string; temperature?: number; maxTokens?: number }): Promise<LLMResponse>;
+}`;
+var LLM_MOCK_PROVIDER = `const createMockProvider = (): LLMProvider => ({
+  async chat(messages) {
+    const lastMessage = messages[messages.length - 1];
+    return {
+      content: \`[Mock response to: \${(lastMessage?.content ?? '').slice(0, 50)}...]\`,
+      toolCalls: [],
+      finishReason: 'stop',
+      usage: { promptTokens: 10, completionTokens: 20 },
+    };
+  },
+});
+
+const llmProvider: LLMProvider = createMockProvider();`;
+var LLM_MOCK_PROVIDER_WITH_TOOLS = `const createMockProvider = (): LLMProvider => ({
+  async chat(messages, options) {
+    const last = messages[messages.length - 1];
+    if (options?.tools && last.content.toLowerCase().includes('search')) {
+      return {
+        content: null,
+        toolCalls: [
+          {
+            id: 'call_' + Date.now(),
+            name: 'search',
+            arguments: { query: last.content },
+          },
+        ],
+        finishReason: 'tool_calls',
+        usage: { promptTokens: 15, completionTokens: 30 },
+      };
+    }
+
+    return {
+      content: '[Mock answer] ' + last.content,
+      toolCalls: [],
+      finishReason: 'stop',
+      usage: { promptTokens: 10, completionTokens: 20 },
+    };
+  },
+});
+
+const llmProvider: LLMProvider = createMockProvider();`;
+
+// src/cli/templates/workflows/ai-agent.ts
+var aiConfigSchema = {
+  provider: {
+    type: "select",
+    label: "LLM Provider",
+    description: "Choose your LLM provider",
+    default: "mock",
+    options: [
+      { value: "openai", label: "OpenAI" },
+      { value: "anthropic", label: "Anthropic" },
+      { value: "ollama", label: "Ollama (Local)" },
+      { value: "mock", label: "Mock (Testing)" }
+    ]
+  },
+  model: {
+    type: "string",
+    label: "Model",
+    description: "Model identifier",
+    default: "gpt-4o",
+    placeholder: "e.g., gpt-4o, claude-3-5-sonnet-20241022, llama3.2",
+    dependsOn: {
+      field: "provider",
+      values: ["openai", "anthropic", "ollama"]
+    }
+  }
+};
+var aiAgentTemplate = {
+  id: "ai-agent",
+  name: "AI Agent (Tool Calling)",
+  description: "Stateful LLM agent with explicit reasoning loop and tool execution",
+  category: "ai",
+  configSchema: aiConfigSchema,
+  generate: ({ workflowName, config }) => {
+    const provider = config?.provider || "mock";
+    const model = config?.model || "";
+    const providerCode = provider === "mock" ? `
+/* ============================================================
+ * MOCK PROVIDER (REPLACE IN REAL USE)
+ * ============================================================
+ */
+
+${LLM_MOCK_PROVIDER_WITH_TOOLS}
+` : getProviderCode(provider, model);
+    return `
+/* ============================================================
+ * CORE TYPES
+ * ============================================================
+ */
+
+${LLM_CORE_TYPES}
+
+type TerminationReason =
+  | 'completed'
+  | 'max_iterations'
+  | 'tool_error'
+  | 'llm_error'
+  | 'aborted';
+
+/* ============================================================
+ * AGENT STATE
+ * ============================================================
+ */
+
+interface AgentState {
+  messages: LLMMessage[];
+  iteration: number;
+  toolsUsed: string[];
+  terminated: boolean;
+  terminationReason?: TerminationReason;
+  finalResponse?: string;
+}
+
+${providerCode}
+
+const SYSTEM_PROMPT = \`You are a helpful AI assistant with access to tools.
+Use tools when necessary. Respond directly when the task is complete.\`;
+
+const MAX_ITERATIONS = 10;
+
+/* ============================================================
+ * TOOLS
+ * ============================================================
+ */
+
+const AVAILABLE_TOOLS: LLMTool[] = [
+  {
+    name: 'search',
+    description: 'Search for information',
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string' },
+      },
+      required: ['query'],
+    },
+  },
+];
+
+type ToolResult =
+  | { ok: true; value: string }
+  | { ok: false; error: string };
+
+type ToolFn = (args: Record<string, unknown>) => Promise<ToolResult>;
+
+const TOOL_IMPLEMENTATIONS: Record<string, ToolFn> = {
+  async search(args) {
+    if (typeof args.query !== 'string') {
+      return { ok: false, error: 'Invalid query' };
+    }
+    return { ok: true, value: '[Search results for: ' + args.query + ']' };
+  },
+};
+
+/* ============================================================
+ * NODES
+ * ============================================================
+ */
+
+/**
+ * Agent loop that orchestrates LLM calls and tool execution
+ * Uses scoped ports to handle iteration internally
+ *
+ * @flowWeaver nodeType
+ * @label Agent Loop
+ * @input userMessage [order:1] - User's input message
+ * @input [maxIterations] [order:2] - Maximum loop iterations (default: 10)
+ * @input success scope:iteration [order:0] - From LLM onSuccess
+ * @input failure scope:iteration [order:1] - From LLM onFailure
+ * @input llmResponse scope:iteration [order:2] - LLM response
+ * @input toolMessages scope:iteration [order:3] - Tool results
+ * @input execute [order:0] - Execute
+ * @output start scope:iteration [order:0] - Triggers iteration
+ * @output state scope:iteration [order:1] - Current agent state
+ * @output response [order:2] - Final response when done
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+async function agentLoop(
+  execute: boolean,
+  userMessage: string,
+  maxIterations: number = MAX_ITERATIONS,
+  iteration: (start: boolean, state: AgentState) => Promise<{
+    success: boolean;
+    failure: boolean;
+    llmResponse: LLMResponse | null;
+    toolMessages: LLMMessage[];
+  }>
+): Promise<{ onSuccess: boolean; onFailure: boolean; response: string }> {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, response: '' };
+  }
+
+  let state: AgentState = {
+    messages: [{ role: 'user', content: userMessage }],
+    iteration: 0,
+    toolsUsed: [],
+    terminated: false,
+  };
+
+  while (state.iteration < maxIterations) {
+    const result = await iteration(true, state);
+
+    state.iteration++;
+
+    // Handle LLM failure
+    if (result.failure) {
+      return { onSuccess: false, onFailure: true, response: 'LLM error occurred' };
+    }
+
+    // Add assistant message if present
+    if (result.llmResponse?.content) {
+      state.messages.push({ role: 'assistant', content: result.llmResponse.content });
+    }
+
+    // Add tool messages
+    if (result.toolMessages && result.toolMessages.length > 0) {
+      state.messages.push(...result.toolMessages);
+    }
+
+    // Check termination: no tool calls means we're done
+    if (result.llmResponse && result.llmResponse.toolCalls.length === 0 && result.llmResponse.content) {
+      return { onSuccess: true, onFailure: false, response: result.llmResponse.content };
+    }
+  }
+
+  return { onSuccess: true, onFailure: false, response: 'Max iterations reached' };
+}
+
+/**
+ * Calls the LLM with current state
+ *
+ * @flowWeaver nodeType
+ * @label Call LLM
+ * @input state [order:1] - Current agent state
+ * @input execute [order:0] - Execute
+ * @output response [order:2] - LLM response
+ * @output toolCalls [order:3] - Tool calls from LLM
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+async function callLLM(
+  execute: boolean,
+  state: AgentState
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  response: LLMResponse | null;
+  toolCalls: LLMToolCall[];
+}> {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, response: null, toolCalls: [] };
+  }
+
+  try {
+    const response = await llmProvider.chat(state.messages, {
+      tools: AVAILABLE_TOOLS,
+      systemPrompt: SYSTEM_PROMPT,
+    });
+
+    return { onSuccess: true, onFailure: false, response, toolCalls: response.toolCalls };
+  } catch {
+    return { onSuccess: false, onFailure: true, response: null, toolCalls: [] };
+  }
+}
+
+/**
+ * Executes tool calls
+ *
+ * @flowWeaver nodeType
+ * @label Execute Tools
+ * @input calls [order:1] - Tool calls to execute
+ * @input execute [order:0] - Execute
+ * @output messages [order:2] - Tool response messages
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+async function executeTools(
+  execute: boolean,
+  calls: LLMToolCall[]
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  messages: LLMMessage[];
+}> {
+  if (!execute || !calls || calls.length === 0) {
+    return { onSuccess: true, onFailure: false, messages: [] };
+  }
+
+  const messages: LLMMessage[] = [];
+
+  for (const call of calls) {
+    const impl = TOOL_IMPLEMENTATIONS[call.name];
+    if (!impl) {
+      messages.push({
+        role: 'tool',
+        content: 'Unknown tool: ' + call.name,
+        toolCallId: call.id,
+      });
+      continue;
+    }
+
+    const result = await impl(call.arguments);
+
+    messages.push({
+      role: 'tool',
+      content: result.ok ? result.value : 'Error: ' + result.error,
+      toolCallId: call.id,
+    });
+  }
+
+  return { onSuccess: true, onFailure: false, messages };
+}
+
+/* ============================================================
+ * WORKFLOW
+ * ============================================================
+ */
+
+/**
+ * AI Agent that uses tools to accomplish tasks
+ *
+ * @flowWeaver workflow
+ * @node loop agentLoop [color: "purple"] [icon: "smartToy"]
+ * @node llm callLLM loop.iteration [color: "blue"] [icon: "psychology"]
+ * @node tools executeTools loop.iteration [color: "orange"] [icon: "build"] [suppress: "AGENT_UNGUARDED_TOOL_EXECUTOR"]
+ * @connect Start.execute -> loop.execute
+ * @connect Start.userMessage -> loop.userMessage
+ * @connect loop.start:iteration -> llm.execute
+ * @connect loop.state:iteration -> llm.state
+ * @connect llm.toolCalls -> tools.calls
+ * @connect llm.onSuccess -> tools.execute
+ * @connect llm.response -> loop.llmResponse:iteration
+ * @connect llm.onSuccess -> loop.success:iteration
+ * @connect llm.onFailure -> loop.failure:iteration
+ * @connect tools.messages -> loop.toolMessages:iteration
+ * @connect tools.onFailure -> loop.failure:iteration
+ * @connect loop.response -> Exit.response
+ * @connect loop.onSuccess -> Exit.onSuccess
+ * @connect loop.onFailure -> Exit.onFailure
+ * @param execute [order:0] - Execute
+ * @param userMessage [order:1] - User's message to the agent
+ * @returns onSuccess [order:0] - Agent completed successfully
+ * @returns onFailure [order:1] - Agent encountered an error
+ * @returns response [order:2] - Agent's final response
+ */
+export async function ${workflowName}(
+  execute: boolean,
+  params: { userMessage: string }
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  response: string;
+}> {
+  throw new Error('Compile with: fw compile <file>');
+}
+`.trim();
+  }
+};
+
+// src/cli/templates/workflows/ai-react.ts
+var aiReactTemplate = {
+  id: "ai-react",
+  name: "ReAct Agent",
+  description: "Reasoning + Acting agent with explicit thought process",
+  category: "ai",
+  configSchema: aiConfigSchema,
+  generate: (opts) => {
+    const { workflowName, config } = opts;
+    const provider = config?.provider || "mock";
+    const model = config?.model || "";
+    const providerCode = provider === "mock" ? `
+// Mock provider. Replace with a real provider for production.
+const createMockReactProvider = (): LLMProvider => ({
+  async chat(messages) {
+    const lastMessage = messages[messages.length - 1];
+    return {
+      content: \`Thought: Processing the request\\nAction: FINISH\\nAction Input: [Mock answer to: \${lastMessage.content.slice(0, 30)}...]\`,
+      toolCalls: [],
+      finishReason: 'stop',
+    };
+  },
+});
+
+const llmProvider: LLMProvider = createMockReactProvider();
+` : getProviderCode(provider, model);
+    return `
+// ============================================================
+// ReAct Agent: Thought \u2192 Action \u2192 Observation loop
+// ============================================================
+//
+// The agent follows the ReAct pattern (Yao et al., 2022):
+//   1. Think: reason about the current state
+//   2. Act: call a tool or FINISH
+//   3. Observe: receive tool output, feed back into next thought
+//
+// The reactLoop node manages iteration and message accumulation.
+// think + act run inside the loop's scoped iteration.
+
+// ============================================================
+// LLM TYPES
+// ============================================================
+
+${LLM_CORE_TYPES}
+
+${providerCode}
+const MAX_STEPS = 10;
+
+const REACT_PROMPT = \`You are a ReAct (Reasoning + Acting) agent.
+
+For each step, you MUST respond in this exact format:
+Thought: [Your reasoning about what to do next]
+Action: [tool_name] or [FINISH]
+Action Input: [input for the tool, or final answer if FINISH]
+
+Available tools: search, calculate
+
+When you have the final answer:
+Thought: I now have enough information to answer
+Action: FINISH
+Action Input: [Your final answer here]\`;
+
+// Parse ReAct response format
+function parseReactResponse(content: string): {
+  thought: string;
+  action: string;
+  actionInput: string;
+} {
+  const thoughtMatch = content.match(/Thought:\\s*(.+?)(?=\\nAction:|$)/s);
+  const actionMatch = content.match(/Action:\\s*(.+?)(?=\\nAction Input:|$)/s);
+  const inputMatch = content.match(/Action Input:\\s*(.+?)$/s);
+
+  return {
+    thought: thoughtMatch?.[1]?.trim() ?? '',
+    action: actionMatch?.[1]?.trim() ?? 'FINISH',
+    actionInput: inputMatch?.[1]?.trim() ?? '',
+  };
+}
+
+// ============================================================
+// TOOL IMPLEMENTATIONS
+// ============================================================
+
+// Replace with real tools
+const TOOL_IMPLEMENTATIONS: Record<string, (input: string) => Promise<string>> = {
+  async search(input: string): Promise<string> {
+    return '[Search results for: ' + input + ']';
+  },
+  async calculate(input: string): Promise<string> {
+    return '[Calculation result for: ' + input + ']';
+  },
+};
+
+// ============================================================
+// NODES
+// ============================================================
+
+/**
+ * ReAct loop: manages Think\u2192Act\u2192Observe iterations.
+ * Accumulates messages and terminates when action is FINISH or max steps.
+ *
+ * @flowWeaver nodeType
+ * @label ReAct Loop
+ * @input execute [order:0] - Execute
+ * @input task [order:1] - Task for the agent
+ * @input [maxSteps] [order:2] - Maximum reasoning steps (default: 10)
+ * @input success scope:step [order:0] - Iteration succeeded
+ * @input failure scope:step [order:1] - Iteration failed
+ * @input thought scope:step [order:2] - Agent's reasoning
+ * @input action scope:step [order:3] - Action name
+ * @input actionInput scope:step [order:4] - Action input / final answer
+ * @input observation scope:step [order:5] - Tool observation
+ * @output onSuccess [order:0] - On Success (finished)
+ * @output onFailure [order:1] - On Failure
+ * @output start scope:step [order:0] - Triggers iteration
+ * @output messages scope:step [order:1] - Current messages for LLM
+ * @output answer [order:2] - Final answer
+ */
+async function reactLoop(
+  execute: boolean,
+  task: string,
+  maxSteps: number = MAX_STEPS,
+  step: (start: boolean, messages: LLMMessage[]) => Promise<{
+    success: boolean;
+    failure: boolean;
+    thought: string;
+    action: string;
+    actionInput: string;
+    observation: string;
+  }>
+): Promise<{ onSuccess: boolean; onFailure: boolean; answer: string }> {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, answer: '' };
+  }
+
+  const messages: LLMMessage[] = [{ role: 'user', content: task }];
+
+  for (let i = 0; i < maxSteps; i++) {
+    const result = await step(true, messages);
+
+    if (result.failure) {
+      return { onSuccess: false, onFailure: true, answer: '' };
+    }
+
+    // Append thought + action as assistant message
+    messages.push({
+      role: 'assistant',
+      content: \`Thought: \${result.thought}\\nAction: \${result.action}\\nAction Input: \${result.actionInput}\`,
+    });
+
+    // Check termination
+    if (result.action.toUpperCase() === 'FINISH') {
+      return { onSuccess: true, onFailure: false, answer: result.actionInput };
+    }
+
+    // Append observation
+    if (result.observation) {
+      messages.push({ role: 'user', content: \`Observation: \${result.observation}\` });
+    }
+  }
+
+  return { onSuccess: true, onFailure: false, answer: 'Max steps reached' };
+}
+
+/**
+ * ReAct reasoning step: calls LLM and parses Thought/Action/ActionInput
+ *
+ * @flowWeaver nodeType
+ * @label Think
+ * @input execute [order:0] - Execute
+ * @input messages [order:1] - Conversation history
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ * @output thought [order:2] - Agent's reasoning
+ * @output action [order:3] - Action to take (tool name or FINISH)
+ * @output actionInput [order:4] - Input for action or final answer
+ */
+async function think(
+  execute: boolean,
+  messages: LLMMessage[]
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  thought: string;
+  action: string;
+  actionInput: string;
+}> {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, thought: '', action: '', actionInput: '' };
+  }
+
+  try {
+    const response = await llmProvider.chat(messages, { systemPrompt: REACT_PROMPT });
+    const parsed = parseReactResponse(response.content ?? '');
+
+    return {
+      onSuccess: true,
+      onFailure: false,
+      thought: parsed.thought,
+      action: parsed.action,
+      actionInput: parsed.actionInput,
+    };
+  } catch {
+    return { onSuccess: false, onFailure: true, thought: '', action: '', actionInput: '' };
+  }
+}
+
+/**
+ * Execute action and return observation
+ *
+ * @flowWeaver nodeType
+ * @label Act
+ * @input execute [order:0] - Execute
+ * @input action [order:1] - Tool name to execute
+ * @input actionInput [order:2] - Input for tool
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ * @output observation [order:2] - Tool observation result
+ */
+async function act(
+  execute: boolean,
+  action: string,
+  actionInput: string
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  observation: string;
+}> {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, observation: '' };
+  }
+
+  const tool = TOOL_IMPLEMENTATIONS[action.toLowerCase()];
+  if (!tool) {
+    return {
+      onSuccess: true,
+      onFailure: false,
+      observation: 'Unknown tool: ' + action,
+    };
+  }
+
+  try {
+    const observation = await tool(actionInput);
+    return { onSuccess: true, onFailure: false, observation };
+  } catch (error) {
+    return { onSuccess: false, onFailure: true, observation: '' };
+  }
+}
+
+// ============================================================
+// WORKFLOW
+// ============================================================
+
+/**
+ * ReAct Agent: iterative Thought\u2192Action\u2192Observation loop
+ *
+ * @flowWeaver workflow
+ * @node loop reactLoop [color: "purple"] [icon: "psychology"]
+ * @node thinking think loop.step [color: "blue"] [icon: "autoAwesome"]
+ * @node acting act loop.step [color: "orange"] [icon: "bolt"]
+ * @connect Start.execute -> loop.execute
+ * @connect Start.task -> loop.task
+ * @connect loop.start:step -> thinking.execute
+ * @connect loop.messages:step -> thinking.messages
+ * @connect thinking.onSuccess -> acting.execute
+ * @connect thinking.action -> acting.action
+ * @connect thinking.actionInput -> acting.actionInput
+ * @connect thinking.thought -> loop.thought:step
+ * @connect thinking.action -> loop.action:step
+ * @connect thinking.actionInput -> loop.actionInput:step
+ * @connect thinking.onFailure -> loop.failure:step
+ * @connect acting.observation -> loop.observation:step
+ * @connect acting.onSuccess -> loop.success:step
+ * @connect acting.onFailure -> loop.failure:step
+ * @connect loop.onSuccess -> Exit.onSuccess
+ * @connect loop.onFailure -> Exit.onFailure
+ * @connect loop.answer -> Exit.answer
+ * @param execute [order:0] - Execute
+ * @param task [order:1] - Task for the agent
+ * @returns onSuccess [order:0] - On Success
+ * @returns onFailure [order:1] - On Failure
+ * @returns answer [order:2] - Final answer
+ */
+export async function ${workflowName}(
+  execute: boolean,
+  params: { task: string }
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  answer: string;
+}> {
+  throw new Error('Compile with: fw compile <file>');
+}
+`.trim();
+  }
+};
+
+// src/cli/templates/workflows/ai-rag.ts
+var aiRagTemplate = {
+  id: "ai-rag",
+  name: "RAG Pipeline",
+  description: "Retrieval-Augmented Generation for knowledge-based Q&A",
+  category: "ai",
+  configSchema: aiConfigSchema,
+  generate: (opts) => {
+    const { workflowName, config } = opts;
+    const provider = config?.provider || "mock";
+    const model = config?.model || "";
+    const providerCode = provider === "mock" ? `
+// Mock provider for testing - replace with real provider
+${LLM_MOCK_PROVIDER}
+` : getProviderCode(provider, model);
+    return `
+// ============================================================
+// LLM TYPES - Provider-agnostic interface
+// ============================================================
+
+${LLM_SIMPLE_TYPES}
+
+${providerCode}
+
+// Document store (replace with vector DB like Pinecone, Weaviate, etc.)
+interface Document {
+  id: string;
+  content: string;
+  metadata?: Record<string, unknown>;
+}
+
+const documentStore: Document[] = [
+  // TODO: Add your documents or connect to vector database
+  { id: '1', content: 'Flow Weaver is a visual programming tool.' },
+  { id: '2', content: 'It uses typed ports for data flow.' },
+];
+
+/**
+ * Retrieves relevant documents for a query
+ *
+ * @flowWeaver nodeType
+ * @label Retrieve
+ * @input query [order:1] - Search query
+ * @input [topK] [order:2] - Number of results (default 3)
+ * @input execute [order:0] - Execute
+ * @output documents [order:2] [hidden] - Retrieved documents
+ * @output context [order:3] - Combined document text
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+async function retrieve(
+  execute: boolean,
+  query: string,
+  topK?: number
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  documents: Document[];
+  context: string;
+}> {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, documents: [], context: '' };
+  }
+
+  const k = topK ?? 3;
+
+  // TODO: Replace with actual vector similarity search
+  // For now, simple keyword matching
+  const queryLower = query.toLowerCase();
+  const scored = documentStore
+    .map((doc) => ({
+      doc,
+      score: doc.content.toLowerCase().includes(queryLower) ? 1 : 0,
+    }))
+    .filter((s) => s.score > 0)
+    .slice(0, k)
+    .map((s) => s.doc);
+
+  const context = scored.map((d) => d.content).join('\\n\\n');
+
+  return {
+    onSuccess: true,
+    onFailure: false,
+    documents: scored,
+    context,
+  };
+}
+
+/**
+ * Generates answer using retrieved context
+ *
+ * @flowWeaver nodeType
+ * @label Generate
+ * @input question [order:1] - User question
+ * @input context [order:2] - Retrieved context
+ * @input execute [order:0] - Execute
+ * @output answer [order:2] - Generated answer
+ * @output sourcesUsed [order:3] - Number of sources used
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+async function generate(
+  execute: boolean,
+  question: string,
+  context: string
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  answer: string;
+  sourcesUsed: number;
+}> {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, answer: '', sourcesUsed: 0 };
+  }
+
+  const prompt = \`Answer the question based on the following context.
+If the context doesn't contain relevant information, say so.
+
+Context:
+\${context}
+
+Question: \${question}
+
+Answer:\`;
+
+  const response = await llmProvider.chat([{ role: 'user', content: prompt }]);
+  const sourcesUsed = context
+    .split('\\n\\n')
+    .filter((s) => s.trim()).length;
+
+  return {
+    onSuccess: true,
+    onFailure: false,
+    answer: response.content ?? '',
+    sourcesUsed,
+  };
+}
+
+/**
+ * RAG Pipeline for knowledge-based Q&A
+ *
+ * @flowWeaver workflow
+ * @node retriever retrieve [color: "teal"] [icon: "search"] [suppress: "UNUSED_OUTPUT_PORT", "DESIGN_ASYNC_NO_ERROR_PATH"]
+ * @node generator generate [color: "purple"] [icon: "autoAwesome"]
+ * @connect Start.execute -> retriever.execute
+ * @connect Start.question -> retriever.query
+ * @connect Start.topK -> retriever.topK
+ * @connect Start.question -> generator.question
+ * @connect retriever.context -> generator.context
+ * @connect retriever.onSuccess -> generator.execute
+ * @connect generator.answer -> Exit.answer
+ * @connect generator.sourcesUsed -> Exit.sourcesUsed
+ * @connect generator.onSuccess -> Exit.onSuccess
+ * @connect generator.onFailure -> Exit.onFailure
+ * @param execute [order:0] - Execute
+ * @param question [order:1] - User's question
+ * @param topK [order:2] - Number of documents to retrieve
+ * @returns onSuccess [order:0] - On Success
+ * @returns onFailure [order:1] - On Failure
+ * @returns answer [order:2] - Generated answer
+ * @returns sourcesUsed [order:3] - Number of sources used
+ */
+export async function ${workflowName}(
+  execute: boolean,
+  params: { question: string; topK?: number }
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  answer: string;
+  sourcesUsed: number;
+}> {
+  throw new Error('Compile with: fw compile <file>');
+}
+`.trim();
+  }
+};
+
+// src/cli/templates/workflows/ai-chat.ts
+var aiChatTemplate = {
+  id: "ai-chat",
+  name: "Stateful Chat",
+  description: "Conversational AI with memory management",
+  category: "ai",
+  configSchema: aiConfigSchema,
+  generate: (opts) => {
+    const { workflowName, config } = opts;
+    const provider = config?.provider || "mock";
+    const model = config?.model || "";
+    const providerCode = provider === "mock" ? `
+// Mock provider for testing - replace with real provider
+${LLM_MOCK_PROVIDER}
+` : getProviderCode(provider, model);
+    return `
+// ============================================================
+// LLM TYPES - Provider-agnostic interface
+// ============================================================
+
+${LLM_SIMPLE_TYPES}
+
+${providerCode}
+
+// Conversation memory store
+const conversations: Map<string, LLMMessage[]> = new Map();
+
+const DEFAULT_SYSTEM_PROMPT = \`You are a helpful AI assistant.
+Be concise but friendly. Remember context from earlier in the conversation.\`;
+
+/**
+ * Manages conversation memory
+ *
+ * @flowWeaver nodeType
+ * @label Memory
+ * @input conversationId [order:1] - Conversation identifier
+ * @input [newMessage] [order:2] - Message to add
+ * @input [maxHistory=50] [order:3] - Max messages to retain
+ * @input execute [order:0] - Execute
+ * @output history [order:2] - Conversation history
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+function memory(
+  execute: boolean,
+  conversationId: string,
+  newMessage?: LLMMessage,
+  maxHistory?: number
+): {
+  onSuccess: boolean;
+  onFailure: boolean;
+  history: LLMMessage[];
+} {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, history: [] };
+  }
+
+  if (!conversations.has(conversationId)) {
+    conversations.set(conversationId, []);
+  }
+
+  const history = conversations.get(conversationId)!;
+
+  if (newMessage) {
+    history.push(newMessage);
+    const max = maxHistory ?? 50;
+    while (history.length > max) {
+      history.shift();
+    }
+  }
+
+  return { onSuccess: true, onFailure: false, history: [...history] };
+}
+
+/**
+ * Generates chat response
+ *
+ * @flowWeaver nodeType
+ * @label Chat
+ * @input history [order:1] - Conversation history
+ * @input [systemPrompt] [order:2] - System prompt
+ * @input execute [order:0] - Execute
+ * @output response [order:2] - Assistant response
+ * @output responseMessage [order:3] - Response as LLMMessage
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+async function chat(
+  execute: boolean,
+  history: LLMMessage[],
+  systemPrompt?: string
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  response: string;
+  responseMessage: LLMMessage;
+}> {
+  if (!execute) {
+    return {
+      onSuccess: false,
+      onFailure: false,
+      response: '',
+      responseMessage: { role: 'assistant', content: '' },
+    };
+  }
+
+  const response = await llmProvider.chat(history, {
+    systemPrompt: systemPrompt ?? DEFAULT_SYSTEM_PROMPT,
+  });
+
+  const content = response.content ?? '';
+
+  return {
+    onSuccess: true,
+    onFailure: false,
+    response: content,
+    responseMessage: { role: 'assistant', content },
+  };
+}
+
+/**
+ * Stateful chat with conversation memory
+ *
+ * @flowWeaver workflow
+ * @node mem memory [color: "teal"] [icon: "database"]
+ * @node respond chat [color: "purple"] [icon: "campaign"] [suppress: "AGENT_LLM_NO_FALLBACK"]
+ * @node saveMem memory [color: "teal"] [icon: "database"] [suppress: "UNUSED_OUTPUT_PORT"]
+ * @connect Start.execute -> mem.execute
+ * @connect Start.conversationId -> mem.conversationId
+ * @connect Start.userMessage -> mem.newMessage
+ * @connect mem.history -> respond.history
+ * @connect mem.onSuccess -> respond.execute
+ * @connect Start.conversationId -> saveMem.conversationId
+ * @connect respond.responseMessage -> saveMem.newMessage
+ * @connect respond.onSuccess -> saveMem.execute
+ * @connect respond.onFailure -> Exit.onFailure
+ * @connect respond.response -> Exit.response
+ * @connect saveMem.onSuccess -> Exit.onSuccess
+ * @param execute [order:0] - Execute
+ * @param conversationId [order:1] - Unique conversation ID
+ * @param userMessage [order:2] - User's message
+ * @param systemPrompt [order:3] - System prompt (optional)
+ * @returns onSuccess [order:0] - On Success
+ * @returns onFailure [order:1] - On Failure
+ * @returns response [order:2] - Assistant's response
+ */
+export async function ${workflowName}(
+  execute: boolean,
+  params: { conversationId: string; userMessage: LLMMessage; systemPrompt?: string }
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  response: string;
+}> {
+  throw new Error('Compile with: fw compile <file>');
+}
+`.trim();
+  }
+};
+
+// src/cli/templates/workflows/aggregator.ts
+var aggregatorTemplate = {
+  id: "aggregator",
+  name: "Aggregator",
+  description: "Combine multiple data sources into one output",
+  category: "data-processing",
+  generate: (opts) => {
+    const { workflowName, async: isAsync } = opts;
+    const asyncKeyword = isAsync ? "async " : "";
+    const returnType = isAsync ? "Promise<{ onSuccess: boolean; onFailure: boolean; aggregated: any }>" : "{ onSuccess: boolean; onFailure: boolean; aggregated: any }";
+    return `
+// Use @expression for most functions, normal mode only for error-with-data or void side-effects
+
+/**
+ * Fetches data from source A
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Fetch Source A
+ * @input query [order:0] - Query parameters
+ * @output data [order:0] - Data from source A
+ */
+function fetchSourceA(query: any): { data: any } {
+  // TODO: Fetch from source A
+  return { data: { source: "A", items: [] } };
+}
+
+/**
+ * Fetches data from source B
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Fetch Source B
+ * @input query [order:0] - Query parameters
+ * @output data [order:0] - Data from source B
+ */
+function fetchSourceB(query: any): { data: any } {
+  // TODO: Fetch from source B
+  return { data: { source: "B", items: [] } };
+}
+
+/**
+ * Combines data from multiple sources
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Combine Data
+ * @input dataA [order:0] - Data from source A
+ * @input dataB [order:1] - Data from source B
+ * @output aggregated [order:0] - Combined data
+ */
+function combineData(dataA: any, dataB: any): { aggregated: any } {
+  // TODO: Implement aggregation logic
+  return {
+    aggregated: {
+      sources: [dataA?.source, dataB?.source],
+      totalItems: (dataA?.items?.length || 0) + (dataB?.items?.length || 0),
+      items: [...(dataA?.items || []), ...(dataB?.items || [])],
+      aggregatedAt: new Date().toISOString()
+    }
+  };
+}
+
+/**
+ * @flowWeaver workflow
+ * @node sourceA fetchSourceA [color: "blue"] [icon: "download"]
+ * @node sourceB fetchSourceB [color: "blue"] [icon: "download"]
+ * @node combiner combineData [color: "purple"] [icon: "callMerge"]
+ * @connect Start.execute -> sourceA.execute
+ * @connect Start.execute -> sourceB.execute
+ * @connect Start.query -> sourceA.query
+ * @connect Start.query -> sourceB.query
+ * @connect sourceA.onSuccess -> combiner.execute
+ * @connect sourceA.data -> combiner.dataA
+ * @connect sourceB.data -> combiner.dataB
+ * @connect combiner.aggregated -> Exit.aggregated
+ * @connect combiner.onSuccess -> Exit.onSuccess
+ * @connect combiner.onFailure -> Exit.onFailure
+ * @param execute [order:0] - Execute
+ * @param query [order:1] - Query parameters for fetching
+ * @returns onSuccess [order:0] - On Success
+ * @returns onFailure [order:1] - On Failure
+ * @returns aggregated [order:2] - Combined data from all sources
+ */
+export ${asyncKeyword}function ${workflowName}(
+  execute: boolean,
+  params: { query: any }
+): ${returnType} {
+  throw new Error("Compile with: fw compile <file>");
+}
+`.trim();
+  }
+};
+
+// src/cli/templates/workflows/webhook.ts
+var 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 [color: "green"] [icon: "verified"]
+ * @node processor processPayload [color: "blue"] [icon: "settings"]
+ * @node responder formatResponse [color: "cyan"] [icon: "send"]
+ * @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();
+  }
+};
+
+// src/cli/templates/workflows/error-handler.ts
+var errorHandlerTemplate = {
+  id: "error-handler",
+  name: "Error Handler",
+  description: "Try/catch/retry pattern with error recovery",
+  category: "utility",
+  generate: (opts) => {
+    const { workflowName, async: isAsync } = opts;
+    const asyncKeyword = isAsync ? "async " : "";
+    const returnType = isAsync ? "Promise<{ onSuccess: boolean; onFailure: boolean; result: any; attempts: number; lastError?: string }>" : "{ onSuccess: boolean; onFailure: boolean; result: any; attempts: number; lastError?: string }";
+    return `
+/**
+ * Retry loop that orchestrates operation attempts
+ * Uses scoped ports to handle retry iteration internally
+ *
+ * @flowWeaver nodeType
+ * @label Retry Loop
+ * @input data [order:1] - Input data to process
+ * @input maxRetries [order:2] - Maximum retry attempts
+ * @input success scope:attempt [order:0] - From operation onSuccess
+ * @input failure scope:attempt [order:1] - From operation onFailure
+ * @input result scope:attempt [order:2] - Operation result
+ * @input error scope:attempt [order:3] - Error from operation
+ * @input execute [order:0] - Execute
+ * @output start scope:attempt [order:0] - Triggers attempt
+ * @output attemptData scope:attempt [order:1] - Data for this attempt
+ * @output attemptNum scope:attempt [order:2] - Current attempt number
+ * @output finalResult [order:2] - Final result
+ * @output attempts [order:3] - Total attempts made
+ * @output lastError [order:4] - Last error if failed
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+function retryLoop(
+  execute: boolean,
+  data: any,
+  maxRetries: number,
+  attempt: (start: boolean, attemptData: any, attemptNum: number) => {
+    success: boolean;
+    failure: boolean;
+    result: any;
+    error: string;
+  }
+): { onSuccess: boolean; onFailure: boolean; finalResult: any; attempts: number; lastError: string } {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, finalResult: null, attempts: 0, lastError: '' };
+  }
+
+  let lastError = '';
+  for (let attemptNum = 1; attemptNum <= maxRetries; attemptNum++) {
+    const result = attempt(true, data, attemptNum);
+
+    if (result.success) {
+      return { onSuccess: true, onFailure: false, finalResult: result.result, attempts: attemptNum, lastError: '' };
+    }
+
+    lastError = result.error;
+    console.log(\`[Retry] Attempt \${attemptNum} failed: \${lastError}. \${attemptNum < maxRetries ? 'Retrying...' : 'Max retries reached.'}\`);
+  }
+
+  return { onSuccess: false, onFailure: true, finalResult: null, attempts: maxRetries, lastError };
+}
+
+/**
+ * Attempts an operation that might fail
+ *
+ * @flowWeaver nodeType
+ * @label Try Operation
+ * @input data [order:1] - Input data
+ * @input attempt [order:2] - Current attempt number
+ * @input execute [order:0] - Execute
+ * @output result [order:2] - Operation result
+ * @output error [order:3] - Error message if failed
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+function tryOperation(
+  execute: boolean,
+  data: any,
+  attempt: number
+): { onSuccess: boolean; onFailure: boolean; result: any; error: string } {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, result: null, error: '' };
+  }
+
+  try {
+    // TODO: Replace with your operation that might fail
+    // This is a placeholder that randomly fails for demonstration
+    if (Math.random() < 0.3) {
+      throw new Error('Simulated failure');
+    }
+
+    const result = { processed: data, attempt };
+    return { onSuccess: true, onFailure: false, result, error: '' };
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
+    return { onSuccess: false, onFailure: true, result: null, error };
+  }
+}
+
+/**
+ * @flowWeaver workflow
+ * @node loop retryLoop [color: "orange"] [icon: "refresh"]
+ * @node tryOp tryOperation loop.attempt [color: "blue"] [icon: "playArrow"]
+ * @connect Start.execute -> loop.execute
+ * @connect Start.data -> loop.data
+ * @connect Start.maxRetries -> loop.maxRetries
+ * @connect loop.start:attempt -> tryOp.execute
+ * @connect loop.attemptData:attempt -> tryOp.data
+ * @connect loop.attemptNum:attempt -> tryOp.attempt
+ * @connect tryOp.result -> loop.result:attempt
+ * @connect tryOp.error -> loop.error:attempt
+ * @connect tryOp.onSuccess -> loop.success:attempt
+ * @connect tryOp.onFailure -> loop.failure:attempt
+ * @connect loop.finalResult -> Exit.result
+ * @connect loop.attempts -> Exit.attempts
+ * @connect loop.lastError -> Exit.lastError
+ * @connect loop.onSuccess -> Exit.onSuccess
+ * @connect loop.onFailure -> Exit.onFailure
+ * @param execute [order:0] - Execute
+ * @param data [order:1] - Input data to process
+ * @param [maxRetries=3] [order:2] - Maximum retry attempts
+ * @returns onSuccess [order:0] - Operation succeeded
+ * @returns onFailure [order:1] - All retries exhausted
+ * @returns result [order:2] - Operation result
+ * @returns attempts [order:3] - Number of attempts made
+ * @returns lastError [order:4] - Last error message if failed
+ */
+export ${asyncKeyword}function ${workflowName}(
+  execute: boolean,
+  params: { data: any; maxRetries?: number }
+): ${returnType} {
+  throw new Error("Compile with: fw compile <file>");
+}
+`.trim();
+  }
+};
+
+// src/cli/templates/workflows/approval.ts
+var configSchema2 = {
+  input: {
+    type: "string",
+    label: "Input Port Name",
+    description: "Name of the parameter that carries what needs approval",
+    default: "request",
+    placeholder: "request"
+  },
+  output: {
+    type: "string",
+    label: "Output Port Name",
+    description: "Name of the return value",
+    default: "outcome",
+    placeholder: "outcome"
+  }
+};
+var approvalTemplate = {
+  id: "approval",
+  name: "Approval",
+  description: "Prepare a request, pause for a person to approve it, then carry it out",
+  category: "automation",
+  configSchema: configSchema2,
+  generate: (opts) => {
+    const { workflowName, config } = opts;
+    const input = config?.input || "request";
+    const output = config?.output || "outcome";
+    return `
+/**
+ * Summarises the ${input} for the person who will decide.
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Prepare
+ * @input ${input} - What needs approval
+ * @output summary - One line for the approver
+ * @output ${input} - The same, passed on
+ */
+function prepare${cap(input)}(${input}: any): { summary: string; ${input}: any } {
+  // TODO: say what is being asked, in one line
+  return { summary: typeof ${input} === 'string' ? ${input} : JSON.stringify(${input}), ${input} };
+}
+
+/**
+ * A person approves or refuses. The run pauses here and resumes with the
+ * answer: the approver's note on onSuccess, or a refusal along onFailure.
+ * The body never runs. The coordinator substitutes the answer.
+ *
+ * @flowWeaver nodeType
+ * @durableGate approval
+ * @label Approve
+ * @input summary - What the approver sees
+ * @output note - What the approver said
+ */
+async function approve(
+  execute: boolean,
+  summary: string
+): Promise<{ onSuccess: boolean; onFailure: boolean; note: string }> {
+  throw new Error(\`durable gate: never executes (\${execute}:\${summary})\`);
+}
+
+/**
+ * Carries out the approved ${input}.
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Apply
+ * @input ${input} - The approved ${input}, from Prepare
+ * @input note - The approver's note
+ * @output ${output} - What happened
+ */
+function apply${cap(input)}(${input}: any, note: string): { ${output}: string } {
+  // TODO: do the thing
+  return { ${output}: \`applied \${JSON.stringify(${input})} -- \${note}\` };
+}
+
+/**
+ * @flowWeaver workflow
+ * @node prepare prepare${cap(input)} [color: "blue"] [icon: "description"]
+ * @node approval approve [color: "purple"] [icon: "how_to_reg"]
+ * @node apply apply${cap(input)} [color: "green"] [icon: "task_alt"]
+ * @path Start -> prepare -> approval -> apply -> Exit
+ * @path approval:fail -> Exit
+ * @param ${input} - What needs approval
+ * @returns ${output} - What happened
+ */
+export async function ${workflowName}(
+  execute: boolean,
+  params: { ${input}: any }
+): Promise<{ onSuccess: boolean, onFailure: boolean, ${output}: string }> {
+  throw new Error("Compile with: fw compile <file>");
+}
+`.trim();
+  }
+};
+var cap = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+
+// src/cli/templates/nodes/validator.ts
+var validatorNodeTemplate = {
+  id: "validator",
+  name: "Validator",
+  description: "Input validation with success/failure routing",
+  category: "validation",
+  generate: (name) => {
+    const pascalName = toPascalCase(name);
+    return `
+/**
+ * Validates input data against rules
+ *
+ * @flowWeaver nodeType
+ * @label ${pascalName}
+ * @color green
+ * @icon rule
+ * @input data [order:1] - Data to validate
+ * @input execute [order:0] - Execute
+ * @output isValid [order:2] - Whether data is valid
+ * @output validData [order:3] - Validated data (if valid)
+ * @output errors [order:4] - Validation errors (if invalid)
+ * @output onSuccess [order:0] - Validation passed
+ * @output onFailure [order:1] - Validation failed
+ */
+function ${name}(
+  execute: boolean,
+  data: any
+): { onSuccess: boolean; onFailure: boolean; isValid: boolean; validData: any; errors: string[] } {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, isValid: false, validData: null, errors: [] };
+  }
+
+  const errors: string[] = [];
+
+  // TODO: Add your validation rules
+  // Example validations:
+  if (data === null || data === undefined) {
+    errors.push("Data is required");
+  }
+
+  // if (typeof data.email === 'string' && !data.email.includes('@')) {
+  //   errors.push("Invalid email format");
+  // }
+
+  // if (typeof data.age === 'number' && (data.age < 0 || data.age > 150)) {
+  //   errors.push("Age must be between 0 and 150");
+  // }
+
+  if (errors.length > 0) {
+    return { onSuccess: false, onFailure: true, isValid: false, validData: null, errors };
+  }
+
+  return { onSuccess: true, onFailure: false, isValid: true, validData: data, errors: [] };
+}
+`.trim();
+  }
+};
+
+// src/cli/templates/nodes/transformer.ts
+var transformerNodeTemplate = {
+  id: "transformer",
+  name: "Transformer",
+  description: "Data transformation and mapping",
+  category: "data",
+  generate: (name) => {
+    const pascalName = toPascalCase(name);
+    return `
+/**
+ * Transforms input data into a new shape
+ *
+ * @flowWeaver nodeType
+ * @label ${pascalName}
+ * @color pink
+ * @icon changeCircle
+ * @input data [order:1] - Input data to transform
+ * @input execute [order:0] - Execute
+ * @output result [order:2] - Transformed data
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+function ${name}(
+  execute: boolean,
+  data: any
+): { onSuccess: boolean; onFailure: boolean; result: any } {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, result: null };
+  }
+
+  try {
+    // TODO: Implement your transformation logic
+    // Examples:
+
+    // Map array items
+    // const result = data.map(item => ({ ...item, processed: true }));
+
+    // Reshape object
+    // const result = {
+    //   id: data.userId,
+    //   fullName: \`\${data.firstName} \${data.lastName}\`,
+    //   email: data.contactEmail
+    // };
+
+    // Filter and transform
+    // const result = data
+    //   .filter(item => item.active)
+    //   .map(item => item.name);
+
+    const result = {
+      ...data,
+      transformedAt: new Date().toISOString()
+    };
+
+    return { onSuccess: true, onFailure: false, result };
+  } catch (err) {
+    console.error("[${pascalName}] Transform error:", err);
+    return { onSuccess: false, onFailure: true, result: null };
+  }
+}
+`.trim();
+  }
+};
+
+// src/cli/templates/nodes/http.ts
+var 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();
+  }
+};
+
+// src/cli/templates/nodes/aggregator.ts
+var 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();
+  }
+};
+
+// src/cli/templates/nodes/llm-call.ts
+var llmCallNodeTemplate = {
+  id: "llm-call",
+  name: "LLM Call",
+  description: "Provider-agnostic LLM API call with tool support",
+  category: "ai",
+  generate: (name) => {
+    const funcName = name || "llmCall";
+    return `
+// LLM Types
+interface LLMMessage { role: 'system' | 'user' | 'assistant' | 'tool'; content: string; toolCallId?: string; }
+interface LLMTool { name: string; description: string; parameters: { type: 'object'; properties: Record<string, { type: string; description?: string }>; required?: string[] }; }
+interface LLMToolCall { id: string; name: string; arguments: Record<string, unknown>; }
+interface LLMResponse { content: string | null; toolCalls: LLMToolCall[]; finishReason: string; }
+interface LLMProvider { chat(messages: LLMMessage[], options?: { tools?: LLMTool[]; temperature?: number }): Promise<LLMResponse>; }
+
+// Mock provider - replace with real provider (OpenAI, Anthropic, etc.)
+const createMockProvider = (): LLMProvider => ({
+  async chat(messages, options) {
+    const lastMsg = messages[messages.length - 1];
+    if (options?.tools?.length && lastMsg.content.toLowerCase().includes('search')) {
+      return { content: null, toolCalls: [{ id: \`call_\${Date.now()}\`, name: 'search', arguments: { query: lastMsg.content } }], finishReason: 'tool_calls' };
+    }
+    return { content: \`[Mock: \${lastMsg.content.slice(0, 40)}...]\`, toolCalls: [], finishReason: 'stop' };
+  },
+});
+
+const llmProvider: LLMProvider = createMockProvider();
+
+/**
+ * Calls an LLM with messages and optional tools
+ *
+ * @flowWeaver nodeType
+ * @label ${funcName}
+ * @color purple
+ * @icon psychology
+ * @input messages [order:1] - Conversation messages
+ * @input tools [order:2] - Available tools/functions (optional)
+ * @input systemPrompt [order:3] - System prompt (optional)
+ * @input temperature [order:4] - Temperature 0-1 (optional)
+ * @input execute [order:0] - Execute
+ * @output content [order:2] - Text response (null if tool call)
+ * @output toolCalls [order:3] - Tool calls requested by LLM
+ * @output hasToolCalls [order:4] - Whether LLM wants to call tools
+ * @output finishReason [order:5] - Why generation stopped
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+async function ${funcName}(
+  execute: boolean,
+  messages: LLMMessage[],
+  tools?: LLMTool[],
+  systemPrompt?: string,
+  temperature?: number
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  content: string | null;
+  toolCalls: LLMToolCall[];
+  hasToolCalls: boolean;
+  finishReason: string;
+}> {
+  if (!execute) {
+    return {
+      onSuccess: false,
+      onFailure: false,
+      content: null,
+      toolCalls: [],
+      hasToolCalls: false,
+      finishReason: 'skipped'
+    };
+  }
+
+  try {
+    const allMessages: LLMMessage[] = systemPrompt
+      ? [{ role: 'system', content: systemPrompt }, ...messages]
+      : messages;
+
+    const response = await llmProvider.chat(allMessages, {
+      tools,
+      temperature,
+    });
+
+    return {
+      onSuccess: true,
+      onFailure: false,
+      content: response.content,
+      toolCalls: response.toolCalls,
+      hasToolCalls: response.toolCalls.length > 0,
+      finishReason: response.finishReason
+    };
+  } catch (error) {
+    console.error('LLM call failed:', error);
+    return {
+      onSuccess: false,
+      onFailure: true,
+      content: null,
+      toolCalls: [],
+      hasToolCalls: false,
+      finishReason: 'error'
+    };
+  }
+}
+`.trim();
+  }
+};
+
+// src/cli/templates/nodes/tool-executor.ts
+var toolExecutorNodeTemplate = {
+  id: "tool-executor",
+  name: "Tool Executor",
+  description: "Executes tool calls from LLM response",
+  category: "ai",
+  generate: (name) => {
+    const funcName = name || "executeTool";
+    return `
+// LLM Types
+interface LLMToolCall { id: string; name: string; arguments: Record<string, unknown>; }
+interface LLMMessage { role: 'system' | 'user' | 'assistant' | 'tool'; content: string; toolCallId?: string; }
+
+// Register your tools here
+type ToolFunction = (args: Record<string, unknown>) => Promise<unknown>;
+const toolRegistry: Record<string, ToolFunction> = {
+  // Example tools:
+  // 'search': async (args) => {
+  //   const query = String(args.query || '');
+  //   return await searchDatabase(query);
+  // },
+  // 'get_weather': async (args) => {
+  //   const city = String(args.city || '');
+  //   const response = await fetch(\`https://api.weather.example/v1/\${encodeURIComponent(city)}\`);
+  //   return response.json();
+  // },
+};
+
+/**
+ * Executes a single tool call and returns result as message
+ *
+ * @flowWeaver nodeType
+ * @label ${funcName}
+ * @color cyan
+ * @icon build
+ * @input toolCall [order:1] - Tool call to execute
+ * @input execute [order:0] - Execute
+ * @output result [order:2] - Tool execution result
+ * @output resultMessage [order:3] - Result formatted as LLM message
+ * @output toolName [order:4] - Name of executed tool
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+async function ${funcName}(
+  execute: boolean,
+  toolCall: LLMToolCall
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  result: unknown;
+  resultMessage: LLMMessage;
+  toolName: string;
+}> {
+  if (!execute) {
+    return {
+      onSuccess: false,
+      onFailure: false,
+      result: null,
+      resultMessage: { role: 'tool', content: '', toolCallId: '' },
+      toolName: ''
+    };
+  }
+
+  const tool = toolRegistry[toolCall.name];
+  if (!tool) {
+    return {
+      onSuccess: false,
+      onFailure: true,
+      result: null,
+      resultMessage: {
+        role: 'tool',
+        content: JSON.stringify({ error: \`Unknown tool: \${toolCall.name}\` }),
+        toolCallId: toolCall.id
+      },
+      toolName: toolCall.name
+    };
+  }
+
+  try {
+    const result = await tool(toolCall.arguments);
+    return {
+      onSuccess: true,
+      onFailure: false,
+      result,
+      resultMessage: {
+        role: 'tool',
+        content: JSON.stringify(result),
+        toolCallId: toolCall.id
+      },
+      toolName: toolCall.name
+    };
+  } catch (error) {
+    return {
+      onSuccess: false,
+      onFailure: true,
+      result: null,
+      resultMessage: {
+        role: 'tool',
+        content: JSON.stringify({ error: String(error) }),
+        toolCallId: toolCall.id
+      },
+      toolName: toolCall.name
+    };
+  }
+}
+`.trim();
+  }
+};
+
+// src/cli/templates/nodes/conversation-memory.ts
+var 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();
+  }
+};
+
+// src/cli/templates/nodes/prompt-template.ts
+var promptTemplateNodeTemplate = {
+  id: "prompt-template",
+  name: "Prompt Template",
+  description: "Interpolate variables into a prompt template string",
+  category: "ai",
+  generate: (name) => {
+    const funcName = name || "promptTemplate";
+    const label = toPascalCase(funcName);
+    return `
+/**
+ * Interpolate variables into a prompt template string.
+ * Uses {{variableName}} syntax for placeholders.
+ *
+ * Example:
+ *   template: "Hello {{name}}, your order {{orderId}} is ready."
+ *   variables: { name: "Alice", orderId: "12345" }
+ *   \u2192 prompt: "Hello Alice, your order 12345 is ready."
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label ${label}
+ * @color pink
+ * @icon textSnippet
+ * @input template [order:0] - Template string with {{variable}} placeholders
+ * @input variables [order:1] - Key-value pairs to interpolate
+ * @output prompt [order:0] - Rendered prompt string
+ * @output unresolvedCount [order:1] - Number of unresolved placeholders
+ */
+function ${funcName}(
+  template: string,
+  variables: Record<string, string>
+): {
+  prompt: string;
+  unresolvedCount: number;
+} {
+  let unresolved = 0;
+
+  const prompt = template.replace(/\\{\\{\\s*(\\w+)\\s*\\}\\}/g, (match, key) => {
+    if (key in variables) {
+      return variables[key];
+    }
+    unresolved++;
+    return match; // Leave unresolved placeholders as-is
+  });
+
+  return { prompt, unresolvedCount: unresolved };
+}
+`.trim();
+  }
+};
+
+// src/cli/templates/nodes/json-extractor.ts
+var 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();
+  }
+};
+
+// src/cli/templates/nodes/human-approval.ts
+var humanApprovalNodeTemplate = {
+  id: "human-approval",
+  name: "Human Approval",
+  description: "Pause workflow and wait for human approval",
+  category: "workflow",
+  generate: (name) => {
+    const funcName = name || "humanApproval";
+    const label = toPascalCase(funcName);
+    return `
+/**
+ * Yield a durable human-approval gate.
+ *
+ * The generated engine never calls this body. A coordinator persists the
+ * yielded continuation and gate atomically, then supplies the exact resolution
+ * to a later compatible Node.js executor invocation.
+ *
+ * @flowWeaver nodeType
+ * @durableGate approval
+ * @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;
+}> {
+  throw new Error(
+    \`durable approval gate must not execute: \${execute}:\${prompt}:\${String(context)}:\${String(timeout)}\`,
+  );
+}
+`.trim();
+  }
+};
+
+// src/cli/templates/nodes/agent-router.ts
+var 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 \u2192 agentRouter.category
+//   agentRouter.selectedRoute \u2192 (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();
+  }
+};
+
+// src/cli/templates/nodes/rag-retriever.ts
+var ragRetrieverNodeTemplate = {
+  id: "rag-retriever",
+  name: "RAG Retriever",
+  description: "Retrieve relevant documents via vector similarity search",
+  category: "ai",
+  generate: (name) => {
+    const funcName = name || "ragRetriever";
+    const label = toPascalCase(funcName);
+    return `
+// ============================================================
+// VECTOR STORE
+// ============================================================
+//
+// Replace mockRetrieve() with your vector store:
+//
+//   Pinecone:  const results = await index.query({ vector: embedding, topK });
+//   pgvector:  const results = await db.query(
+//                'SELECT text, metadata, 1 - (embedding <=> $1) AS score FROM docs ORDER BY score DESC LIMIT $2',
+//                [embedding, topK]
+//              );
+//   Weaviate:  const results = await client.graphql.get()
+//                .withClassName('Document')
+//                .withNearText({ concepts: [query] })
+//                .withLimit(topK)
+//                .do();
+//   ChromaDB:  const results = await collection.query({ queryTexts: [query], nResults: topK });
+
+interface RetrievedDocument {
+  text: string;
+  score: number;
+  metadata?: Record<string, unknown>;
+}
+
+// Mock document store. Replace with a real vector database
+const MOCK_DOCUMENTS: Record<string, RetrievedDocument[]> = {
+  default: [
+    { text: 'Flow Weaver compiles workflows to standalone TypeScript functions.', score: 0.95, metadata: { source: 'docs/overview.md' } },
+    { text: 'The compiler validates connections at compile time, catching errors before runtime.', score: 0.88, metadata: { source: 'docs/compiler.md' } },
+    { text: 'Workflows are standard TypeScript files with JSDoc annotations.', score: 0.82, metadata: { source: 'docs/authoring.md' } },
+    { text: 'Deploy compiled workflows to any supported target via installed packs.', score: 0.75, metadata: { source: 'docs/deployment.md' } },
+    { text: 'The console shows each run step by step and answers paused gates from a form.', score: 0.71, metadata: { source: 'docs/console.md' } },
+  ],
+};
+
+async function mockRetrieve(query: string, collection: string, topK: number): Promise<RetrievedDocument[]> {
+  const docs = MOCK_DOCUMENTS[collection] || MOCK_DOCUMENTS['default'] || [];
+
+  // Simple keyword overlap scoring (mock, since real stores use vector similarity)
+  const queryWords = new Set(query.toLowerCase().split(/\\s+/));
+  const scored = docs.map((doc) => {
+    const docWords = doc.text.toLowerCase().split(/\\s+/);
+    const overlap = docWords.filter((w) => queryWords.has(w)).length;
+    const score = Math.min(0.99, overlap / Math.max(queryWords.size, 1) * 0.5 + doc.score * 0.5);
+    return { ...doc, score };
+  });
+
+  return scored
+    .sort((a, b) => b.score - a.score)
+    .slice(0, topK);
+}
+
+/**
+ * Retrieve relevant documents via vector similarity search.
+ * Returns scored documents and a concatenated context string ready for LLM input.
+ *
+ * @flowWeaver nodeType
+ * @label ${label}
+ * @color green
+ * @icon search
+ * @input execute [order:0] - Execute
+ * @input query [order:1] - Search query text
+ * @input collection [order:2] - Collection/index name
+ * @input topK [order:3] - Number of results (optional, default 5)
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ * @output documents [order:2] - Retrieved documents with relevance scores
+ * @output context [order:3] - Concatenated document text for LLM context
+ */
+async function ${funcName}(
+  execute: boolean,
+  query: string,
+  collection: string,
+  topK?: number
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  documents: RetrievedDocument[];
+  context: string;
+}> {
+  if (!execute) {
+    return {
+      onSuccess: false,
+      onFailure: false,
+      documents: [],
+      context: '',
+    };
+  }
+
+  try {
+    const limit = topK ?? 5;
+    const documents = await mockRetrieve(query, collection, limit);
+
+    // Concatenate document texts for easy LLM context injection
+    const context = documents
+      .map((doc, i) => \`[Document \${i + 1} (score: \${doc.score.toFixed(2)})]
+\${doc.text}\`)
+      .join('\\n\\n');
+
+    return {
+      onSuccess: true,
+      onFailure: false,
+      documents,
+      context,
+    };
+  } catch (error) {
+    console.error('RAG retrieval failed:', error);
+    return {
+      onSuccess: false,
+      onFailure: true,
+      documents: [],
+      context: '',
+    };
+  }
+}
+`.trim();
+  }
+};
+
+// src/cli/templates/index.ts
+var workflowTemplates = [
+  sequentialTemplate,
+  foreachTemplate,
+  conditionalTemplate,
+  approvalTemplate,
+  aiAgentTemplate,
+  aiReactTemplate,
+  aiRagTemplate,
+  aiChatTemplate,
+  aggregatorTemplate,
+  webhookTemplate,
+  errorHandlerTemplate
+];
+var nodeTemplates = [
+  validatorNodeTemplate,
+  transformerNodeTemplate,
+  httpNodeTemplate,
+  aggregatorNodeTemplate,
+  llmCallNodeTemplate,
+  toolExecutorNodeTemplate,
+  conversationMemoryNodeTemplate,
+  promptTemplateNodeTemplate,
+  jsonExtractorNodeTemplate,
+  humanApprovalNodeTemplate,
+  agentRouterNodeTemplate,
+  ragRetrieverNodeTemplate
+];
+function getWorkflowTemplate(id) {
+  return workflowTemplates.find((t) => t.id === id) ?? packWorkflowTemplates.find((t) => t.id === id);
+}
+function getNodeTemplate(id) {
+  return nodeTemplates.find((t) => t.id === id);
+}
+var packWorkflowTemplates = [];
+function getAllWorkflowTemplates() {
+  return [...workflowTemplates, ...packWorkflowTemplates];
+}
+function registerWorkflowTemplates(templates) {
+  for (const tmpl of templates) {
+    if (!packWorkflowTemplates.some((t) => t.id === tmpl.id)) {
+      packWorkflowTemplates.push(tmpl);
+    }
+  }
+}
+
+export {
+  toCamelCase,
+  nodeTemplates,
+  getWorkflowTemplate,
+  getNodeTemplate,
+  getAllWorkflowTemplates,
+  registerWorkflowTemplates
+};