Simplify UI design - minimal clean interface

- Removed all emojis and decorative elements
- Shortened titles and labels
- Removed verbose debug messages
- Simplified tab names
- Removed unnecessary markdown headers
- Reduced text sizes and spacing
- Cleaned up buttons and inputs
- Removed example sections
- Minimalistic debug tab

src/streamlit_app.py

@@ -18,23 +18,12 @@ st.set_page_config(
     layout="wide"
 )
 
-# Debug: Show Streamlit version and environment info
-with st.sidebar:
-    st.info(f"🐍 Python {sys.version}")
-    st.info(f"📦 Streamlit {st.__version__}")
-
-# Import our modules
-try:
-    from structure_analysis import (
-        detect_summary_fields,
-        classify_data_structure,
-        get_hierarchy_summary
-    )
-    st.success("✅ Successfully imported structure_analysis module")
-except ImportError as e:
-    st.error(f"⚠️ Import error: {e}")
-    st.error("⚠️ structure_analysis.py not found. Make sure all files are uploaded.")
-    st.stop()
+# Import modules silently
+from structure_analysis import (
+    detect_summary_fields,
+    classify_data_structure,
+    get_hierarchy_summary
+)
 
 # Session state
 if 'analysis_result' not in st.session_state:
@@ -174,13 +163,12 @@ def generate_regex_patterns(field_names: list, data_sample: dict, summary_sample
 
 def main():
     """Main application."""
-    st.title("🤖 Field Correlation Analyzer")
-    st.markdown("Upload a JSON file to analyze important fields and generate regex patterns")
+    st.title("Field Analyzer")
     
-    # Try alternative method for Hugging Face Spaces
+    # Upload method selection
     upload_method = st.radio(
-        "Upload Method:",
-        ["Standard Upload (recommended)", "Text Paste (alternative)"],
+        "",
+        ["File Upload", "Text Paste"],
         horizontal=True,
         key="upload_method"
     )
@@ -188,21 +176,16 @@ def main():
     uploaded_file = None
     pasted_content = None
     
-    if upload_method == "Standard Upload (recommended)":
-        # File upload with accept_multiple_files for better debugging
+    if upload_method == "File Upload":
         uploaded_file = st.file_uploader(
-            "Choose a JSON file (Max size: 1 GB)",
+            "Upload JSON file",
             type=['json'],
-            help="Upload a JSON file with structured data (Maximum file size: 1 GB)",
             key="json_file_uploader"
         )
     else:
-        # Alternative: Allow pasting JSON content
-        st.info("📋 Paste your JSON content below:")
         pasted_content = st.text_area(
-            "JSON Content",
-            height=200,
-            help="Paste the full JSON content here",
+            "Paste JSON",
+            height=150,
             key="pasted_json"
         )
     
@@ -210,117 +193,44 @@ def main():
     content_str = None
     file_name = None
     
-    if upload_method == "Text Paste (alternative)" and pasted_content:
-        st.success("✅ Content pasted successfully!")
+    if upload_method == "Text Paste" and pasted_content:
         content_str = pasted_content
         file_name = "pasted_content.json"
     elif uploaded_file is not None:
-        st.success(f"✅ Upload widget triggered! File object received: {type(uploaded_file)}")
         file_name = uploaded_file.name
     
-    # Debug upload widget state
-    if upload_method == "Standard Upload (recommended)":
-        st.info(f"🔍 Upload widget state: {uploaded_file is not None}")
-        
-        if uploaded_file is None:
-            st.info("📝 Waiting for file upload...")
-            st.warning("⚠️ If you've selected a file but see this message, the file isn't being processed by the backend")
-    
     if content_str or uploaded_file is not None:
-        # Debug file upload info
-        if uploaded_file is not None:
-            st.info(f"📁 File uploaded: {uploaded_file.name} (Size: {uploaded_file.size} bytes)")
-            st.info(f"🔍 File type: {uploaded_file.type}")
-            st.info(f"🔍 File ID: {uploaded_file.file_id}")
-        else:
-            st.info(f"📁 Content pasted: {file_name}")
-        
-        # Read and parse JSON
         try:
-            if not content_str:  # Only read from file if content_str not already set
-                st.info("🔄 Reading file content...")
-                
-                # Reset file pointer in case it was read before
+            if not content_str:
+                # Read from uploaded file
                 uploaded_file.seek(0)
-                
-                # Read the file content
                 content = uploaded_file.read()
-                uploaded_file.seek(0)  # Reset for potential re-reading
-                
-                st.info(f"📄 Content length: {len(content)} characters")
+                uploaded_file.seek(0)
                 
                 if len(content) == 0:
-                    st.error("❌ File appears to be empty!")
-                    st.warning("This might be a bug. Please try uploading the file again.")
+                    st.error("File is empty")
                     return
                 
-                # Try to decode as UTF-8
                 try:
                     content_str = content.decode('utf-8')
-                except UnicodeDecodeError as e:
-                    st.error(f"❌ File encoding error: {e}")
-                    st.error("Please ensure your JSON file is UTF-8 encoded")
+                except UnicodeDecodeError:
+                    st.error("File encoding error")
                     return
-            else:
-                st.info("🔄 Using pasted content...")
-                st.info(f"📄 Content length: {len(content_str)} characters")
             
-            st.info("🔄 Parsing JSON...")
             data = json.loads(content_str)
+            st.success(f"Loaded: {file_name}")
             
-            st.success("✅ File loaded successfully!")
-            st.info(f"📊 Data structure: {type(data)} with {len(data) if isinstance(data, (dict, list)) else 'unknown'} top-level items")
-            
-            # Debug tab for troubleshooting
-            st.markdown("---")
-            with st.expander("🐛 Debug Information (Click to expand)", expanded=False):
-                col1, col2 = st.columns(2)
-                
-                with col1:
-                    st.markdown("#### Upload Details")
-                    if uploaded_file is not None:
-                        st.text(f"File Name: {uploaded_file.name}")
-                        st.text(f"File Size: {uploaded_file.size} bytes ({uploaded_file.size / 1024:.2f} KB)")
-                        st.text(f"File Type: {uploaded_file.type}")
-                        st.text(f"File ID: {uploaded_file.file_id}")
-                    else:
-                        st.text(f"Source: Pasted Content")
-                        st.text(f"File Name: {file_name}")
-                        st.text(f"Content Length: {len(content_str)} bytes ({len(content_str) / 1024:.2f} KB)")
-                        st.text(f"Encoding: UTF-8")
-                    
-                with col2:
-                    st.markdown("#### Data Details")
-                    st.text(f"Content Length: {len(content_str)} bytes")
-                    st.text(f"Data Type: {type(data).__name__}")
-                    st.text(f"Top-level Keys: {list(data.keys())[:5] if isinstance(data, dict) else 'N/A'}")
-                    st.text(f"Encoding: UTF-8")
-            
-            # Sidebar for settings
             with st.sidebar:
-                st.header("⚙️ Settings")
-                
-                # Target field input
-                target_field = st.text_input(
-                    "Target Field",
-                    value="rotation_enabled",
-                    help="The field you want to analyze"
-                )
+                target_field = st.text_input("Target Field", value="rotation_enabled")
                 
-                # Analyze button
-                if st.button("🔍 Analyze", type="primary"):
-                    with st.spinner("Analyzing data structure..."):
-                        st.info(f"🎯 Analyzing with target field: {target_field}")
+                if st.button("Analyze", type="primary"):
+                    with st.spinner("Analyzing..."):
                         try:
                             analysis_result = analyze_with_llm(data, target_field)
                             st.session_state.analysis_result = analysis_result
                             st.session_state.data = data
-                            st.success("✅ Analysis completed successfully!")
                         except Exception as e:
-                            st.error(f"❌ Analysis failed: {e}")
-                            st.error(f"Error type: {type(e).__name__}")
-                            import traceback
-                            st.code(traceback.format_exc())
+                            st.error(f"Analysis failed: {e}")
             
             # Display results if available
             if st.session_state.analysis_result:
@@ -339,59 +249,47 @@ def main():
                 
                 st.markdown("---")
                 
-                # Create tabs
                 tab1, tab2, tab3, tab4, tab5 = st.tabs([
-                    "📊 Structure Analysis",
-                    "🎯 Field Recommendations", 
-                    "📝 Generated Patterns",
-                    "📄 Raw Data",
-                    "🐛 Debug Log"
+                    "Analysis",
+                    "Fields", 
+                    "Patterns",
+                    "Data",
+                    "Debug"
                 ])
                 
                 with tab1:
-                    st.subheader("Data Hierarchy")
-                    
-                    # Summary fields
                     if analysis['summary_fields_detected']:
-                        st.markdown("#### Level 1: Summary/Aggregate Fields (Highest Priority)")
+                        st.write("**Summary Fields**")
                         for field in analysis['summary_fields_detected'][:10]:
-                            st.write(f"✓ `{field}`")
+                            st.write(f"`{field}`")
                     
-                    # Config fields
                     config_fields = analysis['classification'].get('config_fields', [])
                     if config_fields:
-                        st.markdown("#### Level 2: Configuration/Compliance Fields")
+                        st.write("**Config Fields**")
                         for field in config_fields[:10]:
-                            st.write(f"✓ `{field}`")
+                            st.write(f"`{field}`")
                     
-                    # Object arrays
                     object_arrays = analysis['classification'].get('object_arrays', [])
                     if object_arrays:
-                        st.markdown("#### Level 3: Object Arrays")
+                        st.write("**Object Arrays**")
                         for field in object_arrays[:5]:
-                            st.write(f"✓ `{field}`")
+                            st.write(f"`{field}`")
                     
-                    # Show sample data
-                    with st.expander("📋 View Summary Data Sample"):
+                    with st.expander("Summary Sample"):
                         st.json(analysis['summary_sample'])
                     
-                    with st.expander("📋 View Object Data Sample"):
+                    with st.expander("Object Sample"):
                         st.json(analysis['sample_object'])
                 
                 with tab2:
-                    st.subheader("Recommended Fields for Analysis")
-                    
                     if analysis['recommended_fields']:
-                        st.info("These fields are recommended based on the data hierarchy and target field.")
-                        
-                        # Let user select fields
                         selected_fields = st.multiselect(
-                            "Select fields to generate patterns for:",
+                            "Select fields:",
                             analysis['recommended_fields'],
                             default=analysis['recommended_fields'][:3]
                         )
                         
-                        if selected_fields and st.button("Generate Patterns"):
+                        if selected_fields and st.button("Generate"):
                             patterns = generate_regex_patterns(
                                 selected_fields,
                                 analysis['sample_object'],
@@ -402,169 +300,60 @@ def main():
                                 'fields': selected_fields,
                                 'patterns': patterns
                             }
-                    else:
-                        st.warning("No recommended fields found.")
                 
                 with tab3:
                     if 'generated_patterns' in st.session_state:
                         patterns_data = st.session_state.generated_patterns
                         
-                        st.subheader("Generated Regex Patterns")
-                        
-                        # Show patterns
-                        for i, (field, pattern) in enumerate(zip(patterns_data['fields'], patterns_data['patterns']), 1):
-                            st.markdown(f"**Pattern {i}: {field}**")
-                            st.code(pattern, language="regex", line_numbers=False)
-                            st.markdown("---")
+                        for field, pattern in zip(patterns_data['fields'], patterns_data['patterns']):
+                            st.write(f"**{field}**")
+                            st.code(pattern)
+                            st.write("")
                         
-                        # Copy to clipboard
                         all_patterns = "\n".join(patterns_data['patterns'])
-                        st.text_area(
-                            "All Patterns (copy this):",
-                            all_patterns,
-                            height=100
-                        )
+                        st.text_area("All Patterns:", all_patterns, height=100)
                         
-                        # JSON export
                         export_data = {
-                            "test_name": "Field Analysis",
-                            "important_fields": patterns_data['fields'],
-                            "reasoning": "Fields identified using hierarchical analysis prioritizing summary/aggregate fields",
-                            "generated_regex": patterns_data['patterns']
+                            "fields": patterns_data['fields'],
+                            "patterns": patterns_data['patterns']
                         }
                         
                         st.download_button(
-                            label="📥 Download as JSON",
+                            "Download JSON",
                             data=json.dumps(export_data, indent=2),
-                            file_name="analysis_result.json",
+                            file_name="analysis.json",
                             mime="application/json"
                         )
-                    else:
-                        st.info("👆 Go to 'Field Recommendations' tab to select fields and generate patterns.")
                 
                 with tab4:
-                    st.subheader("Raw Data Structure")
-                    
-                    # Full data viewer
                     st.json(data)
-                    
-                    # Download raw data
                     st.download_button(
-                        label="📥 Download Raw Data",
+                        "Download Raw",
                         data=json.dumps(data, indent=2),
-                        file_name="raw_data.json",
+                        file_name="raw.json",
                         mime="application/json"
                     )
                 
                 with tab5:
-                    st.subheader("🐛 Debug Information")
-                    
                     col1, col2 = st.columns(2)
                     
                     with col1:
-                        st.markdown("#### File Upload Details")
-                        debug_info = {
-                            "File Name": uploaded_file.name if uploaded_file else "None",
-                            "File Size (bytes)": uploaded_file.size if uploaded_file else 0,
-                            "File Type": uploaded_file.type if uploaded_file else "None",
-                            "File ID": str(uploaded_file.file_id) if uploaded_file else "None",
-                        }
-                        
-                        for key, value in debug_info.items():
-                            st.text(f"{key}: {value}")
-                        
-                        # Server configuration
-                        st.markdown("#### Server Configuration")
-                        config_info = {
-                            "Python Version": sys.version.split('\n')[0],
-                            "Streamlit Version": st.__version__,
-                            "Upload Size Limit": "1024 MB (1 GB)",
-                            "XSRF Protection": "Disabled",
-                        }
-                        
-                        for key, value in config_info.items():
-                            st.text(f"{key}: {value}")
+                        st.write("**Upload**")
+                        st.text(f"File: {uploaded_file.name if uploaded_file else 'N/A'}")
+                        st.text(f"Size: {uploaded_file.size if uploaded_file else 0} bytes")
+                        st.text(f"Streamlit: {st.__version__}")
                     
                     with col2:
-                        st.markdown("#### Session State")
-                        session_keys = list(st.session_state.keys())
-                        
-                        if session_keys:
-                            for key in session_keys:
-                                value = st.session_state[key]
-                                if isinstance(value, (dict, list)):
-                                    st.text(f"{key}: {type(value).__name__} ({len(value)} items)")
-                                else:
-                                    st.text(f"{key}: {str(value)[:50]}...")
-                        else:
-                            st.info("No session state data")
-                        
-                        st.markdown("#### Analysis Metadata")
+                        st.write("**Analysis**")
                         if st.session_state.get('analysis_result'):
-                            analysis = st.session_state.analysis_result
-                            st.text(f"Summary Fields: {len(analysis.get('summary_fields_detected', []))}")
-                            st.text(f"Total Objects: {analysis.get('total_objects', 0)}")
-                            st.text(f"Recommended Fields: {len(analysis.get('recommended_fields', []))}")
-                        else:
-                            st.info("No analysis data yet")
-                    
-                    # Debug console output
-                    st.markdown("#### Backend Console Output")
-                    st.info("Check your browser console (F12) and Streamlit terminal for detailed backend logs")
-                    
-                    # Refresh button
-                    if st.button("🔄 Refresh Debug Info"):
-                        st.rerun()
+                            a = st.session_state.analysis_result
+                            st.text(f"Fields: {len(a.get('summary_fields_detected', []))}")
+                            st.text(f"Objects: {a.get('total_objects', 0)}")
         
         except json.JSONDecodeError as e:
-            st.error(f"❌ Invalid JSON file: {e}")
+            st.error(f"Invalid JSON: {e}")
         except Exception as e:
-            st.error(f"❌ Error processing file: {e}")
-            st.error(f"Error type: {type(e).__name__}")
-            import traceback
-            st.code(traceback.format_exc())
-    
-    else:
-        # Show example when no file uploaded
-        st.info("👆 Please upload a JSON file to begin analysis")
-        
-        with st.expander("📖 How to use"):
-            st.markdown("""
-            **Steps:**
-            1. Upload a JSON file with structured data
-            2. Set the target field you want to analyze (e.g., `rotation_enabled`)
-            3. Click "Analyze" to process the data
-            4. Review the structure analysis and field recommendations
-            5. Select fields and generate regex patterns
-            6. Download the results as JSON
-            
-            **What this tool does:**
-            - Detects summary/aggregate fields automatically
-            - Classifies data structure by hierarchy levels
-            - Recommends important fields for validation
-            - Generates regex patterns for field extraction
-            """)
-        
-        with st.expander("📋 Example JSON Structure"):
-            example = {
-                "results": {
-                    "summary": {
-                        "total_keys": 13,
-                        "rotated_keys": 6,
-                        "rotation_percentage": 46
-                    },
-                    "kms_keys": {
-                        "object": [
-                            {
-                                "key_id": "12345",
-                                "rotation_enabled": True,
-                                "key_state": "Enabled"
-                            }
-                        ]
-                    }
-                }
-            }
-            st.json(example)
+            st.error(f"Error: {e}")
 
 
 if __name__ == "__main__":