feat: claude version

app.py

@@ -1,78 +1,267 @@
 import gradio as gr
 import json
+import re
+from collections import defaultdict
 from ortools.sat.python import cp_model
 
-def solve_task_order(requirements_text):
-    # Split and clean the input
-    requirements_text = requirements_text.lower()
-    lines = [l.strip() for l in requirements_text.strip().splitlines() if l.strip()]
-    if not lines:
-        return "No requirements specified."
-    
-    prerequisites = []
+def parse_requirements(requirements):
+    """Parse requirements list into dependency graph."""
+    dependencies = defaultdict(list)
     all_tasks = set()
-    for req in lines:
-        if "requires" not in req:
-            return f"Error: Each line must be like 'TaskA requires TaskB'. Bad line: {req}"
-        before, _, after = req.partition(" requires ")
-        before, after = before.strip(), after.strip()
-        prerequisites.append((before, after))
-        all_tasks |= {before, after}
-    task_list = sorted(all_tasks)
-    task_to_idx = {task: i for i, task in enumerate(task_list)}
-    n_tasks = len(task_list)
-    
-    # Model
+    
+    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())
+        if match:
+            task, required = match.groups()
+            all_tasks.add(task)
+            all_tasks.add(required)
+            dependencies[task].append(required)
+    
+    return dependencies, list(all_tasks)
+
+def solve_all_tasks(dependencies, all_tasks):
+    """Try to schedule all tasks (works if DAG)."""
+    model = cp_model.CpModel()
+    n_tasks = len(all_tasks)
+    
+    position = {}
+    for task in all_tasks:
+        position[task] = model.NewIntVar(0, n_tasks - 1, f'pos_{task}')
+    
+    model.AddAllDifferent(list(position.values()))
+    
+    for task, required_list in dependencies.items():
+        for required_task in required_list:
+            if required_task in position:
+                model.Add(position[required_task] < position[task])
+    
+    solver = cp_model.CpSolver()
+    status = solver.Solve(model)
+    
+    if status in [cp_model.OPTIMAL, cp_model.FEASIBLE]:
+        task_order = [(solver.Value(position[task]), task) for task in all_tasks]
+        task_order.sort()
+        return [task for _, task in task_order]
+    
+    return None
+
+def solve_maximum_subset(dependencies, all_tasks):
+    """Find maximum subset of tasks that can be executed (handles cycles)."""
     model = cp_model.CpModel()
-    order = [model.NewIntVar(0, n_tasks - 1, f'order_{task}') for task in task_list]
-    model.AddAllDifferent(order)
-    constraints_satisfied = []
-    for before, after in prerequisites:
-        bidx = task_to_idx[before]
-        aidx = task_to_idx[after]
-        ok = model.NewBoolVar(f'prereq_{before}_after_{after}')
-        model.Add(order[aidx] < order[bidx]).OnlyEnforceIf(ok)
-        model.Add(order[aidx] >= order[bidx]).OnlyEnforceIf(ok.Not())
-        constraints_satisfied.append(ok)
-    model.Maximize(sum(constraints_satisfied))
+    n_tasks = len(all_tasks)
+    
+    include = {}
+    position = {}
+    
+    for task in all_tasks:
+        include[task] = model.NewBoolVar(f'include_{task}')
+        position[task] = model.NewIntVar(0, n_tasks - 1, f'pos_{task}')
+    
+    for task, required_list in dependencies.items():
+        for required_task in required_list:
+            if required_task in include:
+                model.AddImplication(include[task], include[required_task])
+                model.Add(position[required_task] < position[task]).OnlyEnforceIf(
+                    [include[task], include[required_task]]
+                )
+    
+    for i, task1 in enumerate(all_tasks):
+        for j, task2 in enumerate(all_tasks):
+            if i < j:
+                model.Add(position[task1] != position[task2]).OnlyEnforceIf(
+                    [include[task1], include[task2]]
+                )
+    
+    for task in all_tasks:
+        model.Add(position[task] == n_tasks).OnlyEnforceIf(include[task].Not())
+    
+    model.Maximize(sum(include.values()))
+    
     solver = cp_model.CpSolver()
     status = solver.Solve(model)
