@synergenius/flow-weaver 0.2.0

package/dist/cli/templates/nodes/llm-call.js

@@ -0,0 +1,106 @@
+export const 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 = (globalThis as unknown as { __fw_llm_provider__?: LLMProvider }).__fw_llm_provider__ ?? 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();
+    },
+};
+//# sourceMappingURL=llm-call.js.map

package/dist/cli/templates/nodes/prompt-template.d.ts

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

package/dist/cli/templates/nodes/prompt-template.js

@@ -0,0 +1,52 @@
+import { toPascalCase } from '../index.js';
+export const 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" }
+ *   → 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();
+    },
+};
+//# sourceMappingURL=prompt-template.js.map

package/dist/cli/templates/nodes/rag-retriever.d.ts

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

package/dist/cli/templates/nodes/rag-retriever.js

@@ -0,0 +1,128 @@
+import { toPascalCase } from '../index.js';
+export const 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 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 Lambda, Vercel, Cloudflare, or Inngest.', score: 0.75, metadata: { source: 'docs/deployment.md' } },
+    { text: 'The visual editor provides bidirectional editing — code changes update the canvas and vice versa.', score: 0.71, metadata: { source: 'docs/editor.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 — 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)})]\n\${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();
+    },
+};
+//# sourceMappingURL=rag-retriever.js.map

package/dist/cli/templates/nodes/tool-executor.d.ts

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

package/dist/cli/templates/nodes/tool-executor.js

@@ -0,0 +1,108 @@
+export const 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();
+    },
+};
+//# sourceMappingURL=tool-executor.js.map

package/dist/cli/templates/nodes/transformer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Transformer Node Template
+ * Data transformation and mapping
+ */
+import type { NodeTemplate } from "../index.js";
+export declare const transformerNodeTemplate: NodeTemplate;
+//# sourceMappingURL=transformer.d.ts.map

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

@@ -0,0 +1,68 @@
+/**
+ * Transformer Node Template
+ * Data transformation and mapping
+ */
+import { toPascalCase } from "../index.js";
+export const 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();
+    },
+};
+//# sourceMappingURL=transformer.js.map

package/dist/cli/templates/nodes/validator.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Validator Node Template
+ * Input validation with success/failure routing
+ */
+import type { NodeTemplate } from "../index.js";
+export declare const validatorNodeTemplate: NodeTemplate;
+//# sourceMappingURL=validator.d.ts.map

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

@@ -0,0 +1,62 @@
+/**
+ * Validator Node Template
+ * Input validation with success/failure routing
+ */
+import { toPascalCase } from "../index.js";
+export const 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();
+    },
+};
+//# sourceMappingURL=validator.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * LLM Provider Code Generators
+ * Generate provider implementation code for different LLM services
+ */
+export interface ProviderCodeOptions {
+    model: string;
+    apiKeyEnvVar?: string;
+}
+export declare function generateOpenAIProvider(opts: ProviderCodeOptions): string;
+export declare function generateAnthropicProvider(opts: ProviderCodeOptions): string;
+export declare function generateOllamaProvider(opts: ProviderCodeOptions): string;
+export declare function generateMockProvider(): string;
+export declare function getProviderCode(provider: string, model?: string): string;
+//# sourceMappingURL=index.d.ts.map