mermaid

app.py

@@ -3,24 +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"
-        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)."""
@@ -98,52 +115,128 @@ def solve_maximum_subset(dependencies, all_tasks):
 def parse_tasks(tasks_text):
     """Parse tasks from text input."""
     if not tasks_text.strip():
-        return []
+        return [], {}
     
     # Split by lines or commas and clean up
     tasks = []
-    for line in tasks_text.lower().strip().split('\n'):
-        for task in line.split(','):
-            task = task.strip()
-            if task and task not in tasks:
-                tasks.append(task)
+    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"
     
-    return sorted(tasks)
+    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 = parse_tasks(tasks_text)
-    task_choices = [""] + tasks  # Empty option first for single select
-    req_choices = tasks  # No empty option needed for multi-select
+    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_choices, value=""),
-        gr.CheckboxGroup(choices=req_choices, value=[])
+        gr.Dropdown(choices=task_display_choices, value=""),
+        gr.CheckboxGroup(choices=req_display_choices, value=[])
     )
 
-def add_dependencies(task, required_tasks, current_deps):
+def add_dependencies(task_display, required_display_list, current_deps):
     """Add multiple dependencies for a single task."""
-    if not task:
+    if not task_display:
         return current_deps, "⚠️ Please select a task"
     
-    if not required_tasks:
+    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
+    # Create new dependencies (using original display names)
     new_deps = []
     existing_deps = []
     
-    for req_task in required_tasks:
-        new_dep = f"{task} requires {req_task}"
-        if new_dep in current_deps:
-            existing_deps.append(req_task)
-        else:
-            new_deps.append(new_dep)
+    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"
@@ -178,35 +271,42 @@ def format_dependencies_display(dependencies_list):
     # Group by task for better readability
     task_deps = defaultdict(list)
     for dep in dependencies_list:
-        match = re.match(r'(\w+)\s+requires\s+(\w+)', dep)
-        if match:
-            task, required = match.groups()
+        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()):
-        requirements = ", ".join(sorted(task_deps[task]))
+    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 = parse_tasks(tasks_text)
+    tasks, task_original_names = parse_tasks(tasks_text)
     
     if not tasks:
-        return "❌ Please enter some 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"
-        for i, task in enumerate(tasks, 1):
-            output += f"{i}. {task}\n"
-        json_output = json.dumps(tasks, indent=2)
-        return output, "", json_output
+        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"
+        
+        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 = parse_requirements(dependencies_list)
+        dependencies, all_tasks, dep_original_names = parse_requirements(dependencies_list)
+        
+        # Merge original names
+        all_original_names = {**task_original_names, **dep_original_names}
         
         # Add any tasks that aren't in dependencies
         for task in tasks:
@@ -217,10 +317,13 @@ def solve_dependencies(tasks_text, dependencies_list):
         dep_summary = "**Parsed Dependencies:**\n"
         if dependencies:
             for task, deps in dependencies.items():
-                dep_summary += f"• {task} requires: {', '.join(deps)}\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:** {len(all_tasks)}\n"
-        dep_summary += f"**Tasks:** {', '.join(sorted(all_tasks))}"
+        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)
@@ -229,10 +332,16 @@ def solve_dependencies(tasks_text, dependencies_list):
             # 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)
             
-            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
@@ -242,23 +351,32 @@ def solve_dependencies(tasks_text, dependencies_list):
                 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 tasks
 example_tasks = """Sleep
@@ -275,13 +393,13 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
     # 🔄 Task Dependency Solver
     
-    Build task dependencies efficiently with multi-select requirements.
+    Build task dependencies efficiently with multi-select requirements. Now with **case-insensitive** matching and **Mermaid.js visualizations**!
     
     **How to use:**
     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
+    4. Click "Solve Dependencies" to get the optimal execution order with visualizations
     """)
     
     # State to store current dependencies
@@ -294,7 +412,8 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
                 label="Tasks (one per line or comma-separated)",
                 placeholder="Enter your tasks like:\nSleep\nDinner\nPrep\nShopping",
                 lines=6,
-                value=example_tasks
+                value=example_tasks,
+                info="Case-insensitive: 'Sleep' and 'sleep' are treated the same"
             )
             
             gr.Markdown("### 🔗 Step 2: Build Dependencies")
@@ -346,6 +465,21 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
             with gr.Accordion("💾 JSON Output", open=False):
                 json_output = gr.Code(language="json")
     
+    # 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():
@@ -357,21 +491,25 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
         **Click the buttons above to load example task sets!**
         
         Each example includes pre-defined tasks. After loading, you can quickly build dependencies using the multi-select interface.
+        
+        **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 = parse_tasks(tasks_text)
-        task_choices = [""] + tasks
-        req_choices = tasks
+        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_choices, value=""),  # task_dropdown
-            gr.CheckboxGroup(choices=req_choices, value=[]),  # requirements_checkbox
+            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
         )
     
@@ -452,7 +590,7 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
     solve_btn.click(
         fn=solve_dependencies,
         inputs=[tasks_input, dependencies_state],
-        outputs=[result_output, dep_analysis, json_output]
+        outputs=[result_output, dep_analysis, json_output, gantt_chart, dependency_flowchart]
     )
     
     # Example buttons