Added planning agent

Add .env.example and .gitignore files; implement GradioPlanningAgent for AI-powered planning in app.py; update README with setup instructions and features; add settings management; include test script for planning agent.

.env.example

@@ -0,0 +1,12 @@
+MODEL_ID=Qwen/Qwen2.5-Coder-32B-Instruct
+API_BASE_URL=
+API_KEY=
+
+# Application Settings
+GRADIO_HOST=127.0.0.1
+GRADIO_PORT=7860
+GRADIO_DEBUG=true
+
+# Planning Agent Settings
+PLANNING_VERBOSITY=1
+MAX_PLANNING_STEPS=10

.gitignore

@@ -0,0 +1,281 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be added to the global gitignore or merged into this project gitignore.  For a PyCharm
+#  project, it is usually recommended to include .idea/ directory in version control.
+.idea/
+
+# VS Code
+.vscode/
+*.code-workspace
+
+# Sublime Text
+*.sublime-project
+*.sublime-workspace
+
+# Vim
+*.swp
+*.swo
+*~
+
+# Emacs
+*~
+\#*\#
+/.emacs.desktop
+/.emacs.desktop.lock
+*.elc
+auto-save-list
+tramp
+.\#*
+
+# macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+Icon
+._*
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+# Windows
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+Desktop.ini
+$RECYCLE.BIN/
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+*.lnk
+
+# Linux
+*~
+.fuse_hidden*
+.directory
+.Trash-*
+.nfs*
+
+# UV (Python package manager)
+.uv/
+
+# Gradio
+gradio_cached_examples/
+flagged/
+
+# Project specific
+*.md
+!README.md
+!.env.example
+user_app_plan.md
+plan_*.md
+
+# Logs
+*.log
+logs/
+
+# Temporary files
+tmp/
+temp/
+.tmp/
+
+# Generated content
+generated/
+output/
+
+# AI model cache
+.cache/
+models/
+*.pkl
+*.pickle
+
+# Jupyter notebooks (optional - uncomment if you don't want to track notebooks)
+# *.ipynb
+
+# Local configuration overrides
+local_settings.py
+config_local.py
+
+# Screenshots and media (for demos)
+screenshots/
+*.png
+*.jpg
+*.jpeg
+*.gif
+*.mp4
+*.avi
+
+# Database files
+*.db
+*.sqlite
+*.sqlite3
+
+# Backup files
+*.bak
+*.backup
+*.old

README.md

@@ -1,5 +1,121 @@
-# 💗Likable
-It's almost Lovable - Build Gradio apps, using only a chat interface.
+# 💗 Likable
 
