@synergenius/flow-weaver 0.33.2 → 0.44.0

package/dist/api/parse.js

@@ -1,115 +0,0 @@
-import { parser } from '../parser.js';
-import { getErrorMessage } from '../utils/error-utils.js';
-/**
- * Parse a workflow file and convert it to AST
- *
- * @param filePath - Path to the workflow file
- * @param options - Parse options including workflow name
- * @returns ParseResult with AST, errors, and warnings
- *
- * @example
- * ```typescript
- * const result = await parseWorkflow('./my-workflow.ts', {
- *   workflowName: 'myWorkflow'
- * });
- *
- * if (result.errors.length > 0) {
- *   console.error('Parse errors:', result.errors);
- * } else {
- *   console.log('Parsed workflow:', result.ast.functionName);
- * }
- * ```
- */
-export async function parseWorkflow(filePath, options) {
-    const errors = [];
-    const warnings = [];
-    let availableWorkflows = [];
-    try {
-        // Load marketplace pack tag handlers before parsing
-        if (options?.projectDir) {
-            await parser.loadPackHandlers(options.projectDir);
-        }
-        // Parse the file to extract nodes and workflows
-        const parsed = parser.parse(filePath);
-        warnings.push(...parsed.warnings);
-        errors.push(...parsed.errors);
-        // Get available workflow names
-        availableWorkflows = parsed.workflows.map((w) => w.functionName);
-        // Determine which workflow to use
-        let workflowName = options?.workflowName;
-        if (!workflowName) {
-            if (parsed.workflows.length === 0) {
-                // If nodeTypesOnly mode is enabled and we have node types, return them
-                if (options?.nodeTypesOnly && parsed.nodeTypes.length > 0) {
-                    return {
-                        ast: {
-                            type: 'Workflow',
-                            functionName: '',
-                            name: '',
-                            sourceFile: filePath,
-                            nodeTypes: parsed.nodeTypes,
-                            instances: [],
-                            connections: [],
-                            scopes: {},
-                            startPorts: {},
-                            exitPorts: {},
-                            imports: [],
-                        },
-                        errors: [],
-                        warnings,
-                        availableWorkflows: [],
-                        allWorkflows: [],
-                    };
-                }
-                const nodeTypeCount = parsed.nodeTypes.length;
-                const nodeTypeHint = nodeTypeCount > 0
-                    ? ` (found ${nodeTypeCount} node type${nodeTypeCount === 1 ? '' : 's'}, but no workflow function)`
-                    : '';
-                errors.push(`No workflows found in file${nodeTypeHint}. Add a /** @flowWeaver workflow */ annotation above an exported function to define a workflow. Ensure node type functions are annotated with /** @flowWeaver nodeType */ first.`);
-                throw new Error('No workflows found in file');
-            }
-            if (parsed.workflows.length > 1) {
-                errors.push(`[MULTIPLE_WORKFLOWS_FOUND] Multiple workflows found: ${availableWorkflows.join(', ')}. Please specify workflowName in options.`);
-                throw new Error('Multiple workflows found, workflowName required');
-            }
-            // Single workflow found, use it
-            workflowName = parsed.workflows[0].functionName;
-        }
-        // Find the workflow
-        const workflow = parsed.workflows.find((w) => w.functionName === workflowName);
-        if (!workflow) {
-            errors.push(`Workflow "${workflowName}" not found. Available: ${availableWorkflows.join(', ')}`);
-            throw new Error(`Workflow "${workflowName}" not found`);
-        }
-        return {
-            ast: workflow,
-            errors,
-            warnings,
-            availableWorkflows,
-            allWorkflows: parsed.workflows,
-        };
-    }
-    catch (error) {
-        // If we already added errors, return with availableWorkflows
-        if (errors.length > 0) {
-            return {
-                ast: {}, // Return empty AST on error
-                errors,
-                warnings,
-                availableWorkflows, // Include available workflows even on error
-                allWorkflows: [],
-            };
-        }
-        // Handle unexpected errors
-        const errorMessage = getErrorMessage(error);
-        errors.push(`Failed to parse workflow: ${errorMessage}`);
-        return {
-            ast: {},
-            errors,
-            warnings,
-            availableWorkflows,
-            allWorkflows: [],
-        };
-    }
-}
-//# sourceMappingURL=parse.js.map

package/dist/api/patterns.d.ts

