@synergenius/flow-weaver 0.33.1 → 0.44.0

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

@@ -1,106 +0,0 @@
-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.js

@@ -1,52 +0,0 @@
-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.js

@@ -1,128 +0,0 @@
-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 any supported target via installed packs.', 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.js

@@ -1,108 +0,0 @@
-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.js

@@ -1,68 +0,0 @@
-/**
- * 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.js

@@ -1,62 +0,0 @@
-/**
- * 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/pack-loader.js

@@ -1,58 +0,0 @@
-/**
- * Load workflow templates from installed marketplace packs.
- *
- * Separated from the main templates barrel so that Node.js-only imports
- * (marketplace/registry, init-personas, fs, path) are not pulled into
- * browser builds that only need the template definitions.
- */
-import { registerWorkflowTemplates } from './index.js';
-/**
- * Load workflow templates from installed pack manifests.
- * Templates declared in `initContributions.templates` are dynamically imported
- * and appended to the available template list.
- *
- * @param projectDir - Project root to scan for installed packs
- */
-export async function loadPackTemplates(projectDir) {
-    try {
-        const { listInstalledPackages } = await import('../../marketplace/registry.js');
-        const { registerPackUseCase } = await import('../commands/init-personas.js');
-        const packages = await listInstalledPackages(projectDir);
-        const loaded = [];
-        for (const pkg of packages) {
-            const contributions = pkg.manifest.initContributions;
-            if (!contributions?.templates)
-                continue;
-            // Register use case if declared
-            if (contributions.useCase) {
-                registerPackUseCase(contributions.useCase, contributions.templates);
-            }
-            // Pack templates must be exported from the pack's main entry point
-            // or from a templates.js file alongside the manifest
-            try {
-                const templatesPath = await import('path').then((p) => p.join(pkg.path, 'templates.js'));
-                const { existsSync } = await import('fs');
-                if (!existsSync(templatesPath))
-                    continue;
-                const mod = await import(templatesPath);
-                if (mod.workflowTemplates && Array.isArray(mod.workflowTemplates)) {
-                    for (const tmpl of mod.workflowTemplates) {
-                        if (contributions.templates.includes(tmpl.id)) {
-                            loaded.push(tmpl);
-                        }
-                    }
-                }
-            }
-            catch {
-                // Skip packs that fail to load templates
-            }
-        }
-        if (loaded.length > 0) {
-            registerWorkflowTemplates(loaded);
-        }
-    }
-    catch {
-        // Marketplace scanning not available (e.g., no node_modules)
-    }
-}
-//# sourceMappingURL=pack-loader.js.map