mermaid (#3)

- clau (29b68a9a286e8b56c7dbbb357b718753e5a47f51)
- mermaid (a9eb975d4673cabf23938b05bc50adc89bab502d)

app.py

@@ -3,25 +3,41 @@ import json
 import re
 from collections import defaultdict
 from ortools.sat.python import cp_model
+from datetime import datetime, timedelta
+
+def normalize_task_name(task):
+    """Normalize task name to lowercase for consistent comparison."""
+    return task.strip().lower()
+
+def display_task_name(task):
+    """Format task name for display (title case)."""
+    return task.replace('_', ' ').title()
 
 def parse_requirements(requirements):
     """Parse requirements list into dependency graph."""
     dependencies = defaultdict(list)
     all_tasks = set()
+    original_names = {}  # Store original casing
     
     for req in requirements:
         if not req.strip():
             continue
         # Match pattern like "TaskA requires TaskB"
-        req = req.lower()
-        match = re.match(r'(\w+)\s+requires\s+(\w+)', req.strip())
+        match = re.match(r'(\w+)\s+requires\s+(\w+)', req.strip(), re.IGNORECASE)
         if match:
-            task, required = match.groups()
+            task_orig, required_orig = match.groups()
+            task = normalize_task_name(task_orig)
+            required = normalize_task_name(required_orig)
+            
             all_tasks.add(task)
             all_tasks.add(required)
             dependencies[task].append(required)
+            
+            # Store original names for display
+            original_names[task] = task_orig
+            original_names[required] = required_orig
     
-    return dependencies, list(all_tasks)
+    return dependencies, list(all_tasks), original_names
 
 def solve_all_tasks(dependencies, all_tasks):
     """Try to schedule all tasks (works if DAG)."""
@@ -96,33 +112,218 @@ def solve_maximum_subset(dependencies, all_tasks):
     
     return []
 
-def solve_task_ordering_ui(requirements_text):
-    """Main function for Gradio interface."""
-    if not requirements_text.strip():
-        return "❌ Please enter some requirements!", "", ""
+def parse_tasks(tasks_text):
+    """Parse tasks from text input."""
+    if not tasks_text.strip():
+        return [], {}
     
-    try:
-        # Split by lines and filter empty lines
-        requirements = [line.strip() for line in requirements_text.strip().split('\n') if line.strip()]
+    # Split by lines or commas and clean up
+    tasks = []
+    original_names = {}
+    
+    for line in tasks_text.strip().split('\n'):
+        for task_orig in line.split(','):
+            task_orig = task_orig.strip()
+            if task_orig:
+                task = normalize_task_name(task_orig)
+                if task not in [normalize_task_name(t) for t in tasks]:
+                    tasks.append(task)
+                    original_names[task] = task_orig
+    
+    return sorted(tasks), original_names
+
+def generate_mermaid_gantt(task_order, original_names):
+    """Generate Mermaid Gantt chart syntax."""
+    if not task_order:
+        return "gantt\n    title Task Execution Timeline\n    dateFormat  YYYY-MM-DD\n    section No Tasks\n    No tasks to display : 2024-01-01, 1d"
+    
+    # Start from today
+    start_date = datetime.now()
+
+    gantt = "```mermaid\ngantt\n"
+    gantt += "    title Task Execution Timeline\n"
+    gantt += "    dateFormat  YYYY-MM-DD\n"
+    gantt += "    section Tasks\n"
+    
+    current_date = start_date
+    for i, task in enumerate(task_order):
+        display_name = original_names.get(task, display_task_name(task))
+        # Clean task name for Mermaid (remove special chars)
+        clean_name = re.sub(r'[^a-zA-Z0-9\s]', '', display_name)
+        
+        task_start = current_date.strftime("%Y-%m-%d")
+        current_date += timedelta(days=1)
+        
+        gantt += f"    {clean_name} : {task_start}, 1d\n"
+    
+    gantt += "```"
+    return gantt
+
+def generate_mermaid_flowchart(dependencies, all_tasks, original_names):
+    """Generate Mermaid flowchart syntax."""
+    if not all_tasks:
+        return "flowchart TD\n    A[No tasks to display]"
+    
+    flowchart = "```mermaid\nflowchart TD\n"
+    
+    # Create nodes for all tasks
+    for task in all_tasks:
+        display_name = original_names.get(task, display_task_name(task))
+        # Create a clean ID for the node
+        node_id = task.replace(' ', '_').replace('-', '_')
+        flowchart += f"    {node_id}[{display_name}]\n"
+    
+    # Add dependencies as edges
+    if dependencies:
+        for task, required_list in dependencies.items():
+            task_id = task.replace(' ', '_').replace('-', '_')
+            for required_task in required_list:
+                req_id = required_task.replace(' ', '_').replace('-', '_')
+                flowchart += f"    {req_id} --> {task_id}\n"
+    else:
+        # If no dependencies, just show all tasks
+        flowchart += "    style A fill:#e1f5fe\n"
+    
+    flowchart += "```"
+    return flowchart
+
+def update_dropdowns(tasks_text):
+    """Update dropdown choices when tasks change."""
+    tasks, original_names = parse_tasks(tasks_text)
+    
+    # Create display choices (original casing)
+    task_display_choices = [""] + [original_names.get(task, display_task_name(task)) for task in tasks]
+    req_display_choices = [original_names.get(task, display_task_name(task)) for task in tasks]
+    
+    return (
+        gr.Dropdown(choices=task_display_choices, value=""),
+        gr.CheckboxGroup(choices=req_display_choices, value=[])
+    )
+
+def add_dependencies(task_display, required_display_list, current_deps):
+    """Add multiple dependencies for a single task."""
+    if not task_display:
+        return current_deps, "⚠️ Please select a task"
+    
+    if not required_display_list:
+        return current_deps, "⚠️ Please select at least one requirement"
+    
+    # Normalize for comparison
+    task = normalize_task_name(task_display)
+    required_tasks = [normalize_task_name(req) for req in required_display_list]
+    
+    # Remove the selected task from requirements if somehow selected
+    required_tasks = [req for req in required_tasks if req != task]
+    
+    if not required_tasks:
+        return current_deps, "⚠️ A task cannot require itself"
+    
+    # Create new dependencies (using original display names)
+    new_deps = []
+    existing_deps = []
+    
+    for req_display in required_display_list:
+        if normalize_task_name(req_display) in required_tasks:
+            new_dep = f"{task_display} requires {req_display}"
+            
+            # Check if this dependency already exists (case-insensitive)
+            exists = any(
+                normalize_task_name(dep.split(' requires ')[0]) == task and 
+                normalize_task_name(dep.split(' requires ')[1]) == normalize_task_name(req_display)
+                for dep in current_deps if ' requires ' in dep
+            )
+            
+            if exists:
+                existing_deps.append(req_display)
+            else:
+                new_deps.append(new_dep)
+    
+    if not new_deps and existing_deps:
+        return current_deps, f"⚠️ All selected dependencies already exist"
+    
+    updated_deps = current_deps + new_deps
+    
+    # Create status message
+    status_parts = []
+    if new_deps:
+        status_parts.append(f"✅ Added {len(new_deps)} dependencies")
+    if existing_deps:
+        status_parts.append(f"⚠️ {len(existing_deps)} already existed")
+    
+    status = " | ".join(status_parts)
+    
+    return updated_deps, status
+
+def remove_dependency(deps_to_remove, current_deps):
+    """Remove selected dependencies."""
+    if not deps_to_remove:
+        return current_deps, "⚠️ Please select dependencies to remove"
+    
+    updated_deps = [dep for dep in current_deps if dep not in deps_to_remove]
+    removed_count = len(current_deps) - len(updated_deps)
+    return updated_deps, f"✅ Removed {removed_count} dependencies"
+
+def format_dependencies_display(dependencies_list):
+    """Format dependencies for display."""
+    if not dependencies_list:
+        return "No dependencies added yet."
+    
+    # Group by task for better readability
+    task_deps = defaultdict(list)
+    for dep in dependencies_list:
+        parts = dep.split(' requires ')
+        if len(parts) == 2:
+            task, required = parts
+            task_deps[task].append(required)
+    
+    display = "**Current Dependencies:**\n"
+    for task in sorted(task_deps.keys(), key=str.lower):
+        requirements = ", ".join(sorted(task_deps[task], key=str.lower))
+        display += f"• **{task}** requires: {requirements}\n"
+    
+    return display
+
+def solve_dependencies(tasks_text, dependencies_list):
+    """Solve the task ordering problem."""
+    tasks, task_original_names = parse_tasks(tasks_text)
+    
+    if not tasks:
+        return "❌ Please enter some tasks!", "", "", "", ""
+    
+    if not dependencies_list:
+        # No dependencies, just return tasks in alphabetical order
+        output = "✅ **No dependencies - alphabetical order:**\n\n"
+        display_tasks = [task_original_names.get(task, display_task_name(task)) for task in tasks]
+        for i, task_display in enumerate(display_tasks, 1):
+            output += f"{i}. {task_display}\n"
         
-        if not requirements:
-            return "❌ Please enter some requirements!", "", ""
+        json_output = json.dumps(display_tasks, indent=2)
+        gantt = generate_mermaid_gantt(tasks, task_original_names)
+        flowchart = generate_mermaid_flowchart({}, tasks, task_original_names)
+        return output, "", json_output, gantt, flowchart
+    
+    try:
+        dependencies, all_tasks, dep_original_names = parse_requirements(dependencies_list)
         
-        dependencies, all_tasks = parse_requirements(requirements)
+        # Merge original names
+        all_original_names = {**task_original_names, **dep_original_names}
         
-        if not all_tasks:
-            return "❌ No valid requirements found! Please use format: 'TaskA requires TaskB'", "", ""
+        # Add any tasks that aren't in dependencies
+        for task in tasks:
+            if task not in all_tasks:
+                all_tasks.append(task)
         
         # Create dependency summary
         dep_summary = "**Parsed Dependencies:**\n"
         if dependencies:
             for task, deps in dependencies.items():
-                dep_summary += f"• {task} requires: {', '.join(deps)}\n"
-        else:
-            dep_summary += "• No dependencies found\n"
+                task_display = all_original_names.get(task, display_task_name(task))
+                deps_display = [all_original_names.get(dep, display_task_name(dep)) for dep in deps]
+                dep_summary += f"• {task_display} requires: {', '.join(deps_display)}\n"
         
-        dep_summary += f"\n**Total tasks found:** {len(all_tasks)}\n"
-        dep_summary += f"**Tasks:** {', '.join(sorted(all_tasks))}"
+        dep_summary += f"\n**Total tasks:** {len(all_tasks)}\n"
+        task_displays = [all_original_names.get(task, display_task_name(task)) for task in sorted(all_tasks)]
+        dep_summary += f"**Tasks:** {', '.join(task_displays)}"
         
         # Try to solve
         result = solve_all_tasks(dependencies, all_tasks)
@@ -131,11 +332,16 @@ def solve_task_ordering_ui(requirements_text):
             # All tasks can be executed
             output = "✅ **All tasks can be executed!**\n\n"
             output += "**Optimal execution order:**\n"
+            
+            result_display = []
             for i, task in enumerate(result, 1):
-                output += f"{i}. {task}\n"
+                task_display = all_original_names.get(task, display_task_name(task))
+                output += f"{i}. {task_display}\n"
+                result_display.append(task_display)
             
-            # Create JSON output
-            json_output = json.dumps(result, indent=2)
+            json_output = json.dumps(result_display, indent=2)
+            gantt = generate_mermaid_gantt(result, all_original_names)
+            flowchart = generate_mermaid_flowchart(dependencies, all_tasks, all_original_names)
             
         else:
             # Try maximum subset
@@ -145,122 +351,269 @@ def solve_task_ordering_ui(requirements_text):
                 excluded_tasks = set(all_tasks) - set(result)
                 output = f"⚠️ **Circular dependencies detected!**\n\n"
                 output += f"**Maximum executable tasks ({len(result)}/{len(all_tasks)}):**\n"
+                
+                result_display = []
                 for i, task in enumerate(result, 1):
-                    output += f"{i}. {task}\n"
+                    task_display = all_original_names.get(task, display_task_name(task))
+                    output += f"{i}. {task_display}\n"
+                    result_display.append(task_display)
                 
                 if excluded_tasks:
                     output += f"\n**❌ Excluded tasks (due to circular dependencies):**\n"
                     for task in sorted(excluded_tasks):
-                        output += f"• {task}\n"
+                        task_display = all_original_names.get(task, display_task_name(task))
+                        output += f"• {task_display}\n"
                 
-                json_output = json.dumps(result, indent=2)
+                json_output = json.dumps(result_display, indent=2)
+                gantt = generate_mermaid_gantt(result, all_original_names)
+                flowchart = generate_mermaid_flowchart(dependencies, all_tasks, all_original_names)
             else:
                 output = "❌ **No solution found!** There might be complex circular dependencies."
                 json_output = "[]"
+                gantt = generate_mermaid_gantt([], all_original_names)
+                flowchart = generate_mermaid_flowchart(dependencies, all_tasks, all_original_names)
         
-        return output, dep_summary, json_output
+        return output, dep_summary, json_output, gantt, flowchart
         
     except Exception as e:
-        return f"❌ **Error:** {str(e)}", "", ""
+        return f"❌ **Error:** {str(e)}", "", "", "", ""
 
-# Example requirements
-example_requirements = """Sleep requires dinner
-Sleep requires toothbrushing
-Dinner requires prep
-Dinner requires clean_dining_room
-Prep requires shopping
-Shopping requires money
-Clean_dining_room requires cleaning_time"""
+# Example tasks
+example_tasks = """Sleep
+Dinner
+Toothbrushing
+Prep
+Shopping
+Money
+Clean_dining_room
+Cleaning_time"""
 
 # Create Gradio interface
 with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
     # 🔄 Task Dependency Solver
     
-    This tool helps you find the optimal order to execute tasks based on their dependencies.
+    Build task dependencies efficiently with multi-select requirements. Now with **case-insensitive** matching and **Mermaid.js visualizations**!
     
     **How to use:**
-    1. Enter your requirements, one per line
-    2. Use the format: `TaskA requires TaskB`
-    3. Click "Solve Dependencies" to get the optimal execution order
-    
-    **Features:**
-    - ✅ Finds optimal task ordering
-    - 🔄 Handles circular dependencies
-    - 📊 Maximizes the number of executable tasks
-    - 🎯 Uses Google OR-Tools constraint solver
+    1. Enter your tasks (one per line or comma-separated)
+    2. Select a task, then select all its requirements at once
+    3. Click "Add Dependencies" to add them all
+    4. Click "Solve Dependencies" to get the optimal execution order with visualizations
     """)
     
+    # State to store current dependencies
+    dependencies_state = gr.State([])
+    
     with gr.Row():
         with gr.Column(scale=1):
-            requirements_input = gr.Textbox(
-                label="Requirements (one per line)",
-                placeholder="Enter requirements like:\nTaskA requires TaskB\nTaskB requires TaskC",
-                lines=10,
-                value=example_requirements
+            gr.Markdown("### 📝 Step 1: Define Your Tasks")
+            tasks_input = gr.Textbox(
+                label="Tasks (one per line or comma-separated)",
+                placeholder="Enter your tasks like:\nSleep\nDinner\nPrep\nShopping",
+                lines=6,
+                value=example_tasks,
+                info="Case-insensitive: 'Sleep' and 'sleep' are treated the same"
             )
             
-            solve_btn = gr.Button("🚀 Solve Dependencies", variant="primary", size="lg")
+            gr.Markdown("### 🔗 Step 2: Build Dependencies")
+            task_dropdown = gr.Dropdown(
+                label="Select Task",
+                choices=[],
+                value="",
+                info="Choose the task that has requirements"
+            )
+            
+            requirements_checkbox = gr.CheckboxGroup(
+                label="Select Requirements (can select multiple)",
+                choices=[],
+                value=[],
+                info="Choose what the task requires"
+            )
+            
+            with gr.Row():
+                add_btn = gr.Button("➕ Add Dependencies", variant="primary", scale=2)
+                clear_all_btn = gr.Button("🗑️ Clear All", variant="secondary", scale=1)
+            
+            add_status = gr.Markdown("")
             
-            gr.Markdown("""
-            **Example formats:**
-            - `Sleep requires dinner`
-            - `Dinner requires prep`
-            - `Prep requires shopping`
-            """)
-        
         with gr.Column(scale=1):
-            result_output = gr.Markdown(label="Solution")
+            gr.Markdown("### 📋 Current Dependencies")
+            dependencies_display = gr.Markdown("No dependencies added yet.")
             
-            with gr.Accordion("📋 Dependency Analysis", open=False):
+            with gr.Accordion("🗑️ Remove Dependencies", open=False):
+                remove_deps = gr.CheckboxGroup(
+                    label="Select dependencies to remove:",
+                    choices=[],
+                    value=[]
+                )
+                
+                remove_btn = gr.Button("Remove Selected", variant="secondary")
+                remove_status = gr.Markdown("")
+    
+    gr.Markdown("### 🚀 Step 3: Solve")
+    solve_btn = gr.Button("🎯 Solve Dependencies", variant="primary", size="lg")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            result_output = gr.Markdown()
+        
+        with gr.Column(scale=1):
+            with gr.Accordion("📊 Analysis", open=False):
                 dep_analysis = gr.Markdown()
             
             with gr.Accordion("💾 JSON Output", open=False):
-                json_output = gr.Code(language="json", label="JSON Array")
+                json_output = gr.Code(language="json")
     
-    # Examples
-    with gr.Accordion("📚 Example Use Cases", open=False):
+    # Mermaid visualizations
+    gr.Markdown("### 📊 Visualizations")
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("#### 📅 Gantt Chart (Timeline)")
+            gantt_chart = gr.Markdown(
+                value="gantt\n    title Task Execution Timeline\n    dateFormat  YYYY-MM-DD\n    section Tasks\n    Click Solve to see timeline : 2024-01-01, 1d"
+            )
+        
+        with gr.Column(scale=1):
+            gr.Markdown("#### 🔀 Dependency Flowchart")
+            dependency_flowchart = gr.Markdown(
+                value="flowchart TD\n    A[Click Solve to see dependencies]"
+            )
+    
+    # Examples section
+    with gr.Accordion("📚 Quick Examples", open=False):
+        with gr.Row():
+            morning_btn = gr.Button("🌅 Morning Routine")
+            cooking_btn = gr.Button("🍳 Cooking Tasks")
+            project_btn = gr.Button("💼 Project Tasks")
+        
         gr.Markdown("""
-        **Morning Routine:**
-        ```
-        Leave_house requires breakfast
-        Leave_house requires dressed
-        Breakfast requires coffee
-        Coffee requires water
-        Dressed requires shower
-        Shower requires wake_up
-        ```
+        **Click the buttons above to load example task sets!**
         
-        **Software Deployment:**
-        ```
-        Deploy requires tests_pass
-        Deploy requires build_complete
-        Tests_pass requires code_review
-        Build_complete requires dependencies_installed
-        Code_review requires code_written
-        Dependencies_installed requires environment_setup
-        ```
+        Each example includes pre-defined tasks. After loading, you can quickly build dependencies using the multi-select interface.
         
-        **Circular Dependency Example:**
-        ```
-        A requires B
-        B requires C
-        C requires A
-        D requires E
-        ```
+        **Note:** All matching is case-insensitive. You can mix cases freely!
         """)
     
+    # Event handlers
+    def update_ui_after_tasks_change(tasks_text, current_deps):
+        """Update dropdowns and dependency checkboxes when tasks change."""
+        tasks, original_names = parse_tasks(tasks_text)
+        
+        # Create display choices (original casing)
+        task_display_choices = [""] + [original_names.get(task, display_task_name(task)) for task in tasks]
+        req_display_choices = [original_names.get(task, display_task_name(task)) for task in tasks]
+        
+        # Update dependency removal checkboxes
+        checkbox_choices = current_deps if current_deps else []
+        
+        return (
+            gr.Dropdown(choices=task_display_choices, value=""),  # task_dropdown
+            gr.CheckboxGroup(choices=req_display_choices, value=[]),  # requirements_checkbox
+            gr.CheckboxGroup(choices=checkbox_choices, value=[])  # remove_deps
+        )
+    
+    def handle_add_dependencies(task, required_tasks, current_deps):
+        """Handle adding dependencies and update UI."""
+        updated_deps, status = add_dependencies(task, required_tasks, current_deps)
+        display = format_dependencies_display(updated_deps)
+        checkbox_choices = updated_deps if updated_deps else []
+        
+        return (
+            updated_deps,  # dependencies_state
+            display,       # dependencies_display
+            status,        # add_status
+            gr.CheckboxGroup(choices=checkbox_choices, value=[]),  # remove_deps
+            "",           # task_dropdown (clear)
+            []            # requirements_checkbox (clear)
+        )
+    
+    def handle_remove_dependencies(deps_to_remove, current_deps):
+        """Handle removing dependencies and update UI."""
+        updated_deps, status = remove_dependency(deps_to_remove, current_deps)
+        display = format_dependencies_display(updated_deps)
+        checkbox_choices = updated_deps if updated_deps else []
+        
+        return (
+            updated_deps,  # dependencies_state
+            display,       # dependencies_display
+            status,        # remove_status
+            gr.CheckboxGroup(choices=checkbox_choices, value=[])  # remove_deps
+        )
+    
+    def clear_all_dependencies():
+        """Clear all dependencies."""
+        return (
+            [],  # dependencies_state
+            "No dependencies added yet.",  # dependencies_display
+            "✅ All dependencies cleared",  # add_status
+            gr.CheckboxGroup(choices=[], value=[])  # remove_deps
+        )
+    
+    # Example loaders
+    def load_morning_example():
+        tasks = "Wake_up\nShower\nBrush_teeth\nGet_dressed\nEat_breakfast\nMake_coffee\nLeave_house"
+        return tasks, [], "No dependencies added yet.", gr.CheckboxGroup(choices=[], value=[])
+    
+    def load_cooking_example():
+        tasks = "Shop_ingredients\nPrep_vegetables\nPreheat_oven\nCook_main_dish\nMake_sauce\nPlate_food\nServe_dinner"
+        return tasks, [], "No dependencies added yet.", gr.CheckboxGroup(choices=[], value=[])
+    
+    def load_project_example():
+        tasks = "Research\nPlan\nDesign\nDevelop\nTest\nDeploy\nDocument\nReview"
+        return tasks, [], "No dependencies added yet.", gr.CheckboxGroup(choices=[], value=[])
+    
+    # Wire up events
+    tasks_input.change(
+        fn=update_ui_after_tasks_change,
+        inputs=[tasks_input, dependencies_state],
+        outputs=[task_dropdown, requirements_checkbox, remove_deps]
+    )
+    
+    add_btn.click(
+        fn=handle_add_dependencies,
+        inputs=[task_dropdown, requirements_checkbox, dependencies_state],
+        outputs=[dependencies_state, dependencies_display, add_status, remove_deps, task_dropdown, requirements_checkbox]
+    )
+    
+    remove_btn.click(
+        fn=handle_remove_dependencies,
+        inputs=[remove_deps, dependencies_state],
+        outputs=[dependencies_state, dependencies_display, remove_status, remove_deps]
+    )
+    
+    clear_all_btn.click(
+        fn=clear_all_dependencies,
+        outputs=[dependencies_state, dependencies_display, add_status, remove_deps]
+    )
+    
     solve_btn.click(
-        fn=solve_task_ordering_ui,
-        inputs=[requirements_input],
-        outputs=[result_output, dep_analysis, json_output]
+        fn=solve_dependencies,
+        inputs=[tasks_input, dependencies_state],
+        outputs=[result_output, dep_analysis, json_output, gantt_chart, dependency_flowchart]
+    )
+    
+    # Example buttons
+    morning_btn.click(
+        fn=load_morning_example,
+        outputs=[tasks_input, dependencies_state, dependencies_display, remove_deps]
+    )
+    
+    cooking_btn.click(
+        fn=load_cooking_example,
+        outputs=[tasks_input, dependencies_state, dependencies_display, remove_deps]
+    )
+    
+    project_btn.click(
+        fn=load_project_example,
+        outputs=[tasks_input, dependencies_state, dependencies_display, remove_deps]
     )
     
-    # Auto-solve on load
+    # Initialize on load
     demo.load(
-        fn=solve_task_ordering_ui,
-        inputs=[requirements_input],
-        outputs=[result_output, dep_analysis, json_output]
+        fn=update_ui_after_tasks_change,
+        inputs=[tasks_input, dependencies_state],
+        outputs=[task_dropdown, requirements_checkbox, remove_deps]
     )
 
 if __name__ == "__main__":