-## Notes
-- Use as little custom css as possible!!!
+A Gradio application builder powered by Smolagents CodeAgent for intelligent planning.
+
+## Features
+
+- **AI-Powered Planning**: Uses Smolagents CodeAgent to create comprehensive plans for Gradio applications
+- **Interactive Chat Interface**: Describe what you want to build in natural language
+- **Structured Planning Output**: Get detailed action plans, implementation strategies, and testing approaches
+- **Component Analysis**: Automatically identifies required Gradio components and dependencies
+- **Preview & Code Views**: Switch between live preview and generated code
+- **Environment-based Configuration**: Flexible configuration via environment variables
+
+## Setup
+
+1. **Install dependencies:**
+   ```bash
+   uv install
+   ```
+
+2. **Configure environment variables:**
+   ```bash
+   # Copy the example environment file
+   cp .env.example .env
+
+   # Edit .env with your configuration
+   # At minimum, set your API_KEY
+   ```
+
+3. **Set up your API_KEY:**
+
+   Add it to your `.env` file:
+   ```
+   API_KEY=your_actual_key_here
+   ```
+
+4. **Run the application:**
+   ```bash
+   python app.py
+   ```
+
+## Configuration
+
+The application uses environment variables for configuration. See `.env.example` for all available options:
+
+### Core Configuration
+- `API_KEY`: Your API key (required)
+- `MODEL_ID`: Model to use for planning (default: Qwen/Qwen2.5-Coder-32B-Instruct)
+
+### Application Settings
+- `GRADIO_HOST`: Host to bind Gradio server (default: 127.0.0.1)
+- `GRADIO_PORT`: Port for Gradio server (default: 7860)
+- `GRADIO_DEBUG`: Enable debug mode (default: true)
+
+### Planning Agent Settings
+- `PLANNING_VERBOSITY`: Agent verbosity level 0-2 (default: 1)
+- `MAX_PLANNING_STEPS`: Maximum planning steps (default: 10)
+
+### Test Your Configuration
+```bash
+# View current configuration
+python settings.py
+
+# Test the planning agent
+python test_planning_agent.py
+
+# Interactive demo
+python test_planning_agent.py demo
+```
+
+## Planning Agent
+
+The core of Likable is the `GradioPlanningAgent` which uses Smolagents to:
+
+- Analyze your application requirements
+- Create detailed action plans
+- Suggest appropriate Gradio components
+- Plan implementation strategies
+- Design testing approaches
+- Estimate complexity and dependencies
+
+### Using the Planning Agent Directly
+
+```python
+from planning_agent import GradioPlanningAgent
+
+# Uses configuration from settings.py (loads from .env)
+agent = GradioPlanningAgent()
+result = agent.plan_application("Create a simple calculator app")
+
+print(agent.format_plan_as_markdown(result))
+```
+
+## Project Structure
+
+```
+likable/
+├── app.py                 # Main Gradio application
+├── planning_agent.py      # Smolagents CodeAgent for planning
+├── settings.py            # Configuration management
+├── test_planning_agent.py # Test script and examples
+├── .env.example           # Environment variables template
+├── pyproject.toml         # Project dependencies
+└── README.md              # This file
+```
+
+## Environment Requirements
+
+- Python 3.12+
+- Inference API key
+- Internet connection for model inference
+
+## Dependencies
+
+- `gradio` - Web UI framework
+- `smolagents` - AI agent framework
+- `python-dotenv` - Environment variable management
+
+---
+
+*Built with ❤️ using Gradio and Smolagents*

app.py

@@ -1,27 +1,87 @@
-import random
-import time
-
 import gradio as gr
 
+from planning_agent import GradioPlanningAgent
+from settings import settings
+
 gr.NO_RELOAD = False
 
+# Initialize the planning agent globally
+planning_agent = None
+
+
+def get_planning_agent():
+    """Get or initialize the planning agent (lazy loading)."""
+    global planning_agent
+    if planning_agent is None:
+        try:
+            planning_agent = GradioPlanningAgent()
+        except Exception as e:
+            print(f"Error initializing planning agent: {e}")
+            return None
+    return planning_agent
+
+
+# Enhanced AI response using the planning agent
+def ai_response_with_planning(message, history):
+    """Generate AI response using the planning agent for actual planning."""
+
+    agent = get_planning_agent()
+
+    if agent is None:
+        # Fallback to mock response if agent fails to initialize
+        response = (
+            "Sorry, the planning agent is not available. "
+            "Please check your API_KEY environment variable."
+        )
+        history.append({"role": "user", "content": message})
+        history.append({"role": "assistant", "content": response})
+        return history, ""
+
+    try:
+        # Use the planning agent for actual planning
+        planning_result = agent.plan_application(message)
+
+        # Format the response with key insights
+        action_summary = (
+            planning_result.action_plan[:300] + "..."
+            if len(planning_result.action_plan) > 300
+            else planning_result.action_plan
+        )
+
+        components_list = chr(10).join(
+            [f"• {comp}" for comp in planning_result.gradio_components[:5]]
+        )
+        dependencies_list = chr(10).join(
+            [f"• {dep}" for dep in planning_result.dependencies[:5]]
+        )
+
+        response = f"""I'll help you plan that application! Here's what I've analyzed:
+
+**Complexity**: {planning_result.estimated_complexity}
 
-# Mock function to simulate AI responses
-def simulate_ai_response(message, history):
-    """Simulate an AI response for demonstration purposes"""
-    time.sleep(1)  # Simulate processing time
+**Key Gradio Components Needed**:
+{components_list}
 
-    # Simple demo responses
-    responses = [
-        "I'll help you build that! Let me generate some code for you.",
-        "Great idea! I'm working on implementing that feature.",
-        "Here's what I can create for you based on your request.",
-        "Let me design that component and show you a preview.",
-        "I understand what you need. I'll code that up right now!",
-    ]
+**Dependencies Required**:
+{dependencies_list}
+
+**High-Level Action Plan**:
+{action_summary}
+
+I've created a comprehensive plan including implementation details and testing \
+strategy. Check the detailed view for the complete plan!"""
+
+        # Store the full planning result for later use
+        # You could save this to a session state or database
+
+    except Exception as e:
+        response = (
+            f"I encountered an error while planning: {str(e)}. "
+            "Let me try a simpler approach..."
+        )
 
