docs: add CLAUDE.md development guide and schedule.py

Added comprehensive development guide for Claude Code instances and
standalone personal scheduling module with constraint solving.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

CLAUDE.md

@@ -0,0 +1,91 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is a constraint satisfaction and scheduling application built with Google OR-Tools and Gradio. The project provides both a web UI and programmatic interfaces for solving task scheduling problems with dependencies and time constraints.
+
+### Core Architecture
+
+- **app.py** - Main Gradio web application with constraint solving logic
+- **schedule.py** - Standalone scheduling solver for personal activities 
+- **test_app.py** - Test suite for the application logic
+
+The application uses:
+- Google OR-Tools CP-SAT solver for constraint satisfaction problems
+- Gradio for the web interface
+- Mermaid diagrams for schedule visualization
+- UV for dependency management and Python execution
+
+## Development Commands
+
+### Environment Setup
+```bash
+uv sync                    # Install/sync dependencies
+```
+
+### Running the Application
+```bash
+uv run python app.py       # Start Gradio web interface (serves on http://localhost:7860)
+uv run python schedule.py  # Run standalone personal scheduler
+```
+
+### Testing
+```bash
+uv run pytest              # Run all tests
+uv run pytest test_app.py -v  # Run specific test file with verbose output
+```
+Note: Some tests are currently failing due to task name normalization changes
+
+### Code Quality
+```bash
+uv run ruff check app.py   # Lint specific file
+uv run ruff format app.py  # Format specific file
+uv run ruff check .        # Lint entire project
+uv run ruff format .       # Format entire project
+```
+
+### Adding Dependencies
+```bash
+uv add <package>           # Add new dependency to pyproject.toml
+```
+
+## Key Functions and Logic
+
+### Task Parsing and Normalization
+- `normalize_task_name()` - Converts task names to lowercase with underscores for internal processing
+- `parse_requirements()` - Parses dependency strings like "TaskA requires TaskB" into dependency graphs
+- `parse_tasks()` - Extracts task lists from comma/newline separated text
+
+### Constraint Solving
+- `solve_all_tasks()` - Main CP-SAT solver that schedules all tasks respecting dependencies
+- Uses Google OR-Tools constraint programming to find valid task orderings
+- Returns ordered task lists or indicates if no solution exists (cyclic dependencies)
+
+### Visualization
+- `generate_mermaid_gantt()` - Creates Mermaid Gantt charts from task schedules
+- Supports both simple ordering and time-based scheduling with durations
+
+### Gradio Interface
+The web UI provides text areas for:
+- Task list input (comma or newline separated)
+- Requirements/dependencies input 
+- Interactive solving and visualization
+
+## Code Conventions
+
+- Uses snake_case for functions and variables
+- Type hints encouraged for public APIs
+- Ruff for linting/formatting (PEP8 style)
+- 4-space indentation, 120-character line limit
+- Comprehensive docstrings for public functions
+
+## Development Notes
+
+- The project uses UV instead of pip/venv for faster dependency management
+- Tests exist but some are failing due to recent changes in task name handling
+- The application can handle cyclic dependency detection
+- Both programmatic (schedule.py) and interactive (app.py) interfaces available
+- Mermaid diagram generation supports time-based and simple orderings
+- try to keep all features accessible from gradio

schedule.py

@@ -0,0 +1,70 @@
+from ortools.sat.python import cp_model
+
+def main():
+    model = cp_model.CpModel()
+    horizon = 48  # 24-hour day in 30-minute slots (adjust as needed)
+
+    # Activities and durations (in 30-min increments)
+    activities = {
+        'breakfast': 2,    # 1 hour (prep + eat + cleanup)
+        'lunch': 2,
+        'dinner': 2,
+        'nap': 4,          # 2-hour nap
+        'laundry': 4,      # 2 hours
+        'wifes_parents': 6,  # 3-hour visit
+        'mom': 6,          # Friday night (fixed)
+        'personal_time': 4,  # 2 hours total
+        'kids_duty': 1,    # Rotating 30-min shifts
+    }
+
+    # --- Time Windows ---
+    # All times are in 30-min slots from 0 (8:00 AM) to 48 (next day 8:00 AM)
+    time_windows = {
+        'mom': (36, 42),  # Friday 6:00 PM–9:00 PM (if Friday is day 0)
+        'nap': (12, 18),  # Preferred nap window: 1:00 PM–4:00 PM
+        'laundry': (20, 36),  # Flexible but avoid late-night
+    }
+
+    # --- Variables ---
+    starts = {act: model.NewIntVar(0, horizon, f'start_{act}') for act in activities}
+    ends = {act: model.NewIntVar(0, horizon, f'end_{act}') for act in activities}
+    
+    # Duration constraints
+    for act, duration in activities.items():
+        model.Add(ends[act] == starts[act] + duration)
+
+    # --- Fixed Time Constraints ---
+    model.Add(starts['mom'] == time_windows['mom'][0])  # Fixed Friday night
+    
+    # --- Meal Spacing (4-hour gaps) ---
+    model.Add(starts['lunch'] >= starts['breakfast'] + 8)  # 8 slots = 4 hours
+    model.Add(starts['dinner'] >= starts['lunch'] + 8)
+
+    # --- Nap After Lunch ---
+    model.Add(starts['nap'] >= starts['lunch'] + 2)  # At least 1 hour after lunch
+
+    # --- Laundry During Kid-Free Time ---
+    model.Add(starts['laundry'] >= 20)  # Not before 10 AM
+
+    # --- Personal Time (flexible, but prioritize) ---
+    model.AddMaxEquality(ends['personal_time'], [horizon])
+
+    # --- Kids’ Duty Constraints ---
+    # Simplified: Alternate shifts (for realism, expand to check overlaps)
+    for act in ['wifes_parents', 'mom', 'personal_time']:
+        model.AddNoOverlap([starts[act], ends[act], starts['kids_duty'], ends['kids_duty']])
+
+    # --- Solve ---
+    solver = cp_model.CpSolver()
+    status = solver.Solve(model)
+
+    # --- Print Schedule ---
+    if status == cp_model.OPTIMAL:
+        for act in activities:
+            start = solver.Value(starts[act])
+            print(f"{act}: {start//2}:{30*(start%2):02}–{(start+activities[act])//2}:{30*((start+activities[act])%2):02}")
+    else:
+        print("No feasible schedule found.")
+
+if __name__ == '__main__':
+    main()