leedstack 3.1.0

package/tools/templates/modules/chatbot/backend/python-fastapi/backend/app/services/chatbot_service.py

@@ -0,0 +1,123 @@
+import os
+import re
+import aiohttp
+from typing import List, Dict
+
+class ChatbotService:
+    def __init__(self):
+        self.openai_api_key = os.getenv("OPENAI_API_KEY")
+        self.anthropic_api_key = os.getenv("ANTHROPIC_API_KEY")
+
+    async def generate_response(self, message: str, history: List[Dict]) -> str:
+        """
+        Generate a chatbot response. Tries AI providers first,
+        falls back to basic responses if no API keys configured.
+        """
+        # Try LLM providers in order of preference
+        if self.anthropic_api_key:
+            return await self._generate_anthropic_response(message, history)
+
+        if self.openai_api_key:
+            return await self._generate_openai_response(message, history)
+
+        # Fallback to basic rule-based responses
+        return self._generate_basic_response(message)
+
+    async def _generate_openai_response(self, message: str, history: List[Dict]) -> str:
+        """Generate response using OpenAI API"""
+        try:
+            async with aiohttp.ClientSession() as session:
+                messages = [
+                    {"role": "system", "content": "You are a helpful assistant for this web application. Be concise and friendly."}
+                ]
+                messages.extend([{"role": msg.get("role"), "content": msg.get("content")} for msg in history])
+                messages.append({"role": "user", "content": message})
+
+                async with session.post(
+                    "https://api.openai.com/v1/chat/completions",
+                    headers={
+                        "Content-Type": "application/json",
+                        "Authorization": f"Bearer {self.openai_api_key}"
+                    },
+                    json={
+                        "model": "gpt-4o-mini",
+                        "messages": messages,
+                        "max_tokens": 500,
+                        "temperature": 0.7
+                    }
+                ) as response:
+                    if response.status != 200:
+                        raise Exception(f"OpenAI API error: {response.status}")
+
+                    data = await response.json()
+                    return data["choices"][0]["message"]["content"]
+        except Exception as e:
+            print(f"OpenAI error: {e}")
+            return self._generate_basic_response(message)
+
+    async def _generate_anthropic_response(self, message: str, history: List[Dict]) -> str:
+        """Generate response using Anthropic API"""
+        try:
+            async with aiohttp.ClientSession() as session:
+                messages = []
+                messages.extend([{"role": msg.get("role"), "content": msg.get("content")} for msg in history])
+                messages.append({"role": "user", "content": message})
+
+                async with session.post(
+                    "https://api.anthropic.com/v1/messages",
+                    headers={
+                        "Content-Type": "application/json",
+                        "x-api-key": self.anthropic_api_key,
+                        "anthropic-version": "2023-06-01"
+                    },
+                    json={
+                        "model": "claude-3-5-haiku-20241022",
+                        "max_tokens": 500,
+                        "system": "You are a helpful assistant for this web application. Be concise and friendly.",
+                        "messages": messages
+                    }
+                ) as response:
+                    if response.status != 200:
+                        raise Exception(f"Anthropic API error: {response.status}")
+
+                    data = await response.json()
+                    return data["content"][0]["text"]
+        except Exception as e:
+            print(f"Anthropic error: {e}")
+            return self._generate_basic_response(message)
+
+    def _generate_basic_response(self, message: str) -> str:
+        """Generate basic rule-based response (no API key required)"""
+        lower_message = message.lower()
+
+        # Greeting patterns
+        if re.search(r'(hello|hi|hey|greetings)', lower_message, re.IGNORECASE):
+            return "Hello! I'm here to help. You can ask me questions about this application or configure me with an AI API key for more advanced responses."
+
+        # Help patterns
+        if re.search(r'(help|what can you do|how do you work)', lower_message, re.IGNORECASE):
+            return "I can answer questions and assist you with this application. Currently, I'm running in basic mode. To unlock AI-powered responses, add OPENAI_API_KEY or ANTHROPIC_API_KEY to your backend .env file."
+
+        # Feature questions
+        if re.search(r'(feature|what|how)', lower_message, re.IGNORECASE):
+            return "This is a full-stack web application with authentication, database integration, and more. Feel free to explore the codebase or ask me specific questions!"
+
+        # API/Configuration questions
+        if re.search(r'(api|configure|setup|install)', lower_message, re.IGNORECASE):
+            return """To configure AI responses:
+
+1. Get an API key from OpenAI or Anthropic
+2. Add it to backend/.env:
+   OPENAI_API_KEY=sk-...
+   or
+   ANTHROPIC_API_KEY=sk-ant-...
+3. Restart the backend
+
+Then I'll be powered by AI!"""
+
+        # Thanks/Goodbye
+        if re.search(r'(thank|thanks|bye|goodbye)', lower_message, re.IGNORECASE):
+            return "You're welcome! Let me know if you need anything else."
+
+        # Default fallback
+        return "I received your message! I'm currently in basic mode with limited responses. For more intelligent conversations, configure an AI API key (OpenAI or Anthropic) in your backend environment variables."