-    response = random.choice(responses)
-    history.append([message, response])
+    history.append({"role": "user", "content": message})
+    history.append({"role": "assistant", "content": response})
     return history, ""
 
 
@@ -120,7 +180,7 @@ def create_lovable_ui():
                             height=500,
                             show_copy_button=True,
                             avatar_images=(None, "🤖"),
-                            bubble_full_width=False,
+                            type="messages",
                         )
 
                         with gr.Row():
@@ -151,7 +211,7 @@ def create_lovable_ui():
                             height=500,
                             show_copy_button=True,
                             avatar_images=(None, "🤖"),
-                            bubble_full_width=False,
+                            type="messages",
                         )
 
                         with gr.Row():
@@ -181,26 +241,26 @@ def create_lovable_ui():
 
         # Event handlers for Preview tab
         msg_input_preview.submit(
-            simulate_ai_response,
+            ai_response_with_planning,
             inputs=[msg_input_preview, chatbot_preview],
             outputs=[chatbot_preview, msg_input_preview],
         )
 
         send_btn_preview.click(
-            simulate_ai_response,
+            ai_response_with_planning,
             inputs=[msg_input_preview, chatbot_preview],
             outputs=[chatbot_preview, msg_input_preview],
         )
 
         # Event handlers for Code tab
         msg_input_code.submit(
-            simulate_ai_response,
+            ai_response_with_planning,
             inputs=[msg_input_code, chatbot_code],
             outputs=[chatbot_code, msg_input_code],
         )
 
         send_btn_code.click(
-            simulate_ai_response,
+            ai_response_with_planning,
             inputs=[msg_input_code, chatbot_code],
             outputs=[chatbot_code, msg_input_code],
         )
@@ -210,4 +270,5 @@ def create_lovable_ui():
 
 if __name__ == "__main__":
     demo = create_lovable_ui()
-    demo.launch(debug=True)
+    gradio_config = settings.get_gradio_config()
+    demo.launch(**gradio_config)

planning_agent.py