@@ -1,112 +0,0 @@
-/**
- * Pure pattern API — no I/O, no console, no filesystem writes.
- *
- * Provides business logic for listing patterns, applying patterns to workflows,
- * and generating node type code. CLI and MCP layers call these functions
- * and handle their own I/O.
- */
-import type { TPatternAST, TNodeTypeAST, TWorkflowAST } from '../ast/types.js';
-export interface PatternInfo {
-    name: string;
-    description?: string;
-    inputPorts: Array<{
-        name: string;
-        description?: string;
-    }>;
-    outputPorts: Array<{
-        name: string;
-        description?: string;
-    }>;
-    nodes: string[];
-}
-export interface WorkflowFileInfo {
-    filePath: string;
-    workflows: Array<{
-        name: string;
-        functionName: string;
-        nodeCount: number;
-        connectionCount: number;
-    }>;
-}
-export interface ExtractPatternOptions {
-    workflowAST: TWorkflowAST;
-    nodeTypes: TNodeTypeAST[];
-    nodeIds: string[];
-    name?: string;
-}
-export interface ExtractPatternResult {
-    patternCode: string;
-    patternName: string;
-    nodes: string[];
-    inputPorts: string[];
-    outputPorts: string[];
-    internalConnectionCount: number;
-}
-export interface ApplyPatternOptions {
-    /** The pattern AST to apply */
-    patternAST: TPatternAST;
-    /** Raw text content of the target workflow file */
-    targetContent: string;
-    /** Node type names already present in the target workflow */
-    targetNodeTypes: Set<string>;
-    /** Optional prefix for node IDs to avoid conflicts */
-    prefix?: string;
-}
-export interface ApplyPatternResult {
-    /** Modified file content with the pattern applied */
-    modifiedContent: string;
-    /** Number of node instances added */
-    nodesAdded: number;
-    /** Number of connections added */
-    connectionsAdded: number;
-    /** Names of node types added (those not already in the target) */
-    nodeTypesAdded: string[];
-    /** Node type names that conflict (exist in both pattern and target) */
-    conflicts: string[];
-    /** Human-readable instructions for wiring IN/OUT ports */
-    wiringInstructions: string[];
-    /** Structured fw_modify_batch operations for wiring IN/OUT ports */
-    wiringOperations: Array<{
-        operation: 'addConnection';
-        params: {
-            from: string;
-            to: string;
-        };
-    }>;
-}
-/**
- * Parse a file and return metadata for all patterns found.
- *
- * Pure: reads file via AnnotationParser, returns structured data.
- */
-export declare function listPatterns(filePath: string): PatternInfo[];
-/**
- * Compute the result of applying a pattern to a workflow.
- *
- * Pure: takes AST + content + options, returns the modified content
- * and structured metadata (conflicts, wiring instructions, etc.).
- * Does **not** write to disk.
- */
-export declare function applyPattern(options: ApplyPatternOptions): ApplyPatternResult;
-/**
- * Generate a TypeScript stub for a node type.
- *
- * Produces a JSDoc-annotated function with the correct ports.
- */
-export declare function generateNodeTypeCode(nodeType: TNodeTypeAST): string;
-/**
- * Scan a directory for files containing @flowWeaver workflow annotations
- * and return structured metadata for each.
- *
- * Pure: reads files via AnnotationParser, returns structured data.
- * Skips files that fail to parse.
- */
-export declare function findWorkflows(directory: string, pattern?: string): Promise<WorkflowFileInfo[]>;
-/**
- * Extract a reusable pattern from selected nodes in a workflow.
- *
- * Pure: takes AST + node IDs, returns pattern code and metadata.
- * Does **not** write to disk.
- */
-export declare function extractPattern(options: ExtractPatternOptions): ExtractPatternResult;
-//# sourceMappingURL=patterns.d.ts.map

package/dist/api/patterns.js

