agentic-qe 2.6.5 → 2.7.0

package/dist/code-intelligence/analysis/mincut/GraphAdapter.js

@@ -0,0 +1,335 @@
+"use strict";
+/**
+ * Graph Adapter for MinCut Analysis
+ *
+ * Converts CodeGraph format to MinCut input format, enabling
+ * minimum cut analysis on code dependency graphs for identifying
+ * optimal module boundaries and coupling reduction points.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphAdapter = void 0;
+/**
+ * Edge type to weight mapping for coupling analysis.
+ * Higher weights indicate stronger coupling between components.
+ */
+const EDGE_TYPE_WEIGHTS = {
+    extends: 1.0, // Strongest - inheritance creates tight coupling
+    implements: 0.9, // Very strong - interface implementation
+    imports: 0.8, // Strong - direct dependency
+    calls: 0.6, // Moderate - function calls
+    uses: 0.5, // Moderate - type usage
+    contains: 0.3, // Weak - parent-child containment
+    exports: 0.5, // Moderate - export relationship
+    returns: 0.4, // Weak - return type dependency
+    parameter: 0.4, // Weak - parameter type dependency
+    overrides: 0.8, // Strong - method override
+    defines: 0.3, // Weak - definition relationship
+    tests: 0.2, // Very weak - test relationship
+};
+/**
+ * GraphAdapter converts CodeGraph to MinCut input format
+ *
+ * @example
+ * ```typescript
+ * const graphBuilder = new GraphBuilder();
+ * // ... build graph ...
+ *
+ * const adapter = GraphAdapter.toMinCutFormat(graphBuilder.exportGraph(), {
+ *   nodeFilter: (node) => node.type === 'file',
+ *   normalizeWeights: true
+ * });
+ *
+ * const analyzer = new MinCutAnalyzer();
+ * const result = await analyzer.computeMinCut(adapter);
+ * ```
+ */
+class GraphAdapter {
+    /**
+     * Convert CodeGraph to MinCut input format.
+     *
+     * @param graph - The code graph to convert (from GraphBuilder.exportGraph())
+     * @param options - Conversion options
+     * @returns MinCut-compatible graph format
+     *
+     * @example
+     * ```typescript
+     * const minCutInput = GraphAdapter.toMinCutFormat(graph, {
+     *   nodeFilter: (node) => node.type === 'file' || node.type === 'class',
+     *   normalizeWeights: true,
+     *   directed: false
+     * });
+     * ```
+     */
+    static toMinCutFormat(graph, options = {}) {
+        const { nodeFilter = () => true, edgeFilter = () => true, directed = false, normalizeWeights = false, } = options;
+        // Handle empty graph
+        if (!graph.nodes || graph.nodes.length === 0) {
+            return { nodes: [], edges: [], directed };
+        }
+        // Filter and convert nodes
+        const filteredNodes = graph.nodes.filter(nodeFilter);
+        const nodeIdSet = new Set(filteredNodes.map(n => n.id));
+        const minCutNodes = filteredNodes.map(node => ({
+            id: node.id,
+            label: node.label,
+            properties: {
+                type: node.type,
+                filePath: node.filePath,
+                startLine: node.startLine,
+                endLine: node.endLine,
+                language: node.language,
+                ...node.properties,
+            },
+        }));
+        // Handle graph with no edges
+        if (!graph.edges || graph.edges.length === 0) {
+            return { nodes: minCutNodes, edges: [], directed };
+        }
+        // Filter and convert edges
+        const edgeMap = new Map();
+        for (const edge of graph.edges) {
+            // Skip if edge doesn't pass filter
+            if (!edgeFilter(edge))
+                continue;
+            // Skip self-loops
+            if (edge.source === edge.target)
+                continue;
+            // Skip edges referencing non-existent nodes (after filtering)
+            if (!nodeIdSet.has(edge.source) || !nodeIdSet.has(edge.target)) {
+                continue;
+            }
+            // Calculate weight
+            let weight = edge.weight;
+            if (normalizeWeights) {
+                weight = this.normalizeWeight(edge);
+            }
+            // Create edge key for duplicate detection
+            const edgeKey = directed
+                ? `${edge.source}->${edge.target}`
+                : [edge.source, edge.target].sort().join('<->');
+            // Keep edge with highest weight for duplicates
+            const existing = edgeMap.get(edgeKey);
+            if (!existing || weight > existing.weight) {
+                edgeMap.set(edgeKey, {
+                    source: edge.source,
+                    target: edge.target,
+                    weight,
+                    edgeType: edge.type,
+                });
+            }
+        }
+        const minCutEdges = Array.from(edgeMap.values());
+        return {
+            nodes: minCutNodes,
+            edges: minCutEdges,
+            directed,
+        };
+    }
+    /**
+     * Normalize edge weight based on edge type.
+     *
+     * Different edge types represent different coupling strengths:
+     * - extends: 1.0 (strongest - inheritance)
+     * - implements: 0.9
+     * - imports: 0.8
+     * - calls: 0.6
+     * - uses: 0.5
+     * - contains: 0.3 (weakest)
+     *
+     * @param edge - The edge to normalize
+     * @returns Normalized weight (0.0 - 1.0)
+     *
+     * @example
+     * ```typescript
+     * const edge = { type: 'extends', weight: 2.5, ... };
+     * const normalized = GraphAdapter.normalizeWeight(edge);
+     * // normalized = 1.0 (extends has highest coupling)
+     * ```
+     */
+    static normalizeWeight(edge) {
+        const baseWeight = this.getEdgeTypeWeight(edge.type);
+        // Combine type-based weight with original edge weight
+        // Original weight acts as a multiplier (capped at 2.0)
+        const multiplier = Math.min(edge.weight, 2.0);
+        return baseWeight * multiplier;
+    }
+    /**
+     * Get coupling weight for an edge type.
+     *
+     * @param edgeType - The type of edge
+     * @returns Weight between 0.0 and 1.0
+     *
+     * @example
+     * ```typescript
+     * const weight = GraphAdapter.getEdgeTypeWeight('extends'); // 1.0
+     * const weight2 = GraphAdapter.getEdgeTypeWeight('uses'); // 0.5
+     * ```
+     */
+    static getEdgeTypeWeight(edgeType) {
+        return EDGE_TYPE_WEIGHTS[edgeType] ?? 0.5;
+    }
+    /**
+     * Extract a subgraph containing only specified files.
+     *
+     * Useful for analyzing coupling between specific modules or components.
+     * Only includes nodes and edges where both endpoints are in the specified files.
+     *
+     * @param graph - The full code graph
+     * @param filePaths - List of file paths to include
+     * @returns Subgraph containing only specified files
+     *
+     * @example
+     * ```typescript
+     * const subgraph = GraphAdapter.extractFileSubgraph(graph, [
+     *   '/src/auth/login.ts',
+     *   '/src/auth/register.ts'
+     * ]);
+     * // Analyze coupling within auth module
+     * const minCutInput = GraphAdapter.toMinCutFormat(subgraph);
+     * ```
+     */
+    static extractFileSubgraph(graph, filePaths) {
+        if (!graph.nodes || graph.nodes.length === 0) {
+            return { nodes: [], edges: [] };
+        }
+        const filePathSet = new Set(filePaths);
+        // Filter nodes to only those in specified files
+        const filteredNodes = graph.nodes.filter(node => filePathSet.has(node.filePath));
+        const nodeIdSet = new Set(filteredNodes.map(n => n.id));
+        // Filter edges to only those connecting nodes in the subgraph
+        const filteredEdges = (graph.edges || []).filter(edge => nodeIdSet.has(edge.source) && nodeIdSet.has(edge.target));
+        return {
+            nodes: filteredNodes,
+            edges: filteredEdges,
+        };
+    }
+    /**
+     * Create a file-level dependency graph from a detailed code graph.
+     *
+     * Aggregates all relationships between files, useful for module-level analysis.
+     *
+     * @param graph - The detailed code graph
+     * @returns File-level graph with aggregated edges
+     *
+     * @example
+     * ```typescript
+     * const fileGraph = GraphAdapter.aggregateByFile(detailedGraph);
+     * const minCutInput = GraphAdapter.toMinCutFormat(fileGraph, {
+     *   normalizeWeights: true
+     * });
+     * // Analyze optimal module splits at file level
+     * ```
+     */
+    static aggregateByFile(graph) {
+        if (!graph.nodes || graph.nodes.length === 0) {
+            return { nodes: [], edges: [] };
+        }
+        // Create one node per file
+        const fileNodeMap = new Map();
+        for (const node of graph.nodes) {
+            if (!fileNodeMap.has(node.filePath)) {
+                fileNodeMap.set(node.filePath, {
+                    id: `file:${node.filePath}`,
+                    type: 'file',
+                    label: node.filePath.split('/').pop() || node.filePath,
+                    filePath: node.filePath,
+                    startLine: 0,
+                    endLine: 0,
+                    language: node.language,
+                    properties: {},
+                });
+            }
+        }
+        // Aggregate edges by file-to-file relationships
+        const fileEdgeMap = new Map();
+        for (const edge of graph.edges || []) {
+            const sourceNode = graph.nodes.find(n => n.id === edge.source);
+            const targetNode = graph.nodes.find(n => n.id === edge.target);
+            if (!sourceNode || !targetNode)
+                continue;
+            // Skip same-file edges
+            if (sourceNode.filePath === targetNode.filePath)
+                continue;
+            const edgeKey = `${sourceNode.filePath}->${targetNode.filePath}`;
+            const existing = fileEdgeMap.get(edgeKey);
+            if (existing) {
+                existing.weight += edge.weight;
+                existing.types.add(edge.type);
+            }
+            else {
+                fileEdgeMap.set(edgeKey, {
+                    weight: edge.weight,
+                    types: new Set([edge.type]),
+                });
+            }
+        }
+        // Convert aggregated edges
+        const fileEdges = [];
+        let edgeId = 0;
+        for (const [key, data] of fileEdgeMap) {
+            const [sourceFile, targetFile] = key.split('->');
+            const sourceId = `file:${sourceFile}`;
+            const targetId = `file:${targetFile}`;
+            fileEdges.push({
+                id: `edge_${edgeId++}`,
+                source: sourceId,
+                target: targetId,
+                type: Array.from(data.types)[0], // Use first type for aggregated edge
+                weight: data.weight,
+                properties: {
+                    aggregatedTypes: Array.from(data.types),
+                    aggregatedWeight: data.weight,
+                },
+            });
+        }
+        return {
+            nodes: Array.from(fileNodeMap.values()),
+            edges: fileEdges,
+        };
+    }
+    /**
+     * Validate that a graph is suitable for MinCut analysis.
+     *
+     * @param graph - Graph to validate
+     * @returns Validation result with error messages
+     *
+     * @example
+     * ```typescript
+     * const validation = GraphAdapter.validateGraph(graph);
+     * if (!validation.valid) {
+     *   console.error('Invalid graph:', validation.errors);
+     * }
+     * ```
+     */
+    static validateGraph(graph) {
+        const errors = [];
+        if (!graph.nodes || graph.nodes.length === 0) {
+            errors.push('Graph has no nodes');
+        }
+        if (graph.nodes && graph.nodes.length === 1) {
+            errors.push('Graph must have at least 2 nodes for MinCut analysis');
+        }
+        // Check for disconnected graph
+        if (graph.edges && graph.edges.length === 0 && graph.nodes && graph.nodes.length > 1) {
+            errors.push('Graph has no edges (completely disconnected)');
+        }
+        // Validate edge references
+        if (graph.edges && graph.nodes) {
+            const nodeIds = new Set(graph.nodes.map(n => n.id));
+            for (const edge of graph.edges) {
+                if (!nodeIds.has(edge.source)) {
+                    errors.push(`Edge references non-existent source node: ${edge.source}`);
+                }
+                if (!nodeIds.has(edge.target)) {
+                    errors.push(`Edge references non-existent target node: ${edge.target}`);
+                }
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+}
+exports.GraphAdapter = GraphAdapter;
+//# sourceMappingURL=GraphAdapter.js.map

package/dist/code-intelligence/analysis/mincut/GraphAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphAdapter.js","sourceRoot":"","sources":["../../../../src/code-intelligence/analysis/mincut/GraphAdapter.ts"],"names":[],"mappings":"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"}

package/dist/code-intelligence/analysis/mincut/JsMinCut.d.ts

@@ -0,0 +1,55 @@
+import { MinCutResult, MinCutGraphInput } from './types.js';
+/**
+ * Pure JavaScript implementation of the Stoer-Wagner minimum cut algorithm.
+ *
+ * Time Complexity: O(V³) or O(VE log V) with priority queue optimization
+ * Space Complexity: O(V²)
+ *
+ * Reference: Stoer, M., & Wagner, F. (1997). A simple min-cut algorithm.
+ * Journal of the ACM, 44(4), 585-591.
+ */
+export declare class JsMinCut {
+    /**
+     * Compute the minimum cut of an undirected weighted graph using Stoer-Wagner algorithm
+     *
+     * @param input - Graph input with nodes and edges
+     * @param normalizeWeights - Whether to normalize edge weights to [0, 1]
+     * @returns MinCutResult with the minimum cut value and partitions
+     */
+    computeMinCut(input: MinCutGraphInput, normalizeWeights?: boolean): MinCutResult;
+    /**
+     * Build internal graph representation from input
+     */
+    private buildGraph;
+    /**
+     * Stoer-Wagner minimum cut algorithm
+     *
+     * The algorithm works by repeatedly finding a minimum s-t cut and
+     * merging the nodes s and t, until only one node remains.
+     */
+    private stoerWagner;
+    /**
+     * Minimum cut phase: finds the minimum s-t cut using maximum adjacency search
+     *
+     * This is essentially a modified Prim's algorithm that grows a set A by
+     * always adding the most tightly connected vertex.
+     */
+    private minimumCutPhase;
+    /**
+     * Merge two nodes by combining their adjacency lists
+     */
+    private mergeNodes;
+    /**
+     * Find edges that cross the partition
+     */
+    private findCutEdges;
+    /**
+     * Handle empty graph
+     */
+    private emptyResult;
+    /**
+     * Handle single-node graph
+     */
+    private singleNodeResult;
+}
+//# sourceMappingURL=JsMinCut.d.ts.map

package/dist/code-intelligence/analysis/mincut/JsMinCut.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsMinCut.d.ts","sourceRoot":"","sources":["../../../../src/code-intelligence/analysis/mincut/JsMinCut.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAiC,MAAM,YAAY,CAAC;AAK3F;;;;;;;;GAQG;AACH,qBAAa,QAAQ;IACnB;;;;;;OAMG;IACI,aAAa,CAAC,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,UAAO,GAAG,YAAY;IAgCpF;;OAEG;IACH,OAAO,CAAC,UAAU;IAsClB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IA+DnB;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IAiEvB;;OAEG;IACH,OAAO,CAAC,UAAU;IAqClB;;OAEG;IACH,OAAO,CAAC,YAAY;IAyBpB;;OAEG;IACH,OAAO,CAAC,WAAW;IAWnB;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAUzB"}

package/dist/code-intelligence/analysis/mincut/JsMinCut.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsMinCut = void 0;
+const Logger_js_1 = require("../../../utils/Logger.js");
+const logger = Logger_js_1.Logger.getInstance();
+/**
+ * Pure JavaScript implementation of the Stoer-Wagner minimum cut algorithm.
+ *
+ * Time Complexity: O(V³) or O(VE log V) with priority queue optimization
+ * Space Complexity: O(V²)
+ *
+ * Reference: Stoer, M., & Wagner, F. (1997). A simple min-cut algorithm.
+ * Journal of the ACM, 44(4), 585-591.
+ */
+class JsMinCut {
+    /**
+     * Compute the minimum cut of an undirected weighted graph using Stoer-Wagner algorithm
+     *
+     * @param input - Graph input with nodes and edges
+     * @param normalizeWeights - Whether to normalize edge weights to [0, 1]
+     * @returns MinCutResult with the minimum cut value and partitions
+     */
+    computeMinCut(input, normalizeWeights = true) {
+        const startTime = performance.now();
+        // Convert to internal graph representation
+        const graph = this.buildGraph(input, normalizeWeights);
+        if (graph.nodeCount === 0) {
+            return this.emptyResult(startTime);
+        }
+        if (graph.nodeCount === 1) {
+            return this.singleNodeResult(graph, startTime);
+        }
+        // Run Stoer-Wagner algorithm
+        const { minCut, partition1, partition2 } = this.stoerWagner(graph);
+        // Find cut edges
+        const cutEdges = this.findCutEdges(input, partition1, partition2);
+        const computationTimeMs = performance.now() - startTime;
+        return {
+            cutValue: minCut,
+            partition1: Array.from(partition1),
+            partition2: Array.from(partition2),
+            cutEdges,
+            algorithmUsed: 'stoer-wagner',
+            computationTimeMs,
+        };
+    }
+    /**
+     * Build internal graph representation from input
+     */
+    buildGraph(input, normalizeWeights) {
+        const adjacency = new Map();
+        const nodeSet = new Set();
+        // Initialize adjacency lists
+        for (const node of input.nodes) {
+            nodeSet.add(node.id);
+            adjacency.set(node.id, new Map());
+        }
+        // Find max weight for normalization
+        let maxWeight = 1;
+        if (normalizeWeights) {
+            maxWeight = Math.max(...input.edges.map(e => e.weight), 1);
+        }
+        // Add edges (treat directed as undirected)
+        for (const edge of input.edges) {
+            const weight = normalizeWeights ? edge.weight / maxWeight : edge.weight;
+            // Add edge in both directions for undirected graph
+            const sourceAdj = adjacency.get(edge.source);
+            const targetAdj = adjacency.get(edge.target);
+            if (sourceAdj && targetAdj) {
+                // Sum weights if multiple edges exist
+                sourceAdj.set(edge.target, (sourceAdj.get(edge.target) || 0) + weight);
+                targetAdj.set(edge.source, (targetAdj.get(edge.source) || 0) + weight);
+            }
+        }
+        return {
+            adjacency,
+            nodes: Array.from(nodeSet),
+            nodeCount: nodeSet.size,
+        };
+    }
+    /**
+     * Stoer-Wagner minimum cut algorithm
+     *
+     * The algorithm works by repeatedly finding a minimum s-t cut and
+     * merging the nodes s and t, until only one node remains.
+     */
+    stoerWagner(graph) {
+        // Track which original nodes belong to each contracted node
+        const nodeGroups = new Map();
+        for (const node of graph.nodes) {
+            nodeGroups.set(node, new Set([node]));
+        }
+        // Working copy of adjacency list
+        const workingAdj = new Map();
+        for (const [node, neighbors] of Array.from(graph.adjacency.entries())) {
+            workingAdj.set(node, new Map(Array.from(neighbors.entries())));
+        }
+        let activeNodes = new Set(graph.nodes);
+        let minCutValue = Infinity;
+        let bestPartition1 = new Set();
+        let bestPartition2 = new Set();
+        // Continue until only one node remains
+        while (activeNodes.size > 1) {
+            // Find minimum s-t cut of current graph
+            const phase = this.minimumCutPhase(workingAdj, activeNodes);
+            // Update global minimum if this phase found a better cut
+            if (phase.cutValue < minCutValue) {
+                minCutValue = phase.cutValue;
+                // The partition is: {merged node} vs {everything else}
+                const mergedGroup = nodeGroups.get(phase.mergedNode);
+                bestPartition1 = new Set(mergedGroup);
+                bestPartition2 = new Set();
+                const activeNodeArray = Array.from(activeNodes);
+                for (const node of activeNodeArray) {
+                    if (node !== phase.mergedNode) {
+                        const group = nodeGroups.get(node);
+                        const groupArray = Array.from(group);
+                        groupArray.forEach(n => bestPartition2.add(n));
+                    }
+                }
+            }
+            // Merge the two nodes (contract edge)
+            this.mergeNodes(workingAdj, activeNodes, nodeGroups, phase.mergedNode, phase.targetNode);
+        }
+        return {
+            minCut: minCutValue,
+            partition1: bestPartition1,
+            partition2: bestPartition2,
+        };
+    }
+    /**
+     * Minimum cut phase: finds the minimum s-t cut using maximum adjacency search
+     *
+     * This is essentially a modified Prim's algorithm that grows a set A by
+     * always adding the most tightly connected vertex.
+     */
+    minimumCutPhase(adjacency, activeNodes) {
+        const nodes = Array.from(activeNodes);
+        // Start with an arbitrary node
+        const startNode = nodes[0];
+        const inA = new Set([startNode]);
+        // Track the most recently added node and the one before it
+        let previousNode = startNode;
+        let lastNode = startNode;
+        // Weights from A to each vertex not in A
+        const weights = new Map();
+        // Initialize weights from start node
+        const startAdj = adjacency.get(startNode);
+        for (const node of nodes) {
+            if (node !== startNode) {
+                weights.set(node, startAdj.get(node) || 0);
+            }
+        }
+        // Grow A by adding most tightly connected vertices
+        while (inA.size < nodes.length) {
+            // Find vertex with maximum weight to A
+            let maxWeight = -Infinity;
+            let maxNode = '';
+            const weightsArray = Array.from(weights.entries());
+            for (const [node, weight] of weightsArray) {
+                if (!inA.has(node) && weight > maxWeight) {
+                    maxWeight = weight;
+                    maxNode = node;
+                }
+            }
+            // Add most tightly connected vertex to A
+            inA.add(maxNode);
+            previousNode = lastNode;
+            lastNode = maxNode;
+            // Update weights: for each neighbor of maxNode, add edge weight
+            const maxNodeAdj = adjacency.get(maxNode);
+            const maxNodeAdjArray = Array.from(maxNodeAdj.entries());
+            for (const [neighbor, edgeWeight] of maxNodeAdjArray) {
+                if (!inA.has(neighbor)) {
+                    weights.set(neighbor, (weights.get(neighbor) || 0) + edgeWeight);
+                }
+            }
+        }
+        // The cut-of-the-phase is the cut that separates the last added vertex
+        // from the rest. Its value is the total weight from lastNode to A.
+        const cutValue = weights.get(lastNode) || 0;
+        return {
+            cutValue,
+            mergedNode: lastNode,
+            targetNode: previousNode,
+        };
+    }
+    /**
+     * Merge two nodes by combining their adjacency lists
+     */
+    mergeNodes(adjacency, activeNodes, nodeGroups, mergedNode, targetNode) {
+        const mergedAdj = adjacency.get(mergedNode);
+        const targetAdj = adjacency.get(targetNode);
+        // Add all edges from mergedNode to targetNode
+        const mergedAdjArray = Array.from(mergedAdj.entries());
+        for (const [neighbor, weight] of mergedAdjArray) {
+            if (neighbor === targetNode)
+                continue; // Skip self-loop
+            // Add weight to existing edge or create new edge
+            const currentWeight = targetAdj.get(neighbor) || 0;
+            targetAdj.set(neighbor, currentWeight + weight);
+            // Update reverse edge
+            const neighborAdj = adjacency.get(neighbor);
+            neighborAdj.delete(mergedNode);
+            neighborAdj.set(targetNode, (neighborAdj.get(targetNode) || 0) + weight);
+        }
+        // Merge node groups
+        const mergedGroup = nodeGroups.get(mergedNode);
+        const targetGroup = nodeGroups.get(targetNode);
+        const mergedGroupArray = Array.from(mergedGroup);
+        mergedGroupArray.forEach(node => targetGroup.add(node));
+        // Remove merged node
+        adjacency.delete(mergedNode);
+        activeNodes.delete(mergedNode);
+        targetAdj.delete(mergedNode);
+    }
+    /**
+     * Find edges that cross the partition
+     */
+    findCutEdges(input, partition1, partition2) {
+        const cutEdges = [];
+        for (const edge of input.edges) {
+            const sourceIn1 = partition1.has(edge.source);
+            const targetIn1 = partition1.has(edge.target);
+            // Edge crosses the cut if endpoints are in different partitions
+            if (sourceIn1 !== targetIn1) {
+                cutEdges.push({
+                    source: edge.source,
+                    target: edge.target,
+                    weight: edge.weight,
+                    edgeType: edge.edgeType,
+                });
+            }
+        }
+        return cutEdges;
+    }
+    /**
+     * Handle empty graph
+     */
+    emptyResult(startTime) {
+        return {
+            cutValue: 0,
+            partition1: [],
+            partition2: [],
+            cutEdges: [],
+            algorithmUsed: 'stoer-wagner',
+            computationTimeMs: performance.now() - startTime,
+        };
+    }
+    /**
+     * Handle single-node graph
+     */
+    singleNodeResult(graph, startTime) {
+        return {
+            cutValue: 0,
+            partition1: [graph.nodes[0]],
+            partition2: [],
+            cutEdges: [],
+            algorithmUsed: 'stoer-wagner',
+            computationTimeMs: performance.now() - startTime,
+        };
+    }
+}
+exports.JsMinCut = JsMinCut;
+//# sourceMappingURL=JsMinCut.js.map