leedstack 3.1.0

package/tools/templates/modules/admin/frontend/svelte/frontend/src/routes/dashboard/+page.svelte

@@ -0,0 +1,93 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import { getToken, isAuthenticated } from '$lib/auth';
+  import { goto } from '$app/navigation';
+
+  let stats: any = null;
+  let loading = true;
+  let error = '';
+
+  onMount(async () => {
+    const auth = await new Promise<boolean>((resolve) => {
+      const unsubscribe = isAuthenticated.subscribe(value => {
+        resolve(value);
+        unsubscribe();
+      });
+    });
+
+    if (!auth) {
+      goto('/login');
+      return;
+    }
+
+    try {
+      const API_BASE = import.meta.env.PUBLIC_API_BASE || 'http://localhost:8080';
+      const token = await getToken();
+
+      const response = await fetch(`${API_BASE}/api/admin/stats`, {
+        headers: {
+          'Authorization': `Bearer ${token}`
+        }
+      });
+
+      if (response.ok) {
+        stats = await response.json();
+      } else {
+        error = 'Failed to load stats';
+      }
+    } catch (err) {
+      error = 'Error loading stats';
+    } finally {
+      loading = false;
+    }
+  });
+</script>
+
+<h1>Admin Dashboard</h1>
+
+{#if loading}
+  <p>Loading...</p>
+{:else if error}
+  <p style="color: red;">{error}</p>
+{:else if stats}
+  <div class="stats">
+    <div class="stat-card">
+      <h2>Users</h2>
+      <p class="stat-value">{stats.users}</p>
+    </div>
+
+<% if (modules.contact) { -%>
+    <div class="stat-card">
+      <h2>Contact Messages</h2>
+      <p class="stat-value">{stats.contacts}</p>
+    </div>
+<% } -%>
+  </div>
+{/if}
+
+<style>
+  .stats {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 1rem;
+    margin-top: 2rem;
+  }
+
+  .stat-card {
+    padding: 1.5rem;
+    background: #f5f5f5;
+    border-radius: 8px;
+  }
+
+  .stat-card h2 {
+    margin: 0 0 0.5rem 0;
+    font-size: 1rem;
+    color: #666;
+  }
+
+  .stat-value {
+    font-size: 2.5rem;
+    font-weight: bold;
+    margin: 0;
+  }
+</style>

package/tools/templates/modules/auth/backend/node-express/backend/src/middleware/auth.ts

@@ -0,0 +1,42 @@
+import { Request, Response, NextFunction } from 'express';
+import { createRemoteJWKSet, jwtVerify } from 'jose';
+
+const JWKS = createRemoteJWKSet(new URL(`https://${process.env.AUTH0_DOMAIN}/.well-known/jwks.json`));
+const ISSUER = `https://${process.env.AUTH0_DOMAIN}/`;
+const AUDIENCE = process.env.AUTH0_AUDIENCE;
+
+export async function authMiddleware(req: Request, res: Response, next: NextFunction) {
+  const authHeader = req.headers.authorization;
+
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    return res.status(401).json({ error: 'Unauthorized' });
+  }
+
+  const token = authHeader.substring(7);
+
+  try {
+    const { payload } = await jwtVerify(token, JWKS, {
+      issuer: ISSUER,
+      audience: AUDIENCE
+    });
+
+    (req as any).user = payload;
+    next();
+  } catch (err) {
+    console.error('JWT verification failed:', err);
+    return res.status(401).json({ error: 'Invalid token' });
+  }
+}
+
+export function requireScope(scope: string) {
+  return (req: Request, res: Response, next: NextFunction) => {
+    const user = (req as any).user;
+    const scopes = user?.scope?.split(' ') || [];
+
+    if (!scopes.includes(scope)) {
+      return res.status(403).json({ error: 'Forbidden' });
+    }
+
+    next();
+  };
+}

package/tools/templates/modules/auth/frontend/svelte/frontend/src/hooks.client.ts

@@ -0,0 +1,3 @@
+import { initAuth } from '$lib/auth';
+
+initAuth();

package/tools/templates/modules/auth/frontend/svelte/frontend/src/lib/auth.ts

