mcp-souschef 2.5.3__py3-none-any.whl → 3.0.0__py3-none-any.whl

souschef/ui/app.py

@@ -1,42 +1,66 @@
-"""
-Visual Migration Planning Interface for SousChef.
+# Add the parent directory to the path so we can import souschef modules
+import sys
+from pathlib import Path
 
-A Streamlit-based web interface for Chef to Ansible migration planning,
-assessment, and visualization.
-"""
+app_path = Path(__file__).parent.parent
+if str(app_path) not in sys.path:
+    sys.path.insert(0, str(app_path))
 
 import contextlib
-import sys
-from pathlib import Path
+import os
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Concatenate,
+    ParamSpec,
+    TypeVar,
+)
 
 import streamlit as st
 
-# Add the parent directory to the path so we can import souschef modules
-sys.path.insert(0, str(Path(__file__).parent.parent))
+if TYPE_CHECKING:
+    import networkx as nx
+    import plotly.graph_objects as go
+    from matplotlib.figure import Figure
+
+P = ParamSpec("P")
+R = TypeVar("R")
 
-# Import page modules
+from souschef.ui.pages.ai_settings import show_ai_settings_page
 from souschef.ui.pages.cookbook_analysis import show_cookbook_analysis_page
 
-# Constants for repeated strings
+# Constants
+SECTION_COMMUNITY_COOKBOOKS_HEADER = "Community Cookbooks:"
+SECTION_COMMUNITY_COOKBOOKS = "Community Cookbooks"
+SECTION_CIRCULAR_DEPENDENCIES = "Circular Dependencies"
+SECTION_MIGRATION_IMPACT_ANALYSIS = "Migration Impact Analysis"
 NAV_MIGRATION_PLANNING = "Migration Planning"
 NAV_DEPENDENCY_MAPPING = "Dependency Mapping"
 NAV_VALIDATION_REPORTS = "Validation Reports"
+NAV_AI_SETTINGS = "AI Settings"
+NAV_COOKBOOK_ANALYSIS = "Cookbook Analysis"
+BUTTON_ANALYSE_DEPENDENCIES = "Analyse Dependencies"
+INPUT_METHOD_DIRECTORY_PATH = "Directory Path"
 MIME_TEXT_MARKDOWN = "text/markdown"
 MIME_APPLICATION_JSON = "application/json"
-SECTION_CIRCULAR_DEPENDENCIES = "Circular Dependencies"
+ERROR_MSG_ENTER_PATH = "Please enter a path."
+SCOPE_BEST_PRACTICES = "Best Practices"
 
 
 class ProgressTracker:
     """Track progress for long-running operations."""
 
-    def __init__(self, total_steps=100, description="Processing..."):
-        self.total_steps = total_steps
-        self.current_step = 0
-        self.description = description
+    def __init__(
+        self, total_steps: int = 100, description: str = "Processing..."
+    ) -> None:
+        self.total_steps: int = total_steps
+        self.current_step: int = 0
+        self.description: str = description
         self.progress_bar = st.progress(0)
         self.status_text = st.empty()
 
-    def update(self, step=None, description=None):
+    def update(self, step: int | None = None, description: str | None = None) -> None:
         """Update progress."""
         if step is not None:
             self.current_step = min(step, self.total_steps)
@@ -52,7 +76,7 @@ class ProgressTracker:
             f"{self.description} ({self.current_step}/{self.total_steps})"
         )
 
-    def complete(self, message="Completed!"):
+    def complete(self, message: str = "Completed!") -> None:
         """Mark progress as complete."""
         self.progress_bar.progress(1.0)
         self.status_text.text(message)
@@ -60,24 +84,26 @@ class ProgressTracker:
 
         time.sleep(0.5)  # Brief pause to show completion
 
-    def close(self):
+    def close(self) -> None:
         """Clean up progress indicators."""
         self.progress_bar.empty()
         self.status_text.empty()
 
 
 def with_progress_tracking(
-    operation_func, description="Processing...", total_steps=100
-):
+    operation_func: Callable[Concatenate[ProgressTracker, P], R],
+    description: str = "Processing...",
+    total_steps: int = 100,
+) -> Callable[P, R]:
     """Add progress tracking to operations."""
 
-    def wrapper(*args, **kwargs):
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
         tracker = ProgressTracker(total_steps, description)
         try:
-            result = operation_func(tracker, *args, **kwargs)
+            result: R = operation_func(tracker, *args, **kwargs)
             tracker.complete()
             return result
-        except Exception as e:
+        except Exception as e:  # noqa: BLE001
             tracker.close()
             raise e
         finally:
@@ -86,90 +112,273 @@ def with_progress_tracking(
     return wrapper
 
 
-def main():
+def main() -> None:
     """Run the main Streamlit application."""
     st.set_page_config(
         page_title="SousChef - Chef to Ansible Migration",
         layout="wide",
-        initial_sidebar_state="expanded",
+        initial_sidebar_state="collapsed",
     )
 
     st.title("SousChef - Visual Migration Planning")
     st.markdown("*AI-powered Chef to Ansible migration planning interface*")
 
-    # Sidebar navigation
-    page = st.sidebar.selectbox(
-        "Navigation",
-        [
-            "Dashboard",
+    # Main content area - default to dashboard
+    page = st.session_state.get("current_page", "Dashboard")
+
+    # Navigation section
+    st.subheader("Navigation")
+
+    col1, col2, col3, col4, col5 = st.columns(5)
+
+    with col1:
+        if st.button(
             "Cookbook Analysis",
-            NAV_MIGRATION_PLANNING,
-            NAV_DEPENDENCY_MAPPING,
-            NAV_VALIDATION_REPORTS,
-        ],
-        help="Choose the section you want to work with. "
-        "Use arrow keys to navigate options.",
-        key="main_navigation",
-    )
+            type="primary" if page == NAV_COOKBOOK_ANALYSIS else "secondary",
+            width="stretch",
+            key="nav_cookbook_analysis",
+        ):
+            st.session_state.current_page = NAV_COOKBOOK_ANALYSIS
+            st.rerun()
+
+    with col2:
+        if st.button(
+            "Migration Planning",
+            type="primary" if page == NAV_MIGRATION_PLANNING else "secondary",
+            width="stretch",
+            key="nav_migration_planning",
+        ):
+            st.session_state.current_page = NAV_MIGRATION_PLANNING
+            st.rerun()
 
-    # Main content area
-    if page == "Dashboard":
-        show_dashboard()
-    elif page == "Cookbook Analysis":
-        show_cookbook_analysis_page()
-    elif page == NAV_MIGRATION_PLANNING:
-        show_migration_planning()
-    elif page == NAV_DEPENDENCY_MAPPING:
-        show_dependency_mapping()
-    elif page == NAV_VALIDATION_REPORTS:
-        show_validation_reports()
+    with col3:
+        if st.button(
+            "Dependency Mapping",
+            type="primary" if page == NAV_DEPENDENCY_MAPPING else "secondary",
+            width="stretch",
+            key="nav_dependency_mapping",
+        ):
+            st.session_state.current_page = NAV_DEPENDENCY_MAPPING
+            st.rerun()
+
+    with col4:
+        if st.button(
+            "Validation Reports",
+            type="primary" if page == NAV_VALIDATION_REPORTS else "secondary",
+            width="stretch",
+            key="nav_validation_reports",
+        ):
+            st.session_state.current_page = NAV_VALIDATION_REPORTS
+            st.rerun()
 
+    with col5:
+        if st.button(
+            "AI Settings",
+            type="primary" if page == NAV_AI_SETTINGS else "secondary",
+            width="stretch",
+            key="nav_ai_settings",
+        ):
+            st.session_state.current_page = NAV_AI_SETTINGS
+            st.rerun()
+
+    st.divider()
+
+    # Page routing
+    _route_to_page(page)
+
+
+def _route_to_page(page: str) -> None:
+    """Route to the appropriate page based on the current page state."""
+    page_routes = {
+        "Dashboard": show_dashboard,
+        NAV_COOKBOOK_ANALYSIS: show_cookbook_analysis_page,
+        NAV_MIGRATION_PLANNING: show_migration_planning,
+        NAV_DEPENDENCY_MAPPING: show_dependency_mapping,
+        NAV_VALIDATION_REPORTS: show_validation_reports,
+        NAV_AI_SETTINGS: show_ai_settings_page,
+    }
+
+    route_func = page_routes.get(page)
+    if route_func:
+        route_func()
+    else:
+        show_dashboard()  # Default fallback
+
+
+def _calculate_dashboard_metrics() -> tuple[int, str, int, int]:
+    """Calculate and return dashboard metrics."""
+    complexity_counts = {"High": 0, "Medium": 0, "Low": 0}
+    successful_analyses = 0
+    cookbooks_analysed = 0
+
+    if "analysis_results" in st.session_state and st.session_state.analysis_results:
+        results = st.session_state.analysis_results
+        cookbooks_analysed = len(results)
+        successful_analyses = len([r for r in results if r.get("status") == "Analysed"])
+
+        for r in results:
+            comp = r.get("complexity", "Unknown")
+            if comp in complexity_counts:
+                complexity_counts[comp] += 1
+
+    # Determine overall complexity
+    overall_complexity = "Unknown"
+    if cookbooks_analysed > 0:
+        if complexity_counts["High"] > 0:
+            overall_complexity = "High"
+        elif complexity_counts["Medium"] > 0:
+            overall_complexity = "Medium"
+        elif complexity_counts["Low"] > 0:
+            overall_complexity = "Low"
+
+    conversion_rate = 0
+    if cookbooks_analysed > 0:
+        conversion_rate = int((successful_analyses / cookbooks_analysed) * 100)
+
+    return (
+        cookbooks_analysed,
+        overall_complexity,
+        conversion_rate,
+        successful_analyses,
+    )
 
-def show_dashboard():
-    """Show the main dashboard with migration overview."""
-    st.header("Migration Dashboard")
 
+def _display_dashboard_metrics(
+    cookbooks_analysed: int,
+    overall_complexity: str,
+    conversion_rate: int,
+    successful_analyses: int,
+) -> None:
+    """Display the dashboard metrics."""
     col1, col2, col3 = st.columns(3)
 
     with col1:
-        st.metric("Cookbooks Analyzed", "0", "Ready to analyze")
+        st.metric(
+            "Cookbooks Analysed",
+            str(cookbooks_analysed),
+            f"{cookbooks_analysed} processed"
+            if cookbooks_analysed > 0
+            else "Ready to analyse",
+        )
         st.caption("Total cookbooks processed")
 
     with col2:
-        st.metric("Migration Complexity", "Unknown", "Assessment needed")
+        st.metric(
+            "Migration Complexity",
+            overall_complexity,
+            "Based on analysis"
+            if overall_complexity != "Unknown"
+            else "Assessment needed",
+        )
         st.caption("Overall migration effort")
 
     with col3:
-        st.metric("Conversion Rate", "0%", "Start migration")
-        st.caption("Successful conversions")
+        st.metric(
+            "Success Rate",
+            f"{conversion_rate}%",
+            f"{successful_analyses} successful"
+            if cookbooks_analysed > 0
+            else "Start migration",
+        )
+        st.caption("Successful analyses")
 
-    st.divider()
 
-    # Quick actions
-    st.subheader("Quick Actions")
+def _display_quick_upload_section() -> None:
+    """Display the quick upload section."""
+    st.subheader("Quick Start - Upload Cookbooks")
 
-    col1, col2 = st.columns(2)
+    col1, col2 = st.columns([2, 1])
 
     with col1:
-        if st.button(
-            "Analyze Cookbook Directory", type="primary", use_container_width=True
-        ):
-            st.rerun()  # This will trigger navigation to cookbook analysis
+        uploaded_file = st.file_uploader(
+            "Upload Cookbook Archive",
+            type=["zip", "tar.gz", "tgz", "tar"],
+            help="Upload a ZIP or TAR archive containing your Chef "
+            "cookbooks for quick analysis",
+            key="dashboard_upload",
+        )
+
+        if uploaded_file:
+            # Store the uploaded file in session state for persistence across pages
+            st.session_state.uploaded_file_data = uploaded_file.getvalue()
+            st.session_state.uploaded_file_name = uploaded_file.name
+            st.session_state.uploaded_file_type = uploaded_file.type
+
+            st.success(f"File {uploaded_file.name} uploaded successfully!")
+            st.info(
+                "Navigate to Cookbook Analysis above to process this file, "
+                "or upload another file to replace it."
+            )
 
     with col2:
-        if st.button(
-            "Generate Migration Plan", type="secondary", use_container_width=True
-        ):
-            st.rerun()  # This will trigger navigation to migration planning
+        st.markdown("**Upload Options:**")
+        st.markdown("- ZIP archives (.zip)")
+        st.markdown("- TAR archives (.tar, .tar.gz, .tgz)")
+        st.markdown("- Process uploaded files using the navigation buttons above")
 
-    # Recent activity
+
+def _display_recent_activity() -> None:
+    """Display the recent activity section."""
     st.subheader("Recent Activity")
-    st.info("No recent migration activity. Start by analyzing your cookbooks!")
+    st.info(
+        "No recent migration activity. Start by uploading cookbooks "
+        f"above or using the {NAV_COOKBOOK_ANALYSIS} page!"
+    )
+
+    # Getting started guide
+    with st.expander("How to Get Started"):
+        st.markdown("""
+        **New to SousChef? Here's how to begin:**
+
+        1. **Upload Cookbooks**: Use the uploader above or go to {NAV_COOKBOOK_ANALYSIS}
+        2. **Analyse Complexity**: Get detailed migration assessments
+        3. **Plan Migration**: Generate timelines and resource requirements
+        4. **Convert to Ansible**: Download converted playbooks
+
+        **Supported Formats:**
+        - ZIP archives (.zip)
+        - TAR archives (.tar, .tar.gz, .tgz)
+        - Directory paths (in {NAV_COOKBOOK_ANALYSIS})
+
+        **Expected Structure:**
+        ```
+        your-cookbooks/
+        ├── nginx/
+        │   ├── metadata.rb
+        │   ├── recipes/
+        │   └── attributes/
+        └── apache2/
+            └── metadata.rb
+        ```
+        """)
+
+
+def show_dashboard() -> None:
+    """Show the main dashboard with migration overview."""
+    st.header("Migration Dashboard")
+
+    # Metrics calculation
+    cookbooks_analysed, overall_complexity, conversion_rate, successful_analyses = (
+        _calculate_dashboard_metrics()
+    )
+
+    # Display metrics
+    _display_dashboard_metrics(
+        cookbooks_analysed, overall_complexity, conversion_rate, successful_analyses
+    )
+
+    st.divider()
+
+    # Quick upload section
+    _display_quick_upload_section()
+
+    # Recent activity
+    _display_recent_activity()
 
 
-def show_migration_planning():
+def show_migration_planning() -> None:
     """Show migration planning interface."""
-    st.header("Migration Planning")
+    st.header(NAV_MIGRATION_PLANNING)
 
     # Import assessment functions
     from souschef.assessment import generate_migration_plan
@@ -183,13 +392,27 @@ def show_migration_planning():
     # Step 1: Cookbook Selection
     st.subheader("Step 1: Cookbook Selection")
 
+    # Check for previously analyzed cookbooks
+    uploaded_plan_context = None
+    if (
+        "analysis_cookbook_path" in st.session_state
+        and st.session_state.analysis_cookbook_path
+    ):
+        uploaded_plan_context = st.session_state.analysis_cookbook_path
+        st.info(f"Using analyzed cookbooks from: {uploaded_plan_context}")
+
     col1, col2 = st.columns([3, 1])
 
     with col1:
+        # Default to analyzed path if available
+        default_paths = uploaded_plan_context if uploaded_plan_context else ""
+
         cookbook_paths = st.text_area(
             "Cookbook Paths",
+            value=default_paths,
             placeholder="/path/to/cookbooks/nginx,/path/to/cookbooks/apache2,/path/to/cookbooks/mysql",
-            help="Enter comma-separated paths to your Chef cookbooks",
+            help="Enter comma-separated paths to your Chef cookbooks. If you uploaded "
+            "an archive in the Analysis tab, that path is pre-filled.",
             height=100,
         )
 
@@ -274,7 +497,12 @@ def show_migration_planning():
     # Step 3: Generate Plan
     st.subheader("Step 3: Generate Migration Plan")
 
-    if st.button("Generate Migration Plan", type="primary", use_container_width=True):
+    if st.button(
+        "Generate Migration Plan",
+        type="primary",
+        width="stretch",
+        key="migration_plan_generate",
+    ):
         if not cookbook_paths.strip():
             st.error("Please enter cookbook paths to generate a migration plan.")
             return
@@ -318,7 +546,9 @@ def show_migration_planning():
         display_migration_plan_results()
 
 
-def _display_migration_summary_metrics(cookbook_paths, strategy, timeline):
+def _display_migration_summary_metrics(
+    cookbook_paths: str, strategy: str, timeline: int
+) -> None:
     """Display migration overview summary metrics."""
     st.subheader("Migration Overview")
 
@@ -338,7 +568,7 @@ def _display_migration_summary_metrics(cookbook_paths, strategy, timeline):
         st.metric("Status", "Plan Generated")
 
 
-def _display_migration_plan_details(plan_result):
+def _display_migration_plan_details(plan_result: str) -> None:
     """Display the detailed migration plan sections."""
     st.subheader("Migration Plan Details")
 
@@ -359,14 +589,18 @@ def _display_migration_plan_details(plan_result):
             st.markdown(section)
 
 
-def _display_migration_action_buttons(cookbook_paths):
+def _display_migration_action_buttons(cookbook_paths: str) -> None:
     """Display action buttons for next steps."""
     st.subheader("Next Steps")
 
     col1, col2, col3 = st.columns(3)
 
     with col1:
-        if st.button("📊 Generate Detailed Report", use_container_width=True):
+        if st.button(
+            "Generate Detailed Report",
+            width="stretch",
+            key="migration_detailed_report",
+        ):
             with st.spinner("Generating detailed migration report..."):
                 try:
                     from souschef.assessment import generate_migration_report
@@ -380,27 +614,31 @@ def _display_migration_action_buttons(cookbook_paths):
                     st.error(f"Error generating report: {e}")
 
     with col2:
-        if st.button("🔍 Analyze Dependencies", use_container_width=True):
+        if st.button(
+            "Analyse Dependencies",
+            width="stretch",
+            key="migration_analyse_dependencies",
+        ):
             if len(cookbook_paths.split(",")) == 1:
                 # Single cookbook dependency analysis
                 cookbook_path = cookbook_paths.split(",")[0].strip()
-                with st.spinner(f"Analyzing dependencies for {cookbook_path}..."):
+                with st.spinner(f"Analysing dependencies for {cookbook_path}..."):
                     try:
-                        from souschef.assessment import analyze_cookbook_dependencies
+                        from souschef.assessment import analyse_cookbook_dependencies
 
-                        dep_analysis = analyze_cookbook_dependencies(cookbook_path)
+                        dep_analysis = analyse_cookbook_dependencies(cookbook_path)
                         st.session_state.dep_analysis = dep_analysis
                         st.success("Dependency analysis complete!")
                     except Exception as e:
                         st.error(f"Error analyzing dependencies: {e}")
             else:
                 st.info(
-                    "Dependency analysis is optimized for single cookbooks. "
+                    "Dependency analysis is optimised for single cookbooks. "
                     "Select one cookbook path for detailed analysis."
                 )
 
     with col3:
-        if st.button("📥 Export Plan", use_container_width=True):
+        if st.button("Export Plan", width="stretch", key="migration_export_plan"):
             # Create downloadable plan
             plan_content = f"""# Chef to Ansible Migration Plan
 Generated: {st.session_state.get("timestamp", "Unknown")}
@@ -423,20 +661,20 @@ Generated: {st.session_state.get("timestamp", "Unknown")}
             )
 
 
-def _display_additional_reports():
+def _display_additional_reports() -> None:
     """Display detailed report and dependency analysis if available."""
     # Display detailed report if generated
     if "detailed_report" in st.session_state:
-        with st.expander("📊 Detailed Migration Report"):
+        with st.expander("Detailed Migration Report"):
             st.markdown(st.session_state.detailed_report)
 
     # Display dependency analysis if generated
     if "dep_analysis" in st.session_state:
-        with st.expander("🔍 Dependency Analysis"):
+        with st.expander("Dependency Analysis"):
             st.markdown(st.session_state.dep_analysis)
 
 
-def display_migration_plan_results():
+def display_migration_plan_results() -> None:
     """Display the generated migration plan results."""
     plan_result = st.session_state.migration_plan
     cookbook_paths = st.session_state.cookbook_paths
@@ -449,25 +687,55 @@ def display_migration_plan_results():
     _display_additional_reports()
 
 
-def show_dependency_mapping():
+def show_dependency_mapping() -> None:
     """Show dependency mapping visualization."""
     st.header(NAV_DEPENDENCY_MAPPING)
 
     # Import assessment functions
-    from souschef.assessment import analyze_cookbook_dependencies
+    from souschef.assessment import analyse_cookbook_dependencies
 
     st.markdown("""
-    Visualize and analyze cookbook dependencies to understand migration order
+    Visualise and analyse cookbook dependencies to understand migration order
     and identify potential circular dependencies.
     """)
 
-    # Cookbook path input
-    cookbook_path = st.text_input(
-        "Cookbook Directory Path",
-        placeholder="/path/to/your/cookbooks",
-        help="Enter the path to your cookbooks directory for dependency analysis",
+    # Input method selection
+    input_method = st.radio(
+        "Choose Input Method",
+        ["Upload Archive", INPUT_METHOD_DIRECTORY_PATH],
+        horizontal=True,
+        help="Select how to provide cookbooks for dependency analysis",
+        key="dep_input_method",
     )
 
+    cookbook_path = None
+    uploaded_file = None
+
+    if input_method == INPUT_METHOD_DIRECTORY_PATH:
+        cookbook_path = st.text_input(
+            "Cookbook Directory Path",
+            placeholder="/path/to/your/cookbooks",
+            help="Enter the path to your cookbooks directory for dependency analysis",
+        )
+    else:
+        uploaded_file = st.file_uploader(
+            "Upload Cookbook Archive",
+            type=["zip", "tar.gz", "tgz", "tar"],
+            help="Upload a ZIP or TAR archive containing your Chef cookbooks",
+            key="dep_archive_upload",
+        )
+        if uploaded_file:
+            try:
+                with st.spinner("Extracting archive..."):
+                    # Import the extract function from cookbook_analysis
+                    from souschef.ui.pages.cookbook_analysis import extract_archive
+
+                    cookbook_path = str(extract_archive(uploaded_file))
+                st.success("Archive extracted successfully")
+            except Exception as e:
+                st.error(f"Failed to extract archive: {e}")
+                return
+
     # Analysis options
     col1, col2 = st.columns(2)
 
@@ -475,7 +743,7 @@ def show_dependency_mapping():
         dependency_depth = st.selectbox(
             "Analysis Depth",
             ["direct", "transitive", "full"],
-            help="How deep to analyze dependencies",
+            help="How deep to analyse dependencies",
             format_func=lambda x: {
                 "direct": "Direct Dependencies Only",
                 "transitive": "Include Transitive Dependencies",
@@ -496,21 +764,26 @@ def show_dependency_mapping():
         )
 
     # Analysis button
-    if st.button("Analyze Dependencies", type="primary", use_container_width=True):
-        if not cookbook_path.strip():
+    if st.button(
+        BUTTON_ANALYSE_DEPENDENCIES,
+        type="primary",
+        width="stretch",
+        key="dep_analyse_dependencies",
+    ):
+        if not cookbook_path or not cookbook_path.strip():
             st.error("Please enter a cookbook directory path.")
             return
 
         # Create progress tracker
         progress_tracker = ProgressTracker(
-            total_steps=5, description="Analyzing cookbook dependencies..."
+            total_steps=5, description="Analysing cookbook dependencies..."
         )
 
         try:
             progress_tracker.update(1, "Scanning cookbook directory...")
 
-            # Analyze dependencies
-            analysis_result = analyze_cookbook_dependencies(
+            # Analyse dependencies
+            analysis_result = analyse_cookbook_dependencies(
                 cookbook_path.strip(), dependency_depth
             )
 
@@ -538,17 +811,17 @@ def show_dependency_mapping():
         display_dependency_analysis_results()
 
 
-def _setup_dependency_mapping_ui():
+def _setup_dependency_mapping_ui() -> None:
     """Set up the dependency mapping UI header and description."""
     st.header(NAV_DEPENDENCY_MAPPING)
 
     st.markdown("""
-    Visualize and analyze cookbook dependencies to understand migration order
+    Visualise and analyse cookbook dependencies to understand migration order
     and identify potential circular dependencies.
     """)
 
 
-def _get_dependency_mapping_inputs():
+def _get_dependency_mapping_inputs() -> tuple[str, str, str]:
     """Collect user inputs for dependency analysis."""
     # Cookbook path input
     cookbook_path = st.text_input(
@@ -564,7 +837,7 @@ def _get_dependency_mapping_inputs():
         dependency_depth = st.selectbox(
             "Analysis Depth",
             ["direct", "transitive", "full"],
-            help="How deep to analyze dependencies",
+            help="How deep to analyse dependencies",
             format_func=lambda x: {
                 "direct": "Direct Dependencies Only",
                 "transitive": "Include Transitive Dependencies",
@@ -588,12 +861,14 @@ def _get_dependency_mapping_inputs():
 
 
 def _handle_dependency_analysis_execution(
-    cookbook_path, dependency_depth, visualization_type
-):
+    cookbook_path: str, dependency_depth: str, visualization_type: str
+) -> None:
     """Handle the dependency analysis execution when button is clicked."""
     # Analysis button
-    if st.button("Analyze Dependencies", type="primary", use_container_width=True):
-        if not cookbook_path.strip():
+    if st.button(
+        BUTTON_ANALYSE_DEPENDENCIES, type="primary", width="stretch", key="dep_analyze"
+    ):
+        if not cookbook_path or not cookbook_path.strip():
             st.error("Please enter a cookbook directory path.")
             return
 
@@ -602,21 +877,23 @@ def _handle_dependency_analysis_execution(
         )
 
 
-def _perform_dependency_analysis(cookbook_path, dependency_depth, visualization_type):
+def _perform_dependency_analysis(
+    cookbook_path: str, dependency_depth: str, visualization_type: str
+) -> None:
     """Perform the actual dependency analysis."""
     # Import assessment functions
-    from souschef.assessment import analyze_cookbook_dependencies
+    from souschef.assessment import analyse_cookbook_dependencies
 
     # Create progress tracker
     progress_tracker = ProgressTracker(
-        total_steps=5, description="Analyzing cookbook dependencies..."
+        total_steps=5, description="Analysing cookbook dependencies..."
     )
 
     try:
         progress_tracker.update(1, "Scanning cookbook directory...")
 
-        # Analyze dependencies
-        analysis_result = analyze_cookbook_dependencies(cookbook_path, dependency_depth)
+        # Analyse dependencies
+        analysis_result = analyse_cookbook_dependencies(cookbook_path, dependency_depth)
 
         progress_tracker.update(2, "Parsing dependency relationships...")
         progress_tracker.update(3, "Detecting circular dependencies...")
@@ -637,16 +914,16 @@ def _perform_dependency_analysis(cookbook_path, dependency_depth, visualization_
         st.error(f"Error analyzing dependencies: {e}")
 
 
-def _display_dependency_analysis_results_if_available():
+def _display_dependency_analysis_results_if_available() -> None:
     """Display dependency analysis results if they exist in session state."""
     # Display results if available
     if "dep_analysis_result" in st.session_state:
         display_dependency_analysis_results()
 
 
-def _extract_dependency_relationships(lines):
+def _extract_dependency_relationships(lines: Iterable[str]) -> dict[str, list[str]]:
     """Extract dependency relationships from analysis lines."""
-    dependencies = {}
+    dependencies: dict[str, list[str]] = {}
     current_section = None
 
     for line in lines:
@@ -655,7 +932,7 @@ def _extract_dependency_relationships(lines):
             current_section = "direct"
         elif "Transitive Dependencies:" in line:
             current_section = "transitive"
-        elif line.startswith("- ") and current_section in ["direct", "transitive"]:
+        elif line.startswith("- ") and current_section == "direct":
             # Regular dependencies
             dep_text = line[2:].strip()
             if ":" in dep_text:
@@ -669,11 +946,13 @@ def _extract_dependency_relationships(lines):
     return dependencies
 
 
-def _extract_circular_and_community_deps(lines):
+def _extract_circular_and_community_deps(
+    lines: Iterable[str],
+) -> tuple[list[tuple[str, str]], list[str]]:
     """Extract circular dependencies and community cookbooks."""
     circular_deps: list[tuple[str, str]] = []
     community_cookbooks: list[str] = []
-    current_section = None
+    current_section: str | None = None
 
     for line in lines:
         current_section = _update_current_section(line, current_section)
@@ -685,22 +964,27 @@ def _extract_circular_and_community_deps(lines):
     return circular_deps, community_cookbooks
 
 
-def _update_current_section(line, current_section):
+def _update_current_section(line: str, current_section: str | None) -> str | None:
     """Update the current section based on the line content."""
     line = line.strip()
     if "Circular Dependencies:" in line:
         return "circular"
-    elif "Community Cookbooks:" in line:
+    elif SECTION_COMMUNITY_COOKBOOKS_HEADER in line:
         return "community"
     return current_section
 
 
-def _is_list_item(line):
+def _is_list_item(line: str) -> bool:
     """Check if the line is a list item."""
     return line.strip().startswith("- ")
 
 
-def _process_list_item(line, current_section, circular_deps, community_cookbooks):
+def _process_list_item(
+    line: str,
+    current_section: str | None,
+    circular_deps: list[tuple[str, str]],
+    community_cookbooks: list[str],
+) -> None:
     """Process a list item based on the current section."""
     if current_section == "circular":
         _process_circular_dependency_item(line, circular_deps)
@@ -708,7 +992,9 @@ def _process_list_item(line, current_section, circular_deps, community_cookbooks
         _process_community_cookbook_item(line, community_cookbooks)
 
 
-def _process_circular_dependency_item(line, circular_deps):
+def _process_circular_dependency_item(
+    line: str, circular_deps: list[tuple[str, str]]
+) -> None:
     """Process a circular dependency list item."""
     dep_text = line[2:].strip()
     if "->" in dep_text:
@@ -717,14 +1003,16 @@ def _process_circular_dependency_item(line, circular_deps):
             circular_deps.append((parts[0].strip(), parts[1].strip()))
 
 
-def _process_community_cookbook_item(line, community_cookbooks):
+def _process_community_cookbook_item(line: str, community_cookbooks: list[str]) -> None:
     """Process a community cookbook list item."""
     cookbook = line[2:].strip()
     if cookbook:
         community_cookbooks.append(cookbook)
 
 
-def _parse_dependency_analysis(analysis_result):
+def _parse_dependency_analysis(
+    analysis_result: str,
+) -> tuple[dict[str, list[str]], list[tuple[str, str]], list[str]]:
     """Parse dependency analysis result into structured data."""
     lines = analysis_result.split("\n")
 
@@ -734,7 +1022,11 @@ def _parse_dependency_analysis(analysis_result):
     return dependencies, circular_deps, community_cookbooks
 
 
-def _create_networkx_graph(dependencies, circular_deps, community_cookbooks):
+def _create_networkx_graph(
+    dependencies: Mapping[str, Sequence[str]],
+    circular_deps: Sequence[tuple[str, str]],
+    community_cookbooks: Sequence[str],
+) -> "nx.DiGraph":
     """Create NetworkX graph from dependency data."""
     import networkx as nx
 
@@ -759,40 +1051,106 @@ def _create_networkx_graph(dependencies, circular_deps, community_cookbooks):
     return graph
 
 
-def _calculate_graph_positions(graph, layout_algorithm):
-    """Calculate node positions using specified layout algorithm."""
-    import networkx as nx
+def _calculate_graph_positions(
+    graph: "nx.DiGraph", layout_algorithm: str
+) -> tuple[dict[Any, tuple[float, float]], str]:
+    """
+    Calculate positions for graph nodes using the specified layout algorithm.
+
+    Args:
+        graph: NetworkX graph object
+        layout_algorithm: String specifying the layout algorithm to use
+
+    Returns:
+        tuple: (positions_dict, algorithm_used)
 
+    """
     # Choose layout algorithm based on graph size and user preference
     num_nodes = len(graph.nodes)
     if layout_algorithm == "auto":
-        if num_nodes < 10:
-            layout_algorithm = "spring"
-        elif num_nodes < 50:
-            layout_algorithm = "kamada_kawai"
-        else:
-            layout_algorithm = "circular"
+        layout_algorithm = _choose_auto_layout_algorithm(num_nodes)
 
     # Calculate positions using selected layout algorithm
-    if layout_algorithm == "spring":
-        pos = nx.spring_layout(graph, k=2, iterations=50)
-    elif layout_algorithm == "circular":
-        pos = nx.circular_layout(graph)
-    elif layout_algorithm == "kamada_kawai":
-        try:
-            pos = nx.kamada_kawai_layout(graph)
-        except Exception:
-            # Fallback to spring layout if kamada_kawai fails
-            pos = nx.spring_layout(graph, k=2, iterations=50)
-    else:
-        pos = nx.spring_layout(graph, k=2, iterations=50)
+    pos = _calculate_positions_with_algorithm(graph, layout_algorithm)
 
     return pos, layout_algorithm
 
 
-def _create_plotly_edge_traces(graph, pos):
+def _choose_auto_layout_algorithm(num_nodes: int) -> str:
+    """Choose the best layout algorithm based on graph size."""
+    if num_nodes <= 10:
+        return "circular"
+    elif num_nodes <= 50:
+        return "spring"
+    else:
+        return "kamada_kawai"
+
+
+def _calculate_positions_with_algorithm(
+    graph: "nx.DiGraph", layout_algorithm: str
+) -> Any:
+    """Calculate node positions using the specified algorithm."""
+    import networkx as nx
+
+    try:
+        if layout_algorithm == "spring":
+            return nx.spring_layout(graph, k=2, iterations=50, seed=42)
+        elif layout_algorithm == "circular":
+            return nx.circular_layout(graph)
+        elif layout_algorithm == "kamada_kawai":
+            return nx.kamada_kawai_layout(graph)
+        elif layout_algorithm == "shell":
+            return _calculate_shell_layout_positions(graph)
+        elif layout_algorithm == "random":
+            return nx.random_layout(graph, seed=42)
+        elif layout_algorithm == "spectral":
+            return nx.spectral_layout(graph)
+        elif layout_algorithm == "force_directed":
+            return nx.spring_layout(graph, k=3, iterations=100, seed=42, scale=2)
+        else:
+            return nx.spring_layout(graph, k=2, iterations=50, seed=42)
+    except Exception as e:
+        # Fallback to spring layout if algorithm fails
+        st.warning(
+            f"Layout algorithm '{layout_algorithm}' failed, using spring layout: {e}"
+        )
+        return nx.spring_layout(graph, k=2, iterations=50, seed=42)
+
+
+def _calculate_shell_layout_positions(
+    graph: "nx.DiGraph",
+) -> Any:
+    """Calculate shell layout positions for hierarchical organization."""
+    import networkx as nx
+
+    # Identify leaf nodes (no outgoing edges)
+    leaf_nodes = [n for n in graph.nodes() if graph.out_degree(n) == 0]
+    # Identify root nodes (no incoming edges)
+    root_nodes = [n for n in graph.nodes() if graph.in_degree(n) == 0]
+    # Middle nodes
+    middle_nodes = [
+        n for n in graph.nodes() if n not in leaf_nodes and n not in root_nodes
+    ]
+
+    shells = []
+    if root_nodes:
+        shells.append(root_nodes)
+    if middle_nodes:
+        shells.append(middle_nodes)
+    if leaf_nodes:
+        shells.append(leaf_nodes)
+
+    if shells:
+        return nx.shell_layout(graph, shells)
+    else:
+        return nx.spring_layout(graph, k=2, iterations=50, seed=42)
+
+
+def _create_plotly_edge_traces(
+    graph: "nx.DiGraph", pos: Mapping[Any, tuple[float, float]]
+) -> list["go.Scatter"]:
     """Create edge traces for Plotly graph."""
-    import plotly.graph_objects as go  # type: ignore[import-untyped]
+    import plotly.graph_objects as go
 
     edge_traces = []
 
@@ -843,7 +1201,9 @@ def _create_plotly_edge_traces(graph, pos):
     return edge_traces
 
 
-def _create_plotly_node_trace(graph, pos):
+def _create_plotly_node_trace(
+    graph: "nx.DiGraph", pos: Mapping[Any, tuple[float, float]]
+) -> "go.Scatter":
     """Create node trace for Plotly graph."""
     import plotly.graph_objects as go
 
@@ -896,14 +1256,16 @@ def _create_plotly_node_trace(graph, pos):
     return node_trace
 
 
-def _create_plotly_figure_layout(num_nodes, layout_algorithm):
+def _create_plotly_figure_layout(num_nodes: int, layout_algorithm: str) -> "go.Layout":
     """Create Plotly figure layout."""
     import plotly.graph_objects as go
 
-    return go.Layout(
-        title=f"Cookbook Dependency Graph ({num_nodes} nodes, "
-        f"{layout_algorithm} layout)",
-        titlefont_size=16,
+    layout: go.Layout = go.Layout(
+        title={
+            "text": f"Cookbook Dependency Graph ({num_nodes} nodes, "
+            f"{layout_algorithm} layout)",
+            "font": {"size": 16},
+        },
         showlegend=True,
         hovermode="closest",
         margin={"b": 20, "l": 5, "r": 5, "t": 40},
@@ -920,8 +1282,15 @@ def _create_plotly_figure_layout(num_nodes, layout_algorithm):
         plot_bgcolor="white",
     )
 
+    return layout
 
-def _create_interactive_plotly_graph(graph, pos, num_nodes, layout_algorithm):
+
+def _create_interactive_plotly_graph(
+    graph: "nx.DiGraph",
+    pos: Mapping[Any, tuple[float, float]],
+    num_nodes: int,
+    layout_algorithm: str,
+) -> "go.Figure":
     """Create interactive Plotly graph visualization."""
     import plotly.graph_objects as go
 
@@ -935,7 +1304,12 @@ def _create_interactive_plotly_graph(graph, pos, num_nodes, layout_algorithm):
     return fig
 
 
-def _create_static_matplotlib_graph(graph, pos, num_nodes, layout_algorithm):
+def _create_static_matplotlib_graph(
+    graph: "nx.DiGraph",
+    pos: Mapping[Any, tuple[float, float]],
+    num_nodes: int,
+    layout_algorithm: str,
+) -> "Figure":
     """Create static matplotlib graph visualization."""
     import matplotlib.pyplot as plt
 
@@ -1026,15 +1400,20 @@ def _create_static_matplotlib_graph(graph, pos, num_nodes, layout_algorithm):
     return plt.gcf()
 
 
-def create_dependency_graph(analysis_result, viz_type, layout_algorithm="auto"):
+def create_dependency_graph(
+    analysis_result: str,
+    viz_type: str,
+    layout_algorithm: str = "auto",
+    filters: Mapping[str, Any] | None = None,
+) -> "go.Figure | Figure | None":
     """
-    Create a dependency graph visualization.
+    Create a dependency graph visualization with optional filtering.
 
     Args:
         analysis_result: Text analysis result from dependency analysis
         viz_type: Visualization type ("interactive" or "static")
-        layout_algorithm: Layout algorithm to use ("auto", "spring",
-                          "circular", "kamada_kawai")
+        layout_algorithm: Layout algorithm to use
+        filters: Dictionary of filter options
 
     Returns:
         Plotly figure for interactive graphs, matplotlib figure for static graphs
@@ -1049,6 +1428,10 @@ def create_dependency_graph(analysis_result, viz_type, layout_algorithm="auto"):
         # Create NetworkX graph
         graph = _create_networkx_graph(dependencies, circular_deps, community_cookbooks)
 
+        # Apply filters if provided
+        if filters:
+            graph = _apply_graph_filters(graph, filters)
+
         if len(graph.nodes) == 0:
             return None
 
@@ -1069,7 +1452,83 @@ def create_dependency_graph(analysis_result, viz_type, layout_algorithm="auto"):
         return None
 
 
-def _parse_dependency_metrics_from_result(analysis_result):
+def _apply_graph_filters(
+    graph: "nx.DiGraph", filters: Mapping[str, Any]
+) -> "nx.DiGraph":
+    """Apply filters to the NetworkX graph."""
+    filtered_graph = graph.copy()
+
+    # Apply each filter type
+    filtered_graph = _filter_circular_dependencies_only(filtered_graph, filters)
+    filtered_graph = _filter_community_cookbooks_only(filtered_graph, filters)
+    filtered_graph = _filter_minimum_connections(filtered_graph, filters)
+
+    return filtered_graph
+
+
+def _filter_circular_dependencies_only(
+    graph: "nx.DiGraph", filters: Mapping[str, Any]
+) -> "nx.DiGraph":
+    """Filter graph to show only nodes involved in circular dependencies."""
+    if not filters.get("circular_only", False):
+        return graph
+
+    # Find nodes involved in circular dependencies
+    circular_nodes = set()
+    for source, target in filters.get("circular_deps", []):
+        circular_nodes.add(source)
+        circular_nodes.add(target)
+
+    # Remove nodes not involved in circular dependencies
+    nodes_to_remove = [n for n in graph.nodes() if n not in circular_nodes]
+    graph.remove_nodes_from(nodes_to_remove)
+
+    return graph
+
+
+def _filter_community_cookbooks_only(
+    graph: "nx.DiGraph", filters: Mapping[str, Any]
+) -> "nx.DiGraph":
+    """Filter graph to show only community cookbooks and their dependencies."""
+    if not filters.get("community_only", False):
+        return graph
+
+    community_nodes = set()
+    for node in graph.nodes():
+        if graph.nodes[node].get("community", False):
+            community_nodes.add(node)
+            # Also include dependencies of community cookbooks
+            for successor in graph.successors(node):
+                community_nodes.add(successor)
+
+    # Remove nodes not related to community cookbooks
+    nodes_to_remove = [n for n in graph.nodes() if n not in community_nodes]
+    graph.remove_nodes_from(nodes_to_remove)
+
+    return graph
+
+
+def _filter_minimum_connections(
+    graph: "nx.DiGraph", filters: Mapping[str, Any]
+) -> "nx.DiGraph":
+    """Filter graph to show only nodes with minimum connection count."""
+    min_connections = filters.get("min_connections", 0)
+    if min_connections <= 0:
+        return graph
+
+    nodes_to_remove = []
+    for node in graph.nodes():
+        degree = graph.degree(node)
+        if degree < min_connections:
+            nodes_to_remove.append(node)
+    graph.remove_nodes_from(nodes_to_remove)
+
+    return graph
+
+
+def _parse_dependency_metrics_from_result(
+    analysis_result: str,
+) -> tuple[int, int, int, int]:
     """Parse dependency analysis result to extract key metrics."""
     lines = analysis_result.split("\n")
 
@@ -1097,8 +1556,8 @@ def _parse_dependency_metrics_from_result(analysis_result):
 
 
 def _display_dependency_summary_metrics(
-    direct_deps, transitive_deps, circular_deps, community_cookbooks
-):
+    direct_deps: int, transitive_deps: int, circular_deps: int, community_cookbooks: int
+) -> None:
     """Display dependency analysis summary metrics."""
     col1, col2, col3, col4 = st.columns(4)
 