@@ -0,0 +1,288 @@
+"""
+Smolagents CodeAgent for planning Gradio applications.
+
+This module provides a specialized planning agent that can:
+- Take a prompt describing a program
+- Extensively plan how to implement the program using Python and Gradio
+- Return an action, implementation and testing plan
+"""
+
+from dataclasses import dataclass
+
+from smolagents import LiteLLMModel
+
+from settings import settings
+
+
+@dataclass
+class PlanningResult:
+    """Result of the planning agent containing structured plans."""
+
+    action_plan: str
+    implementation_plan: str
+    testing_plan: str
+    gradio_components: list[str]
+    estimated_complexity: str
+    dependencies: list[str]
+
+
+class GradioPlanningAgent:
+    """
+    A specialized CodeAgent for planning Gradio applications.
+
+    This agent takes natural language descriptions of programs and creates
+    comprehensive plans for implementing them with Python and Gradio.
+    """
+
+    def __init__(
+        self,
+        model_id: str | None = None,
+        api_base_url: str | None = None,
+        api_key: str | None = None,
+        verbosity_level: int | None = None,
+    ):
+        """
+        Initialize the Gradio Planning Agent.
+
+        Args:
+            model_id: Model ID to use for planning (uses settings if None)
+            api_base_url: API base URL (uses settings if None)
+            api_key: API key (uses settings if None)
+            verbosity_level: Level of verbosity for agent output (uses settings if None)
+        """
+        # Use settings as defaults, but allow override
+        self.model_id = model_id or settings.model_id
+        self.api_base_url = api_base_url or settings.api_base_url
+        self.api_key = api_key or settings.api_key
+        verbosity_level = verbosity_level or settings.planning_verbosity
+
+        # Initialize the language model
+        self.model = LiteLLMModel(
+            model_id=self.model_id,
+            api_base=self.api_base_url,
+            api_key=self.api_key,
+        )
+
+        self.planning_prompt = """You are an expert software architect and Gradio \
+application developer. Your role is to create comprehensive, detailed plans \
+for building Gradio applications based on user requirements.
+
+IMPORTANT: This is a PLANNING AND ARCHITECTURE phase only. Do NOT write any actual \
+code. Focus on high-level design, structure, and planning. Code implementation will \
+happen in a separate phase.
+
+When given a description of a program to build, you must create three detailed plans:
+
+1. **ACTION PLAN**: Break down the high-level steps needed to build the application
+2. **IMPLEMENTATION PLAN**: Detailed technical implementation using Python and Gradio
+3. **TESTING PLAN**: Comprehensive testing strategy for the application
+
+For each plan, consider:
+- Gradio components needed (gr.Textbox, gr.Button, gr.Chatbot, gr.Plot, etc.)
+- Python dependencies and imports required
+- Data flow and state management
+- User interface design and user experience
+- Error handling and edge cases
+- Performance considerations
+- Deployment considerations
+
+You should structure your response using the following format:
+
+## ACTION PLAN
+[High-level steps and workflow]
+
+## IMPLEMENTATION PLAN
+[Detailed technical implementation with Gradio components]
+
+## TESTING PLAN
+[Comprehensive testing strategy]
+
+## GRADIO COMPONENTS
+[List of Gradio components that will be used]
+
+## ESTIMATED COMPLEXITY
+[Simple/Medium/Complex with brief explanation]
+
+## DEPENDENCIES
+[Required Python packages beyond gradio]
+
+Be thorough, practical, and consider real-world constraints. Focus on creating \
+maintainable, user-friendly Gradio applications. Remember: NO CODE IMPLEMENTATION \
+at this stage - only architectural planning and structural design."""
+
+    def plan_application(self, prompt: str) -> PlanningResult:
+        """
+        Create a comprehensive plan for a Gradio application based on the prompt.
+
+        Args:
+            prompt: Natural language description of the program to build
+
+        Returns:
+            PlanningResult containing structured plans
+        """
+
+        # Enhanced prompt for the agent
+        user_prompt = f"""
+Create a comprehensive plan for building the following Gradio application:
+
+{prompt}
+
+Please provide detailed ACTION, IMPLEMENTATION, and TESTING plans following the \
+specified format. Consider all aspects of the application including UI/UX, \
+functionality, error handling, and deployment.
+"""
+
+        messages = [
+            {"role": "system", "content": self.planning_prompt},
+            {"role": "user", "content": user_prompt},
+        ]
+        response = self.model.generate(messages)
+
+        # Parse the response into structured result
+        return self._parse_planning_response(response.content)
+
+    def _parse_planning_response(self, response: str) -> PlanningResult:
+        """
+        Parse the agent's response into a structured PlanningResult.
+
+        Args:
+            response: Raw response from the planning agent
+
+        Returns:
+            Structured PlanningResult
+        """
+
+        # Initialize default values
+        action_plan = ""
+        implementation_plan = ""
+        testing_plan = ""
+        gradio_components = []
+        estimated_complexity = "Medium"
+        dependencies = ["gradio"]
+
+        # Parse sections from the response
+        sections = self._extract_sections(response)
+
+        action_plan = sections.get("ACTION PLAN", "")
+        implementation_plan = sections.get("IMPLEMENTATION PLAN", "")
+        testing_plan = sections.get("TESTING PLAN", "")
+
+        # Parse gradio components list
+        components_text = sections.get("GRADIO COMPONENTS", "")
+        if components_text:
+            gradio_components = self._extract_list_items(components_text)
+
+        # Parse complexity
+        complexity_text = sections.get("ESTIMATED COMPLEXITY", "")
+        if complexity_text:
+            estimated_complexity = complexity_text.strip()
+
+        # Parse dependencies
+        deps_text = sections.get("DEPENDENCIES", "")
+        if deps_text:
+            dependencies = ["gradio"] + self._extract_list_items(deps_text)
+            # Remove duplicates while preserving order
+            dependencies = list(dict.fromkeys(dependencies))
+
+        return PlanningResult(
+            action_plan=action_plan,
+            implementation_plan=implementation_plan,
+            testing_plan=testing_plan,
+            gradio_components=gradio_components,
+            estimated_complexity=estimated_complexity,
+            dependencies=dependencies,
+        )
+
+    def _extract_sections(self, text: str) -> dict[str, str]:
+        """Extract sections from markdown-formatted text."""
+        sections = {}
+        current_section = None
+        current_content = []
+
+        for line in text.split("\n"):
+            line = line.strip()
+
+            # Check if line is a section header
+            if line.startswith("## "):
+                # Save previous section if exists
+                if current_section and current_content:
+                    sections[current_section] = "\n".join(current_content).strip()
+
+                # Start new section
+                current_section = line[3:].strip()
+                current_content = []
+            elif current_section:
+                current_content.append(line)
+
+        # Save last section
+        if current_section and current_content:
+            sections[current_section] = "\n".join(current_content).strip()
+
+        return sections
+
+    def _extract_list_items(self, text: str) -> list[str]:
+        """Extract list items from text (handles bullet points, numbered lists, etc.)"""
+        items = []
+        for line in text.split("\n"):
+            line = line.strip()
+            if line:
+                # Remove common list prefixes
+                if line.startswith("- "):
+                    line = line[2:].strip()
+                elif line.startswith("* "):
+                    line = line[2:].strip()
+                elif ". " in line and line.split(".")[0].isdigit():
+                    line = line.split(".", 1)[1].strip()
+
+                if line:
+                    items.append(line)
+
+        return items
+
+    def format_plan_as_markdown(self, result: PlanningResult) -> str:
+        """
+        Format the planning result as a well-structured markdown document.
+
+        Args:
+            result: PlanningResult to format
+
+        Returns:
+            Markdown-formatted string
+        """
+
+        markdown = f"""# Gradio Application Plan
+
+## 📋 Action Plan
+{result.action_plan}
+
+## 🔧 Implementation Plan
+{result.implementation_plan}
+
+## 🧪 Testing Plan
+{result.testing_plan}
+
+## 🎨 Gradio Components
+{chr(10).join([f"- {component}" for component in result.gradio_components])}
+
+## ⚡ Estimated Complexity
+{result.estimated_complexity}
+
+## 📦 Dependencies
+{chr(10).join([f"- {dep}" for dep in result.dependencies])}
+"""
+
+        return markdown
+
+
+# Example usage and testing
+if __name__ == "__main__":
+    # Example of how to use the planning agent
+    agent = GradioPlanningAgent()
+
+    # Test with a simple calculator example
+    result = agent.plan_application(
+        "Write a simple calculator app that can perform basic arithmetic operations"
+    )
+
+    print("=== PLANNING RESULT ===")
+    print(agent.format_plan_as_markdown(result))

