ueifu

app.py

@@ -1370,16 +1370,15 @@ def validate_parameters(parameters: List[Dict]) -> Dict:
     Validate parameters for duplicates, missing fields, and consistency.
     Returns a validation report with issues and suggestions.
     """
-    # Handle case where parameters might be None or not a list
     if not parameters or not isinstance(parameters, list):
         return {
-            "is_valid": False,
+            "is_valid": True,  # Changed to True for empty case
             "duplicate_parameters": [],
             "missing_required_fields": [],
             "empty_options": [],
             "invalid_types": [],
             "similar_parameters": [],
-            "suggestions": ["No valid parameters provided"]
+            "suggestions": []
         }
     
     validation_report = {
@@ -1398,94 +1397,123 @@ def validate_parameters(parameters: List[Dict]) -> Dict:
         if not isinstance(param, dict):
             continue
             
-        param_name = param.get("Parameter", "").strip()
-        param_lower = param_name.lower()
-        
-        if param_lower in seen_params:
+        param_name = param.get("Parameter", "").strip().lower()
+        if not param_name:
+            continue
+            
+        if param_name in seen_params:
             validation_report["duplicate_parameters"].append({
-                "parameter": param_name,
-                "indices": [seen_params[param_lower], i]
+                "parameter": param.get("Parameter", ""),
+                "indices": [seen_params[param_name], i]
             })
             validation_report["is_valid"] = False
         else:
-            seen_params[param_lower] = i
+            seen_params[param_name] = i
+    
+    # Check for similar parameters (same meaning)
+    from difflib import SequenceMatcher
+    param_names = [(i, p.get("Parameter", "")) for i, p in enumerate(parameters) if isinstance(p, dict) and p.get("Parameter", "").strip()]
+    
+    for i, (idx1, name1) in enumerate(param_names):
+        for j, (idx2, name2) in enumerate(param_names[i+1:], i+1):
+            similarity = SequenceMatcher(None, name1.lower(), name2.lower()).ratio()
+            if similarity > 0.8:  # Very similar
+                validation_report["similar_parameters"].append({
+                    "param1": name1,
+                    "param2": name2,
+                    "similarity": round(similarity, 2),
+                    "indices": [idx1, idx2]
+                })
+                validation_report["suggestions"].append(
+                    f"'{name1}' and '{name2}' seem very similar - consider merging them"
+                )
+    
+    # Validate parameter types
+    valid_types = ["Checklist", "Dropdown", "Image Upload", "Remarks", "Text Input", "Numeric Input", "Toggle"]
+    
+    for i, param in enumerate(parameters):
+        if not isinstance(param, dict):
+            continue
+            
+        param_name = param.get("Parameter", "")
+        param_type = param.get("Type", "")
+        
+        # Check required fields
+        if not param_name.strip():
+            validation_report["missing_required_fields"].append({
+                "index": i,
+                "field": "Parameter name"
+            })
+            validation_report["is_valid"] = False
+        
+        # Check valid type
+        if param_type not in valid_types:
+            validation_report["invalid_types"].append({
+                "parameter": param_name,
+                "invalid_type": param_type,
+                "suggested_type": "Text Input"
+            })
+            validation_report["is_valid"] = False
+        
+        # Check options for Dropdown/Checklist
+        if param_type in ["Dropdown", "Checklist"]:
+            options = param.get("DropdownOptions", "").strip()
+            if not options:
+                validation_report["empty_options"].append({
+                    "parameter": param_name,
+                    "type": param_type
+                })
+                validation_report["suggestions"].append(
+                    f"'{param_name}' is a {param_type} but has no options defined"
+                )
     
     return validation_report
 
 def deduplicate_parameters(parameters: List[Dict]) -> List[Dict]:
-    """
-    Remove duplicate parameters intelligently.
-    Merges similar parameters and keeps the most complete version.
-    """
-    from difflib import SequenceMatcher
+    """Remove exact duplicates and merge very similar parameters"""
+    if not parameters or not isinstance(parameters, list):
+        return []
     
-    # First pass: Remove exact duplicates
+    # Remove exact duplicates first
     seen = {}
-    deduped = []
+    unique_params = []
     
     for param in parameters:
-        param_key = param.get("Parameter", "").lower().strip()
-        
+        if not isinstance(param, dict):
+            continue
+            
+        param_key = param.get("Parameter", "").strip().lower()
+        if not param_key:
+            continue
+            
         if param_key not in seen:
             seen[param_key] = param
-            deduped.append(param)
+            unique_params.append(param)
         else:
             # Merge information from duplicate
             existing = seen[param_key]
             
-            # Merge options if applicable
-            if param.get("Type") in ["Dropdown", "Checklist"]:
+            # Keep the more detailed spec
+            if not existing.get("Spec", "") and param.get("Spec", ""):
+                existing["Spec"] = param.get("Spec", "")
+            
+            # Merge options for dropdowns/checklists
+            if existing.get("Type") in ["Dropdown", "Checklist"]:
                 existing_options = existing.get("DropdownOptions", "")
                 new_options = param.get("DropdownOptions", "")
                 
                 if existing_options and new_options:
-                    # Merge unique options
                     existing_list = [opt.strip() for opt in existing_options.split(",")]
                     new_list = [opt.strip() for opt in new_options.split(",")]
                     
+                    # Add unique new options
                     for opt in new_list:
-                        if opt not in existing_list:
+                        if opt and opt not in existing_list:
                             existing_list.append(opt)
                     
                     existing["DropdownOptions"] = ", ".join(existing_list)
-            
-            # Keep the more detailed spec
-            if not existing.get("Spec") and param.get("Spec"):
-                existing["Spec"] = param.get("Spec")
-    
-    # Second pass: Merge similar parameters
-    final_params = []
-    processed = set()
     
-    for i, param in enumerate(deduped):
-        if i in processed:
-            continue
-            
-        param_name = param.get("Parameter", "")
-        merged = False
-        
-        # Check against remaining parameters
-        for j in range(i + 1, len(deduped)):
-            if j in processed:
-                continue
-                
-            other_name = deduped[j].get("Parameter", "")
-            similarity = SequenceMatcher(None, param_name.lower(), other_name.lower()).ratio()
-            
-            if similarity > 0.85:  # High similarity threshold
-                # Merge parameters
-                merged_param = merge_similar_parameters(param, deduped[j])
-                final_params.append(merged_param)
-                processed.add(i)
-                processed.add(j)
-                merged = True
-                break
-        
-        if not merged:
-            final_params.append(param)
-            processed.add(i)
-    
-    return final_params
+    return unique_params
 
 def merge_similar_parameters(param1: Dict, param2: Dict) -> Dict:
     """
