feat(ui): add durations per task and copyable mermaid diagram text

- Adds an editable table for durations per task in minutes, with state storage
- uses per-task durations if provided
- Adds output code blocks to let user easily copy/paste the raw mermaid.js code for Gantt and flowchart visualizations
- UI in main gradio interface updated, including sync events

🤖 Generated with opencode
Co-Authored-By: opencode <noreply@opencode.ai>

OpenCode.md

@@ -1,10 +1,11 @@
 # OpenCode Guide for or-tools repo
 
 ## Commands
-- **Install deps:** `python -m venv .venv && . .venv/bin/activate && pip install -r requirements.txt`
-- **Lint:** `.venv/bin/ruff check app.py`
-- **Format:** `.venv/bin/ruff format app.py`
-- **Run Gradio app:** `python app.py`
+- **Install deps:** `uv sync`
+- **Add deps: `uv add dep`
+- **Lint:** `uv run ruff check app.py`
+- **Format:** `uv run ruff format app.py`
+- **Run Gradio app:** `uv run app.py`
 - **No tests currently found.**
 
 ## Code Style & Conventions
@@ -16,6 +17,6 @@
 - **Error handling:** Prefer informative exceptions & user messages. Wrap untrusted input in try/except when user-facing.
 - **Docstrings:** Use triple-double-quote for all public functions/classes. Prefer Google or NumPy style.
 - **No tests yet:** Place tests in files named `test_*.py` when adding.
-- **Dependencies:** Only add to `pyproject.toml`/`requirements.txt`.
+- **Dependencies:** Only add to `pyproject.toml`
 
 *See https://docs.astral.sh/ruff/ for further lint rules. Contribute new code in line with this guide.*

app.py

@@ -139,29 +139,39 @@ def parse_tasks(tasks_text):
     return sorted(tasks), original_names
 
 
-def generate_mermaid_gantt(task_order, original_names):
-    """Generate Mermaid Gantt chart syntax."""
+def generate_mermaid_gantt(task_order, original_names, durations=None, start_time=None):
+    """Generate Mermaid Gantt chart syntax with minute granularity and selectable start time."""
     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"
+        return "gantt\n    title Task Execution Timeline\n    dateFormat  YYYY-MM-DD HH:mm\n    section No Tasks\n    No tasks to display : 2024-01-01 08:00, 1m"
 
-    # Start from today
-    start_date = datetime.now()
+    if start_time is None:
+        start_date = datetime.now().replace(second=0, microsecond=0)
+    else:
+        start_date = start_time.replace(second=0, microsecond=0)
 
     gantt = "```mermaid\ngantt\n"
     gantt += "    title Task Execution Timeline\n"
-    gantt += "    dateFormat  YYYY-MM-DD\n"
+    gantt += "    dateFormat  YYYY-MM-DD HH:mm\n"
     gantt += "    section Tasks\n"
 
-    current_date = start_date
+    current_dt = 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)
+        # Get duration for this task in minutes (default 1m if not specified)
+        minutes = 1
+        if durations and task in durations:
+            minutes = durations[task]
+        elif durations is None:
+            minutes = 1
+        else:
+            minutes = durations.get(task, 1)
 
-        gantt += f"    {clean_name} : {task_start}, 1d\n"
+        task_start = current_dt.strftime("%Y-%m-%d %H:%M")
+        gantt += f"    {clean_name} : {task_start}, {minutes}m\n"
+        current_dt += timedelta(minutes=minutes)
 
     gantt += "```"
     return gantt
@@ -302,12 +312,17 @@ def format_dependencies_display(dependencies_list):
     return display
 
 
-def solve_dependencies(tasks_text, dependencies_list):
+def solve_dependencies(tasks_text, dependencies_list, durations_state=None):
     """Solve the task ordering problem."""
     tasks, task_original_names = parse_tasks(tasks_text)
 
+    durations = durations_state or {}
+    # durations is a dict: {normalized_task_name: int_minutes}, may be string-int if loaded from input
+    # normalize keys and intify
+    durations = {normalize_task_name(k): int(v) for k, v in durations.items() if str(v).isdigit() and int(v) > 0}
+
     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
@@ -319,9 +334,12 @@ def solve_dependencies(tasks_text, dependencies_list):
             output += f"{i}. {task_display}\n"
 
         json_output = json.dumps(display_tasks, indent=2)