@@ -1,303 +0,0 @@
-/**
- * Pure pattern API — no I/O, no console, no filesystem writes.
- *
- * Provides business logic for listing patterns, applying patterns to workflows,
- * and generating node type code. CLI and MCP layers call these functions
- * and handle their own I/O.
- */
-import { glob } from 'glob';
-import { AnnotationParser } from '../parser.js';
-// ─── List Patterns ───────────────────────────────────────────────────────────
-/**
- * Parse a file and return metadata for all patterns found.
- *
- * Pure: reads file via AnnotationParser, returns structured data.
- */
-export function listPatterns(filePath) {
-    const parser = new AnnotationParser();
-    const result = parser.parse(filePath);
-    return result.patterns.map((p) => ({
-        name: p.name,
-        description: p.description,
-        inputPorts: Object.keys(p.inputPorts).map((name) => ({
-            name: `IN.${name}`,
-            description: p.inputPorts[name].description,
-        })),
-        outputPorts: Object.keys(p.outputPorts).map((name) => ({
-            name: `OUT.${name}`,
-            description: p.outputPorts[name].description,
-        })),
-        nodes: p.instances.map((i) => i.id),
-    }));
-}
-// ─── Apply Pattern ───────────────────────────────────────────────────────────
-/**
- * Compute the result of applying a pattern to a workflow.
- *
- * Pure: takes AST + content + options, returns the modified content
- * and structured metadata (conflicts, wiring instructions, etc.).
- * Does **not** write to disk.
- */
-export function applyPattern(options) {
-    const { patternAST: pattern, targetContent, targetNodeTypes, prefix } = options;
-    const nodePrefix = prefix ? `${prefix}_` : '';
-    // ── Conflict detection ──────────────────────────────────────────────
-    const conflicts = [];
-    for (const nodeType of pattern.nodeTypes) {
-        if (targetNodeTypes.has(nodeType.name)) {
-            conflicts.push(nodeType.name);
-        }
-    }
-    // ── Build @node declarations (with inline [position:] when present) ──
-    const nodeDeclarations = pattern.instances.map((inst) => {
-        const posAttr = inst.config?.x !== undefined && inst.config?.y !== undefined
-            ? ` [position: ${inst.config.x} ${inst.config.y}]`
-            : '';
-        return ` * @node ${nodePrefix}${inst.id} ${inst.nodeType}${posAttr}`;
-    });
-    // ── Build @connect declarations + wiring instructions ───────────────
-    const connectDeclarations = [];
-    const wiringInstructions = [];
-    const wiringOperations = [];
-    for (const conn of pattern.connections) {
-        const fromNode = conn.from.node === 'IN' || conn.from.node === 'OUT'
-            ? conn.from.node
-            : `${nodePrefix}${conn.from.node}`;
-        const toNode = conn.to.node === 'IN' || conn.to.node === 'OUT'
-            ? conn.to.node
-            : `${nodePrefix}${conn.to.node}`;
-        if (conn.from.node === 'IN') {
-            wiringInstructions.push(`Connect to ${nodePrefix}${conn.to.node}.${conn.to.port} from IN.${conn.from.port}`);
-            wiringOperations.push({
-                operation: 'addConnection',
-                params: {
-                    from: `<WIRE_FROM>.${conn.from.port}`,
-                    to: `${nodePrefix}${conn.to.node}.${conn.to.port}`,
-                },
-            });
-        }
-        else if (conn.to.node === 'OUT') {
-            wiringInstructions.push(`Connect from ${nodePrefix}${conn.from.node}.${conn.from.port} to OUT.${conn.to.port}`);
-            wiringOperations.push({
-                operation: 'addConnection',
-                params: {
-                    from: `${nodePrefix}${conn.from.node}.${conn.from.port}`,
-                    to: `<WIRE_TO>.${conn.to.port}`,
-                },
-            });
-        }
-        else {
-            connectDeclarations.push(` * @connect ${fromNode}.${conn.from.port} -> ${toNode}.${conn.to.port}`);
-        }
-    }
-    // ── Generate node type functions (only non-conflicting) ─────────────
-    const nodeTypesAdded = [];
-    const nodeTypeFunctions = [];
-    for (const nodeType of pattern.nodeTypes) {
-        if (!targetNodeTypes.has(nodeType.name)) {
-            nodeTypesAdded.push(nodeType.name);
-            nodeTypeFunctions.push(generateNodeTypeCode(nodeType));
-        }
-    }
-    // ── Build annotation block ──────────────────────────────────────────
-    const annotationLines = [
-        `// --- Pattern: ${pattern.name} ${prefix ? `(prefix: ${prefix})` : ''} ---`,
-        ...nodeDeclarations,
-        ...connectDeclarations,
-    ];
-    // ── Insert into target content ──────────────────────────────────────
-    const workflowMatch = targetContent.match(/\/\*\*[\s\S]*?@flowWeaver\s+workflow[\s\S]*?\*\//);
-    if (!workflowMatch) {
-        throw new Error('No @flowWeaver workflow found in target file');
-    }
-    const insertPosition = workflowMatch.index + workflowMatch[0].lastIndexOf('*/');
-    const newAnnotations = annotationLines.join('\n') + '\n ';
-    let modifiedContent = targetContent.slice(0, insertPosition) + newAnnotations + targetContent.slice(insertPosition);
-    // Strip @autoConnect when pattern adds explicit connections — the explicit @connect
-    // annotations would conflict with autoConnect (parser skips auto-wiring when connections exist)
-    if (connectDeclarations.length > 0 && modifiedContent.match(/@autoConnect\b/)) {
-        modifiedContent = modifiedContent.replace(/^\s*\*\s*@autoConnect\s*\n/m, '');
-        wiringInstructions.push('Note: @autoConnect was removed because the pattern adds explicit connections');
-    }
-    // Append node type functions at end (if not conflicting)
-    if (nodeTypeFunctions.length > 0) {
-        modifiedContent += '\n\n' + nodeTypeFunctions.join('\n\n');
-    }
-    return {
-        modifiedContent,
-        nodesAdded: pattern.instances.length,
-        connectionsAdded: connectDeclarations.length,
-        nodeTypesAdded,
-        conflicts,
-        wiringInstructions,
-        wiringOperations,
-    };
-}
-// ─── Generate Node Type Code ─────────────────────────────────────────────────
-/**
- * Generate a TypeScript stub for a node type.
- *
- * Produces a JSDoc-annotated function with the correct ports.
- */
-export function generateNodeTypeCode(nodeType) {
-    // If original source text is available, use it directly
-    if (nodeType.functionText) {
-        return nodeType.functionText;
-    }
-    const lines = [];
-    lines.push('/**');
-    lines.push(' * @flowWeaver nodeType');
-    if (nodeType.label) {
-        lines.push(` * @label ${nodeType.label}`);
-    }
-    for (const [name, port] of Object.entries(nodeType.inputs)) {
-        if (name === 'execute')
-            continue;
-        lines.push(` * @input ${name}${port.label ? ` - ${port.label}` : ''}`);
-    }
-    for (const [name, port] of Object.entries(nodeType.outputs)) {
-        if (name === 'onSuccess' || name === 'onFailure')
-            continue;
-        lines.push(` * @output ${name}${port.label ? ` - ${port.label}` : ''}`);
-    }
-    lines.push(' */');
-    const inputParams = Object.entries(nodeType.inputs)
-        .filter(([name]) => name !== 'execute')
-        .map(([name, port]) => `${name}: ${port.tsType || 'any'}`);
-    const outputFields = Object.entries(nodeType.outputs)
-        .filter(([name]) => name !== 'onSuccess' && name !== 'onFailure')
-        .map(([name, port]) => `${name}: ${port.tsType || 'any'}`);
-    lines.push(`function ${nodeType.name}(execute: boolean${inputParams.length > 0 ? ', ' + inputParams.join(', ') : ''}) {`);
-    lines.push(`  if (!execute) return { onSuccess: false, onFailure: false${outputFields.map((f) => `, ${f.split(':')[0]}: null`).join('')} };`);
-    lines.push(`  return { onSuccess: true, onFailure: false${outputFields.map((f) => `, ${f.split(':')[0]}: null`).join('')} };`);
-    lines.push('}');
-    return lines.join('\n');
-}
-// ─── Find Workflows ──────────────────────────────────────────────────────────
-/**
- * Scan a directory for files containing @flowWeaver workflow annotations
- * and return structured metadata for each.
- *
- * Pure: reads files via AnnotationParser, returns structured data.
- * Skips files that fail to parse.
- */
-export async function findWorkflows(directory, pattern) {
-    const files = await glob(pattern ?? '**/*.ts', { cwd: directory, absolute: true });
-    const parser = new AnnotationParser();
-    const results = [];
-    for (const file of files) {
-        try {
-            const parseResult = parser.parse(file);
-            if (parseResult.workflows.length > 0) {
-                results.push({
-                    filePath: file,
-                    workflows: parseResult.workflows.map((w) => ({
-                        name: w.name,
-                        functionName: w.functionName,
-                        nodeCount: w.instances.length,
-                        connectionCount: w.connections.length,
-                    })),
-                });
-            }
-        }
-        catch {
-            // Skip files that fail to parse
-        }
-    }
-    return results;
-}
-// ─── Extract Pattern ─────────────────────────────────────────────────────────
-/**
- * Extract a reusable pattern from selected nodes in a workflow.
- *
- * Pure: takes AST + node IDs, returns pattern code and metadata.
- * Does **not** write to disk.
- */
-export function extractPattern(options) {
-    const { workflowAST: workflow, nodeTypes, nodeIds, name } = options;
-    // Validate nodes exist
-    const instanceMap = new Map(workflow.instances.map((i) => [i.id, i]));
-    const missingNodes = nodeIds.filter((id) => !instanceMap.has(id));
-    if (missingNodes.length > 0) {
-        throw new Error(`Nodes not found: ${missingNodes.join(', ')}`);
-    }
-    // Get instances to extract
-    const extractedInstances = nodeIds.map((id) => instanceMap.get(id));
-    // Classify connections: internal, input boundary (IN), output boundary (OUT)
-    const nodeIdSet = new Set(nodeIds);
-    const internalConnections = [];
-    const boundaryConnections = [];
-    for (const conn of workflow.connections) {
-        const fromInSet = nodeIdSet.has(conn.from.node);
-        const toInSet = nodeIdSet.has(conn.to.node);
-        if (fromInSet && toInSet) {
-            internalConnections.push(conn);
-        }
-        else if (fromInSet && !toInSet) {
-            boundaryConnections.push({ type: 'OUT', conn });
-        }
-        else if (!fromInSet && toInSet) {
-            boundaryConnections.push({ type: 'IN', conn });
-        }
-    }
-    // Generate pattern name
-    const patternName = name || `extracted_${nodeIds.join('_')}`;
-    // Collect node types used by extracted instances
-    const usedNodeTypeNames = new Set(extractedInstances.map((i) => i.nodeType));
-    const usedNodeTypes = nodeTypes.filter((nt) => usedNodeTypeNames.has(nt.name));
-    // Generate pattern code
-    const lines = [];
-    lines.push('/**');
-    lines.push(` * @flowWeaver pattern`);
-    lines.push(` * @name ${patternName}`);
-    // Node declarations (with inline [position:] when present)
-    for (const inst of extractedInstances) {
-        const posAttr = inst.config?.x !== undefined && inst.config?.y !== undefined
-            ? ` [position: ${inst.config.x} ${inst.config.y}]`
-            : '';
-        lines.push(` * @node ${inst.id} ${inst.nodeType}${posAttr}`);
-    }
-    // Internal connections
-    for (const conn of internalConnections) {
-        lines.push(` * @connect ${conn.from.node}.${conn.from.port} -> ${conn.to.node}.${conn.to.port}`);
-    }
-    // Boundary connections as IN/OUT
-    const inputPorts = [];
-    const outputPorts = [];
-    for (const { type, conn } of boundaryConnections) {
-        if (type === 'IN') {
-            const portName = conn.from.port;
-            inputPorts.push(portName);
-            lines.push(` * @connect IN.${portName} -> ${conn.to.node}.${conn.to.port}`);
-        }
-        else {
-            const portName = conn.to.port;
-            outputPorts.push(portName);
-            lines.push(` * @connect ${conn.from.node}.${conn.from.port} -> OUT.${portName}`);
-        }
-    }
-    // Port declarations
-    for (const port of [...new Set(inputPorts)]) {
-        lines.push(` * @port IN.${port}`);
-    }
-    for (const port of [...new Set(outputPorts)]) {
-        lines.push(` * @port OUT.${port}`);
-    }
-    lines.push(' */');
-    lines.push('function patternPlaceholder() {}');
-    // Add node type functions
-    for (const nodeType of usedNodeTypes) {
-        lines.push('');
-        lines.push(generateNodeTypeCode(nodeType));
-    }
-    const patternCode = lines.join('\n');
-    return {
-        patternCode,
-        patternName,
-        nodes: nodeIds,
-        inputPorts: [...new Set(inputPorts)],
-        outputPorts: [...new Set(outputPorts)],
-        internalConnectionCount: internalConnections.length,
-    };
-}
-//# sourceMappingURL=patterns.js.map