@@ -0,0 +1,104 @@
+import { Auth0Client } from '@auth0/auth0-spa-js';
+import { writable } from 'svelte/store';
+
+const domain = import.meta.env.PUBLIC_AUTH0_DOMAIN || '';
+const clientId = import.meta.env.PUBLIC_AUTH0_CLIENT_ID || '';
+const audience = import.meta.env.PUBLIC_AUTH0_AUDIENCE || '';
+
+let auth0Client: Auth0Client;
+
+export const isAuthenticated = writable(false);
+export const user = writable(null);
+export const token = writable('');
+
+async function createClient() {
+  auth0Client = new Auth0Client({
+    domain,
+    clientId,
+    authorizationParams: {
+      audience,
+      redirect_uri: window.location.origin + '/callback'
+    },
+    cacheLocation: 'localstorage'
+  });
+
+  return auth0Client;
+}
+
+export async function initAuth() {
+  if (!auth0Client) {
+    await createClient();
+  }
+
+  try {
+    const isAuth = await auth0Client.isAuthenticated();
+    isAuthenticated.set(isAuth);
+
+    if (isAuth) {
+      const userInfo = await auth0Client.getUser();
+      user.set(userInfo);
+
+      const accessToken = await auth0Client.getTokenSilently();
+      token.set(accessToken);
+    }
+  } catch (err) {
+    console.error('Auth init error:', err);
+  }
+}
+
+export async function login() {
+  if (!auth0Client) {
+    await createClient();
+  }
+  await auth0Client.loginWithRedirect();
+}
+
+export async function handleCallback() {
+  if (!auth0Client) {
+    await createClient();
+  }
+
+  try {
+    await auth0Client.handleRedirectCallback();
+    const userInfo = await auth0Client.getUser();
+    const accessToken = await auth0Client.getTokenSilently();
+
+    isAuthenticated.set(true);
+    user.set(userInfo);
+    token.set(accessToken);
+
+    return true;
+  } catch (err) {
+    console.error('Callback error:', err);
+    return false;
+  }
+}
+
+export async function logout() {
+  if (!auth0Client) {
+    await createClient();
+  }
+
+  await auth0Client.logout({
+    logoutParams: {
+      returnTo: window.location.origin
+    }
+  });
+
+  isAuthenticated.set(false);
+  user.set(null);
+  token.set('');
+}
+
+export async function getToken() {
+  if (!auth0Client) {
+    await createClient();
+  }
+
+  try {
+    return await auth0Client.getTokenSilently();
+  } catch (err) {
+    console.error('Get token error:', err);
+    return '';
+  }
+}

package/tools/templates/modules/auth/frontend/svelte/frontend/src/routes/callback/+page.svelte

@@ -0,0 +1,18 @@
+<script>
+  import { onMount } from 'svelte';
+  import { goto } from '$app/navigation';
+  import { handleCallback } from '$lib/auth';
+
+  onMount(async () => {
+    const success = await handleCallback();
+    if (success) {
+      goto('/');
+    } else {
+      goto('/login');
+    }
+  });
+</script>
+
+<div>
+  <p>Processing login...</p>
+</div>

package/tools/templates/modules/auth/frontend/svelte/frontend/src/routes/login/+page.svelte

@@ -0,0 +1,12 @@
+<script>
+  import { onMount } from 'svelte';
+  import { login } from '$lib/auth';
+
+  onMount(() => {
+    login();
+  });
+</script>
+
+<div>
+  <p>Redirecting to login...</p>
+</div>

package/tools/templates/modules/chatbot/backend/node-express/backend/src/index.ts.ejs

@@ -0,0 +1,69 @@
+import express from 'express';
+import cors from 'cors';
+import dotenv from 'dotenv';
+<% if (modules.auth) { -%>
+import authRoutes from './routes/auth';
+<% } -%>
+<% if (modules.payments) { -%>
+import stripeRoutes from './routes/stripe';
+<% } -%>
+<% if (modules.contact) { -%>
+import contactRoutes from './routes/contact';
+<% } -%>
+<% if (modules.admin) { -%>
+import adminRoutes from './routes/admin';
+<% } -%>
+import chatbotRoutes from './routes/chatbot';
+
+dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 8080;
+
+// CORS configuration - allow only the configured frontend URL
+const allowedOrigins = [
+  process.env.FRONTEND_URL
+].filter(Boolean);
+
+app.use(cors({
+  origin: (origin, callback) => {
+    if (!origin) return callback(null, true);
+    if (allowedOrigins.indexOf(origin) !== -1) {
+      callback(null, true);
+    } else {
+      callback(new Error('Not allowed by CORS'));
+    }
+  },
+  credentials: true
+}));
+
+app.use(express.json());
+
+// Example route
+app.get('/api/example', (req, res) => {
+  res.json({
+    message: 'Hello from node-express backend!',
+    timestamp: new Date().toISOString()
+  });
+});
+
+// Module routes
+<% if (modules.auth) { -%>
+app.use('/api/auth', authRoutes);
+<% } -%>
+<% if (modules.payments) { -%>
+app.use('/stripe', stripeRoutes);
+<% } -%>
+<% if (modules.contact) { -%>
+app.use('/api/contact', contactRoutes);
+<% } -%>
+<% if (modules.admin) { -%>
+app.use('/api/admin', adminRoutes);
+<% } -%>
+app.use('/api/chatbot', chatbotRoutes);
+
+app.listen(PORT, () => {
+  console.log(`✅ Server running on http://localhost:${PORT}`);
+  console.log(`📡 API endpoint: http://localhost:${PORT}/api/example`);
+  console.log(`💬 Chatbot endpoint: http://localhost:${PORT}/api/chatbot`);
+});