-    if status not in (cp_model.OPTIMAL, cp_model.FEASIBLE):
-        return "No feasible schedule could be found (cycle or conflict?)"
-    idx_to_task = {solver.Value(o): task for o, task in zip(order, task_list)}
-    schedule = [idx_to_task[i] for i in range(n_tasks)]
-    # Format output: numbered list, and json
-    display = "\n".join(f"{i+1}. {task}" for i, task in enumerate(schedule))
-    output_json = json.dumps(schedule, indent=2)
-    satisfied = int(solver.ObjectiveValue())
-    summary = f"Number of constraints satisfied: {satisfied} / {len(prerequisites)}"
-    return f"{display}\n\nJSON:\n{output_json}\n\n{summary}"
+    
+    if status in [cp_model.OPTIMAL, cp_model.FEASIBLE]:
+        included_tasks = []
+        for task in all_tasks:
+            if solver.Value(include[task]) == 1:
+                pos = solver.Value(position[task])
+                included_tasks.append((pos, task))
+        
+        included_tasks.sort()
+        return [task for _, task in included_tasks]
+    
+    return []
+
+def solve_task_ordering_ui(requirements_text):
+    """Main function for Gradio interface."""
+    if not requirements_text.strip():
+        return "❌ Please enter some requirements!", "", ""
+    
+    try:
+        # Split by lines and filter empty lines
+        requirements = [line.strip() for line in requirements_text.strip().split('\n') if line.strip()]
+        
+        if not requirements:
+            return "❌ Please enter some requirements!", "", ""
+        
+        dependencies, all_tasks = parse_requirements(requirements)
+        
+        if not all_tasks:
+            return "❌ No valid requirements found! Please use format: 'TaskA requires TaskB'", "", ""
+        
+        # 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"
+        
+        dep_summary += f"\n**Total tasks found:** {len(all_tasks)}\n"
+        dep_summary += f"**Tasks:** {', '.join(sorted(all_tasks))}"
+        
+        # Try to solve
+        result = solve_all_tasks(dependencies, all_tasks)
+        
+        if result:
+            # All tasks can be executed
+            output = "✅ **All tasks can be executed!**\n\n"
+            output += "**Optimal execution order:**\n"
+            for i, task in enumerate(result, 1):
+                output += f"{i}. {task}\n"
+            
+            # Create JSON output
+            json_output = json.dumps(result, indent=2)
+            
+        else:
+            # Try maximum subset
+            result = solve_maximum_subset(dependencies, all_tasks)
+            
+            if result:
+                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"
+                for i, task in enumerate(result, 1):
+                    output += f"{i}. {task}\n"
+                
+                if excluded_tasks:
+                    output += f"\n**❌ Excluded tasks (due to circular dependencies):**\n"
+                    for task in sorted(excluded_tasks):
+                        output += f"• {task}\n"
+                
+                json_output = json.dumps(result, indent=2)
+            else:
+                output = "❌ **No solution found!** There might be complex circular dependencies."
+                json_output = "[]"
+        
+        return output, dep_summary, json_output
+        
+    except Exception as e:
+        return f"❌ **Error:** {str(e)}", "", ""
 
-example_input = """\
-Sleep requires dinner
+# 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
-"""
+Clean_dining_room requires cleaning_time"""
 
-title = "Task Order Solver (Google OR-Tools Scheduler)"
-description = (
-    "Enter requirements like 'A requires B' (one per line). "
-    "The scheduler will order tasks so that as many requirements as possible are satisfied. "
-    "100% satisfaction is guaranteed if there are no cycles."
-)
-
-iface = gr.Interface(
-    fn=solve_task_order,
-    inputs=gr.Textbox(lines=12, label="Paste 'A requires B' constraints here"),
-    outputs=gr.Textbox(label="Task order (Numbered, JSON, Stats)"),
-    title=title,
-    description=description,
-    examples=[[example_input]],
-)
+# 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.
+    
+    **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
+    """)
+    
+    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
+            )
+            
+            solve_btn = gr.Button("🚀 Solve Dependencies", variant="primary", size="lg")
+            
+            gr.Markdown("""
+            **Example formats:**
+            - `Sleep requires dinner`
+            - `Dinner requires prep`
+            - `Prep requires shopping`
+            """)
+        
+        with gr.Column(scale=1):
+            result_output = gr.Markdown(label="Solution")
+            
+            with gr.Accordion("📋 Dependency Analysis", open=False):
+                dep_analysis = gr.Markdown()
+            
+            with gr.Accordion("💾 JSON Output", open=False):
+                json_output = gr.Code(language="json", label="JSON Array")
+    
+    # Examples
+    with gr.Accordion("📚 Example Use Cases", open=False):
+        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
+        ```
+        
+        **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
+        ```
+        
+        **Circular Dependency Example:**
+        ```
+        A requires B
+        B requires C
+        C requires A
+        D requires E
+        ```
+        """)
+    
+    solve_btn.click(
+        fn=solve_task_ordering_ui,
+        inputs=[requirements_input],
+        outputs=[result_output, dep_analysis, json_output]
+    )
+    
+    # Auto-solve on load
+    demo.load(
+        fn=solve_task_ordering_ui,
+        inputs=[requirements_input],
+        outputs=[result_output, dep_analysis, json_output]
+    )
 
 if __name__ == "__main__":
-    iface.launch()
+    demo.launch()