@@ -1112,85 +1571,479 @@ def _display_dependency_summary_metrics(
         st.metric(
             SECTION_CIRCULAR_DEPENDENCIES,
             circular_deps,
-            delta="⚠️ Check" if circular_deps > 0 else "✅ OK",
+            delta="Check" if circular_deps > 0 else "OK",
         )
 
     with col4:
-        st.metric("Community Cookbooks", community_cookbooks)
+        st.metric(SECTION_COMMUNITY_COOKBOOKS, community_cookbooks)
+
+
+def _calculate_migration_impact(
+    dependencies: Mapping[str, Sequence[str]],
+    circular_deps: Sequence[tuple[str, str]],
+    community_cookbooks: Sequence[str],
+) -> dict[str, Any]:
+    """Calculate migration impact analysis based on dependency structure."""
+    impact: dict[str, Any] = {
+        "risk_score": 0.0,
+        "timeline_impact_weeks": 0,
+        "complexity_level": "Low",
+        "parallel_streams": 1,
+        "critical_path": [],
+        "bottlenecks": [],
+        "recommendations": [],
+    }
+
+    # Calculate risk score based on various factors
+    risk_factors = {
+        "circular_deps": len(circular_deps)
+        * 2.0,  # Each circular dep adds significant risk
+        "total_deps": len(dependencies) * 0.1,  # More dependencies = higher complexity
+        "community_cookbooks": len(community_cookbooks)
+        * 0.5,  # Community cookbooks need evaluation
+        "max_chain_length": _calculate_max_dependency_chain(dependencies)
+        * 0.3,  # Long chains are risky
+    }
+
+    impact["risk_score"] = min(10.0, sum(risk_factors.values()))
+
+    # Determine complexity level
+    if impact["risk_score"] > 7:
+        impact["complexity_level"] = "High"
+        impact["timeline_impact_weeks"] = 4
+    elif impact["risk_score"] > 4:
+        impact["complexity_level"] = "Medium"
+        impact["timeline_impact_weeks"] = 2
+    else:
+        impact["complexity_level"] = "Low"
+        impact["timeline_impact_weeks"] = 0
+
+    # Calculate parallel migration streams
+    if len(dependencies) > 20:
+        impact["parallel_streams"] = 3
+    elif len(dependencies) > 10:
+        impact["parallel_streams"] = 2
+    else:
+        impact["parallel_streams"] = 1
+
+    # Identify critical path (longest dependency chain)
+    impact["critical_path"] = _find_critical_path(dependencies)
+
+    # Identify bottlenecks (highly depended-upon cookbooks)
+    impact["bottlenecks"] = _identify_bottlenecks(dependencies)
+
+    # Generate recommendations
+    impact["recommendations"] = _generate_impact_recommendations(
+        impact, circular_deps, community_cookbooks
+    )
+
+    return impact
+
+
+def _calculate_max_dependency_chain(dependencies: Mapping[str, Sequence[str]]) -> int:
+    """Calculate the maximum dependency chain length."""
+    max_length = 0
+
+    def get_chain_length(cookbook, visited=None):
+        if visited is None:
+            visited = set()
+
+        if cookbook in visited:
+            return 0  # Circular dependency detected
+
+        visited.add(cookbook)
+        deps = dependencies.get(cookbook, [])
+
+        if not deps:
+            return 1
+
+        max_child_length = 0
+        for dep in deps:
+            child_length = get_chain_length(dep, visited.copy())
+            max_child_length = max(max_child_length, child_length)
+
+        return 1 + max_child_length
+
+    for cookbook in dependencies:
+        length = get_chain_length(cookbook)
+        max_length = max(max_length, length)
+
+    return max_length
+
+
+def _find_critical_path(dependencies: Mapping[str, Sequence[str]]) -> list[str]:
+    """Find the critical path (longest dependency chain)."""
+    longest_chain: list[str] = []
+
+    def find_longest_chain(cookbook, visited=None):
+        if visited is None:
+            visited = set()
+
+        if cookbook in visited:
+            return []  # Circular dependency
+
+        visited.add(cookbook)
+        deps = dependencies.get(cookbook, [])
 
+        if not deps:
+            return [cookbook]
+
+        longest_child_chain: list[str] = []
+        for dep in deps:
+            child_chain = find_longest_chain(dep, visited.copy())
+            if len(child_chain) > len(longest_child_chain):
+                longest_child_chain = child_chain
+
+        return [cookbook] + longest_child_chain
+
+    for cookbook in dependencies:
+        chain = find_longest_chain(cookbook)
+        if len(chain) > len(longest_chain):
+            longest_chain = chain
+
+    return longest_chain
+
+
+def _identify_bottlenecks(
+    dependencies: Mapping[str, Sequence[str]],
+) -> list[dict[str, Any]]:
+    """Identify bottleneck cookbooks (highly depended upon)."""
+    # Count how many times each cookbook is depended upon
+    dependency_counts: dict[str, int] = {}
+
+    for deps in dependencies.values():
+        for dep in deps:
+            dependency_counts[dep] = dependency_counts.get(dep, 0) + 1
+
+    # Find cookbooks with high dependency counts
+    bottlenecks = []
+    max_count: int = max(dependency_counts.values()) if dependency_counts else 0
+
+    for cookbook, count in dependency_counts.items():
+        if count >= 5:
+            risk_level = "High"
+        elif count >= 3:
+            risk_level = "Medium"
+        else:
+            risk_level = "Low"
+
+        if count >= 3 or (max_count > 1 and count == max_count):
+            bottlenecks.append(
+                {
+                    "cookbook": cookbook,
+                    "dependent_count": count,
+                    "risk_level": risk_level,
+                }
+            )
+
+    return sorted(bottlenecks, key=lambda x: x["dependent_count"], reverse=True)
+
+
+def _generate_impact_recommendations(
+    impact: Mapping[str, Any],
+    circular_deps: Sequence[tuple[str, str]],
+    community_cookbooks: Sequence[str],
+) -> list[dict[str, Any]]:
+    """Generate recommendations based on impact analysis."""
+    recommendations = []
+
+    if circular_deps:
+        recommendations.append(
+            {
+                "priority": "Critical",
+                "action": (
+                    f"Resolve {len(circular_deps)} circular dependencies "
+                    "before migration"
+                ),
+                "impact": "Prevents successful migration",
+            }
+        )
+
+    if impact["parallel_streams"] > 1:
+        recommendations.append(
+            {
+                "priority": "High",
+                "action": (
+                    f"Plan {impact['parallel_streams']} parallel migration streams"
+                ),
+                "impact": (
+                    f"Reduces timeline by ~{impact['parallel_streams'] * 2} weeks"
+                ),
+            }
+        )
+
+    if community_cookbooks:
+        recommendations.append(
+            {
+                "priority": "Medium",
+                "action": (
+                    f"Evaluate {len(community_cookbooks)} community cookbooks "
+                    "for Ansible Galaxy alternatives"
+                ),
+                "impact": "Reduces custom development effort",
+            }
+        )
+
+    if impact["bottlenecks"]:
+        bottleneck_names = [b["cookbook"] for b in impact["bottlenecks"][:3]]
+        recommendations.append(
+            {
+                "priority": "Medium",
+                "action": (
+                    f"Migrate bottleneck cookbooks first: {', '.join(bottleneck_names)}"
+                ),
+                "impact": "Unblocks dependent cookbook migrations",
+            }
+        )
+
+    if impact["timeline_impact_weeks"] > 0:
+        recommendations.append(
+            {
+                "priority": "Low",
+                "action": (
+                    f"Allocate additional {impact['timeline_impact_weeks']} "
+                    "weeks for complexity"
+                ),
+                "impact": "Ensures successful migration completion",
+            }
+        )
 
-def _handle_graph_caching():
-    """Handle graph data caching logic."""
-    # Cache control
-    with st.expander("⚙️ Graph Settings"):
+    return recommendations
+
+
+def _display_detailed_impact_analysis(
+    impact_analysis: Mapping[str, Any],
+    dependencies: Mapping[str, Sequence[str]],
+    circular_deps: Sequence[tuple[str, str]],
+    community_cookbooks: Sequence[str],
+) -> None:
+    """Display detailed impact analysis breakdown."""
+    _display_risk_assessment_breakdown(dependencies, circular_deps, community_cookbooks)
+    _display_critical_path_analysis(impact_analysis)
+    _display_migration_bottlenecks(impact_analysis)
+    _display_strategic_recommendations(impact_analysis)
+
+
+def _display_risk_assessment_breakdown(
+    dependencies: Mapping[str, Sequence[str]],
+    circular_deps: Sequence[tuple[str, str]],
+    community_cookbooks: Sequence[str],
+) -> None:
+    """Display risk assessment breakdown."""
+    st.markdown("### Risk Assessment Breakdown")
+
+    # Risk factors
+    risk_factors = {
+        "Circular Dependencies": len(circular_deps) * 2.0,
+        "Total Dependencies": len(dependencies) * 0.1,
+        "Community Cookbooks": len(community_cookbooks) * 0.5,
+        "Dependency Chain Length": _calculate_max_dependency_chain(dependencies) * 0.3,
+    }
+
+    for factor, score in risk_factors.items():
+        if score > 0:
+            st.write(f"• **{factor}**: {score:.1f} points")
+
+
+def _display_critical_path_analysis(impact_analysis: Mapping[str, Any]) -> None:
+    """Display critical path analysis."""
+    st.markdown("### Critical Path Analysis")
+    if impact_analysis["critical_path"]:
+        st.write("**Longest dependency chain:**")
+        st.code(" → ".join(impact_analysis["critical_path"]), language="text")
+    else:
+        st.write("No dependency chains identified.")
+
+
+def _display_migration_bottlenecks(impact_analysis: Mapping[str, Any]) -> None:
+    """Display migration bottlenecks."""
+    st.markdown("### Migration Bottlenecks")
+    if impact_analysis["bottlenecks"]:
+        for bottleneck in impact_analysis["bottlenecks"]:
+            risk_level = bottleneck["risk_level"]
+            if risk_level == "High":
+                risk_icon = "HIGH"
+            elif risk_level == "Medium":
+                risk_icon = "MEDIUM"
+            else:
+                risk_icon = "LOW"
+            st.write(
+                f"• {risk_icon} **{bottleneck['cookbook']}**: "
+                f"{bottleneck['dependent_count']} dependents "
+                f"({risk_level} risk)"
+            )
+    else:
+        st.write("No significant bottlenecks identified.")
+
+
+def _display_strategic_recommendations(impact_analysis: Mapping[str, Any]) -> None:
+    """Display strategic recommendations."""
+    st.markdown("### Strategic Recommendations")
+    for rec in impact_analysis["recommendations"]:
+        priority = rec["priority"]
+        if priority == "Critical":
+            priority_icon = "CRITICAL"
+        elif priority == "High":
+            priority_icon = "HIGH"
+        else:
+            priority_icon = "MEDIUM"
+        st.write(f"• {priority_icon} **{priority}**: {rec['action']}")
+        st.write(f"  *Impact*: {rec['impact']}")
+
+
+def _handle_graph_caching() -> None:
+    """Handle graph caching controls and cleanup."""
+    st.subheader("Graph Cache Management")
+
+    col1, col2, col3 = st.columns([1, 1, 2])
+
+    with col1:
+        # Toggle caching on/off
         cache_enabled = st.checkbox(
             "Enable Graph Caching",
             value=st.session_state.get("graph_cache_enabled", True),
-            help="Cache graph data to improve performance for repeated views",
+            help="Cache graph visualizations to improve performance for repeated views",
         )
-        st.session_state["graph_cache_enabled"] = cache_enabled
+        st.session_state.graph_cache_enabled = cache_enabled
 
+    with col2:
+        # Clear cache button
         if st.button(
-            "🗑️ Clear Graph Cache", help="Clear cached graph data to free memory"
+            "Clear Cache", help="Clear all cached graph data", key="clear_cache"
         ):
-            # Clear all cached graphs
-            keys_to_remove = [k for k in st.session_state if k.startswith("graph_")]
-            for key in keys_to_remove:
+            # Find and remove all graph cache keys
+            cache_keys = [key for key in st.session_state if key.startswith("graph_")]
+            for key in cache_keys:
                 del st.session_state[key]
-            st.success("Graph cache cleared!")
+            st.success(f"Cleared {len(cache_keys)} cached graphs")
             st.rerun()
 
+    with col3:
+        # Cache statistics
+        cache_keys = [key for key in st.session_state if key.startswith("graph_")]
+        cache_count = len(cache_keys)
+
+        if cache_count > 0:
+            # Estimate memory usage (rough approximation)
+            estimated_memory = cache_count * 50  # Rough estimate: 50KB per cached graph
+            st.metric(
+                "Cached Graphs",
+                f"{cache_count} items",
+                f"~{estimated_memory}KB estimated",
+            )
+        else:
+            st.info("📭 No graphs currently cached")
+
+    # Cache status indicator
+    if cache_enabled:
+        st.success(
+            "Graph caching is enabled - visualizations will be "
+            "cached for faster loading"
+        )
+    else:
+        st.warning(
+            "Graph caching is disabled - each visualization will be recalculated"
+        )
+
 
-def _display_dependency_graph_visualization(analysis_result, viz_type, selected_layout):
-    """Display the dependency graph visualization section."""
+def _display_dependency_graph_visualization(
+    analysis_result: str,
+    viz_type: str,
+    selected_layout: str,
+    show_circular_only: bool,
+    show_community_only: bool,
+    min_connections: int,
+) -> None:
+    """Display the dependency graph visualization section with filtering."""
     try:
-        # Create cache key for graph data
-        cache_key = f"graph_{hash(analysis_result)}_{viz_type}_{selected_layout}"
+        # Parse dependencies for filtering
+        _, circular_deps, _ = _parse_dependency_analysis(analysis_result)
+
+        # Prepare filters
+        filters = {
+            "circular_only": show_circular_only,
+            "community_only": show_community_only,
+            "min_connections": min_connections,
+            "circular_deps": circular_deps,
+        }
 
-        # Check if we have cached graph data
-        if cache_key in st.session_state and st.session_state.get(
-            "graph_cache_enabled", True
-        ):
-            graph_data = st.session_state[cache_key]
-            st.info("📋 Using cached graph data")
-        else:
-            # Create dependency graph
+        # Try to get cached graph data
+        graph_data = _get_cached_graph_data(
+            analysis_result, viz_type, selected_layout, filters
+        )
+
+        if graph_data is None:
+            # Create dependency graph with filters
             graph_data = create_dependency_graph(
-                analysis_result, viz_type, selected_layout
+                analysis_result, viz_type, selected_layout, filters
             )
-
             # Cache the result
-            if graph_data is not None and st.session_state.get(
-                "graph_cache_enabled", True
-            ):
-                st.session_state[cache_key] = graph_data
-
-        _handle_graph_caching()
+            _cache_graph_data(
+                analysis_result, viz_type, selected_layout, filters, graph_data
+            )
 
         if graph_data:
             _display_graph_with_export_options(graph_data, viz_type)
         else:
-            st.info("No dependency relationships found to visualize.")
+            st.info(
+                "No dependency relationships found to visualise after applying filters."
+            )
 
     except Exception as e:
         _handle_graph_visualization_error(e, analysis_result)
 
 
-def _display_graph_with_export_options(graph_data, viz_type):
+def _get_cached_graph_data(
+    analysis_result: str,
+    viz_type: str,
+    selected_layout: str,
+    filters: Mapping[str, Any],
+) -> Any | None:
+    """Get cached graph data if available."""
+    cache_key = (
+        f"graph_{hash(analysis_result)}_{viz_type}_{selected_layout}_{str(filters)}"
+    )
+
+    if cache_key in st.session_state and st.session_state.get(
+        "graph_cache_enabled", True
+    ):
+        graph_data = st.session_state[cache_key]
+        st.info("Using cached graph data")
+        return graph_data
+
+    return None
+
+
+def _cache_graph_data(
+    analysis_result: str,
+    viz_type: str,
+    selected_layout: str,
+    filters: Mapping[str, Any],
+    graph_data: Any,
+) -> None:
+    """Cache graph data if caching is enabled."""
+    if graph_data is not None and st.session_state.get("graph_cache_enabled", True):
+        cache_key = (
+            f"graph_{hash(analysis_result)}_{viz_type}_{selected_layout}_{str(filters)}"
+        )
+        st.session_state[cache_key] = graph_data
+
+
+def _display_graph_with_export_options(graph_data: Any, viz_type: str) -> None:
     """Display graph and provide export options."""
     if viz_type == "interactive":
         # Interactive Plotly graph
-        st.plotly_chart(graph_data, use_container_width=True)
+        st.plotly_chart(graph_data, width="stretch")
 
         # Export options for interactive graph
         st.subheader("Export Graph")
-        col1, col2, col3 = st.columns(3)
+        col1, col2, col3, col4 = st.columns(4)
 
         with col1:
             # Export as HTML
             html_content = graph_data.to_html(full_html=False, include_plotlyjs="cdn")
             st.download_button(
-                label="📄 Export as HTML",
+                label="HTML",
                 data=html_content,
                 file_name="dependency_graph.html",
                 mime="text/html",
@@ -1201,7 +2054,7 @@ def _display_graph_with_export_options(graph_data, viz_type):
             # Export as JSON
             json_data = graph_data.to_json()
             st.download_button(
-                label="📊 Export as JSON",
+                label="JSON",
                 data=json_data,
                 file_name="dependency_graph.json",
                 mime=MIME_APPLICATION_JSON,
@@ -1211,26 +2064,42 @@ def _display_graph_with_export_options(graph_data, viz_type):
         with col3:
             # Export as PNG (requires kaleido)
             try:
-                import plotly.io as pio  # type: ignore[import-untyped]
+                import plotly.io as pio
 
-                png_data = pio.to_image(graph_data, format="png")
+                png_data = pio.to_image(graph_data, format="png", scale=2)
                 st.download_button(
-                    label="🖼️ Export as PNG",
+                    label="PNG (High-res)",
                     data=png_data,
                     file_name="dependency_graph.png",
                     mime="image/png",
-                    help="Download graph as PNG image",
+                    help="Download graph as high-resolution PNG",
                 )
             except ImportError:
                 st.info("PNG export requires additional dependencies")
 
+        with col4:
+            # Export as PDF
+            try:
+                import plotly.io as pio
+
+                pdf_data = pio.to_image(graph_data, format="pdf")
+                st.download_button(
+                    label="PDF",
+                    data=pdf_data,
+                    file_name="dependency_graph.pdf",
+                    mime="application/pdf",
+                    help="Download graph as PDF document",
+                )
+            except ImportError:
+                st.info("PDF export requires additional dependencies")
+
     else:
         # Static matplotlib graph
         st.pyplot(graph_data)
 
         # Export options for static graph
         st.subheader("Export Graph")
-        col1, col2 = st.columns(2)
+        col1, col2, col3, col4 = st.columns(4)
 
         with col1:
             # Export as PNG
@@ -1240,7 +2109,7 @@ def _display_graph_with_export_options(graph_data, viz_type):
             graph_data.savefig(buf, format="png", dpi=300, bbox_inches="tight")
             buf.seek(0)
             st.download_button(
-                label="🖼️ Export as PNG",
+                label="PNG (High-res)",
                 data=buf.getvalue(),
                 file_name="dependency_graph.png",
                 mime="image/png",
@@ -1253,17 +2122,43 @@ def _display_graph_with_export_options(graph_data, viz_type):
             graph_data.savefig(buf_svg, format="svg", bbox_inches="tight")
             buf_svg.seek(0)
             st.download_button(
-                label="📈 Export as SVG",
+                label="SVG",
                 data=buf_svg.getvalue(),
                 file_name="dependency_graph.svg",
                 mime="image/svg+xml",
                 help="Download graph as scalable SVG",
             )
 
+        with col3:
+            # Export as PDF
+            buf_pdf = io.BytesIO()
+            graph_data.savefig(buf_pdf, format="pdf", bbox_inches="tight")
+            buf_pdf.seek(0)
+            st.download_button(
+                label="PDF",
+                data=buf_pdf.getvalue(),
+                file_name="dependency_graph.pdf",
+                mime="application/pdf",
+                help="Download graph as PDF document",
+            )
+
+        with col4:
+            # Export as EPS
+            buf_eps = io.BytesIO()
+            graph_data.savefig(buf_eps, format="eps", bbox_inches="tight")
+            buf_eps.seek(0)
+            st.download_button(
+                label="EPS",
+                data=buf_eps.getvalue(),
+                file_name="dependency_graph.eps",
+                mime="application/postscript",
+                help="Download graph as EPS vector format",
+            )
 
-def _handle_graph_visualization_error(error, analysis_result):
+
+def _handle_graph_visualization_error(error: Exception, analysis_result: str) -> None:
     """Handle graph visualization errors with fallback display."""
-    st.error("❌ **Graph Visualization Error**")
+    st.error("**Graph Visualization Error**")
     with st.expander("Error Details"):
         st.code(str(error), language="text")
         st.markdown("""
@@ -1279,7 +2174,7 @@ def _handle_graph_visualization_error(error, analysis_result):
         """)
 
     # Fallback: show text summary
-    st.info("📄 Showing text-based dependency summary instead:")
+    st.info("Showing text-based dependency summary instead:")
     st.text_area(
         "Dependency Analysis Text",
         analysis_result,
@@ -1288,7 +2183,7 @@ def _handle_graph_visualization_error(error, analysis_result):
     )
 
 
-def _display_dependency_analysis_sections(analysis_result):
+def _display_dependency_analysis_sections(analysis_result: str) -> None:
     """Display dependency analysis results in expandable sections."""
     # Split analysis into sections
     sections = analysis_result.split("\n## ")
@@ -1300,33 +2195,38 @@ def _display_dependency_analysis_sections(analysis_result):
 
             # Add expanders for different sections
             if "Migration Order Recommendations" in section:
-                with st.expander("📋 Migration Order Recommendations"):
+                with st.expander("Migration Order Recommendations"):
                     st.markdown(
                         section.replace("## Migration Order Recommendations", "")
                     )
             elif "Dependency Graph" in section:
-                with st.expander("🔗 Dependency Graph"):
+                with st.expander("Dependency Graph"):
                     st.markdown(section.replace("## Dependency Graph", ""))
-            elif "Circular Dependencies" in section:
-                with st.expander(f"⚠️ {SECTION_CIRCULAR_DEPENDENCIES}"):
-                    st.markdown(section.replace("## Circular Dependencies", ""))
-            elif "Community Cookbooks" in section:
-                with st.expander("🌐 Community Cookbooks"):
-                    st.markdown(section.replace("## Community Cookbooks", ""))
-            elif "Migration Impact Analysis" in section:
-                with st.expander("📊 Migration Impact Analysis"):
-                    st.markdown(section.replace("## Migration Impact Analysis", ""))
+                with st.expander(f"{SECTION_CIRCULAR_DEPENDENCIES}"):
+                    st.markdown(
+                        section.replace(f"## {SECTION_CIRCULAR_DEPENDENCIES}", "")
+                    )
+                with st.expander(f"{SECTION_COMMUNITY_COOKBOOKS}"):
+                    st.markdown(
+                        section.replace(f"## {SECTION_COMMUNITY_COOKBOOKS}", "")
+                    )
+            elif SECTION_MIGRATION_IMPACT_ANALYSIS in section:
+                with st.expander(SECTION_MIGRATION_IMPACT_ANALYSIS):
+                    header_text = f"## {SECTION_MIGRATION_IMPACT_ANALYSIS}"
+                    st.markdown(section.replace(header_text, ""))
             else:
                 st.markdown(section)
 
 
-def _display_migration_recommendations(circular_deps, community_cookbooks, direct_deps):
+def _display_migration_recommendations(
+    circular_deps: int, community_cookbooks: int, direct_deps: int
+) -> None:
     """Display migration recommendations based on analysis results."""
     st.subheader("Migration Recommendations")
 
     if circular_deps > 0:
         st.error(
-            "⚠️ **Critical Issue**: Circular dependencies detected. "
+            "**Critical Issue**: Circular dependencies detected. "
             "Resolve before migration."
         )
         st.markdown("""
@@ -1339,7 +2239,7 @@ def _display_migration_recommendations(circular_deps, community_cookbooks, direc
 
     if community_cookbooks > 0:
         st.success(
-            f"✅ **Good News**: {community_cookbooks} community cookbooks identified."
+            f"**Good News**: {community_cookbooks} community cookbooks identified."
         )
         st.markdown("""
         **Recommendations:**
@@ -1349,7 +2249,7 @@ def _display_migration_recommendations(circular_deps, community_cookbooks, direc
         """)
 
     if direct_deps > 10:
-        st.warning("⚠️ **Complex Dependencies**: High dependency count detected.")
+        st.warning("**Complex Dependencies**: High dependency count detected.")
         st.markdown("""
         **Consider:**
         - Breaking down monolithic cookbooks
@@ -1358,15 +2258,26 @@ def _display_migration_recommendations(circular_deps, community_cookbooks, direc
         """)
 
 
+def health_check() -> dict[str, str]:
+    """Return health check information for the SousChef UI service."""
+    from souschef.core.constants import VERSION
+
+    return {
+        "status": "healthy",
+        "service": "souschef-ui",
+        "version": VERSION,
+    }
+
+
 def _display_dependency_export_options(
-    analysis_result,
-    cookbook_path,
-    depth,
-    direct_deps,
-    transitive_deps,
-    circular_deps,
-    community_cookbooks,
-):
+    analysis_result: str,
+    cookbook_path: str,
+    depth: str,
+    direct_deps: int,
+    transitive_deps: int,
+    circular_deps: int,
+    community_cookbooks: int,
+) -> None:
     """Display export options for dependency analysis."""
     st.subheader("Export Analysis")
 
@@ -1374,7 +2285,7 @@ def _display_dependency_export_options(
 
     with col1:
         st.download_button(
-            label="📥 Download Full Analysis",
+            label="Download Full Analysis",
             data=analysis_result,
             file_name="dependency_analysis.md",
             mime=MIME_TEXT_MARKDOWN,
@@ -1398,7 +2309,7 @@ def _display_dependency_export_options(
         import json
 
         st.download_button(
-            label="📊 Download JSON Summary",
+            label="Download JSON Summary",
             data=json.dumps(analysis_json, indent=2),
             file_name="dependency_analysis.json",
             mime=MIME_APPLICATION_JSON,
@@ -1406,13 +2317,10 @@ def _display_dependency_export_options(
         )
 
 
-def display_dependency_analysis_results():
-    """Display dependency analysis results."""
-    analysis_result = st.session_state.dep_analysis_result
-    cookbook_path = st.session_state.dep_cookbook_path
-    depth = st.session_state.dep_depth
-    viz_type = st.session_state.get("dep_viz_type", "text")
-
+def _display_dependency_analysis_summary(
+    analysis_result: str, cookbook_path: str, depth: str
+) -> None:
+    """Display dependency analysis summary section."""
     # Summary metrics
     st.subheader("Dependency Analysis Summary")
 
@@ -1427,38 +2335,201 @@ def display_dependency_analysis_results():
     )
 
     # Analysis depth indicator
-    st.info(f"Analysis performed with **{depth}** depth on: `{cookbook_path}`")
-
-    # Graph Visualization Section
-    if viz_type in ["graph", "interactive"]:
-        st.subheader("📊 Dependency Graph Visualization")
-
-        # Layout algorithm selector
-        layout_options = ["auto", "spring", "circular", "kamada_kawai"]
-        selected_layout = st.selectbox(
-            "Layout Algorithm",
-            layout_options,
-            help="Choose graph layout algorithm. 'auto' selects best "
-            "algorithm based on graph size.",
-            format_func=lambda x: {
-                "auto": "Auto (recommended)",
-                "spring": "Spring Layout",
-                "circular": "Circular Layout",
-                "kamada_kawai": "Kamada-Kawai Layout",
-            }.get(x, str(x)),
+    analysis_msg = f"Analysis performed with **{depth}** depth on: `{cookbook_path}`"
+    st.info(analysis_msg)
+
+
+def _display_graph_visualization_section(analysis_result: str, viz_type: str) -> None:
+    """Display graph visualization section."""
+    if viz_type not in ["graph", "interactive"]:
+        return
+
+    st.subheader("Dependency Graph Visualization")
+
+    # Parse dependencies for filtering and analysis
+    _ = _parse_dependency_analysis(analysis_result)
+
+    # Layout algorithm selector
+    layout_options = [
+        "auto",
+        "spring",
+        "circular",
+        "kamada_kawai",
+        "shell",
+        "spectral",
+        "force_directed",
+        "random",
+    ]
+    selected_layout = st.selectbox(
+        "Layout Algorithm",
+        layout_options,
+        help="Choose graph layout algorithm. 'auto' selects best "
+        "algorithm based on graph size.",
+        format_func=lambda x: {
+            "auto": "Auto (recommended)",
+            "spring": "Spring Layout",
+            "circular": "Circular Layout",
+            "kamada_kawai": "Kamada-Kawai Layout",
+            "shell": "Shell Layout (hierarchical)",
+            "spectral": "Spectral Layout",
+            "force_directed": "Force Directed",
+            "random": "Random Layout",
+        }.get(x, str(x)),
+    )
+
+    # Graph cache management
+    _handle_graph_caching()
+
+    # Graph Filtering Options
+    st.subheader("Graph Filtering & Analysis")
+
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        show_circular_only = st.checkbox(
+            "Show Circular Dependencies Only",
+            help=("Filter graph to show only nodes involved in circular dependencies"),
+        )
+
+    with col2:
+        show_community_only = st.checkbox(
+            "Show Community Cookbooks Only",
+            help=(
+                "Filter graph to show only community cookbooks and their dependencies"
+            ),
+        )
+
+    with col3:
+        min_connections = st.slider(
+            "Minimum Connections",
+            min_value=0,
+            max_value=10,
+            value=0,
+            help="Show only nodes with at least this many connections",
+        )
+
+    _display_dependency_graph_visualization(
+        analysis_result,
+        viz_type,
+        selected_layout,
+        show_circular_only,
+        show_community_only,
+        min_connections,
+    )
+
+
+def _display_impact_analysis_section(analysis_result: str) -> None:
+    """Display migration impact analysis section."""
+    # Parse dependencies for impact analysis
+    dependencies, circular_deps, community_cookbooks = _parse_dependency_analysis(
+        analysis_result
+    )
+
+    # Impact Analysis Section
+    st.subheader("Migration Impact Analysis")
+
+    if not dependencies:
+        st.info("No dependencies found for impact analysis.")
+        return
+
+    impact_analysis = _calculate_migration_impact(
+        dependencies, circular_deps, community_cookbooks
+    )
+
+    # Calculate risk score delta
+    risk_score = impact_analysis["risk_score"]
+    if risk_score > 7:
+        risk_delta = "High"
+    elif risk_score > 4:
+        risk_delta = "Medium"
+    else:
+        risk_delta = "Low"
+
+    col1, col2, col3, col4 = st.columns(4)
+
+    with col1:
+        st.metric(
+            "Migration Risk Score",
+            f"{impact_analysis['risk_score']:.1f}/10",
+            delta=risk_delta,
+        )
+
+    with col2:
+        timeline_weeks = impact_analysis["timeline_impact_weeks"]
+        timeline_delta = "Increase" if timeline_weeks > 0 else "Unchanged"
+        st.metric(
+            "Estimated Timeline Impact",
+            f"{timeline_weeks} weeks",
+            delta=timeline_delta,
         )
 
-        _display_dependency_graph_visualization(
-            analysis_result, viz_type, selected_layout
+    with col3:
+        complexity_level = impact_analysis["complexity_level"]
+        complexity_delta = "High" if complexity_level == "High" else "Low"
+        st.metric(
+            "Dependency Complexity",
+            complexity_level,
+            delta=complexity_delta,
         )
 
+    with col4:
+        parallel_streams = impact_analysis["parallel_streams"]
+        parallel_delta = "Multiple" if parallel_streams > 1 else "Single"
+        st.metric(
+            "Parallel Migration Streams",
+            parallel_streams,
+            delta=parallel_delta,
+        )
+
+    # Detailed impact breakdown
+    with st.expander("Detailed Impact Analysis"):
+        _display_detailed_impact_analysis(
+            impact_analysis, dependencies, circular_deps, community_cookbooks
+        )
+
+
+def _display_analysis_details_section(
+    analysis_result: str,
+    circular_deps: list[tuple[str, str]],
+    community_cookbooks: list[str],
+    direct_deps: int,
+) -> None:
+    """Display analysis details section."""
     # Display analysis results
     st.subheader("Dependency Analysis Details")
 
     _display_dependency_analysis_sections(analysis_result)
 
     # Migration recommendations
-    _display_migration_recommendations(circular_deps, community_cookbooks, direct_deps)
+    _display_migration_recommendations(
+        len(circular_deps), len(community_cookbooks), direct_deps
+    )
+
+
+def display_dependency_analysis_results() -> None:
+    """Display dependency analysis results."""
+    analysis_result = st.session_state.dep_analysis_result
+    cookbook_path = st.session_state.dep_cookbook_path
+    depth = st.session_state.dep_depth
+    viz_type = st.session_state.get("dep_viz_type", "text")
+
+    # Display summary section
+    _display_dependency_analysis_summary(analysis_result, cookbook_path, depth)
+
+    # Display graph visualization section
+    _display_graph_visualization_section(analysis_result, viz_type)
+
+    # Display impact analysis section
+    _display_impact_analysis_section(analysis_result)
+
+    # Display analysis details section
+    dependencies, circular_deps, community_cookbooks = _parse_dependency_analysis(
+        analysis_result
+    )
+    direct_deps = len(dependencies) if dependencies else 0
+    _display_analysis_details_section(
+        analysis_result, circular_deps, community_cookbooks, direct_deps
+    )
 
     # Export options
     _display_dependency_export_options(
@@ -1466,43 +2537,125 @@ def display_dependency_analysis_results():
         cookbook_path,
         depth,
         direct_deps,
-        transitive_deps,
-        circular_deps,
-        community_cookbooks,
+        len(dependencies) if dependencies else 0,  # transitive_deps approximation
+        len(circular_deps),
+        len(community_cookbooks),
     )
 
 
-def show_validation_reports():
-    """Show validation reports and conversion validation."""
-    st.header("Validation Reports")
+def _collect_files_to_validate(input_path: str) -> list[Path]:
+    """Collect valid YAML files from input path."""
+    validated_path = _normalize_and_validate_input_path(input_path)
+    if validated_path is None:
+        # Error already reported by _normalize_and_validate_input_path
+        return []
 
-    # Import validation functions
-    from souschef.core.validation import ValidationEngine
+    path_obj = validated_path
+    files_to_validate = []
 
-    st.markdown("""
-    Validate Chef to Ansible conversions and generate comprehensive
-    validation reports for migration quality assurance.
-    """)
+    if not path_obj.exists():
+        st.error(f"Path does not exist: {path_obj}")
+        return []
+
+    if path_obj.is_file():
+        if path_obj.suffix in [".yml", ".yaml"] and path_obj.name not in [
+            ".kitchen.yml",
+            "kitchen.yml",
+            "docker-compose.yml",
+        ]:
+            files_to_validate.append(path_obj)
+    elif path_obj.is_dir():
+        # Filter out obvious non-playbook files
+        excluded_files = {".kitchen.yml", "kitchen.yml", "docker-compose.yml"}
+
+        yml_files = list(path_obj.glob("**/*.yml"))
+        yaml_files = list(path_obj.glob("**/*.yaml"))
+
+        raw_files = yml_files + yaml_files
+        files_to_validate.extend([f for f in raw_files if f.name not in excluded_files])
+
+    return files_to_validate
+
+
+def _run_validation_engine(files_to_validate: Sequence[Path]) -> list[Any]:
+    """Run validation engine on a list of files."""
+    from souschef.core.validation import (
+        ValidationCategory,
+        ValidationEngine,
+        ValidationLevel,
+        ValidationResult,
+    )
 
-    # Validation options
+    engine = ValidationEngine()
+    all_results = []
+
+    for file_path in files_to_validate:
+        try:
+            content = file_path.read_text()
+            # We assume 'recipe' (Playbook) conversion type for .yml files found
+            file_results = engine.validate_conversion("recipe", content)
+
+            # If no issues found, explicitly add a success record
+            if not file_results:
+                file_results = [
+                    ValidationResult(
+                        ValidationLevel.INFO,
+                        ValidationCategory.SYNTAX,
+                        "File passed all validation checks",
+                        location=file_path.name,
+                    )
+                ]
+
+            # Annotate results with location if missing
+            for res in file_results:
+                if not res.location:
+                    res.location = file_path.name
+
+            all_results.extend(file_results)
+        except Exception as file_err:
+            st.warning(f"Could not read/validate {file_path.name}: {file_err}")
+
+    return all_results
+
+
+def _get_default_validation_path() -> str:
+    """Determine the default path for validation from session state."""
+    default_path = ""
+    if "converted_playbooks_path" in st.session_state:
+        default_path = st.session_state.converted_playbooks_path
+        st.info(f"Pre-filled path from conversion: {default_path}")
+    elif (
+        "analysis_cookbook_path" in st.session_state
+        and st.session_state.analysis_cookbook_path
+    ):
+        default_path = st.session_state.analysis_cookbook_path
+        st.info(f"Pre-filled path from analysis: {default_path}")
+        st.caption(
+            "Note: This tool validates Ansible playbooks (.yml). If you're using a raw "
+            "Chef cookbook path, please ensure you've performed the conversion first."
+        )
+    return default_path
+
+
+def _render_validation_options_ui() -> tuple[str, str]:
+    """Render validation scope and format options."""
     col1, col2 = st.columns(2)
 
     with col1:
-        validation_type = st.selectbox(
-            "Validation Type",
-            ["syntax", "logic", "security", "performance", "full"],
-            help="Type of validation to perform",
-            format_func=lambda x: {
-                "syntax": "Syntax Validation",
-                "logic": "Logic & Structure Validation",
-                "security": "Security Best Practices",
-                "performance": "Performance Analysis",
-                "full": "Complete Validation Suite",
-            }.get(x, str(x)),
+        sub_scope = st.selectbox(
+            "Validation Scope",
+            [
+                "Full Suite",
+                "Syntax Only",
+                "Logic/Semantic",
+                "Security",
+                SCOPE_BEST_PRACTICES,
+            ],
+            help="Filter which validation checks to run",
         )
 
     with col2:
-        output_format = st.selectbox(
+        sub_format = st.selectbox(
             "Output Format",
             ["text", "json", "html"],
             help="Format for validation reports",
@@ -1512,8 +2665,11 @@ def show_validation_reports():
                 "html": "HTML Report",
             }.get(x, str(x)),
         )
+    return sub_scope, sub_format
+
 
-    # File/Directory input
+def _render_validation_input_ui(default_path: str) -> str:
+    """Render input source selection UI."""
     st.subheader("Input Source")
 
     input_type = st.radio(
@@ -1526,17 +2682,24 @@ def show_validation_reports():
     if input_type == "Directory":
         input_path = st.text_input(
             "Directory Path",
+            value=default_path,
             placeholder="/path/to/ansible/playbooks",
             help="Path to directory containing Ansible playbooks to validate",
         )
     else:
         input_path = st.text_input(
             "File Path",
+            value=default_path
+            if default_path and default_path.endswith((".yml", ".yaml"))
+            else "",
             placeholder="/path/to/playbook.yml",
             help="Path to single Ansible playbook file to validate",
         )
+    return input_path
 
-    # Validation options
+
+def _render_validation_settings_ui() -> tuple[bool, bool, bool]:
+    """Render strict mode and other validation settings."""
     st.subheader("Validation Options")
 
     col1, col2, col3 = st.columns(3)
@@ -1548,7 +2711,7 @@ def show_validation_reports():
 
     with col2:
         include_best_practices = st.checkbox(
-            "Include Best Practices",
+            f"Include {SCOPE_BEST_PRACTICES}",
             value=True,
             help="Check for Ansible best practices",
         )
@@ -1560,69 +2723,163 @@ def show_validation_reports():
             help="Provide improvement suggestions",
         )
 
-    # Validation button
-    if st.button("Run Validation", type="primary", use_container_width=True):
-        if not input_path.strip():
-            st.error("Please enter a path to validate.")
+    return strict_mode, include_best_practices, generate_recommendations
+
+
+def _normalize_and_validate_input_path(input_path: str) -> Path | None:
+    """
+    Normalize and validate a user-provided filesystem path.
+
+    Returns a resolved Path object if valid, otherwise reports an error
+    via Streamlit and returns None.
+    """
+    if not input_path:
+        st.error(ERROR_MSG_ENTER_PATH)
+        return None
+
+    raw = input_path.strip()
+    if not raw:
+        st.error(ERROR_MSG_ENTER_PATH)
+        return None
+
+    try:
+        # Expand user home and resolve to an absolute, normalized path
+        path_obj = Path(raw).expanduser().resolve()
+    except Exception:
+        st.error(f"Invalid path: {raw}")
+        return None
+
+    # Optional safety: constrain to the application root directory
+    try:
+        app_root = Path(app_path).resolve()
+        path_obj.relative_to(app_root)
+    except Exception:
+        st.error("Path must be within the SousChef project directory.")
+        return None
+
+    return path_obj
+
+
+def _handle_validation_execution(input_path: str, options: Mapping[str, Any]) -> None:
+    """Execute the validation process with progress tracking."""
+    progress_tracker = ProgressTracker(
+        total_steps=6, description="Running validation..."
+    )
+
+    try:
+        progress_tracker.update(1, "Preparing validation environment...")
+
+        progress_tracker.update(2, "Scanning input files...")
+
+        files_to_validate = _collect_files_to_validate(input_path)
+
+        if not files_to_validate:
+            # Error is handled inside _collect_files_to_validate
+            # if path doesn't exist or is invalid
+            validated_path = _normalize_and_validate_input_path(input_path)
+            if validated_path is not None and validated_path.exists():
+                st.warning(f"No YAML files found in {validated_path}")
             return
 
-        # Create progress tracker
-        progress_tracker = ProgressTracker(
-            total_steps=6, description="Running validation..."
+        progress_tracker.update(3, f"Validating {len(files_to_validate)} files...")
+
+        all_results = _run_validation_engine(files_to_validate)
+
+        # Filter results based on scope
+        filtered_results = _filter_results_by_scope(all_results, options["scope"])
+
+        # Format the results as text
+        validation_result = "\n".join(
+            [
+                f"[{result.level.value.upper()}] {result.location}: {result.message}"
+                for result in filtered_results
+            ]
         )
 
-        try:
-            progress_tracker.update(1, "Preparing validation environment...")
-
-            # Prepare validation options
-            options = {
-                "strict": strict_mode,
-                "best_practices": include_best_practices,
-                "recommendations": generate_recommendations,
-                "format": output_format,
-            }
+        if not validation_result:
+            validation_result = "No issues found matching the selected scope."
 
-            progress_tracker.update(2, "Scanning input files...")
-            progress_tracker.update(3, "Running syntax validation...")
-            progress_tracker.update(4, "Performing logic checks...")
+        progress_tracker.update(5, "Generating validation report...")
 
-            # Run validation
-            engine = ValidationEngine()
-            validation_results = engine.validate_conversion(
-                validation_type, input_path.strip()
-            )
+        # Store results
+        st.session_state.validation_result = validation_result
+        st.session_state.validation_path = input_path.strip()
+        st.session_state.validation_type = options["scope"]
+        st.session_state.validation_options = options
 
-            # Format the results as text
-            validation_result = "\n".join(
-                [
-                    f"{result.level.value.upper()}: {result.message}"
-                    for result in validation_results
-                ]
-            )
+        progress_tracker.complete("Validation completed!")
+        st.success(f"Validation completed! Scanned {len(files_to_validate)} files.")
+        st.rerun()
 
-            progress_tracker.update(5, "Generating validation report...")
+    except Exception as e:
+        progress_tracker.close()
+        st.error(f"Error during validation: {e}")
 
-            # Store results
-            st.session_state.validation_result = validation_result
-            st.session_state.validation_path = input_path.strip()
-            st.session_state.validation_type = validation_type
-            st.session_state.validation_options = options
 
-            progress_tracker.complete("Validation completed!")
-            st.success("Validation completed successfully!")
-            st.rerun()
+def show_validation_reports() -> None:
+    """Show validation reports and conversion validation."""
+    st.header(NAV_VALIDATION_REPORTS)
 
-        except Exception as e:
-            progress_tracker.close()
-            st.error(f"Error during validation: {e}")
+    st.markdown("""
+    Validate Chef to Ansible conversions and generate comprehensive
+    validation reports for migration quality assurance.
+    """)
+
+    # Check for previously analyzed path to pre-fill
+    default_path = _get_default_validation_path()
+
+    # UI Components
+    validation_scope, output_format = _render_validation_options_ui()
+    input_path = _render_validation_input_ui(default_path)
+    strict_mode, include_best_practices, generate_recommendations = (
+        _render_validation_settings_ui()
+    )
+
+    # Validation button
+    if st.button(
+        "Run Validation", type="primary", width="stretch", key="run_validation"
+    ):
+        if not input_path or not input_path.strip():
+            st.error("Please enter a path to validate.")
             return
 
+        options = {
+            "strict": strict_mode,
+            "best_practices": include_best_practices,
+            "recommendations": generate_recommendations,
+            "scope": validation_scope,
+            "format": output_format,
+        }
+
+        _handle_validation_execution(input_path, options)
+
     # Display results if available
     if "validation_result" in st.session_state:
         display_validation_results()
 
 
-def _parse_validation_metrics(validation_result):
+def _filter_results_by_scope(results: list[Any], scope: str) -> list[Any]:
+    """Filter validation results based on selected scope."""
+    from souschef.core.validation import ValidationCategory
+
+    if scope == "Full Suite":
+        return results
+
+    scope_map = {
+        "Syntax Only": ValidationCategory.SYNTAX,
+        "Logic/Semantic": ValidationCategory.SEMANTIC,
+        "Security": ValidationCategory.SECURITY,
+        SCOPE_BEST_PRACTICES: ValidationCategory.BEST_PRACTICE,
+    }
+
+    target_category = scope_map.get(scope)
+    if not target_category:
+        return results
+
+    return [r for r in results if r.category == target_category]
+
+
+def _parse_validation_metrics(validation_result: str) -> tuple[int, int, int, int]:
     """Parse validation result to extract key metrics."""
     lines = validation_result.split("\n")
 
@@ -1632,20 +2889,35 @@ def _parse_validation_metrics(validation_result):
     total_checks = 0
 
     for line in lines:
-        if "ERROR:" in line.upper():
+        line_upper = line.upper()
+        # Match both old format "ERROR:" and new format "[ERROR]"
+        if "ERROR:" in line_upper or "[ERROR]" in line_upper:
             errors += 1
-        elif "WARNING:" in line.upper():
+        elif "WARNING:" in line_upper or "[WARNING]" in line_upper:
             warnings += 1
-        elif "PASSED:" in line.upper() or "✓" in line:
+        # Match explicit passed check or INFO level (which we use for success now)
+        elif (
+            "PASSED:" in line_upper
+            or "PASSED" in line_upper
+            or "✓" in line
+            or "[INFO]" in line_upper
+        ):
             passed += 1
         if "Total checks:" in line.lower():
             with contextlib.suppress(ValueError):
                 total_checks = int(line.split(":")[1].strip())
 
+    # If we found errors/warnings but no explicit "checks" count (legacy log parsing),
+    # infer total checks from line items
+    if total_checks == 0 and (errors > 0 or warnings > 0 or passed > 0):
+        total_checks = errors + warnings + passed
+
     return errors, warnings, passed, total_checks
 
 
-def _display_validation_summary_metrics(errors, warnings, passed, total_checks):
+def _display_validation_summary_metrics(
+    errors: int, warnings: int, passed: int, total_checks: int
+) -> None:
     """Display validation summary metrics."""
     col1, col2, col3, col4 = st.columns(4)
 
@@ -1653,28 +2925,28 @@ def _display_validation_summary_metrics(errors, warnings, passed, total_checks):
         st.metric("Total Checks", total_checks)
 
     with col2:
-        st.metric("Passed", passed, delta="✅" if passed > 0 else "")
+        st.metric("Passed", passed, delta="Pass" if passed > 0 else "")
 
     with col3:
-        st.metric("Warnings", warnings, delta="⚠️" if warnings > 0 else "")
+        st.metric("Warnings", warnings, delta="Warning" if warnings > 0 else "")
 
     with col4:
-        st.metric("Errors", errors, delta="❌" if errors > 0 else "")
+        st.metric("Errors", errors, delta="Error" if errors > 0 else "")
 
 
-def _display_validation_status(errors, warnings):
+def _display_validation_status(errors: int, warnings: int) -> None:
     """Display overall validation status."""
     if errors > 0:
-        st.error("❌ **Validation Failed**: Critical issues found that need attention.")
+        st.error("**Validation Failed**: Critical issues found that need attention.")
     elif warnings > 0:
         st.warning(
-            "⚠️ **Validation Passed with Warnings**: Review warnings before proceeding."
+            "**Validation Passed with Warnings**: Review warnings before proceeding."
         )
     else:
-        st.success("✅ **Validation Passed**: All checks successful!")
+        st.success("**Validation Passed**: All checks successful!")
 
 
-def _display_validation_sections(validation_result):
+def _display_validation_sections(validation_result: str) -> None:
     """Display validation results in expandable sections."""
     # Split results into sections
     sections = validation_result.split("\n## ")
@@ -1686,28 +2958,28 @@ def _display_validation_sections(validation_result):
 
             # Add expanders for different sections
             if "Syntax Validation" in section:
-                with st.expander("🔍 Syntax Validation"):
+                with st.expander("Syntax Validation"):
                     st.markdown(section.replace("## Syntax Validation", ""))
             elif "Logic Validation" in section:
-                with st.expander("🧠 Logic Validation"):
+                with st.expander("Logic Validation"):
                     st.markdown(section.replace("## Logic Validation", ""))
             elif "Security Validation" in section:
-                with st.expander("🔒 Security Validation"):
+                with st.expander("Security Validation"):
                     st.markdown(section.replace("## Security Validation", ""))
             elif "Performance Validation" in section:
-                with st.expander("⚡ Performance Validation"):
+                with st.expander("Performance Validation"):
                     st.markdown(section.replace("## Performance Validation", ""))
-            elif "Best Practices" in section:
-                with st.expander("📋 Best Practices"):
-                    st.markdown(section.replace("## Best Practices", ""))
+            elif SCOPE_BEST_PRACTICES in section:
+                with st.expander(f"{SCOPE_BEST_PRACTICES}"):
+                    st.markdown(section.replace(f"## {SCOPE_BEST_PRACTICES}", ""))
             elif "Recommendations" in section:
-                with st.expander("💡 Recommendations"):
+                with st.expander("Recommendations"):
                     st.markdown(section.replace("## Recommendations", ""))
             else:
                 st.markdown(section)
 
 
-def _display_validation_action_items(errors, warnings):
+def _display_validation_action_items(errors: int, warnings: int) -> None:
     """Display action items based on validation results."""
     if errors > 0 or warnings > 0:
         st.subheader("Action Items")
@@ -1732,15 +3004,15 @@ def _display_validation_action_items(errors, warnings):
 
 
 def _display_validation_export_options(
-    validation_result,
-    input_path,
-    validation_type,
-    options,
-    errors,
-    warnings,
-    passed,
-    total_checks,
-):
+    validation_result: str,
+    input_path: str,
+    validation_type: str,
+    options: Mapping[str, Any],
+    errors: int,
+    warnings: int,
+    passed: int,
+    total_checks: int,
+) -> None:
     """Display export options for validation results."""
     st.subheader("Export Report")
 
@@ -1748,7 +3020,7 @@ def _display_validation_export_options(
 
     with col1:
         st.download_button(
-            label="📥 Download Full Report",
+            label="Download Full Report",
             data=validation_result,
             file_name="validation_report.md",
             mime=MIME_TEXT_MARKDOWN,
@@ -1780,7 +3052,7 @@ def _display_validation_export_options(
         import json
 
         st.download_button(
-            label="📊 Download JSON Summary",
+            label="Download JSON Summary",
             data=json.dumps(report_json, indent=2),
             file_name="validation_report.json",
             mime=MIME_APPLICATION_JSON,
@@ -1788,7 +3060,7 @@ def _display_validation_export_options(
         )
 
 
-def display_validation_results():
+def display_validation_results() -> None:
     """Display validation results."""
     validation_result = st.session_state.validation_result
     input_path = st.session_state.validation_path
@@ -1810,7 +3082,8 @@ def display_validation_results():
     _display_validation_status(errors, warnings)
 
     # Validation details
-    st.info(f"Validation type: **{validation_type}** | Path: `{input_path}`")
+    validation_msg = f"Validation type: **{validation_type}** | Path: `{input_path}`"
+    st.info(validation_msg)
 
     # Display validation results
     st.subheader("Validation Details")
@@ -1833,5 +3106,11 @@ def display_validation_results():
     )
 
 
+# UI code only when running under Streamlit
+if not os.environ.get("STREAMLIT_SERVER_PORT") and not os.environ.get(
+    "STREAMLIT_SERVER_HEADLESS"
+):
+    main()
+
 if __name__ == "__main__":
     main()