@@ -1621,14 +1649,12 @@ def suggest_missing_parameters(parameters: List[Dict], product_name: str) -> Lis
 
 # REPLACE THIS ENTIRE FUNCTION
 def apply_intelligent_fixes(parameters: List[Dict]) -> List[Dict]:
-    """
-    Apply intelligent fixes to common parameter issues.
-    """
-    # Fix the bool iteration error
+    """Apply intelligent fixes to parameter issues"""
     if not parameters or not isinstance(parameters, list):
         return []
     
     fixed_params = []
+    valid_types = ["Checklist", "Dropdown", "Image Upload", "Remarks", "Text Input", "Numeric Input", "Toggle"]
     
     for param in parameters:
         if not isinstance(param, dict):
@@ -1638,34 +1664,30 @@ def apply_intelligent_fixes(parameters: List[Dict]) -> List[Dict]:
         
         # Fix empty parameter names
         if not fixed_param.get("Parameter", "").strip():
-            fixed_param["Parameter"] = f"{fixed_param.get('Type', 'Unknown')} Parameter"
+            fixed_param["Parameter"] = f"Parameter {len(fixed_params) + 1}"
         
         # Fix invalid types
-        valid_types = ["Checklist", "Dropdown", "Image Upload", "Remarks", "Text Input", "Numeric Input", "Toggle"]
         if fixed_param.get("Type", "") not in valid_types:
-            # Try to infer type from name
             param_name_lower = fixed_param.get("Parameter", "").lower()
             
-            if any(word in param_name_lower for word in ["remark", "comment", "note"]):
+            if any(word in param_name_lower for word in ["remark", "comment", "note", "observation"]):
                 fixed_param["Type"] = "Remarks"
-            elif any(word in param_name_lower for word in ["photo", "image", "picture"]):
+            elif any(word in param_name_lower for word in ["photo", "image", "picture", "visual"]):
                 fixed_param["Type"] = "Image Upload"
-            elif any(word in param_name_lower for word in ["weight", "dimension", "temperature", "time"]):
+            elif any(word in param_name_lower for word in ["weight", "temperature", "dimension", "size", "measurement"]):
                 fixed_param["Type"] = "Numeric Input"
+            elif any(word in param_name_lower for word in ["acceptable", "pass", "fail", "yes", "no"]):
+                fixed_param["Type"] = "Toggle"
             elif fixed_param.get("DropdownOptions", ""):
-                # Has options, likely dropdown or checklist
                 options = fixed_param.get("DropdownOptions", "").split(",")
