Merge branch 'fe-edge' into fe-rag

Author: yilinxia

backend/app/main.py

@@ -518,13 +518,15 @@ def create_edges_on_graph():
             "common_stargazers_enabled": true,
             "stargazer_threshold": 5,
             "use_and_logic": false
-        }
+        },
+        "filtered_node_ids": ["node1", "node2", ...] // Optional: only consider these nodes for edge creation
     }
     """
     try:
         data = request.get_json()
         gexf_content = data.get("gexfContent", "")
         criteria_config = data.get("criteria_config", {})
+        filtered_node_ids = data.get("filtered_node_ids", None)  # Get filtered node IDs
 
         if not gexf_content:
             return jsonify({
@@ -574,7 +576,7 @@ def create_edges_on_graph():
         edge_service = EdgeGenerationService()
 
         # Create edges based on the criteria
-        edges_created = edge_service.create_edges_on_existing_graph(G, criteria_config)
+        edges_created = edge_service.create_edges_on_existing_graph(G, criteria_config, filtered_node_ids)
 
         # Save the updated graph
         import hashlib

backend/app/services/edge_generation_service.py

@@ -116,13 +116,14 @@ def generate_edges_with_criteria(
 
         return G, edge_stats
 
-    def create_edges_on_existing_graph(self, G: nx.Graph, criteria_config: Dict[str, any]) -> Dict[str, any]:
+    def create_edges_on_existing_graph(self, G: nx.Graph, criteria_config: Dict[str, any], filtered_node_ids: List[str] = None) -> Dict[str, any]:
         """
         Create edges on an existing graph based on specified criteria.
         
         Args:
             G: Existing NetworkX graph with nodes
             criteria_config: Configuration for edge generation criteria
+            filtered_node_ids: Optional list of node IDs to consider for edge creation (only these nodes will be used)
             
         Returns:
             Dictionary with statistics about created edges
@@ -152,10 +153,27 @@ def create_edges_on_existing_graph(self, G: nx.Graph, criteria_config: Dict[str,
         # Remove all existing edges first
         G.remove_edges_from(list(G.edges()))
 
-        # Get all nodes
-        nodes = list(G.nodes())
-        if len(nodes) < 2:
-            return {'message': 'Not enough nodes to create edges'}
+        # Use filtered nodes if provided, otherwise use all nodes
+        if filtered_node_ids is not None:
+            # Validate that all filtered node IDs exist in the graph
+            existing_nodes = set(G.nodes())
+            valid_filtered_nodes = [node_id for node_id in filtered_node_ids if node_id in existing_nodes]
+            
+            if len(valid_filtered_nodes) < 2:
+                return {
+                    'message': f'Not enough valid filtered nodes to create edges. Found {len(valid_filtered_nodes)} valid nodes out of {len(filtered_node_ids)} provided.',
+                    'total_edges': 0,
+                    'total_nodes': len(valid_filtered_nodes)
+                }
+            
+            nodes = valid_filtered_nodes
+            print(f"Using {len(nodes)} filtered nodes for edge creation out of {len(existing_nodes)} total nodes")
+        else:
+            # Use all nodes if no filtering is applied
+            nodes = list(G.nodes())
+            if len(nodes) < 2:
+                return {'message': 'Not enough nodes to create edges'}
+            print(f"Using all {len(nodes)} nodes for edge creation")
 
         # Generate edges based on enabled criteria
         edge_stats = {}

src/views/EdgePanel.tsx

@@ -213,15 +213,19 @@ const EdgePanel: FC<{ isExpanded: boolean }> = ({ isExpanded }) => {
                 use_and_logic: enabledCriteria > 1 // Use AND logic if multiple criteria enabled
             };
 
-            // Call backend API with original graph
+            // Get filtered node IDs to pass to backend
+            const filteredNodeIds = computedData?.filteredNodes ? Array.from(computedData.filteredNodes) : null;
+
+            // Call backend API with original graph and filtered nodes
             const response = await fetch('http://127.0.0.1:5002/api/create-edges-on-graph', {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
                 },
                 body: JSON.stringify({
                     gexfContent: originalGexfContent,
-                    criteria_config: criteriaConfig
+                    criteria_config: criteriaConfig,
+                    filtered_node_ids: filteredNodeIds
                 })
             });
 
@@ -315,8 +319,18 @@ const EdgePanel: FC<{ isExpanded: boolean }> = ({ isExpanded }) => {
 
                         // Notify user of success
                         const edgesCreated = result.edgesCreated?.total_edges || 0;
+                        const nodeCount = computedData?.filteredNodes ? computedData.filteredNodes.size : data?.graph?.order || 0;
+                        const totalNodes = data?.graph?.order || 0;
+
+                        let successMessage = `Successfully created ${edgesCreated} edges`;
+                        if (computedData?.filteredNodes && computedData.filteredNodes.size < totalNodes) {
+                            successMessage += ` using ${nodeCount} filtered nodes (out of ${totalNodes} total)`;
+                        } else {
+                            successMessage += ` from original graph`;
+                        }
+
                         notify({
-                            message: `Successfully created ${edgesCreated} edges from original graph`,
+                            message: successMessage,
                             type: "success"
                         });
 
@@ -399,7 +413,18 @@ const EdgePanel: FC<{ isExpanded: boolean }> = ({ isExpanded }) => {
                         </h1>
 
                         <div className="mb-3">
-                            <h3 className="form-label fs-6 mb-3">Configure how edges are automatically created between repositories based on various criteria</h3>
+                            <h3 className="form-label fs-6 mb-3">
+                                Configure how edges are automatically created between repositories based on various criteria
+                                {computedData?.filteredNodes && (
+                                    <>
+                                        <br />
+                                        <br />
+                                        <span className="text-white">
+                                            Note: Edge creation will only consider currently visible nodes. Hidden/filtered nodes will not participate in edge creation.
+                                        </span>
+                                    </>
+                                )}
+                            </h3>
                         </div>
 
                         {/* Topic Based Linking */}
@@ -549,13 +574,6 @@ const EdgePanel: FC<{ isExpanded: boolean }> = ({ isExpanded }) => {
 
                         {/* Apply Button */}
                         <div className="mb-3">
-                            {computedData?.filteredNodes && (
-                                <div className="alert alert-info small mb-3">
-                                    <strong>Note:</strong> Edge creation will only consider currently visible nodes ({computedData.filteredNodes.size} of {data?.graph?.order || 0} total).
-                                    Hidden/filtered nodes will not participate in edge creation.
-                                </div>
-                            )}
-
                             {/* Warning when no criteria are selected */}
                             {!enableTopicLinking && !enableSharedOrganization && !enableContributorOverlap && !enableCommonStargazers && (
                                 <div className="alert alert-info small mb-3">