pyproject.toml

@@ -6,6 +6,7 @@ readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
     "gradio>=5.32.0",
+    "smolagents[litellm]>=1.17.0",
 ]
 
 [dependency-groups]

settings.py

@@ -0,0 +1,122 @@
+"""
+Application settings loaded from environment variables.
+
+This module handles loading and validation of environment variables
+for the Likable application.
+"""
+
+import os
+
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+
+class Settings:
+    """Application settings loaded from environment variables."""
+
+    def __init__(self):
+        """Initialize settings from environment variables."""
+
+        self.model_id: str = os.getenv("MODEL_ID", "Qwen/Qwen2.5-Coder-32B-Instruct")
+        self.api_base_url: str | None = os.getenv("API_BASE_URL")
+        self.api_key: str | None = os.getenv("API_KEY")
+
+        # Application Settings
+        self.gradio_host: str = os.getenv("GRADIO_HOST", "127.0.0.1")
+        self.gradio_port: int = int(os.getenv("GRADIO_PORT", "7860"))
+        self.gradio_debug: bool = os.getenv("GRADIO_DEBUG", "false").lower() == "true"
+
+        # Planning Agent Settings
+        self.planning_verbosity: int = int(os.getenv("PLANNING_VERBOSITY", "1"))
+        self.max_planning_steps: int = int(os.getenv("MAX_PLANNING_STEPS", "10"))
+
+        # Validate critical settings
+        self._validate()
+
+    def _validate(self):
+        """Validate critical settings and provide helpful error messages."""
+
+        if not self.api_key:
+            print("⚠️  Warning: API_KEY not set in environment variables.")
+            print("   The planning agent may not work without a valid API key.")
+            print("   Set it in your .env file or as an environment variable.")
+            print()
+
+        if self.planning_verbosity not in [0, 1, 2]:
+            print(
+                f"⚠️  Warning: PLANNING_VERBOSITY={self.planning_verbosity} is not \
+in valid range [0, 1, 2]"
+            )
+            print("   Using default value of 1")
+            self.planning_verbosity = 1
+
+    def get_model_config(self) -> dict:
+        """Get model configuration for the planning agent."""
+        config = {"model_id": self.model_id, "api_key": self.api_key}
+
+        if self.api_base_url:
+            config["api_base_url"] = self.api_base_url
+        if self.api_key:
+            config["api_key"] = self.api_key
+
+        return config
+
+    def get_gradio_config(self) -> dict:
+        """Get Gradio launch configuration."""
+        return {
+            "server_name": self.gradio_host,
+            "server_port": self.gradio_port,
+            "debug": self.gradio_debug,
+        }
+
+    def get_planning_config(self) -> dict:
+        """Get planning agent configuration."""
+        return {
+            "verbosity_level": self.planning_verbosity,
+            "max_steps": self.max_planning_steps,
+        }
+
+    def __repr__(self) -> str:
+        """String representation of settings (excluding sensitive data)."""
+        return f"""Settings(
+    model_id='{self.model_id}',
+    api_key={'***' if self.api_key else 'None'},
+    api_base_url='{self.api_base_url}',
+    gradio_host='{self.gradio_host}',
+    gradio_port={self.gradio_port},
+    gradio_debug={self.gradio_debug},
+    planning_verbosity={self.planning_verbosity},
+    max_planning_steps={self.max_planning_steps}
+)"""
+
+
+# Global settings instance
+settings = Settings()
+
+
+# Convenience functions for backward compatibility
+def get_api_key() -> str | None:
+    """Get API key."""
+    return settings.api_key
+
+
+def get_model_id() -> str:
+    """Get model ID."""
+    return settings.model_id
+
+
+if __name__ == "__main__":
+    print("Current Settings:")
+    print("=" * 50)
+    print(settings)
+    print()
+    print("Model Config:")
+    print(settings.get_model_config())
+    print()
+    print("Gradio Config:")
+    print(settings.get_gradio_config())
+    print()
+    print("Planning Config:")
+    print(settings.get_planning_config())