-                if len(options) > 4:
-                    fixed_param["Type"] = "Checklist"
-                else:
-                    fixed_param["Type"] = "Dropdown"
+                fixed_param["Type"] = "Checklist" if len(options) > 4 else "Dropdown"
             else:
                 fixed_param["Type"] = "Text Input"
         
         # Add default options for empty dropdowns/checklists
         if fixed_param["Type"] in ["Dropdown", "Checklist"] and not fixed_param.get("DropdownOptions", "").strip():
             if fixed_param["Type"] == "Dropdown":
-                fixed_param["DropdownOptions"] = "Option 1, Option 2, Option 3"
+                fixed_param["DropdownOptions"] = "Acceptable, Marginal, Not Acceptable"
             else:
                 fixed_param["DropdownOptions"] = "Item 1, Item 2, Item 3, Item 4"
         
@@ -1673,6 +1695,14 @@ def apply_intelligent_fixes(parameters: List[Dict]) -> List[Dict]:
         if not fixed_param.get("Section", "").strip():
             fixed_param["Section"] = "General"
         
+        # Set default values for missing fields
+        if not fixed_param.get("Spec"):
+            fixed_param["Spec"] = ""
+        if not fixed_param.get("IncludeRemarks"):
+            fixed_param["IncludeRemarks"] = "No"
+        if not fixed_param.get("ClauseReference"):
+            fixed_param["ClauseReference"] = ""
+        
         fixed_params.append(fixed_param)
     
     return fixed_params
@@ -2020,11 +2050,29 @@ def refine_parameters():
         updated_params = apply_intelligent_fixes(updated_params)
     
     # Validate parameters
-        # Skip validation for now - just organize and store
+        # Validate and fix parameters
+        validation_report = validate_parameters(updated_params)
+        
+        if not validation_report["is_valid"]:
+            print("⚠️ Validation issues found, applying fixes...")
+            
+            # Remove duplicates
+            if validation_report["duplicate_parameters"]:
+                updated_params = deduplicate_parameters(updated_params)
+                print(f"✅ Removed {len(validation_report['duplicate_parameters'])} duplicate parameters")
+            
+            # Fix invalid types and missing fields
+            if validation_report["invalid_types"] or validation_report["missing_required_fields"]:
+                updated_params = apply_intelligent_fixes(updated_params)
+                print("✅ Fixed parameter issues")
+                
+            # Re-validate after fixes
+            validation_report = validate_parameters(updated_params)
+        
+        suggestions = validation_report.get("suggestions", [])
         global_parameters = updated_params
-        suggestions = []
 
-        print(f"✅ Generated {len(updated_params)} parameters")
+        print(f"✅ Generated {len(updated_params)} validated parameters")
         
         print(f"✅ Generated {len(updated_params)} parameters as requested")
         
@@ -2366,12 +2414,45 @@ def edit_parameters():
         print(llm_response[:500] + "..." if len(llm_response) > 500 else llm_response)
         print("=" * 50)
 
+        
         # Parse response
         summary_text, changes_list = parse_llm_changes(llm_response)
         
-        # For edit operations, we need to handle the response differently
-        # The LLM should return the complete parameter list with modifications
-        updated_params = []
+        # Apply changes and validate for duplicates
+        if isinstance(changes_list, list):
+            updated_params = []
+            
+            # If we got a complete list, use it
+            if changes_list and all(change.get("Parameter") for change in changes_list):
+                for change in changes_list:
+                    param_type = change.get("Type", "Text Input")
+                    if param_type not in ["Checklist", "Dropdown", "Image Upload", "Remarks", "Text Input", "Numeric Input", "Toggle"]:
+                        param_type = "Text Input"
+                    
+                    updated_params.append({
+                        "Parameter": change.get("Parameter", ""),
+                        "Type": param_type,
+                        "Spec": change.get("Spec", ""),
+                        "DropdownOptions": change.get("DropdownOptions", "") or change.get("ChecklistOptions", ""),
+                        "IncludeRemarks": change.get("IncludeRemarks", "No"),
+                        "Section": change.get("Section", "General"),
+                        "ClauseReference": change.get("ClauseReference", "")
+                    })
+            else:
+                # Fallback to applying changes to existing parameters
+                updated_params = apply_changes_to_params(existing_parameters.copy(), changes_list)
+        else:
+            print(f"⚠️ Warning: changes_list is not a list: {type(changes_list)}")
+            updated_params = existing_parameters.copy()
+        
+        # Validate for duplicates and similar parameters in edits
+        validation_report = validate_parameters(updated_params)
+        
+        if validation_report["duplicate_parameters"] or validation_report["similar_parameters"]:
+            print("⚠️ Found duplicates/similar parameters in edit, cleaning up...")
+            updated_params = deduplicate_parameters(updated_params)
+            updated_params = apply_intelligent_fixes(updated_params)
+            print("✅ Cleaned up duplicate parameters")
         
         # If we got a complete list, use it
         if changes_list and all(change.get("Parameter") for change in changes_list):