refactor!: add mpc solver, refactor all systems

feat!: completed mpc tool solver system
refactor!: streamlined services
feat!: add logging system

README.md

@@ -15,9 +15,7 @@ tags: ["agent-demo-track"]
 
 Yuga Planner is a neuro-symbolic system prototype: it provides an agent-powered team scheduling and task allocation platform built on [Gradio](https://gradio.app/).
 
-It takes a project description file such as a README.md file, breaks it down into actionable tasks through a [LLamaIndex](https://www.llamaindex.ai/) agent, then uses [Timefold](http://www.timefold.ai) to generate optimal employee schedules for complex projects.
-
-**Demo Video:** [pCloud]()
+It takes a project description, breaks it down into actionable tasks through a [LLamaIndex](https://www.llamaindex.ai/) agent, then uses [Timefold](http://www.timefold.ai) to generate optimal employee schedules for complex projects.
 
 ## 🚀 Try It Now
 **Live Demo:**
@@ -26,25 +24,49 @@ It takes a project description file such as a README.md file, breaks it down int
 **Source Code on GitHub:**
 [https://github.com/blackopsrepl/yuga-planner](https://github.com/blackopsrepl/yuga-planner)
 
-### Usage
+### Gradio Web Demo Usage
 
-1. Go to [the live demo](https://huggingface.co/spaces/Agents-MCP-Hackathon/yuga-planner) or [http://localhost:7860](http://localhost:7860)
+1. Go to [the live demo](https://huggingface.co/spaces/blackopsrepl/yuga-planner) or [http://localhost:7860](http://localhost:7860)
 
-2. Upload one or more Markdown project file(s), then click "Load Data"
+2. **Upload project files** or **use mock projects:**
+   - Upload one or more Markdown project file(s), then click "Load Data"
+   - OR select from pre-configured mock projects for quick testing
    - Each file will be taken as a separate project
-   - The app will parse, decompose, and estimate tasks
-   - Click "Solve" to generate an optimal schedule
-   - Task order is preserved withing each project
+   - The app will parse, decompose, and estimate tasks using LLM agents
+
+3. **Generate schedule:**
+   - Click "Solve" to generate an optimal schedule against a randomly generated team
+   - View results interactively with real-time solver progress
+   - Task order is preserved within each project
+
+### MCP Tool Usage
+
+1. **In any MCP-compatible chatbot or agent platform:**
+   ```
+   use yuga-planner mcp tool
+   Task Description: [Your task description]
+   ```
 
-3. When the data is loaded, click "Solve" and view results interactively
+2. **Attach your calendar file (.ics)** to provide existing commitments
+
+3. **Receive optimized schedule** that integrates your new task with existing calendar events
 
 ## Architecture
 
-- **Gradio UI:** Main entry point for users
-- **task_composer_agent:** Uses LLMs to decompose and estimate tasks from Markdown
-- **Data Provider:** Generates synthetic employee data and availability preferences
-- **Constraint Solver:** Assigns tasks to employees, optimizing for skills, availability, and fairness
-- **Utils:** Markdown analysis, secret loading, and more
+Yuga Planner follows a **service-oriented architecture** with clear separation of concerns:
+
+### Core Services Layer
+- **DataService:** Handles data loading, processing, and format conversion from various sources (Markdown, calendars)
+- **ScheduleService:** Orchestrates schedule generation, solver management, and solution polling
+- **StateService:** Centralized state management for job tracking and schedule storage
+- **LoggingService:** Real-time log streaming for UI feedback and debugging
+- **MockProjectService:** Provides sample project data for testing and demos
+
+### System Components
+- **Gradio UI:** Modern web interface with real-time updates and interactive schedule visualization
+- **Task Composer Agent:** Uses [LLamaIndex](https://www.llamaindex.ai/) + [Nebius AI](https://nebius.ai/) for intelligent task decomposition and estimation
+- **Constraint Solver:** [Timefold](http://www.timefold.ai) optimization engine for optimal task-to-employee assignments
+- **MCP Integration:** Model Context Protocol endpoint for agent workflow integration
 
 ---
 
@@ -63,30 +85,78 @@ It takes a project description file such as a README.md file, breaks it down int
 | **Calendar Parsing** | Extracts tasks from uploaded calendar files (.ics) | ✅ |
 | **MCP Endpoint** | API endpoint for MCP tool integration | ✅ |
 
-## 🧩 MCP Tool Integration
+## 🎯 Two Usage Modes
+
+Yuga Planner operates as **two separate systems** serving different use cases:
+
+### 1. 🖥️ Gradio Web Demo
+**Purpose:** Interactive team scheduling for project management
+- **Access:** [Live demo](https://huggingface.co/spaces/blackopsrepl/yuga-planner) or local web interface
+- **Input:** Upload Markdown project files or use pre-configured mock projects
+- **Team:** Schedules against a **randomly generated team** with diverse skills and availability
+- **Use Case:** Project managers scheduling real teams for complex multi-project workloads
 
-Yuga Planner now includes an **MCP tool** endpoint, allowing integration with the Hugging Face MCP platform. The MCP tool can process uploaded calendar files (such as `.ics`) and user messages, extracting events and generating a corresponding task dataframe.
+### 2. 🤖 MCP Personal Tool
+**Purpose:** Individual task scheduling integrated with personal calendars
+- **Access:** Through MCP-compatible chatbots and agent platforms
+- **Input:** Attach `.ics` calendar files + natural language task descriptions
+- **Team:** Schedules against your **personal calendar** and existing commitments
+- **Use Case:** Personal productivity and task planning around existing appointments
 
-> **Note:** The current MCP tool implementation returns the *unsolved* task dataframe (not a scheduled/solved output), as full schedule solving is not yet supported for MCP requests. This allows downstream tools or users to inspect and process the extracted tasks before scheduling is implemented.
+**Example MCP Usage:**
+```
+User: use yuga-planner mcp tool
+Task Description: Create a new EC2 instance on AWS
+[Attaches calendar.ics file]
+
+Tool Response: Optimized schedule created - EC2 setup task assigned to
+available time slots around your existing meetings
+```
+
+## 🧩 MCP Tool Integration Details
 
 **Features:**
-- Accepts calendar files and user instructions
-- Parses events into actionable tasks
-- Returns a structured dataframe of tasks (unsolved)
-- Designed for easy integration with agent workflows
+- Accepts calendar files and user task descriptions via chat interface
+- Parses existing calendar events and new task requirements
+- **Full schedule solving support** - generates optimized task assignments
+- Returns complete solved schedules integrated with personal calendar
+- Designed for seamless chatbot and agent workflow integration
+
+**Current Limitations:**
+- **Weekend constraints:** Tasks can be scheduled on weekends (should respect work-week boundaries)
+- **Working hours:** No enforcement of standard business hours (8 AM - 6 PM)
+- **Calendar pinning:** Tasks from uploaded calendars are solved alongside other tasks but should remain pinned to their original time slots
 
 See the [CHANGELOG.md](CHANGELOG.md) for details on recent MCP-related changes.
 
+### Recent Improvements ✅
+
+- **Service Architecture Refactoring:** Complete service-oriented architecture with proper encapsulation and clean boundaries
+- **State Management:** Centralized state handling through dedicated StateService
+- **Handler Compliance:** Clean separation between UI handlers and business logic services
+- **Method Encapsulation:** Fixed all private method violations for better code maintainability
+
 ### Work in Progress
 
-- **MCP**
-- **Gradio UI overhaul**
-- **Migration to Pydantic models**
+- **Constraint Enhancements:**
+  - Weekend respect (prevent scheduling on weekends)
+  - Working hours enforcement (8 AM - 6 PM business hours)
+  - Calendar task pinning (preserve original time slots for imported calendar events)
+- **Gradio UI overhaul:** Enhanced user experience and visual improvements
+- **Migration to Pydantic models:** Type-safe data validation and serialization
 - **Migrate from violation_analyzer to Timefold dedicated libraries**
 - **Include tests for all constraints using ConstraintVerifier**
 
 ### Future Work
 
+#### System Integration Roadmap
+Currently, the **Gradio web demo** and **MCP personal tool** operate as separate systems. As the project evolves, these will become **more integrated**, enabling:
+- **Unified scheduling engine** that can handle both team management and personal productivity in one interface
+- **Hybrid workflows** where personal tasks can be coordinated with team projects
+- **Cross-system data sharing** between web demo projects and personal MCP calendars
+- **Seamless switching** between team management and individual task planning modes
+
+#### Core Feature Enhancements
 - **RAG:** validation of task decomposition and estimation against industry relevant literature
 - **More granular task dependency:** representation of tasks in a tree instead of a list to allow overlap within projects, where feasible/convenient
 - **Input from GitHub issues:** instead of processing markdown directly, it creates a list by parsing issue
@@ -138,18 +208,6 @@ See the [CHANGELOG.md](CHANGELOG.md) for details on recent MCP-related changes.
 
 ---
 
-## Testing
-
-- **Run tests:**
-  ```bash
-  make test
-  ```
-
-- **Test files:**
-  Located in the `tests/` directory.
-
----
-
 ## Python Dependencies
 
 See `requirements.txt` for full list.

src/agents/task_composer_agent.py

@@ -1,4 +1,4 @@
-import os, asyncio, logging
+import os, asyncio
 from typing import Optional, List
 
 from llama_index.llms.nebius import NebiusLLM
@@ -19,9 +19,11 @@ from agents.task_processing import (
     log_task_duration_breakdown,
     log_total_time,
 )
+from utils.logging_config import setup_logging, get_logger
 
-logging.basicConfig(level=logging.INFO)
-logger: logging.Logger = logging.getLogger(__name__)
+# Initialize logging
+setup_logging()
+logger = get_logger(__name__)
 
 
 from domain import AgentsConfig, AGENTS_CONFIG

src/agents/task_processing.py

@@ -1,9 +1,11 @@
-import re, logging
+import re
 
 from utils.markdown_analyzer import MarkdownAnalyzer
+from utils.logging_config import setup_logging, get_logger
 
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+# Initialize logging
+setup_logging()
+logger = get_logger(__name__)
 
 
 ### MARKDOWN UTILS ###

src/app.py

@@ -1,8 +1,11 @@
-import os, argparse, logging
+import os, argparse
 import gradio as gr
 
-logging.basicConfig(level=logging.INFO)
+from utils.logging_config import setup_logging, get_logger
 
+# Initialize logging early - will be reconfigured based on debug mode
+setup_logging()
+logger = get_logger(__name__)
 
 from utils.load_secrets import load_secrets
 
@@ -33,6 +36,18 @@ last_attached_file = None
 
 
 def app(debug: bool = False):
+    """Main application function with optional debug mode"""
+
+    # Configure logging based on debug mode
+    if debug:
+        os.environ["YUGA_DEBUG"] = "true"
+        setup_logging("DEBUG")
+        logger.info("Application started in DEBUG mode")
+    else:
+        os.environ["YUGA_DEBUG"] = "false"
+        setup_logging("INFO")
+        logger.info("Application started in normal mode")
+
     with gr.Blocks() as demo:
         gr.Markdown(
             """
@@ -41,254 +56,308 @@ def app(debug: bool = False):
             """
         )
 
-        with gr.Tab("Information"):
+        _draw_info_page(debug)
+        # _draw_hackathon_page(debug)
 
-            def get_server_url():
-                try:
-                    return gr.get_state().server_url + "/gradio_api/mcp/sse"
-                except:
-                    return "http://localhost:7860/gradio_api/mcp/sse"
+        # Register the MCP tool as an API endpoint
+        gr.api(process_message_and_attached_file)
 
-            gr.Markdown(
-                f"""
-                This is a demo of the Yuga Planner system.
-
-                To use as an MCP server:
-                1. Register the MCP server with your client using the URL:
-                ```
-                {get_server_url()}
-                ```
-                2. Call the tool from your client. Example:
-                ```
-                use yuga planner tool @tests/data/calendar.ics
-                Task Description: Create a new AWS VPC
-                ```
-
-                """
-            )
+    return demo
 
-        with gr.Tab("Task Scheduling"):
-            gr.Markdown("### SWE Team Task Scheduling Demo")
 
-            gr.Markdown(
-                """
-                ## Instructions
-                1. Choose a project source - either upload your own project file(s) or select from our mock projects
-                2. Click 'Load Data' to parse, decompose, and estimate tasks
-                3. Click 'Solve' to generate an optimal schedule based on employee skills and availability
-                4. Review the results in the tables below
-                """
-            )
+def _draw_info_page(debug: bool = False):
+    with gr.Tab("Information"):
 
-            # Project source selector
-            project_source = gr.Radio(
-                choices=["Upload Project Files", "Use Mock Projects"],
-                value="Upload Project Files",
-                label="Project Source",
-            )
+        def get_server_url():
+            try:
+                return gr.get_state().server_url + "/gradio_api/mcp/sse"
+            except:
+                return "http://localhost:7860/gradio_api/mcp/sse"
 
-            # Configuration parameters
-            with gr.Row():
-                employee_count = gr.Number(
-                    label="Number of Employees",
-                    value=12,
-                    minimum=1,
-                    maximum=100,
-                    step=1,
-                    precision=0,
-                )
-                days_in_schedule = gr.Number(
-                    label="Days in Schedule",
-                    value=365,
-                    minimum=1,
-                    maximum=365,
-                    step=1,
-                    precision=0,
-                )
+        gr.Markdown(
+            f"""
+            This is a demo of the Yuga Planner system.
+
+            To use as an MCP server:
+            1. Register the MCP server with your client using the URL:
+            ```
+            {get_server_url()}
+            ```
+            2. Call the tool from your client. Example:
+            ```
+            use yuga planner tool @tests/data/calendar.ics
+            Task Description: Create a new AWS VPC
+            ```
 
-            # File upload component (initially visible)
-            with gr.Group(visible=True) as file_upload_group:
-                file_upload = gr.File(
-                    label="Upload Project Files (Markdown)",
-                    file_types=[".md"],
-                    file_count="multiple",
-                )
+            """
+        )
 
-            # Mock projects dropdown (initially hidden)
-            with gr.Group(visible=False) as mock_projects_group:
-                # Get mock project names from ProjectService
-                available_projects = MockProjectService.get_available_project_names()
-                mock_project_dropdown = gr.Dropdown(
-                    choices=available_projects,
-                    label="Select Mock Projects (multiple selection allowed)",
-                    value=[available_projects[0]] if available_projects else [],
-                    multiselect=True,
-                )
 
-                # Accordion for viewing mock project content
-                with gr.Accordion("📋 Project Content Preview", open=False):
-                    mock_project_content_accordion = gr.Textbox(
-                        label="Project Content",
-                        interactive=False,
-                        lines=15,
-                        max_lines=20,
-                        show_copy_button=True,
-                        placeholder="Select projects above and expand this section to view content...",
-                    )
-
-                # Auto-update content when projects change
-                mock_project_dropdown.change(
-                    show_mock_project_content,
-                    inputs=[mock_project_dropdown],
-                    outputs=[mock_project_content_accordion],
-                )
+def _draw_hackathon_page(debug: bool = False):
+    with gr.Tab("Hackathon Agent Demo"):
+        gr.Markdown("### SWE Team Task Scheduling Demo")
+
+        gr.Markdown(
+            """
+            ## Instructions
+            1. Choose a project source - either upload your own project file(s) or select from our mock projects
+            2. Click 'Load Data' to parse, decompose, and estimate tasks
+            3. Click 'Solve' to generate an optimal schedule based on employee skills and availability
+            4. Review the results in the tables below
+            """
+        )
+
+        # Project source selector
+        project_source = gr.Radio(
+            choices=["Upload Project Files", "Use Mock Projects"],
+            value="Upload Project Files",
+            label="Project Source",
+        )
 
-            # Log Terminal - Always visible for streaming logs
-            gr.Markdown("## Live Log Terminal")
-            log_terminal = gr.Textbox(
-                label="Processing Logs",
-                interactive=False,
-                lines=8,
-                max_lines=15,
-                show_copy_button=True,
-                placeholder="Logs will appear here during data loading...",
+        # Configuration parameters
+        with gr.Row():
+            employee_count = gr.Number(
+                label="Number of Employees",
+                value=12,
+                minimum=1,
+                maximum=100,
+                step=1,
+                precision=0,
+            )
+            days_in_schedule = gr.Number(
+                label="Days in Schedule",
+                value=365,
+                minimum=1,
+                maximum=365,
+                step=1,
+                precision=0,
             )
 
-            # Toggle visibility based on project source selection
-            def toggle_visibility(choice):
-                if choice == "Upload Project Files":
-                    return gr.update(visible=True), gr.update(visible=False)
-                else:
-                    return gr.update(visible=False), gr.update(visible=True)
-
-            project_source.change(
-                toggle_visibility,
-                inputs=[project_source],
-                outputs=[file_upload_group, mock_projects_group],
+        # File upload component (initially visible)
+        with gr.Group(visible=True) as file_upload_group:
+            file_upload = gr.File(
+                label="Upload Project Files (Markdown)",
+                file_types=[".md"],
+                file_count="multiple",
             )
 
-            # State for LLM output, persists per session
-            llm_output_state = gr.State(value=None)
-            job_id_state = gr.State(value=None)
-            status_text = gr.Textbox(
-                label="Solver Status",
-                interactive=False,
-                lines=8,
-                max_lines=20,
-                show_copy_button=True,
+        # Mock projects dropdown (initially hidden)
+        with gr.Group(visible=False) as mock_projects_group:
+            # Get mock project names from ProjectService
+            available_projects = MockProjectService.get_available_project_names()
+            mock_project_dropdown = gr.Dropdown(
+                choices=available_projects,
+                label="Select Mock Projects (multiple selection allowed)",
+                value=[available_projects[0]] if available_projects else [],
+                multiselect=True,
             )
 
-            with gr.Row():
-                load_btn = gr.Button("Load Data")
-                solve_btn = gr.Button("Solve", interactive=False)  # Initially disabled
+            # Accordion for viewing mock project content
+            with gr.Accordion("📋 Project Content Preview", open=False):
+                mock_project_content_accordion = gr.Textbox(
+                    label="Project Content",
+                    interactive=False,
+                    lines=15,
+                    max_lines=20,
+                    show_copy_button=True,
+                    placeholder="Select projects above and expand this section to view content...",
+                )
 
-            gr.Markdown("## Employees")
-            employees_table = gr.Dataframe(label="Employees", interactive=False)
+            # Auto-update content when projects change
+            mock_project_dropdown.change(
+                show_mock_project_content,
+                inputs=[mock_project_dropdown],
+                outputs=[mock_project_content_accordion],
+            )
 
-            gr.Markdown("## Tasks")
-            schedule_table = gr.Dataframe(label="Tasks Table", interactive=False)
+        # Log Terminal - Always visible for streaming logs
+        gr.Markdown("## Live Log Terminal")
 
-            # Outputs: always keep state as last output
-            outputs = [
-                employees_table,
-                schedule_table,
-                job_id_state,
-                status_text,
-                llm_output_state,
-                log_terminal,
-            ]
-
-            # Outputs for load_data that also enables solve button
-            load_outputs = outputs + [solve_btn]
-
-            # Create wrapper function to pass debug flag to auto_poll
-            async def auto_poll_with_debug(job_id, llm_output):
-                return await auto_poll(job_id, llm_output, debug=debug)
-
-            # Timer for polling (not related to state)
-            timer = gr.Timer(2, active=False)
-            timer.tick(
-                auto_poll_with_debug,
-                inputs=[job_id_state, llm_output_state],
-                outputs=outputs,
+        # Show debug status
+        if debug:
+            gr.Markdown(
+                "🐛 **Debug Mode Enabled** - Showing detailed logs including DEBUG messages"
             )
+        else:
+            gr.Markdown(
+                "ℹ️ **Normal Mode** - Showing INFO, WARNING, and ERROR messages"
+            )
+
+        log_terminal = gr.Textbox(
+            label="Processing Logs",
+            interactive=False,
+            lines=8,
+            max_lines=15,
+            show_copy_button=True,
+            placeholder="Logs will appear here during data loading and solving...",
+        )
+
+        # Toggle visibility based on project source selection
+        def toggle_visibility(choice):
+            if choice == "Upload Project Files":
+                return gr.update(visible=True), gr.update(visible=False)
+            else:
+                return gr.update(visible=False), gr.update(visible=True)
+
+        project_source.change(
+            toggle_visibility,
+            inputs=[project_source],
+            outputs=[file_upload_group, mock_projects_group],
+        )
+
+        # State for LLM output, persists per session
+        llm_output_state = gr.State(value=None)
+        job_id_state = gr.State(value=None)
+        status_text = gr.Textbox(
+            label="Solver Status",
+            interactive=False,
+            lines=8,
+            max_lines=20,
+            show_copy_button=True,
+        )
 
-            # Create wrapper function to pass debug flag to load_data
-            async def load_data_with_debug(
+        with gr.Row():
+            load_btn = gr.Button("Load Data")
+            solve_btn = gr.Button("Solve", interactive=False)  # Initially disabled
+
+        gr.Markdown("## Employees")
+        employees_table = gr.Dataframe(label="Employees", interactive=False)
+
+        gr.Markdown("## Tasks")
+        schedule_table = gr.Dataframe(label="Tasks Table", interactive=False)
+
+        # Outputs: always keep state as last output
+        outputs = [
+            employees_table,
+            schedule_table,
+            job_id_state,
+            status_text,
+            llm_output_state,
+            log_terminal,
+        ]
+
+        # Outputs for load_data that also enables solve button
+        load_outputs = outputs + [solve_btn]
+
+        # Create wrapper function to pass debug flag to auto_poll
+        async def auto_poll_with_debug(job_id, llm_output):
+            result = await auto_poll(job_id, llm_output, debug=debug)
+            # auto_poll now returns 6 values including logs
+            return result
+
+        # Timer for polling (not related to state)
+        timer = gr.Timer(2, active=False)
+        timer.tick(
+            auto_poll_with_debug,
+            inputs=[job_id_state, llm_output_state],
+            outputs=outputs,  # This now includes log_terminal updates
+        )
+
+        # Create wrapper function to pass debug flag to load_data
+        async def load_data_with_debug(
+            project_source,
+            file_obj,
+            mock_projects,
+            employee_count,
+            days_in_schedule,
+            llm_output,
+            progress=gr.Progress(),
+        ):
+            async for result in load_data(
                 project_source,
                 file_obj,
                 mock_projects,
                 employee_count,
                 days_in_schedule,
                 llm_output,
-                progress=gr.Progress(),
+                debug=debug,
+                progress=progress,
             ):
-                async for result in load_data(
-                    project_source,
-                    file_obj,
-                    mock_projects,
-                    employee_count,
-                    days_in_schedule,
-                    llm_output,
-                    debug=debug,
-                    progress=progress,
-                ):
-                    yield result
-
-            # Use state as both input and output
-            load_btn.click(
-                load_data_with_debug,
-                inputs=[
-                    project_source,
-                    file_upload,
-                    mock_project_dropdown,
-                    employee_count,
-                    days_in_schedule,
-                    llm_output_state,
-                ],
-                outputs=load_outputs,
-                api_name="load_data",
-            )
+                yield result
 
-            # Create wrapper function to pass debug flag to show_solved
-            async def show_solved_with_debug(state_data, job_id):
-                return await show_solved(state_data, job_id, debug=debug)
+        # Use state as both input and output
+        load_btn.click(
+            load_data_with_debug,
+            inputs=[
+                project_source,
+                file_upload,
+                mock_project_dropdown,
+                employee_count,
+                days_in_schedule,
+                llm_output_state,
+            ],
+            outputs=load_outputs,
+            api_name="load_data",
+        )
 
-            solve_btn.click(
-                show_solved_with_debug,
-                inputs=[llm_output_state, job_id_state],
-                outputs=outputs,
-            ).then(start_timer, inputs=[job_id_state, llm_output_state], outputs=timer)
+        # Create wrapper function to pass debug flag to show_solved
+        async def show_solved_with_debug(state_data, job_id):
+            return await show_solved(state_data, job_id, debug=debug)
 
-            if debug:
+        solve_btn.click(
+            show_solved_with_debug,
+            inputs=[llm_output_state, job_id_state],
+            outputs=outputs,
+        ).then(start_timer, inputs=[job_id_state, llm_output_state], outputs=timer)
 
-                def debug_set_state(state):
-                    logging.info(f"DEBUG: Setting state to test_value")
-                    return "Debug: State set!", "test_value"
+        if debug:
+            gr.Markdown("### 🐛 Debug Controls")
+            gr.Markdown(
+                "These controls help test the centralized logging system and state management."
+            )
+
+            def debug_set_state(state):
+                logger.info("DEBUG: Setting state to test_value")
+                logger.debug("DEBUG: Detailed state operation in progress")
+                return "Debug: State set!", "test_value"
+
+            def debug_show_state(state):
+                logger.info("DEBUG: Current state is %s", state)
+                logger.debug("DEBUG: State retrieval operation completed")
+                return f"Debug: Current state: {state}", gr.update()
 
-                def debug_show_state(state):
-                    logging.info(f"DEBUG: Current state is {state}")
-                    return f"Debug: Current state: {state}", gr.update()
+            def debug_test_logging():
+                """Test all logging levels for UI demonstration"""
+                logger.debug("🐛 DEBUG: This is a debug message")
+                logger.info("ℹ️ INFO: This is an info message")
+                logger.warning("⚠️ WARNING: This is a warning message")
+                logger.error("❌ ERROR: This is an error message")
+                return "Generated test log messages at all levels"
 
-                debug_out = gr.Textbox(label="Debug Output")
+            debug_out = gr.Textbox(label="Debug Output")
+
+            with gr.Row():
                 debug_set_btn = gr.Button("Debug Set State")
                 debug_show_btn = gr.Button("Debug Show State")
+                debug_log_btn = gr.Button("Test Log Levels")
 
-                debug_set_btn.click(
-                    debug_set_state,
-                    inputs=[llm_output_state],
-                    outputs=[debug_out, llm_output_state],
-                )
-                debug_show_btn.click(
-                    debug_show_state,
-                    inputs=[llm_output_state],
-                    outputs=[debug_out, gr.State()],
-                )
+            debug_set_btn.click(
+                debug_set_state,
+                inputs=[llm_output_state],
+                outputs=[debug_out, llm_output_state],
+            )
+            debug_show_btn.click(
+                debug_show_state,
+                inputs=[llm_output_state],
+                outputs=[debug_out, gr.State()],
+            )
+            debug_log_btn.click(
+                debug_test_logging,
+                inputs=[],
+                outputs=[debug_out],
+            )
 
-            # Register the MCP tool as an API endpoint
-            gr.api(process_message_and_attached_file)
 
-    return demo
+def set_test_state():
+    logger.debug("Setting state to test_value")
+    app_state.set("test_key", "test_value")
+    return "State set to test_value"
+
+
+def get_test_state():
+    state = app_state.get("test_key", "No state found")
+    logger.debug("Current state is %s", state)
+    return f"Current state: {state}"
 
 
 if __name__ == "__main__":

src/constraint_solvers/timetable/constraints.py

@@ -118,14 +118,17 @@ def no_overlapping_tasks(constraint_factory: ConstraintFactory):
     return (
         constraint_factory.for_each_unique_pair(
             Task,
-            Joiners.equal(lambda task: task.employee.name),
+            Joiners.equal(lambda task: task.employee),  # Same employee
             Joiners.overlapping(
                 lambda task: task.start_slot,
                 lambda task: task.start_slot + task.duration_slots,
             ),
         )
+        .filter(
+            lambda task1, task2: task1.employee is not None
+        )  # Only check assigned tasks
         .penalize(HardSoftDecimalScore.ONE_HARD, get_slot_overlap)
-        .as_constraint("No overlapping tasks")
+        .as_constraint("No overlapping tasks for same employee")
     )
 
 
@@ -194,10 +197,11 @@ def maintain_project_task_order(constraint_factory: ConstraintFactory):
         .join(Task)
         .filter(tasks_violate_sequence_order)
         .penalize(
-            HardSoftDecimalScore.ONE_SOFT,
-            lambda task1, task2: 100
-            * (task1.start_slot + task1.duration_slots - task2.start_slot),
-        )  # High penalty (100x) proportional to overlap to strongly encourage proper sequencing
+            HardSoftDecimalScore.ONE_HARD,  # Make this a HARD constraint
+            lambda task1, task2: task1.start_slot
+            + task1.duration_slots
+            - task2.start_slot,
+        )  # Penalty proportional to overlap
         .as_constraint("Project task sequence order")
     )
 

src/constraint_solvers/timetable/domain.py

@@ -56,6 +56,8 @@ class Task:
     project_id: str = ""
     # Sequence number within the project to maintain original task order
     sequence_number: int = 0
+    # Whether this task is pinned to its current assignment (for calendar events)
+    pinned: Annotated[bool, PlanningPin] = False
     employee: Annotated[
         Employee | None, PlanningVariable(value_range_provider_refs=["employeeRange"])
     ] = None
@@ -69,6 +71,7 @@ class Task:
             "required_skill": self.required_skill,
             "project_id": self.project_id,
             "sequence_number": self.sequence_number,
+            "pinned": self.pinned,
             "employee": self.employee.to_dict() if self.employee else None,
         }
 
@@ -82,6 +85,7 @@ class Task:
             required_skill=d["required_skill"],
             project_id=d.get("project_id", ""),
             sequence_number=d.get("sequence_number", 0),
+            pinned=d.get("pinned", False),
             employee=Employee.from_dict(d["employee"]) if d["employee"] else None,
         )
 

src/constraint_solvers/timetable/solver.py

@@ -16,7 +16,7 @@ solver_config: SolverConfig = SolverConfig(
     score_director_factory_config=ScoreDirectorFactoryConfig(
         constraint_provider_function=define_constraints
     ),
-    termination_config=TerminationConfig(spent_limit=Duration(seconds=30)),
+    # termination_config=TerminationConfig(spent_limit=Duration(seconds=30)),  # Commented out to allow unlimited solving time
 )
 
 solver_manager: SolverManager = SolverManager.create(

src/domain.py

@@ -1,4 +1,4 @@
-import os
+import os, warnings
 from dataclasses import dataclass
 
 # =========================
@@ -78,7 +78,7 @@ class AgentsConfig:
     nebius_model: str
 
     # Prompt templates
-    task_splitter_prompt: str = "Split the following task into an accurate and concise tree of required subtasks:\n{{query}}\n\nYour output must be a markdown bullet list, with no additional comments.\n\n"
+    task_splitter_prompt: str = "Split the following task into an accurate and concise tree of required subtasks:\n{{query}}\n\nAim for 3 to 15 subtasks.\n\nYour output must be a markdown bullet list, with no additional comments.\n\n"
     task_evaluator_prompt: str = "Evaluate the elapsed time, in 30 minute units, for a competent human to complete the following task:\n{{query}}\n\nYour output must be a one integer, with no additional comments.\n\n"
     task_deps_matcher_prompt: str = "Given the following task:\n{{task}}\n\nAnd these available skills:\n{{skills}}\n\nIn this context:\n{{context}}\n\nSelect the most appropriate skill to complete this task. Return only the skill name as a string, with no additional comments or formatting.\n\n"
 
@@ -95,12 +95,10 @@ class AgentsConfig:
         """Validate required configuration"""
         if not self.nebius_model or not self.nebius_api_key:
             if self.nebius_model == "dev-model" and self.nebius_api_key == "dev-key":
-                # Development mode - just warn
-                import warnings
-
                 warnings.warn(
                     "Using development defaults for NEBIUS_MODEL and NEBIUS_API_KEY"
                 )
+
             else:
                 raise ValueError(
                     "NEBIUS_MODEL and NEBIUS_API_KEY environment variables must be set"

src/factory/data_generators.py

@@ -23,10 +23,13 @@ LAST_NAMES = (
 
 
 def generate_employees(
-    parameters: TimeTableDataParameters, random: Random
+    parameters: TimeTableDataParameters,
+    random: Random,
+    required_skills_needed: set[str] = None,
 ) -> list[Employee]:
     """
     Generates a list of Employee objects with random names and skills.
+    Ensures that collectively the employees have all required_skills_needed.
     """
     name_permutations = [
         f"{first_name} {last_name}"
@@ -36,19 +39,60 @@ def generate_employees(
     random.shuffle(name_permutations)
 
     employees = []
-    for i in range(parameters.employee_count):
-        (count,) = random.choices(
-            population=counts(parameters.optional_skill_distribution),
-            weights=weights(parameters.optional_skill_distribution),
-        )
 
-        # Ensure we don't try to sample more skills than available
-        count = min(count, len(parameters.skill_set.optional_skills))
+    # If specific skills are needed, ensure they're covered
+    if required_skills_needed:
+        skills_needed = set(required_skills_needed)
+
+        # For single employee (MCP case), give them all needed skills plus some random ones
+        if parameters.employee_count == 1:
+            all_available_skills = list(parameters.skill_set.required_skills) + list(
+                parameters.skill_set.optional_skills
+            )
+            # Give all available skills to the single employee to handle any task
+            employees.append(
+                Employee(name=name_permutations[0], skills=set(all_available_skills))
+            )
+            return employees
+
+        # For multiple employees, distribute needed skills and add random skills
+        for i in range(parameters.employee_count):
+            (count,) = random.choices(
+                population=counts(parameters.optional_skill_distribution),
+                weights=weights(parameters.optional_skill_distribution),
+            )
+            count = min(count, len(parameters.skill_set.optional_skills))
+
+            skills = []
+
+            # Ensure each employee gets at least one required skill
+            skills += random.sample(parameters.skill_set.required_skills, 1)
+
+            # Add random optional skills
+            skills += random.sample(parameters.skill_set.optional_skills, count)
 
-        skills = []
-        skills += random.sample(parameters.skill_set.optional_skills, count)
-        skills += random.sample(parameters.skill_set.required_skills, 1)
-        employees.append(Employee(name=name_permutations[i], skills=set(skills)))
+            # If there are still skills needed and this is one of the first employees,
+            # ensure they get some of the needed skills
+            if skills_needed and i < len(skills_needed):
+                needed_skill = skills_needed.pop()
+                if needed_skill not in skills:
+                    skills.append(needed_skill)
+
+            employees.append(Employee(name=name_permutations[i], skills=set(skills)))
+
+    else:
+        # Original random generation when no specific skills are needed
+        for i in range(parameters.employee_count):
+            (count,) = random.choices(
+                population=counts(parameters.optional_skill_distribution),
+                weights=weights(parameters.optional_skill_distribution),
+            )
+            count = min(count, len(parameters.skill_set.optional_skills))
+
+            skills = []
+            skills += random.sample(parameters.skill_set.optional_skills, count)
+            skills += random.sample(parameters.skill_set.required_skills, 1)
+            employees.append(Employee(name=name_permutations[i], skills=set(skills)))
 
     return employees
 
@@ -185,11 +229,14 @@ def generate_tasks_from_calendar(
                 duration_slots = max(1, duration_minutes // 30)
             else:
                 duration_slots = 2  # Default 1 hour
+
             # Randomize required_skill as in generate_tasks
             if random.random() >= 0.5:
                 required_skill = random.choice(parameters.skill_set.required_skills)
+
             else:
                 required_skill = random.choice(parameters.skill_set.optional_skills)
+
             tasks.append(
                 Task(
                     id=next(ids),
@@ -199,8 +246,10 @@ def generate_tasks_from_calendar(
                     required_skill=required_skill,
                 )
             )
+
         except Exception:
             continue
+
     return tasks
 
 
@@ -292,9 +341,3 @@ def tasks_from_agent_output(agent_output, parameters, project_id: str = ""):
             )
         )
     return tasks
-
-
-def skills_from_parameters(parameters: TimeTableDataParameters) -> list[str]:
-    return list(parameters.skill_set.required_skills) + list(
-        parameters.skill_set.optional_skills
-    )

src/factory/data_provider.py

@@ -16,9 +16,11 @@ from agents.task_composer_agent import TaskComposerAgent
 
 from constraint_solvers.timetable.domain import *
 
-import logging
+from utils.logging_config import setup_logging, get_logger
 
-logging.basicConfig(level=logging.INFO)
+# Initialize logging
+setup_logging()
+logger = get_logger(__name__)
 
 # =========================
 #        CONSTANTS
@@ -102,8 +104,7 @@ async def generate_agent_data(
     employees: list[Employee] = generate_employees(parameters, randomizer)
     total_slots: int = parameters.days_in_schedule * SLOTS_PER_DAY
 
-    if os.getenv("YUGA_DEBUG", "false").lower() == "true":
-        logging.info("FILE OBJECT: %s %s", file, type(file))
+    logger.debug("Processing file object: %s (type: %s)", file, type(file))
 
     match file:
         case file if hasattr(file, "read"):
@@ -158,12 +159,44 @@ async def generate_mcp_data(
 
     start_date: date = earliest_monday_on_or_after(date.today())
     randomizer: Random = Random(parameters.random_seed)
-    employees: list[Employee] = generate_employees(parameters, randomizer)
     total_slots: int = parameters.days_in_schedule * SLOTS_PER_DAY
 
+    # --- CALENDAR TASKS ---
+    calendar_tasks = generate_tasks_from_calendar(
+        parameters, randomizer, calendar_entries
+    )
+    # Assign project_id 'EXISTING' to all calendar tasks
+    for t in calendar_tasks:
+        t.sequence_number = 0  # will be overwritten later
+        t.project_id = "EXISTING"
+
+    # --- LLM TASKS ---
+    llm_tasks = []
+    if user_message:
+        from factory.data_provider import run_task_composer_agent
+
+        agent_output = await run_task_composer_agent(user_message, parameters)
+        llm_tasks = tasks_from_agent_output(agent_output, parameters, "PROJECT")
+        for t in llm_tasks:
+            t.sequence_number = 0  # will be overwritten later
+            t.project_id = "PROJECT"
+
+    # --- ANALYZE REQUIRED SKILLS ---
+    all_tasks = calendar_tasks + llm_tasks
+    required_skills_needed = set()
+    for task in all_tasks:
+        if hasattr(task, "required_skill") and task.required_skill:
+            required_skills_needed.add(task.required_skill)
+
+    # --- GENERATE EMPLOYEES WITH REQUIRED SKILLS ---
+    employees: list[Employee] = generate_employees(
+        parameters, randomizer, required_skills_needed
+    )
+
     # Set the single employee's name to 'Chatbot User'
     if len(employees) == 1:
         employees[0].name = "Chatbot User"
+
     else:
         raise ValueError("MCP data provider only supports one employee")
 
@@ -173,16 +206,11 @@ async def generate_mcp_data(
         emp.undesired_dates.clear()
         emp.desired_dates.clear()
 
-    # --- CALENDAR TASKS ---
-    calendar_tasks = generate_tasks_from_calendar(
-        parameters, randomizer, calendar_entries
-    )
-    # Assign project_id 'EXISTING' to all calendar tasks
-    for t in calendar_tasks:
-        t.sequence_number = 0  # will be overwritten later
+    # --- ASSIGN EMPLOYEES TO TASKS ---
+    for t in all_tasks:
         t.employee = employees[0]
-        t.project_id = "EXISTING"
-    # Create DataFrame
+
+    # Create DataFrames for debugging
     calendar_df = pd.DataFrame(
         [
             {
@@ -199,20 +227,8 @@ async def generate_mcp_data(
         ]
     )
 
-    print("\nCalendar DataFrame:")
-    print(calendar_df)
+    logger.debug("Generated calendar tasks DataFrame:\n%s", calendar_df)
 
-    # --- LLM TASKS ---
-    llm_tasks = []
-    if user_message:
-        from factory.data_provider import run_task_composer_agent
-
-        agent_output = await run_task_composer_agent(user_message, parameters)
-        llm_tasks = tasks_from_agent_output(agent_output, parameters, "PROJECT")
-        for t in llm_tasks:
-            t.sequence_number = 0  # will be overwritten later
-            t.employee = employees[0]
-            t.project_id = "PROJECT"
     llm_df = pd.DataFrame(
         [
             {
@@ -229,12 +245,9 @@ async def generate_mcp_data(
         ]
     )
 
-    print("\nLLM DataFrame:")
-    print(llm_df)
+    logger.debug("Generated LLM tasks DataFrame:\n%s", llm_df)
 
-    # --- MERGE AND ASSIGN SEQUENCE ---
-    all_tasks = calendar_tasks + llm_tasks
-    # Assign sequence_number per project group
+    # --- ASSIGN SEQUENCE NUMBERS ---
     existing_seq = 0
     project_seq = 0
     for t in all_tasks:
@@ -250,9 +263,11 @@ async def generate_mcp_data(
         tasks=all_tasks,
         schedule_info=ScheduleInfo(total_slots=total_slots),
     )
+
     final_df = schedule_to_dataframe(schedule)
-    print("\nFinal DataFrame (MCP-aligned):")
-    print(final_df)
+
+    logger.debug("Final schedule DataFrame (MCP-aligned):\n%s", final_df)
+
     return final_df
 
 
@@ -265,18 +280,26 @@ async def run_task_composer_agent(
     )
     context = f"Project scheduling for {parameters.employee_count} employees over {parameters.days_in_schedule} days"
 
-    logging.info(f"Starting workflow with timeout: {AGENTS_CONFIG.workflow_timeout}s")
-    logging.info(f"Input length: {len(input_str)} characters")
-    logging.info(f"Available skills: {available_skills}")
+    logger.info(
+        "Starting task composer workflow - timeout: %ds, input length: %d chars",
+        AGENTS_CONFIG.workflow_timeout,
+        len(input_str),
+    )
+
+    logger.debug("Available skills: %s", available_skills)
 
     try:
         agent_output = await agent.run_workflow(
             query=input_str, skills=available_skills, context=context
         )
-        logging.info(
-            f"Workflow completed successfully. Generated {len(agent_output)} tasks."
+
+        logger.info(
+            "Task composer workflow completed successfully - generated %d tasks",
+            len(agent_output),
         )
+
         return agent_output
+
     except Exception as e:
-        logging.error(f"Workflow failed: {e}")
+        logger.error("Task composer workflow failed: %s", e)
         raise

src/handlers.py

@@ -1,16 +1,20 @@
-import logging
-from typing import Tuple, Dict, List, Optional
+from typing import Tuple
 
 import pandas as pd
 import gradio as gr
 
-from state import app_state
+from utils.logging_config import setup_logging, get_logger, is_debug_enabled
+
+# Initialize logging
+setup_logging()
+logger = get_logger(__name__)
 
 from services import (
     LoggingService,
     ScheduleService,
     DataService,
     MockProjectService,
+    StateService,
 )
 
 # Global logging service instance for UI streaming
@@ -21,16 +25,18 @@ async def show_solved(
     state_data, job_id: str, debug: bool = False
 ) -> Tuple[pd.DataFrame, pd.DataFrame, str, str, object, str]:
     """Handler for solving a schedule from UI state data"""
-    # Set up log streaming for solving process
-    logging_service.setup_log_streaming()
+    # Ensure log streaming is set up and respects debug mode
+    _ensure_log_streaming_setup(debug)
 
-    logging.info(
-        f"🔧 show_solved called with state_data type: {type(state_data)}, job_id: {job_id}"
+    logger.info(
+        "show_solved called with state_data type: %s, job_id: %s",
+        type(state_data),
+        job_id,
     )
 
     # Check if data has been loaded
     if not state_data:
-        logging.warning("❌ No data loaded - cannot solve schedule")
+        logger.warning("No data loaded - cannot solve schedule")
         return (
             gr.update(),
             gr.update(),
@@ -40,7 +46,7 @@ async def show_solved(
             logging_service.get_streaming_logs(),
         )
 
-    logging.info(f"✅ State data found, proceeding with solve...")
+    logger.info("State data found, proceeding with solve...")
 
     try:
         # Use the schedule service to solve the schedule
@@ -54,7 +60,7 @@ async def show_solved(
             state_data, job_id, debug=debug
         )
 
-        logging.info(f"✅ Solver completed successfully, returning results")
+        logger.info("Solver completed successfully, returning results")
 
         return (
             emp_df,
@@ -65,7 +71,7 @@ async def show_solved(
             logging_service.get_streaming_logs(),
         )
     except Exception as e:
-        logging.error(f"Error in show_solved: {e}")
+        logger.error("Error in show_solved: %s", e)
         return (
             gr.update(),
             gr.update(),
@@ -95,12 +101,14 @@ async def load_data(
     Handler for data loading from either file uploads or mock projects - streaming version
     Yields intermediate updates for real-time progress
     """
-    # Set up log streaming and clear previous logs
-    logging_service.setup_log_streaming()
+    # Ensure log streaming is set up and clear previous logs
+    _ensure_log_streaming_setup(debug)
     logging_service.clear_streaming_logs()
 
     # Initial log message
-    logging.info("🚀 Starting data loading process...")
+    logger.info("Starting data loading process...")
+    if debug:
+        logger.debug("Debug mode enabled for data loading")
 
     # Yield initial state
     yield (
@@ -131,7 +139,9 @@ async def load_data(
         )
 
         # Store schedule for later use
-        app_state.add_solved_schedule(job_id, None)  # Will be populated when solved
+        StateService.store_solved_schedule(
+            job_id, None
+        )  # Will be populated when solved
 
         # Final yield with complete results
         yield (
@@ -145,7 +155,7 @@ async def load_data(
         )
 
     except Exception as e:
-        logging.error(f"Error loading data: {e}")
+        logger.error("Error loading data: %s", e)
         yield (
             gr.update(),
             gr.update(),
@@ -181,25 +191,25 @@ def poll_solution(
             job_id,
             status_message,
             schedule,
-            gr.update(),  # log_terminal
+            logging_service.get_streaming_logs(),  # Include logs in polling updates
         )
 
     except Exception as e:
-        logging.error(f"Error in poll_solution: {e}")
+        logger.error("Error in poll_solution: %s", e)
         return (
             gr.update(),
             gr.update(),
             job_id,
             f"Error polling solution: {str(e)}",
             schedule,
-            gr.update(),  # log_terminal
+            logging_service.get_streaming_logs(),  # Include logs even on error
         )
 
 
 async def auto_poll(
     job_id: str, llm_output: dict, debug: bool = False
 ) -> Tuple[pd.DataFrame, pd.DataFrame, str, str, dict, str]:
-    """Handler for automatic polling of updates"""
+    """Handler for auto-polling a solution"""
     try:
         (
             emp_df,
@@ -210,21 +220,40 @@ async def auto_poll(
         ) = await ScheduleService.auto_poll(job_id, llm_output, debug)
 
         return (
-            emp_df,  # employees_table
-            task_df,  # schedule_table
-            job_id,  # job_id_state
-            status_message,  # status_text
-            llm_output,  # llm_output_state
-            logging_service.get_streaming_logs(),  # log_terminal
+            emp_df,
+            task_df,
+            job_id,
+            status_message,
+            llm_output,
+            logging_service.get_streaming_logs(),  # Include logs in auto-poll updates
         )
 
     except Exception as e:
-        logging.error(f"Error in auto_poll: {e}")
+        logger.error("Error in auto_poll: %s", e)
         return (
             gr.update(),
             gr.update(),
             job_id,
-            f"Error in auto polling: {str(e)}",
+            f"Error in auto-polling: {str(e)}",
             llm_output,
-            logging_service.get_streaming_logs(),  # log_terminal
+            logging_service.get_streaming_logs(),  # Include logs even on error
         )
+
+
+def _ensure_log_streaming_setup(debug: bool = False) -> None:
+    """
+    Ensure log streaming is properly set up with current debug settings.
+    This helps maintain consistency when debug mode changes at runtime.
+    """
+    if debug:
+        # Force debug mode setup if explicitly requested
+        import os
+
+        os.environ["YUGA_DEBUG"] = "true"
+        setup_logging("DEBUG")
+
+    # Always setup streaming (it will respect current logging level)
+    logging_service.setup_log_streaming()
+
+    if debug:
+        logger.debug("Log streaming setup completed with debug mode enabled")

src/helpers.py

@@ -20,7 +20,15 @@ def schedule_to_dataframe(schedule) -> pd.DataFrame:
         employee: str = task.employee.name if task.employee else "Unassigned"
 
         # Calculate start and end times based on 30-minute slots
-        start_time: datetime = datetime.now() + timedelta(minutes=30 * task.start_slot)
+        # Schedule starts from next Monday at 8 AM
+        from datetime import date
+        from factory.data_generators import earliest_monday_on_or_after
+
+        base_date = earliest_monday_on_or_after(date.today())
+        base_datetime = datetime.combine(
+            base_date, datetime.min.time().replace(hour=8)
+        )  # Start at 8 AM Monday
+        start_time: datetime = base_datetime + timedelta(minutes=30 * task.start_slot)
         end_time: datetime = start_time + timedelta(minutes=30 * task.duration_slots)
 
         # Add task data to list with availability flags

src/mcp_handlers.py

@@ -1,116 +1,224 @@
-import os
-from dataclasses import dataclass
-import uuid
+"""
+MCP (Model Context Protocol) Handlers for Yuga Planner
+
+This module provides an MCP tool endpoint for external integrations and is separate from the Gradio UI's workflow.
+
+Key Features:
+- Centralized logging integration with debug mode support
+- Performance timing for API monitoring
+- Comprehensive error handling for external consumers
+- Automatic debug mode detection from environment variables
+
+Usage:
+    The main endpoint is registered as a Gradio API and can be called by MCP clients:
+
+    POST /api/process_message_and_attached_file
+    {
+        "file_path": "/path/to/calendar.ics",
+        "message_body": "Create tasks for this week's meetings"
+    }
+
+Environment Variables:
+    YUGA_DEBUG: Set to "true" to enable detailed debug logging for API requests
+
+Logging:
+    - Uses centralized logging system from utils.logging_config
+    - Respects YUGA_DEBUG environment variable (from CLI flag --debug)
+    - Includes performance timing and detailed error information
+    - Provides different log levels for production vs development usage
+"""
+
 import time
-import asyncio
 
 from utils.extract_calendar import extract_ical_entries
+
 from factory.data_provider import generate_mcp_data
-from services.schedule_service import ScheduleService
+from services import ScheduleService, StateService
+from helpers import schedule_to_dataframe
 
+from utils.logging_config import setup_logging, get_logger, is_debug_enabled
 
-@dataclass
-class MCPProcessingResult:
-    user_message: str
-    file: str
-    calendar_entries: list = None
-    error: str = None
-    solved_task_df: object = None
-    status: str = None
-    score: object = None
+setup_logging()
+logger = get_logger(__name__)
 
 
 async def process_message_and_attached_file(file_path: str, message_body: str) -> dict:
     """
-    Store the last chat message and attached file, echo the message, extract calendar entries, generate tasks, solve, and poll for the solution.
+    MCP API endpoint for processing calendar files and task descriptions.
+
+    This is a separate workflow from the main Gradio UI and handles external API requests.
+
     Args:
-        file_path (str): Path to the attached file
+        file_path (str): Path to the attached file (typically .ics calendar file)
         message_body (str): The body of the last chat message, which contains the task description
     Returns:
         dict: Contains confirmation, file info, calendar entries, error, and solved schedule info
     """
+
+    # Determine debug mode from environment or default to False for API calls
+    debug_mode = is_debug_enabled()
+
+    logger.info("MCP Handler: Processing message with attached file")
+    logger.debug("File path: %s", file_path)
+    logger.debug("Message: %s", message_body)
+    logger.debug("Debug mode: %s", debug_mode)
+
+    # Track timing for API performance
+    start_time = time.time()
+
     try:
+        # Step 1: Extract calendar entries from the attached file
+        logger.info("Step 1: Extracting calendar entries...")
+
         with open(file_path, "rb") as f:
             file_bytes = f.read()
-    except Exception as e:
-        result = MCPProcessingResult(
-            user_message="",
-            file="",
-            calendar_entries=[],
-            error=f"Failed to read file: {e}",
+
+        calendar_entries, error = extract_ical_entries(file_bytes)
+
+        if error:
+            logger.error("Failed to extract calendar entries: %s", error)
+            return {
+                "error": f"Failed to extract calendar entries: {error}",
+                "status": "failed",
+                "timestamp": time.time(),
+                "processing_time_seconds": time.time() - start_time,
+            }
+
+        logger.info("Extracted %d calendar entries", len(calendar_entries))
+        if debug_mode:
+            logger.debug(
+                "Calendar entries details: %s",
+                [e.get("summary", "No summary") for e in calendar_entries[:5]],
+            )
+
+        # Step 2: Generate MCP data (combines calendar and LLM tasks)
+        logger.info("Step 2: Generating tasks using MCP data provider...")
+
+        schedule_data = await generate_mcp_data(
+            calendar_entries=calendar_entries,
+            user_message=message_body,
+            project_id="PROJECT",
+            employee_count=1,  # MCP uses single user
+            days_in_schedule=365,
+        )
+
+        logger.info("Generated schedule with %d total tasks", len(schedule_data))
+
+        # Step 3: Convert to format needed for solving
+        logger.info("Step 3: Preparing schedule for solving...")
+
+        # Create state data format expected by ScheduleService
+        state_data = {
+            "task_df_json": schedule_data.to_json(orient="split"),
+            "employee_count": 1,
+            "days_in_schedule": 365,
+        }
+
+        # Step 4: Start solving the schedule
+        logger.info("Step 4: Starting schedule solver...")
+
+        (
+            emp_df,
+            task_df,
+            job_id,
+            status,
+            state_data,
+        ) = await ScheduleService.solve_schedule_from_state(
+            state_data=state_data,
+            job_id=None,
+            debug=debug_mode,  # Respect debug mode for MCP calls
         )
-        return result.__dict__
-
-    # Try to extract calendar entries
-    entries, error = extract_ical_entries(file_bytes)
-    if error:
-        result = MCPProcessingResult(
-            user_message=f"Received your message: {message_body}",
-            file=os.path.basename(file_path),
-            error=f"File is not a valid calendar file: {error}",
+
+        logger.info("Solver started with job_id: %s", job_id)
+        logger.debug("Initial status: %s", status)
+
+        # Step 5: Poll until the schedule is solved
+        logger.info("Step 5: Polling for solution...")
+
+        max_polls = 60  # Maximum 60 polls (about 2 minutes)
+        poll_interval = 2  # Poll every 2 seconds
+
+        for poll_count in range(max_polls):
+            if StateService.has_solved_schedule(job_id):
+                solved_schedule = StateService.get_solved_schedule(job_id)
+
+                # Check if we have a valid solution
+                if solved_schedule and solved_schedule.score is not None:
+                    processing_time = time.time() - start_time
+                    logger.info(
+                        "Schedule solved after %d polls! (Total time: %.2fs)",
+                        poll_count + 1,
+                        processing_time,
+                    )
+
+                    # Convert to final dataframe
+                    final_df = schedule_to_dataframe(solved_schedule)
+
+                    # Generate status message
+                    status_message = ScheduleService.generate_status_message(
+                        solved_schedule
+                    )
+
+                    logger.info("Final Status: %s", status_message)
+
+                    # Return comprehensive JSON response
+                    return {
+                        "status": "success",
+                        "message": "Schedule solved successfully",
+                        "file_info": {
+                            "path": file_path,
+                            "calendar_entries_count": len(calendar_entries),
+                        },
+                        "calendar_entries": calendar_entries,
+                        "solution_status": status_message,
+                        "schedule": final_df.to_dict(
+                            orient="records"
+                        ),  # Convert to list of dicts for JSON
+                        "job_id": job_id,
+                        "polls_required": poll_count + 1,
+                        "processing_time_seconds": processing_time,
+                        "timestamp": time.time(),
+                        "debug_mode": debug_mode,
+                    }
+
+            if debug_mode:
+                logger.debug("Poll %d/%d: Still solving...", poll_count + 1, max_polls)
+
+            time.sleep(poll_interval)
+
+        # If we get here, polling timed out
+        processing_time = time.time() - start_time
+        logger.warning(
+            "Polling timed out after %.2fs - returning partial results", processing_time
         )
-        return result.__dict__
-
-    # Generate MCP DataFrame
-    df = await generate_mcp_data(entries, message_body)
-    if df is None or df.empty:
-        result = MCPProcessingResult(
-            user_message=f"Received your message: {message_body}",
-            file=os.path.basename(file_path),
-            calendar_entries=entries,
-            error="Failed to generate MCP data.",
+
+        return {
+            "status": "timeout",
+            "message": "Schedule solving timed out after maximum polls",
+            "file_info": {
+                "path": file_path,
+                "calendar_entries_count": len(calendar_entries),
+            },
+            "calendar_entries": calendar_entries,
+            "job_id": job_id,
+            "max_polls_reached": max_polls,
+            "processing_time_seconds": processing_time,
+            "timestamp": time.time(),
+            "debug_mode": debug_mode,
+        }
+
+    except Exception as e:
+        processing_time = time.time() - start_time
+        logger.error(
+            "MCP handler error after %.2fs: %s", processing_time, e, exc_info=debug_mode
         )
-        return result.__dict__
 
-    # Build state_data for the solver
-    state_data = {
-        "task_df_json": df.to_json(orient="split"),
-        "employee_count": 1,
-        "days_in_schedule": 365,
-    }
-    job_id = str(uuid.uuid4())
-    (
-        emp_df,
-        solved_task_df,
-        new_job_id,
-        status,
-        state_data,
-    ) = await ScheduleService.solve_schedule_from_state(state_data, job_id, debug=True)
-
-    # Poll for the solution until the status string does not contain 'Solving'
-    max_wait = 30  # seconds
-    interval = 0.5
-    waited = 0
-    final_task_df = None
-    final_status = None
-    final_score = None
-    solved = False
-    while waited < max_wait:
-        (
-            _,
-            polled_task_df,
-            _,
-            polled_status,
-            solved_schedule,
-        ) = ScheduleService.poll_solution(new_job_id, None, debug=True)
-        if polled_status and "Solving" not in polled_status:
-            final_task_df = polled_task_df
-            final_status = polled_status
-            final_score = getattr(solved_schedule, "score", None)
-            solved = True
-            break
-        await asyncio.sleep(interval)
-        waited += interval
-
-    result = MCPProcessingResult(
-        user_message=f"Received your message: {message_body}",
-        file=os.path.basename(file_path),
-        calendar_entries=entries,
-        solved_task_df=final_task_df.to_dict(orient="records")
-        if final_task_df is not None
-        else None,
-        status=final_status,
-        score=final_score,
-        error=None if solved else "Solver did not finish within the timeout",
-    )
-    return result.__dict__
+        return {
+            "error": str(e),
+            "status": "failed",
+            "file_path": file_path,
+            "message_body": message_body,
+            "processing_time_seconds": processing_time,
+            "timestamp": time.time(),
+            "debug_mode": debug_mode,
+        }

src/services/__init__.py

@@ -8,10 +8,12 @@ from .logging_service import LoggingService
 from .schedule_service import ScheduleService
 from .data_service import DataService
 from .mock_projects_service import MockProjectService
+from .state_service import StateService
 
 __all__ = [
     "LoggingService",
     "ScheduleService",
     "DataService",
     "MockProjectService",
+    "StateService",
 ]

src/services/data_service.py

@@ -1,7 +1,5 @@
 import os
 import uuid
-import logging
-from datetime import datetime
 from io import StringIO
 from typing import Dict, List, Tuple, Union, Optional, Any
 
@@ -23,6 +21,11 @@ from constraint_solvers.timetable.domain import (
 
 from helpers import schedule_to_dataframe, employees_to_dataframe
 from .mock_projects_service import MockProjectService
+from utils.logging_config import setup_logging, get_logger
+
+# Initialize logging
+setup_logging()
+logger = get_logger(__name__)
 
 
 class DataService:
@@ -52,24 +55,25 @@ class DataService:
             Tuple of (emp_df, task_df, job_id, status_message, state_data)
         """
         if project_source == "Upload Project Files":
-            files, project_source_info = DataService._process_uploaded_files(file_obj)
+            files, project_source_info = DataService.process_uploaded_files(file_obj)
+
         else:
-            files, project_source_info = DataService._process_mock_projects(
+            files, project_source_info = DataService.process_mock_projects(
                 mock_projects
             )
 
-        logging.info(f"🔄 Processing {len(files)} project(s)...")
+        logger.info(f"🔄 Processing {len(files)} project(s)...")
 
         combined_tasks: List[Task] = []
         combined_employees: Dict[str, Employee] = {}
 
         # Process each file/project
         for idx, single_file in enumerate(files):
-            project_id = DataService._derive_project_id(
+            project_id = DataService.derive_project_id(
                 project_source, single_file, mock_projects, idx
             )
 
-            logging.info(f"⚙️ Processing project {idx+1}/{len(files)}: '{project_id}'")
+            logger.info(f"⚙️ Processing project {idx+1}/{len(files)}: '{project_id}'")
 
             schedule_part: EmployeeSchedule = await generate_agent_data(
                 single_file,
@@ -77,7 +81,8 @@ class DataService:
                 employee_count=employee_count,
                 days_in_schedule=days_in_schedule,
             )
-            logging.info(f"✅ Completed processing project '{project_id}'")
+
+            logger.info(f"✅ Completed processing project '{project_id}'")
 
             # Merge employees (unique by name)
             for emp in schedule_part.employees:
@@ -87,17 +92,17 @@ class DataService:
             # Append tasks with project id already set
             combined_tasks.extend(schedule_part.tasks)
 
-        logging.info(
+        logger.info(
             f"👥 Merging data: {len(combined_employees)} unique employees, {len(combined_tasks)} total tasks"
         )
 
         # Build final schedule
-        final_schedule = DataService._build_final_schedule(
+        final_schedule = DataService.build_final_schedule(
             combined_employees, combined_tasks, employee_count, days_in_schedule
         )
 
         # Convert to DataFrames
-        emp_df, task_df = DataService._convert_to_dataframes(final_schedule, debug)
+        emp_df, task_df = DataService.convert_to_dataframes(final_schedule, debug)
 
         # Generate job ID and state data
         job_id = str(uuid.uuid4())
@@ -108,12 +113,12 @@ class DataService:
         }
 
         status_message = f"Data loaded successfully from {project_source_info}"
-        logging.info("🎉 Data loading completed successfully!")
+        logger.info("🎉 Data loading completed successfully!")
 
         return emp_df, task_df, job_id, status_message, state_data
 
     @staticmethod
-    def _process_uploaded_files(file_obj: Any) -> Tuple[List[Any], str]:
+    def process_uploaded_files(file_obj: Any) -> Tuple[List[Any], str]:
         """Process uploaded files and return file list and description"""
         if file_obj is None:
             raise ValueError("No file uploaded. Please upload a file.")
@@ -121,12 +126,12 @@ class DataService:
         # Support multiple files. Gradio returns a list when multiple files are selected.
         files = file_obj if isinstance(file_obj, list) else [file_obj]
         project_source_info = f"{len(files)} file(s)"
-        logging.info(f"📄 Found {len(files)} file(s) to process")
+        logger.info(f"📄 Found {len(files)} file(s) to process")
 
         return files, project_source_info
 
     @staticmethod
-    def _process_mock_projects(
+    def process_mock_projects(
         mock_projects: Union[str, List[str], None]
     ) -> Tuple[List[str], str]:
         """Process mock projects and return file contents and description"""
@@ -149,12 +154,12 @@ class DataService:
         project_source_info = (
             f"{len(mock_projects)} mock project(s): {', '.join(mock_projects)}"
         )
-        logging.info(f"📋 Selected mock projects: {', '.join(mock_projects)}")
+        logger.info(f"📋 Selected mock projects: {', '.join(mock_projects)}")
 
         return files, project_source_info
 
     @staticmethod
-    def _derive_project_id(
+    def derive_project_id(
         project_source: str,
         single_file: Any,
         mock_projects: Union[str, List[str], None],
@@ -164,16 +169,19 @@ class DataService:
         if project_source == "Upload Project Files":
             try:
                 return os.path.splitext(os.path.basename(single_file.name))[0]
+
             except AttributeError:
                 return f"project_{idx+1}"
+
         else:
             # For mock projects, use the mock project name as the project ID
             if isinstance(mock_projects, list):
                 return mock_projects[idx]
+
             return mock_projects or f"project_{idx+1}"
 
     @staticmethod
-    def _build_final_schedule(
+    def build_final_schedule(
         combined_employees: Dict[str, Employee],
         combined_tasks: List[Task],
         employee_count: Optional[int],
@@ -184,7 +192,7 @@ class DataService:
 
         # Override with custom parameters if provided
         if employee_count is not None or days_in_schedule is not None:
-            logging.info(
+            logger.info(
                 f"⚙️ Customizing parameters: {employee_count} employees, {days_in_schedule} days"
             )
             parameters = TimeTableDataParameters(
@@ -200,7 +208,8 @@ class DataService:
                 random_seed=parameters.random_seed,
             )
 
-        logging.info("🏗️ Building final schedule structure...")
+        logger.info("🏗️ Building final schedule structure...")
+
         return EmployeeSchedule(
             employees=list(combined_employees.values()),
             tasks=combined_tasks,
@@ -210,11 +219,11 @@ class DataService:
         )
 
     @staticmethod
-    def _convert_to_dataframes(
+    def convert_to_dataframes(
         schedule: EmployeeSchedule, debug: bool = False
     ) -> Tuple[pd.DataFrame, pd.DataFrame]:
         """Convert schedule to DataFrames for display"""
-        logging.info("📊 Converting to data tables...")
+        logger.info("📊 Converting to data tables...")
         emp_df: pd.DataFrame = employees_to_dataframe(schedule)
         task_df: pd.DataFrame = schedule_to_dataframe(schedule)
 
@@ -234,12 +243,12 @@ class DataService:
 
         if debug:
             # Log sequence numbers for debugging
-            logging.info("Task sequence numbers after load_data:")
+            logger.info("Task sequence numbers after load_data:")
             for _, row in task_df.iterrows():
-                logging.info(
+                logger.info(
                     f"Project: {row['Project']}, Sequence: {row['Sequence']}, Task: {row['Task']}"
                 )
-            logging.info("Task DataFrame being set in load_data: %s", task_df.head())
+            logger.info("Task DataFrame being set in load_data: %s", task_df.head())
 
         return emp_df, task_df
 
@@ -261,20 +270,22 @@ class DataService:
             raise ValueError("No task_df_json provided")
 
         try:
-            logging.info("📋 Parsing task data from JSON...")
+            logger.info("📋 Parsing task data from JSON...")
             task_df: pd.DataFrame = pd.read_json(StringIO(task_df_json), orient="split")
-            logging.info(f"📊 Found {len(task_df)} tasks to schedule")
+            logger.info(f"📊 Found {len(task_df)} tasks to schedule")
 
             if debug:
-                logging.info("Task sequence numbers from JSON:")
+                logger.info("Task sequence numbers from JSON:")
+
                 for _, row in task_df.iterrows():
-                    logging.info(
+                    logger.info(
                         f"Project: {row.get('Project', 'N/A')}, Sequence: {row.get('Sequence', 'N/A')}, Task: {row['Task']}"
                     )
 
             return task_df
+
         except Exception as e:
-            logging.error(f"❌ Error parsing task_df_json: {e}")
+            logger.error(f"❌ Error parsing task_df_json: {e}")
             raise ValueError(f"Error parsing task data: {str(e)}")
 
     @staticmethod
@@ -288,7 +299,7 @@ class DataService:
         Returns:
             List of Task objects
         """
-        logging.info("🆔 Generating task IDs and converting to solver format...")
+        logger.info("🆔 Generating task IDs and converting to solver format...")
         ids = (str(i) for i in range(len(task_df)))
 
         tasks = []
@@ -305,5 +316,5 @@ class DataService:
                 )
             )
 
-        logging.info(f"✅ Converted {len(tasks)} tasks for solver")
+        logger.info(f"✅ Converted {len(tasks)} tasks for solver")
         return tasks

src/services/logging_service.py

@@ -3,6 +3,12 @@ import threading
 from datetime import datetime
 from typing import List
 
+from utils.logging_config import setup_logging, get_logger, is_debug_enabled
+
+# Initialize logging
+setup_logging()
+logger = get_logger(__name__)
+
 
 class LogCapture:
     """Helper class to capture logs for streaming to UI"""
@@ -52,27 +58,40 @@ class LoggingService:
 
     def setup_log_streaming(self) -> None:
         """Set up log streaming to capture logs for UI"""
-        logger = logging.getLogger()
+        # Use the root logger which is configured by our centralized system
+        root_logger = logging.getLogger()
 
-        # Remove existing handlers to avoid duplicate logs
-        for handler in logger.handlers[:]:
+        # Remove existing streaming handlers to avoid duplicates
+        for handler in root_logger.handlers[:]:
             if isinstance(handler, StreamingLogHandler):
-                logger.removeHandler(handler)
+                root_logger.removeHandler(handler)
 
         # Add our streaming handler
         stream_handler = StreamingLogHandler(self.log_capture)
-        stream_handler.setLevel(logging.INFO)
-        formatter = logging.Formatter("%(levelname)s - %(message)s")
+
+        # Respect the debug flag when setting the handler level
+        if is_debug_enabled():
+            stream_handler.setLevel(logging.DEBUG)
+            logger.debug("UI log streaming configured for DEBUG level")
+        else:
+            stream_handler.setLevel(logging.INFO)
+            logger.debug("UI log streaming configured for INFO level")
+
+        # Use a more detailed formatter for UI streaming
+        formatter = logging.Formatter("%(levelname)s - %(name)s - %(message)s")
         stream_handler.setFormatter(formatter)
-        logger.addHandler(stream_handler)
+        root_logger.addHandler(stream_handler)
         self._handler_added = True
 
+        logger.debug("UI log streaming handler added to root logger")
+
     def get_streaming_logs(self) -> str:
         """Get accumulated logs for streaming to UI"""
         return self.log_capture.get_logs()
 
     def clear_streaming_logs(self) -> None:
         """Clear accumulated logs"""
+        logger.debug("Clearing UI streaming logs")
         self.log_capture.clear()
 
     def is_setup(self) -> bool:

src/services/schedule_service.py

@@ -1,13 +1,11 @@
-import uuid
-import logging
-import random
+import os, uuid, random
 from datetime import datetime
 from typing import Tuple, Dict, Any, Optional
 
 import pandas as pd
 import gradio as gr
 
-from state import app_state
+from .state_service import StateService
 from constraint_solvers.timetable.solver import solver_manager
 from factory.data_provider import (
     generate_employees,
@@ -17,15 +15,16 @@ from factory.data_provider import (
     SLOTS_PER_DAY,
 )
 
-from constraint_solvers.timetable.domain import (
-    EmployeeSchedule,
-    ScheduleInfo,
-    Task,
-)
+from constraint_solvers.timetable.domain import EmployeeSchedule, ScheduleInfo
 
 from helpers import schedule_to_dataframe, employees_to_dataframe
 from .data_service import DataService
 from constraint_solvers.timetable.analysis import ConstraintViolationAnalyzer
+from utils.logging_config import setup_logging, get_logger
+
+# Initialize logging
+setup_logging()
+logger = get_logger(__name__)
 
 
 class ScheduleService:
@@ -46,33 +45,25 @@ class ScheduleService:
         Returns:
             Tuple of (emp_df, task_df, new_job_id, status_message, state_data)
         """
-        logging.info(f"🔧 solve_schedule_from_state called with job_id: {job_id}")
-        logging.info("🚀 Starting solve process...")
-
-        # Set debug environment variable for constraint system
-        import os
+        logger.info(f"🔧 solve_schedule_from_state called with job_id: {job_id}")
+        logger.info("🚀 Starting solve process...")
 
         if debug:
             os.environ["YUGA_DEBUG"] = "true"
+            # Reconfigure logging for debug mode
+            setup_logging("DEBUG")
+
         else:
             os.environ["YUGA_DEBUG"] = "false"
 
-        # Handle both old format (string) and new format (dict) for backward compatibility
-        if isinstance(state_data, str):
-            task_df_json = state_data
-            employee_count = None
-            days_in_schedule = None
-        elif isinstance(state_data, dict):
-            task_df_json = state_data.get("task_df_json")
-            employee_count = state_data.get("employee_count")
-            days_in_schedule = state_data.get("days_in_schedule")
-        else:
-            task_df_json = None
-            employee_count = None
-            days_in_schedule = None
+        # Extract parameters from state data dict
+        task_df_json = state_data.get("task_df_json")
+        employee_count = state_data.get("employee_count")
+        days_in_schedule = state_data.get("days_in_schedule")
 
         if not task_df_json:
-            logging.warning("❌ No task_df_json provided to solve_schedule_from_state")
+            logger.warning("❌ No task_df_json provided to solve_schedule_from_state")
+
             return (
                 gr.update(),
                 gr.update(),
@@ -90,15 +81,16 @@ class ScheduleService:
 
             # Debug: Log task information if debug is enabled
             if debug:
-                logging.info("🔍 DEBUG: Task information for constraint checking:")
+                logger.info("🔍 DEBUG: Task information for constraint checking:")
+
                 for task in tasks:
-                    logging.info(
+                    logger.info(
                         f"  Task ID: {task.id}, Project: '{task.project_id}', "
                         f"Sequence: {task.sequence_number}, Description: '{task.description[:30]}...'"
                     )
 
             # Generate schedule
-            schedule = ScheduleService._generate_schedule_for_solving(
+            schedule = ScheduleService.generate_schedule_for_solving(
                 tasks, employee_count, days_in_schedule
             )
 
@@ -108,13 +100,14 @@ class ScheduleService:
                 solved_task_df,
                 new_job_id,
                 status,
-            ) = await ScheduleService._solve_schedule(schedule, debug)
+            ) = await ScheduleService.solve_schedule(schedule, debug)
 
-            logging.info("📈 Solver process initiated successfully")
+            logger.info("📈 Solver process initiated successfully")
             return emp_df, solved_task_df, new_job_id, status, state_data
 
         except Exception as e:
-            logging.error(f"Error in solve_schedule_from_state: {e}")
+            logger.error(f"Error in solve_schedule_from_state: {e}")
+
             return (
                 gr.update(),
                 gr.update(),
@@ -124,7 +117,7 @@ class ScheduleService:
             )
 
     @staticmethod
-    def _generate_schedule_for_solving(
+    def generate_schedule_for_solving(
         tasks: list, employee_count: Optional[int], days_in_schedule: Optional[int]
     ) -> EmployeeSchedule:
         """Generate a complete schedule ready for solving"""
@@ -145,16 +138,38 @@ class ScheduleService:
                 random_seed=parameters.random_seed,
             )
 
-        logging.info("👥 Generating employees and availability...")
+        logger.info("👥 Generating employees and availability...")
         start_date = datetime.now().date()
+
         randomizer = random.Random(parameters.random_seed)
-        employees = generate_employees(parameters, randomizer)
-        logging.info(f"✅ Generated {len(employees)} employees")
 
-        # Generate employee availability preferences
-        logging.info("📅 Generating employee availability preferences...")
-        generate_employee_availability(employees, parameters, start_date, randomizer)
-        logging.info("✅ Employee availability generated")
+        # Analyze tasks to determine what skills are actually needed
+        required_skills_needed = set()
+        for task in tasks:
+            if hasattr(task, "required_skill") and task.required_skill:
+                required_skills_needed.add(task.required_skill)
+
+        logger.info(f"🔍 Tasks require skills: {sorted(required_skills_needed)}")
+
+        # Generate employees with skills needed for the tasks
+        employees = generate_employees(parameters, randomizer, required_skills_needed)
+
+        # For single employee scenarios, set name and clear availability constraints
+        if parameters.employee_count == 1 and len(employees) == 1:
+            employees[0].name = "Chatbot User"
+            employees[0].unavailable_dates.clear()
+            employees[0].undesired_dates.clear()
+            employees[0].desired_dates.clear()
+
+        else:
+            # Generate employee availability preferences for multi-employee scenarios
+            logger.info("📅 Generating employee availability preferences...")
+            generate_employee_availability(
+                employees, parameters, start_date, randomizer
+            )
+            logger.info("✅ Employee availability generated")
+
+        logger.info(f"✅ Generated {len(employees)} employees")
 
         return EmployeeSchedule(
             employees=employees,
@@ -165,7 +180,7 @@ class ScheduleService:
         )
 
     @staticmethod
-    async def _solve_schedule(
+    async def solve_schedule(
         schedule: EmployeeSchedule, debug: bool = False
     ) -> Tuple[pd.DataFrame, pd.DataFrame, str, str]:
         """
@@ -185,7 +200,7 @@ class ScheduleService:
 
         # Start solving asynchronously
         def listener(solution):
-            app_state.add_solved_schedule(job_id, solution)
+            StateService.store_solved_schedule(job_id, solution)
 
         solver_manager.solve_and_listen(job_id, schedule, listener)
 
@@ -222,17 +237,18 @@ class ScheduleService:
         Returns:
             Tuple of (emp_df, task_df, job_id, status_message, schedule)
         """
-        if job_id and app_state.has_solved_schedule(job_id):
-            solved_schedule: EmployeeSchedule = app_state.get_solved_schedule(job_id)
+        if job_id and StateService.has_solved_schedule(job_id):
+            solved_schedule: EmployeeSchedule = StateService.get_solved_schedule(job_id)
 
             emp_df: pd.DataFrame = employees_to_dataframe(solved_schedule)
             task_df: pd.DataFrame = schedule_to_dataframe(solved_schedule)
 
             if debug:
                 # Log solved task order for debugging
-                logging.info("Solved task order:")
+                logger.info("Solved task order:")
+
                 for _, row in task_df.iterrows():
-                    logging.info(
+                    logger.info(
                         f"Project: {row['Project']}, Sequence: {row['Sequence']}, Task: {row['Task'][:30]}, Start: {row['Start']}"
                     )
 
@@ -250,7 +266,7 @@ class ScheduleService:
             ].sort_values(["Start"])
 
             # Check if hard constraints are violated (infeasible solution)
-            status_message = ScheduleService._generate_status_message(solved_schedule)
+            status_message = ScheduleService.generate_status_message(solved_schedule)
 
             return emp_df, task_df, job_id, status_message, solved_schedule
 
@@ -272,8 +288,8 @@ class ScheduleService:
             Tuple of (emp_df, task_df, job_id, status_message, llm_output)
         """
         try:
-            if job_id and app_state.has_solved_schedule(job_id):
-                schedule = app_state.get_solved_schedule(job_id)
+            if job_id and StateService.has_solved_schedule(job_id):
+                schedule = StateService.get_solved_schedule(job_id)
                 emp_df = employees_to_dataframe(schedule)
                 task_df = schedule_to_dataframe(schedule)
 
@@ -281,16 +297,16 @@ class ScheduleService:
                 task_df = task_df.sort_values("Start")
 
                 if debug:
-                    logging.info(f"Polling for job {job_id}")
-                    logging.info(f"Current schedule state: {task_df.head()}")
+                    logger.info(f"Polling for job {job_id}")
+                    logger.info(f"Current schedule state: {task_df.head()}")
 
                 # Generate status message based on constraint satisfaction
-                status_message = ScheduleService._generate_status_message(schedule)
+                status_message = ScheduleService.generate_status_message(schedule)
 
                 return emp_df, task_df, job_id, status_message, llm_output
 
         except Exception as e:
-            logging.error(f"Error polling: {e}")
+            logger.error(f"Error polling: {e}")
             return (
                 gr.update(),
                 gr.update(),
@@ -308,7 +324,7 @@ class ScheduleService:
         )
 
     @staticmethod
-    def _generate_status_message(schedule: EmployeeSchedule) -> str:
+    def generate_status_message(schedule: EmployeeSchedule) -> str:
         """Generate status message based on schedule score and constraint violations"""
         status_message = "Solution updated"
 
@@ -327,13 +343,14 @@ class ScheduleService:
                     f"⚠️ CONSTRAINTS VIOLATED: {violation_count} hard constraint(s) could not be satisfied. "
                     f"The schedule is not feasible.\n\n{violation_details}\n\nSuggestions:\n{suggestion_text}"
                 )
-                logging.warning(
+                logger.warning(
                     f"Infeasible solution detected. Hard score: {hard_score}"
                 )
+
             else:
                 soft_score = schedule.score.soft_score
                 status_message = f"✅ Solved successfully! Score: {hard_score}/{soft_score} (hard/soft)"
-                logging.info(
+                logger.info(
                     f"Feasible solution found. Score: {hard_score}/{soft_score}"
                 )
 

src/services/state_service.py

@@ -0,0 +1,96 @@
+from typing import Optional
+from state import app_state
+from constraint_solvers.timetable.domain import EmployeeSchedule
+from utils.logging_config import setup_logging, get_logger
+
+# Initialize logging
+setup_logging()
+logger = get_logger(__name__)
+
+
+class StateService:
+    """Service for managing application state operations"""
+
+    @staticmethod
+    def store_solved_schedule(
+        job_id: str, schedule: Optional[EmployeeSchedule]
+    ) -> None:
+        """
+        Store a solved schedule in the application state.
+
+        Args:
+            job_id: Unique identifier for the job
+            schedule: The schedule to store (can be None for placeholder)
+        """
+        logger.debug(f"Storing schedule for job_id: {job_id}")
+        app_state.add_solved_schedule(job_id, schedule)
+
+    @staticmethod
+    def has_solved_schedule(job_id: str) -> bool:
+        """
+        Check if a solved schedule exists for the given job ID.
+
+        Args:
+            job_id: Job identifier to check
+
+        Returns:
+            True if a solved schedule exists for the job ID
+        """
+        return app_state.has_solved_schedule(job_id)
+
+    @staticmethod
+    def get_solved_schedule(job_id: str) -> Optional[EmployeeSchedule]:
+        """
+        Retrieve a solved schedule by job ID.
+
+        Args:
+            job_id: Job identifier to retrieve
+
+        Returns:
+            The solved schedule if it exists, None otherwise
+        """
+        if app_state.has_solved_schedule(job_id):
+            return app_state.get_solved_schedule(job_id)
+        return None
+
+    @staticmethod
+    def clear_schedule(job_id: str) -> None:
+        """
+        Clear a schedule from application state.
+
+        Args:
+            job_id: Job identifier to clear
+        """
+        logger.debug(f"Clearing schedule for job_id: {job_id}")
+        # Note: app_state doesn't have a clear method, but we can implement if needed
+        # For now, we'll log the request
+        logger.warning(
+            f"Clear schedule requested for {job_id} but not implemented in app_state"
+        )
+
+    @staticmethod
+    def get_all_job_ids() -> list:
+        """
+        Get all job IDs currently in the state.
+
+        Returns:
+            List of job IDs
+        """
+        # Note: This would need to be implemented in app_state if needed
+        logger.warning("get_all_job_ids called but not implemented in app_state")
+        return []
+
+    @staticmethod
+    def get_state_info() -> dict:
+        """
+        Get general information about the current state.
+
+        Returns:
+            Dictionary with state information
+        """
+        # This is a placeholder for state introspection
+        return {
+            "service": "StateService",
+            "status": "active",
+            "note": "State information retrieval not fully implemented",
+        }

src/utils/extract_calendar.py

@@ -5,6 +5,7 @@ def extract_ical_entries(file_bytes):
     try:
         cal = Calendar.from_ical(file_bytes)
         entries = []
+
         for component in cal.walk():
             if component.name == "VEVENT":
                 summary = str(component.get("summary", ""))
@@ -14,9 +15,12 @@ def extract_ical_entries(file_bytes):
                 def to_iso(val):
                     if hasattr(val, "dt"):
                         dt = val.dt
+
                         if hasattr(dt, "isoformat"):
                             return dt.isoformat()
+
                         return str(dt)
+
                     return str(val)
 
                 entries.append(
@@ -26,6 +30,8 @@ def extract_ical_entries(file_bytes):
                         "dtend": to_iso(dtend),
                     }
                 )
+
         return entries, None
+
     except Exception as e:
         return None, str(e)

src/utils/load_secrets.py

@@ -1,7 +1,10 @@
-import os, logging
+import os
 
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+from utils.logging_config import setup_logging, get_logger
+
+# Initialize logging
+setup_logging()
+logger = get_logger(__name__)
 
 ### SECRETS ###
 def load_secrets(secrets_file: str):

src/utils/logging_config.py

@@ -0,0 +1,84 @@
+"""
+Centralized Logging Configuration for Yuga Planner
+
+This module provides a unified logging configuration that:
+1. Respects the YUGA_DEBUG environment variable for debug logging
+2. Uses consistent formatting across the entire codebase
+3. Eliminates the need for individual logging.basicConfig() calls
+
+Usage:
+    from utils.logging_config import setup_logging, get_logger
+
+    # Initialize logging (typically done once per module)
+    setup_logging()
+    logger = get_logger(__name__)
+
+    # Use logging methods
+    logger.debug("Debug message - only shown when YUGA_DEBUG=true")
+    logger.info("Info message - always shown")
+    logger.warning("Warning message")
+    logger.error("Error message")
+
+Environment Variables:
+    YUGA_DEBUG: Set to "true" to enable debug logging
+
+Migration from old logging:
+    Replace:
+        import logging
+        logging.basicConfig(level=logging.INFO)
+        logger = logging.getLogger(__name__)
+
+    With:
+        from utils.logging_config import setup_logging, get_logger
+        setup_logging()
+        logger = get_logger(__name__)
+"""
+
+import logging
+import os
+from typing import Optional
+
+
+def setup_logging(level: Optional[str] = None) -> None:
+    """
+    Set up centralized logging configuration for the application.
+
+    Args:
+        level: Override the logging level. If None, uses YUGA_DEBUG environment variable.
+    """
+    # Determine logging level
+    if level is not None:
+        log_level = getattr(logging, level.upper(), logging.INFO)
+
+    else:
+        debug_enabled = os.getenv("YUGA_DEBUG", "false").lower() == "true"
+        log_level = logging.DEBUG if debug_enabled else logging.INFO
+
+    # Configure logging
+    logging.basicConfig(
+        level=log_level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    # Log the configuration
+    logger = logging.getLogger(__name__)
+    logger.debug("Debug logging enabled via YUGA_DEBUG environment variable")
+
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    Get a logger instance with the specified name.
+
+    Args:
+        name: Name for the logger, typically __name__
+
+    Returns:
+        Configured logger instance
+    """
+    return logging.getLogger(name)
+
+
+def is_debug_enabled() -> bool:
+    """Check if debug logging is enabled via environment variable."""
+    return os.getenv("YUGA_DEBUG", "false").lower() == "true"