Upload 22 files

README.md

@@ -1,13 +1,187 @@
----
-title: Ai Workflow Agent
-emoji: 🚀
-colorFrom: indigo
-colorTo: purple
-sdk: gradio
-sdk_version: 6.8.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# AI Workflow Agent - Milestone 1 (M1 Only)
+
+## What This Package Contains
+
+This is a **standalone M1 implementation** - Core AI Decision Making with CrewAI and GitHub Search.
+
+### Features:
+- AI Decision Engine (picks n8n vs ComfyUI)
+- Multi-turn Chat with Session Management
+- Web Search (DuckDuckGo - no API key)
+- GitHub Project Search
+- 16 Workflow Templates (8 n8n + 8 ComfyUI)
+- Docker Container Management
+
+---
+
+## Prerequisites
+
+### ✅ Required:
+- **Python 3.10+** with virtual environment (already included)
+- **Nothing else!** M1 is fully standalone
+
+### ⚠️ Optional (for enhanced features):
+- **Ollama** (for AI-powered LLM responses)
+  - Without it: Uses smart keyword matching (works perfectly)
+  - With it: Uses Qwen2.5 LLM for deeper analysis
+  - Start: `docker-compose up -d ollama` (from parent directory)
+  - Pull model: `docker exec -it ollama ollama pull qwen2.5:3b`
+
+- **Docker daemon** (for Docker management endpoints only)
+  - Only needed if you want to test `/docker/*` endpoints
+  - Not required for core M1 features
+
+### 🚫 NOT Required:
+- ❌ n8n (M1 only generates workflows, doesn't deploy them)
+- ❌ ComfyUI (M1 only generates workflows, doesn't execute them)
+- ❌ Database (M1 uses in-memory storage)
+- ❌ API keys (DuckDuckGo and GitHub work without auth)
+
+---
+
+## Quick Start
+
+### 1. Use Existing Virtual Environment
+
+```powershell
+# The existing venv from parent directory will be used automatically
+# No need to create a new one!
+```
+
+### 2. Start M1 API Server
+
+```powershell
+cd M1_only
+.\start_m1.ps1
+```
+
+Server runs on: **http://localhost:8001** (different from full app on 8000)
+
+### 3. Access UI Dashboard 🎨
+
+The UI dashboard will automatically open in your browser!
+
+**Manual access:**
+- **UI Dashboard (English):** Open `ui.html` in your browser
+- **UI Dashboard (Spanish):** Open `ui_es.html` in your browser
+- **API Docs:** http://localhost:8001/docs (Swagger documentation)
+
+The UI Dashboard provides:
+- ✨ Beautiful interface for testing all M1 features
+- 🌐 Available in **English** and **Spanish**
+- 🎯 Pre-filled example queries for quick demos
+- 📊 Real-time response display with JSON formatting
+- 🚀 Perfect for client demonstrations
+
+---
+
+## Run Tests
+
+```powershell
+# Run all M1 tests
+python test_m1_integration.py
+
+# Run unit tests
+python test_m1.py
+
+# Run Phase 0 tests
+python test_agent.py
+```
+
+---
+
+## M1 Endpoints
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | /health | Health check |
+| POST | /analyze | AI decision making |
+| POST | /build | Generate workflow |
+| POST | /chat | Multi-turn chat |
+| POST | /github/search | Search GitHub |
+| GET | /search/web | Web search |
+| GET | /search/projects | GitHub projects |
+| GET | /search/alternatives | Find alternatives |
+| GET | /docker/containers | List containers |
+| GET | /docker/logs/{id} | Container logs |
+| DELETE | /docker/stop/{id} | Stop container |
+
+---
+
+## File Structure
+
+```
+M1_only/
+├── main_m1.py              # M1 API server (port 8001)
+├── config.py               # Configuration
+├── decision_agent.py       # AI decision logic
+├── chat_handler.py         # Chat sessions
+├── crew_agents.py          # CrewAI agents
+├── ui.html                 # Web UI Dashboard (English)
+├── ui_es.html              # Web UI Dashboard (Spanish)
+├── tools/
+│   ├── web_search.py       # DuckDuckGo search
+│   ├── github_search.py    # GitHub API
+│   ├── n8n_builder.py      # n8n workflows
+│   ├── comfyui_builder.py  # ComfyUI workflows
+│   ├── workflow_templates.py  # 8 n8n templates
+│   ├── comfyui_templates.py   # 8 image templates
+│   └── docker_helper.py    # Docker management
+├── test_agent.py           # Phase 0 tests (6)
+├── test_m1.py             # M1 unit tests (7)
+├── test_m1_integration.py # M1 integration tests (8)
+├── requirements.txt        # M1 dependencies only
+├── start_m1.ps1           # Startup script (uses existing venv)
+└── README.md              # This file
+```
+
+---
+
+## Testing Examples
+
+### Test AI Decision
+
+```bash
+curl -X POST http://localhost:8001/analyze \
+  -H "Content-Type: application/json" \
+  -d '{"query":"send automated emails daily"}'
+```
+
+### Test Chat
+
+```bash
+curl -X POST http://localhost:8001/chat \
+  -H "Content-Type: application/json" \
+  -d '{"query":"create a workflow for processing customer data"}'
+```
+
+### Test Web Search
+
+```bash
+curl "http://localhost:8001/search/web?query=python+automation&max_results=3"
+```
+
+---
+
+## Test Results
+
+- **Phase 0 Tests**: 6/6 PASS
+- **M1 Unit Tests**: 7/7 PASS
+- **M1 Integration Tests**: 8/8 PASS
+- **Total**: 21/21 PASS
+
+---
+
+## Key Points
+
+- Runs on port **8001** (not 8000) to avoid conflicts
+- Uses existing venv from parent directory
+- Fully isolated from M2 and M3 code
+- All M1 features included and tested
+- Ready for standalone delivery
+
+---
+
+## Support
+
+See M1_DELIVERY.md for complete documentation.

app.py

@@ -0,0 +1,465 @@
+"""
+Gradio Interface for M1 - Hugging Face Spaces Deployment
+Replicates the functionality of ui_es.html in a Gradio interface
+"""
+
+import gradio as gr
+import asyncio
+import json
+from decision_agent import DecisionAgent
+from tools.n8n_builder import N8NWorkflowBuilder
+from tools.comfyui_builder import ComfyUIWorkflowBuilder
+from tools.github_search import GitHubSearchTool
+from tools.web_search import WebSearchTool
+from chat_handler import SessionManager
+
+# Initialize components
+decision_agent = DecisionAgent()
+n8n_builder = N8NWorkflowBuilder()
+comfyui_builder = ComfyUIWorkflowBuilder()
+github_tool = GitHubSearchTool()
+web_tool = WebSearchTool()
+session_manager = SessionManager()
+
+# Helper to run async functions
+def run_async(coro):
+    """Run async function in sync context"""
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        return loop.run_until_complete(coro)
+    finally:
+        loop.close()
+
+# ========================================
+# TAB 1: AI Analysis
+# ========================================
+def analyze_query(query, use_llm):
+    """Analyze user query with AI"""
+    if not query:
+        return "❌ Por favor ingrese una consulta"
+    
+    try:
+        result = run_async(decision_agent.analyze(query, context={'use_llm': use_llm}))
+        
+        # Format response nicely
+        output = f"""
+## 🧠 Resultado del Análisis IA
+
+**Tipo de Proyecto:** {result['project_type'].upper()}
+**Confianza:** {result['confidence']*100:.0f}%
+**Método:** {result.get('classification_method', 'N/A')}
+
+### 📝 Explicación:
+{result['explanation']}
+
+### 🔧 Herramientas Sugeridas:
+{chr(10).join('- ' + tool for tool in result.get('suggested_tools', []))}
+
+### 📋 Próximos Pasos:
+{chr(10).join(f"{i+1}. {step}" for i, step in enumerate(result.get('next_steps', [])))}
+"""
+        return output
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+# ========================================
+# TAB 2: Build Workflow
+# ========================================
+def build_workflow(description, tool, use_llm):
+    """Generate workflow from description"""
+    if not description:
+        return "❌ Por favor ingrese una descripción", ""
+    
+    try:
+        if tool == "n8n":
+            workflow = run_async(n8n_builder.generate_workflow(description, context={'use_llm': use_llm}))
+        else:
+            workflow = run_async(comfyui_builder.generate_workflow(description, context={'use_llm': use_llm}))
+        
+        # Format response
+        enhanced = workflow.get('meta', {}).get('generated_with_llm', False)
+        status = "🧠 Generado con IA" if enhanced else "⚡ Generado con plantillas"
+        
+        output = f"""
+## ✅ ¡Flujo de Trabajo Generado!
+
+**Tipo:** {tool.upper()}
+**Método:** {status}
+**Nodos:** {len(workflow.get('nodes', []))}
+**Nombre:** {workflow.get('name', 'N/A')}
+"""
+        
+        if enhanced and 'llm_analysis' in workflow.get('meta', {}):
+            analysis = workflow['meta']['llm_analysis']
+            output += f"""
+### 📊 Análisis IA:
+- **Explicación:** {analysis.get('explanation', 'N/A')[:200]}...
+- **Confianza:** {analysis.get('confidence', 0)*100:.0f}%
+"""
+        
+        # Return formatted output + JSON
+        workflow_json = json.dumps(workflow, indent=2, ensure_ascii=False)
+        return output, workflow_json
+        
+    except Exception as e:
+        return f"❌ Error: {str(e)}", ""
+
+# ========================================
+# TAB 3: GitHub Search
+# ========================================
+def search_github(keywords, max_results):
+    """Search GitHub repositories"""
+    if not keywords:
+        return "❌ Por favor ingrese palabras clave"
+    
+    try:
+        results = run_async(github_tool.search(keywords, max_results=int(max_results)))
+        
+        if not results:
+            return "📭 No se encontraron repositorios"
+        
+        output = f"## 🔍 Resultados de GitHub ({len(results)} encontrados)\n\n"
+        
+        for i, repo in enumerate(results, 1):
+            output += f"""
+### {i}. {repo.get('full_name', 'N/A')}
+- ⭐ **Estrellas:** {repo.get('stars', 0):,}
+- 📝 **Descripción:** {repo.get('description', 'Sin descripción')[:150]}...
+- 🔗 **URL:** {repo.get('url', 'N/A')}
+- 💻 **Lenguaje:** {repo.get('language', 'N/A')}
+{'- 🐳 **Docker:** Sí' if repo.get('has_docker') else ''}
+
+---
+"""
+        return output
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+# ========================================
+# TAB 4: Web Search
+# ========================================
+def search_web(query, max_results):
+    """Search the web with DuckDuckGo"""
+    if not query:
+        return "❌ Por favor ingrese una consulta"
+    
+    try:
+        results = run_async(web_tool.search(query, max_results=int(max_results)))
+        
+        if not results:
+            return "📭 No se encontraron resultados"
+        
+        output = f"## 🌐 Resultados de Búsqueda ({len(results)} encontrados)\n\n"
+        
+        for i, result in enumerate(results, 1):
+            output += f"""
+### {i}. {result.get('title', 'Sin título')}
+{result.get('snippet', 'Sin descripción')}
+
+🔗 {result.get('url', 'N/A')}
+
+---
+"""
+        return output
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+# ========================================
+# TAB 5: Chat
+# ========================================
+def chat_response(message, history, use_llm):
+    """Chat with AI assistant"""
+    if not message:
+        return history, ""
+    
+    try:
+        # Create or get session
+        if not hasattr(chat_response, 'session'):
+            chat_response.session = session_manager.create_session()
+        
+        # Add user message
+        chat_response.session.add_message("user", message)
+        
+        # Get AI analysis
+        result = run_async(decision_agent.analyze(message, context={'use_llm': use_llm}))
+        
+        response = f"{result['explanation']}\n\n**Herramientas sugeridas:** {', '.join(result.get('suggested_tools', []))}"
+        
+        # Add assistant message
+        chat_response.session.add_message("assistant", response)
+        
+        # Update history
+        history.append((message, response))
+        
+        return history, ""
+    except Exception as e:
+        history.append((message, f"❌ Error: {str(e)}"))
+        return history, ""
+
+# ========================================
+# Create Gradio Interface
+# ========================================
+
+# Custom CSS for better styling
+css = """
+.gradio-container {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+}
+"""
+
+with gr.Blocks(css=css, title="M1 - Agente de Flujo de Trabajo IA", theme=gr.themes.Soft()) as demo:
+    
+    gr.Markdown("""
+    # 🤖 Agente de Flujo de Trabajo IA - Milestone 1
+    ### Toma de Decisiones IA Básica
+    
+    Sistema de análisis y generación de flujos de trabajo potenciado por IA.
+    """)
+    
+    # Global AI Mode Toggle
+    with gr.Row():
+        use_llm_global = gr.Checkbox(
+            label="🧠 Modo IA Inteligente (Gemini)",
+            value=False,
+            info="Activar para usar análisis con Gemini AI. Desactivar para modo rápido con palabras clave."
+        )
+    
+    # Create tabs
+    with gr.Tabs():
+        
+        # ========================================
+        # HOME TAB
+        # ========================================
+        with gr.TabItem("🏠 Inicio"):
+            gr.Markdown("""
+            ## Bienvenido al Panel M1
+            
+            Este sistema proporciona:
+            
+            ### ✨ Características Principales:
+            - 🧠 **Análisis IA**: Analiza tus necesidades y recomienda la mejor herramienta
+            - ⚙️ **Generación de Flujos**: Crea flujos de trabajo de n8n y ComfyUI
+            - 🔍 **Búsqueda Inteligente**: Busca en GitHub y la web
+            - 💬 **Chat IA**: Asistente conversacional para automatización
+            
+            ### 📊 Estadísticas:
+            - **21 endpoints API** activos
+            - **16 plantillas** de flujos de trabajo (8 n8n + 8 ComfyUI)
+            - **2 modos**: Rápido (palabras clave) y Inteligente (Gemini AI)
+            
+            ### 🚀 Comenzar:
+            1. Activa el **Modo IA** arriba para análisis inteligente
+            2. Navega por las pestañas para explorar características
+            3. Prueba las consultas de ejemplo en cada pestaña
+            """)
+        
+        # ========================================
+        # AI ANALYSIS TAB
+        # ========================================
+        with gr.TabItem("🧠 Análisis IA"):
+            gr.Markdown("### Permite que la IA analice tus necesidades de automatización")
+            
+            with gr.Row():
+                with gr.Column():
+                    analysis_query = gr.Textbox(
+                        label="Tu Consulta",
+                        placeholder="Describe lo que deseas automatizar...",
+                        lines=3
+                    )
+                    
+                    gr.Examples(
+                        examples=[
+                            "Necesito enviar correos electrónicos automatizados a 1000 clientes cada mañana",
+                            "Quiero generar arte IA a partir de descripciones de texto y publicar en Instagram",
+                            "Procesar datos de clientes de Shopify y sincronizar con CRM",
+                            "Crear un chatbot que responda preguntas de mi documentación"
+                        ],
+                        inputs=analysis_query,
+                        label="💡 Consultas de Ejemplo"
+                    )
+                    
+                    analyze_btn = gr.Button("Analizar con IA ✨", variant="primary")
+                
+                with gr.Column():
+                    analysis_output = gr.Markdown(label="Resultado")
+            
+            analyze_btn.click(
+                fn=analyze_query,
+                inputs=[analysis_query, use_llm_global],
+                outputs=analysis_output
+            )
+        
+        # ========================================
+        # BUILD WORKFLOW TAB
+        # ========================================
+        with gr.TabItem("⚙️ Construir Flujo"):
+            gr.Markdown("### Genera flujos de trabajo completos a partir de descripciones")
+            
+            with gr.Row():
+                with gr.Column():
+                    build_description = gr.Textbox(
+                        label="Descripción del Flujo de Trabajo",
+                        placeholder="Describe el flujo de trabajo que deseas crear...",
+                        lines=4
+                    )
+                    
+                    build_tool = gr.Radio(
+                        choices=["n8n", "comfyui"],
+                        value="n8n",
+                        label="Herramienta",
+                        info="n8n para automatización, ComfyUI para generación de imágenes IA"
+                    )
+                    
+                    gr.Examples(
+                        examples=[
+                            "Crear un flujo que reciba datos de clientes desde webhook y envíe correo de confirmación",
+                            "Construir un flujo que monitoree Twitter para menciones y envíe notificaciones de Slack",
+                            "Generar fotos profesionales a partir de fotos subidas"
+                        ],
+                        inputs=build_description,
+                        label="💡 Flujos de Ejemplo"
+                    )
+                    
+                    build_btn = gr.Button("Generar Flujo de Trabajo 🚀", variant="primary")
+                
+                with gr.Column():
+                    build_output = gr.Markdown(label="Resultado")
+                    build_json = gr.Code(label="JSON del Flujo de Trabajo", language="json")
+            
+            build_btn.click(
+                fn=build_workflow,
+                inputs=[build_description, build_tool, use_llm_global],
+                outputs=[build_output, build_json]
+            )
+        
+        # ========================================
+        # GITHUB SEARCH TAB
+        # ========================================
+        with gr.TabItem("🔍 Búsqueda GitHub"):
+            gr.Markdown("### Encuentra proyectos de código abierto relevantes")
+            
+            with gr.Row():
+                with gr.Column():
+                    github_keywords = gr.Textbox(
+                        label="Palabras Clave de Búsqueda",
+                        placeholder="ej., automatización de flujos de trabajo"
+                    )
+                    
+                    github_max = gr.Slider(
+                        minimum=1,
+                        maximum=10,
+                        value=5,
+                        step=1,
+                        label="Resultados Máximos"
+                    )
+                    
+                    gr.Examples(
+                        examples=[
+                            "automatización de flujos de trabajo",
+                            "implementación de aprendizaje automático",
+                            "generación de imágenes IA"
+                        ],
+                        inputs=github_keywords,
+                        label="💡 Ejemplos de Búsqueda"
+                    )
+                    
+                    github_btn = gr.Button("Buscar en GitHub 🔍", variant="primary")
+                
+                with gr.Column():
+                    github_output = gr.Markdown(label="Resultados")
+            
+            github_btn.click(
+                fn=search_github,
+                inputs=[github_keywords, github_max],
+                outputs=github_output
+            )
+        
+        # ========================================
+        # WEB SEARCH TAB
+        # ========================================
+        with gr.TabItem("🌐 Búsqueda Web"):
+            gr.Markdown("### Busca en la web usando DuckDuckGo")
+            
+            with gr.Row():
+                with gr.Column():
+                    web_query = gr.Textbox(
+                        label="Consulta de Búsqueda",
+                        placeholder="ej., ejemplos de automatización n8n"
+                    )
+                    
+                    web_max = gr.Slider(
+                        minimum=1,
+                        maximum=10,
+                        value=5,
+                        step=1,
+                        label="Resultados Máximos"
+                    )
+                    
+                    web_btn = gr.Button("Buscar en Web 🔍", variant="primary")
+                
+                with gr.Column():
+                    web_output = gr.Markdown(label="Resultados")
+            
+            web_btn.click(
+                fn=search_web,
+                inputs=[web_query, web_max],
+                outputs=web_output
+            )
+        
+        # ========================================
+        # CHAT TAB
+        # ========================================
+        with gr.TabItem("💬 Chat"):
+            gr.Markdown("### Conversa con la IA sobre tus necesidades de automatización")
+            
+            chatbot = gr.Chatbot(label="Conversación", height=400)
+            
+            with gr.Row():
+                chat_input = gr.Textbox(
+                    label="Tu Mensaje",
+                    placeholder="Pregunta al asistente IA cualquier cosa...",
+                    scale=4
+                )
+                chat_btn = gr.Button("Enviar 💬", scale=1, variant="primary")
+            
+            gr.Examples(
+                examples=[
+                    "Quiero crear un bot que responda preguntas de clientes desde mi sitio web",
+                    "Ayúdame a automatizar mis publicaciones en redes sociales",
+                    "Necesito procesar archivos CSV y generar reportes"
+                ],
+                inputs=chat_input,
+                label="💡 Iniciadores de Conversación"
+            )
+            
+            chat_btn.click(
+                fn=chat_response,
+                inputs=[chat_input, chatbot, use_llm_global],
+                outputs=[chatbot, chat_input]
+            )
+            
+            chat_input.submit(
+                fn=chat_response,
+                inputs=[chat_input, chatbot, use_llm_global],
+                outputs=[chatbot, chat_input]
+            )
+    
+    # Footer
+    gr.Markdown("""
+    ---
+    ### 📝 Notas:
+    - **Modo Rápido (palabras clave)**: <100ms, usa plantillas predefinidas
+    - **Modo Inteligente (Gemini)**: 2-3s, análisis profundo con IA
+    - **Requisitos**: Clave API de Gemini para modo inteligente (gratis en [Google AI Studio](https://aistudio.google.com/app/apikeys))
+    
+    🚀 **Milestone 1** - Sistema de toma de decisiones IA básico completado
+    """)
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,  # HF Spaces default port
+        share=False
+    )

chat_handler.py

@@ -0,0 +1,425 @@
+# AI Workflow Agent - Chat API
+"""
+Conversational interface for the AI Workflow Agent.
+Supports multi-turn conversations with session management.
+"""
+
+import uuid
+import json
+import logging
+from datetime import datetime
+from typing import Dict, Any, Optional, List
+from dataclasses import dataclass, field, asdict
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+class MessageRole(Enum):
+    """Message roles in conversation."""
+    USER = "user"
+    ASSISTANT = "assistant"
+    SYSTEM = "system"
+
+
+class ConversationState(Enum):
+    """Current state of conversation."""
+    INITIAL = "initial"
+    ANALYZING = "analyzing"
+    CLARIFYING = "clarifying"
+    PLANNING = "planning"
+    BUILDING = "building"
+    COMPLETE = "complete"
+    ERROR = "error"
+
+
+@dataclass
+class Message:
+    """Single message in conversation."""
+    role: str
+    content: str
+    timestamp: str = field(default_factory=lambda: datetime.now().isoformat())
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class Session:
+    """Conversation session."""
+    session_id: str
+    created_at: str
+    state: str = ConversationState.INITIAL.value
+    messages: List[Dict[str, Any]] = field(default_factory=list)
+    context: Dict[str, Any] = field(default_factory=dict)
+    project_type: Optional[str] = None
+    workflow: Optional[Dict[str, Any]] = None
+    pending_questions: List[str] = field(default_factory=list)
+    
+    def add_message(self, role: str, content: str, metadata: Dict = None):
+        """Add a message to the conversation."""
+        self.messages.append({
+            "role": role,
+            "content": content,
+            "timestamp": datetime.now().isoformat(),
+            "metadata": metadata or {}
+        })
+    
+    def get_history_text(self, limit: int = 10) -> str:
+        """Get conversation history as text for LLM context."""
+        recent = self.messages[-limit:]
+        lines = []
+        for msg in recent:
+            role = msg["role"].upper()
+            content = msg["content"]
+            lines.append(f"{role}: {content}")
+        return "\n".join(lines)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return asdict(self)
+
+
+class SessionManager:
+    """Manages conversation sessions."""
+    
+    def __init__(self, max_sessions: int = 100):
+        self.sessions: Dict[str, Session] = {}
+        self.max_sessions = max_sessions
+    
+    def create_session(self) -> Session:
+        """Create a new conversation session."""
+        # Cleanup old sessions if limit reached
+        if len(self.sessions) >= self.max_sessions:
+            self._cleanup_old_sessions()
+        
+        session_id = str(uuid.uuid4())[:8]
+        session = Session(
+            session_id=session_id,
+            created_at=datetime.now().isoformat()
+        )
+        
+        # Add system message
+        session.add_message(
+            MessageRole.SYSTEM.value,
+            "AI Workflow Agent initialized. Ready to help build n8n, ComfyUI, "
+            "or hybrid workflows. Describe what you want to create."
+        )
+        
+        self.sessions[session_id] = session
+        logger.info(f"Created session: {session_id}")
+        return session
+    
+    def get_session(self, session_id: str) -> Optional[Session]:
+        """Get existing session by ID."""
+        return self.sessions.get(session_id)
+    
+    def get_or_create(self, session_id: Optional[str] = None) -> Session:
+        """Get existing session or create new one."""
+        if session_id and session_id in self.sessions:
+            return self.sessions[session_id]
+        return self.create_session()
+    
+    def update_state(self, session_id: str, state: ConversationState):
+        """Update session state."""
+        if session_id in self.sessions:
+            self.sessions[session_id].state = state.value
+    
+    def delete_session(self, session_id: str) -> bool:
+        """Delete a session."""
+        if session_id in self.sessions:
+            del self.sessions[session_id]
+            logger.info(f"Deleted session: {session_id}")
+            return True
+        return False
+    
+    def list_sessions(self) -> List[Dict[str, Any]]:
+        """List all active sessions."""
+        return [
+            {
+                "session_id": s.session_id,
+                "created_at": s.created_at,
+                "state": s.state,
+                "message_count": len(s.messages),
+                "project_type": s.project_type
+            }
+            for s in self.sessions.values()
+        ]
+    
+    def _cleanup_old_sessions(self):
+        """Remove oldest sessions to make room."""
+        if not self.sessions:
+            return
+        
+        # Sort by creation time and remove oldest 20%
+        sorted_sessions = sorted(
+            self.sessions.items(),
+            key=lambda x: x[1].created_at
+        )
+        
+        to_remove = len(sorted_sessions) // 5
+        for session_id, _ in sorted_sessions[:to_remove]:
+            del self.sessions[session_id]
+        
+        logger.info(f"Cleaned up {to_remove} old sessions")
+
+
+class ChatHandler:
+    """Handles chat interactions with the agent system."""
+    
+    def __init__(self):
+        self.session_manager = SessionManager()
+        self._agent_system = None  # Lazy load
+    
+    @property
+    def agent_system(self):
+        """Lazy load agent system to avoid circular imports."""
+        if self._agent_system is None:
+            from crew_agents import crew_agent_system
+            self._agent_system = crew_agent_system
+        return self._agent_system
+    
+    async def chat(
+        self,
+        message: str,
+        session_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Process a chat message and return response.
+        
+        Args:
+            message: User message
+            session_id: Optional existing session ID
+            
+        Returns:
+            Dict with response, session_id, state, and optionally questions/workflow
+        """
+        # Get or create session
+        session = self.session_manager.get_or_create(session_id)
+        
+        # Add user message
+        session.add_message(MessageRole.USER.value, message)
+        
+        try:
+            # Handle based on current state
+            if session.state == ConversationState.CLARIFYING.value:
+                # User is answering clarifying questions
+                return await self._handle_clarification(session, message)
+            else:
+                # New request or continuation
+                return await self._handle_request(session, message)
+                
+        except Exception as e:
+            logger.error(f"Chat error: {e}")
+            session.state = ConversationState.ERROR.value
+            session.add_message(
+                MessageRole.ASSISTANT.value,
+                f"Sorry, I encountered an error: {str(e)}. Please try again."
+            )
+            return {
+                "success": False,
+                "session_id": session.session_id,
+                "response": f"Error: {str(e)}",
+                "state": session.state
+            }
+    
+    async def _handle_request(self, session: Session, message: str) -> Dict[str, Any]:
+        """Handle a new or continuing request."""
+        session.state = ConversationState.ANALYZING.value
+        
+        # Analyze the request
+        analysis = await self.agent_system.analyze_request(
+            query=message,
+            session_id=session.session_id,
+            context={"history": session.get_history_text()}
+        )
+        
+        if not analysis.get("success"):
+            error_msg = analysis.get("error", "Analysis failed")
+            session.add_message(MessageRole.ASSISTANT.value, f"Error: {error_msg}")
+            return {
+                "success": False,
+                "session_id": session.session_id,
+                "response": error_msg,
+                "state": session.state
+            }
+        
+        # Check if clarification needed
+        if analysis.get("needs_clarification") and analysis.get("confidence", 0) < 0.7:
+            session.state = ConversationState.CLARIFYING.value
+            questions = analysis.get("questions", [])
+            session.pending_questions = questions
+            
+            # Build response with questions
+            response_parts = [analysis.get("analysis", "I need some clarification:")]
+            for i, q in enumerate(questions, 1):
+                response_parts.append(f"\n{i}. {q}")
+            
+            response = "\n".join(response_parts)
+            session.add_message(MessageRole.ASSISTANT.value, response)
+            
+            return {
+                "success": True,
+                "session_id": session.session_id,
+                "response": response,
+                "state": session.state,
+                "needs_clarification": True,
+                "questions": questions,
+                "project_type": analysis.get("project_type")
+            }
+        
+        # Proceed to build
+        return await self._build_workflow(session, analysis)
+    
+    async def _handle_clarification(self, session: Session, answer: str) -> Dict[str, Any]:
+        """Handle user's answer to clarifying questions."""
+        # Store the clarification
+        if session.pending_questions:
+            question = session.pending_questions[0]
+            self.agent_system.add_clarification(
+                session.session_id,
+                question,
+                answer
+            )
+            session.pending_questions = session.pending_questions[1:]
+        
+        # If more questions pending, ask next one
+        if session.pending_questions:
+            next_question = session.pending_questions[0]
+            response = f"Thanks! Next question: {next_question}"
+            session.add_message(MessageRole.ASSISTANT.value, response)
+            
+            return {
+                "success": True,
+                "session_id": session.session_id,
+                "response": response,
+                "state": session.state,
+                "needs_clarification": True,
+                "questions": session.pending_questions
+            }
+        
+        # All questions answered, proceed to build
+        session.add_message(
+            MessageRole.ASSISTANT.value,
+            "Great, I have all the information I need. Building your workflow..."
+        )
+        
+        # Re-analyze with new information
+        conv_context = self.agent_system.get_session(session.session_id)
+        if conv_context:
+            analysis = {
+                "project_type": conv_context.project_type,
+                "confidence": 0.9,
+                "requirements": conv_context.requirements
+            }
+            return await self._build_workflow(session, analysis)
+        
+        return await self._handle_request(session, session.messages[-2]["content"])
+    
+    async def _build_workflow(self, session: Session, analysis: Dict[str, Any]) -> Dict[str, Any]:
+        """Build the workflow based on analysis."""
+        session.state = ConversationState.PLANNING.value
+        session.project_type = analysis.get("project_type")
+        
+        # Use the simple builders for reliability (CrewAI for complex cases)
+        from tools.n8n_builder import N8NWorkflowBuilder
+        from tools.comfyui_builder import ComfyUIWorkflowBuilder
+        from tools.github_search import GitHubSearchTool
+        
+        project_type = analysis.get("project_type", "unknown")
+        original_query = session.messages[1]["content"] if len(session.messages) > 1 else ""
+        
+        session.state = ConversationState.BUILDING.value
+        
+        try:
+            if project_type == "n8n":
+                builder = N8NWorkflowBuilder()
+                workflow = await builder.generate_workflow(original_query)
+                response = "I've generated an n8n workflow for you. Here's the configuration:"
+                
+            elif project_type == "comfyui":
+                builder = ComfyUIWorkflowBuilder()
+                workflow = await builder.generate_workflow(original_query)
+                response = "I've generated a ComfyUI workflow. Here's the configuration:"
+                
+            elif project_type == "hybrid":
+                n8n_builder = N8NWorkflowBuilder()
+                comfyui_builder = ComfyUIWorkflowBuilder()
+                
+                n8n_wf = await n8n_builder.generate_workflow(original_query)
+                comfyui_wf = await comfyui_builder.generate_workflow(original_query)
+                
+                workflow = {
+                    "type": "hybrid",
+                    "n8n_workflow": n8n_wf,
+                    "comfyui_workflow": comfyui_wf,
+                    "integration_note": "n8n can call ComfyUI via HTTP Request node to /prompt endpoint"
+                }
+                response = "I've generated a hybrid workflow combining n8n automation with ComfyUI for AI generation."
+                
+            elif project_type == "external_repo":
+                github = GitHubSearchTool()
+                repos = await github.search(original_query, max_results=3)
+                recommendation = await github.generate_recommendation(repos)
+                
+                workflow = {
+                    "type": "external_repo",
+                    "repositories": repos,
+                    "recommendation": recommendation
+                }
+                response = f"I found some relevant repositories:\n\n{recommendation}"
+                
+            else:
+                workflow = None
+                response = "I couldn't determine the project type. Could you provide more details?"
+            
+            session.workflow = workflow
+            session.state = ConversationState.COMPLETE.value
+            
+            if workflow and project_type not in ["external_repo"]:
+                response += f"\n\n```json\n{json.dumps(workflow, indent=2)[:2000]}\n```"
+            
+            session.add_message(MessageRole.ASSISTANT.value, response[:500] + "..." if len(response) > 500 else response)
+            
+            return {
+                "success": True,
+                "session_id": session.session_id,
+                "response": response,
+                "state": session.state,
+                "project_type": project_type,
+                "workflow": workflow
+            }
+            
+        except Exception as e:
+            logger.error(f"Build error: {e}")
+            session.state = ConversationState.ERROR.value
+            response = f"Error building workflow: {str(e)}"
+            session.add_message(MessageRole.ASSISTANT.value, response)
+            
+            return {
+                "success": False,
+                "session_id": session.session_id,
+                "response": response,
+                "state": session.state,
+                "error": str(e)
+            }
+    
+    def get_session_info(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """Get session information."""
+        session = self.session_manager.get_session(session_id)
+        if session:
+            return session.to_dict()
+        return None
+    
+    def list_sessions(self) -> List[Dict[str, Any]]:
+        """List all sessions."""
+        return self.session_manager.list_sessions()
+    
+    def clear_session(self, session_id: str) -> bool:
+        """Clear a session."""
+        # Also clear from agent system
+        if hasattr(self, '_agent_system') and self._agent_system:
+            self._agent_system.clear_session(session_id)
+        return self.session_manager.delete_session(session_id)
+
+
+# Singleton instance
+chat_handler = ChatHandler()

config.py

@@ -0,0 +1,113 @@
+# AI Workflow Agent - Configuration
+import os
+from pathlib import Path
+from pydantic_settings import BaseSettings
+from typing import Optional
+
+# Load environment variables from .env file
+from dotenv import load_dotenv
+
+# Load .env file from the M1_only directory
+env_path = Path(__file__).parent / '.env'
+if env_path.exists():
+    load_dotenv(env_path)
+else:
+    # Try to load from parent directory
+    env_path = Path(__file__).parent.parent / '.env'
+    if env_path.exists():
+        load_dotenv(env_path)
+
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables."""
+    
+    # LLM Configuration
+    LLM_PROVIDER: str = os.getenv("LLM_PROVIDER", "gemini")  # gemini or ollama
+    GEMINI_API_KEY: Optional[str] = os.getenv("GEMINI_API_KEY", None)
+    USE_LLM: bool = os.getenv("USE_LLM", "true").lower() == "true"  # Enabled by default if key exists
+    
+    # Ollama LLM Configuration (fallback)
+    OLLAMA_HOST: str = os.getenv("OLLAMA_HOST", "http://localhost:11434")
+    OLLAMA_MODEL: str = os.getenv("OLLAMA_MODEL", "qwen2.5:3b")
+    
+    # n8n Configuration
+    N8N_HOST: str = os.getenv("N8N_HOST", "http://localhost:5678")
+    N8N_API_KEY: Optional[str] = os.getenv("N8N_API_KEY", None)
+    
+    # ComfyUI Configuration
+    COMFYUI_HOST: str = os.getenv("COMFYUI_HOST", "http://localhost:8188")
+    
+    # PostgreSQL Configuration
+    POSTGRES_HOST: str = os.getenv("POSTGRES_HOST", "localhost")
+    POSTGRES_PORT: int = int(os.getenv("POSTGRES_PORT", "5432"))
+    POSTGRES_USER: str = os.getenv("POSTGRES_USER", "agent")
+    POSTGRES_PASSWORD: str = os.getenv("POSTGRES_PASSWORD", "agent_secret_2026")
+    POSTGRES_DB: str = os.getenv("POSTGRES_DB", "workflow_agent")
+    
+    # GitHub Configuration
+    GITHUB_TOKEN: Optional[str] = os.getenv("GITHUB_TOKEN", None)
+    
+    # Colab Configuration (Milestone 2)
+    NGROK_AUTH_TOKEN: Optional[str] = os.getenv("NGROK_AUTH_TOKEN", None)
+    
+    # Project Directories
+    PROJECTS_DIR: str = os.getenv("PROJECTS_DIR", "/app/projects")
+    WORKFLOWS_DIR: str = os.getenv("WORKFLOWS_DIR", "/app/workflows")
+    
+    @property
+    def database_url(self) -> str:
+        return f"postgresql://{self.POSTGRES_USER}:{self.POSTGRES_PASSWORD}@{self.POSTGRES_HOST}:{self.POSTGRES_PORT}/{self.POSTGRES_DB}"
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+
+
+# Global settings instance
+settings = Settings()
+
+
+# Project Type Definitions
+class ProjectType:
+    N8N = "n8n"
+    COMFYUI = "comfyui"
+    HYBRID = "hybrid"
+    EXTERNAL_REPO = "external_repo"
+    UNKNOWN = "unknown"
+
+
+# Keywords for project classification
+CLASSIFICATION_KEYWORDS = {
+    ProjectType.N8N: [
+        "automation", "workflow", "integrate", "api", "webhook", "schedule",
+        "email", "slack", "telegram", "notification", "trigger", "connect",
+        "sync", "transfer", "backup", "monitor", "alert", "scrape", "fetch",
+        "social media", "post", "publish", "send", "share", "broadcast",
+        "twitter", "facebook", "instagram", "linkedin", "discord", "whatsapp",
+        "bot", "chatbot", "automate", "automated", "batch", "bulk", "mass",
+        "campaign", "marketing", "crm", "customer", "lead", "contact",
+        "database", "spreadsheet", "csv", "excel", "google sheets",
+        "zapier", "ifttt", "data processing", "etl", "pipeline",
+        "report", "reporting", "export", "transform", "convert", "parse",
+        "import", "data", "file", "process data", "data export"
+    ],
+    ProjectType.COMFYUI: [
+        "image", "generate", "ai art", "stable diffusion", "flux", "sdxl",
+        "inpaint", "upscale", "controlnet", "lora", "checkpoint", "model",
+        "txt2img", "img2img", "video", "animation", "diffusion", "generative",
+        "photo", "picture", "visual", "art", "create image", "make image",
+        "design", "logo", "banner", "thumbnail", "avatar", "illustration"
+    ],
+    ProjectType.HYBRID: [
+        "generate image and", "create image and", "ai image and send",
+        "photo generation and", "ai art and", "design and automation",
+        "generate images and automate", "image generation workflow",
+        "stable diffusion and", "image to", "generate and email with images",
+        "automated image", "generative ai and automation"
+    ],
+    ProjectType.EXTERNAL_REPO: [
+        "github", "repository", "repo", "clone", "download project",
+        "install", "setup project", "deploy", "docker project",
+        "existing project", "open source", "template"
+    ]
+}

decision_agent.py

@@ -0,0 +1,399 @@
+# AI Workflow Agent - Decision Agent (Core Brain)
+"""
+Decision Agent using LLM (Gemini 2.5 Flash or Ollama)
+Analyzes user queries and decides:
+- n8n automation
+- ComfyUI generative workflow
+- Hybrid (n8n + ComfyUI)
+- External repo project
+"""
+
+import httpx
+import json
+import logging
+from typing import Dict, Any, Optional, List
+
+from config import settings, ProjectType, CLASSIFICATION_KEYWORDS
+
+logger = logging.getLogger(__name__)
+
+
+class DecisionAgent:
+    """
+    Core decision-making agent that analyzes user queries
+    and determines the appropriate workflow type.
+    """
+    
+    def __init__(self):
+        self.llm_provider = settings.LLM_PROVIDER
+        self.gemini_api_key = settings.GEMINI_API_KEY
+        self.ollama_host = settings.OLLAMA_HOST
+        self.ollama_model = settings.OLLAMA_MODEL
+        self.client = httpx.AsyncClient(timeout=120.0)
+    
+    async def check_ollama_health(self) -> str:
+        """Check if Ollama is running and responsive."""
+        try:
+            response = await self.client.get(f"{self.ollama_host}/api/tags")
+            if response.status_code == 200:
+                return "healthy"
+            return "unhealthy"
+        except Exception as e:
+            logger.debug(f"Ollama health check failed: {e}")
+            return "unreachable"
+    
+    async def ensure_model_available(self) -> bool:
+        """Ensure the required model is available in Ollama."""
+        try:
+            # Check if model exists
+            response = await self.client.get(f"{self.ollama_host}/api/tags")
+            if response.status_code == 200:
+                models = response.json().get("models", [])
+                model_names = [m.get("name", "") for m in models]
+                
+                if self.model not in model_names and f"{self.model}:latest" not in model_names:
+                    logger.info(f"Pulling model {self.model}...")
+                    # Pull the model
+                    pull_response = await self.client.post(
+                        f"{self.ollama_host}/api/pull",
+                        json={"name": self.model},
+                        timeout=600.0  # 10 minutes for large models
+                    )
+                    return pull_response.status_code == 200
+                return True
+            return False
+        except Exception as e:
+            logger.debug(f"Model check failed: {e}")
+            return False
+    
+    async def analyze(self, query: str, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Analyze user query and determine project type.
+        
+        STRATEGY: Respect user's LLM toggle from context
+        - If context says use_llm=True → Use Gemini (if available)
+        - If context says use_llm=False → Use keywords only
+        - If no context → Use Gemini (if available)
+        
+        Returns:
+            Dict with project_type, confidence, explanation, suggested_tools, next_steps
+        """
+        
+        # Check if LLM is explicitly disabled in context
+        use_llm = True  # Default to LLM
+        if context and isinstance(context, dict):
+            use_llm = context.get('use_llm', True)  # Respect the toggle
+        
+        # PRIMARY: Try LLM if enabled and available
+        if use_llm and self.gemini_api_key:
+            llm_result = await self._llm_analyze(query, context)
+            
+            # If Gemini succeeded, use it
+            if llm_result["project_type"] != ProjectType.UNKNOWN:
+                final_result = llm_result
+                final_result["classification_method"] = "Gemini 2.5 Flash (LLM)"
+                logger.info(f"Decision (Gemini): {final_result['project_type']} (confidence: {final_result['confidence']:.2f})")
+                final_result["suggested_tools"] = self._get_suggested_tools(final_result["project_type"])
+                final_result["next_steps"] = self._get_next_steps(final_result["project_type"], query)
+                return final_result
+        
+        # FALLBACK: Use keywords when LLM disabled or unavailable
+        keyword_result = self._keyword_classify(query)
+        keyword_result["classification_method"] = "Keyword Matching (Fallback)"
+        logger.info(f"Decision (Keywords): {keyword_result['project_type']} (confidence: {keyword_result['confidence']:.2f})")
+        keyword_result["suggested_tools"] = self._get_suggested_tools(keyword_result["project_type"])
+        keyword_result["next_steps"] = self._get_next_steps(keyword_result["project_type"], query)
+        return keyword_result
+    
+    def _keyword_classify(self, query: str) -> Dict[str, Any]:
+        """Fast keyword-based classification (FALLBACK ONLY).
+        
+        Logic:
+        - If both COMFYUI + N8N keywords present → HYBRID
+        - Otherwise pick highest scoring type
+        """
+        query_lower = query.lower()
+        scores = {}
+        
+        for project_type, keywords in CLASSIFICATION_KEYWORDS.items():
+            score = sum(1 for kw in keywords if kw in query_lower)
+            scores[project_type] = score
+        
+        # Check for HYBRID: both image generation AND automation keywords present
+        comfyui_score = scores.get(ProjectType.COMFYUI, 0)
+        n8n_score = scores.get(ProjectType.N8N, 0)
+        
+        # If both types have keywords, it's HYBRID
+        if comfyui_score >= 1 and n8n_score >= 1:
+            confidence = min((comfyui_score + n8n_score) / 3, 1.0)
+            return {
+                "project_type": ProjectType.HYBRID,
+                "confidence": confidence,
+                "explanation": "Detected hybrid automation + AI task."
+            }
+        
+        # Otherwise use highest score
+        if not scores or max(scores.values()) == 0:
+            return {
+                "project_type": ProjectType.N8N,
+                "confidence": 0.3,
+                "explanation": "Default to n8n automation. Tell me more about what you want to automate."
+            }
+        
+        best_type = max(scores, key=scores.get)
+        max_score = scores[best_type]
+        confidence = min(max_score / 3, 1.0)
+        
+        explanations = {
+            ProjectType.N8N: "Detected automation task.",
+            ProjectType.COMFYUI: "Detected image generation task.",
+            ProjectType.HYBRID: "Detected hybrid automation + AI task.",
+            ProjectType.EXTERNAL_REPO: "Detected GitHub repository request."
+        }
+        
+        return {
+            "project_type": best_type,
+            "confidence": confidence,
+            "explanation": explanations.get(best_type, f"Detected {best_type}.")
+        }
+    
+    async def _llm_analyze(self, query: str, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """LLM-based analysis using configured provider (Gemini or Ollama)."""
+        
+        if self.llm_provider == "gemini" and self.gemini_api_key:
+            return await self._gemini_analyze(query, context)
+        else:
+            return await self._ollama_analyze(query, context)
+    
+    async def _gemini_analyze(self, query: str, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Analyze using Google Gemini 2.5 Flash API.
+        
+        Use PRINCIPLE-BASED reasoning, not example-based.
+        This way the LLM handles edge cases intelligently without constant prompt tweaking.
+        """
+        
+        system_prompt = """You are a project classification assistant. Classify user requests into project types based on PRINCIPLES, not examples.
+
+PRINCIPLES:
+- **n8n**: Automation, workflows, data processing. Handles logic/connections/scheduling. (CSV reports are DATA, not images)
+- **comfyui**: Visual generation. Creates images/photos/artwork using AI. (Image generation ONLY)
+- **hybrid**: Both automation AND image generation in one workflow. (Must involve creating images AND automating something)
+- **external_repo**: User wants to download/use existing code from GitHub
+
+KEY DISTINCTION:
+- "Report" = data document (n8n) 
+- "Image/photo" = visual content (comfyui)
+- Both = hybrid
+
+Respond ONLY with valid JSON:
+{"project_type": "n8n" | "comfyui" | "hybrid" | "external_repo" | "unknown", "confidence": 0.0-1.0, "explanation": "..."}"""
+
+        user_prompt = f'Classify: "{query}"'
+        
+        try:
+            response = await self.client.post(
+                "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent",
+                headers={"Content-Type": "application/json"},
+                json={
+                    "contents": [{
+                        "parts": [{
+                            "text": f"{system_prompt}\n\n{user_prompt}"
+                        }]
+                    }]
+                },
+                params={"key": self.gemini_api_key}
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                try:
+                    # Extract text from Gemini response
+                    text_content = result["candidates"][0]["content"]["parts"][0]["text"]
+                    
+                    # Try to extract JSON from the response
+                    # Sometimes Gemini wraps JSON in markdown code blocks
+                    if "```json" in text_content:
+                        json_str = text_content.split("```json")[1].split("```")[0].strip()
+                    elif "```" in text_content:
+                        json_str = text_content.split("```")[1].split("```")[0].strip()
+                    else:
+                        json_str = text_content
+                    
+                    parsed = json.loads(json_str)
+                    return {
+                        "project_type": parsed.get("project_type", ProjectType.UNKNOWN),
+                        "confidence": float(parsed.get("confidence", 0.5)),
+                        "explanation": parsed.get("explanation", "Gemini analysis")
+                    }
+                except (json.JSONDecodeError, KeyError, IndexError) as e:
+                    logger.warning(f"Failed to parse Gemini response: {e}")
+                    return {
+                        "project_type": ProjectType.UNKNOWN,
+                        "confidence": 0.0,
+                        "explanation": "Gemini response parsing failed"
+                    }
+            else:
+                logger.debug(f"Gemini request failed: {response.status_code}")
+                return {
+                    "project_type": ProjectType.UNKNOWN,
+                    "confidence": 0.0,
+                    "explanation": "Gemini request failed"
+                }
+                
+        except Exception as e:
+            logger.debug(f"Gemini analysis error: {e}")
+            return {
+                "project_type": ProjectType.UNKNOWN,
+                "confidence": 0.0,
+                "explanation": f"Gemini error: {str(e)}"
+            }
+
+    async def _ollama_analyze(self, query: str, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Analyze using Ollama (Qwen2.5 or other model).
+        
+        Use PRINCIPLE-BASED reasoning, not example-based.
+        """
+        
+        system_prompt = """You are a project classification assistant. Classify user requests into project types based on PRINCIPLES, not examples.
+
+PRINCIPLES:
+- **n8n**: Automation, workflows, data processing. Handles logic/connections/scheduling. (CSV reports are DATA, not images)
+- **comfyui**: Visual generation. Creates images/photos/artwork using AI. (Image generation ONLY)
+- **hybrid**: Both automation AND image generation in one workflow. (Must involve creating images AND automating something)
+- **external_repo**: User wants to download/use existing code from GitHub
+
+KEY DISTINCTION:
+- "Report" = data document (n8n) 
+- "Image/photo" = visual content (comfyui)
+- Both = hybrid
+
+Respond ONLY with valid JSON:
+{"project_type": "n8n" | "comfyui" | "hybrid" | "external_repo" | "unknown", "confidence": 0.0-1.0, "explanation": "..."}"""
+
+        user_prompt = f'Classify: "{query}"'
+        
+        try:
+            response = await self.client.post(
+                f"{self.ollama_host}/api/generate",
+                json={
+                    "model": self.ollama_model,
+                    "prompt": f"{system_prompt}\n\n{user_prompt}",
+                    "stream": False,
+                    "format": "json"
+                }
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                llm_response = result.get("response", "{}")
+                
+                # Parse JSON response
+                try:
+                    parsed = json.loads(llm_response)
+                    return {
+                        "project_type": parsed.get("project_type", ProjectType.UNKNOWN),
+                        "confidence": float(parsed.get("confidence", 0.5)),
+                        "explanation": parsed.get("explanation", "Ollama analysis")
+                    }
+                except json.JSONDecodeError:
+                    logger.warning(f"Failed to parse Ollama response: {llm_response}")
+                    return {
+                        "project_type": ProjectType.UNKNOWN,
+                        "confidence": 0.0,
+                        "explanation": "Ollama response parsing failed"
+                    }
+            else:
+                logger.debug(f"Ollama request failed: {response.status_code}")
+                return {
+                    "project_type": ProjectType.UNKNOWN,
+                    "confidence": 0.0,
+                    "explanation": "Ollama request failed"
+                }
+                
+        except Exception as e:
+            logger.debug(f"Ollama analysis error: {e}")
+            return {
+                "project_type": ProjectType.UNKNOWN,
+                "confidence": 0.0,
+                "explanation": f"Ollama error: {str(e)}"
+            }
+    
+    def _get_suggested_tools(self, project_type: str) -> List[str]:
+        """Get suggested tools based on project type."""
+        tools_map = {
+            ProjectType.N8N: [
+                "n8n_builder - Generate workflow JSON",
+                "n8n_deploy - Deploy to n8n instance",
+                "webhook_trigger - Setup webhook triggers"
+            ],
+            ProjectType.COMFYUI: [
+                "comfyui_builder - Generate workflow graph",
+                "comfyui_execute - Run workflow",
+                "model_download - Download required models"
+            ],
+            ProjectType.HYBRID: [
+                "n8n_builder - Generate automation workflow",
+                "comfyui_builder - Generate AI workflow",
+                "api_connector - Connect n8n to ComfyUI"
+            ],
+            ProjectType.EXTERNAL_REPO: [
+                "github_search - Find relevant repositories",
+                "docker_helper - Clone and build",
+                "error_analyzer - Fix build issues"
+            ]
+        }
+        return tools_map.get(project_type, ["unknown_tool"])
+    
+    def _get_next_steps(self, project_type: str, query: str) -> List[str]:
+        """Get recommended next steps."""
+        steps_map = {
+            ProjectType.N8N: [
+                "1. Generate workflow JSON template",
+                "2. Customize nodes and connections",
+                "3. Deploy to n8n instance",
+                "4. Test with sample data"
+            ],
+            ProjectType.COMFYUI: [
+                "1. Generate ComfyUI workflow graph",
+                "2. Check required models are installed",
+                "3. Execute workflow",
+                "4. Review generated output"
+            ],
+            ProjectType.HYBRID: [
+                "1. Create ComfyUI workflow for AI task",
+                "2. Create n8n workflow for automation",
+                "3. Connect n8n → ComfyUI via HTTP",
+                "4. Test end-to-end pipeline"
+            ],
+            ProjectType.EXTERNAL_REPO: [
+                "1. Search GitHub for relevant projects",
+                "2. Select best matching repository",
+                "3. Clone and configure with Docker",
+                "4. Validate and fix any errors"
+            ]
+        }
+        return steps_map.get(project_type, ["Please provide more details"])
+
+
+# ============================================
+# CrewAI Integration (Advanced Mode)
+# ============================================
+
+class CrewAIDecisionAgent:
+    """
+    Advanced decision agent using CrewAI framework.
+    Used for more complex multi-step reasoning.
+    """
+    
+    def __init__(self):
+        self.simple_agent = DecisionAgent()
+        # CrewAI setup would go here
+        # We use simple agent for Phase 0, upgrade to CrewAI in Milestone 1
+    
+    async def analyze_complex(self, query: str, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Complex analysis using CrewAI agents.
+        Reserved for Milestone 1 implementation.
+        """
+        # For now, delegate to simple agent
+        return await self.simple_agent.analyze(query, context)

requirements.txt

@@ -0,0 +1,35 @@
+# Milestone 1: Core AI Decision Agent
+# Works for: Local FastAPI server + Hugging Face Gradio deployment
+# Python 3.9+
+
+# Web Frameworks
+fastapi==0.115.0
+uvicorn==0.32.0
+gradio>=4.0.0
+
+# Data Validation
+pydantic==2.9.2
+pydantic-settings==2.6.1
+
+# AI & LLM
+crewai==0.80.0
+litellm==1.81.13
+google-generativeai>=0.3.0
+
+# Configuration & Environment
+python-dotenv==1.0.0
+
+# HTTP & Web
+httpx==0.28.1
+requests==2.32.3
+beautifulsoup4>=4.12.0
+
+# Search & Tools
+duckduckgo-search==6.3.5
+
+# Docker (optional, for local development)
+docker==7.1.0
+
+# Testing
+pytest==8.3.3
+pytest-asyncio==0.24.0

tools/__init__.py

@@ -0,0 +1,18 @@
+# Tools package initialization
+from .github_search import GitHubSearchTool
+from .n8n_builder import N8NWorkflowBuilder
+from .comfyui_builder import ComfyUIWorkflowBuilder
+from .docker_helper import DockerHelper
+from .web_search import WebSearchTool
+from .workflow_templates import get_workflow_templates
+from .comfyui_templates import get_comfyui_templates
+
+__all__ = [
+    "GitHubSearchTool",
+    "N8NWorkflowBuilder", 
+    "ComfyUIWorkflowBuilder",
+    "DockerHelper",
+    "WebSearchTool",
+    "get_workflow_templates",
+    "get_comfyui_templates"
+]

tools/comfyui_builder.py

@@ -0,0 +1,546 @@
+# ComfyUI Workflow Builder Tool
+"""
+Generate and execute ComfyUI workflow JSON templates.
+Supports common generative AI patterns.
+LLM-enhanced generation when context.use_llm=True.
+"""
+
+import httpx
+import json
+import logging
+import uuid
+from typing import Dict, Any, List, Optional
+
+from config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class ComfyUIWorkflowBuilder:
+    """
+    ComfyUI workflow generator and executor.
+    Creates JSON workflow graphs and executes via ComfyUI API.
+    """
+    
+    def __init__(self):
+        self.comfyui_host = settings.COMFYUI_HOST
+        self.client = httpx.AsyncClient(timeout=300.0)  # Long timeout for image generation
+    
+    async def check_health(self) -> str:
+        """Check if ComfyUI is running and responsive."""
+        try:
+            response = await self.client.get(f"{self.comfyui_host}/system_stats")
+            if response.status_code == 200:
+                return "healthy"
+            return "unhealthy"
+        except Exception as e:
+            logger.debug(f"ComfyUI health check failed: {e}")
+            return "unreachable"
+    
+    async def generate_workflow(self, query: str, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Generate ComfyUI workflow JSON based on user query.
+        
+        Args:
+            query: User's natural language request
+            context: Optional context with use_llm flag for LLM-enhanced generation
+            
+        Returns:
+            ComfyUI workflow JSON structure
+        """
+        # Check if LLM enhancement is requested
+        use_llm = False
+        if context and isinstance(context, dict):
+            use_llm = context.get('use_llm', False)
+        
+        # If LLM mode is enabled, use AI to analyze and create more intelligent workflow
+        if use_llm:
+            logger.info("Using LLM-enhanced workflow generation")
+            workflow = await self._generate_llm_workflow(query)
+            if workflow:
+                return workflow
+            # Fall back to template if LLM fails
+            logger.warning("LLM generation failed, falling back to templates")
+        
+        # Template-based generation (keyword mode)
+        workflow_type = self._detect_workflow_type(query)
+        
+        # Extract parameters from query
+        params = self._extract_params(query)
+        
+        # Generate appropriate template
+        templates = {
+            "txt2img": self._generate_txt2img_workflow,
+            "img2img": self._generate_img2img_workflow,
+            "upscale": self._generate_upscale_workflow,
+            "inpaint": self._generate_inpaint_workflow,
+            "controlnet": self._generate_controlnet_workflow,
+            "generic": self._generate_generic_workflow
+        }
+        
+        generator = templates.get(workflow_type, self._generate_generic_workflow)
+        workflow = generator(params)
+        
+        return workflow
+    
+    async def _generate_llm_workflow(self, query: str) -> Optional[Dict[str, Any]]:
+        """
+        Use LLM to generate a more intelligent workflow based on query analysis.
+        
+        Args:
+            query: User's natural language request
+            
+        Returns:
+            Enhanced ComfyUI workflow or None if LLM fails
+        """
+        try:
+            # Import here to avoid circular dependency
+            from decision_agent import DecisionAgent
+            
+            agent = DecisionAgent()
+            analysis = await agent.analyze(query, context={'use_llm': True})
+            
+            # Use analysis explanation to create more detailed workflow
+            workflow_type = self._detect_workflow_type(query)
+            explanation = analysis.get('explanation', '')
+            params = self._extract_params(query)
+            
+            # Generate base template
+            templates = {
+                "txt2img": self._generate_txt2img_workflow,
+                "img2img": self._generate_img2img_workflow,
+                "upscale": self._generate_upscale_workflow,
+                "inpaint": self._generate_inpaint_workflow,
+                "controlnet": self._generate_controlnet_workflow,
+                "generic": self._generate_generic_workflow
+            }
+            
+            generator = templates.get(workflow_type, self._generate_generic_workflow)
+            workflow = generator(params)
+            
+            # Enhance with LLM analysis
+            workflow['meta']['llm_analysis'] = {
+                'explanation': explanation,
+                'confidence': analysis.get('confidence', 0.0),
+                'suggested_tools': analysis.get('suggested_tools', []),
+                'next_steps': analysis.get('next_steps', [])
+            }
+            workflow['meta']['generated_with_llm'] = True
+            
+            return workflow
+            
+        except Exception as e:
+            logger.error(f"LLM workflow generation failed: {e}")
+            return None
+    
+    def _detect_workflow_type(self, query: str) -> str:
+        """Detect the type of ComfyUI workflow needed."""
+        query_lower = query.lower()
+        
+        if any(w in query_lower for w in ["upscale", "enhance", "higher resolution", "4x", "2x"]):
+            return "upscale"
+        elif any(w in query_lower for w in ["inpaint", "edit", "remove", "fill", "mask"]):
+            return "inpaint"
+        elif any(w in query_lower for w in ["controlnet", "pose", "depth", "canny", "edge"]):
+            return "controlnet"
+        elif any(w in query_lower for w in ["img2img", "transform", "style transfer", "from image"]):
+            return "img2img"
+        else:
+            return "txt2img"
+    
+    def _extract_params(self, query: str) -> Dict[str, Any]:
+        """Extract generation parameters from query."""
+        # Default parameters
+        params = {
+            "prompt": query,
+            "negative_prompt": "bad quality, blurry, deformed",
+            "width": 512,
+            "height": 512,
+            "steps": 20,
+            "cfg": 7.0,
+            "seed": -1,  # Random
+            "checkpoint": "v1-5-pruned-emaonly.safetensors"
+        }
+        
+        query_lower = query.lower()
+        
+        # Detect resolution
+        if "portrait" in query_lower or "vertical" in query_lower:
+            params["width"] = 512
+            params["height"] = 768
+        elif "landscape" in query_lower or "horizontal" in query_lower:
+            params["width"] = 768
+            params["height"] = 512
+        elif "square" in query_lower:
+            params["width"] = 512
+            params["height"] = 512
+        elif "hd" in query_lower or "1024" in query_lower:
+            params["width"] = 1024
+            params["height"] = 1024
+        
+        # Detect model
+        if "sdxl" in query_lower:
+            params["checkpoint"] = "sd_xl_base_1.0.safetensors"
+            params["width"] = 1024
+            params["height"] = 1024
+        elif "flux" in query_lower:
+            params["checkpoint"] = "flux1-dev.safetensors"
+        
+        # Detect quality settings
+        if "high quality" in query_lower or "detailed" in query_lower:
+            params["steps"] = 30
+            params["cfg"] = 8.0
+        elif "fast" in query_lower or "quick" in query_lower:
+            params["steps"] = 15
+            params["cfg"] = 6.0
+        
+        return params
+    
+    def _generate_txt2img_workflow(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate text-to-image workflow."""
+        return {
+            "prompt": {
+                "3": {
+                    "inputs": {
+                        "seed": params.get("seed", -1),
+                        "steps": params.get("steps", 20),
+                        "cfg": params.get("cfg", 7.0),
+                        "sampler_name": "euler",
+                        "scheduler": "normal",
+                        "denoise": 1.0,
+                        "model": ["4", 0],
+                        "positive": ["6", 0],
+                        "negative": ["7", 0],
+                        "latent_image": ["5", 0]
+                    },
+                    "class_type": "KSampler",
+                    "_meta": {"title": "KSampler"}
+                },
+                "4": {
+                    "inputs": {
+                        "ckpt_name": params.get("checkpoint", "v1-5-pruned-emaonly.safetensors")
+                    },
+                    "class_type": "CheckpointLoaderSimple",
+                    "_meta": {"title": "Load Checkpoint"}
+                },
+                "5": {
+                    "inputs": {
+                        "width": params.get("width", 512),
+                        "height": params.get("height", 512),
+                        "batch_size": 1
+                    },
+                    "class_type": "EmptyLatentImage",
+                    "_meta": {"title": "Empty Latent Image"}
+                },
+                "6": {
+                    "inputs": {
+                        "text": params.get("prompt", "beautiful landscape"),
+                        "clip": ["4", 1]
+                    },
+                    "class_type": "CLIPTextEncode",
+                    "_meta": {"title": "CLIP Text Encode (Prompt)"}
+                },
+                "7": {
+                    "inputs": {
+                        "text": params.get("negative_prompt", "bad quality, blurry"),
+                        "clip": ["4", 1]
+                    },
+                    "class_type": "CLIPTextEncode",
+                    "_meta": {"title": "CLIP Text Encode (Negative)"}
+                },
+                "8": {
+                    "inputs": {
+                        "samples": ["3", 0],
+                        "vae": ["4", 2]
+                    },
+                    "class_type": "VAEDecode",
+                    "_meta": {"title": "VAE Decode"}
+                },
+                "9": {
+                    "inputs": {
+                        "filename_prefix": "ComfyUI",
+                        "images": ["8", 0]
+                    },
+                    "class_type": "SaveImage",
+                    "_meta": {"title": "Save Image"}
+                }
+            },
+            "meta": {
+                "generated_by": "AI Workflow Agent",
+                "type": "txt2img",
+                "params": params
+            }
+        }
+    
+    def _generate_img2img_workflow(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate image-to-image workflow."""
+        workflow = self._generate_txt2img_workflow(params)
+        
+        # Modify for img2img
+        workflow["prompt"]["5"] = {
+            "inputs": {
+                "image": "INPUT_IMAGE_PATH",
+                "upload": "image"
+            },
+            "class_type": "LoadImage",
+            "_meta": {"title": "Load Image"}
+        }
+        
+        # Add VAE encode for input
+        workflow["prompt"]["10"] = {
+            "inputs": {
+                "pixels": ["5", 0],
+                "vae": ["4", 2]
+            },
+            "class_type": "VAEEncode",
+            "_meta": {"title": "VAE Encode"}
+        }
+        
+        # Update sampler to use encoded image
+        workflow["prompt"]["3"]["inputs"]["latent_image"] = ["10", 0]
+        workflow["prompt"]["3"]["inputs"]["denoise"] = 0.75
+        
+        workflow["meta"]["type"] = "img2img"
+        
+        return workflow
+    
+    def _generate_upscale_workflow(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate upscale workflow."""
+        return {
+            "prompt": {
+                "1": {
+                    "inputs": {
+                        "image": "INPUT_IMAGE_PATH",
+                        "upload": "image"
+                    },
+                    "class_type": "LoadImage",
+                    "_meta": {"title": "Load Image"}
+                },
+                "2": {
+                    "inputs": {
+                        "model_name": "RealESRGAN_x4plus.pth"
+                    },
+                    "class_type": "UpscaleModelLoader",
+                    "_meta": {"title": "Load Upscale Model"}
+                },
+                "3": {
+                    "inputs": {
+                        "upscale_model": ["2", 0],
+                        "image": ["1", 0]
+                    },
+                    "class_type": "ImageUpscaleWithModel",
+                    "_meta": {"title": "Upscale Image"}
+                },
+                "4": {
+                    "inputs": {
+                        "filename_prefix": "Upscaled",
+                        "images": ["3", 0]
+                    },
+                    "class_type": "SaveImage",
+                    "_meta": {"title": "Save Image"}
+                }
+            },
+            "meta": {
+                "generated_by": "AI Workflow Agent",
+                "type": "upscale",
+                "params": params
+            }
+        }
+    
+    def _generate_inpaint_workflow(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate inpainting workflow."""
+        workflow = self._generate_txt2img_workflow(params)
+        
+        # Add mask loading
+        workflow["prompt"]["10"] = {
+            "inputs": {
+                "image": "INPUT_IMAGE_PATH",
+                "upload": "image"
+            },
+            "class_type": "LoadImage",
+            "_meta": {"title": "Load Image"}
+        }
+        
+        workflow["prompt"]["11"] = {
+            "inputs": {
+                "image": "MASK_IMAGE_PATH",
+                "upload": "image"
+            },
+            "class_type": "LoadImage",
+            "_meta": {"title": "Load Mask"}
+        }
+        
+        # Replace empty latent with masked image
+        workflow["prompt"]["5"] = {
+            "inputs": {
+                "grow_mask_by": 6,
+                "pixels": ["10", 0],
+                "vae": ["4", 2],
+                "mask": ["11", 0]
+            },
+            "class_type": "VAEEncodeForInpaint",
+            "_meta": {"title": "VAE Encode (Inpaint)"}
+        }
+        
+        workflow["meta"]["type"] = "inpaint"
+        
+        return workflow
+    
+    def _generate_controlnet_workflow(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate ControlNet workflow."""
+        workflow = self._generate_txt2img_workflow(params)
+        
+        # Add ControlNet
+        workflow["prompt"]["10"] = {
+            "inputs": {
+                "control_net_name": "control_v11p_sd15_canny.pth"
+            },
+            "class_type": "ControlNetLoader",
+            "_meta": {"title": "Load ControlNet"}
+        }
+        
+        workflow["prompt"]["11"] = {
+            "inputs": {
+                "image": "CONTROL_IMAGE_PATH",
+                "upload": "image"
+            },
+            "class_type": "LoadImage",
+            "_meta": {"title": "Load Control Image"}
+        }
+        
+        workflow["prompt"]["12"] = {
+            "inputs": {
+                "strength": 1.0,
+                "conditioning": ["6", 0],
+                "control_net": ["10", 0],
+                "image": ["11", 0]
+            },
+            "class_type": "ControlNetApply",
+            "_meta": {"title": "Apply ControlNet"}
+        }
+        
+        # Update sampler to use ControlNet conditioning
+        workflow["prompt"]["3"]["inputs"]["positive"] = ["12", 0]
+        
+        workflow["meta"]["type"] = "controlnet"
+        
+        return workflow
+    
+    def _generate_generic_workflow(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate generic workflow (defaults to txt2img)."""
+        return self._generate_txt2img_workflow(params)
+    
+    async def execute_workflow(self, workflow: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Execute workflow in ComfyUI.
+        
+        Args:
+            workflow: ComfyUI workflow JSON
+            
+        Returns:
+            Execution result with output paths
+        """
+        try:
+            # Get the prompt part of workflow
+            prompt = workflow.get("prompt", workflow)
+            
+            # Generate client ID
+            client_id = str(uuid.uuid4())
+            
+            # Queue the prompt
+            response = await self.client.post(
+                f"{self.comfyui_host}/prompt",
+                json={
+                    "prompt": prompt,
+                    "client_id": client_id
+                }
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                prompt_id = result.get("prompt_id")
+                
+                logger.info(f"ComfyUI prompt queued: {prompt_id}")
+                
+                # Wait for completion (poll history)
+                output = await self._wait_for_completion(prompt_id)
+                
+                return {
+                    "success": True,
+                    "prompt_id": prompt_id,
+                    "output": output
+                }
+            else:
+                logger.error(f"ComfyUI queue failed: {response.status_code}")
+                return {
+                    "success": False,
+                    "error": f"Queue failed: {response.status_code}"
+                }
+                
+        except Exception as e:
+            logger.error(f"ComfyUI execute error: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    
+    async def _wait_for_completion(
+        self,
+        prompt_id: str,
+        timeout: int = 300,
+        poll_interval: int = 2
+    ) -> Dict[str, Any]:
+        """Wait for ComfyUI prompt to complete."""
+        import asyncio
+        
+        elapsed = 0
+        while elapsed < timeout:
+            try:
+                response = await self.client.get(
+                    f"{self.comfyui_host}/history/{prompt_id}"
+                )
+                
+                if response.status_code == 200:
+                    history = response.json()
+                    if prompt_id in history:
+                        return history[prompt_id]
+                
+                await asyncio.sleep(poll_interval)
+                elapsed += poll_interval
+                
+            except Exception as e:
+                logger.warning(f"Poll error: {e}")
+                await asyncio.sleep(poll_interval)
+                elapsed += poll_interval
+        
+        return {"status": "timeout", "elapsed": elapsed}
+    
+    async def get_models(self) -> List[str]:
+        """Get available models in ComfyUI."""
+        try:
+            response = await self.client.get(
+                f"{self.comfyui_host}/object_info/CheckpointLoaderSimple"
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                models = data.get("CheckpointLoaderSimple", {}).get(
+                    "input", {}
+                ).get("required", {}).get("ckpt_name", [[]])[0]
+                return models
+            return []
+            
+        except Exception as e:
+            logger.error(f"Get models error: {e}")
+            return []
+    
+    async def get_queue_status(self) -> Dict[str, Any]:
+        """Get current ComfyUI queue status."""
+        try:
+            response = await self.client.get(f"{self.comfyui_host}/queue")
+            if response.status_code == 200:
+                return response.json()
+            return {}
+        except Exception as e:
+            logger.error(f"Queue status error: {e}")
+            return {}

tools/comfyui_templates.py

@@ -0,0 +1,537 @@
+# Additional ComfyUI Workflow Templates
+"""
+Extended ComfyUI workflow templates for generative AI.
+Milestone 1: More comprehensive image generation patterns.
+"""
+
+from datetime import datetime
+from typing import Dict, Any
+
+
+def get_comfyui_templates() -> Dict[str, callable]:
+    """Return all available ComfyUI templates."""
+    return {
+        "text_to_image": text_to_image_workflow,
+        "image_to_image": image_to_image_workflow,
+        "inpainting": inpainting_workflow,
+        "upscale": upscale_workflow,
+        "controlnet": controlnet_workflow,
+        "batch_generation": batch_generation_workflow,
+        "style_transfer": style_transfer_workflow,
+        "lora_generation": lora_generation_workflow,
+    }
+
+
+def text_to_image_workflow(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate basic text-to-image workflow."""
+    prompt = params.get("prompt", "a beautiful landscape")
+    negative = params.get("negative_prompt", "blurry, low quality, distorted")
+    model = params.get("model", "sd_xl_base_1.0.safetensors")
+    width = params.get("width", 1024)
+    height = params.get("height", 1024)
+    steps = params.get("steps", 25)
+    cfg = params.get("cfg", 7.0)
+    seed = params.get("seed", -1)
+    
+    return {
+        "3": {
+            "inputs": {
+                "seed": seed if seed > 0 else 12345,
+                "steps": steps,
+                "cfg": cfg,
+                "sampler_name": "dpmpp_2m",
+                "scheduler": "karras",
+                "denoise": 1.0,
+                "model": ["4", 0],
+                "positive": ["6", 0],
+                "negative": ["7", 0],
+                "latent_image": ["5", 0]
+            },
+            "class_type": "KSampler",
+            "_meta": {"title": "KSampler"}
+        },
+        "4": {
+            "inputs": {"ckpt_name": model},
+            "class_type": "CheckpointLoaderSimple",
+            "_meta": {"title": "Load Checkpoint"}
+        },
+        "5": {
+            "inputs": {"width": width, "height": height, "batch_size": 1},
+            "class_type": "EmptyLatentImage",
+            "_meta": {"title": "Empty Latent"}
+        },
+        "6": {
+            "inputs": {"text": prompt, "clip": ["4", 1]},
+            "class_type": "CLIPTextEncode",
+            "_meta": {"title": "Positive Prompt"}
+        },
+        "7": {
+            "inputs": {"text": negative, "clip": ["4", 1]},
+            "class_type": "CLIPTextEncode",
+            "_meta": {"title": "Negative Prompt"}
+        },
+        "8": {
+            "inputs": {"samples": ["3", 0], "vae": ["4", 2]},
+            "class_type": "VAEDecode",
+            "_meta": {"title": "VAE Decode"}
+        },
+        "9": {
+            "inputs": {"filename_prefix": "txt2img", "images": ["8", 0]},
+            "class_type": "SaveImage",
+            "_meta": {"title": "Save Image"}
+        }
+    }
+
+
+def image_to_image_workflow(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate image-to-image transformation workflow."""
+    prompt = params.get("prompt", "enhance this image")
+    negative = params.get("negative_prompt", "blurry, low quality")
+    model = params.get("model", "sd_xl_base_1.0.safetensors")
+    denoise = params.get("denoise", 0.75)
+    steps = params.get("steps", 30)
+    
+    return {
+        "1": {
+            "inputs": {"image": "input.png", "upload": "image"},
+            "class_type": "LoadImage",
+            "_meta": {"title": "Load Input Image"}
+        },
+        "2": {
+            "inputs": {"ckpt_name": model},
+            "class_type": "CheckpointLoaderSimple",
+            "_meta": {"title": "Load Checkpoint"}
+        },
+        "3": {
+            "inputs": {"pixels": ["1", 0], "vae": ["2", 2]},
+            "class_type": "VAEEncode",
+            "_meta": {"title": "VAE Encode"}
+        },
+        "4": {
+            "inputs": {"text": prompt, "clip": ["2", 1]},
+            "class_type": "CLIPTextEncode",
+            "_meta": {"title": "Positive Prompt"}
+        },
+        "5": {
+            "inputs": {"text": negative, "clip": ["2", 1]},
+            "class_type": "CLIPTextEncode",
+            "_meta": {"title": "Negative Prompt"}
+        },
+        "6": {
+            "inputs": {
+                "seed": 12345,
+                "steps": steps,
+                "cfg": 7.0,
+                "sampler_name": "dpmpp_2m",
+                "scheduler": "karras",
+                "denoise": denoise,
+                "model": ["2", 0],
+                "positive": ["4", 0],
+                "negative": ["5", 0],
+                "latent_image": ["3", 0]
+            },
+            "class_type": "KSampler",
+            "_meta": {"title": "KSampler"}
+        },
+        "7": {
+            "inputs": {"samples": ["6", 0], "vae": ["2", 2]},
+            "class_type": "VAEDecode",
+            "_meta": {"title": "VAE Decode"}
+        },
+        "8": {
+            "inputs": {"filename_prefix": "img2img", "images": ["7", 0]},
+            "class_type": "SaveImage",
+            "_meta": {"title": "Save Image"}
+        }
+    }
+
+
+def inpainting_workflow(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate inpainting workflow."""
+    prompt = params.get("prompt", "fill in the masked area")
+    negative = params.get("negative_prompt", "blurry, distorted")
+    model = params.get("model", "sd_xl_base_1.0.safetensors")
+    
+    return {
+        "1": {
+            "inputs": {"image": "input.png", "upload": "image"},
+            "class_type": "LoadImage",
+            "_meta": {"title": "Load Image"}
+        },
+        "2": {
+            "inputs": {"image": "mask.png", "upload": "image"},
+            "class_type": "LoadImage",
+            "_meta": {"title": "Load Mask"}
+        },
+        "3": {
+            "inputs": {"ckpt_name": model},
+            "class_type": "CheckpointLoaderSimple",
+            "_meta": {"title": "Load Checkpoint"}
+        },
+        "4": {
+            "inputs": {
+                "pixels": ["1", 0],
+                "vae": ["3", 2],
+                "mask": ["2", 0],
+                "grow_mask_by": 6
+            },
+            "class_type": "VAEEncodeForInpaint",
+            "_meta": {"title": "VAE Encode (Inpaint)"}
+        },
+        "5": {
+            "inputs": {"text": prompt, "clip": ["3", 1]},
+            "class_type": "CLIPTextEncode",
+            "_meta": {"title": "Positive"}
+        },
+        "6": {
+            "inputs": {"text": negative, "clip": ["3", 1]},
+            "class_type": "CLIPTextEncode",
+            "_meta": {"title": "Negative"}
+        },
+        "7": {
+            "inputs": {
+                "seed": 12345,
+                "steps": 30,
+                "cfg": 8.0,
+                "sampler_name": "dpmpp_2m_sde",
+                "scheduler": "karras",
+                "denoise": 1.0,
+                "model": ["3", 0],
+                "positive": ["5", 0],
+                "negative": ["6", 0],
+                "latent_image": ["4", 0]
+            },
+            "class_type": "KSampler",
+            "_meta": {"title": "KSampler"}
+        },
+        "8": {
+            "inputs": {"samples": ["7", 0], "vae": ["3", 2]},
+            "class_type": "VAEDecode",
+            "_meta": {"title": "VAE Decode"}
+        },
+        "9": {
+            "inputs": {"filename_prefix": "inpaint", "images": ["8", 0]},
+            "class_type": "SaveImage",
+            "_meta": {"title": "Save Image"}
+        }
+    }
+
+
+def upscale_workflow(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate image upscaling workflow."""
+    upscale_model = params.get("upscale_model", "RealESRGAN_x4plus.pth")
+    
+    return {
+        "1": {
+            "inputs": {"image": "input.png", "upload": "image"},
+            "class_type": "LoadImage",
+            "_meta": {"title": "Load Image"}
+        },
+        "2": {
+            "inputs": {"model_name": upscale_model},
+            "class_type": "UpscaleModelLoader",
+            "_meta": {"title": "Load Upscale Model"}
+        },
+        "3": {
+            "inputs": {"upscale_model": ["2", 0], "image": ["1", 0]},
+            "class_type": "ImageUpscaleWithModel",
+            "_meta": {"title": "Upscale Image"}
+        },
+        "4": {
+            "inputs": {"filename_prefix": "upscaled", "images": ["3", 0]},
+            "class_type": "SaveImage",
+            "_meta": {"title": "Save Image"}
+        }
+    }
+
+
+def controlnet_workflow(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate ControlNet-guided workflow."""
+    prompt = params.get("prompt", "a detailed illustration")
+    negative = params.get("negative_prompt", "blurry, low quality")
+    model = params.get("model", "sd_xl_base_1.0.safetensors")
+    controlnet = params.get("controlnet", "controlnet-canny-sdxl-1.0.safetensors")
+    strength = params.get("strength", 1.0)
+    
+    return {
+        "1": {
+            "inputs": {"image": "control_image.png", "upload": "image"},
+            "class_type": "LoadImage",
+            "_meta": {"title": "Load Control Image"}
+        },
+        "2": {
+            "inputs": {"ckpt_name": model},
+            "class_type": "CheckpointLoaderSimple",
+            "_meta": {"title": "Load Checkpoint"}
+        },
+        "3": {
+            "inputs": {"control_net_name": controlnet},
+            "class_type": "ControlNetLoader",
+            "_meta": {"title": "Load ControlNet"}
+        },
+        "4": {
+            "inputs": {"text": prompt, "clip": ["2", 1]},
+            "class_type": "CLIPTextEncode",
+            "_meta": {"title": "Positive"}
+        },
+        "5": {
+            "inputs": {"text": negative, "clip": ["2", 1]},
+            "class_type": "CLIPTextEncode",
+            "_meta": {"title": "Negative"}
+        },
+        "6": {
+            "inputs": {
+                "strength": strength,
+                "conditioning": ["4", 0],
+                "control_net": ["3", 0],
+                "image": ["1", 0]
+            },
+            "class_type": "ControlNetApply",
+            "_meta": {"title": "Apply ControlNet"}
+        },
+        "7": {
+            "inputs": {"width": 1024, "height": 1024, "batch_size": 1},
+            "class_type": "EmptyLatentImage",
+            "_meta": {"title": "Empty Latent"}
+        },
+        "8": {
+            "inputs": {
+                "seed": 12345,
+                "steps": 30,
+                "cfg": 7.5,
+                "sampler_name": "dpmpp_2m",
+                "scheduler": "karras",
+                "denoise": 1.0,
+                "model": ["2", 0],
+                "positive": ["6", 0],
+                "negative": ["5", 0],
+                "latent_image": ["7", 0]
+            },
+            "class_type": "KSampler",
+            "_meta": {"title": "KSampler"}
+        },
+        "9": {
+            "inputs": {"samples": ["8", 0], "vae": ["2", 2]},
+            "class_type": "VAEDecode",
+            "_meta": {"title": "VAE Decode"}
+        },
+        "10": {
+            "inputs": {"filename_prefix": "controlnet", "images": ["9", 0]},
+            "class_type": "SaveImage",
+            "_meta": {"title": "Save Image"}
+        }
+    }
+
+
+def batch_generation_workflow(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate batch image generation workflow."""
+    prompt = params.get("prompt", "artistic image")
+    negative = params.get("negative_prompt", "blurry")
+    model = params.get("model", "sd_xl_base_1.0.safetensors")
+    batch_size = params.get("batch_size", 4)
+    
+    return {
+        "1": {
+            "inputs": {"ckpt_name": model},
+            "class_type": "CheckpointLoaderSimple",
+            "_meta": {"title": "Load Checkpoint"}
+        },
+        "2": {
+            "inputs": {"width": 1024, "height": 1024, "batch_size": batch_size},
+            "class_type": "EmptyLatentImage",
+            "_meta": {"title": "Empty Latent (Batch)"}
+        },
+        "3": {
+            "inputs": {"text": prompt, "clip": ["1", 1]},
+            "class_type": "CLIPTextEncode",
+            "_meta": {"title": "Positive"}
+        },
+        "4": {
+            "inputs": {"text": negative, "clip": ["1", 1]},
+            "class_type": "CLIPTextEncode",
+            "_meta": {"title": "Negative"}
+        },
+        "5": {
+            "inputs": {
+                "seed": 12345,
+                "steps": 25,
+                "cfg": 7.0,
+                "sampler_name": "dpmpp_2m",
+                "scheduler": "karras",
+                "denoise": 1.0,
+                "model": ["1", 0],
+                "positive": ["3", 0],
+                "negative": ["4", 0],
+                "latent_image": ["2", 0]
+            },
+            "class_type": "KSampler",
+            "_meta": {"title": "KSampler"}
+        },
+        "6": {
+            "inputs": {"samples": ["5", 0], "vae": ["1", 2]},
+            "class_type": "VAEDecode",
+            "_meta": {"title": "VAE Decode"}
+        },
+        "7": {
+            "inputs": {"filename_prefix": "batch", "images": ["6", 0]},
+            "class_type": "SaveImage",
+            "_meta": {"title": "Save Images"}
+        }
+    }
+
+
+def style_transfer_workflow(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate style transfer workflow using IPAdapter."""
+    prompt = params.get("prompt", "in the style of the reference")
+    negative = params.get("negative_prompt", "blurry, low quality")
+    model = params.get("model", "sd_xl_base_1.0.safetensors")
+    weight = params.get("style_weight", 0.8)
+    
+    return {
+        "1": {
+            "inputs": {"image": "content.png", "upload": "image"},
+            "class_type": "LoadImage",
+            "_meta": {"title": "Load Content Image"}
+        },
+        "2": {
+            "inputs": {"image": "style.png", "upload": "image"},
+            "class_type": "LoadImage",
+            "_meta": {"title": "Load Style Image"}
+        },
+        "3": {
+            "inputs": {"ckpt_name": model},
+            "class_type": "CheckpointLoaderSimple",
+            "_meta": {"title": "Load Checkpoint"}
+        },
+        "4": {
+            "inputs": {"ipadapter_file": "ip-adapter_sdxl.safetensors"},
+            "class_type": "IPAdapterModelLoader",
+            "_meta": {"title": "Load IPAdapter"}
+        },
+        "5": {
+            "inputs": {"clip_name": "clip_vision_g.safetensors"},
+            "class_type": "CLIPVisionLoader",
+            "_meta": {"title": "Load CLIP Vision"}
+        },
+        "6": {
+            "inputs": {
+                "weight": weight,
+                "model": ["3", 0],
+                "ipadapter": ["4", 0],
+                "image": ["2", 0],
+                "clip_vision": ["5", 0]
+            },
+            "class_type": "IPAdapterApply",
+            "_meta": {"title": "Apply IPAdapter"}
+        },
+        "7": {
+            "inputs": {"text": prompt, "clip": ["3", 1]},
+            "class_type": "CLIPTextEncode",
+            "_meta": {"title": "Positive"}
+        },
+        "8": {
+            "inputs": {"text": negative, "clip": ["3", 1]},
+            "class_type": "CLIPTextEncode",
+            "_meta": {"title": "Negative"}
+        },
+        "9": {
+            "inputs": {"pixels": ["1", 0], "vae": ["3", 2]},
+            "class_type": "VAEEncode",
+            "_meta": {"title": "VAE Encode"}
+        },
+        "10": {
+            "inputs": {
+                "seed": 12345,
+                "steps": 30,
+                "cfg": 7.0,
+                "sampler_name": "dpmpp_2m",
+                "scheduler": "karras",
+                "denoise": 0.7,
+                "model": ["6", 0],
+                "positive": ["7", 0],
+                "negative": ["8", 0],
+                "latent_image": ["9", 0]
+            },
+            "class_type": "KSampler",
+            "_meta": {"title": "KSampler"}
+        },
+        "11": {
+            "inputs": {"samples": ["10", 0], "vae": ["3", 2]},
+            "class_type": "VAEDecode",
+            "_meta": {"title": "VAE Decode"}
+        },
+        "12": {
+            "inputs": {"filename_prefix": "style_transfer", "images": ["11", 0]},
+            "class_type": "SaveImage",
+            "_meta": {"title": "Save Image"}
+        }
+    }
+
+
+def lora_generation_workflow(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate LoRA-enhanced workflow."""
+    prompt = params.get("prompt", "high quality artwork")
+    negative = params.get("negative_prompt", "blurry, low quality")
+    model = params.get("model", "sd_xl_base_1.0.safetensors")
+    lora_name = params.get("lora", "detail_enhancer.safetensors")
+    lora_strength = params.get("lora_strength", 0.8)
+    
+    return {
+        "1": {
+            "inputs": {"ckpt_name": model},
+            "class_type": "CheckpointLoaderSimple",
+            "_meta": {"title": "Load Checkpoint"}
+        },
+        "2": {
+            "inputs": {
+                "lora_name": lora_name,
+                "strength_model": lora_strength,
+                "strength_clip": lora_strength,
+                "model": ["1", 0],
+                "clip": ["1", 1]
+            },
+            "class_type": "LoraLoader",
+            "_meta": {"title": "Load LoRA"}
+        },
+        "3": {
+            "inputs": {"text": prompt, "clip": ["2", 1]},
+            "class_type": "CLIPTextEncode",
+            "_meta": {"title": "Positive"}
+        },
+        "4": {
+            "inputs": {"text": negative, "clip": ["2", 1]},
+            "class_type": "CLIPTextEncode",
+            "_meta": {"title": "Negative"}
+        },
+        "5": {
+            "inputs": {"width": 1024, "height": 1024, "batch_size": 1},
+            "class_type": "EmptyLatentImage",
+            "_meta": {"title": "Empty Latent"}
+        },
+        "6": {
+            "inputs": {
+                "seed": 12345,
+                "steps": 25,
+                "cfg": 7.0,
+                "sampler_name": "dpmpp_2m",
+                "scheduler": "karras",
+                "denoise": 1.0,
+                "model": ["2", 0],
+                "positive": ["3", 0],
+                "negative": ["4", 0],
+                "latent_image": ["5", 0]
+            },
+            "class_type": "KSampler",
+            "_meta": {"title": "KSampler"}
+        },
+        "7": {
+            "inputs": {"samples": ["6", 0], "vae": ["1", 2]},
+            "class_type": "VAEDecode",
+            "_meta": {"title": "VAE Decode"}
+        },
+        "8": {
+            "inputs": {"filename_prefix": "lora_gen", "images": ["7", 0]},
+            "class_type": "SaveImage",
+            "_meta": {"title": "Save Image"}
+        }
+    }

tools/docker_helper.py

@@ -0,0 +1,449 @@
+# Docker Helper Tool
+"""
+Clone repositories and manage Docker builds.
+Includes error analysis and fix suggestions.
+"""
+
+import httpx
+import subprocess
+import os
+import shutil
+import logging
+from typing import Dict, Any, Optional, List
+from pathlib import Path
+
+from config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class DockerHelper:
+    """
+    Docker automation helper.
+    Clones repos, builds containers, analyzes errors, suggests fixes.
+    """
+    
+    def __init__(self):
+        self.projects_dir = Path(settings.PROJECTS_DIR)
+        self.ollama_host = settings.OLLAMA_HOST
+        self.ollama_model = settings.OLLAMA_MODEL
+        self.client = httpx.AsyncClient(timeout=120.0)
+        
+        # Ensure projects directory exists
+        self.projects_dir.mkdir(parents=True, exist_ok=True)
+    
+    async def clone_and_build(
+        self,
+        repo_url: str,
+        branch: str = "main"
+    ) -> Dict[str, Any]:
+        """
+        Clone repository and attempt Docker build.
+        
+        Args:
+            repo_url: GitHub repository URL
+            branch: Branch to clone (default: main)
+            
+        Returns:
+            Dict with success status, logs, and fix suggestions
+        """
+        project_name = self._extract_project_name(repo_url)
+        project_path = self.projects_dir / project_name
+        
+        try:
+            # Step 1: Clone repository
+            clone_result = await self._clone_repo(repo_url, project_path, branch)
+            if not clone_result["success"]:
+                return clone_result
+            
+            # Step 2: Detect project structure
+            structure = await self._detect_structure(project_path)
+            
+            # Step 3: Attempt Docker build
+            build_result = await self._docker_build(project_path, structure)
+            
+            if build_result["success"]:
+                return {
+                    "success": True,
+                    "message": f"Project {project_name} built successfully",
+                    "container_id": build_result.get("container_id"),
+                    "logs": build_result.get("logs", "")
+                }
+            else:
+                # Step 4: Analyze error and suggest fix
+                fix = await self._analyze_and_suggest_fix(
+                    build_result.get("logs", ""),
+                    project_path
+                )
+                
+                return {
+                    "success": False,
+                    "message": f"Build failed for {project_name}",
+                    "logs": build_result.get("logs", ""),
+                    "fix_suggestion": fix
+                }
+                
+        except Exception as e:
+            logger.error(f"Clone and build error: {e}")
+            return {
+                "success": False,
+                "message": f"Error: {str(e)}",
+                "logs": str(e)
+            }
+    
+    def _extract_project_name(self, repo_url: str) -> str:
+        """Extract project name from repository URL."""
+        # Handle various URL formats
+        url = repo_url.rstrip("/")
+        if url.endswith(".git"):
+            url = url[:-4]
+        return url.split("/")[-1]
+    
+    async def _clone_repo(
+        self,
+        repo_url: str,
+        project_path: Path,
+        branch: str
+    ) -> Dict[str, Any]:
+        """Clone repository to local directory."""
+        try:
+            # Remove existing directory if present
+            if project_path.exists():
+                shutil.rmtree(project_path)
+            
+            # Clone repository
+            result = subprocess.run(
+                ["git", "clone", "--depth", "1", "-b", branch, repo_url, str(project_path)],
+                capture_output=True,
+                text=True,
+                timeout=120
+            )
+            
+            if result.returncode == 0:
+                logger.info(f"Cloned {repo_url} to {project_path}")
+                return {"success": True, "message": "Repository cloned"}
+            else:
+                # Try without branch specification (use default)
+                result = subprocess.run(
+                    ["git", "clone", "--depth", "1", repo_url, str(project_path)],
+                    capture_output=True,
+                    text=True,
+                    timeout=120
+                )
+                
+                if result.returncode == 0:
+                    return {"success": True, "message": "Repository cloned (default branch)"}
+                else:
+                    return {
+                        "success": False,
+                        "message": f"Clone failed: {result.stderr}",
+                        "logs": result.stderr
+                    }
+                    
+        except subprocess.TimeoutExpired:
+            return {"success": False, "message": "Clone timed out"}
+        except Exception as e:
+            return {"success": False, "message": f"Clone error: {str(e)}"}
+    
+    async def _detect_structure(self, project_path: Path) -> Dict[str, Any]:
+        """Detect project structure and configuration files."""
+        structure = {
+            "has_dockerfile": False,
+            "has_compose": False,
+            "has_requirements": False,
+            "has_package_json": False,
+            "has_makefile": False,
+            "dockerfile_path": None,
+            "compose_path": None,
+            "language": "unknown"
+        }
+        
+        files_to_check = {
+            "Dockerfile": ("has_dockerfile", "dockerfile_path"),
+            "docker-compose.yml": ("has_compose", "compose_path"),
+            "docker-compose.yaml": ("has_compose", "compose_path"),
+            "compose.yml": ("has_compose", "compose_path"),
+            "compose.yaml": ("has_compose", "compose_path"),
+            "requirements.txt": ("has_requirements", None),
+            "package.json": ("has_package_json", None),
+            "Makefile": ("has_makefile", None)
+        }
+        
+        for filename, (flag, path_key) in files_to_check.items():
+            file_path = project_path / filename
+            if file_path.exists():
+                structure[flag] = True
+                if path_key:
+                    structure[path_key] = str(file_path)
+        
+        # Detect language
+        if structure["has_requirements"]:
+            structure["language"] = "python"
+        elif structure["has_package_json"]:
+            structure["language"] = "javascript"
+        
+        return structure
+    
+    async def _docker_build(
+        self,
+        project_path: Path,
+        structure: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Attempt to build Docker container."""
+        try:
+            project_name = project_path.name.lower().replace("_", "-").replace(".", "-")
+            
+            # Prefer docker-compose if available
+            if structure["has_compose"]:
+                compose_path = structure["compose_path"]
+                
+                result = subprocess.run(
+                    ["docker", "compose", "-f", compose_path, "build"],
+                    capture_output=True,
+                    text=True,
+                    cwd=str(project_path),
+                    timeout=600  # 10 minute timeout
+                )
+                
+                if result.returncode == 0:
+                    # Start containers
+                    start_result = subprocess.run(
+                        ["docker", "compose", "-f", compose_path, "up", "-d"],
+                        capture_output=True,
+                        text=True,
+                        cwd=str(project_path),
+                        timeout=300
+                    )
+                    
+                    return {
+                        "success": start_result.returncode == 0,
+                        "logs": result.stdout + start_result.stdout,
+                        "method": "docker-compose"
+                    }
+                else:
+                    return {
+                        "success": False,
+                        "logs": result.stderr,
+                        "method": "docker-compose"
+                    }
+            
+            # Fall back to Dockerfile
+            elif structure["has_dockerfile"]:
+                result = subprocess.run(
+                    ["docker", "build", "-t", project_name, "."],
+                    capture_output=True,
+                    text=True,
+                    cwd=str(project_path),
+                    timeout=600
+                )
+                
+                if result.returncode == 0:
+                    # Run container
+                    run_result = subprocess.run(
+                        ["docker", "run", "-d", "--name", f"{project_name}-container", project_name],
+                        capture_output=True,
+                        text=True,
+                        timeout=60
+                    )
+                    
+                    return {
+                        "success": run_result.returncode == 0,
+                        "container_id": run_result.stdout.strip()[:12] if run_result.returncode == 0 else None,
+                        "logs": result.stdout + run_result.stdout,
+                        "method": "dockerfile"
+                    }
+                else:
+                    return {
+                        "success": False,
+                        "logs": result.stderr,
+                        "method": "dockerfile"
+                    }
+            
+            # No Docker configuration found - generate Dockerfile
+            else:
+                generated = await self._generate_dockerfile(project_path, structure)
+                if generated:
+                    # Retry build with generated Dockerfile
+                    structure["has_dockerfile"] = True
+                    structure["dockerfile_path"] = str(project_path / "Dockerfile")
+                    return await self._docker_build(project_path, structure)
+                else:
+                    return {
+                        "success": False,
+                        "logs": "No Dockerfile found and auto-generation failed",
+                        "method": "none"
+                    }
+                    
+        except subprocess.TimeoutExpired:
+            return {"success": False, "logs": "Build timed out (>10 minutes)"}
+        except Exception as e:
+            return {"success": False, "logs": f"Build error: {str(e)}"}
+    
+    async def _generate_dockerfile(
+        self,
+        project_path: Path,
+        structure: Dict[str, Any]
+    ) -> bool:
+        """Generate a Dockerfile based on project structure."""
+        try:
+            dockerfile_content = ""
+            
+            if structure["language"] == "python":
+                dockerfile_content = """# Auto-generated Dockerfile
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+CMD ["python", "main.py"]
+"""
+            elif structure["language"] == "javascript":
+                dockerfile_content = """# Auto-generated Dockerfile
+FROM node:20-alpine
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm install
+
+COPY . .
+
+EXPOSE 3000
+
+CMD ["npm", "start"]
+"""
+            else:
+                # Generic fallback
+                dockerfile_content = """# Auto-generated Dockerfile
+FROM ubuntu:22.04
+
+WORKDIR /app
+
+COPY . .
+
+CMD ["bash"]
+"""
+            
+            dockerfile_path = project_path / "Dockerfile"
+            dockerfile_path.write_text(dockerfile_content)
+            
+            logger.info(f"Generated Dockerfile for {project_path.name}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Dockerfile generation error: {e}")
+            return False
+    
+    async def _analyze_and_suggest_fix(
+        self,
+        error_logs: str,
+        project_path: Path
+    ) -> str:
+        """
+        Analyze build error and suggest fix using LLM.
+        
+        NOTE: This only suggests ONE fix, no infinite loops.
+        """
+        try:
+            prompt = f"""Analyze this Docker build error and suggest ONE specific fix.
+
+Error logs:
+```
+{error_logs[:2000]}
+```
+
+Project: {project_path.name}
+
+Provide a concise fix suggestion. If multiple issues, focus on the first/most critical one.
+Format:
+1. Problem: [what went wrong]
+2. Fix: [specific action to take]
+3. Command: [if applicable, the command to run]"""
+
+            response = await self.client.post(
+                f"{self.ollama_host}/api/generate",
+                json={
+                    "model": self.ollama_model,
+                    "prompt": prompt,
+                    "stream": False
+                }
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                return result.get("response", "Unable to analyze error")
+            else:
+                return "Error analysis unavailable (LLM request failed)"
+                
+        except Exception as e:
+            logger.error(f"Error analysis failed: {e}")
+            return f"Error analysis failed: {str(e)}"
+    
+    async def get_container_logs(self, container_id: str, lines: int = 100) -> str:
+        """Get logs from a running container."""
+        try:
+            result = subprocess.run(
+                ["docker", "logs", "--tail", str(lines), container_id],
+                capture_output=True,
+                text=True,
+                timeout=30
+            )
+            return result.stdout + result.stderr
+        except Exception as e:
+            return f"Failed to get logs: {str(e)}"
+    
+    async def list_containers(self, all_containers: bool = False) -> List[Dict[str, str]]:
+        """List Docker containers."""
+        try:
+            cmd = ["docker", "ps", "--format", "{{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Image}}"]
+            if all_containers:
+                cmd.append("-a")
+            
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+            
+            containers = []
+            for line in result.stdout.strip().split("\n"):
+                if line:
+                    parts = line.split("\t")
+                    if len(parts) >= 4:
+                        containers.append({
+                            "id": parts[0],
+                            "name": parts[1],
+                            "status": parts[2],
+                            "image": parts[3]
+                        })
+            return containers
+            
+        except Exception as e:
+            logger.error(f"List containers error: {e}")
+            return []
+    
+    async def stop_container(self, container_id: str) -> bool:
+        """Stop a running container."""
+        try:
+            result = subprocess.run(
+                ["docker", "stop", container_id],
+                capture_output=True,
+                text=True,
+                timeout=60
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+    
+    async def remove_container(self, container_id: str) -> bool:
+        """Remove a container."""
+        try:
+            result = subprocess.run(
+                ["docker", "rm", "-f", container_id],
+                capture_output=True,
+                text=True,
+                timeout=60
+            )
+            return result.returncode == 0
+        except Exception:
+            return False

tools/github_search.py

@@ -0,0 +1,241 @@
+# GitHub Search Tool
+"""
+Search GitHub repositories and provide recommendations.
+Simple keyword search with README summarization.
+"""
+
+import httpx
+import logging
+from typing import List, Dict, Any, Optional
+
+from config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class GitHubSearchTool:
+    """
+    GitHub repository search tool.
+    Searches for relevant projects and provides recommendations.
+    """
+    
+    def __init__(self):
+        self.api_base = "https://api.github.com"
+        self.token = settings.GITHUB_TOKEN
+        self.client = httpx.AsyncClient(timeout=30.0)
+        
+        # Set headers
+        self.headers = {
+            "Accept": "application/vnd.github.v3+json",
+            "User-Agent": "AI-Workflow-Agent"
+        }
+        if self.token:
+            self.headers["Authorization"] = f"token {self.token}"
+    
+    async def search(
+        self,
+        keywords: str,
+        max_results: int = 3,
+        language: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Search GitHub repositories by keywords.
+        
+        Args:
+            keywords: Search terms
+            max_results: Maximum number of results (default 3)
+            language: Optional language filter
+            
+        Returns:
+            List of repository info dictionaries
+        """
+        try:
+            # Build search query
+            query = keywords
+            if language:
+                query += f" language:{language}"
+            
+            # Search repositories
+            response = await self.client.get(
+                f"{self.api_base}/search/repositories",
+                params={
+                    "q": query,
+                    "sort": "stars",
+                    "order": "desc",
+                    "per_page": max_results
+                },
+                headers=self.headers
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                repos = data.get("items", [])
+                
+                # Extract relevant info
+                results = []
+                for repo in repos[:max_results]:
+                    repo_info = await self._extract_repo_info(repo)
+                    results.append(repo_info)
+                
+                return results
+            else:
+                logger.error(f"GitHub search failed: {response.status_code}")
+                return []
+                
+        except Exception as e:
+            logger.error(f"GitHub search error: {e}")
+            return []
+    
+    async def _extract_repo_info(self, repo: Dict[str, Any]) -> Dict[str, Any]:
+        """Extract relevant information from repository data."""
+        # Get README summary
+        readme_summary = await self._get_readme_summary(
+            repo.get("owner", {}).get("login", ""),
+            repo.get("name", "")
+        )
+        
+        return {
+            "name": repo.get("name", ""),
+            "full_name": repo.get("full_name", ""),
+            "url": repo.get("html_url", ""),
+            "clone_url": repo.get("clone_url", ""),
+            "description": repo.get("description", "No description"),
+            "stars": repo.get("stargazers_count", 0),
+            "forks": repo.get("forks_count", 0),
+            "language": repo.get("language", "Unknown"),
+            "topics": repo.get("topics", []),
+            "updated_at": repo.get("updated_at", ""),
+            "has_docker": await self._check_has_docker(
+                repo.get("owner", {}).get("login", ""),
+                repo.get("name", "")
+            ),
+            "readme_summary": readme_summary
+        }
+    
+    async def _get_readme_summary(self, owner: str, repo: str) -> str:
+        """Fetch and summarize repository README."""
+        try:
+            response = await self.client.get(
+                f"{self.api_base}/repos/{owner}/{repo}/readme",
+                headers=self.headers
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                # README is base64 encoded
+                import base64
+                content = base64.b64decode(data.get("content", "")).decode("utf-8")
+                
+                # Simple summary: first 500 chars
+                summary = content[:500].replace("\n", " ").strip()
+                if len(content) > 500:
+                    summary += "..."
+                return summary
+            return "README not available"
+            
+        except Exception as e:
+            logger.warning(f"README fetch error: {e}")
+            return "README not available"
+    
+    async def _check_has_docker(self, owner: str, repo: str) -> bool:
+        """Check if repository has Dockerfile or docker-compose."""
+        try:
+            # Check for Dockerfile
+            response = await self.client.get(
+                f"{self.api_base}/repos/{owner}/{repo}/contents/Dockerfile",
+                headers=self.headers
+            )
+            if response.status_code == 200:
+                return True
+            
+            # Check for docker-compose
+            response = await self.client.get(
+                f"{self.api_base}/repos/{owner}/{repo}/contents/docker-compose.yml",
+                headers=self.headers
+            )
+            if response.status_code == 200:
+                return True
+                
+            # Check for docker-compose.yaml
+            response = await self.client.get(
+                f"{self.api_base}/repos/{owner}/{repo}/contents/docker-compose.yaml",
+                headers=self.headers
+            )
+            return response.status_code == 200
+            
+        except Exception:
+            return False
+    
+    async def generate_recommendation(self, repos: List[Dict[str, Any]]) -> str:
+        """
+        Generate a recommendation summary for found repositories.
+        
+        Args:
+            repos: List of repository info dictionaries
+            
+        Returns:
+            Recommendation text
+        """
+        if not repos:
+            return "No repositories found. Try different keywords."
+        
+        # Build recommendation
+        lines = ["📦 **Repository Recommendations:**\n"]
+        
+        for i, repo in enumerate(repos, 1):
+            stars = repo.get("stars", 0)
+            docker_status = "✅ Docker" if repo.get("has_docker") else "❌ No Docker"
+            
+            lines.append(f"**{i}. {repo.get('name', 'Unknown')}** ⭐ {stars}")
+            lines.append(f"   {repo.get('description', 'No description')}")
+            lines.append(f"   Language: {repo.get('language', 'Unknown')} | {docker_status}")
+            lines.append(f"   URL: {repo.get('url', '')}")
+            lines.append("")
+        
+        # Add best pick recommendation
+        if repos:
+            best = max(repos, key=lambda r: r.get("stars", 0))
+            if best.get("has_docker"):
+                lines.append(f"💡 **Recommended:** {best.get('name')} (most stars + Docker support)")
+            else:
+                docker_repos = [r for r in repos if r.get("has_docker")]
+                if docker_repos:
+                    best_docker = max(docker_repos, key=lambda r: r.get("stars", 0))
+                    lines.append(f"💡 **Recommended:** {best_docker.get('name')} (has Docker support)")
+                else:
+                    lines.append(f"💡 **Recommended:** {best.get('name')} (most stars, but needs Docker setup)")
+        
+        return "\n".join(lines)
+    
+    async def get_repo_details(self, repo_url: str) -> Dict[str, Any]:
+        """
+        Get detailed information about a specific repository.
+        
+        Args:
+            repo_url: GitHub repository URL or owner/repo format
+            
+        Returns:
+            Repository details dictionary
+        """
+        try:
+            # Parse owner/repo from URL or direct format
+            if "github.com" in repo_url:
+                parts = repo_url.rstrip("/").split("/")
+                owner = parts[-2]
+                repo = parts[-1]
+            else:
+                owner, repo = repo_url.split("/")
+            
+            response = await self.client.get(
+                f"{self.api_base}/repos/{owner}/{repo}",
+                headers=self.headers
+            )
+            
+            if response.status_code == 200:
+                return await self._extract_repo_info(response.json())
+            else:
+                return {"error": f"Repository not found: {response.status_code}"}
+                
+        except Exception as e:
+            logger.error(f"Repo details error: {e}")
+            return {"error": str(e)}

tools/n8n_builder.py

@@ -0,0 +1,620 @@
+# n8n Workflow Builder Tool
+"""
+Generate and deploy n8n workflow JSON templates.
+Supports common automation patterns.
+LLM-enhanced generation when context.use_llm=True.
+"""
+
+import httpx
+import json
+import logging
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+from config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class N8NWorkflowBuilder:
+    """
+    n8n workflow generator and deployer.
+    Creates JSON workflow templates and deploys via n8n API.
+    """
+    
+    def __init__(self):
+        self.n8n_host = settings.N8N_HOST
+        self.api_key = settings.N8N_API_KEY
+        self.client = httpx.AsyncClient(timeout=30.0)
+        
+        # Headers for n8n API
+        self.headers = {
+            "Content-Type": "application/json"
+        }
+        if self.api_key:
+            self.headers["X-N8N-API-KEY"] = self.api_key
+    
+    async def check_health(self) -> str:
+        """Check if n8n is running and responsive."""
+        try:
+            response = await self.client.get(
+                f"{self.n8n_host}/healthz"
+            )
+            if response.status_code == 200:
+                return "healthy"
+            return "unhealthy"
+        except Exception as e:
+            logger.debug(f"n8n health check failed: {e}")
+            return "unreachable"
+    
+    async def generate_workflow(self, query: str, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Generate n8n workflow JSON based on user query.
+        
+        Args:
+            query: User's natural language request
+            context: Optional context with use_llm flag for LLM-enhanced generation
+            
+        Returns:
+            n8n workflow JSON structure
+        """
+        # Check if LLM enhancement is requested
+        use_llm = False
+        if context and isinstance(context, dict):
+            use_llm = context.get('use_llm', False)
+        
+        # If LLM mode is enabled, use AI to analyze and create more intelligent workflow
+        if use_llm:
+            logger.info("Using LLM-enhanced workflow generation")
+            workflow = await self._generate_llm_workflow(query)
+            if workflow:
+                return workflow
+            # Fall back to template if LLM fails
+            logger.warning("LLM generation failed, falling back to templates")
+        
+        # Template-based generation (keyword mode)
+        workflow_type = self._detect_workflow_type(query)
+        
+        # Generate appropriate template
+        templates = {
+            "webhook": self._generate_webhook_workflow,
+            "schedule": self._generate_schedule_workflow,
+            "api_integration": self._generate_api_workflow,
+            "email": self._generate_email_workflow,
+            "data_transform": self._generate_transform_workflow,
+            "notification": self._generate_notification_workflow,
+            "generic": self._generate_generic_workflow
+        }
+        
+        generator = templates.get(workflow_type, self._generate_generic_workflow)
+        workflow = generator(query)
+        
+        return workflow
+    
+    async def _generate_llm_workflow(self, query: str) -> Optional[Dict[str, Any]]:
+        """
+        Use LLM to generate a more intelligent workflow based on query analysis.
+        
+        Args:
+            query: User's natural language request
+            
+        Returns:
+            Enhanced n8n workflow or None if LLM fails
+        """
+        try:
+            # Import here to avoid circular dependency
+            from decision_agent import DecisionAgent
+            
+            agent = DecisionAgent()
+            analysis = await agent.analyze(query, context={'use_llm': True})
+            
+            # Use analysis explanation to create more detailed workflow
+            workflow_type = self._detect_workflow_type(query)
+            explanation = analysis.get('explanation', '')
+            
+            # Generate base template
+            templates = {
+                "webhook": self._generate_webhook_workflow,
+                "schedule": self._generate_schedule_workflow,
+                "api_integration": self._generate_api_workflow,
+                "email": self._generate_email_workflow,
+                "data_transform": self._generate_transform_workflow,
+                "notification": self._generate_notification_workflow,
+                "generic": self._generate_generic_workflow
+            }
+            
+            generator = templates.get(workflow_type, self._generate_generic_workflow)
+            workflow = generator(query)
+            
+            # Enhance with LLM analysis
+            workflow['meta']['llm_analysis'] = {
+                'explanation': explanation,
+                'confidence': analysis.get('confidence', 0.0),
+                'suggested_tools': analysis.get('suggested_tools', []),
+                'next_steps': analysis.get('next_steps', [])
+            }
+            workflow['meta']['generated_with_llm'] = True
+            
+            return workflow
+            
+        except Exception as e:
+            logger.error(f"LLM workflow generation failed: {e}")
+            return None
+    
+    def _detect_workflow_type(self, query: str) -> str:
+        """Detect the type of workflow needed from query."""
+        query_lower = query.lower()
+        
+        if any(w in query_lower for w in ["webhook", "http", "api call", "endpoint"]):
+            return "webhook"
+        elif any(w in query_lower for w in ["schedule", "cron", "every day", "every hour", "periodic"]):
+            return "schedule"
+        elif any(w in query_lower for w in ["api", "rest", "fetch", "get data"]):
+            return "api_integration"
+        elif any(w in query_lower for w in ["email", "mail", "send message", "gmail"]):
+            return "email"
+        elif any(w in query_lower for w in ["transform", "convert", "process", "parse"]):
+            return "data_transform"
+        elif any(w in query_lower for w in ["notify", "slack", "telegram", "alert"]):
+            return "notification"
+        else:
+            return "generic"
+    
+    def _generate_webhook_workflow(self, query: str) -> Dict[str, Any]:
+        """Generate webhook-triggered workflow."""
+        return {
+            "name": f"Webhook Workflow - {datetime.now().strftime('%Y%m%d_%H%M%S')}",
+            "nodes": [
+                {
+                    "parameters": {
+                        "httpMethod": "POST",
+                        "path": "webhook-trigger",
+                        "responseMode": "onReceived",
+                        "responseData": "allEntries"
+                    },
+                    "id": "webhook_1",
+                    "name": "Webhook",
+                    "type": "n8n-nodes-base.webhook",
+                    "typeVersion": 1,
+                    "position": [250, 300]
+                },
+                {
+                    "parameters": {},
+                    "id": "set_1",
+                    "name": "Process Data",
+                    "type": "n8n-nodes-base.set",
+                    "typeVersion": 1,
+                    "position": [450, 300]
+                },
+                {
+                    "parameters": {
+                        "functionCode": "// Process incoming data\nconst items = $input.all();\nreturn items;"
+                    },
+                    "id": "code_1",
+                    "name": "Custom Logic",
+                    "type": "n8n-nodes-base.code",
+                    "typeVersion": 1,
+                    "position": [650, 300]
+                }
+            ],
+            "connections": {
+                "Webhook": {
+                    "main": [[{"node": "Process Data", "type": "main", "index": 0}]]
+                },
+                "Process Data": {
+                    "main": [[{"node": "Custom Logic", "type": "main", "index": 0}]]
+                }
+            },
+            "settings": {
+                "executionOrder": "v1"
+            },
+            "meta": {
+                "generated_by": "AI Workflow Agent",
+                "query": query,
+                "type": "webhook"
+            }
+        }
+    
+    def _generate_schedule_workflow(self, query: str) -> Dict[str, Any]:
+        """Generate schedule-triggered workflow."""
+        return {
+            "name": f"Scheduled Workflow - {datetime.now().strftime('%Y%m%d_%H%M%S')}",
+            "nodes": [
+                {
+                    "parameters": {
+                        "rule": {
+                            "interval": [{"field": "hours", "hoursInterval": 1}]
+                        }
+                    },
+                    "id": "schedule_1",
+                    "name": "Schedule Trigger",
+                    "type": "n8n-nodes-base.scheduleTrigger",
+                    "typeVersion": 1,
+                    "position": [250, 300]
+                },
+                {
+                    "parameters": {
+                        "functionCode": "// Scheduled task logic\nconst now = new Date();\nreturn [{ json: { timestamp: now.toISOString(), status: 'executed' } }];"
+                    },
+                    "id": "code_1",
+                    "name": "Execute Task",
+                    "type": "n8n-nodes-base.code",
+                    "typeVersion": 1,
+                    "position": [450, 300]
+                }
+            ],
+            "connections": {
+                "Schedule Trigger": {
+                    "main": [[{"node": "Execute Task", "type": "main", "index": 0}]]
+                }
+            },
+            "settings": {
+                "executionOrder": "v1"
+            },
+            "meta": {
+                "generated_by": "AI Workflow Agent",
+                "query": query,
+                "type": "schedule"
+            }
+        }
+    
+    def _generate_api_workflow(self, query: str) -> Dict[str, Any]:
+        """Generate API integration workflow."""
+        return {
+            "name": f"API Integration - {datetime.now().strftime('%Y%m%d_%H%M%S')}",
+            "nodes": [
+                {
+                    "parameters": {
+                        "httpMethod": "GET",
+                        "path": "api-trigger",
+                        "responseMode": "responseNode"
+                    },
+                    "id": "webhook_1",
+                    "name": "API Trigger",
+                    "type": "n8n-nodes-base.webhook",
+                    "typeVersion": 1,
+                    "position": [250, 300]
+                },
+                {
+                    "parameters": {
+                        "url": "https://api.example.com/data",
+                        "method": "GET",
+                        "options": {}
+                    },
+                    "id": "http_1",
+                    "name": "HTTP Request",
+                    "type": "n8n-nodes-base.httpRequest",
+                    "typeVersion": 4,
+                    "position": [450, 300]
+                },
+                {
+                    "parameters": {
+                        "respondWith": "json",
+                        "responseBody": "={{ $json }}"
+                    },
+                    "id": "respond_1",
+                    "name": "Respond",
+                    "type": "n8n-nodes-base.respondToWebhook",
+                    "typeVersion": 1,
+                    "position": [650, 300]
+                }
+            ],
+            "connections": {
+                "API Trigger": {
+                    "main": [[{"node": "HTTP Request", "type": "main", "index": 0}]]
+                },
+                "HTTP Request": {
+                    "main": [[{"node": "Respond", "type": "main", "index": 0}]]
+                }
+            },
+            "settings": {
+                "executionOrder": "v1"
+            },
+            "meta": {
+                "generated_by": "AI Workflow Agent",
+                "query": query,
+                "type": "api_integration"
+            }
+        }
+    
+    def _generate_email_workflow(self, query: str) -> Dict[str, Any]:
+        """Generate email workflow."""
+        return {
+            "name": f"Email Workflow - {datetime.now().strftime('%Y%m%d_%H%M%S')}",
+            "nodes": [
+                {
+                    "parameters": {
+                        "httpMethod": "POST",
+                        "path": "send-email",
+                        "responseMode": "onReceived"
+                    },
+                    "id": "webhook_1",
+                    "name": "Trigger",
+                    "type": "n8n-nodes-base.webhook",
+                    "typeVersion": 1,
+                    "position": [250, 300]
+                },
+                {
+                    "parameters": {
+                        "fromEmail": "={{ $json.from || 'noreply@example.com' }}",
+                        "toEmail": "={{ $json.to }}",
+                        "subject": "={{ $json.subject }}",
+                        "emailType": "text",
+                        "message": "={{ $json.body }}"
+                    },
+                    "id": "email_1",
+                    "name": "Send Email",
+                    "type": "n8n-nodes-base.emailSend",
+                    "typeVersion": 2,
+                    "position": [450, 300],
+                    "credentials": {
+                        "smtp": {
+                            "id": "SMTP_CREDENTIAL_ID",
+                            "name": "SMTP Account"
+                        }
+                    }
+                }
+            ],
+            "connections": {
+                "Trigger": {
+                    "main": [[{"node": "Send Email", "type": "main", "index": 0}]]
+                }
+            },
+            "settings": {
+                "executionOrder": "v1"
+            },
+            "meta": {
+                "generated_by": "AI Workflow Agent",
+                "query": query,
+                "type": "email",
+                "note": "Requires SMTP credentials configuration"
+            }
+        }
+    
+    def _generate_transform_workflow(self, query: str) -> Dict[str, Any]:
+        """Generate data transformation workflow."""
+        return {
+            "name": f"Data Transform - {datetime.now().strftime('%Y%m%d_%H%M%S')}",
+            "nodes": [
+                {
+                    "parameters": {
+                        "httpMethod": "POST",
+                        "path": "transform",
+                        "responseMode": "responseNode"
+                    },
+                    "id": "webhook_1",
+                    "name": "Input",
+                    "type": "n8n-nodes-base.webhook",
+                    "typeVersion": 1,
+                    "position": [250, 300]
+                },
+                {
+                    "parameters": {
+                        "functionCode": "// Transform data\nconst items = $input.all();\nconst transformed = items.map(item => {\n  return {\n    json: {\n      ...item.json,\n      processed: true,\n      timestamp: new Date().toISOString()\n    }\n  };\n});\nreturn transformed;"
+                    },
+                    "id": "code_1",
+                    "name": "Transform",
+                    "type": "n8n-nodes-base.code",
+                    "typeVersion": 1,
+                    "position": [450, 300]
+                },
+                {
+                    "parameters": {
+                        "respondWith": "json",
+                        "responseBody": "={{ $json }}"
+                    },
+                    "id": "respond_1",
+                    "name": "Output",
+                    "type": "n8n-nodes-base.respondToWebhook",
+                    "typeVersion": 1,
+                    "position": [650, 300]
+                }
+            ],
+            "connections": {
+                "Input": {
+                    "main": [[{"node": "Transform", "type": "main", "index": 0}]]
+                },
+                "Transform": {
+                    "main": [[{"node": "Output", "type": "main", "index": 0}]]
+                }
+            },
+            "settings": {
+                "executionOrder": "v1"
+            },
+            "meta": {
+                "generated_by": "AI Workflow Agent",
+                "query": query,
+                "type": "data_transform"
+            }
+        }
+    
+    def _generate_notification_workflow(self, query: str) -> Dict[str, Any]:
+        """Generate notification workflow (Slack/Telegram)."""
+        return {
+            "name": f"Notification Workflow - {datetime.now().strftime('%Y%m%d_%H%M%S')}",
+            "nodes": [
+                {
+                    "parameters": {
+                        "httpMethod": "POST",
+                        "path": "notify",
+                        "responseMode": "onReceived"
+                    },
+                    "id": "webhook_1",
+                    "name": "Trigger",
+                    "type": "n8n-nodes-base.webhook",
+                    "typeVersion": 1,
+                    "position": [250, 300]
+                },
+                {
+                    "parameters": {
+                        "channel": "={{ $json.channel || '#general' }}",
+                        "text": "={{ $json.message }}",
+                        "otherOptions": {}
+                    },
+                    "id": "slack_1",
+                    "name": "Slack",
+                    "type": "n8n-nodes-base.slack",
+                    "typeVersion": 2,
+                    "position": [450, 250],
+                    "credentials": {
+                        "slackApi": {
+                            "id": "SLACK_CREDENTIAL_ID",
+                            "name": "Slack Account"
+                        }
+                    }
+                },
+                {
+                    "parameters": {
+                        "chatId": "={{ $json.chat_id }}",
+                        "text": "={{ $json.message }}"
+                    },
+                    "id": "telegram_1",
+                    "name": "Telegram",
+                    "type": "n8n-nodes-base.telegram",
+                    "typeVersion": 1,
+                    "position": [450, 350],
+                    "credentials": {
+                        "telegramApi": {
+                            "id": "TELEGRAM_CREDENTIAL_ID",
+                            "name": "Telegram Bot"
+                        }
+                    }
+                }
+            ],
+            "connections": {
+                "Trigger": {
+                    "main": [
+                        [
+                            {"node": "Slack", "type": "main", "index": 0},
+                            {"node": "Telegram", "type": "main", "index": 0}
+                        ]
+                    ]
+                }
+            },
+            "settings": {
+                "executionOrder": "v1"
+            },
+            "meta": {
+                "generated_by": "AI Workflow Agent",
+                "query": query,
+                "type": "notification",
+                "note": "Requires Slack/Telegram credentials configuration"
+            }
+        }
+    
+    def _generate_generic_workflow(self, query: str) -> Dict[str, Any]:
+        """Generate generic workflow template."""
+        return {
+            "name": f"Workflow - {datetime.now().strftime('%Y%m%d_%H%M%S')}",
+            "nodes": [
+                {
+                    "parameters": {
+                        "httpMethod": "POST",
+                        "path": "workflow-trigger",
+                        "responseMode": "responseNode"
+                    },
+                    "id": "webhook_1",
+                    "name": "Start",
+                    "type": "n8n-nodes-base.webhook",
+                    "typeVersion": 1,
+                    "position": [250, 300]
+                },
+                {
+                    "parameters": {
+                        "functionCode": f"// Generated for: {query}\n// Add your custom logic here\nconst input = $input.all();\nreturn input;"
+                    },
+                    "id": "code_1",
+                    "name": "Process",
+                    "type": "n8n-nodes-base.code",
+                    "typeVersion": 1,
+                    "position": [450, 300]
+                },
+                {
+                    "parameters": {
+                        "respondWith": "json",
+                        "responseBody": "={{ $json }}"
+                    },
+                    "id": "respond_1",
+                    "name": "End",
+                    "type": "n8n-nodes-base.respondToWebhook",
+                    "typeVersion": 1,
+                    "position": [650, 300]
+                }
+            ],
+            "connections": {
+                "Start": {
+                    "main": [[{"node": "Process", "type": "main", "index": 0}]]
+                },
+                "Process": {
+                    "main": [[{"node": "End", "type": "main", "index": 0}]]
+                }
+            },
+            "settings": {
+                "executionOrder": "v1"
+            },
+            "meta": {
+                "generated_by": "AI Workflow Agent",
+                "query": query,
+                "type": "generic"
+            }
+        }
+    
+    async def deploy_workflow(self, workflow: Dict[str, Any]) -> str:
+        """
+        Deploy workflow to n8n instance via API.
+        
+        Args:
+            workflow: n8n workflow JSON
+            
+        Returns:
+            Workflow ID if successful
+        """
+        try:
+            response = await self.client.post(
+                f"{self.n8n_host}/api/v1/workflows",
+                headers=self.headers,
+                json=workflow
+            )
+            
+            if response.status_code in [200, 201]:
+                data = response.json()
+                workflow_id = data.get("id", "unknown")
+                logger.info(f"Workflow deployed: {workflow_id}")
+                return workflow_id
+            else:
+                logger.error(f"Deploy failed: {response.status_code} - {response.text}")
+                raise Exception(f"Deploy failed: {response.status_code}")
+                
+        except Exception as e:
+            logger.error(f"Deploy error: {e}")
+            raise
+    
+    async def list_workflows(self) -> List[Dict[str, Any]]:
+        """List all workflows in n8n."""
+        try:
+            response = await self.client.get(
+                f"{self.n8n_host}/api/v1/workflows",
+                headers=self.headers
+            )
+            
+            if response.status_code == 200:
+                return response.json().get("data", [])
+            return []
+            
+        except Exception as e:
+            logger.error(f"List workflows error: {e}")
+            return []
+    
+    async def activate_workflow(self, workflow_id: str, active: bool = True) -> bool:
+        """Activate or deactivate a workflow."""
+        try:
+            response = await self.client.patch(
+                f"{self.n8n_host}/api/v1/workflows/{workflow_id}",
+                headers=self.headers,
+                json={"active": active}
+            )
+            return response.status_code == 200
+            
+        except Exception as e:
+            logger.error(f"Activate workflow error: {e}")
+            return False

tools/web_search.py

@@ -0,0 +1,169 @@
+# Web Search Tool
+"""
+Search the web for project recommendations and documentation.
+Uses DuckDuckGo (no API key required) for search.
+"""
+
+import httpx
+import logging
+import re
+from typing import Dict, Any, List, Optional
+from urllib.parse import quote_plus
+
+logger = logging.getLogger(__name__)
+
+
+class WebSearchTool:
+    """
+    Web search tool for finding project recommendations.
+    Uses DuckDuckGo HTML search (no API required).
+    """
+    
+    def __init__(self):
+        self.client = httpx.AsyncClient(timeout=30.0)
+        self.headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        }
+    
+    async def search(
+        self,
+        query: str,
+        max_results: int = 5,
+        site_filter: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Search the web for relevant results.
+        
+        Args:
+            query: Search query
+            max_results: Maximum results to return
+            site_filter: Optional site to filter (e.g., "github.com")
+            
+        Returns:
+            List of search results with title, url, snippet
+        """
+        try:
+            # Build search query
+            search_query = query
+            if site_filter:
+                search_query = f"site:{site_filter} {query}"
+            
+            # Use DuckDuckGo HTML search
+            url = f"https://html.duckduckgo.com/html/?q={quote_plus(search_query)}"
+            
+            response = await self.client.get(url, headers=self.headers)
+            
+            if response.status_code == 200:
+                results = self._parse_ddg_results(response.text, max_results)
+                return results
+            else:
+                logger.warning(f"Search failed: {response.status_code}")
+                return []
+                
+        except Exception as e:
+            logger.error(f"Web search error: {e}")
+            return []
+    
+    def _parse_ddg_results(self, html: str, max_results: int) -> List[Dict[str, Any]]:
+        """Parse DuckDuckGo HTML results."""
+        results = []
+        
+        # Simple regex parsing for result links
+        # Pattern matches result entries in DuckDuckGo HTML
+        link_pattern = r'<a rel="nofollow" class="result__a" href="([^"]+)"[^>]*>([^<]+)</a>'
+        snippet_pattern = r'<a class="result__snippet"[^>]*>([^<]+(?:<[^>]+>[^<]*</[^>]+>)*[^<]*)</a>'
+        
+        links = re.findall(link_pattern, html)
+        snippets = re.findall(snippet_pattern, html)
+        
+        for i, (url, title) in enumerate(links[:max_results]):
+            # Clean up URL (DuckDuckGo wraps URLs)
+            if "uddg=" in url:
+                # Extract actual URL from redirect
+                match = re.search(r'uddg=([^&]+)', url)
+                if match:
+                    from urllib.parse import unquote
+                    url = unquote(match.group(1))
+            
+            result = {
+                "title": self._clean_html(title),
+                "url": url,
+                "snippet": self._clean_html(snippets[i]) if i < len(snippets) else ""
+            }
+            results.append(result)
+        
+        return results
+    
+    def _clean_html(self, text: str) -> str:
+        """Remove HTML tags and clean text."""
+        # Remove HTML tags
+        text = re.sub(r'<[^>]+>', '', text)
+        # Decode HTML entities
+        text = text.replace('&amp;', '&').replace('&lt;', '<').replace('&gt;', '>')
+        text = text.replace('&quot;', '"').replace('&#39;', "'")
+        # Clean whitespace
+        text = ' '.join(text.split())
+        return text.strip()
+    
+    async def search_github_projects(
+        self,
+        query: str,
+        max_results: int = 5
+    ) -> List[Dict[str, Any]]:
+        """Search specifically for GitHub projects."""
+        return await self.search(query, max_results, site_filter="github.com")
+    
+    async def search_documentation(
+        self,
+        tool: str,
+        topic: str,
+        max_results: int = 3
+    ) -> List[Dict[str, Any]]:
+        """Search for tool documentation."""
+        query = f"{tool} documentation {topic}"
+        return await self.search(query, max_results)
+    
+    async def find_alternatives(
+        self,
+        tool: str,
+        purpose: str,
+        max_results: int = 5
+    ) -> List[Dict[str, Any]]:
+        """Find alternative tools for a specific purpose."""
+        query = f"best {purpose} tools alternatives to {tool} open source"
+        return await self.search(query, max_results)
+    
+    async def search_with_summary(
+        self,
+        query: str,
+        max_results: int = 5
+    ) -> Dict[str, Any]:
+        """
+        Search and generate a summary of findings.
+        
+        Returns:
+            Dict with results and AI-generated summary
+        """
+        results = await self.search(query, max_results)
+        
+        if not results:
+            return {
+                "results": [],
+                "summary": "No results found for your query."
+            }
+        
+        # Generate simple summary
+        summary_parts = [f"Found {len(results)} relevant results:"]
+        for i, r in enumerate(results, 1):
+            summary_parts.append(f"{i}. **{r['title']}**")
+            if r['snippet']:
+                summary_parts.append(f"   {r['snippet'][:100]}...")
+        
+        return {
+            "results": results,
+            "summary": "\n".join(summary_parts)
+        }
+
+
+# Singleton instance
+web_search = WebSearchTool()

tools/workflow_templates.py

@@ -0,0 +1,585 @@
+# Additional n8n Workflow Templates
+"""
+Extended workflow templates for common automation patterns.
+Milestone 1: More comprehensive template library.
+"""
+
+from datetime import datetime
+from typing import Dict, Any
+
+
+def get_workflow_templates() -> Dict[str, callable]:
+    """Return all available workflow templates."""
+    return {
+        "database_sync": database_sync_workflow,
+        "file_processor": file_processor_workflow,
+        "social_media": social_media_workflow,
+        "crm_integration": crm_integration_workflow,
+        "monitoring": monitoring_workflow,
+        "data_pipeline": data_pipeline_workflow,
+        "chatbot": chatbot_workflow,
+        "report_generator": report_generator_workflow,
+    }
+
+
+def database_sync_workflow(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate database synchronization workflow."""
+    return {
+        "name": f"Database Sync - {datetime.now().strftime('%Y%m%d_%H%M%S')}",
+        "nodes": [
+            {
+                "parameters": {
+                    "rule": {"interval": [{"field": "hours", "hoursInterval": 1}]}
+                },
+                "id": "schedule_1",
+                "name": "Schedule",
+                "type": "n8n-nodes-base.scheduleTrigger",
+                "typeVersion": 1,
+                "position": [250, 300]
+            },
+            {
+                "parameters": {
+                    "operation": "executeQuery",
+                    "query": "SELECT * FROM source_table WHERE updated_at > NOW() - INTERVAL '1 hour'"
+                },
+                "id": "postgres_source",
+                "name": "Source DB",
+                "type": "n8n-nodes-base.postgres",
+                "typeVersion": 2,
+                "position": [450, 300],
+                "credentials": {"postgres": {"id": "SOURCE_DB_ID", "name": "Source Database"}}
+            },
+            {
+                "parameters": {
+                    "operation": "insert",
+                    "table": "destination_table",
+                    "columns": "={{ Object.keys($json).join(',') }}"
+                },
+                "id": "postgres_dest",
+                "name": "Destination DB",
+                "type": "n8n-nodes-base.postgres",
+                "typeVersion": 2,
+                "position": [650, 300],
+                "credentials": {"postgres": {"id": "DEST_DB_ID", "name": "Destination Database"}}
+            }
+        ],
+        "connections": {
+            "Schedule": {"main": [[{"node": "Source DB", "type": "main", "index": 0}]]},
+            "Source DB": {"main": [[{"node": "Destination DB", "type": "main", "index": 0}]]}
+        },
+        "settings": {"executionOrder": "v1"},
+        "meta": {"type": "database_sync", "generated_by": "AI Workflow Agent"}
+    }
+
+
+def file_processor_workflow(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate file processing workflow."""
+    return {
+        "name": f"File Processor - {datetime.now().strftime('%Y%m%d_%H%M%S')}",
+        "nodes": [
+            {
+                "parameters": {"path": "/data/input", "events": ["change"]},
+                "id": "file_trigger",
+                "name": "File Trigger",
+                "type": "n8n-nodes-base.localFileTrigger",
+                "typeVersion": 1,
+                "position": [250, 300]
+            },
+            {
+                "parameters": {"filePath": "={{ $json.path }}"},
+                "id": "read_file",
+                "name": "Read File",
+                "type": "n8n-nodes-base.readBinaryFiles",
+                "typeVersion": 1,
+                "position": [450, 300]
+            },
+            {
+                "parameters": {
+                    "functionCode": """// Process file content
+const items = $input.all();
+const processed = items.map(item => {
+  // Add processing logic here
+  return {
+    json: {
+      ...item.json,
+      processed: true,
+      processedAt: new Date().toISOString()
+    }
+  };
+});
+return processed;"""
+                },
+                "id": "process",
+                "name": "Process",
+                "type": "n8n-nodes-base.code",
+                "typeVersion": 1,
+                "position": [650, 300]
+            },
+            {
+                "parameters": {
+                    "fileName": "={{ 'processed_' + $json.filename }}",
+                    "filePath": "/data/output/"
+                },
+                "id": "write_file",
+                "name": "Save Output",
+                "type": "n8n-nodes-base.writeBinaryFile",
+                "typeVersion": 1,
+                "position": [850, 300]
+            }
+        ],
+        "connections": {
+            "File Trigger": {"main": [[{"node": "Read File", "type": "main", "index": 0}]]},
+            "Read File": {"main": [[{"node": "Process", "type": "main", "index": 0}]]},
+            "Process": {"main": [[{"node": "Save Output", "type": "main", "index": 0}]]}
+        },
+        "settings": {"executionOrder": "v1"},
+        "meta": {"type": "file_processor", "generated_by": "AI Workflow Agent"}
+    }
+
+
+def social_media_workflow(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate social media automation workflow."""
+    return {
+        "name": f"Social Media - {datetime.now().strftime('%Y%m%d_%H%M%S')}",
+        "nodes": [
+            {
+                "parameters": {
+                    "httpMethod": "POST",
+                    "path": "post-social",
+                    "responseMode": "onReceived"
+                },
+                "id": "webhook",
+                "name": "Trigger",
+                "type": "n8n-nodes-base.webhook",
+                "typeVersion": 1,
+                "position": [250, 300]
+            },
+            {
+                "parameters": {
+                    "functionCode": """// Prepare content for different platforms
+const content = $input.first().json;
+return [
+  {
+    json: {
+      platform: 'twitter',
+      text: content.message.substring(0, 280),
+      media: content.image_url
+    }
+  },
+  {
+    json: {
+      platform: 'linkedin',
+      text: content.message,
+      media: content.image_url
+    }
+  }
+];"""
+                },
+                "id": "prepare",
+                "name": "Prepare Content",
+                "type": "n8n-nodes-base.code",
+                "typeVersion": 1,
+                "position": [450, 300]
+            },
+            {
+                "parameters": {
+                    "text": "={{ $json.text }}",
+                    "additionalFields": {}
+                },
+                "id": "twitter",
+                "name": "Post to Twitter",
+                "type": "n8n-nodes-base.twitter",
+                "typeVersion": 2,
+                "position": [650, 200],
+                "credentials": {"twitterOAuth2Api": {"id": "TWITTER_ID", "name": "Twitter"}}
+            },
+            {
+                "parameters": {
+                    "text": "={{ $json.text }}",
+                    "shareMediaCategory": "NONE"
+                },
+                "id": "linkedin",
+                "name": "Post to LinkedIn",
+                "type": "n8n-nodes-base.linkedIn",
+                "typeVersion": 1,
+                "position": [650, 400],
+                "credentials": {"linkedInOAuth2Api": {"id": "LINKEDIN_ID", "name": "LinkedIn"}}
+            }
+        ],
+        "connections": {
+            "Trigger": {"main": [[{"node": "Prepare Content", "type": "main", "index": 0}]]},
+            "Prepare Content": {"main": [
+                [{"node": "Post to Twitter", "type": "main", "index": 0}],
+                [{"node": "Post to LinkedIn", "type": "main", "index": 0}]
+            ]}
+        },
+        "settings": {"executionOrder": "v1"},
+        "meta": {"type": "social_media", "generated_by": "AI Workflow Agent"}
+    }
+
+
+def crm_integration_workflow(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate CRM integration workflow."""
+    return {
+        "name": f"CRM Integration - {datetime.now().strftime('%Y%m%d_%H%M%S')}",
+        "nodes": [
+            {
+                "parameters": {
+                    "httpMethod": "POST",
+                    "path": "new-lead",
+                    "responseMode": "responseNode"
+                },
+                "id": "webhook",
+                "name": "New Lead",
+                "type": "n8n-nodes-base.webhook",
+                "typeVersion": 1,
+                "position": [250, 300]
+            },
+            {
+                "parameters": {
+                    "resource": "contact",
+                    "operation": "create",
+                    "email": "={{ $json.email }}",
+                    "additionalFields": {
+                        "firstName": "={{ $json.first_name }}",
+                        "lastName": "={{ $json.last_name }}",
+                        "phone": "={{ $json.phone }}"
+                    }
+                },
+                "id": "hubspot",
+                "name": "Create in HubSpot",
+                "type": "n8n-nodes-base.hubspot",
+                "typeVersion": 2,
+                "position": [450, 300],
+                "credentials": {"hubspotApi": {"id": "HUBSPOT_ID", "name": "HubSpot"}}
+            },
+            {
+                "parameters": {
+                    "fromEmail": "sales@company.com",
+                    "toEmail": "={{ $json.email }}",
+                    "subject": "Welcome to our platform!",
+                    "emailType": "html",
+                    "message": "<h1>Welcome!</h1><p>Thank you for your interest.</p>"
+                },
+                "id": "email",
+                "name": "Send Welcome Email",
+                "type": "n8n-nodes-base.emailSend",
+                "typeVersion": 2,
+                "position": [650, 300],
+                "credentials": {"smtp": {"id": "SMTP_ID", "name": "SMTP"}}
+            },
+            {
+                "parameters": {
+                    "respondWith": "json",
+                    "responseBody": "={{ JSON.stringify({success: true, contact_id: $json.id}) }}"
+                },
+                "id": "respond",
+                "name": "Response",
+                "type": "n8n-nodes-base.respondToWebhook",
+                "typeVersion": 1,
+                "position": [850, 300]
+            }
+        ],
+        "connections": {
+            "New Lead": {"main": [[{"node": "Create in HubSpot", "type": "main", "index": 0}]]},
+            "Create in HubSpot": {"main": [[{"node": "Send Welcome Email", "type": "main", "index": 0}]]},
+            "Send Welcome Email": {"main": [[{"node": "Response", "type": "main", "index": 0}]]}
+        },
+        "settings": {"executionOrder": "v1"},
+        "meta": {"type": "crm_integration", "generated_by": "AI Workflow Agent"}
+    }
+
+
+def monitoring_workflow(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate monitoring and alerting workflow."""
+    return {
+        "name": f"Monitoring - {datetime.now().strftime('%Y%m%d_%H%M%S')}",
+        "nodes": [
+            {
+                "parameters": {
+                    "rule": {"interval": [{"field": "minutes", "minutesInterval": 5}]}
+                },
+                "id": "schedule",
+                "name": "Every 5 Minutes",
+                "type": "n8n-nodes-base.scheduleTrigger",
+                "typeVersion": 1,
+                "position": [250, 300]
+            },
+            {
+                "parameters": {
+                    "url": "={{ $json.endpoint || 'https://api.example.com/health' }}",
+                    "method": "GET",
+                    "options": {"timeout": 10000}
+                },
+                "id": "check",
+                "name": "Health Check",
+                "type": "n8n-nodes-base.httpRequest",
+                "typeVersion": 4,
+                "position": [450, 300]
+            },
+            {
+                "parameters": {
+                    "conditions": {
+                        "boolean": [
+                            {"value1": "={{ $json.status }}", "value2": 200, "operation": "notEqual"}
+                        ]
+                    }
+                },
+                "id": "if_error",
+                "name": "If Error",
+                "type": "n8n-nodes-base.if",
+                "typeVersion": 1,
+                "position": [650, 300]
+            },
+            {
+                "parameters": {
+                    "channel": "#alerts",
+                    "text": "🚨 *Alert*: Service health check failed!\nStatus: {{ $json.status }}\nTime: {{ new Date().toISOString() }}"
+                },
+                "id": "slack",
+                "name": "Alert Slack",
+                "type": "n8n-nodes-base.slack",
+                "typeVersion": 2,
+                "position": [850, 200],
+                "credentials": {"slackApi": {"id": "SLACK_ID", "name": "Slack"}}
+            },
+            {
+                "parameters": {},
+                "id": "noop",
+                "name": "All Good",
+                "type": "n8n-nodes-base.noOp",
+                "typeVersion": 1,
+                "position": [850, 400]
+            }
+        ],
+        "connections": {
+            "Every 5 Minutes": {"main": [[{"node": "Health Check", "type": "main", "index": 0}]]},
+            "Health Check": {"main": [[{"node": "If Error", "type": "main", "index": 0}]]},
+            "If Error": {
+                "main": [
+                    [{"node": "Alert Slack", "type": "main", "index": 0}],
+                    [{"node": "All Good", "type": "main", "index": 0}]
+                ]
+            }
+        },
+        "settings": {"executionOrder": "v1"},
+        "meta": {"type": "monitoring", "generated_by": "AI Workflow Agent"}
+    }
+
+
+def data_pipeline_workflow(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate data processing pipeline workflow."""
+    return {
+        "name": f"Data Pipeline - {datetime.now().strftime('%Y%m%d_%H%M%S')}",
+        "nodes": [
+            {
+                "parameters": {
+                    "httpMethod": "POST",
+                    "path": "ingest-data",
+                    "responseMode": "onReceived"
+                },
+                "id": "webhook",
+                "name": "Data Input",
+                "type": "n8n-nodes-base.webhook",
+                "typeVersion": 1,
+                "position": [250, 300]
+            },
+            {
+                "parameters": {
+                    "functionCode": """// Validate incoming data
+const data = $input.all();
+const validated = data.filter(item => {
+  const json = item.json;
+  return json.id && json.timestamp && json.value !== undefined;
+});
+if (validated.length === 0) {
+  throw new Error('No valid data received');
+}
+return validated;"""
+                },
+                "id": "validate",
+                "name": "Validate",
+                "type": "n8n-nodes-base.code",
+                "typeVersion": 1,
+                "position": [450, 300]
+            },
+            {
+                "parameters": {
+                    "functionCode": """// Transform data
+const items = $input.all();
+return items.map(item => ({
+  json: {
+    ...item.json,
+    processed_value: item.json.value * 1.1,
+    source: 'pipeline',
+    ingested_at: new Date().toISOString()
+  }
+}));"""
+                },
+                "id": "transform",
+                "name": "Transform",
+                "type": "n8n-nodes-base.code",
+                "typeVersion": 1,
+                "position": [650, 300]
+            },
+            {
+                "parameters": {
+                    "operation": "insert",
+                    "table": "processed_data"
+                },
+                "id": "store",
+                "name": "Store",
+                "type": "n8n-nodes-base.postgres",
+                "typeVersion": 2,
+                "position": [850, 300],
+                "credentials": {"postgres": {"id": "DB_ID", "name": "Database"}}
+            }
+        ],
+        "connections": {
+            "Data Input": {"main": [[{"node": "Validate", "type": "main", "index": 0}]]},
+            "Validate": {"main": [[{"node": "Transform", "type": "main", "index": 0}]]},
+            "Transform": {"main": [[{"node": "Store", "type": "main", "index": 0}]]}
+        },
+        "settings": {"executionOrder": "v1"},
+        "meta": {"type": "data_pipeline", "generated_by": "AI Workflow Agent"}
+    }
+
+
+def chatbot_workflow(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate AI chatbot workflow."""
+    return {
+        "name": f"AI Chatbot - {datetime.now().strftime('%Y%m%d_%H%M%S')}",
+        "nodes": [
+            {
+                "parameters": {
+                    "httpMethod": "POST",
+                    "path": "chat",
+                    "responseMode": "responseNode"
+                },
+                "id": "webhook",
+                "name": "Chat Input",
+                "type": "n8n-nodes-base.webhook",
+                "typeVersion": 1,
+                "position": [250, 300]
+            },
+            {
+                "parameters": {
+                    "url": "http://ollama:11434/api/generate",
+                    "method": "POST",
+                    "sendBody": True,
+                    "bodyParameters": {
+                        "parameters": [
+                            {"name": "model", "value": "qwen2.5:7b"},
+                            {"name": "prompt", "value": "={{ $json.message }}"},
+                            {"name": "stream", "value": "false"}
+                        ]
+                    }
+                },
+                "id": "ollama",
+                "name": "Ask LLM",
+                "type": "n8n-nodes-base.httpRequest",
+                "typeVersion": 4,
+                "position": [450, 300]
+            },
+            {
+                "parameters": {
+                    "respondWith": "json",
+                    "responseBody": "={{ JSON.stringify({response: $json.response, model: 'qwen2.5'}) }}"
+                },
+                "id": "respond",
+                "name": "Response",
+                "type": "n8n-nodes-base.respondToWebhook",
+                "typeVersion": 1,
+                "position": [650, 300]
+            }
+        ],
+        "connections": {
+            "Chat Input": {"main": [[{"node": "Ask LLM", "type": "main", "index": 0}]]},
+            "Ask LLM": {"main": [[{"node": "Response", "type": "main", "index": 0}]]}
+        },
+        "settings": {"executionOrder": "v1"},
+        "meta": {"type": "chatbot", "generated_by": "AI Workflow Agent"}
+    }
+
+
+def report_generator_workflow(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate automated report workflow."""
+    return {
+        "name": f"Report Generator - {datetime.now().strftime('%Y%m%d_%H%M%S')}",
+        "nodes": [
+            {
+                "parameters": {
+                    "rule": {"interval": [{"field": "days", "daysInterval": 1}]},
+                    "triggerAtTime": "09:00"
+                },
+                "id": "schedule",
+                "name": "Daily at 9 AM",
+                "type": "n8n-nodes-base.scheduleTrigger",
+                "typeVersion": 1,
+                "position": [250, 300]
+            },
+            {
+                "parameters": {
+                    "operation": "executeQuery",
+                    "query": """SELECT 
+                        DATE(created_at) as date,
+                        COUNT(*) as total,
+                        SUM(amount) as revenue
+                    FROM orders 
+                    WHERE created_at >= NOW() - INTERVAL '7 days'
+                    GROUP BY DATE(created_at)
+                    ORDER BY date"""
+                },
+                "id": "query",
+                "name": "Get Data",
+                "type": "n8n-nodes-base.postgres",
+                "typeVersion": 2,
+                "position": [450, 300],
+                "credentials": {"postgres": {"id": "DB_ID", "name": "Database"}}
+            },
+            {
+                "parameters": {
+                    "functionCode": """// Generate HTML report
+const data = $input.all();
+let html = '<h1>Weekly Report</h1><table border="1">';
+html += '<tr><th>Date</th><th>Orders</th><th>Revenue</th></tr>';
+data.forEach(row => {
+  html += '<tr>';
+  html += '<td>' + row.json.date + '</td>';
+  html += '<td>' + row.json.total + '</td>';
+  html += '<td>$' + row.json.revenue.toFixed(2) + '</td>';
+  html += '</tr>';
+});
+html += '</table>';
+return [{json: {html, generated: new Date().toISOString()}}];"""
+                },
+                "id": "generate",
+                "name": "Generate Report",
+                "type": "n8n-nodes-base.code",
+                "typeVersion": 1,
+                "position": [650, 300]
+            },
+            {
+                "parameters": {
+                    "fromEmail": "reports@company.com",
+                    "toEmail": "team@company.com",
+                    "subject": "Weekly Report - {{ new Date().toLocaleDateString() }}",
+                    "emailType": "html",
+                    "message": "={{ $json.html }}"
+                },
+                "id": "email",
+                "name": "Send Report",
+                "type": "n8n-nodes-base.emailSend",
+                "typeVersion": 2,
+                "position": [850, 300],
+                "credentials": {"smtp": {"id": "SMTP_ID", "name": "SMTP"}}
+            }
+        ],
+        "connections": {
+            "Daily at 9 AM": {"main": [[{"node": "Get Data", "type": "main", "index": 0}]]},
+            "Get Data": {"main": [[{"node": "Generate Report", "type": "main", "index": 0}]]},
+            "Generate Report": {"main": [[{"node": "Send Report", "type": "main", "index": 0}]]}
+        },
+        "settings": {"executionOrder": "v1"},
+        "meta": {"type": "report_generator", "generated_by": "AI Workflow Agent"}
+    }