test_planning_agent.py

@@ -0,0 +1,142 @@
+"""
+Test script for the Gradio Planning Agent.
+
+This script demonstrates how to use the planning agent and tests it with
+various prompts.
+"""
+
+from planning_agent import GradioPlanningAgent
+from settings import settings
+
+
+def test_planning_agent():
+    """Test the planning agent with different prompts."""
+
+    # Check if API_KEY is available
+    if not settings.api_key:
+        print("⚠️  Warning: API_KEY environment variable not set.")
+        print("   You may need to set it for the agent to work properly.")
+        print()
+
+    # Display current settings
+    print("Current Configuration:")
+    print(f"   Model ID: {settings.model_id}")
+    print(f"   API Key: {'***' if settings.api_key else 'None'}")
+    print(f"   Verbosity: {settings.planning_verbosity}")
+    print()
+
+    # Initialize the planning agent
+    print("🤖 Initializing Gradio Planning Agent...")
+    agent = GradioPlanningAgent()
+    print("✅ Agent initialized successfully!")
+    print()
+
+    # Test prompts for different types of applications
+    test_prompts = [
+        {
+            "name": "Simple Calculator",
+            "prompt": (
+                "Write a simple calculator app that can perform basic "
+                "arithmetic operations (addition, subtraction, multiplication, "
+                "division)"
+            ),
+        },
+        {
+            "name": "Image Classifier",
+            "prompt": (
+                "Create an image classification app that allows users to "
+                "upload an image and get predictions from a pre-trained model"
+            ),
+        },
+        {
+            "name": "Chat Interface",
+            "prompt": (
+                "Build a chatbot interface where users can have conversations "
+                "with an AI assistant"
+            ),
+        },
+        {
+            "name": "Data Visualization Tool",
+            "prompt": (
+                "Create a data visualization tool that lets users upload CSV "
+                "files and create different types of charts and plots"
+            ),
+        },
+    ]
+
+    # Test each prompt
+    for i, test_case in enumerate(test_prompts, 1):
+        print(f"🧪 Test {i}: {test_case['name']}")
+        print(f"📝 Prompt: {test_case['prompt']}")
+        print("-" * 80)
+
+        try:
+            # Run the planning agent
+            result = agent.plan_application(test_case["prompt"])
+
+            # Display results
+            print("📊 Planning Results:")
+            print(f"   Complexity: {result.estimated_complexity}")
+            print(f"   Components: {', '.join(result.gradio_components[:3])}...")
+            print(f"   Dependencies: {', '.join(result.dependencies[:3])}...")
+            print()
+
+            # Save detailed results to file
+            filename = f"plan_{test_case['name'].lower().replace(' ', '_')}.md"
+            with open(filename, "w") as f:
+                f.write(agent.format_plan_as_markdown(result))
+            print(f"💾 Detailed plan saved to: {filename}")
+
+        except Exception as e:
+            print(f"❌ Error testing {test_case['name']}: {e}")
+
+        print("=" * 80)
+        print()
+
+    print("🎉 Testing completed!")
+
+
+def demo_single_planning():
+    """Demonstrate planning for a single application."""
+
+    print("🎯 Single Application Planning Demo")
+    print("=" * 50)
+
+    # Get user input
+    user_prompt = input("Enter your app description: ").strip()
+
+    if not user_prompt:
+        user_prompt = (
+            "Create a simple todo list app where users can add, edit, "
+            "and delete tasks"
+        )
+        print(f"Using default prompt: {user_prompt}")
+
+    print("\n🤖 Planning your application...")
+
+    try:
+        # Initialize agent and run planning
+        agent = GradioPlanningAgent()
+        result = agent.plan_application(user_prompt)
+
+        # Display formatted results
+        print("\n" + "=" * 60)
+        print(agent.format_plan_as_markdown(result))
+        print("=" * 60)
+
+        # Save to file
+        with open("user_app_plan.md", "w") as f:
+            f.write(agent.format_plan_as_markdown(result))
+        print("\n💾 Plan saved to: user_app_plan.md")
+
+    except Exception as e:
+        print(f"❌ Error during planning: {e}")
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) > 1 and sys.argv[1] == "demo":
+        demo_single_planning()
+    else:
+        test_planning_agent()