@synergenius/flow-weaver 0.2.0

package/dist/cli/templates/workflows/ai-chat.js

@@ -0,0 +1,169 @@
+import { getProviderCode } from '../providers/index.js';
+import { aiConfigSchema } from './ai-agent.js';
+import { LLM_SIMPLE_TYPES, LLM_MOCK_PROVIDER } from '../shared/llm-types.js';
+export const 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 || '';
+        // Get provider-specific code or use mock
+        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
+ * @node respond chat
+ * @node saveMem memory
+ * @position Start -350 0
+ * @position mem -150 0
+ * @position respond 50 0
+ * @position saveMem 250 0
+ * @position Exit 450 0
+ * @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.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: flow-weaver compile <file>');
+}
+`.trim();
+    },
+};
+//# sourceMappingURL=ai-chat.js.map

package/dist/cli/templates/workflows/ai-pipeline-durable.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Durable AI Pipeline Template
+ * Sequential data processing pipeline with durability annotations for Inngest compilation.
+ * Each node maps to a checkpointed step — if step 3 fails, it retries from step 3, not from scratch.
+ */
+import type { WorkflowTemplate } from '../index.js';
+export declare const aiPipelineDurableTemplate: WorkflowTemplate;
+//# sourceMappingURL=ai-pipeline-durable.d.ts.map

package/dist/cli/templates/workflows/ai-pipeline-durable.js

@@ -0,0 +1,330 @@
+import { getProviderCode } from '../providers/index.js';
+import { aiConfigSchema } from './ai-agent.js';
+import { LLM_CORE_TYPES, LLM_MOCK_PROVIDER } from '../shared/llm-types.js';
+export const aiPipelineDurableTemplate = {
+    id: 'ai-pipeline-durable',
+    name: 'Durable AI Pipeline',
+    description: 'Sequential data pipeline with durability — fetch, extract, validate, save',
+    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}
+`
+            : getProviderCode(provider, model);
+        return `
+// ============================================================
+// Durable Data Pipeline
+// ============================================================
+//
+// Each node becomes a checkpointed step when compiled to Inngest.
+// If step 3 fails, it retries from step 3 — not from scratch.
+//
+// Compile:  flow-weaver compile <file>
+// Export:   fw export --target inngest
+//
+// Flow: fetchData → extract (LLM) → validate → save
+//                                      ↓ onFailure
+//                                    Exit.onFailure
+
+/* ============================================================
+ * CORE TYPES
+ * ============================================================ */
+
+${LLM_CORE_TYPES}
+
+/* ============================================================
+ * STORAGE (mock — replace with real database/API)
+ * ============================================================ */
+
+interface ExtractedRecord {
+  title: string;
+  summary: string;
+  entities: string[];
+  confidence: number;
+}
+
+const mockStore: Map<string, ExtractedRecord> = new Map();
+
+${providerCode}
+
+/* ============================================================
+ * NODES
+ * ============================================================ */
+
+/**
+ * Fetch raw data from a URL
+ *
+ * @flowWeaver nodeType
+ * @label Fetch Data
+ * @color blue
+ * @icon download
+ * @input execute [order:0] - Execute
+ * @input url [order:1] - URL to fetch data from
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ * @output data [order:2] - Raw fetched data
+ * @output contentType [order:3] - Response content type
+ */
+async function fetchData(
+  execute: boolean,
+  url: string
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  data: string;
+  contentType: string;
+}> {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, data: '', contentType: '' };
+  }
+
+  try {
+    // Mock fetch — replace with real HTTP call
+    // const response = await fetch(url);
+    // const data = await response.text();
+    // return { onSuccess: true, onFailure: false, data, contentType: response.headers.get('content-type') || '' };
+
+    console.log('[Mock Fetch]', url);
+    const mockData = JSON.stringify({
+      title: 'Sample Article',
+      body: 'This article discusses the benefits of compiled workflows for AI agent reliability and testing.',
+      author: 'Jane Doe',
+      date: '2026-02-18',
+    });
+
+    return { onSuccess: true, onFailure: false, data: mockData, contentType: 'application/json' };
+  } catch (error) {
+    console.error('Fetch failed:', error);
+    return { onSuccess: false, onFailure: true, data: '', contentType: '' };
+  }
+}
+
+/**
+ * Use LLM to extract structured information from raw data
+ *
+ * @flowWeaver nodeType
+ * @label Extract Info
+ * @color purple
+ * @icon psychology
+ * @input execute [order:0] - Execute
+ * @input rawData [order:1] - Raw data to extract from
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ * @output extracted [order:2] - Extracted structured record
+ */
+async function extractInfo(
+  execute: boolean,
+  rawData: string
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  extracted: ExtractedRecord | null;
+}> {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, extracted: null };
+  }
+
+  try {
+    const prompt = \`Extract the following from this data:
+- title: the main title
+- summary: a one-sentence summary
+- entities: list of named entities (people, organizations, topics)
+- confidence: how confident you are in the extraction (0-1)
+
+Respond with valid JSON only.
+
+Data:
+\${rawData}\`;
+
+    const response = await llmProvider.chat([{ role: 'user', content: prompt }]);
+
+    // Parse LLM response as JSON
+    const content = response.content || '{}';
+
+    // Try to extract JSON from response (handle markdown fences)
+    let jsonStr = content;
+    const fenceMatch = content.match(/\`\`\`(?:json)?\\s*([\\s\\S]*?)\`\`\`/);
+    if (fenceMatch) {
+      jsonStr = fenceMatch[1].trim();
+    }
+
+    // Mock extraction for mock provider
+    let extracted: ExtractedRecord;
+    try {
+      extracted = JSON.parse(jsonStr);
+    } catch {
+      // Fallback for mock provider responses
+      extracted = {
+        title: 'Extracted Title',
+        summary: 'Extracted summary from raw data.',
+        entities: ['entity1', 'entity2'],
+        confidence: 0.85,
+      };
+    }
+
+    return { onSuccess: true, onFailure: false, extracted };
+  } catch {
+    return { onSuccess: false, onFailure: true, extracted: null };
+  }
+}
+
+/**
+ * Validate extracted data against expected schema
+ *
+ * @flowWeaver nodeType
+ * @label Validate
+ * @color yellow
+ * @icon check-circle
+ * @input execute [order:0] - Execute
+ * @input data [order:1] - Extracted record to validate
+ * @output onSuccess [order:0] - On Success (valid)
+ * @output onFailure [order:1] - On Failure (invalid)
+ * @output validated [order:2] - Validated record
+ * @output errors [order:3] - Validation error messages
+ */
+function validateResult(
+  execute: boolean,
+  data: ExtractedRecord | null
+): {
+  onSuccess: boolean;
+  onFailure: boolean;
+  validated: ExtractedRecord | null;
+  errors: string[];
+} {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, validated: null, errors: [] };
+  }
+
+  const errors: string[] = [];
+
+  if (!data) {
+    errors.push('No data to validate');
+    return { onSuccess: false, onFailure: true, validated: null, errors };
+  }
+
+  if (!data.title || typeof data.title !== 'string') {
+    errors.push('Missing or invalid title');
+  }
+  if (!data.summary || typeof data.summary !== 'string') {
+    errors.push('Missing or invalid summary');
+  }
+  if (!Array.isArray(data.entities)) {
+    errors.push('Missing or invalid entities array');
+  }
+  if (typeof data.confidence !== 'number' || data.confidence < 0 || data.confidence > 1) {
+    errors.push('Confidence must be a number between 0 and 1');
+  }
+
+  if (errors.length > 0) {
+    return { onSuccess: false, onFailure: true, validated: null, errors };
+  }
+
+  return { onSuccess: true, onFailure: false, validated: data, errors: [] };
+}
+
+/**
+ * Save validated record to storage
+ *
+ * @flowWeaver nodeType
+ * @label Save Result
+ * @color green
+ * @icon database
+ * @input execute [order:0] - Execute
+ * @input data [order:1] - Validated record to save
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ * @output id [order:2] - Saved record identifier
+ */
+async function saveResult(
+  execute: boolean,
+  data: ExtractedRecord
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  id: string;
+}> {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, id: '' };
+  }
+
+  try {
+    // Mock save — replace with real database/API:
+    // await db.insert('records', data);
+    // return { onSuccess: true, onFailure: false, id: result.insertedId };
+
+    const id = 'rec_' + Date.now().toString(36);
+    mockStore.set(id, data);
+    console.log('[Mock Save] Stored record:', id);
+
+    return { onSuccess: true, onFailure: false, id };
+  } catch (error) {
+    console.error('Save failed:', error);
+    return { onSuccess: false, onFailure: true, id: '' };
+  }
+}
+
+/* ============================================================
+ * WORKFLOW
+ * ============================================================ */
+
+/**
+ * Durable Data Pipeline — sequential fetch, extract, validate, save.
+ * Each node becomes a checkpointed step when compiled to Inngest.
+ *
+ * @flowWeaver workflow
+ * @trigger event="pipeline/start"
+ * @retries 3
+ * @node fetch fetchData
+ * @node extract extractInfo
+ * @node validate validateResult
+ * @node save saveResult
+ * @position Start -500 0
+ * @position fetch -280 0
+ * @position extract -40 0
+ * @position validate 200 0
+ * @position save 440 0
+ * @position Exit 680 0
+ * @connect Start.execute -> fetch.execute
+ * @connect Start.url -> fetch.url
+ * @connect fetch.onSuccess -> extract.execute
+ * @connect fetch.data -> extract.rawData
+ * @connect extract.onSuccess -> validate.execute
+ * @connect extract.extracted -> validate.data
+ * @connect validate.onSuccess -> save.execute
+ * @connect validate.validated -> save.data
+ * @connect fetch.onFailure -> Exit.onFailure
+ * @connect extract.onFailure -> Exit.onFailure
+ * @connect validate.onFailure -> Exit.onFailure
+ * @connect save.onSuccess -> Exit.onSuccess
+ * @connect save.id -> Exit.id
+ * @connect validate.errors -> Exit.errors
+ * @param execute [order:0] - Execute
+ * @param url [order:1] - URL to fetch and process
+ * @returns onSuccess [order:0] - Pipeline completed successfully
+ * @returns onFailure [order:1] - Pipeline encountered an error
+ * @returns id [order:2] - Saved record identifier
+ * @returns errors [order:3] - Validation errors (if any)
+ */
+export async function ${workflowName}(
+  execute: boolean,
+  params: { url: string }
+): Promise<{
+  onSuccess: boolean;
+  onFailure: boolean;
+  id: string;
+  errors: string[];
+}> {
+  throw new Error('Compile with: flow-weaver compile <file>');
+}
+`.trim();
+    },
+};
+//# sourceMappingURL=ai-pipeline-durable.js.map