package/tools/templates/modules/chatbot/backend/node-express/backend/src/routes/chatbot.ts.ejs

@@ -0,0 +1,37 @@
+import { Router, Request, Response } from 'express';
+import { ChatbotService } from '../services/chatbotService';
+
+const router = Router();
+const chatbotService = new ChatbotService();
+
+interface ChatMessage {
+  role: 'user' | 'assistant';
+  content: string;
+}
+
+interface ChatRequest {
+  message: string;
+  history?: ChatMessage[];
+}
+
+router.post('/', async (req: Request, res: Response) => {
+  try {
+    const { message, history = [] }: ChatRequest = req.body;
+
+    if (!message || typeof message !== 'string') {
+      return res.status(400).json({ error: 'Message is required' });
+    }
+
+    const response = await chatbotService.generateResponse(message, history);
+
+    res.json({ message: response });
+  } catch (error) {
+    console.error('Chatbot error:', error);
+    res.status(500).json({
+      error: 'Failed to generate response',
+      message: 'Sorry, I encountered an error. Please try again.'
+    });
+  }
+});
+
+export default router;

package/tools/templates/modules/chatbot/backend/node-express/backend/src/services/chatbotService.ts

@@ -0,0 +1,124 @@
+interface ChatMessage {
+  role: 'user' | 'assistant';
+  content: string;
+}
+
+export class ChatbotService {
+  private openaiApiKey: string | undefined;
+  private anthropicApiKey: string | undefined;
+
+  constructor() {
+    this.openaiApiKey = process.env.OPENAI_API_KEY;
+    this.anthropicApiKey = process.env.ANTHROPIC_API_KEY;
+  }
+
+  async generateResponse(message: string, history: ChatMessage[]): Promise<string> {
+    // Try LLM providers in order of preference
+    if (this.anthropicApiKey) {
+      return this.generateAnthropicResponse(message, history);
+    }
+
+    if (this.openaiApiKey) {
+      return this.generateOpenAIResponse(message, history);
+    }
+
+    // Fallback to basic rule-based responses
+    return this.generateBasicResponse(message);
+  }
+
+  private async generateOpenAIResponse(message: string, history: ChatMessage[]): Promise<string> {
+    try {
+      const response = await fetch('https://api.openai.com/v1/chat/completions', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.openaiApiKey}`
+        },
+        body: JSON.stringify({
+          model: 'gpt-4o-mini',
+          messages: [
+            { role: 'system', content: 'You are a helpful assistant for this web application. Be concise and friendly.' },
+            ...history.map(msg => ({ role: msg.role, content: msg.content })),
+            { role: 'user', content: message }
+          ],
+          max_tokens: 500,
+          temperature: 0.7
+        })
+      });
+
+      if (!response.ok) {
+        throw new Error(`OpenAI API error: ${response.statusText}`);
+      }
+
+      const data = await response.json();
+      return data.choices[0]?.message?.content || this.generateBasicResponse(message);
+    } catch (error) {
+      console.error('OpenAI error:', error);
+      return this.generateBasicResponse(message);
+    }
+  }
+
+  private async generateAnthropicResponse(message: string, history: ChatMessage[]): Promise<string> {
+    try {
+      const response = await fetch('https://api.anthropic.com/v1/messages', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.anthropicApiKey!,
+          'anthropic-version': '2023-06-01'
+        },
+        body: JSON.stringify({
+          model: 'claude-3-5-haiku-20241022',
+          max_tokens: 500,
+          system: 'You are a helpful assistant for this web application. Be concise and friendly.',
+          messages: [
+            ...history.map(msg => ({ role: msg.role, content: msg.content })),
+            { role: 'user', content: message }
+          ]
+        })
+      });
+
+      if (!response.ok) {
+        throw new Error(`Anthropic API error: ${response.statusText}`);
+      }
+
+      const data = await response.json();
+      return data.content[0]?.text || this.generateBasicResponse(message);
+    } catch (error) {
+      console.error('Anthropic error:', error);
+      return this.generateBasicResponse(message);
+    }
+  }
+
+  private generateBasicResponse(message: string): string {
+    const lowerMessage = message.toLowerCase();
+
+    // Greeting patterns
+    if (/(hello|hi|hey|greetings)/i.test(lowerMessage)) {
+      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 (/(help|what can you do|how do you work)/i.test(lowerMessage)) {
+      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 (/(feature|what|how)/i.test(lowerMessage)) {
+      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 (/(api|configure|setup|install)/i.test(lowerMessage)) {
+      return "To configure AI responses:\n\n1. Get an API key from OpenAI or Anthropic\n2. Add it to backend/.env:\n   OPENAI_API_KEY=sk-...\n   or\n   ANTHROPIC_API_KEY=sk-ant-...\n3. Restart the backend\n\nThen I'll be powered by AI!";
+    }
+
+    // Thanks/Goodbye
+    if (/(thank|thanks|bye|goodbye)/i.test(lowerMessage)) {
+      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/app/main.py.ejs

@@ -0,0 +1,69 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from datetime import datetime
+import os
+<% if (modules.auth) { -%>
+from app.routes import auth
+<% } -%>
+<% if (modules.payments) { -%>
+from app.routes import stripe
+<% } -%>
+<% if (modules.contact) { -%>
+from app.routes import contact
+<% } -%>
+<% if (modules.admin) { -%>
+from app.routes import admin
+<% } -%>
+from app.routes import chatbot
+
+app = FastAPI(
+    title="<%= AppName %> API",
+    description="API for <%= appName %>",
+    version="1.0.0"
+)
+
+# CORS configuration
+allowed_origins = [
+    "http://localhost:5173",  # Vite default
+    "http://localhost:3000",  # Next.js default
+    os.getenv("FRONTEND_URL", "")
+]
+allowed_origins = [origin for origin in allowed_origins if origin]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=allowed_origins if os.getenv("NODE_ENV") != "development" else ["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/api/example")
+async def example():
+    """Example API endpoint"""
+    return {
+        "message": "Hello from python-fastapi backend!",
+        "timestamp": datetime.utcnow().isoformat()
+    }
+
+# Module routes
+<% if (modules.auth) { -%>
+app.include_router(auth.router, prefix="/api/auth", tags=["auth"])
+<% } -%>
+<% if (modules.payments) { -%>
+app.include_router(stripe.router, prefix="/stripe", tags=["stripe"])
+<% } -%>
+<% if (modules.contact) { -%>
+app.include_router(contact.router, prefix="/api/contact", tags=["contact"])
+<% } -%>
+<% if (modules.admin) { -%>
+app.include_router(admin.router, prefix="/api/admin", tags=["admin"])
+<% } -%>
+app.include_router(chatbot.router, prefix="/api/chatbot", tags=["chatbot"])
+
+@app.on_event("startup")
+async def startup_event():
+    print("✅ Server running on http://localhost:8080")
+    print("📡 API endpoint: http://localhost:8080/api/example")
+    print("💬 Chatbot endpoint: http://localhost:8080/api/chatbot")
+    print("📚 API docs: http://localhost:8080/docs")

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

@@ -0,0 +1,38 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import List, Optional
+from app.services.chatbot_service import ChatbotService
+
+router = APIRouter()
+chatbot_service = ChatbotService()
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+class ChatRequest(BaseModel):
+    message: str
+    history: Optional[List[ChatMessage]] = []
+
+@router.post("")
+async def chat(request: ChatRequest):
+    """
+    Chat endpoint that works with or without AI API keys.
+    Falls back to basic responses if no API key is configured.
+    """
+    try:
+        if not request.message or not isinstance(request.message, str):
+            raise HTTPException(status_code=400, detail="Message is required")
+
+        response = await chatbot_service.generate_response(
+            request.message,
+            request.history
+        )
+
+        return {"message": response}
+    except Exception as e:
+        print(f"Chatbot error: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail="Sorry, I encountered an error. Please try again."
+        )