-        gantt = generate_mermaid_gantt(tasks, task_original_names)
+        gantt = generate_mermaid_gantt(tasks, task_original_names, durations=durations)
         flowchart = generate_mermaid_flowchart({}, tasks, task_original_names)
-        return output, "", json_output, gantt, flowchart
+        # Provide raw for copy-paste, strip code block
+        gantt_raw = gantt.replace('```mermaid\n', '').rstrip('`\n')
+        flow_raw = flowchart.replace('```mermaid\n', '').rstrip('`\n')
+        return output, "", json_output, gantt, flowchart, gantt_raw, flow_raw
 
     try:
         dependencies, all_tasks, dep_original_names = parse_requirements(
@@ -368,10 +386,12 @@ def solve_dependencies(tasks_text, dependencies_list):
                 result_display.append(task_display)
 
             json_output = json.dumps(result_display, indent=2)
-            gantt = generate_mermaid_gantt(result, all_original_names)
+            gantt = generate_mermaid_gantt(result, all_original_names, durations=durations)
             flowchart = generate_mermaid_flowchart(
                 dependencies, all_tasks, all_original_names
             )
+            gantt_raw = gantt.replace('```mermaid\n', '').rstrip('`\n')
+            flow_raw = flowchart.replace('```mermaid\n', '').rstrip('`\n')
 
         else:
             # Try maximum subset
@@ -401,22 +421,26 @@ def solve_dependencies(tasks_text, dependencies_list):
                         output += f"• {task_display}\n"
 
                 json_output = json.dumps(result_display, indent=2)
-                gantt = generate_mermaid_gantt(result, all_original_names)
+                gantt = generate_mermaid_gantt(result, all_original_names, durations=durations)
                 flowchart = generate_mermaid_flowchart(
                     dependencies, all_tasks, all_original_names
                 )
+                gantt_raw = gantt.replace('```mermaid\n', '').rstrip('`\n')
+                flow_raw = flowchart.replace('```mermaid\n', '').rstrip('`\n')
             else:
                 output = "❌ **No solution found!** There might be complex circular dependencies."
                 json_output = "[]"
-                gantt = generate_mermaid_gantt([], all_original_names)
+                gantt = generate_mermaid_gantt([], all_original_names, durations=durations)
                 flowchart = generate_mermaid_flowchart(
                     dependencies, all_tasks, all_original_names
                 )
+                gantt_raw = gantt.replace('```mermaid\n', '').rstrip('`\n')
+                flow_raw = flowchart.replace('```mermaid\n', '').rstrip('`\n')
 
-        return output, dep_summary, json_output, gantt, flowchart
+        return output, dep_summary, json_output, gantt, flowchart, gantt_raw, flow_raw
 
     except Exception as e:
-        return f"❌ **Error:** {str(e)}", "", "", "", ""
+        return f"❌ **Error:** {str(e)}", "", "", "", "", "", ""
 
 
 # Example tasks
@@ -438,13 +462,16 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
     
     **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 with visualizations
+    2. (Optional) Enter the expected duration (in minutes) for each task.
+    3. Select a task, then select all its requirements at once
+    4. Click "Add Dependencies" to add them all
+    5. Click "Solve Dependencies" to get the optimal execution order with visualizations
+    6. You can copy and paste the generated Mermaid.js text below each diagram for use elsewhere!
     """)
 
     # State to store current dependencies
     dependencies_state = gr.State([])
+    durations_state = gr.State({})  # dict: normalized_task -> int (user input durations)
 
     with gr.Row():
         with gr.Column(scale=1):
@@ -457,6 +484,18 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
                 info="Case-insensitive: 'Sleep' and 'sleep' are treated the same",
             )
 
+            gr.Markdown("### ⏱️ (Optional) Step 1.5: Set Task Durations (minutes)")
+            durations_table = gr.Dataframe(
+                headers=["Task", "Minutes"],
+                datatype=["str", "number"],
+                value=[],
+                col_count=(2, "fixed"),
+                row_count=(0, "dynamic"),
+                label="Set duration (minutes) for each listed task.",
+                interactive=True,
+                wrap=True
+            )
+
             gr.Markdown("### 🔗 Step 2: Build Dependencies")
             task_dropdown = gr.Dropdown(
                 label="Select Task",
@@ -512,12 +551,14 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
             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"
             )
+            gantt_mermaid = gr.Code(label="Copy-paste Gantt Mermaid.js", value="", language="markdown")
 
         with gr.Column(scale=1):
             gr.Markdown("#### 🔀 Dependency Flowchart")
             dependency_flowchart = gr.Markdown(
                 value="flowchart TD\n    A[Click Solve to see dependencies]"
             )
+            flow_mermaid = gr.Code(label="Copy-paste Flowchart Mermaid.js", value="", language="markdown")
 
     # Examples section
     with gr.Accordion("📚 Quick Examples", open=False):
@@ -623,12 +664,52 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
             gr.CheckboxGroup(choices=[], value=[]),
         )
 
+    # Utility: update durations table to match tasks
+    def update_durations_table(tasks_text, old_duration_rows):
+        tasks, original_names = parse_tasks(tasks_text)
+        shown_task_set = set()
+        updated_rows = []
+        prev_map = {normalize_task_name(row[0]): row[1] for row in old_duration_rows if len(row) >= 2 and str(row[0]).strip()}
+        for task in tasks:
+            disp = original_names.get(task, display_task_name(task))
+            shown_task_set.add(task)
+            duration = prev_map.get(task, "")
+            updated_rows.append([disp, duration])
+        return updated_rows
+
+    # Converts Dataframe rows to durations dict (normalized)
+    def table_rows_to_durations(table_rows):
+        durations = {}
+        for row in table_rows:
+            if len(row) >= 2 and str(row[0]).strip() and str(row[1]).strip():
+                try:
+                    val = int(float(row[1]))
+                    if val > 0:
+                        durations[normalize_task_name(row[0])] = val
+                except Exception:
+                    continue
+        return durations
+
+    def update_durations_state(rows):
+        return table_rows_to_durations(rows)
+
     # Wire up events
     tasks_input.change(
         fn=update_ui_after_tasks_change,
         inputs=[tasks_input, dependencies_state],
         outputs=[task_dropdown, requirements_checkbox, remove_deps],
     )
+    # Keep durations table in sync
+    tasks_input.change(
+        fn=update_durations_table,
+        inputs=[tasks_input, durations_table],
+        outputs=[durations_table],
+    )
+    durations_table.change(
+        fn=update_durations_state,
+        inputs=[durations_table],
+        outputs=[durations_state],
+    )
 
     add_btn.click(
         fn=handle_add_dependencies,
@@ -656,13 +737,15 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
 
     solve_btn.click(
         fn=solve_dependencies,
-        inputs=[tasks_input, dependencies_state],
+        inputs=[tasks_input, dependencies_state, durations_state],
         outputs=[
             result_output,
             dep_analysis,
             json_output,
             gantt_chart,
             dependency_flowchart,
+            gantt_mermaid,
+            flow_mermaid,
         ],
     )
 
@@ -688,6 +771,12 @@ with gr.Blocks(title="Task Dependency Solver", theme=gr.themes.Soft()) as demo:
         inputs=[tasks_input, dependencies_state],
         outputs=[task_dropdown, requirements_checkbox, remove_deps],
     )
+    # Also set durations table on load
+    demo.load(
+        fn=update_durations_table,
+        inputs=[tasks_input, durations_table],
+        outputs=[durations_table],
+    )
 
 if __name__ == "__main__":
     demo.launch()

test_app.py

@@ -1,5 +1,6 @@
 import pytest
-from app import parse_requirements, parse_tasks, solve_all_tasks, solve_maximum_subset
+from app import parse_requirements, parse_tasks, solve_all_tasks, solve_maximum_subset, generate_mermaid_gantt
+from datetime import datetime, timedelta
 
 def test_parse_requirements_with_spaces():
     reqs = [
@@ -47,3 +48,14 @@ def test_solve_maximum_subset_cycle():
     result = solve_maximum_subset(dependencies, all_tasks)
     # Only d can run because a<->b<->c form a cycle
     assert result == ["d"]
+
+def test_generate_mermaid_gantt_minutes():
+    order = ["a", "b", "c"]
+    names = {"a": "Alpha", "b": "Beta", "c": "Gamma"}
+    durations = {"a": 15, "b": 30, "c": 45}
+    base = datetime(2024, 1, 1, 8, 0)
+    gantt = generate_mermaid_gantt(order, names, durations=durations, start_time=base)
+    assert "dateFormat  YYYY-MM-DD HH:mm" in gantt
+    assert ": 2024-01-01 08:00, 15m" in gantt
+    assert ": 2024-01-01 08:15, 30m" in gantt
+    assert ": 2024-01-01 08:45, 45m" in gantt