package/dist/cli/templates/workflows/ai-rag.d.ts

@@ -0,0 +1,7 @@
+/**
+ * RAG Pipeline Template
+ * Retrieve → Augment → Generate
+ */
+import type { WorkflowTemplate } from '../index.js';
+export declare const aiRagTemplate: WorkflowTemplate;
+//# sourceMappingURL=ai-rag.d.ts.map

package/dist/cli/templates/workflows/ai-rag.js

@@ -0,0 +1,186 @@
+import { getProviderCode } from '../providers/index.js';
+import { aiConfigSchema } from './ai-agent.js';
+import { LLM_SIMPLE_TYPES, LLM_MOCK_PROVIDER } from '../shared/llm-types.js';
+export const 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 || '';
+        // Get provider-specific code or use mock
+        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] - 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
+ * @node generator generate
+ * @position Start -300 0
+ * @position retriever -50 0
+ * @position generator 200 0
+ * @position Exit 400 0
+ * @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: flow-weaver compile <file>');
+}
+`.trim();
+    },
+};
+//# sourceMappingURL=ai-rag.js.map

package/dist/cli/templates/workflows/ai-react.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ReAct Agent Template
+ * Implements: Thought → Action → Observation loop with scoped iteration
+ */
+import type { WorkflowTemplate } from '../index.js';
+export declare const aiReactTemplate: WorkflowTemplate;
+//# sourceMappingURL=ai-react.d.ts.map