package/tools/templates/modules/chatbot/backend/python-fastapi/backend/requirements.txt

@@ -0,0 +1 @@
+aiohttp==3.9.1

package/tools/templates/modules/chatbot/frontend/react/frontend/src/App.jsx.ejs

@@ -0,0 +1,74 @@
+import { useState, useEffect } from 'react'
+import reactLogo from './assets/react.svg'
+import viteLogo from '/vite.svg'
+import './App.css'
+import { apiFetch } from './lib/api'
+import Chatbot from './components/Chatbot'
+
+function App() {
+  const [count, setCount] = useState(0)
+  const [apiStatus, setApiStatus] = useState('checking')
+  const [apiMessage, setApiMessage] = useState('')
+
+  useEffect(() => {
+    // Test API connection on page load
+    apiFetch('/api/example')
+      .then(data => {
+        setApiStatus('connected')
+        setApiMessage(data.message)
+      })
+      .catch(err => {
+        setApiStatus('error')
+        setApiMessage(err.message)
+      })
+  }, [])
+
+  return (
+    <>
+      <div>
+        <a href="https://vite.dev" target="_blank">
+          <img src={viteLogo} className="logo" alt="Vite logo" />
+        </a>
+        <a href="https://react.dev" target="_blank">
+          <img src={reactLogo} className="logo react" alt="React logo" />
+        </a>
+      </div>
+      <h1>Vite + React</h1>
+      <div className="card">
+        <button onClick={() => setCount((count) => count + 1)}>
+          count is {count}
+        </button>
+        <p>
+          Edit <code>src/App.jsx</code> and save to test HMR
+        </p>
+      </div>
+      <div className="api-status">
+        <h3>Backend API Status</h3>
+        {apiStatus === 'checking' && <p>⏳ Checking connection...</p>}
+        {apiStatus === 'connected' && (
+          <>
+            <p style={{ color: 'green' }}>✅ Connected to backend!</p>
+            <p style={{ fontSize: '0.9em', color: '#888' }}>{apiMessage}</p>
+          </>
+        )}
+        {apiStatus === 'error' && (
+          <>
+            <p style={{ color: 'red' }}>❌ Backend not connected</p>
+            <p style={{ fontSize: '0.9em', color: '#888' }}>{apiMessage}</p>
+            <p style={{ fontSize: '0.85em', marginTop: '8px' }}>
+              Make sure the backend server is running on port 8080
+            </p>
+          </>
+        )}
+      </div>
+      <p className="read-the-docs">
+        Click on the Vite and React logos to learn more
+      </p>
+
+      {/* Chatbot component */}
+      <Chatbot />
+    </>
+  )
+}
+
+export default App

package/tools/templates/modules/chatbot/frontend/react/frontend/src/components/Chatbot.css

