@ema.co/mcp-toolkit 2026.2.23 → 2026.2.27

package/dist/mcp/domain/workflow-optimizer.js

@@ -1,671 +0,0 @@
-/**
- * @deprecated Use `workflow-graph-optimizer.ts` instead.
- *
- * This file contains the legacy heuristic-based optimizer (health scores,
- * recommendations, scoring). It is superseded by the deterministic graph
- * optimizer which provides:
- *   - Shared typed graph (`workflow-graph.ts`)
- *   - Provably safe auto-fix transforms (`workflow-graph-transforms.ts`)
- *   - Convergence-based orchestrator (`workflow-graph-optimizer.ts`)
- *
- * Remaining consumer: `test/intelligence-layer.test.ts` (legacy tests).
- * Remove this file once that test is migrated or deleted.
- */
-// ─────────────────────────────────────────────────────────────────────────────
-// Main Entry Point
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Analyze workflow for optimization opportunities
- */
-export function analyzeOptimizations(workflow) {
-    const actions = workflow.actions || [];
-    const graph = buildDependencyGraph(actions);
-    const metrics = calculateMetrics(actions, graph);
-    const optimizations = [];
-    // 1. Find consolidation opportunities (duplicate/redundant nodes)
-    optimizations.push(...findConsolidationOpportunities(actions, graph));
-    // 2. Find parallelization opportunities
-    optimizations.push(...findParallelizationOpportunities(actions, graph));
-    // 3. Find passthrough nodes to eliminate
-    optimizations.push(...findPassthroughNodes(actions, graph));
-    // 4. Find error handling gaps
-    optimizations.push(...findErrorHandlingGaps(actions, graph));
-    // 5. Find LLM call optimizations
-    optimizations.push(...findLlmOptimizations(actions, graph));
-    // 6. Find search optimizations
-    optimizations.push(...findSearchOptimizations(actions, graph));
-    // 7. Find naming improvements
-    optimizations.push(...findNamingImprovements(actions));
-    // 8. Find safety improvements (HITL for side effects)
-    optimizations.push(...findSafetyImprovements(actions, graph));
-    // Calculate health score
-    const healthScore = calculateWorkflowHealth(actions, metrics, optimizations);
-    // Categorize optimizations
-    const quickWins = optimizations.filter(o => o.auto_applicable && o.risk === "none" && o.severity !== "suggestion");
-    const strategic = optimizations.filter(o => !o.auto_applicable || o.risk !== "none");
-    // Generate recommendations
-    const recommendations = generateRecommendations(optimizations, metrics, healthScore);
-    return {
-        workflow_health_score: healthScore,
-        grade: healthScoreToGrade(healthScore),
-        optimizations,
-        quick_wins: quickWins,
-        strategic,
-        metrics,
-        recommendations,
-    };
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Graph Building
-// ─────────────────────────────────────────────────────────────────────────────
-function buildDependencyGraph(actions) {
-    const nodes = new Map();
-    const edges = new Map();
-    const reverseEdges = new Map();
-    // Initialize nodes
-    for (const action of actions) {
-        const actionType = action.action?.name?.name || "unknown";
-        nodes.set(action.name, {
-            id: action.name,
-            type: actionType,
-            depth: 0,
-            inputs: [],
-            outputs: [],
-        });
-        edges.set(action.name, new Set());
-        reverseEdges.set(action.name, new Set());
-    }
-    // Build edges from input bindings
-    for (const action of actions) {
-        const node = nodes.get(action.name);
-        if (action.inputs) {
-            for (const [inputName, binding] of Object.entries(action.inputs)) {
-                const bindingObj = binding;
-                const actionOutput = bindingObj?.actionOutput;
-                if (actionOutput?.actionName) {
-                    const sourceNode = String(actionOutput.actionName);
-                    node.inputs.push(sourceNode);
-                    // Source → Target edge
-                    edges.get(sourceNode)?.add(action.name);
-                    reverseEdges.get(action.name)?.add(sourceNode);
-                    // Update source node outputs
-                    const sourceGraphNode = nodes.get(sourceNode);
-                    if (sourceGraphNode) {
-                        sourceGraphNode.outputs.push(action.name);
-                    }
-                }
-            }
-        }
-    }
-    // Calculate depths (BFS from trigger)
-    const trigger = actions.find(a => a.action?.name?.name?.includes("trigger"));
-    if (trigger) {
-        const visited = new Set();
-        const queue = [{ node: trigger.name, depth: 0 }];
-        while (queue.length > 0) {
-            const { node, depth } = queue.shift();
-            if (visited.has(node))
-                continue;
-            visited.add(node);
-            const graphNode = nodes.get(node);
-            if (graphNode) {
-                graphNode.depth = depth;
-            }
-            for (const child of edges.get(node) || []) {
-                if (!visited.has(child)) {
-                    queue.push({ node: child, depth: depth + 1 });
-                }
-            }
-        }
-    }
-    return { nodes, edges, reverseEdges };
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Metrics Calculation
-// ─────────────────────────────────────────────────────────────────────────────
-function calculateMetrics(actions, graph) {
-    // Count node types
-    const nodeTypes = {};
-    for (const action of actions) {
-        const type = action.action?.name?.name || "unknown";
-        nodeTypes[type] = (nodeTypes[type] || 0) + 1;
-    }
-    // Calculate max depth
-    const maxDepth = Math.max(...Array.from(graph.nodes.values()).map(n => n.depth), 0);
-    // Count branches (nodes with multiple outputs)
-    const branchCount = Array.from(graph.nodes.values()).filter(n => n.outputs.length > 1).length;
-    // Count parallel opportunities (nodes at same depth that could run together)
-    const nodesByDepth = new Map();
-    for (const [id, node] of graph.nodes) {
-        const nodes = nodesByDepth.get(node.depth) || [];
-        nodes.push(id);
-        nodesByDepth.set(node.depth, nodes);
-    }
-    const parallelOpportunities = Array.from(nodesByDepth.values())
-        .filter(nodes => nodes.length > 1).length;
-    // Calculate redundancy score
-    const redundancyScore = calculateRedundancyScore(actions, graph);
-    // Calculate complexity score
-    const complexityScore = calculateComplexityScore(actions, graph, maxDepth, branchCount);
-    // Count sequential latency factors (LLM + search calls on critical path)
-    const latencyFactors = countLatencyFactors(actions, graph);
-    return {
-        total_nodes: actions.length,
-        node_types: nodeTypes,
-        max_depth: maxDepth,
-        branch_count: branchCount,
-        parallel_opportunities: parallelOpportunities,
-        redundancy_score: redundancyScore,
-        complexity_score: complexityScore,
-        estimated_latency_factors: latencyFactors,
-    };
-}
-function calculateRedundancyScore(actions, graph) {
-    let redundancy = 0;
-    // Check for duplicate node types with same inputs
-    const nodeSignatures = new Map();
-    for (const action of actions) {
-        const type = action.action?.name?.name || "unknown";
-        const node = graph.nodes.get(action.name);
-        const signature = `${type}:${node?.inputs.sort().join(",")}`;
-        const existing = nodeSignatures.get(signature) || [];
-        existing.push(action.name);
-        nodeSignatures.set(signature, existing);
-    }
-    // Each duplicate adds to redundancy
-    for (const [_, nodes] of nodeSignatures) {
-        if (nodes.length > 1) {
-            redundancy += (nodes.length - 1) * 10;
-        }
-    }
-    return Math.min(redundancy, 100);
-}
-function calculateComplexityScore(actions, graph, maxDepth, branchCount) {
-    // Base complexity from node count
-    let complexity = Math.min(actions.length * 5, 30);
-    // Add complexity for depth
-    complexity += Math.min(maxDepth * 5, 20);
-    // Add complexity for branching
-    complexity += Math.min(branchCount * 10, 30);
-    // Add complexity for conditional logic
-    const conditionalNodes = actions.filter(a => a.runIf).length;
-    complexity += Math.min(conditionalNodes * 5, 20);
-    return Math.min(complexity, 100);
-}
-function countLatencyFactors(actions, graph) {
-    // Count LLM and search nodes on the longest path
-    const latencyNodes = actions.filter(a => {
-        const type = a.action?.name?.name || "";
-        return type.includes("llm") ||
-            type.includes("respond") ||
-            type.includes("search") ||
-            type.includes("categorizer");
-    });
-    // Find the longest sequential chain of latency nodes
-    let maxSequential = 0;
-    for (const node of latencyNodes) {
-        let count = 1;
-        let current = node.name;
-        // Follow the dependency chain
-        while (true) {
-            const graphNode = graph.nodes.get(current);
-            if (!graphNode || graphNode.outputs.length === 0)
-                break;
-            // Find a latency node in outputs
-            const nextLatency = graphNode.outputs.find(out => latencyNodes.some(ln => ln.name === out));
-            if (!nextLatency)
-                break;
-            count++;
-            current = nextLatency;
-        }
-        maxSequential = Math.max(maxSequential, count);
-    }
-    return maxSequential;
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Optimization Finders
-// ─────────────────────────────────────────────────────────────────────────────
-function findConsolidationOpportunities(actions, graph) {
-    const opportunities = [];
-    // Find duplicate search nodes with same query source
-    const searchNodes = actions.filter(a => a.action?.name?.name?.includes("search") &&
-        !a.action?.name?.name?.includes("combine"));
-    const searchByQuery = new Map();
-    for (const search of searchNodes) {
-        const querySource = getQuerySource(search);
-        const existing = searchByQuery.get(querySource) || [];
-        existing.push(search);
-        searchByQuery.set(querySource, existing);
-    }
-    for (const [query, duplicates] of searchByQuery) {
-        if (duplicates.length > 1) {
-            opportunities.push({
-                id: `consolidate-search-${hashString(query)}`,
-                type: "consolidate_nodes",
-                severity: "recommended",
-                title: "Consolidate Redundant Searches",
-                current_state: `${duplicates.length} search nodes using same query source: "${query}"`,
-                proposed_change: "Consolidate into single search node, share results via named_inputs",
-                benefit: `Reduce API calls by ${duplicates.length - 1}x, faster execution, consistent results`,
-                risk: "low",
-                auto_applicable: false, // Requires careful rewiring
-                affected_nodes: duplicates.map(d => d.name),
-                implementation_hint: "Keep one search, remove others, use named_inputs to pass results to all consumers",
-            });
-        }
-    }
-    // Find duplicate LLM calls with similar prompts
-    const llmNodes = actions.filter(a => a.action?.name?.name?.includes("llm") ||
-        a.action?.name?.name?.includes("respond"));
-    if (llmNodes.length > 2) {
-        // Check for sequential LLM calls
-        for (const node of llmNodes) {
-            const graphNode = graph.nodes.get(node.name);
-            if (graphNode) {
-                const llmChildren = graphNode.outputs.filter(out => llmNodes.some(ln => ln.name === out));
-                if (llmChildren.length > 0) {
-                    opportunities.push({
-                        id: `merge-llm-${node.name}`,
-                        type: "merge_llm_calls",
-                        severity: "suggestion",
-                        title: "Consider Merging Sequential LLM Calls",
-                        current_state: `${node.name} feeds into LLM node(s): ${llmChildren.join(", ")}`,
-                        proposed_change: "Merge into single comprehensive LLM call with structured prompt",
-                        benefit: "Reduce latency, potentially lower cost, more coherent output",
-                        risk: "medium",
-                        auto_applicable: false,
-                        affected_nodes: [node.name, ...llmChildren],
-                        implementation_hint: "Combine prompts, use structured output format, single call_llm with all context",
-                    });
-                }
-            }
-        }
-    }
-    return opportunities;
-}
-function findParallelizationOpportunities(actions, graph) {
-    const opportunities = [];
-    // Find nodes at same depth that share a parent but are sequential
-    const nodesByParent = new Map();
-    for (const [nodeId, graphNode] of graph.nodes) {
-        for (const input of graphNode.inputs) {
-            const siblings = nodesByParent.get(input) || [];
-            siblings.push(nodeId);
-            nodesByParent.set(input, siblings);
-        }
-    }
-    // Check for sequential siblings that could be parallel
-    for (const [parent, children] of nodesByParent) {
-        if (children.length > 1) {
-            // Check if they're actually sequential (one depends on another)
-            const sequential = children.filter(child => {
-                const node = graph.nodes.get(child);
-                return node && children.some(other => other !== child && node.inputs.includes(other));
-            });
-            if (sequential.length > 0 && sequential.length < children.length) {
-                opportunities.push({
-                    id: `parallelize-${parent}`,
-                    type: "parallelize_paths",
-                    severity: "suggestion",
-                    title: "Parallelization Opportunity",
-                    current_state: `Children of ${parent} could potentially run in parallel`,
-                    proposed_change: "Restructure so independent operations branch from same source",
-                    benefit: "Reduced latency through parallel execution",
-                    risk: "low",
-                    auto_applicable: false,
-                    affected_nodes: [parent, ...children],
-                });
-            }
-        }
-    }
-    return opportunities;
-}
-function findPassthroughNodes(actions, graph) {
-    const opportunities = [];
-    // Find nodes that just pass data through without transformation
-    for (const action of actions) {
-        const graphNode = graph.nodes.get(action.name);
-        if (!graphNode)
-            continue;
-        // Skip trigger and output nodes
-        const type = action.action?.name?.name || "";
-        if (type.includes("trigger") || graphNode.outputs.length === 0)
-            continue;
-        // Check if this node has single input and single output with no transformation
-        if (graphNode.inputs.length === 1 && graphNode.outputs.length === 1) {
-            // Check if it's a simple passthrough (no significant configuration)
-            const inputCount = Object.keys(action.inputs || {}).length;
-            const hasTransformation = type.includes("llm") ||
-                type.includes("search") ||
-                type.includes("categorizer") ||
-                type.includes("extract");
-            if (!hasTransformation && inputCount <= 2) {
-                opportunities.push({
-                    id: `eliminate-passthrough-${action.name}`,
-                    type: "eliminate_passthrough",
-                    severity: "suggestion",
-                    title: "Potential Passthrough Node",
-                    current_state: `${action.name} appears to pass data without significant transformation`,
-                    proposed_change: "Consider removing and connecting predecessor directly to successor",
-                    benefit: "Simpler workflow, reduced complexity",
-                    risk: "low",
-                    auto_applicable: false,
-                    affected_nodes: [action.name],
-                });
-            }
-        }
-    }
-    return opportunities;
-}
-function findErrorHandlingGaps(actions, graph) {
-    const opportunities = [];
-    // Check for external action callers without error handling
-    const externalCallers = actions.filter(a => a.action?.name?.name?.includes("external") ||
-        a.action?.name?.name?.includes("email") ||
-        a.action?.name?.name?.includes("tool"));
-    for (const caller of externalCallers) {
-        // Check if there's error handling downstream
-        const graphNode = graph.nodes.get(caller.name);
-        const hasErrorPath = graphNode?.outputs.some(out => {
-            const action = actions.find(a => a.name === out);
-            return action?.runIf && JSON.stringify(action.runIf).includes("error");
-        });
-        if (!hasErrorPath) {
-            opportunities.push({
-                id: `add-error-handling-${caller.name}`,
-                type: "add_error_handling",
-                severity: "recommended",
-                title: "Add Error Handling",
-                current_state: `External action ${caller.name} has no error handling path`,
-                proposed_change: "Add conditional path for handling failures gracefully",
-                benefit: "Better user experience when external services fail",
-                risk: "none",
-                auto_applicable: false,
-                affected_nodes: [caller.name],
-                implementation_hint: "Add runIf condition checking for error status, route to fallback response",
-            });
-        }
-    }
-    return opportunities;
-}
-function findLlmOptimizations(actions, graph) {
-    const opportunities = [];
-    const llmNodes = actions.filter(a => a.action?.name?.name?.includes("llm") ||
-        a.action?.name?.name?.includes("respond"));
-    // Check for call_llm being used instead of respond_with_sources for search results
-    for (const node of llmNodes) {
-        const type = node.action?.name?.name || "";
-        const graphNode = graph.nodes.get(node.name);
-        if (type === "call_llm" && graphNode) {
-            // Check if input comes from search
-            const hasSearchInput = graphNode.inputs.some(input => {
-                const inputAction = actions.find(a => a.name === input);
-                return inputAction?.action?.name?.name?.includes("search");
-            });
-            if (hasSearchInput) {
-                opportunities.push({
-                    id: `use-respond-with-sources-${node.name}`,
-                    type: "improve_response_quality",
-                    severity: "recommended",
-                    title: "Use Purpose-Built Response Node",
-                    current_state: `${node.name} uses call_llm for search-based responses`,
-                    proposed_change: "Replace with respond_with_sources for better citation handling",
-                    benefit: "Better citations, grounded responses, less configuration needed",
-                    risk: "low",
-                    auto_applicable: false,
-                    affected_nodes: [node.name],
-                });
-            }
-        }
-    }
-    return opportunities;
-}
-function findSearchOptimizations(actions, graph) {
-    const opportunities = [];
-    // Check for web search without KB search
-    const hasKbSearch = actions.some(a => a.action?.name?.name === "search" ||
-        a.action?.name?.name?.includes("file_search"));
-    const hasWebSearch = actions.some(a => a.action?.name?.name?.includes("web_search") ||
-        a.action?.name?.name?.includes("live_web"));
-    if (hasWebSearch && !hasKbSearch) {
-        opportunities.push({
-            id: "add-kb-search",
-            type: "optimize_search",
-            severity: "recommended",
-            title: "Add Knowledge Base Search",
-            current_state: "Workflow uses web search but no internal KB search",
-            proposed_change: "Add KB search as primary source, use web search as supplement",
-            benefit: "Faster responses, more controlled content, reduced external dependencies",
-            risk: "none",
-            auto_applicable: false,
-            affected_nodes: actions.filter(a => a.action?.name?.name?.includes("web")).map(a => a.name),
-        });
-    }
-    return opportunities;
-}
-function findNamingImprovements(actions) {
-    const opportunities = [];
-    // Check for generic names
-    const genericPatterns = [
-        /^node_\d+$/i,
-        /^action_\d+$/i,
-        /^step_\d+$/i,
-        /^untitled/i,
-        /^new_/i,
-    ];
-    const poorlyNamed = actions.filter(a => genericPatterns.some(p => p.test(a.name)) ||
-        genericPatterns.some(p => p.test(a.actionDisplayName || "")));
-    if (poorlyNamed.length > 0) {
-        opportunities.push({
-            id: "improve-naming",
-            type: "improve_naming",
-            severity: "suggestion",
-            title: "Improve Node Naming",
-            current_state: `${poorlyNamed.length} nodes have generic names: ${poorlyNamed.map(n => n.name).join(", ")}`,
-            proposed_change: "Use descriptive names that indicate purpose (e.g., 'search_customer_faq', 'respond_billing_inquiry')",
-            benefit: "Better maintainability, easier debugging, clearer workflow understanding",
-            risk: "none",
-            auto_applicable: false,
-            affected_nodes: poorlyNamed.map(n => n.name),
-        });
-    }
-    return opportunities;
-}
-function findSafetyImprovements(actions, graph) {
-    const opportunities = [];
-    // Check for external actions without HITL
-    const sideEffectNodes = actions.filter(a => {
-        const type = a.action?.name?.name || "";
-        return type.includes("email") ||
-            type.includes("external") ||
-            type.includes("create_") ||
-            type.includes("update_") ||
-            type.includes("delete_");
-    });
-    const hitlNodes = actions.filter(a => a.action?.name?.name?.includes("hitl"));
-    for (const sideEffect of sideEffectNodes) {
-        const graphNode = graph.nodes.get(sideEffect.name);
-        if (!graphNode)
-            continue;
-        // Check if there's a HITL node upstream
-        const hasUpstreamHitl = graphNode.inputs.some(input => hitlNodes.some(h => h.name === input));
-        if (!hasUpstreamHitl) {
-            opportunities.push({
-                id: `add-hitl-${sideEffect.name}`,
-                type: "add_hitl_for_safety",
-                severity: "important",
-                title: "Add Human Approval Before Side Effect",
-                current_state: `${sideEffect.name} can execute without human confirmation`,
-                proposed_change: "Add HITL node before this action to confirm before execution",
-                benefit: "Prevent unintended external actions, maintain human oversight",
-                risk: "none",
-                auto_applicable: false,
-                affected_nodes: [sideEffect.name],
-                implementation_hint: "Insert general_hitl between the previous node and this action, add both success and failure paths",
-            });
-        }
-    }
-    return opportunities;
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Health Score Calculation
-// ─────────────────────────────────────────────────────────────────────────────
-function calculateWorkflowHealth(actions, metrics, optimizations) {
-    let score = 100;
-    // Deduct for optimizations based on severity
-    for (const opt of optimizations) {
-        switch (opt.severity) {
-            case "important":
-                score -= 15;
-                break;
-            case "recommended":
-                score -= 8;
-                break;
-            case "suggestion":
-                score -= 3;
-                break;
-        }
-    }
-    // Deduct for high complexity
-    if (metrics.complexity_score > 70) {
-        score -= 10;
-    }
-    else if (metrics.complexity_score > 50) {
-        score -= 5;
-    }
-    // Deduct for high redundancy
-    if (metrics.redundancy_score > 30) {
-        score -= 10;
-    }
-    else if (metrics.redundancy_score > 10) {
-        score -= 5;
-    }
-    // Deduct for many sequential latency factors
-    if (metrics.estimated_latency_factors > 5) {
-        score -= 10;
-    }
-    else if (metrics.estimated_latency_factors > 3) {
-        score -= 5;
-    }
-    // Bonus for good practices
-    const hasTrigger = actions.some(a => a.action?.name?.name?.includes("trigger"));
-    const hasResponse = actions.some(a => a.action?.name?.name?.includes("respond") ||
-        a.action?.name?.name?.includes("llm"));
-    if (hasTrigger && hasResponse) {
-        score = Math.min(score + 5, 100);
-    }
-    return Math.max(score, 0);
-}
-function healthScoreToGrade(score) {
-    if (score >= 90)
-        return "A";
-    if (score >= 80)
-        return "B";
-    if (score >= 70)
-        return "C";
-    if (score >= 60)
-        return "D";
-    return "F";
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Recommendations Generator
-// ─────────────────────────────────────────────────────────────────────────────
-function generateRecommendations(optimizations, metrics, healthScore) {
-    const recommendations = [];
-    // Top priority optimizations
-    const important = optimizations.filter(o => o.severity === "important");
-    if (important.length > 0) {
-        recommendations.push(`🔴 Address ${important.length} important issue(s): ${important.map(o => o.title).join(", ")}`);
-    }
-    // Quick wins
-    const quickWins = optimizations.filter(o => o.auto_applicable && o.risk === "none");
-    if (quickWins.length > 0) {
-        recommendations.push(`✅ ${quickWins.length} quick win(s) available for immediate improvement`);
-    }
-    // Complexity warning
-    if (metrics.complexity_score > 60) {
-        recommendations.push(`⚠️ High complexity (${metrics.complexity_score}/100). Consider simplifying or breaking into sub-workflows.`);
-    }
-    // Latency warning
-    if (metrics.estimated_latency_factors > 4) {
-        recommendations.push(`⏱️ High latency risk: ${metrics.estimated_latency_factors} sequential LLM/search calls. Consider parallelization.`);
-    }
-    // Redundancy warning
-    if (metrics.redundancy_score > 20) {
-        recommendations.push(`🔄 Redundancy detected (${metrics.redundancy_score}/100). Consider consolidating duplicate operations.`);
-    }
-    // Overall assessment
-    if (healthScore >= 90) {
-        recommendations.push("🌟 Excellent workflow health! Minor optimizations optional.");
-    }
-    else if (healthScore >= 70) {
-        recommendations.push("👍 Good workflow health. Apply recommended optimizations for best results.");
-    }
-    else if (healthScore >= 50) {
-        recommendations.push("⚠️ Workflow needs attention. Apply important fixes first.");
-    }
-    else {
-        recommendations.push("🚨 Workflow needs significant improvements. Review all recommendations.");
-    }
-    return recommendations;
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Utilities
-// ─────────────────────────────────────────────────────────────────────────────
-function getQuerySource(action) {
-    const queryInput = action.inputs?.query;
-    const actionOutput = queryInput?.actionOutput;
-    if (actionOutput) {
-        return `${actionOutput.actionName}.${actionOutput.output}`;
-    }
-    return "unknown";
-}
-function hashString(str) {
-    let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-        const char = str.charCodeAt(i);
-        hash = ((hash << 5) - hash) + char;
-        hash = hash & hash;
-    }
-    return Math.abs(hash).toString(36).substring(0, 8);
-}
-/**
- * Get a human-readable summary of the optimization report
- */
-export function summarizeOptimizationReport(report) {
-    const lines = [];
-    lines.push(`## Workflow Health Report`);
-    lines.push("");
-    lines.push(`**Health Score**: ${report.workflow_health_score}/100 (Grade: ${report.grade})`);
-    lines.push("");
-    lines.push("### Metrics");
-    lines.push(`- Nodes: ${report.metrics.total_nodes}`);
-    lines.push(`- Max Depth: ${report.metrics.max_depth}`);
-    lines.push(`- Branches: ${report.metrics.branch_count}`);
-    lines.push(`- Complexity: ${report.metrics.complexity_score}/100`);
-    lines.push(`- Redundancy: ${report.metrics.redundancy_score}/100`);
-    lines.push(`- Latency Factors: ${report.metrics.estimated_latency_factors}`);
-    lines.push("");
-    if (report.quick_wins.length > 0) {
-        lines.push("### Quick Wins");
-        for (const opt of report.quick_wins) {
-            lines.push(`- **${opt.title}**: ${opt.proposed_change}`);
-        }
-        lines.push("");
-    }
-    if (report.strategic.length > 0) {
-        lines.push("### Strategic Improvements");
-        for (const opt of report.strategic) {
-            const severity = opt.severity === "important" ? "🔴" :
-                opt.severity === "recommended" ? "🟡" : "🟢";
-            lines.push(`${severity} **${opt.title}**: ${opt.current_state}`);
-            lines.push(`   → ${opt.proposed_change}`);
-        }
-        lines.push("");
-    }
-    lines.push("### Recommendations");
-    for (const rec of report.recommendations) {
-        lines.push(`- ${rec}`);
-    }
-    return lines.join("\n");
-}