@@ -0,0 +1,198 @@
+.chatbot-toggle {
+  position: fixed;
+  bottom: 24px;
+  right: 24px;
+  width: 60px;
+  height: 60px;
+  border-radius: 50%;
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+  color: white;
+  border: none;
+  font-size: 24px;
+  cursor: pointer;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+  transition: transform 0.2s, box-shadow 0.2s;
+  z-index: 1000;
+}
+
+.chatbot-toggle:hover {
+  transform: scale(1.05);
+  box-shadow: 0 6px 16px rgba(0, 0, 0, 0.2);
+}
+
+.chatbot-window {
+  position: fixed;
+  bottom: 100px;
+  right: 24px;
+  width: 380px;
+  height: 550px;
+  background: white;
+  border-radius: 12px;
+  box-shadow: 0 8px 32px rgba(0, 0, 0, 0.15);
+  display: flex;
+  flex-direction: column;
+  z-index: 1000;
+  overflow: hidden;
+}
+
+.chatbot-header {
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+  color: white;
+  padding: 16px 20px;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.chatbot-header h3 {
+  margin: 0;
+  font-size: 18px;
+  font-weight: 600;
+}
+
+.chatbot-header button {
+  background: transparent;
+  border: none;
+  color: white;
+  font-size: 24px;
+  cursor: pointer;
+  padding: 0;
+  width: 30px;
+  height: 30px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  opacity: 0.8;
+  transition: opacity 0.2s;
+}
+
+.chatbot-header button:hover {
+  opacity: 1;
+}
+
+.chatbot-messages {
+  flex: 1;
+  overflow-y: auto;
+  padding: 16px;
+  background: #f7f9fc;
+}
+
+.message {
+  margin-bottom: 12px;
+  display: flex;
+  animation: fadeIn 0.3s;
+}
+
+@keyframes fadeIn {
+  from { opacity: 0; transform: translateY(10px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+
+.message-user {
+  justify-content: flex-end;
+}
+
+.message-assistant {
+  justify-content: flex-start;
+}
+
+.message-content {
+  max-width: 75%;
+  padding: 10px 14px;
+  border-radius: 12px;
+  word-wrap: break-word;
+  line-height: 1.4;
+}
+
+.message-user .message-content {
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+  color: white;
+  border-bottom-right-radius: 4px;
+}
+
+.message-assistant .message-content {
+  background: white;
+  color: #333;
+  border-bottom-left-radius: 4px;
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
+}
+
+.typing-indicator {
+  display: flex;
+  gap: 4px;
+  padding: 12px 16px;
+}
+
+.typing-indicator span {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  background: #999;
+  animation: typing 1.4s infinite;
+}
+
+.typing-indicator span:nth-child(2) {
+  animation-delay: 0.2s;
+}
+
+.typing-indicator span:nth-child(3) {
+  animation-delay: 0.4s;
+}
+
+@keyframes typing {
+  0%, 60%, 100% { transform: translateY(0); }
+  30% { transform: translateY(-10px); }
+}
+
+.chatbot-input {
+  display: flex;
+  gap: 8px;
+  padding: 16px;
+  background: white;
+  border-top: 1px solid #e5e7eb;
+}
+
+.chatbot-input input {
+  flex: 1;
+  padding: 10px 14px;
+  border: 1px solid #d1d5db;
+  border-radius: 8px;
+  font-size: 14px;
+  outline: none;
+  transition: border-color 0.2s;
+}
+
+.chatbot-input input:focus {
+  border-color: #667eea;
+}
+
+.chatbot-input button {
+  padding: 10px 20px;
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+  color: white;
+  border: none;
+  border-radius: 8px;
+  font-size: 14px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: opacity 0.2s;
+}
+
+.chatbot-input button:hover:not(:disabled) {
+  opacity: 0.9;
+}
+
+.chatbot-input button:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+/* Mobile responsive */
+@media (max-width: 480px) {
+  .chatbot-window {
+    width: calc(100vw - 24px);
+    height: calc(100vh - 120px);
+    right: 12px;
+    bottom: 90px;
+  }
+}

package/tools/templates/modules/chatbot/frontend/react/frontend/src/components/Chatbot.jsx

@@ -0,0 +1,113 @@
+import { useState, useRef, useEffect } from 'react';
+import { apiFetch } from '../lib/api';
+import './Chatbot.css';
+
+export default function Chatbot() {
+  const [isOpen, setIsOpen] = useState(false);
+  const [messages, setMessages] = useState([
+    { role: 'assistant', content: 'Hi! How can I help you today?' }
+  ]);
+  const [input, setInput] = useState('');
+  const [isLoading, setIsLoading] = useState(false);
+  const messagesEndRef = useRef(null);
+  const isMountedRef = useRef(true);
+
+  useEffect(() => {
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+
+  const scrollToBottom = () => {
+    messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
+  };
+
+  useEffect(() => {
+    scrollToBottom();
+  }, [messages]);
+
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    if (!input.trim() || isLoading) return;
+
+    const userMessage = input.trim();
+    setInput('');
+    setMessages(prev => [...prev, { role: 'user', content: userMessage }]);
+    setIsLoading(true);
+
+    try {
+      const response = await apiFetch('/api/chatbot', {
+        method: 'POST',
+        body: JSON.stringify({ message: userMessage, history: messages })
+      });
+
+      if (isMountedRef.current) {
+        setMessages(prev => [...prev, { role: 'assistant', content: response.message }]);
+      }
+    } catch (error) {
+      console.error('Chatbot error:', error);
+      if (isMountedRef.current) {
+        setMessages(prev => [...prev, {
+          role: 'assistant',
+          content: 'Sorry, I encountered an error. Please try again.'
+        }]);
+      }
+    } finally {
+      if (isMountedRef.current) {
+        setIsLoading(false);
+      }
+    }
+  };
+
+  return (
+    <>
+      {/* Chat Button */}
+      <button
+        className="chatbot-toggle"
+        onClick={() => setIsOpen(!isOpen)}
+        aria-label="Toggle chatbot"
+      >
+        {isOpen ? '✕' : '💬'}
+      </button>
+
+      {/* Chat Window */}
+      {isOpen && (
+        <div className="chatbot-window">
+          <div className="chatbot-header">
+            <h3>Chat Assistant</h3>
+            <button onClick={() => setIsOpen(false)} aria-label="Close chat">✕</button>
+          </div>
+
+          <div className="chatbot-messages">
+            {messages.map((msg, idx) => (
+              <div key={idx} className={`message message-${msg.role}`}>
+                <div className="message-content">{msg.content}</div>
+              </div>
+            ))}
+            {isLoading && (
+              <div className="message message-assistant">
+                <div className="message-content typing-indicator">
+                  <span></span><span></span><span></span>
+                </div>
+              </div>
+            )}
+            <div ref={messagesEndRef} />
+          </div>
+
+          <form onSubmit={handleSubmit} className="chatbot-input">
+            <input
+              type="text"
+              value={input}
+              onChange={(e) => setInput(e.target.value)}
+              placeholder="Type your message..."
+              disabled={isLoading}
+            />
+            <button type="submit" disabled={isLoading || !input.trim()}>
+              Send
+            </button>
+          </form>
+        </div>
+      )}
+    </>
+  );
+}

package/tools/templates/modules/contact/backend/java-spring/backend/src/main/java/com/app/controller/ContactController.java

@@ -0,0 +1,29 @@
+package com.app.controller;
+
+import com.app.entity.ContactMessage;
+import com.app.repository.ContactMessageRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api")
+public class ContactController {
+
+    @Autowired
+    private ContactMessageRepository contactMessageRepository;
+
+    @PostMapping("/contact")
+    public ResponseEntity<?> submitContact(@RequestBody Map<String, String> body) {
+        ContactMessage contact = new ContactMessage();
+        contact.setName(body.get("name"));
+        contact.setEmail(body.get("email"));
+        contact.setMessage(body.get("message"));
+
+        contactMessageRepository.save(contact);
+
+        return ResponseEntity.ok(Map.of("success", true));
+    }
+}

package/tools/templates/modules/contact/backend/java-spring/backend/src/main/java/com/app/entity/ContactMessage.java

@@ -0,0 +1,66 @@
+package com.app.entity;
+
+import jakarta.persistence.*;
+import java.time.Instant;
+
+@Entity
+@Table(name = "contact_messages")
+public class ContactMessage {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(length = 120)
+    private String name;
+
+    @Column(length = 255)
+    private String email;
+
+    @Column(columnDefinition = "TEXT")
+    private String message;
+
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private Instant createdAt = Instant.now();
+
+    // Getters and setters
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public Instant getCreatedAt() {
+        return createdAt;
+    }
+
+    public void setCreatedAt(Instant createdAt) {
+        this.createdAt = createdAt;
+    }
+}

package/tools/templates/modules/contact/backend/java-spring/backend/src/main/java/com/app/repository/ContactMessageRepository.java

@@ -0,0 +1,8 @@
+package com.app.repository;
+
+import com.app.entity.ContactMessage;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface ContactMessageRepository extends JpaRepository<ContactMessage, Long> {
+    long count();
+}

package/tools/templates/modules/contact/backend/java-spring/backend/src/main/resources/db/migration/V2__contact.sql

@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS contact_messages (
+    id BIGSERIAL PRIMARY KEY,
+    name VARCHAR(120),
+    email VARCHAR(255),
+    message TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);