fixed indexing on feedback

.env.example

@@ -0,0 +1,43 @@
+# Daily Journal Prompt Generator - Environment Variables
+# Copy this file to .env and fill in your values
+
+# API Keys (required - at least one)
+DEEPSEEK_API_KEY=your_deepseek_api_key_here
+OPENAI_API_KEY=your_openai_api_key_here
+
+# API Configuration
+API_BASE_URL=https://api.deepseek.com
+MODEL=deepseek-chat
+
+# Application Settings
+DEBUG=false
+ENVIRONMENT=development
+NODE_ENV=development
+
+# Server Settings
+HOST=0.0.0.0
+PORT=8000
+
+# CORS Settings (comma-separated list)
+BACKEND_CORS_ORIGINS=http://localhost:3000,http://localhost:80
+
+# Prompt Settings
+MIN_PROMPT_LENGTH=500
+MAX_PROMPT_LENGTH=1000
+NUM_PROMPTS_PER_SESSION=6
+CACHED_POOL_VOLUME=20
+HISTORY_BUFFER_SIZE=60
+FEEDBACK_HISTORY_SIZE=30
+
+# File Paths
+DATA_DIR=data
+PROMPT_TEMPLATE_PATH=data/ds_prompt.txt
+FEEDBACK_TEMPLATE_PATH=data/ds_feedback.txt
+SETTINGS_CONFIG_PATH=data/settings.cfg
+
+# Data File Names
+PROMPTS_HISTORIC_FILE=prompts_historic.json
+PROMPTS_POOL_FILE=prompts_pool.json
+FEEDBACK_WORDS_FILE=feedback_words.json
+FEEDBACK_HISTORIC_FILE=feedback_historic.json
+

.gitignore

@@ -1,6 +1,6 @@
 .env
 venv
 __pycache__
-historic_prompts.json
+#historic_prompts.json
-pool_prompts.json
+#pool_prompts.json
-feedback_words.json
+#feedback_words.json

API_DOCUMENTATION.md

@@ -0,0 +1,375 @@
+# Daily Journal Prompt Generator - API Documentation
+
+## Overview
+
+The Daily Journal Prompt Generator API provides endpoints for generating, managing, and interacting with AI-powered journal writing prompts. The API is built with FastAPI and provides automatic OpenAPI documentation.
+
+## Base URL
+
+- Development: `http://localhost:8000`
+- Production: `https://your-domain.com`
+
+## API Version
+
+All endpoints are prefixed with `/api/v1`
+
+## Authentication
+
+Currently, the API does not require authentication as it's designed for single-user use. Future versions may add authentication for multi-user support.
+
+## Error Handling
+
+All endpoints return appropriate HTTP status codes:
+
+- `200`: Success
+- `400`: Bad Request (validation errors)
+- `404`: Resource Not Found
+- `422`: Unprocessable Entity (request validation failed)
+- `500`: Internal Server Error
+
+Error responses follow this format:
+```json
+{
+  "error": {
+    "type": "ErrorType",
+    "message": "Human-readable error message",
+    "details": {}, // Optional additional details
+    "status_code": 400
+  }
+}
+```
+
+## Endpoints
+
+### Prompt Operations
+
+#### 1. Draw Prompts from Pool
+**GET** `/api/v1/prompts/draw`
+
+Draw prompts from the existing pool without making API calls.
+
+**Query Parameters:**
+- `count` (optional, integer): Number of prompts to draw (default: 6)
+
+**Response:**
+```json
+{
+  "prompts": [
+    "Write about a time when...",
+    "Imagine you could..."
+  ],
+  "count": 2,
+  "remaining_in_pool": 18
+}
+```
+
+#### 2. Fill Prompt Pool
+**POST** `/api/v1/prompts/fill-pool`
+
+Fill the prompt pool to target volume using AI.
+
+**Response:**
+```json
+{
+  "added": 5,
+  "total_in_pool": 20,
+  "target_volume": 20
+}
+```
+
+#### 3. Get Pool Statistics
+**GET** `/api/v1/prompts/stats`
+
+Get statistics about the prompt pool.
+
+**Response:**
+```json
+{
+  "total_prompts": 15,
+  "prompts_per_session": 6,
+  "target_pool_size": 20,
+  "available_sessions": 2,
+  "needs_refill": true
+}
+```
+
+#### 4. Get History Statistics
+**GET** `/api/v1/prompts/history/stats`
+
+Get statistics about prompt history.
+
+**Response:**
+```json
+{
+  "total_prompts": 8,
+  "history_capacity": 60,
+  "available_slots": 52,
+  "is_full": false
+}
+```
+
+#### 5. Get Prompt History
+**GET** `/api/v1/prompts/history`
+
+Get prompt history with optional limit.
+
+**Query Parameters:**
+- `limit` (optional, integer): Maximum number of history items to return
+
+**Response:**
+```json
+[
+  {
+    "key": "prompt00",
+    "text": "Most recent prompt text...",
+    "position": 0
+  },
+  {
+    "key": "prompt01",
+    "text": "Previous prompt text...",
+    "position": 1
+  }
+]
+```
+
+#### 6. Select Prompt (Add to History)
+**POST** `/api/v1/prompts/select/{prompt_index}`
+
+Select a prompt from drawn prompts to add to history.
+
+**Path Parameters:**
+- `prompt_index` (integer): Index of the prompt to select (0-based)
+
+**Note:** This endpoint requires session management and is not fully implemented in the initial version.
+
+### Feedback Operations
+
+#### 7. Generate Theme Feedback Words
+**GET** `/api/v1/feedback/generate`
+
+Generate 6 theme feedback words using AI based on historic prompts.
+
+**Response:**
+```json
+{
+  "theme_words": ["creativity", "reflection", "growth", "memory", "imagination", "emotion"],
+  "count": 6
+}
+```
+
+#### 8. Rate Feedback Words
+**POST** `/api/v1/feedback/rate`
+
+Rate feedback words and update feedback system.
+
+**Request Body:**
+```json
+{
+  "ratings": {
+    "creativity": 5,
+    "reflection": 6,
+    "growth": 4,
+    "memory": 3,
+    "imagination": 5,
+    "emotion": 4
+  }
+}
+```
+
+**Response:**
+```json
+{
+  "feedback_words": [
+    {
+      "key": "feedback00",
+      "word": "creativity",
+      "weight": 5
+    },
+    // ... 5 more items
+  ],
+  "added_to_history": true
+}
+```
+
+#### 9. Get Current Feedback Words
+**GET** `/api/v1/feedback/current`
+
+Get current feedback words with weights.
+
+**Response:**
+```json
+[
+  {
+    "key": "feedback00",
+    "word": "creativity",
+    "weight": 5
+  }
+]
+```
+
+#### 10. Get Feedback History
+**GET** `/api/v1/feedback/history`
+
+Get feedback word history.
+
+**Response:**
+```json
+[
+  {
+    "key": "feedback00",
+    "word": "creativity"
+  }
+]
+```
+
+## Data Models
+
+### PromptResponse
+```json
+{
+  "key": "string",      // e.g., "prompt00"
+  "text": "string",     // Prompt text content
+  "position": "integer" // Position in history (0 = most recent)
+}
+```
+
+### PoolStatsResponse
+```json
+{
+  "total_prompts": "integer",
+  "prompts_per_session": "integer",
+  "target_pool_size": "integer",
+  "available_sessions": "integer",
+  "needs_refill": "boolean"
+}
+```
+
+### HistoryStatsResponse
+```json
+{
+  "total_prompts": "integer",
+  "history_capacity": "integer",
+  "available_slots": "integer",
+  "is_full": "boolean"
+}
+```
+
+### FeedbackWord
+```json
+{
+  "key": "string",    // e.g., "feedback00"
+  "word": "string",   // Feedback word
+  "weight": "integer" // Weight from 0-6
+}
+```
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `DEEPSEEK_API_KEY` | DeepSeek API key | (required) |
+| `OPENAI_API_KEY` | OpenAI API key | (optional) |
+| `API_BASE_URL` | API base URL | `https://api.deepseek.com` |
+| `MODEL` | AI model to use | `deepseek-chat` |
+| `DEBUG` | Debug mode | `false` |
+| `ENVIRONMENT` | Environment | `development` |
+| `HOST` | Server host | `0.0.0.0` |
+| `PORT` | Server port | `8000` |
+| `MIN_PROMPT_LENGTH` | Minimum prompt length | `500` |
+| `MAX_PROMPT_LENGTH` | Maximum prompt length | `1000` |
+| `NUM_PROMPTS_PER_SESSION` | Prompts per session | `6` |
+| `CACHED_POOL_VOLUME` | Target pool size | `20` |
+| `HISTORY_BUFFER_SIZE` | History capacity | `60` |
+| `FEEDBACK_HISTORY_SIZE` | Feedback history capacity | `30` |
+
+### File Structure
+
+```
+data/
+├── prompts_historic.json    # Historic prompts (cyclic buffer)
+├── prompts_pool.json        # Prompt pool
+├── feedback_words.json      # Current feedback words with weights
+├── feedback_historic.json   # Historic feedback words
+├── ds_prompt.txt           # Prompt generation template
+├── ds_feedback.txt         # Feedback analysis template
+└── settings.cfg            # Application settings
+```
+
+## Running the API
+
+### Development
+```bash
+cd backend
+uvicorn main:app --reload
+```
+
+### Production
+```bash
+cd backend
+uvicorn main:app --host 0.0.0.0 --port 8000
+```
+
+### Docker
+```bash
+docker-compose up --build
+```
+
+## Interactive Documentation
+
+FastAPI provides automatic interactive documentation:
+
+- Swagger UI: `http://localhost:8000/docs`
+- ReDoc: `http://localhost:8000/redoc`
+
+## Rate Limiting
+
+Currently, the API does not implement rate limiting. Consider implementing rate limiting in production if needed.
+
+## CORS
+
+CORS is configured to allow requests from:
+- `http://localhost:3000` (frontend dev server)
+- `http://localhost:80` (frontend production)
+
+Additional origins can be configured via the `BACKEND_CORS_ORIGINS` environment variable.
+
+## Health Check
+
+**GET** `/health`
+
+Returns:
+```json
+{
+  "status": "healthy",
+  "service": "daily-journal-prompt-api"
+}
+```
+
+## Root Endpoint
+
+**GET** `/`
+
+Returns API information:
+```json
+{
+  "name": "Daily Journal Prompt Generator API",
+  "version": "1.0.0",
+  "description": "API for generating and managing journal writing prompts",
+  "docs": "/docs",
+  "health": "/health"
+}
+```
+
+## Future Enhancements
+
+1. **Authentication**: Add JWT or session-based authentication
+2. **Rate Limiting**: Implement request rate limiting
+3. **WebSocket Support**: Real-time prompt generation updates
+4. **Export Functionality**: Export prompts to PDF/Markdown
+5. **Prompt Customization**: User-defined prompt templates
+6. **Multi-language Support**: Generate prompts in different languages
+7. **Analytics**: Track prompt usage and user engagement
+8. **Social Features**: Share prompts, community prompts
+

README.md

@@ -1,268 +1,363 @@
-# Daily Journal Prompt Generator
+# Daily Journal Prompt Generator - Web Application
 
-A Python tool that uses OpenAI-compatible AI endpoints to generate creative writing prompts for daily journaling. The tool maintains awareness of previous prompts to minimize repetition while providing diverse, thought-provoking topics for journal writing.
+A modern web application for generating AI-powered journal writing prompts, refactored from a CLI tool to a full web stack with FastAPI backend and Astro frontend.
 
 ## ✨ Features
 
-- **AI-Powered Prompt Generation**: Uses OpenAI-compatible APIs to generate creative writing prompts
+- **AI-Powered Prompt Generation**: Uses DeepSeek/OpenAI API to generate creative writing prompts
-- **Smart Repetition Avoidance**: Maintains history of the last 60 prompts to minimize thematic overlap
+- **Smart History System**: 60-prompt cyclic buffer to avoid repetition and steer themes
-- **Multiple Options**: Generates 6 different prompt options for each session
+- **Prompt Pool Management**: Caches prompts for offline use with automatic refilling
-- **Diverse Topics**: Covers a wide range of themes including memories, creativity, self-reflection, and imagination
+- **Theme Feedback System**: AI analyzes your preferences to improve future prompts
-- **Simple Configuration**: Easy setup with environment variables for API keys
+- **Modern Web Interface**: Responsive design with intuitive UI
-- **JSON-Based History**: Stores prompt history in a structured JSON format for easy management
+- **RESTful API**: Fully documented API for programmatic access
+- **Docker Support**: Easy deployment with Docker and Docker Compose
 
-## 📋 Prerequisites
+## 🏗️ Architecture
 
-- Python 3.7+
+### Backend (FastAPI)
-- An API key from an OpenAI-compatible service (DeepSeek, OpenAI, etc.)
+- **Framework**: FastAPI with async/await support
-- Basic knowledge of Python and command line usage
+- **API Documentation**: Automatic OpenAPI/Swagger documentation
+- **Data Persistence**: JSON file storage with async file operations
+- **Services**: Modular architecture with clear separation of concerns
+- **Validation**: Pydantic models for request/response validation
+- **Error Handling**: Comprehensive error handling with custom exceptions
 
-## 🚀 Installation & Setup
+### Frontend (Astro + React)
+- **Framework**: Astro with React components for interactivity
+- **Styling**: Custom CSS with modern design system
+- **Responsive Design**: Mobile-first responsive layout
+- **API Integration**: Proxy configuration for seamless backend communication
+- **Component Architecture**: Reusable React components
 
-1. **Clone the repository**:
+### Infrastructure
-   ```bash
+- **Docker**: Multi-container setup with development and production configurations
-   git clone <repository-url>
+- **Docker Compose**: Orchestration for local development
-   cd daily-journal-prompt
+- **Nginx**: Reverse proxy for frontend serving
-   ```
+- **Health Checks**: Container health monitoring
-
-2. **Set up a Python virtual environment (recommended)**:
-   ```bash
-   # Create a virtual environment
-   python -m venv venv
-
-   # Activate the virtual environment
-   # On Linux/macOS:
-   source venv/bin/activate
-   # On Windows:
-   # venv\Scripts\activate
-   ```
-
-3. **Set up environment variables**:
-   ```bash
-   cp example.env .env
-   ```
-
-   Edit the `.env` file and add your API key:
-   ```env
-   # DeepSeek
-   DEEPSEEK_API_KEY="sk-your-actual-api-key-here"
-
-   # Or for OpenAI
-   # OPENAI_API_KEY="sk-your-openai-api-key"
-   ```
-
-4. **Install required Python packages**:
-   ```bash
-   pip install -r requirements.txt
-   ```
 
 ## 📁 Project Structure
 
 ```
 daily-journal-prompt/
-├── README.md                 # This documentation
+├── backend/                    # FastAPI backend
-├── generate_prompts.py      # Main Python script with rich interface
+│   ├── app/
-├── simple_generate.py       # Lightweight version without rich dependency
+│   │   ├── api/v1/            # API endpoints
-├── run.sh                   # Convenience bash script
+│   │   ├── core/              # Configuration, logging, exceptions
-├── test_project.py          # Test suite for the project
+│   │   ├── models/            # Pydantic models
-├── requirements.txt         # Python dependencies
+│   │   └── services/          # Business logic services
-├── ds_prompt.txt            # AI prompt template for generating journal prompts
+│   ├── main.py                # FastAPI application entry point
-├── prompts_historic.json    # History of previous 60 prompts (JSON format)
+│   └── requirements.txt       # Python dependencies
-├── prompts_pool.json        # Pool of available prompts for selection (JSON format)
+├── frontend/                  # Astro frontend
-├── example.env              # Example environment configuration
+│   ├── src/
-├── .env                     # Your actual environment configuration (gitignored)
+│   │   ├── components/        # React components
-├── settings.cfg            # Configuration file for prompt settings and pool size
+│   │   ├── layouts/           # Layout components
-└── .gitignore              # Git ignore rules
+│   │   ├── pages/             # Astro pages
+│   │   └── styles/            # CSS styles
+│   ├── astro.config.mjs       # Astro configuration
+│   └── package.json           # Node.js dependencies
+├── data/                      # Data storage (mounted volume)
+│   ├── prompts_historic.json  # Historic prompts
+│   ├── prompts_pool.json      # Prompt pool
+│   ├── feedback_words.json    # Feedback words with weights
+│   ├── feedback_historic.json # Historic feedback
+│   ├── ds_prompt.txt          # Prompt template
+│   ├── ds_feedback.txt        # Feedback template
+│   └── settings.cfg           # Application settings
+├── docker-compose.yml         # Docker Compose configuration
+├── backend/Dockerfile         # Backend Dockerfile
+├── frontend/Dockerfile        # Frontend Dockerfile
+├── .env.example              # Environment variables template
+├── API_DOCUMENTATION.md      # API documentation
+├── AGENTS.md                 # Project planning and architecture
+└── README.md                 # This file
 ```
 
-### File Descriptions
+## 🚀 Quick Start
 
-- **generate_prompts.py**: Main Python script with interactive mode, rich formatting, and full features
+### Prerequisites
-- **simple_generate.py**: Lightweight version without rich dependency for basic usage
+- Python 3.11+
-- **run.sh**: Convenience bash script for easy execution
+- Node.js 18+
-- **test_project.py**: Test suite to verify project setup
+- Docker and Docker Compose (optional)
-- **requirements.txt**: Python dependencies (openai, python-dotenv, rich)
+- API key from DeepSeek or OpenAI
-- **ds_prompt.txt**: The core prompt template that instructs the AI to generate new journal prompts
-- **prompts_historic.json**: JSON array containing the last 60 generated prompts (cyclic buffer)
-- **prompts_pool.json**: JSON array containing the pool of available prompts for selection
-- **example.env**: Template for your environment configuration
-- **.env**: Your actual environment variables (not tracked in git for security)
-- **settings.cfg**: Configuration file for prompt settings (length, count) and pool size
 
-## 🎯 Quick Start
+### Option 1: Docker (Recommended)
 
-### Using the Bash Script (Recommended)
+1. **Clone and setup**
+   ```bash
+   git clone <repository-url>
+   cd daily-journal-prompt
+   cp .env.example .env
+   ```
+
+2. **Edit .env file**
+   ```bash
+   # Add your API key
+   DEEPSEEK_API_KEY=your_api_key_here
+   # or
+   OPENAI_API_KEY=your_api_key_here
+   ```
+
+3. **Start with Docker Compose**
+   ```bash
+   docker-compose up --build
+   ```
+
+4. **Access the application**
+   - Frontend: http://localhost:3000
+   - Backend API: http://localhost:8000
+   - API Documentation: http://localhost:8000/docs
+
+### Option 2: Manual Setup
+
+#### Backend Setup
 ```bash
-# Make the script executable
+cd backend
-chmod +x run.sh
+python -m venv venv
-
+source venv/bin/activate  # On Windows: venv\Scripts\activate
-# Generate prompts (default)
-./run.sh
-
-# Interactive mode with rich interface
-./run.sh --interactive
-
-# Simple version without rich dependency
-./run.sh --simple
-
-# Show statistics
-./run.sh --stats
-
-# Show help
-./run.sh --help
-```
-
-### Using Python Directly
-```bash
-# First, activate your virtual environment (if using one)
-# On Linux/macOS:
-# source venv/bin/activate
-# On Windows:
-# venv\Scripts\activate
-
-# Install dependencies
 pip install -r requirements.txt
 
-# Generate prompts (default)
+# Set environment variables
-python generate_prompts.py
+export DEEPSEEK_API_KEY=your_api_key_here
+# or
+export OPENAI_API_KEY=your_api_key_here
 
-# Interactive mode
+# Run the backend
-python generate_prompts.py --interactive
+uvicorn main:app --reload
-
-# Show statistics
-python generate_prompts.py --stats
-
-# Simple version (no rich dependency needed)
-python simple_generate.py
 ```
 
-### Testing Your Setup
+#### Frontend Setup
 ```bash
-# Run the test suite
+cd frontend
-python test_project.py
+npm install
+npm run dev
 ```
 
-## 🔧 Usage
+## 📚 API Usage
 
-### New Pool-Based System
+The API provides comprehensive endpoints for prompt management:
-
-The system now uses a two-step process:
-
-1. **Fill the Prompt Pool**: Generate prompts using AI and add them to the pool
-2. **Draw from Pool**: Select prompts from the pool for journaling sessions
-
-### Command Line Options
 
+### Basic Operations
 ```bash
-# Default: Draw prompts from pool (no API call)
+# Draw prompts from pool
-python generate_prompts.py
+curl http://localhost:8000/api/v1/prompts/draw
 
-# Interactive mode with menu
+# Fill prompt pool
-python generate_prompts.py --interactive
+curl -X POST http://localhost:8000/api/v1/prompts/fill-pool
 
-# Fill the prompt pool using AI (makes API call)
+# Get statistics
-python generate_prompts.py --fill-pool
+curl http://localhost:8000/api/v1/prompts/stats
-
-# Show pool statistics
-python generate_prompts.py --pool-stats
-
-# Show history statistics
-python generate_prompts.py --stats
-
-# Help
-python generate_prompts.py --help
 ```
 
-### Interactive Mode Options
+### Interactive Documentation
+Access the automatic API documentation at:
+- Swagger UI: http://localhost:8000/docs
+- ReDoc: http://localhost:8000/redoc
 
-1. **Draw prompts from pool (no API call)**: Displays and consumes prompts from the pool file
+## 🔧 Configuration
-2. **Fill prompt pool using API**: Generates new prompts using AI and adds them to pool
-3. **View pool statistics**: Shows pool size, target size, and available sessions
-4. **View history statistics**: Shows historic prompt count and capacity
-5. **Exit**: Quit the program
-
-### Prompt Generation Process
-
-1. User chooses to fill the prompt pool.
-2. The system reads the template from `ds_prompt.txt`
-3. It loads the previous 60 prompts from the fixed length cyclic buffer `prompts_historic.json`
-4. The AI generates some number of new prompts, attempting to minimize repetition
-5. The new prompts are used to fill the prompt pool to the `settings.cfg` configured value.
-
-### Prompt Selection Process
-
-1. A `settings.cfg` configurable number of prompts are drawn from the prompt pool and displayed to the user.
-2. User selects one prompt for his/her journal writing session, which is added to the `prompts_historic.json` cyclic buffer.
-3. All prompts which were displayed are removed from the prompt pool permanently.
-
-## 📝 Prompt Examples
-
-The tool generates prompts like these (from `prompts_historic.json`):
-
-- **Memory-based**: "Describe a memory you have that is tied to a specific smell..."
-- **Creative Writing**: "Invent a mythological creature for a modern urban setting..."
-- **Self-Reflection**: "Write a dialogue between two aspects of yourself..."
-- **Observational**: "Describe your current emotional state as a weather system..."
-
-Each prompt is designed to inspire 1-2 pages of journal writing and ranges from 500-1000 characters.
-
-## ⚙️ Configuration
 
 ### Environment Variables
-
+Create a `.env` file based on `.env.example`:
-Create a `.env` file with your API configuration:
 
 ```env
-# For DeepSeek
+# Required: At least one API key
-DEEPSEEK_API_KEY="sk-your-deepseek-api-key"
+DEEPSEEK_API_KEY=your_deepseek_api_key
+OPENAI_API_KEY=your_openai_api_key
 
-# For OpenAI
+# Optional: Customize behavior
-# OPENAI_API_KEY="sk-your-openai-api-key"
+API_BASE_URL=https://api.deepseek.com
-
+MODEL=deepseek-chat
-# Optional: Custom API base URL
+DEBUG=false
-# API_BASE_URL="https://api.deepseek.com"
+CACHED_POOL_VOLUME=20
+NUM_PROMPTS_PER_SESSION=6
 ```
 
-### Prompt Template Customization
+### Application Settings
+Edit `data/settings.cfg` to customize:
+- Prompt length constraints
+- Number of prompts per session
+- Pool volume targets
 
-You can modify `ds_prompt.txt` to change the prompt generation parameters:
+## 🐛 Troubleshooting
 
-- Number of prompts generated (default: 6)
+### Docker Permission Issues
-- Prompt length requirements (default: 500-1000 characters)
+If you encounter permission errors when running Docker containers:
-- Specific themes or constraints
-- Output format specifications
 
-## 🔄 Maintaining Prompt History
+1. **Check directory permissions**:
+   ```bash
+   ls -la data/
+   ```
+   The `data/` directory should be readable/writable by your user (UID 1000 typically).
 
-The `prompts_historic.json` file maintains a rolling history of the last 60 prompts. This helps:
+2. **Fix permissions** (if needed):
+   ```bash
+   chmod 700 data/
+   chown -R $(id -u):$(id -g) data/
+   ```
 
-1. **Avoid repetition**: The AI references previous prompts to generate new, diverse topics
+3. **Verify Docker user matches host user**:
-2. **Track usage**: See what types of prompts have been generated
+   The Dockerfile creates a user with UID 1000. If your host user has a different UID:
-3. **Quality control**: Monitor the variety and quality of generated prompts
+   ```bash
+   # Check your UID
+   id -u
+
+   # Update Dockerfile to match your UID
+   # Change: RUN useradd -m -u 1000 appuser
+   # To: RUN useradd -m -u YOUR_UID appuser
+   ```
+
+### npm Build Errors
+If you see `npm ci` errors:
+- The Dockerfile uses `npm install` instead of `npm ci` for development
+- For production, generate a `package-lock.json` file first:
+  ```bash
+  cd frontend
+  npm install
+  ```
+
+### API Connection Issues
+If the backend can't connect to AI APIs:
+1. Verify your API key is set in `.env`
+2. Check network connectivity
+3. Ensure the API service is available
+
+## 🧪 Testing
+
+Run the backend tests:
+```bash
+python test_backend.py
+```
+
+## 🐳 Docker Development
+
+### Development Mode
+```bash
+# Hot reload for both backend and frontend
+docker-compose up --build
+
+# View logs
+docker-compose logs -f
+
+# Stop services
+docker-compose down
+```
+
+### Useful Commands
+```bash
+# Rebuild specific service
+docker-compose build backend
+
+# Run single service
+docker-compose up backend
+
+# Execute commands in container
+docker-compose exec backend python -m pytest
+```
+
+## 🔄 Migration from CLI
+
+The web application maintains full compatibility with the original CLI data format:
+
+1. **Data Files**: Existing JSON files are automatically used
+2. **Templates**: Same prompt and feedback templates
+3. **Settings**: Compatible settings.cfg format
+4. **Functionality**: All CLI features available via API
+
+## 📊 Features Comparison
+
+| Feature | CLI Version | Web Version |
+|---------|------------|-------------|
+| Prompt Generation | ✅ | ✅ |
+| Prompt Pool | ✅ | ✅ |
+| History Management | ✅ | ✅ |
+| Theme Feedback | ✅ | ✅ |
+| Web Interface | ❌ | ✅ |
+| REST API | ❌ | ✅ |
+| Docker Support | ❌ | ✅ |
+| Multi-user Ready | ❌ | ✅ (future) |
+| Mobile Responsive | ❌ | ✅ |
+
+## 🛠️ Development
+
+### Backend Development
+```bash
+cd backend
+# Install development dependencies
+pip install -r requirements.txt
+
+# Run with hot reload
+uvicorn main:app --reload --host 0.0.0.0 --port 8000
+
+# Run tests
+python test_backend.py
+```
+
+### Frontend Development
+```bash
+cd frontend
+# Install dependencies
+npm install
+
+# Run development server
+npm run dev
+
+# Build for production
+npm run build
+```
+
+### Code Structure
+- **Backend**: Follows FastAPI best practices with dependency injection
+- **Frontend**: Uses Astro islands architecture with React components
+- **Services**: Async/await pattern for I/O operations
+- **Error Handling**: Comprehensive error handling at all levels
 
 ## 🤝 Contributing
 
-Contributions are welcome! Here are some ways you can contribute:
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests if applicable
+5. Submit a pull request
 
-1. **Add new prompt templates** for different writing styles
+### Development Guidelines
-2. **Improve the AI prompt engineering** for better results
+- Follow PEP 8 for Python code
-3. **Add support for more AI providers**
+- Use TypeScript for React components when possible
-4. **Create a CLI interface** for easier usage
+- Write meaningful commit messages
-5. **Add tests** to ensure reliability
+- Update documentation for new features
+- Add tests for new functionality
 
 ## 📄 License
 
-[Add appropriate license information here]
+This project is licensed under the MIT License - see the LICENSE file for details.
 
 ## 🙏 Acknowledgments
 
-- Inspired by the need for consistent journaling practice
+- Built with [FastAPI](https://fastapi.tiangolo.com/)
-- Built with OpenAI-compatible AI services
+- Frontend with [Astro](https://astro.build/)
-- Community contributions welcome
+- AI integration with [OpenAI](https://openai.com/) and [DeepSeek](https://www.deepseek.com/)
+- Icons from [Font Awesome](https://fontawesome.com/)
 
-## 🆘 Support
+## 📞 Support
 
-For issues, questions, or suggestions:
+- **Issues**: Use GitHub Issues for bug reports and feature requests
-1. Check the existing issues on GitHub
+- **Documentation**: Check `API_DOCUMENTATION.md` for API details
-2. Create a new issue with detailed information
+- **Examples**: See the test files for usage examples
-3. Provide examples of problematic prompts or errors
+
+## 🚀 Deployment
+
+### Cloud Platforms
+- **Render**: One-click deployment with Docker
+- **Railway**: Easy deployment with environment management
+- **Fly.io**: Global deployment with edge computing
+- **AWS/GCP/Azure**: Traditional cloud deployment
+
+### Deployment Steps
+1. Set environment variables
+2. Build Docker images
+3. Configure database (if migrating from JSON)
+4. Set up reverse proxy (nginx/caddy)
+5. Configure SSL certificates
+6. Set up monitoring and logging
+
+---
+
+**Happy Journaling! 📓✨**

backend/Dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create non-root user
+RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app
+USER appuser
+
+# Expose port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')" || exit 1
+
+# Run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+

backend/app/api/v1/api.py

@@ -0,0 +1,15 @@
+"""
+API router for version 1 endpoints.
+"""
+
+from fastapi import APIRouter
+
+from app.api.v1.endpoints import prompts, feedback
+
+# Create main API router
+api_router = APIRouter()
+
+# Include endpoint routers
+api_router.include_router(prompts.router, prefix="/prompts", tags=["prompts"])
+api_router.include_router(feedback.router, prefix="/feedback", tags=["feedback"])
+

backend/app/api/v1/endpoints/feedback.py

@@ -0,0 +1,193 @@
+"""
+Feedback-related API endpoints.
+"""
+
+from typing import List, Dict, Any
+from fastapi import APIRouter, HTTPException, Depends, status
+from pydantic import BaseModel
+
+from app.services.prompt_service import PromptService
+from app.models.prompt import FeedbackWord, RateFeedbackWordsRequest, RateFeedbackWordsResponse
+
+# Create router
+router = APIRouter()
+
+# Response models
+class GenerateFeedbackWordsResponse(BaseModel):
+    """Response model for generating feedback words."""
+    theme_words: List[str]
+    count: int = 6
+
+class FeedbackQueuedWordsResponse(BaseModel):
+    """Response model for queued feedback words."""
+    queued_words: List[FeedbackWord]
+    count: int
+
+class FeedbackActiveWordsResponse(BaseModel):
+    """Response model for active feedback words."""
+    active_words: List[FeedbackWord]
+    count: int
+
+class FeedbackHistoricResponse(BaseModel):
+    """Response model for full feedback history."""
+    feedback_history: List[Dict[str, Any]]
+    count: int
+
+# Service dependency
+async def get_prompt_service() -> PromptService:
+    """Dependency to get PromptService instance."""
+    return PromptService()
+
+@router.get("/queued", response_model=FeedbackQueuedWordsResponse)
+async def get_queued_feedback_words(
+    prompt_service: PromptService = Depends(get_prompt_service)
+):
+    """
+    Get queued feedback words (positions 0-5) for user weighting.
+
+    Returns:
+        List of queued feedback words with weights
+    """
+    try:
+        # Get queued feedback words from PromptService
+        queued_feedback_items = await prompt_service.get_feedback_queued_words()
+
+        # Convert to FeedbackWord models
+        queued_words = []
+        for i, item in enumerate(queued_feedback_items):
+            key = list(item.keys())[0]
+            word = item[key]
+            weight = item.get("weight", 3)  # Default weight is 3
+            queued_words.append(FeedbackWord(key=key, word=word, weight=weight))
+
+        return FeedbackQueuedWordsResponse(
+            queued_words=queued_words,
+            count=len(queued_words)
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Error getting queued feedback words: {str(e)}"
+        )
+
+@router.get("/active", response_model=FeedbackActiveWordsResponse)
+async def get_active_feedback_words(
+    prompt_service: PromptService = Depends(get_prompt_service)
+):
+    """
+    Get active feedback words (positions 6-11) for prompt generation.
+
+    Returns:
+        List of active feedback words with weights
+    """
+    try:
+        # Get active feedback words from PromptService
+        active_feedback_items = await prompt_service.get_feedback_active_words()
+
+        # Convert to FeedbackWord models
+        active_words = []
+        for i, item in enumerate(active_feedback_items):
+            key = list(item.keys())[0]
+            word = item[key]
+            weight = item.get("weight", 3)  # Default weight is 3
+            active_words.append(FeedbackWord(key=key, word=word, weight=weight))
+
+        return FeedbackActiveWordsResponse(
+            active_words=active_words,
+            count=len(active_words)
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Error getting active feedback words: {str(e)}"
+        )
+
+@router.get("/generate", response_model=GenerateFeedbackWordsResponse)
+async def generate_feedback_words(
+    prompt_service: PromptService = Depends(get_prompt_service)
+):
+    """
+    Generate 6 theme feedback words using AI.
+
+    Returns:
+        List of 6 theme words for feedback
+    """
+    try:
+        theme_words = await prompt_service.generate_theme_feedback_words()
+
+        if len(theme_words) != 6:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=f"Expected 6 theme words, got {len(theme_words)}"
+            )
+
+        return GenerateFeedbackWordsResponse(
+            theme_words=theme_words,
+            count=len(theme_words)
+        )
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Error generating feedback words: {str(e)}"
+        )
+
+@router.post("/rate", response_model=RateFeedbackWordsResponse)
+async def rate_feedback_words(
+    request: RateFeedbackWordsRequest,
+    prompt_service: PromptService = Depends(get_prompt_service)
+):
+    """
+    Rate feedback words and update feedback system.
+
+    Args:
+        request: Dictionary of word to rating (0-6)
+
+    Returns:
+        Updated feedback words
+    """
+    try:
+        feedback_words = await prompt_service.update_feedback_words(request.ratings)
+
+        return RateFeedbackWordsResponse(
+            feedback_words=feedback_words,
+            added_to_history=True
+        )
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Error rating feedback words: {str(e)}"
+        )
+
+@router.get("/history", response_model=FeedbackHistoricResponse)
+async def get_feedback_history(
+    prompt_service: PromptService = Depends(get_prompt_service)
+):
+    """
+    Get full feedback word history.
+
+    Returns:
+        Full feedback history with weights
+    """
+    try:
+        feedback_historic = await prompt_service.get_feedback_historic()
+
+        return FeedbackHistoricResponse(
+            feedback_history=feedback_historic,
+            count=len(feedback_historic)
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Error getting feedback history: {str(e)}"
+        )
+

backend/app/api/v1/endpoints/prompts.py

@@ -0,0 +1,196 @@
+"""
+Prompt-related API endpoints.
+"""
+
+from typing import List, Optional
+from fastapi import APIRouter, HTTPException, Depends, status
+from pydantic import BaseModel
+
+from app.services.prompt_service import PromptService
+from app.models.prompt import PromptResponse, PoolStatsResponse, HistoryStatsResponse
+
+# Create router
+router = APIRouter()
+
+# Response models
+class DrawPromptsResponse(BaseModel):
+    """Response model for drawing prompts."""
+    prompts: List[str]
+    count: int
+    remaining_in_pool: int
+
+class FillPoolResponse(BaseModel):
+    """Response model for filling prompt pool."""
+    added: int
+    total_in_pool: int
+    target_volume: int
+
+class SelectPromptRequest(BaseModel):
+    """Request model for selecting a prompt."""
+    prompt_text: str
+
+class SelectPromptResponse(BaseModel):
+    """Response model for selecting a prompt."""
+    selected_prompt: str
+    position_in_history: str  # e.g., "prompt00"
+    history_size: int
+
+# Service dependency
+async def get_prompt_service() -> PromptService:
+    """Dependency to get PromptService instance."""
+    return PromptService()
+
+@router.get("/draw", response_model=DrawPromptsResponse)
+async def draw_prompts(
+    count: Optional[int] = None,
+    prompt_service: PromptService = Depends(get_prompt_service)
+):
+    """
+    Draw prompts from the pool.
+
+    Args:
+        count: Number of prompts to draw (defaults to settings.NUM_PROMPTS_PER_SESSION)
+        prompt_service: PromptService instance
+
+    Returns:
+        List of prompts drawn from pool
+    """
+    try:
+        prompts = await prompt_service.draw_prompts_from_pool(count)
+        pool_size = prompt_service.get_pool_size()
+
+        return DrawPromptsResponse(
+            prompts=prompts,
+            count=len(prompts),
+            remaining_in_pool=pool_size
+        )
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Error drawing prompts: {str(e)}"
+        )
+
+@router.post("/fill-pool", response_model=FillPoolResponse)
+async def fill_prompt_pool(
+    prompt_service: PromptService = Depends(get_prompt_service)
+):
+    """
+    Fill the prompt pool to target volume using AI.
+
+    Returns:
+        Information about added prompts
+    """
+    try:
+        added_count = await prompt_service.fill_pool_to_target()
+        pool_size = prompt_service.get_pool_size()
+        target_volume = prompt_service.get_target_volume()
+
+        return FillPoolResponse(
+            added=added_count,
+            total_in_pool=pool_size,
+            target_volume=target_volume
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Error filling prompt pool: {str(e)}"
+        )
+
+@router.get("/stats", response_model=PoolStatsResponse)
+async def get_pool_stats(
+    prompt_service: PromptService = Depends(get_prompt_service)
+):
+    """
+    Get statistics about the prompt pool.
+
+    Returns:
+        Pool statistics
+    """
+    try:
+        return await prompt_service.get_pool_stats()
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Error getting pool stats: {str(e)}"
+        )
+
+@router.get("/history/stats", response_model=HistoryStatsResponse)
+async def get_history_stats(
+    prompt_service: PromptService = Depends(get_prompt_service)
+):
+    """
+    Get statistics about prompt history.
+
+    Returns:
+        History statistics
+    """
+    try:
+        return await prompt_service.get_history_stats()
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Error getting history stats: {str(e)}"
+        )
+
+@router.get("/history", response_model=List[PromptResponse])
+async def get_prompt_history(
+    limit: Optional[int] = None,
+    prompt_service: PromptService = Depends(get_prompt_service)
+):
+    """
+    Get prompt history.
+
+    Args:
+        limit: Maximum number of history items to return
+
+    Returns:
+        List of historical prompts
+    """
+    try:
+        return await prompt_service.get_prompt_history(limit)
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Error getting prompt history: {str(e)}"
+        )
+
+@router.post("/select", response_model=SelectPromptResponse)
+async def select_prompt(
+    request: SelectPromptRequest,
+    prompt_service: PromptService = Depends(get_prompt_service)
+):
+    """
+    Select a prompt to add to history.
+
+    Adds the provided prompt text to the historic prompts cyclic buffer.
+    The prompt will be added at position 0 (most recent), shifting existing prompts down.
+
+    Args:
+        request: SelectPromptRequest containing the prompt text
+
+    Returns:
+        Confirmation of prompt selection with position in history
+    """
+    try:
+        # Add the prompt to history
+        position_key = await prompt_service.add_prompt_to_history(request.prompt_text)
+
+        # Get updated history stats
+        history_stats = await prompt_service.get_history_stats()
+
+        return SelectPromptResponse(
+            selected_prompt=request.prompt_text,
+            position_in_history=position_key,
+            history_size=history_stats.total_prompts
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Error selecting prompt: {str(e)}"
+        )
+

backend/app/core/config.py

@@ -0,0 +1,76 @@
+"""
+Configuration settings for the application.
+Uses Pydantic settings management with environment variable support.
+"""
+
+import os
+from typing import List, Optional
+from pydantic_settings import BaseSettings
+from pydantic import AnyHttpUrl, validator
+
+
+class Settings(BaseSettings):
+    """Application settings."""
+
+    # API Settings
+    API_V1_STR: str = "/api/v1"
+    PROJECT_NAME: str = "Daily Journal Prompt Generator API"
+    VERSION: str = "1.0.0"
+    DEBUG: bool = False
+    ENVIRONMENT: str = "development"
+
+    # Server Settings
+    HOST: str = "0.0.0.0"
+    PORT: int = 8000
+
+    # CORS Settings
+    BACKEND_CORS_ORIGINS: List[AnyHttpUrl] = [
+        "http://localhost:3000",  # Frontend dev server
+        "http://localhost:80",    # Frontend production
+    ]
+
+    # API Keys
+    DEEPSEEK_API_KEY: Optional[str] = None
+    OPENAI_API_KEY: Optional[str] = None
+    API_BASE_URL: str = "https://api.deepseek.com"
+    MODEL: str = "deepseek-chat"
+
+    # Application Settings
+    MIN_PROMPT_LENGTH: int = 500
+    MAX_PROMPT_LENGTH: int = 1000
+    NUM_PROMPTS_PER_SESSION: int = 3
+    CACHED_POOL_VOLUME: int = 20
+    HISTORY_BUFFER_SIZE: int = 60
+    FEEDBACK_HISTORY_SIZE: int = 30
+
+    # File Paths (relative to project root)
+    DATA_DIR: str = "data"
+    PROMPT_TEMPLATE_PATH: str = "data/ds_prompt.txt"
+    FEEDBACK_TEMPLATE_PATH: str = "data/ds_feedback.txt"
+    SETTINGS_CONFIG_PATH: str = "data/settings.cfg"
+
+    # Data File Names (relative to DATA_DIR)
+    PROMPTS_HISTORIC_FILE: str = "prompts_historic.json"
+    PROMPTS_POOL_FILE: str = "prompts_pool.json"
+    FEEDBACK_HISTORIC_FILE: str = "feedback_historic.json"
+    # Note: feedback_words.json is deprecated and merged into feedback_historic.json
+
+    @validator("BACKEND_CORS_ORIGINS", pre=True)
+    def assemble_cors_origins(cls, v: str | List[str]) -> List[str] | str:
+        """Parse CORS origins from string or list."""
+        if isinstance(v, str) and not v.startswith("["):
+            return [i.strip() for i in v.split(",")]
+        elif isinstance(v, (list, str)):
+            return v
+        raise ValueError(v)
+
+    class Config:
+        """Pydantic configuration."""
+        env_file = ".env"
+        case_sensitive = True
+        extra = "ignore"
+
+
+# Create global settings instance
+settings = Settings()
+

backend/app/core/exception_handlers.py

@@ -0,0 +1,130 @@
+"""
+Exception handlers for the application.
+"""
+
+import logging
+from typing import Any, Dict
+from fastapi import FastAPI, Request, status
+from fastapi.responses import JSONResponse
+from fastapi.exceptions import RequestValidationError
+from pydantic import ValidationError as PydanticValidationError
+
+from app.core.exceptions import DailyJournalPromptException
+from app.core.logging import setup_logging
+
+logger = setup_logging()
+
+
+def setup_exception_handlers(app: FastAPI) -> None:
+    """Set up exception handlers for the FastAPI application."""
+
+    @app.exception_handler(DailyJournalPromptException)
+    async def daily_journal_prompt_exception_handler(
+        request: Request,
+        exc: DailyJournalPromptException,
+    ) -> JSONResponse:
+        """Handle DailyJournalPromptException."""
+        logger.error(f"DailyJournalPromptException: {exc.detail}")
+        return JSONResponse(
+            status_code=exc.status_code,
+            content={
+                "error": {
+                    "type": exc.__class__.__name__,
+                    "message": str(exc.detail),
+                    "status_code": exc.status_code,
+                }
+            },
+        )
+
+    @app.exception_handler(RequestValidationError)
+    async def request_validation_exception_handler(
+        request: Request,
+        exc: RequestValidationError,
+    ) -> JSONResponse:
+        """Handle request validation errors."""
+        logger.warning(f"RequestValidationError: {exc.errors()}")
+        return JSONResponse(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            content={
+                "error": {
+                    "type": "ValidationError",
+                    "message": "Invalid request data",
+                    "details": exc.errors(),
+                    "status_code": status.HTTP_422_UNPROCESSABLE_ENTITY,
+                }
+            },
+        )
+
+    @app.exception_handler(PydanticValidationError)
+    async def pydantic_validation_exception_handler(
+        request: Request,
+        exc: PydanticValidationError,
+    ) -> JSONResponse:
+        """Handle Pydantic validation errors."""
+        logger.warning(f"PydanticValidationError: {exc.errors()}")
+        return JSONResponse(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            content={
+                "error": {
+                    "type": "ValidationError",
+                    "message": "Invalid data format",
+                    "details": exc.errors(),
+                    "status_code": status.HTTP_422_UNPROCESSABLE_ENTITY,
+                }
+            },
+        )
+
+    @app.exception_handler(Exception)
+    async def generic_exception_handler(
+        request: Request,
+        exc: Exception,
+    ) -> JSONResponse:
+        """Handle all other exceptions."""
+        logger.exception(f"Unhandled exception: {exc}")
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content={
+                "error": {
+                    "type": "InternalServerError",
+                    "message": "An unexpected error occurred",
+                    "status_code": status.HTTP_500_INTERNAL_SERVER_ERROR,
+                }
+            },
+        )
+
+    @app.exception_handler(404)
+    async def not_found_exception_handler(
+        request: Request,
+        exc: Exception,
+    ) -> JSONResponse:
+        """Handle 404 Not Found errors."""
+        logger.warning(f"404 Not Found: {request.url}")
+        return JSONResponse(
+            status_code=status.HTTP_404_NOT_FOUND,
+            content={
+                "error": {
+                    "type": "NotFoundError",
+                    "message": f"Resource not found: {request.url}",
+                    "status_code": status.HTTP_404_NOT_FOUND,
+                }
+            },
+        )
+
+    @app.exception_handler(405)
+    async def method_not_allowed_exception_handler(
+        request: Request,
+        exc: Exception,
+    ) -> JSONResponse:
+        """Handle 405 Method Not Allowed errors."""
+        logger.warning(f"405 Method Not Allowed: {request.method} {request.url}")
+        return JSONResponse(
+            status_code=status.HTTP_405_METHOD_NOT_ALLOWED,
+            content={
+                "error": {
+                    "type": "MethodNotAllowedError",
+                    "message": f"Method {request.method} not allowed for {request.url}",
+                    "status_code": status.HTTP_405_METHOD_NOT_ALLOWED,
+                }
+            },
+        )
+

backend/app/core/exceptions.py

@@ -0,0 +1,172 @@
+"""
+Custom exceptions for the application.
+"""
+
+from typing import Any, Dict, Optional
+from fastapi import HTTPException, status
+
+
+class DailyJournalPromptException(HTTPException):
+    """Base exception for Daily Journal Prompt application."""
+
+    def __init__(
+        self,
+        status_code: int = status.HTTP_500_INTERNAL_SERVER_ERROR,
+        detail: Any = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> None:
+        super().__init__(status_code=status_code, detail=detail, headers=headers)
+
+
+class ValidationError(DailyJournalPromptException):
+    """Exception for validation errors."""
+
+    def __init__(
+        self,
+        detail: Any = "Validation error",
+        headers: Optional[Dict[str, str]] = None,
+    ) -> None:
+        super().__init__(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=detail,
+            headers=headers,
+        )
+
+
+class NotFoundError(DailyJournalPromptException):
+    """Exception for resource not found errors."""
+
+    def __init__(
+        self,
+        detail: Any = "Resource not found",
+        headers: Optional[Dict[str, str]] = None,
+    ) -> None:
+        super().__init__(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=detail,
+            headers=headers,
+        )
+
+
+class UnauthorizedError(DailyJournalPromptException):
+    """Exception for unauthorized access errors."""
+
+    def __init__(
+        self,
+        detail: Any = "Unauthorized access",
+        headers: Optional[Dict[str, str]] = None,
+    ) -> None:
+        super().__init__(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=detail,
+            headers=headers,
+        )
+
+
+class ForbiddenError(DailyJournalPromptException):
+    """Exception for forbidden access errors."""
+
+    def __init__(
+        self,
+        detail: Any = "Forbidden access",
+        headers: Optional[Dict[str, str]] = None,
+    ) -> None:
+        super().__init__(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail=detail,
+            headers=headers,
+        )
+
+
+class AIServiceError(DailyJournalPromptException):
+    """Exception for AI service errors."""
+
+    def __init__(
+        self,
+        detail: Any = "AI service error",
+        headers: Optional[Dict[str, str]] = None,
+    ) -> None:
+        super().__init__(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail=detail,
+            headers=headers,
+        )
+
+
+class DataServiceError(DailyJournalPromptException):
+    """Exception for data service errors."""
+
+    def __init__(
+        self,
+        detail: Any = "Data service error",
+        headers: Optional[Dict[str, str]] = None,
+    ) -> None:
+        super().__init__(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=detail,
+            headers=headers,
+        )
+
+
+class ConfigurationError(DailyJournalPromptException):
+    """Exception for configuration errors."""
+
+    def __init__(
+        self,
+        detail: Any = "Configuration error",
+        headers: Optional[Dict[str, str]] = None,
+    ) -> None:
+        super().__init__(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=detail,
+            headers=headers,
+        )
+
+
+class PromptPoolEmptyError(DailyJournalPromptException):
+    """Exception for empty prompt pool."""
+
+    def __init__(
+        self,
+        detail: Any = "Prompt pool is empty",
+        headers: Optional[Dict[str, str]] = None,
+    ) -> None:
+        super().__init__(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=detail,
+            headers=headers,
+        )
+
+
+class InsufficientPoolSizeError(DailyJournalPromptException):
+    """Exception for insufficient pool size."""
+
+    def __init__(
+        self,
+        current_size: int,
+        requested: int,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> None:
+        detail = f"Pool only has {current_size} prompts, requested {requested}"
+        super().__init__(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=detail,
+            headers=headers,
+        )
+
+
+class TemplateNotFoundError(DailyJournalPromptException):
+    """Exception for missing template files."""
+
+    def __init__(
+        self,
+        template_name: str,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> None:
+        detail = f"Template not found: {template_name}"
+        super().__init__(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=detail,
+            headers=headers,
+        )
+

backend/app/core/logging.py

@@ -0,0 +1,54 @@
+"""
+Logging configuration for the application.
+"""
+
+import logging
+import sys
+from typing import Optional
+
+from app.core.config import settings
+
+
+def setup_logging(
+    logger_name: str = "daily_journal_prompt",
+    log_level: Optional[str] = None,
+) -> logging.Logger:
+    """
+    Set up logging configuration.
+
+    Args:
+        logger_name: Name of the logger
+        log_level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+
+    Returns:
+        Configured logger instance
+    """
+    if log_level is None:
+        log_level = "DEBUG" if settings.DEBUG else "INFO"
+
+    # Create logger
+    logger = logging.getLogger(logger_name)
+    logger.setLevel(getattr(logging, log_level.upper()))
+
+    # Remove existing handlers to avoid duplicates
+    logger.handlers.clear()
+
+    # Create console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(getattr(logging, log_level.upper()))
+
+    # Create formatter
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S"
+    )
+    console_handler.setFormatter(formatter)
+
+    # Add handler to logger
+    logger.addHandler(console_handler)
+
+    # Prevent propagation to root logger
+    logger.propagate = False
+
+    return logger
+

backend/app/models/prompt.py

@@ -0,0 +1,88 @@
+"""
+Pydantic models for prompt-related data.
+"""
+
+from typing import List, Optional, Dict, Any
+from pydantic import BaseModel, Field
+
+
+class PromptResponse(BaseModel):
+    """Response model for a single prompt."""
+    key: str = Field(..., description="Prompt key (e.g., 'prompt00')")
+    text: str = Field(..., description="Prompt text content")
+    position: int = Field(..., description="Position in history (0 = most recent)")
+
+    class Config:
+        """Pydantic configuration."""
+        from_attributes = True
+
+
+class PoolStatsResponse(BaseModel):
+    """Response model for pool statistics."""
+    total_prompts: int = Field(..., description="Total prompts in pool")
+    prompts_per_session: int = Field(..., description="Prompts drawn per session")
+    target_pool_size: int = Field(..., description="Target pool volume")
+    available_sessions: int = Field(..., description="Available sessions in pool")
+    needs_refill: bool = Field(..., description="Whether pool needs refilling")
+
+
+class HistoryStatsResponse(BaseModel):
+    """Response model for history statistics."""
+    total_prompts: int = Field(..., description="Total prompts in history")
+    history_capacity: int = Field(..., description="Maximum history capacity")
+    available_slots: int = Field(..., description="Available slots in history")
+    is_full: bool = Field(..., description="Whether history is full")
+
+
+class FeedbackWord(BaseModel):
+    """Model for a feedback word with weight."""
+    key: str = Field(..., description="Feedback key (e.g., 'feedback00')")
+    word: str = Field(..., description="Feedback word")
+    weight: int = Field(..., ge=0, le=6, description="Weight from 0-6")
+
+
+class FeedbackHistoryItem(BaseModel):
+    """Model for a feedback history item (word only, no weight)."""
+    key: str = Field(..., description="Feedback key (e.g., 'feedback00')")
+    word: str = Field(..., description="Feedback word")
+
+
+class GeneratePromptsRequest(BaseModel):
+    """Request model for generating prompts."""
+    count: Optional[int] = Field(
+        None,
+        ge=1,
+        le=20,
+        description="Number of prompts to generate (defaults to settings)"
+    )
+    use_history: bool = Field(
+        True,
+        description="Whether to use historic prompts as context"
+    )
+    use_feedback: bool = Field(
+        True,
+        description="Whether to use feedback words as context"
+    )
+
+
+class GeneratePromptsResponse(BaseModel):
+    """Response model for generated prompts."""
+    prompts: List[str] = Field(..., description="Generated prompts")
+    count: int = Field(..., description="Number of prompts generated")
+    used_history: bool = Field(..., description="Whether history was used")
+    used_feedback: bool = Field(..., description="Whether feedback was used")
+
+
+class RateFeedbackWordsRequest(BaseModel):
+    """Request model for rating feedback words."""
+    ratings: Dict[str, int] = Field(
+        ...,
+        description="Dictionary of word to rating (0-6)"
+    )
+
+
+class RateFeedbackWordsResponse(BaseModel):
+    """Response model for rated feedback words."""
+    feedback_words: List[FeedbackWord] = Field(..., description="Rated feedback words")
+    added_to_history: bool = Field(..., description="Whether added to history")
+

backend/app/services/ai_service.py

@@ -0,0 +1,352 @@
+"""
+AI service for handling OpenAI/DeepSeek API calls.
+"""
+
+import json
+from typing import List, Dict, Any, Optional
+from openai import OpenAI, AsyncOpenAI
+
+from app.core.config import settings
+from app.core.logging import setup_logging
+
+logger = setup_logging()
+
+
+class AIService:
+    """Service for handling AI API calls."""
+
+    def __init__(self):
+        """Initialize AI service."""
+        api_key = settings.DEEPSEEK_API_KEY or settings.OPENAI_API_KEY
+        if not api_key:
+            raise ValueError("No API key found. Set DEEPSEEK_API_KEY or OPENAI_API_KEY in environment.")
+
+        self.client = AsyncOpenAI(
+            api_key=api_key,
+            base_url=settings.API_BASE_URL
+        )
+        self.model = settings.MODEL
+
+    def _clean_ai_response(self, response_content: str) -> str:
+        """
+        Clean up AI response content to handle common formatting issues.
+
+        Handles:
+        1. Leading/trailing backticks (```json ... ```)
+        2. Leading "json" string on its own line
+        3. Extra whitespace and newlines
+        """
+        content = response_content.strip()
+
+        # Remove leading/trailing backticks (```json ... ```)
+        if content.startswith('```'):
+            lines = content.split('\n')
+            if len(lines) > 1:
+                first_line = lines[0].strip()
+                if 'json' in first_line.lower() or first_line == '```':
+                    content = '\n'.join(lines[1:])
+
+            # Remove trailing backticks if present
+            if content.endswith('```'):
+                content = content[:-3].rstrip()
+
+        # Remove leading "json" string on its own line (case-insensitive)
+        lines = content.split('\n')
+        if len(lines) > 0:
+            first_line = lines[0].strip().lower()
+            if first_line == 'json':
+                content = '\n'.join(lines[1:])
+
+        # Also handle the case where "json" might be at the beginning of the first line
+        content = content.strip()
+        if content.lower().startswith('json\n'):
+            content = content[4:].strip()
+
+        return content.strip()
+
+    async def generate_prompts(
+        self,
+        prompt_template: str,
+        historic_prompts: List[Dict[str, str]],
+        feedback_words: Optional[List[Dict[str, Any]]] = None,
+        count: Optional[int] = None,
+        min_length: Optional[int] = None,
+        max_length: Optional[int] = None
+    ) -> List[str]:
+        """
+        Generate journal prompts using AI.
+
+        Args:
+            prompt_template: Base prompt template
+            historic_prompts: List of historic prompts for context
+            feedback_words: List of feedback words with weights
+            count: Number of prompts to generate
+            min_length: Minimum prompt length
+            max_length: Maximum prompt length
+
+        Returns:
+            List of generated prompts
+        """
+        if count is None:
+            count = settings.NUM_PROMPTS_PER_SESSION
+        if min_length is None:
+            min_length = settings.MIN_PROMPT_LENGTH
+        if max_length is None:
+            max_length = settings.MAX_PROMPT_LENGTH
+
+        # Prepare the full prompt
+        full_prompt = self._prepare_prompt(
+            prompt_template,
+            historic_prompts,
+            feedback_words,
+            count,
+            min_length,
+            max_length
+        )
+
+        logger.info(f"Generating {count} prompts with AI")
+
+        try:
+            # Call the AI API
+            response = await self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "You are a creative writing assistant that generates journal prompts. Always respond with valid JSON."
+                    },
+                    {
+                        "role": "user",
+                        "content": full_prompt
+                    }
+                ],
+                temperature=0.7,
+                max_tokens=2000
+            )
+
+            response_content = response.choices[0].message.content
+            logger.debug(f"AI response received: {len(response_content)} characters")
+
+            # Parse the response
+            prompts = self._parse_prompt_response(response_content, count)
+            logger.info(f"Successfully parsed {len(prompts)} prompts from AI response")
+
+            return prompts
+
+        except Exception as e:
+            logger.error(f"Error calling AI API: {e}")
+            logger.debug(f"Full prompt sent to API: {full_prompt[:500]}...")
+            raise
+
+    def _prepare_prompt(
+        self,
+        template: str,
+        historic_prompts: List[Dict[str, str]],
+        feedback_words: Optional[List[Dict[str, Any]]],
+        count: int,
+        min_length: int,
+        max_length: int
+    ) -> str:
+        """Prepare the full prompt with all context."""
+        # Add the instruction for the specific number of prompts
+        prompt_instruction = f"Please generate {count} writing prompts, each between {min_length} and {max_length} characters."
+
+        # Start with template and instruction
+        full_prompt = f"{template}\n\n{prompt_instruction}"
+
+        # Add historic prompts if available
+        if historic_prompts:
+            historic_context = json.dumps(historic_prompts, indent=2)
+            full_prompt = f"{full_prompt}\n\nPrevious prompts:\n{historic_context}"
+
+        # Add feedback words if available
+        if feedback_words:
+            feedback_context = json.dumps(feedback_words, indent=2)
+            full_prompt = f"{full_prompt}\n\nFeedback words:\n{feedback_context}"
+
+        return full_prompt
+
+    def _parse_prompt_response(self, response_content: str, expected_count: int) -> List[str]:
+        """Parse AI response to extract prompts."""
+        cleaned_content = self._clean_ai_response(response_content)
+
+        try:
+            data = json.loads(cleaned_content)
+
+            if isinstance(data, list):
+                if len(data) >= expected_count:
+                    return data[:expected_count]
+                else:
+                    logger.warning(f"AI returned {len(data)} prompts, expected {expected_count}")
+                    return data
+            elif isinstance(data, dict):
+                logger.warning("AI returned dictionary format, expected list format")
+                prompts = []
+                for i in range(expected_count):
+                    key = f"newprompt{i}"
+                    if key in data:
+                        prompts.append(data[key])
+                return prompts
+            else:
+                logger.warning(f"AI returned unexpected data type: {type(data)}")
+                return []
+
+        except json.JSONDecodeError:
+            logger.warning("AI response is not valid JSON, attempting to extract prompts...")
+            return self._extract_prompts_from_text(response_content, expected_count)
+
+    def _extract_prompts_from_text(self, text: str, expected_count: int) -> List[str]:
+        """Extract prompts from plain text response."""
+        lines = text.strip().split('\n')
+        prompts = []
+
+        for line in lines[:expected_count]:
+            line = line.strip()
+            if line and len(line) > 50:  # Reasonable minimum length for a prompt
+                prompts.append(line)
+
+        return prompts
+
+    async def generate_theme_feedback_words(
+        self,
+        feedback_template: str,
+        historic_prompts: List[Dict[str, str]],
+        queued_feedback_words: Optional[List[Dict[str, Any]]] = None,
+        historic_feedback_words: Optional[List[Dict[str, Any]]] = None
+    ) -> List[str]:
+        """
+        Generate theme feedback words using AI.
+
+        Args:
+            feedback_template: Feedback analysis template
+            historic_prompts: List of historic prompts for context
+            queued_feedback_words: Queued feedback words with weights (positions 0-5)
+            historic_feedback_words: Historic feedback words with weights (all positions)
+
+        Returns:
+            List of 6 theme words
+        """
+        # Prepare the full prompt
+        full_prompt = self._prepare_feedback_prompt(
+            feedback_template,
+            historic_prompts,
+            queued_feedback_words,
+            historic_feedback_words
+        )
+
+        logger.info("Generating theme feedback words with AI")
+
+        try:
+            # Call the AI API
+            response = await self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "You are a creative writing assistant that analyzes writing prompts. Always respond with valid JSON."
+                    },
+                    {
+                        "role": "user",
+                        "content": full_prompt
+                    }
+                ],
+                temperature=0.7,
+                max_tokens=1000
+            )
+
+            response_content = response.choices[0].message.content
+            logger.debug(f"AI feedback response received: {len(response_content)} characters")
+
+            # Parse the response
+            theme_words = self._parse_feedback_response(response_content)
+            logger.info(f"Successfully parsed {len(theme_words)} theme words from AI response")
+
+            if len(theme_words) != 6:
+                logger.warning(f"Expected 6 theme words, got {len(theme_words)}")
+
+            return theme_words
+
+        except Exception as e:
+            logger.error(f"Error calling AI API for feedback: {e}")
+            logger.debug(f"Full feedback prompt sent to API: {full_prompt[:500]}...")
+            raise
+
+    def _prepare_feedback_prompt(
+        self,
+        template: str,
+        historic_prompts: List[Dict[str, str]],
+        queued_feedback_words: Optional[List[Dict[str, Any]]],
+        historic_feedback_words: Optional[List[Dict[str, Any]]]
+    ) -> str:
+        """Prepare the full feedback prompt."""
+        if not historic_prompts:
+            raise ValueError("No historic prompts available for feedback analysis")
+
+        full_prompt = f"{template}\n\nPrevious prompts:\n{json.dumps(historic_prompts, indent=2)}"
+
+        # Add queued feedback words if available (these have user-adjusted weights)
+        if queued_feedback_words:
+            # Extract just the words and weights for clarity
+            queued_words_with_weights = []
+            for item in queued_feedback_words:
+                key = list(item.keys())[0]
+                word = item[key]
+                weight = item.get("weight", 3)
+                queued_words_with_weights.append({"word": word, "weight": weight})
+
+            feedback_context = json.dumps(queued_words_with_weights, indent=2)
+            full_prompt = f"{full_prompt}\n\nQueued feedback themes (with user-adjusted weights):\n{feedback_context}"
+
+        # Add historic feedback words if available (these may have weights too)
+        if historic_feedback_words:
+            # Extract just the words for historic context
+            historic_words = []
+            for item in historic_feedback_words:
+                key = list(item.keys())[0]
+                word = item[key]
+                historic_words.append(word)
+
+            feedback_historic_context = json.dumps(historic_words, indent=2)
+            full_prompt = f"{full_prompt}\n\nHistoric feedback themes (just words):\n{feedback_historic_context}"
+
+        return full_prompt
+
+    def _parse_feedback_response(self, response_content: str) -> List[str]:
+        """Parse AI response to extract theme words."""
+        cleaned_content = self._clean_ai_response(response_content)
+
+        try:
+            data = json.loads(cleaned_content)
+
+            if isinstance(data, list):
+                theme_words = []
+                for word in data:
+                    if isinstance(word, str):
+                        theme_words.append(word.lower().strip())
+                    else:
+                        theme_words.append(str(word).lower().strip())
+                return theme_words
+            else:
+                logger.warning(f"AI returned unexpected data type for feedback: {type(data)}")
+                return []
+
+        except json.JSONDecodeError:
+            logger.warning("AI feedback response is not valid JSON, attempting to extract theme words...")
+            return self._extract_theme_words_from_text(response_content)
+
+    def _extract_theme_words_from_text(self, text: str) -> List[str]:
+        """Extract theme words from plain text response."""
+        lines = text.strip().split('\n')
+        theme_words = []
+
+        for line in lines:
+            line = line.strip()
+            if line and len(line) < 50:  # Theme words should be short
+                words = [w.lower().strip('.,;:!?()[]{}\"\'') for w in line.split()]
+                theme_words.extend(words)
+
+            if len(theme_words) >= 6:
+                break
+
+        return theme_words[:6]
+

backend/app/services/data_service.py

@@ -0,0 +1,191 @@
+"""
+Data service for handling JSON file operations.
+"""
+
+import json
+import os
+import aiofiles
+from typing import Any, List, Dict, Optional
+from pathlib import Path
+
+from app.core.config import settings
+from app.core.logging import setup_logging
+
+logger = setup_logging()
+
+
+class DataService:
+    """Service for handling data persistence in JSON files."""
+
+    def __init__(self):
+        """Initialize data service."""
+        self.data_dir = Path(settings.DATA_DIR)
+        self.data_dir.mkdir(exist_ok=True)
+
+    def _get_file_path(self, filename: str) -> Path:
+        """Get full path for a data file."""
+        return self.data_dir / filename
+
+    async def load_json(self, filename: str, default: Any = None) -> Any:
+        """
+        Load JSON data from file.
+
+        Args:
+            filename: Name of the JSON file
+            default: Default value if file doesn't exist or is invalid
+
+        Returns:
+            Loaded data or default value
+        """
+        file_path = self._get_file_path(filename)
+
+        if not file_path.exists():
+            logger.warning(f"File {filename} not found, returning default")
+            return default if default is not None else []
+
+        try:
+            async with aiofiles.open(file_path, 'r', encoding='utf-8') as f:
+                content = await f.read()
+                return json.loads(content)
+        except json.JSONDecodeError as e:
+            logger.error(f"Error decoding JSON from {filename}: {e}")
+            return default if default is not None else []
+        except Exception as e:
+            logger.error(f"Error loading {filename}: {e}")
+            return default if default is not None else []
+
+    async def save_json(self, filename: str, data: Any) -> bool:
+        """
+        Save data to JSON file.
+
+        Args:
+            filename: Name of the JSON file
+            data: Data to save
+
+        Returns:
+            True if successful, False otherwise
+        """
+        file_path = self._get_file_path(filename)
+
+        try:
+            # Create backup of existing file if it exists
+            if file_path.exists():
+                backup_path = file_path.with_suffix('.json.bak')
+                async with aiofiles.open(file_path, 'r', encoding='utf-8') as src:
+                    async with aiofiles.open(backup_path, 'w', encoding='utf-8') as dst:
+                        await dst.write(await src.read())
+
+            # Save new data
+            async with aiofiles.open(file_path, 'w', encoding='utf-8') as f:
+                await f.write(json.dumps(data, indent=2, ensure_ascii=False))
+
+            logger.info(f"Saved data to {filename}")
+            return True
+        except Exception as e:
+            logger.error(f"Error saving {filename}: {e}")
+            return False
+
+    async def load_prompts_historic(self) -> List[Dict[str, str]]:
+        """Load historic prompts from JSON file."""
+        return await self.load_json(
+            settings.PROMPTS_HISTORIC_FILE,
+            default=[]
+        )
+
+    async def save_prompts_historic(self, prompts: List[Dict[str, str]]) -> bool:
+        """Save historic prompts to JSON file."""
+        return await self.save_json(settings.PROMPTS_HISTORIC_FILE, prompts)
+
+    async def load_prompts_pool(self) -> List[str]:
+        """Load prompt pool from JSON file."""
+        return await self.load_json(
+            settings.PROMPTS_POOL_FILE,
+            default=[]
+        )
+
+    async def save_prompts_pool(self, prompts: List[str]) -> bool:
+        """Save prompt pool to JSON file."""
+        return await self.save_json(settings.PROMPTS_POOL_FILE, prompts)
+
+    async def load_feedback_historic(self) -> List[Dict[str, Any]]:
+        """Load historic feedback words from JSON file."""
+        return await self.load_json(
+            settings.FEEDBACK_HISTORIC_FILE,
+            default=[]
+        )
+
+    async def save_feedback_historic(self, feedback_words: List[Dict[str, Any]]) -> bool:
+        """Save historic feedback words to JSON file."""
+        return await self.save_json(settings.FEEDBACK_HISTORIC_FILE, feedback_words)
+
+    async def get_feedback_queued_words(self) -> List[Dict[str, Any]]:
+        """Get queued feedback words (positions 0-5) for user weighting."""
+        feedback_historic = await self.load_feedback_historic()
+        return feedback_historic[:6] if len(feedback_historic) >= 6 else feedback_historic
+
+    async def get_feedback_active_words(self) -> List[Dict[str, Any]]:
+        """Get active feedback words (positions 6-11) for prompt generation."""
+        feedback_historic = await self.load_feedback_historic()
+        if len(feedback_historic) >= 12:
+            return feedback_historic[6:12]
+        elif len(feedback_historic) > 6:
+            return feedback_historic[6:]
+        else:
+            return []
+
+    async def load_prompt_template(self) -> str:
+        """Load prompt template from file."""
+        template_path = Path(settings.PROMPT_TEMPLATE_PATH)
+        if not template_path.exists():
+            logger.error(f"Prompt template not found at {template_path}")
+            return ""
+
+        try:
+            async with aiofiles.open(template_path, 'r', encoding='utf-8') as f:
+                return await f.read()
+        except Exception as e:
+            logger.error(f"Error loading prompt template: {e}")
+            return ""
+
+    async def load_feedback_template(self) -> str:
+        """Load feedback template from file."""
+        template_path = Path(settings.FEEDBACK_TEMPLATE_PATH)
+        if not template_path.exists():
+            logger.error(f"Feedback template not found at {template_path}")
+            return ""
+
+        try:
+            async with aiofiles.open(template_path, 'r', encoding='utf-8') as f:
+                return await f.read()
+        except Exception as e:
+            logger.error(f"Error loading feedback template: {e}")
+            return ""
+
+    async def load_settings_config(self) -> Dict[str, Any]:
+        """Load settings from config file."""
+        config_path = Path(settings.SETTINGS_CONFIG_PATH)
+        if not config_path.exists():
+            logger.warning(f"Settings config not found at {config_path}")
+            return {}
+
+        try:
+            import configparser
+            config = configparser.ConfigParser()
+            config.read(config_path)
+
+            settings_dict = {}
+            if 'prompts' in config:
+                prompts_section = config['prompts']
+                settings_dict['min_length'] = int(prompts_section.get('min_length', settings.MIN_PROMPT_LENGTH))
+                settings_dict['max_length'] = int(prompts_section.get('max_length', settings.MAX_PROMPT_LENGTH))
+                settings_dict['num_prompts'] = int(prompts_section.get('num_prompts', settings.NUM_PROMPTS_PER_SESSION))
+
+            if 'prefetch' in config:
+                prefetch_section = config['prefetch']
+                settings_dict['cached_pool_volume'] = int(prefetch_section.get('cached_pool_volume', settings.CACHED_POOL_VOLUME))
+
+            return settings_dict
+        except Exception as e:
+            logger.error(f"Error loading settings config: {e}")
+            return {}
+

backend/app/services/prompt_service.py

@@ -0,0 +1,470 @@
+"""
+Main prompt service that orchestrates prompt generation and management.
+"""
+
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+
+from app.core.config import settings
+from app.core.logging import setup_logging
+from app.services.data_service import DataService
+from app.services.ai_service import AIService
+from app.models.prompt import (
+    PromptResponse,
+    PoolStatsResponse,
+    HistoryStatsResponse,
+    FeedbackWord,
+    FeedbackHistoryItem
+)
+
+logger = setup_logging()
+
+
+class PromptService:
+    """Main service for prompt generation and management."""
+
+    def __init__(self):
+        """Initialize prompt service with dependencies."""
+        self.data_service = DataService()
+        self.ai_service = AIService()
+
+        # Load settings from config file
+        self.settings_config = {}
+
+        # Cache for loaded data
+        self._prompts_historic_cache = None
+        self._prompts_pool_cache = None
+        self._feedback_words_cache = None
+        self._feedback_historic_cache = None
+        self._prompt_template_cache = None
+        self._feedback_template_cache = None
+
+    async def _load_settings_config(self):
+        """Load settings from config file if not already loaded."""
+        if not self.settings_config:
+            self.settings_config = await self.data_service.load_settings_config()
+
+    async def _get_setting(self, key: str, default: Any) -> Any:
+        """Get setting value, preferring config file over environment."""
+        await self._load_settings_config()
+        return self.settings_config.get(key, default)
+
+    # Data loading methods with caching
+    async def get_prompts_historic(self) -> List[Dict[str, str]]:
+        """Get historic prompts with caching."""
+        if self._prompts_historic_cache is None:
+            self._prompts_historic_cache = await self.data_service.load_prompts_historic()
+        return self._prompts_historic_cache
+
+    async def get_prompts_pool(self) -> List[str]:
+        """Get prompt pool with caching."""
+        if self._prompts_pool_cache is None:
+            self._prompts_pool_cache = await self.data_service.load_prompts_pool()
+        return self._prompts_pool_cache
+
+    async def get_feedback_historic(self) -> List[Dict[str, Any]]:
+        """Get historic feedback words with caching."""
+        if self._feedback_historic_cache is None:
+            self._feedback_historic_cache = await self.data_service.load_feedback_historic()
+        return self._feedback_historic_cache
+
+    async def get_feedback_queued_words(self) -> List[Dict[str, Any]]:
+        """Get queued feedback words (positions 0-5) for user weighting."""
+        feedback_historic = await self.get_feedback_historic()
+        return feedback_historic[:6] if len(feedback_historic) >= 6 else feedback_historic
+
+    async def get_feedback_active_words(self) -> List[Dict[str, Any]]:
+        """Get active feedback words (positions 6-11) for prompt generation."""
+        feedback_historic = await self.get_feedback_historic()
+        if len(feedback_historic) >= 12:
+            return feedback_historic[6:12]
+        elif len(feedback_historic) > 6:
+            return feedback_historic[6:]
+        else:
+            return []
+
+    async def get_prompt_template(self) -> str:
+        """Get prompt template with caching."""
+        if self._prompt_template_cache is None:
+            self._prompt_template_cache = await self.data_service.load_prompt_template()
+        return self._prompt_template_cache
+
+    async def get_feedback_template(self) -> str:
+        """Get feedback template with caching."""
+        if self._feedback_template_cache is None:
+            self._feedback_template_cache = await self.data_service.load_feedback_template()
+        return self._feedback_template_cache
+
+    # Core prompt operations
+    async def draw_prompts_from_pool(self, count: Optional[int] = None) -> List[str]:
+        """
+        Draw prompts from the pool.
+
+        Args:
+            count: Number of prompts to draw
+
+        Returns:
+            List of drawn prompts
+        """
+        if count is None:
+            count = await self._get_setting('num_prompts', settings.NUM_PROMPTS_PER_SESSION)
+
+        pool = await self.get_prompts_pool()
+
+        if len(pool) < count:
+            raise ValueError(
+                f"Pool only has {len(pool)} prompts, requested {count}. "
+                f"Use fill-pool endpoint to add more prompts."
+            )
+
+        # Draw prompts from the beginning of the pool
+        drawn_prompts = pool[:count]
+        remaining_pool = pool[count:]
+
+        # Update cache and save
+        self._prompts_pool_cache = remaining_pool
+        await self.data_service.save_prompts_pool(remaining_pool)
+
+        logger.info(f"Drew {len(drawn_prompts)} prompts from pool, {len(remaining_pool)} remaining")
+        return drawn_prompts
+
+    async def fill_pool_to_target(self) -> int:
+        """
+        Fill the prompt pool to target volume.
+
+        Returns:
+            Number of prompts added
+        """
+        target_volume = await self._get_setting('cached_pool_volume', settings.CACHED_POOL_VOLUME)
+        current_pool = await self.get_prompts_pool()
+        current_size = len(current_pool)
+
+        if current_size >= target_volume:
+            logger.info(f"Pool already at target volume: {current_size}/{target_volume}")
+            return 0
+
+        prompts_needed = target_volume - current_size
+        logger.info(f"Generating {prompts_needed} prompts to fill pool")
+
+        # Generate prompts
+        new_prompts = await self.generate_prompts(
+            count=prompts_needed,
+            use_history=True,
+            use_feedback=True
+        )
+
+        if not new_prompts:
+            logger.error("Failed to generate prompts for pool")
+            return 0
+
+        # Add to pool
+        updated_pool = current_pool + new_prompts
+        self._prompts_pool_cache = updated_pool
+        await self.data_service.save_prompts_pool(updated_pool)
+
+        added_count = len(new_prompts)
+        logger.info(f"Added {added_count} prompts to pool, new size: {len(updated_pool)}")
+        return added_count
+
+    async def generate_prompts(
+        self,
+        count: Optional[int] = None,
+        use_history: bool = True,
+        use_feedback: bool = True
+    ) -> List[str]:
+        """
+        Generate new prompts using AI.
+
+        Args:
+            count: Number of prompts to generate
+            use_history: Whether to use historic prompts as context
+            use_feedback: Whether to use feedback words as context
+
+        Returns:
+            List of generated prompts
+        """
+        if count is None:
+            count = await self._get_setting('num_prompts', settings.NUM_PROMPTS_PER_SESSION)
+
+        min_length = await self._get_setting('min_length', settings.MIN_PROMPT_LENGTH)
+        max_length = await self._get_setting('max_length', settings.MAX_PROMPT_LENGTH)
+
+        # Load templates and data
+        prompt_template = await self.get_prompt_template()
+        if not prompt_template:
+            raise ValueError("Prompt template not found")
+
+        historic_prompts = await self.get_prompts_historic() if use_history else []
+        feedback_words = await self.get_feedback_active_words() if use_feedback else None
+
+        # Generate prompts using AI
+        new_prompts = await self.ai_service.generate_prompts(
+            prompt_template=prompt_template,
+            historic_prompts=historic_prompts,
+            feedback_words=feedback_words,
+            count=count,
+            min_length=min_length,
+            max_length=max_length
+        )
+
+        return new_prompts
+
+    async def add_prompt_to_history(self, prompt_text: str) -> str:
+        """
+        Add a prompt to the historic prompts cyclic buffer.
+
+        Args:
+            prompt_text: Prompt text to add
+
+        Returns:
+            Position key of the added prompt (e.g., "prompt00")
+        """
+        historic_prompts = await self.get_prompts_historic()
+
+        # Create the new prompt object
+        new_prompt = {"prompt00": prompt_text}
+
+        # Shift all existing prompts down by one position
+        updated_prompts = [new_prompt]
+
+        # Add all existing prompts, shifting their numbers down by one
+        for i, prompt_dict in enumerate(historic_prompts):
+            if i >= settings.HISTORY_BUFFER_SIZE - 1:  # Keep only HISTORY_BUFFER_SIZE prompts
+                break
+
+            # Get the prompt text
+            prompt_key = list(prompt_dict.keys())[0]
+            prompt_text = prompt_dict[prompt_key]
+
+            # Create prompt with new number (shifted down by one)
+            new_prompt_key = f"prompt{i+1:02d}"
+            updated_prompts.append({new_prompt_key: prompt_text})
+
+        # Update cache and save
+        self._prompts_historic_cache = updated_prompts
+        await self.data_service.save_prompts_historic(updated_prompts)
+
+        logger.info(f"Added prompt to history as prompt00, history size: {len(updated_prompts)}")
+        return "prompt00"
+
+    # Statistics methods
+    async def get_pool_stats(self) -> PoolStatsResponse:
+        """Get statistics about the prompt pool."""
+        pool = await self.get_prompts_pool()
+        total_prompts = len(pool)
+
+        prompts_per_session = await self._get_setting('num_prompts', settings.NUM_PROMPTS_PER_SESSION)
+        target_pool_size = await self._get_setting('cached_pool_volume', settings.CACHED_POOL_VOLUME)
+
+        available_sessions = total_prompts // prompts_per_session if prompts_per_session > 0 else 0
+        needs_refill = total_prompts < target_pool_size
+
+        return PoolStatsResponse(
+            total_prompts=total_prompts,
+            prompts_per_session=prompts_per_session,
+            target_pool_size=target_pool_size,
+            available_sessions=available_sessions,
+            needs_refill=needs_refill
+        )
+
+    async def get_history_stats(self) -> HistoryStatsResponse:
+        """Get statistics about prompt history."""
+        historic_prompts = await self.get_prompts_historic()
+        total_prompts = len(historic_prompts)
+
+        history_capacity = settings.HISTORY_BUFFER_SIZE
+        available_slots = max(0, history_capacity - total_prompts)
+        is_full = total_prompts >= history_capacity
+
+        return HistoryStatsResponse(
+            total_prompts=total_prompts,
+            history_capacity=history_capacity,
+            available_slots=available_slots,
+            is_full=is_full
+        )
+
+    async def get_prompt_history(self, limit: Optional[int] = None) -> List[PromptResponse]:
+        """
+        Get prompt history.
+
+        Args:
+            limit: Maximum number of history items to return
+
+        Returns:
+            List of historical prompts
+        """
+        historic_prompts = await self.get_prompts_historic()
+
+        if limit is not None:
+            historic_prompts = historic_prompts[:limit]
+
+        prompts = []
+        for i, prompt_dict in enumerate(historic_prompts):
+            prompt_key = list(prompt_dict.keys())[0]
+            prompt_text = prompt_dict[prompt_key]
+
+            prompts.append(PromptResponse(
+                key=prompt_key,
+                text=prompt_text,
+                position=i
+            ))
+
+        return prompts
+
+    # Feedback operations
+    async def generate_theme_feedback_words(self) -> List[str]:
+        """Generate 6 theme feedback words using AI."""
+        feedback_template = await self.get_feedback_template()
+        if not feedback_template:
+            raise ValueError("Feedback template not found")
+
+        historic_prompts = await self.get_prompts_historic()
+        if not historic_prompts:
+            raise ValueError("No historic prompts available for feedback analysis")
+
+        queued_feedback_words = await self.get_feedback_queued_words()
+        historic_feedback_words = await self.get_feedback_historic()
+
+        theme_words = await self.ai_service.generate_theme_feedback_words(
+            feedback_template=feedback_template,
+            historic_prompts=historic_prompts,
+            queued_feedback_words=queued_feedback_words,
+            historic_feedback_words=historic_feedback_words
+        )
+
+        return theme_words
+
+    async def update_feedback_words(self, ratings: Dict[str, int]) -> List[FeedbackWord]:
+        """
+        Update feedback words with new ratings.
+
+        Args:
+            ratings: Dictionary of word to rating (0-6)
+
+        Returns:
+            Updated feedback words
+        """
+        if len(ratings) != 6:
+            raise ValueError(f"Expected 6 ratings, got {len(ratings)}")
+
+        # Get current feedback historic
+        feedback_historic = await self.get_feedback_historic()
+
+        # Update weights for queued words (positions 0-5)
+        for i, (word, rating) in enumerate(ratings.items()):
+            if not 0 <= rating <= 6:
+                raise ValueError(f"Rating for '{word}' must be between 0 and 6, got {rating}")
+
+            if i < len(feedback_historic):
+                # Get the existing item and its key
+                existing_item = feedback_historic[i]
+                # Find the feedback key (not "weight")
+                existing_keys = [k for k in existing_item.keys() if k != "weight"]
+                if existing_keys:
+                    existing_key = existing_keys[0]
+                else:
+                    # Fallback to generating a key
+                    existing_key = f"feedback{i:02d}"
+
+                # Update the item with existing key, same word, new weight
+                feedback_historic[i] = {
+                    existing_key: word,
+                    "weight": rating
+                }
+            else:
+                # If we don't have enough items, add a new one
+                feedback_key = f"feedback{i:02d}"
+                feedback_historic.append({
+                    feedback_key: word,
+                    "weight": rating
+                })
+
+        # Update cache and save
+        self._feedback_historic_cache = feedback_historic
+        await self.data_service.save_feedback_historic(feedback_historic)
+
+        # Generate new feedback words and insert at position 0
+        await self._generate_and_insert_new_feedback_words(feedback_historic)
+
+        # Get updated queued words for response
+        updated_queued_words = feedback_historic[:6] if len(feedback_historic) >= 6 else feedback_historic
+
+        # Convert to FeedbackWord models
+        feedback_words = []
+        for i, item in enumerate(updated_queued_words):
+            key = list(item.keys())[0]
+            word = item[key]
+            weight = item.get("weight", 3)  # Default weight is 3
+            feedback_words.append(FeedbackWord(key=key, word=word, weight=weight))
+
+        logger.info(f"Updated feedback words with {len(feedback_words)} items")
+        return feedback_words
+
+    async def _generate_and_insert_new_feedback_words(self, feedback_historic: List[Dict[str, Any]]) -> None:
+        """Generate new feedback words and insert at position 0."""
+        try:
+            # Generate 6 new feedback words
+            new_words = await self.generate_theme_feedback_words()
+
+            if len(new_words) != 6:
+                logger.warning(f"Expected 6 new feedback words, got {len(new_words)}. Not inserting.")
+                return
+
+            # Create new feedback items with default weight of 3
+            new_feedback_items = []
+            for i, word in enumerate(new_words):
+                # Generate unique key based on position in buffer
+                # New items will be at positions 0-5, so use those indices
+                feedback_key = f"feedback{i:02d}"
+                new_feedback_items.append({
+                    feedback_key: word,
+                    "weight": 3  # Default weight
+                })
+
+            # Insert new words at position 0
+            # Keep only FEEDBACK_HISTORY_SIZE items total
+            updated_feedback_historic = new_feedback_items + feedback_historic
+            if len(updated_feedback_historic) > settings.FEEDBACK_HISTORY_SIZE:
+                updated_feedback_historic = updated_feedback_historic[:settings.FEEDBACK_HISTORY_SIZE]
+
+            # Re-key all items to ensure unique keys
+            for i, item in enumerate(updated_feedback_historic):
+                # Get the word and weight from the current item
+                # Each item has structure: {"feedbackXX": "word", "weight": N}
+                old_key = list(item.keys())[0]
+                if old_key == "weight":
+                    # Handle edge case where weight might be first key
+                    continue
+                word = item[old_key]
+                weight = item.get("weight", 3)
+
+                # Create new key based on position
+                new_key = f"feedback{i:02d}"
+
+                # Replace the item with new structure
+                updated_feedback_historic[i] = {
+                    new_key: word,
+                    "weight": weight
+                }
+
+            # Update cache and save
+            self._feedback_historic_cache = updated_feedback_historic
+            await self.data_service.save_feedback_historic(updated_feedback_historic)
+
+            logger.info(f"Inserted 6 new feedback words at position 0, history size: {len(updated_feedback_historic)}")
+
+        except Exception as e:
+            logger.error(f"Error generating and inserting new feedback words: {e}")
+            raise
+
+    # Utility methods for API endpoints
+    def get_pool_size(self) -> int:
+        """Get current pool size (synchronous for API endpoints)."""
+        if self._prompts_pool_cache is None:
+            raise RuntimeError("Pool cache not initialized")
+        return len(self._prompts_pool_cache)
+
+    def get_target_volume(self) -> int:
+        """Get target pool volume (synchronous for API endpoints)."""
+        return settings.CACHED_POOL_VOLUME
+

backend/main.py

@@ -0,0 +1,90 @@
+"""
+Daily Journal Prompt Generator - FastAPI Backend
+Main application entry point
+"""
+
+import os
+from pathlib import Path
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+
+from app.api.v1.api import api_router
+from app.core.config import settings
+from app.core.logging import setup_logging
+from app.core.exception_handlers import setup_exception_handlers
+
+# Setup logging
+logger = setup_logging()
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Lifespan context manager for startup and shutdown events."""
+    # Startup
+    logger.info("Starting Daily Journal Prompt Generator API")
+    logger.info(f"Environment: {settings.ENVIRONMENT}")
+    logger.info(f"Debug mode: {settings.DEBUG}")
+
+    # Create data directory if it doesn't exist
+    data_dir = Path(settings.DATA_DIR)
+    data_dir.mkdir(exist_ok=True)
+    logger.info(f"Data directory: {data_dir.absolute()}")
+
+    yield
+
+    # Shutdown
+    logger.info("Shutting down Daily Journal Prompt Generator API")
+
+# Create FastAPI app
+app = FastAPI(
+    title="Daily Journal Prompt Generator API",
+    description="API for generating and managing journal writing prompts",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+    lifespan=lifespan
+)
+
+# Setup exception handlers
+setup_exception_handlers(app)
+
+# Configure CORS
+if settings.BACKEND_CORS_ORIGINS:
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=[str(origin) for origin in settings.BACKEND_CORS_ORIGINS],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+# Include API router
+app.include_router(api_router, prefix="/api/v1")
+
+@app.get("/")
+async def root():
+    """Root endpoint with API information."""
+    return {
+        "name": "Daily Journal Prompt Generator API",
+        "version": "1.0.0",
+        "description": "API for generating and managing journal writing prompts",
+        "docs": "/docs",
+        "redoc": "/redoc",
+        "health": "/health"
+    }
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint."""
+    return {"status": "healthy", "service": "daily-journal-prompt-api"}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "main:app",
+        host=settings.HOST,
+        port=settings.PORT,
+        reload=settings.DEBUG,
+        log_level="info"
+    )
+

backend/requirements.txt

@@ -0,0 +1,8 @@
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+pydantic>=2.0.0
+pydantic-settings>=2.0.0
+python-dotenv>=1.0.0
+openai>=1.0.0
+aiofiles>=23.0.0
+

data/ds_feedback.txt

@@ -2,15 +2,13 @@ Request for generation of writing prompts for journaling
 
 Payload:
 The previous 60 prompts have been provided as a JSON array for reference.
-The current 6 feedback themes have been provided. You will not re-use any of these most-recently used words here.
+The previous 30 feedback themes are also provided. You should avoid re-using these words.
-The previous 30 feedback themes are also provided. You should try to avoid re-using these unless it really makes sense to.
 
 Guidelines:
+The six total returned words should be unique.
 Using the attached JSON of writing prompts, you should try to pick out 4 unique and intentionally vague single-word themes that apply to some portion of the list. They can range from common to uncommon words.
 Then add 2 more single word divergent themes that are less related to the historic prompts and are somewhat different from the other 4 for a total of 6 words.
-These 2 divergent themes give the user the option to steer away from existing themes.
+These 2 divergent themes give the user the option to steer away from existing themes, so be bold and unique.
-Examples for the divergent themes could be the option to add a theme like technology when the other themes are related to beauty, or mortality when the other themes are very positive.
-Be creative, don't just use my example.
 A very high temperature AI response is warranted here to generate a large vocabulary.
 
 Expected Output:

data/ds_prompt.txt

@@ -2,7 +2,7 @@ Request for generation of writing prompts for journaling
 
 Payload:
 The previous 60 prompts have been provided as a JSON array for reference.
-Some vague feedback themes have been provided, each having a weight value from 0 to 6.
+Some vague feedback themes have been provided, each having a weight value from 1 to 6.
 
 Guidelines:
 Please generate some number of individual writing prompts in English following these guidelines.
@@ -15,9 +15,12 @@ The history will allow for reducing repetition, however some thematic overlap is
 As the user discards prompts, the themes will be very slowly steered, so it's okay to take some inspiration from the history.
 
 Feedback Themes:
-A JSON of single-word feedback themes is provided with each having a weight value from 0 to 6.
+A JSON of single-word feedback themes is provided with each having a weight value from 1 to 6.
 Consider these weighted themes only rarely when creating a new writing prompt. Most prompts should be created with full creative freedom.
-Only gently influence writing prompts with these. It is better to have all generated prompts ignore a theme than have many reference a theme overtly.
+Only gently influence writing prompts with these. It is better to have all generated prompts ignore a theme than have many reference a theme too overtly.
+If a theme word is submitted with a weight of 1, there should be a fair chance that no generated prompts consider it.
+If a theme word is submitted with a weight of 6, there should be a high chance at least one generated prompt considers it.
+THESE ARE NOT SIMPLY WORDS TO INSERT INTO PROMPTS. They are themes that should only be felt in the background.
 
 Expected Output:
 Output as a JSON list with the requested number of elements.

data/feedback_historic.json

@@ -0,0 +1,122 @@
+[
+  {
+    "feedback00": "labyrinthine",
+    "weight": 3
+  },
+  {
+    "feedback01": "verdant",
+    "weight": 3
+  },
+  {
+    "feedback02": "cacophony",
+    "weight": 3
+  },
+  {
+    "feedback03": "solitude",
+    "weight": 3
+  },
+  {
+    "feedback04": "kaleidoscope",
+    "weight": 3
+  },
+  {
+    "feedback05": "zenith",
+    "weight": 3
+  },
+  {
+    "feedback06": "mellifluous",
+    "weight": 3
+  },
+  {
+    "feedback07": "detritus",
+    "weight": 4
+  },
+  {
+    "feedback08": "liminal",
+    "weight": 1
+  },
+  {
+    "feedback09": "palimpsest",
+    "weight": 1
+  },
+  {
+    "feedback10": "phantasmagoria",
+    "weight": 3
+  },
+  {
+    "feedback11": "ephemeral",
+    "weight": 3
+  },
+  {
+    "feedback12": "gambol",
+    "weight": 3
+  },
+  {
+    "feedback13": "fathom",
+    "weight": 6
+  },
+  {
+    "feedback14": "cipher",
+    "weight": 1
+  },
+  {
+    "feedback15": "lucid",
+    "weight": 3
+  },
+  {
+    "feedback16": "sublime",
+    "weight": 3
+  },
+  {
+    "feedback17": "quiver",
+    "weight": 6
+  },
+  {
+    "feedback18": "murmur",
+    "weight": 3
+  },
+  {
+    "feedback19": "glaze",
+    "weight": 3
+  },
+  {
+    "feedback20": "warp",
+    "weight": 3
+  },
+  {
+    "feedback21": "silt",
+    "weight": 6
+  },
+  {
+    "feedback22": "quasar",
+    "weight": 6
+  },
+  {
+    "feedback23": "glyph",
+    "weight": 3
+  },
+  {
+    "feedback24": "gossamer",
+    "weight": 4
+  },
+  {
+    "feedback25": "algorithm",
+    "weight": 4
+  },
+  {
+    "feedback26": "plenum",
+    "weight": 4
+  },
+  {
+    "feedback27": "drift",
+    "weight": 4
+  },
+  {
+    "feedback28": "cryptid",
+    "weight": 4
+  },
+  {
+    "feedback29": "volta",
+    "weight": 4
+  }
+]

data/feedback_historic.json.bak

@@ -0,0 +1,122 @@
+[
+  {
+    "feedback00": "mellifluous",
+    "weight": 3
+  },
+  {
+    "feedback01": "detritus",
+    "weight": 4
+  },
+  {
+    "feedback02": "liminal",
+    "weight": 1
+  },
+  {
+    "feedback03": "palimpsest",
+    "weight": 1
+  },
+  {
+    "feedback04": "phantasmagoria",
+    "weight": 3
+  },
+  {
+    "feedback05": "ephemeral",
+    "weight": 3
+  },
+  {
+    "feedback06": "gambol",
+    "weight": 3
+  },
+  {
+    "feedback07": "fathom",
+    "weight": 6
+  },
+  {
+    "feedback08": "cipher",
+    "weight": 1
+  },
+  {
+    "feedback09": "lucid",
+    "weight": 3
+  },
+  {
+    "feedback10": "sublime",
+    "weight": 3
+  },
+  {
+    "feedback11": "quiver",
+    "weight": 6
+  },
+  {
+    "feedback12": "murmur",
+    "weight": 3
+  },
+  {
+    "feedback13": "glaze",
+    "weight": 3
+  },
+  {
+    "feedback14": "warp",
+    "weight": 3
+  },
+  {
+    "feedback15": "silt",
+    "weight": 6
+  },
+  {
+    "feedback16": "quasar",
+    "weight": 6
+  },
+  {
+    "feedback17": "glyph",
+    "weight": 3
+  },
+  {
+    "feedback18": "gossamer",
+    "weight": 4
+  },
+  {
+    "feedback19": "algorithm",
+    "weight": 4
+  },
+  {
+    "feedback20": "plenum",
+    "weight": 4
+  },
+  {
+    "feedback21": "drift",
+    "weight": 4
+  },
+  {
+    "feedback22": "cryptid",
+    "weight": 4
+  },
+  {
+    "feedback23": "volta",
+    "weight": 4
+  },
+  {
+    "feedback24": "lacuna",
+    "weight": 3
+  },
+  {
+    "feedback25": "mycelium",
+    "weight": 1
+  },
+  {
+    "feedback26": "talisman",
+    "weight": 3
+  },
+  {
+    "feedback27": "effulgence",
+    "weight": 3
+  },
+  {
+    "feedback28": "chrysalis",
+    "weight": 6
+  },
+  {
+    "feedback29": "sonder",
+    "weight": 1
+  }
+]

data/prompts_historic.json

@@ -0,0 +1,182 @@
+[
+  {
+    "prompt00": "Describe a routine journey you make regularly—a commute, a walk to a local shop, a drive you know by heart. For one trip, perform it in reverse order if possible, or simply pay hyper-attentive, first-time attention to every detail. What do you notice that habit has rendered invisible? Does the familiar path become strange, beautiful, or tedious in a new way? Write about the act of defamiliarizing your own life."
+  },
+  {
+    "prompt01": "Recall a moment when reality seemed to glitch—a déjà vu so strong it was disorienting, a brief failure of recognition for a familiar face, or a dream detail that inexplicably appeared in waking life. Describe the sensation of the world's software briefly stuttering. Did it feel ominous, amusing, or profoundly strange? Explore what such moments reveal about the constructed nature of our perception and the seams in our conscious experience."
+  },
+  {
+    "prompt02": "Describe a container in your home that is almost always empty—a vase, a decorative bowl, a certain drawer. Why is it empty? Is it waiting for the perfect thing, or is its emptiness part of its function or beauty? Contemplate the purpose and presence of void spaces. What would happen if you deliberately filled it with something, or committed to keeping it perpetually empty?"
+  },
+  {
+    "prompt03": "Describe a wall in your city or neighborhood that is covered in layers of peeling posters and graffiti. Read it as a chaotic, collaborative public diary. What events were advertised, what messages were proclaimed, what art was left behind? Imagine the hands that placed each layer. Write about the history and humanity documented in this slow, uncurated accumulation."
+  },
+  {
+    "prompt04": "Describe a skill you learned through sheer, repetitive failure. Chart the arc from initial clumsy attempts, through frustration, to eventual unconscious competence. What did the process teach you about your own capacity for patience and persistence beyond the skill itself? Write about the hidden curriculum of learning by doing things wrong, over and over."
+  },
+  {
+    "prompt05": "You inherit a collection of someone else's bookmarks: train tickets, dried flowers, scraps of paper with cryptic notes. Deduce a portrait of the reader from these interstitial artifacts. What journeys were they on, both literal and literary? What passages were they marking to return to? Write a character study based on the quiet traces left in the pages of another life."
+  },
+  {
+    "prompt06": "Stand in the umbra—the full shadow—of a large object at midday. Describe the quality of light and temperature within this sharp-edged darkness. How does it feel to be so definitively separated from the sun's glare? Now, consider a metaphorical umbra in your life: a situation or emotion that casts a deep, distinct shadow. What grows, or what becomes clearer, in this cooler, shaded space?"
+  },
+  {
+    "prompt07": "Observe a tiled floor, a honeycomb, or a patchwork quilt. Study the tessellation—the repeating pattern of individual units creating a cohesive whole. Now, apply this concept to a week of your life. What are the fundamental, repeating units (tasks, interactions, thoughts) that combine to form the larger pattern? Is the overall design harmonious, chaotic, or in need of a new tile? Write about the beauty and constraint of life's inherent patterning."
+  },
+  {
+    "prompt08": "Consider the concept of a 'personal zenith'—the peak moment of a day, a project, or a phase of life, often recognized only in hindsight. Describe a recent zenith you experienced. What were the conditions that led to it? How did you know you had reached the apex? Was there a feeling of culmination, or was it a quiet cresting? Explore the gentle descent or plateau that followed, and how one navigates the landscape after the highest point has been passed."
+  },
+  {
+    "prompt09": "Imagine you are tasked with designing a new public holiday that celebrates a quiet, overlooked aspect of human experience—like the feeling of a first cool breeze after a heatwave, or the shared silence of strangers waiting in line. What would you call it? What rituals or observances would define it? How would people prepare for it, and what would they be encouraged to reflect upon? Write about the values and subtleties this holiday would enshrine, and why such a celebration feels necessary in the rhythm of the year."
+  },
+  {
+    "prompt10": "Consider the concept of a 'hinterland'—the remote, uncharted territory beyond the familiar borders of your daily awareness. Identify a mental or emotional hinterland within yourself: a set of feelings, memories, or potentials you rarely visit. Describe its imagined landscape. What keeps it distant? Write about a deliberate expedition into this interior wilderness. What do you discover, and how does the journey change your map of yourself?"
+  },
+  {
+    "prompt11": "Recall a moment when you were the recipient of a stranger's gaze—a brief, wordless look exchanged on the street, in a waiting room, or across a crowded space. Reconstruct the micro-expressions you perceived. What story did you instinctively write for them in that instant? Now, reverse the perspective. Imagine you were the stranger, and the look you gave was being interpreted. What unspoken narrative might they have constructed about you? Explore the silent, rapid-fire fiction we create in the gaps between people."
+  },
+  {
+    "prompt12": "You discover an old, handmade 'effigy'—a doll, a figurine, a crude sculpture—whose purpose is unclear. Describe its materials and construction. Who might have made it, and for what ritual or private reason? Does it feel protective, commemorative, or malevolent? Hold it. Write a speculative history of its creation and journey to you, exploring the human impulse to craft physical representations of our fears, hopes, or memories, and the quiet power these objects retain."
+  },
+  {
+    "prompt13": "Conduct a thought experiment: your mind is a 'plenum' of memories. There is no true forgetting, only layers of accumulation. Choose a recent, minor event and trace its connections downward through the strata, linking it to older, deeper memories it subtly echoes. Describe the archaeology of this mental space. What is it like to inhabit a consciousness where nothing is ever truly empty or lost?"
+  },
+  {
+    "prompt14": "Map your personal cosmology. Identify the 'quasars' (energetic cores), the 'gossamer' nebulae (dreamy, forming ideas), the stable planets (routines), and the dark matter (unseen influences). How do these celestial bodies interact? Is there a governing 'algorithm' or natural law to their motions? Write a guide to your inner universe, describing its scale, its mysteries, and its current celestial weather."
+  },
+  {
+    "prompt15": "Describe a structure in your life that functions as a 'plenum' for others—perhaps your attention for a friend, your home for your family, your schedule for your work. You are the space that is filled by their needs, conversations, or expectations. How do you maintain the integrity of your own walls? Do you ever feel on the verge of overpressure? Explore the physics of being a container and the quiet adjustments required to remain both full and whole."
+  },
+  {
+    "prompt16": "Consider the 'algorithm' of your morning routine. Deconstruct it into its fundamental steps, decisions, and conditional loops (if tired, then coffee; if sunny, then walk). Now, introduce a deliberate bug or a random variable. Break one step. Observe how the entire program of your day adapts, crashes, or discovers a new, unexpected function. Write about the poetry and the vulnerability hidden within your personal, daily code."
+  },
+  {
+    "prompt17": "Describe a piece of music that feels like a physical landscape to you. Don't just name the emotions; map the topography. Where are the soaring cliffs, the deep valleys, the calm meadows, the treacherous passes? When do you walk, when do you climb, when are you carried by a current? Write about journeying through this sonic territory. What part of yourself do you encounter in each region? Does the landscape change when you listen with closed eyes versus open? Explore the synesthesia of listening with your whole body."
+  },
+  {
+    "prompt18": "You are an archivist of vanishing sounds. For one day, consciously catalog the ephemeral auditory moments that usually go unnoticed: the specific creak of a floorboard, the sigh of a refrigerator cycling off, the rustle of a particular fabric. Describe these sounds with the precision of someone preserving them for posterity. Why do you choose these particular ones? What memory or feeling is tied to each? Write about the poignant act of listening to the present as if it were already becoming the past, and the history held in transient vibrations."
+  },
+  {
+    "prompt19": "Imagine your mind as a 'lattice'—a delicate, interconnected framework of beliefs, memories, and associations. Describe the nodes and the struts that connect them. Which connections are strong and frequently traveled? Which are fragile or overgrown? Now, consider a new idea or experience that doesn't fit neatly onto this existing lattice. Does it build a new node, strain an old connection, or require you to gently reshape the entire structure? Write about the mental architecture of integration and the quiet labor of building scaffolds for new understanding."
+  },
+  {
+    "prompt20": "Consider the concept of 'patina'—the beautiful, acquired sheen on an object from long use and exposure. Find an object in your possession that has developed its own patina through years of handling. Describe its surface in detail: the worn spots, the subtle discolorations, the softened edges. What stories of use and care are etched into its material? Now, reflect on the metaphorical patinas you have developed. What experiences have polished some parts of your character, while leaving others gently weathered? Write about the beauty of a life lived, not in pristine condition, but with the honorable marks of time and interaction."
+  },
+  {
+    "prompt21": "Recall a piece of clothing you once loved but no longer wear. Describe its texture, its fit, the memories woven into its fibers. Why did you stop wearing it? Did it wear out, fall out of style, or cease to fit the person you became? Write a eulogy for this garment, honoring its service and the version of yourself it once clothed. What have you shed along with it?"
+  },
+  {
+    "prompt22": "Recall a dream that presented itself as a cipher—a series of vivid but inexplicable images. Describe the dream's symbols without attempting to decode them. Sit with their inherent strangeness. What if the value of the dream lies not in its translatable meaning, but in its resistance to interpretation? Write about the experience of holding a mysterious internal artifact and choosing not to solve it."
+  },
+  {
+    "prompt23": "You encounter a natural system in a state of gentle decay—a rotting log, fallen leaves, a piece of fruit fermenting. Observe it closely. Describe the actors in this process: insects, fungi, bacteria. Reframe this not as an end, but as a vibrant, teeming transformation. How does witnessing this quiet, relentless alchemy change your perception of endings? Write about decay as a form of busy, purposeful life."
+  },
+  {
+    "prompt24": "Describe a public space you frequent at a specific time of day—a park bench, a café corner, a bus stop. For one week, observe the choreography of its other inhabitants. Note the regulars, their patterns, their unspoken agreements about space and proximity. Write about your role in this daily ballet. Are you a participant, an observer, or both? What story does this silent, collective movement tell?"
+  },
+  {
+    "prompt25": "Recall a moment when you felt a subtle tremor—not in the earth, but in your convictions, a relationship, or your understanding of a situation. Describe the initial, almost imperceptible vibration. Did it build into a quake, or subside into a new, stable silence? How did you steady yourself? Write about detecting and responding to these foundational shifts that precede more visible change."
+  },
+  {
+    "prompt26": "You find a single, interestingly shaped stone. Hold it in your hand. Consider its journey over millennia: the forces that shaped it, the places it has been, how it came to rest where you found it. Now, consider your own lifespan in comparison. Write a dialogue between you and the stone, exploring scales of time, permanence, and the brief, bright flicker of conscious life."
+  },
+  {
+    "prompt27": "Contemplate the concept of 'drift'—the slow, almost imperceptible movement away from an original position or intention. Identify an area of your life where you have experienced drift: in a relationship, a career path, a personal goal. Describe the subtle currents that caused it. Was it a passive surrender or a series of conscious micro-choices? Do you wish to correct your course, or are you curious to see where this new current leads?"
+  },
+  {
+    "prompt28": "You are tasked with composing a letter that will be sealed in a time capsule to be opened in 100 years. It cannot be about major world events, but about the mundane, beautiful details of an ordinary day in your life now. What do you describe? What do you assume will be incomprehensible to the future reader? What do you hope will be timeless?"
+  },
+  {
+    "prompt29": "Find a crack in a wall or pavement. Observe it closely. How did it form? What tiny ecosystems exist within it? Trace its path with your finger (in reality or in your mind). Use this flaw as a starting point to write about the beauty and necessity of imperfection, not as a deviation from wholeness, but as an integral part of a structure's story and character."
+  },
+  {
+    "prompt30": "Recall a time you witnessed an act of quiet, uncelebrated kindness between strangers. Describe the scene in detail. What was the gesture? How did the recipient react? How did it make you feel as an observer? Explore the ripple effect of such moments. Did it alter your behavior or outlook, even subtly, in the days that followed?"
+  },
+  {
+    "prompt31": "Create a cartography of a single, perfect day from your past. Do not map it chronologically. Instead, chart it by emotional landmarks and sensory waypoints. Where is the bay of contentment? The crossroads of a key decision? The forest of laughter? Draw this map in words, connecting the sites with paths of memory. What does this non-linear geography reveal about the day's true shape and impact?"
+  },
+  {
+    "prompt32": "Consider the alchemy of your daily routine. Take a mundane, repetitive task—making coffee, commuting, sorting mail—and describe it as a sacred, transformative ritual. What base materials (beans, traffic, paper) are you transmuting? What is the philosopher's stone in this process—your attention, your intention, or something else? Write about finding the hidden gold in the lead of habit."
+  },
+  {
+    "prompt33": "Choose a common material—wood, glass, concrete, fabric—and follow its presence through your day. Note every instance you encounter it. Describe its different forms, functions, and textures. By day's end, write about this material not as a passive substance, but as a silent, ubiquitous character in the story of your daily life. How does its constancy shape your experience?"
+  },
+  {
+    "prompt34": "Meditate on the feeling of 'enough.' Identify one area of your life (possessions, information, work, social interaction) where you recently felt a clear sense of sufficiency. Describe the precise moment that feeling arrived. What were its qualities? Contrast it with the more common feeling of scarcity or desire for more. How can you recognize the threshold of 'enough' when you encounter it again?"
+  },
+  {
+    "prompt35": "Think of a skill or talent you admire in someone else but feel you lack. Instead of framing it as a deficiency, imagine it as a different sensory apparatus. If their skill is a form of sight, what color do they see that you cannot? If it's a form of hearing, what frequency do they detect? Write about the world as experienced through this hypothetical sense you don't possess. What beautiful things might you be missing?"
+  },
+  {
+    "prompt36": "Contemplate the concept of 'waste'—not just trash, but wasted time, wasted potential, wasted emotion. Find a physical example of waste in your environment (a discarded object, spoiled food). Describe it without judgment. Then, trace its lineage back to its origin as something useful or desired. Can you find any hidden value or beauty in its current state? Explore the tension between utility and decay."
+  },
+  {
+    "prompt37": "Describe a place you know only through stories—a parent's childhood home, a friend's distant travels, a historical event's location. Build a sensory portrait of this place from second-hand descriptions. Now, imagine finally visiting it. Does the reality match the imagined geography? Write about the collision between inherited memory and firsthand experience, and which feels more real."
+  },
+  {
+    "prompt38": "You are given a blank, high-quality piece of paper and a single, perfect pen. The instruction is to create a map, but not of a physical place. Map the emotional landscape of a recent week. What are its mountain ranges of joy, its valleys of fatigue, its rivers of thought? Where are the uncharted territories? Label the landmarks with the small events that shaped them. Write about the act of cartography as a form of understanding."
+  },
+  {
+    "prompt39": "Contemplate the concept of 'waste' in your life—discarded time, unused potential, physical objects headed for landfill. Select one instance and personify it. Give this 'waste' a voice. What story does it tell about the system that produced it? Does it lament its fate, accept it, or propose an alternative existence? Write a dialogue with this personified fragment, exploring the guilt, inevitability, or hidden value we assign to what we cast aside."
+  },
+  {
+    "prompt40": "You are given a single, unmarked seed. Plant it in a pot of soil and place it where you will see it daily. For the next week, keep a log of your observations and the thoughts it provokes. Do you find yourself impatient for a sign of growth, or content with the mystery? How does this small, silent act of fostering potential mirror other, less tangible forms of nurturing in your life? Write about the discipline and faith in hidden processes."
+  },
+  {
+    "prompt41": "Describe a moment of profound stillness you experienced in a normally chaotic environment—a busy train station, a loud household, a crowded market. How did the noise and motion recede into the background, leaving you in a bubble of quiet observation? What details became hyper-visible in this state? Explore the feeling of being an island of calm within a sea of activity, and what this temporary detachment revealed about your connection to the world around you."
+  },
+  {
+    "prompt42": "Recall a piece of practical knowledge you possess that feels almost like a secret—a shortcut, a repair trick, a way of predicting the weather. How did you acquire it? Was it taught, stumbled upon, or earned through failure? Describe the feeling of holding this minor, useful wisdom. When do you choose to share it, and with whom? Explore the value of these small, uncelebrated competencies that help navigate daily life."
+  },
+  {
+    "prompt43": "Choose a tool you use for creation—a pen, a brush, a kitchen knife, a software cursor. Personify it not as a servant, but as a collaborator with its own temperament. Describe its ideal conditions, its quirks, its moments of resistance or fluid grace. Write about a specific project from its perspective. What does it 'feel' as you work? How does the partnership between your intention and its material properties shape the final outcome?"
+  },
+  {
+    "prompt44": "Describe a moment of profound silence you experienced—not just an absence of sound, but a resonant quiet that felt thick and full. Where were you? What thoughts or feelings arose in that space? Did the silence feel like a void or a presence? Explore how this deep quiet contrasted with the usual noise of your life, and what it revealed about your need for stillness or your fear of it."
+  },
+  {
+    "prompt45": "Recall a dream that took place in a liminal setting: an airport terminal, a ferry, a long corridor. What was the feeling of transit in the dream? Were you trying to reach a gate, find a door, or catch a vehicle? Explore what this dream-space might represent in your waking life. What are you in the process of leaving behind, and what are you attempting to board or enter? Write about the symbolism of dream travel."
+  },
+  {
+    "prompt46": "Meditate on the void left by a finished project, a concluded journey, or a resolved conflict. The effort and focus are gone, leaving an empty space where they once lived. Do you feel relief, disorientation, or a quiet emptiness? How do you inhabit this new quiet? Do you rush to fill it, or allow yourself to rest in the void, understanding it as a necessary pause between acts? Describe the landscape of completion."
+  },
+  {
+    "prompt47": "Think of a piece of art, music, or literature that created a profound echo in your soul—something that resonated so deeply it seemed to vibrate within you long after the initial experience. Deconstruct the echo. What specific frequencies (themes, melodies, images) matched your own internal tuning? Has the echo changed over time, growing fainter or merging with other sounds? Write about the anatomy of a lasting resonance."
+  },
+  {
+    "prompt48": "Choose a book you have read multiple times over the years. Each reading has left a layer of understanding, colored by who you were at the time. Open it now and find a heavily annotated page or a familiar passage. Read it as a palimpsest of your former selves. What do the different layers of your marginalia—the underlines, the question marks, the exclamations—reveal about your evolving relationship with the text and with your own mind?"
+  },
+  {
+    "prompt49": "Listen for an echo in your daily life—not a sonic one, but a recurrence. It could be a phrase someone uses that reminds you of another person, a pattern in your mistakes, or a feeling that returns in different circumstances. Trace this echo back to its source. Is it a memory, a habit, or a unresolved piece of your past? Write about the journey of following this reverberation to its origin and understanding why it persists."
+  },
+  {
+    "prompt50": "Imagine you could perceive the subtle, invisible networks that connect all things—the mycelial threads of relationship, influence, and shared history. Choose a single, ordinary object in your room. Trace its hypothetical connections: to the people who made it, the materials that compose it, the places it has been. Write about the moment your perception shifts, and you see not an isolated item, but a luminous node in a vast, humming web of interdependence."
+  },
+  {
+    "prompt51": "You inherit a box of someone else's photographs. The people and places are largely unknown to you. Select one image and build a speculative history for it. Who are the subjects? What was the occasion? What happened just before and just after the shutter clicked? Write the story this silent image suggests, exploring the act of constructing narrative from anonymous fragments."
+  },
+  {
+    "prompt52": "Recall a time you were lost, not in a wilderness, but in a familiar place made strange—perhaps by fog, darkness, or a disorienting emotional state. Describe the moment your internal map failed. How did you navigate without reliable landmarks? What did you discover about your surroundings and yourself in that state of productive disorientation?"
+  },
+  {
+    "prompt53": "Describe a piece of furniture in your home that has been with you through multiple life stages. Chronicle the conversations it has silently witnessed, the weight of different people who have sat upon it, the objects it has held. How has its function or meaning evolved alongside your own story? What would it say if it could speak of the quiet history embedded in its grain and upholstery?"
+  },
+  {
+    "prompt54": "Find a tree with visible scars—from pruning, lightning, disease, or carved initials. Describe these marks as entries in the tree's personal diary. What do they record about survival, interaction, and the passage of time? Imagine the tree's perspective on healing, which does not erase the wound but grows around it, incorporating the damage into its expanding self. What scars of your own have become part of your structure?"
+  },
+  {
+    "prompt55": "Recall a promise you made to yourself long ago—a vow about the person you would become, the life you would lead, or a principle you would never break. Have you kept it? If so, describe the quiet fidelity required. If not, explore the moment and the reasons for the divergence. Does the broken promise feel like a betrayal or an evolution? Is the ghost of that old vow a compassionate or an accusing presence?"
+  },
+  {
+    "prompt56": "Describe a recurring dream you have not had in years, but whose emotional residue still lingers. What was its landscape, its characters, its unspoken rules? Why do you think it has ceased its nocturnal visits? Explore the possibility that it was a messenger whose work is done, or a story your mind no longer needs to tell. What quiet tremor in your waking life might have signaled its departure?"
+  },
+  {
+    "prompt57": "Imagine you could send a message to yourself ten years in the past. You are limited to five words. What would those five words be? Why? Now, imagine receiving a five-word message from your future self, ten years from now. What might it say? Write about the agonizing economy and profound potential of such constrained communication."
+  },
+  {
+    "prompt58": "Observe a shadow throughout the day. It could be the shadow of a tree, a building, or a simple object on your desk. Chronicle its slow, silent journey. How does its shape, length, and sharpness change? Use this as a meditation on time's passage. What is the relationship between the solid object and its fleeting, dependent silhouette?"
+  },
+  {
+    "prompt59": "Contemplate the concept of a 'horizon'—both literal and metaphorical. Describe a time you physically journeyed toward a horizon. What was the experience of it perpetually receding? Now, identify a current personal or professional horizon. How do you navigate toward something that by definition moves as you do? Write about the tension between the journey and the ever-distant line."
+  }
+]

data/prompts_historic.json.bak

@@ -0,0 +1,182 @@
+[
+  {
+    "prompt00": "Recall a moment when reality seemed to glitch—a déjà vu so strong it was disorienting, a brief failure of recognition for a familiar face, or a dream detail that inexplicably appeared in waking life. Describe the sensation of the world's software briefly stuttering. Did it feel ominous, amusing, or profoundly strange? Explore what such moments reveal about the constructed nature of our perception and the seams in our conscious experience."
+  },
+  {
+    "prompt01": "Describe a container in your home that is almost always empty—a vase, a decorative bowl, a certain drawer. Why is it empty? Is it waiting for the perfect thing, or is its emptiness part of its function or beauty? Contemplate the purpose and presence of void spaces. What would happen if you deliberately filled it with something, or committed to keeping it perpetually empty?"
+  },
+  {
+    "prompt02": "Describe a wall in your city or neighborhood that is covered in layers of peeling posters and graffiti. Read it as a chaotic, collaborative public diary. What events were advertised, what messages were proclaimed, what art was left behind? Imagine the hands that placed each layer. Write about the history and humanity documented in this slow, uncurated accumulation."
+  },
+  {
+    "prompt03": "Describe a skill you learned through sheer, repetitive failure. Chart the arc from initial clumsy attempts, through frustration, to eventual unconscious competence. What did the process teach you about your own capacity for patience and persistence beyond the skill itself? Write about the hidden curriculum of learning by doing things wrong, over and over."
+  },
+  {
+    "prompt04": "You inherit a collection of someone else's bookmarks: train tickets, dried flowers, scraps of paper with cryptic notes. Deduce a portrait of the reader from these interstitial artifacts. What journeys were they on, both literal and literary? What passages were they marking to return to? Write a character study based on the quiet traces left in the pages of another life."
+  },
+  {
+    "prompt05": "Stand in the umbra—the full shadow—of a large object at midday. Describe the quality of light and temperature within this sharp-edged darkness. How does it feel to be so definitively separated from the sun's glare? Now, consider a metaphorical umbra in your life: a situation or emotion that casts a deep, distinct shadow. What grows, or what becomes clearer, in this cooler, shaded space?"
+  },
+  {
+    "prompt06": "Observe a tiled floor, a honeycomb, or a patchwork quilt. Study the tessellation—the repeating pattern of individual units creating a cohesive whole. Now, apply this concept to a week of your life. What are the fundamental, repeating units (tasks, interactions, thoughts) that combine to form the larger pattern? Is the overall design harmonious, chaotic, or in need of a new tile? Write about the beauty and constraint of life's inherent patterning."
+  },
+  {
+    "prompt07": "Consider the concept of a 'personal zenith'—the peak moment of a day, a project, or a phase of life, often recognized only in hindsight. Describe a recent zenith you experienced. What were the conditions that led to it? How did you know you had reached the apex? Was there a feeling of culmination, or was it a quiet cresting? Explore the gentle descent or plateau that followed, and how one navigates the landscape after the highest point has been passed."
+  },
+  {
+    "prompt08": "Imagine you are tasked with designing a new public holiday that celebrates a quiet, overlooked aspect of human experience—like the feeling of a first cool breeze after a heatwave, or the shared silence of strangers waiting in line. What would you call it? What rituals or observances would define it? How would people prepare for it, and what would they be encouraged to reflect upon? Write about the values and subtleties this holiday would enshrine, and why such a celebration feels necessary in the rhythm of the year."
+  },
+  {
+    "prompt09": "Consider the concept of a 'hinterland'—the remote, uncharted territory beyond the familiar borders of your daily awareness. Identify a mental or emotional hinterland within yourself: a set of feelings, memories, or potentials you rarely visit. Describe its imagined landscape. What keeps it distant? Write about a deliberate expedition into this interior wilderness. What do you discover, and how does the journey change your map of yourself?"
+  },
+  {
+    "prompt10": "Recall a moment when you were the recipient of a stranger's gaze—a brief, wordless look exchanged on the street, in a waiting room, or across a crowded space. Reconstruct the micro-expressions you perceived. What story did you instinctively write for them in that instant? Now, reverse the perspective. Imagine you were the stranger, and the look you gave was being interpreted. What unspoken narrative might they have constructed about you? Explore the silent, rapid-fire fiction we create in the gaps between people."
+  },
+  {
+    "prompt11": "You discover an old, handmade 'effigy'—a doll, a figurine, a crude sculpture—whose purpose is unclear. Describe its materials and construction. Who might have made it, and for what ritual or private reason? Does it feel protective, commemorative, or malevolent? Hold it. Write a speculative history of its creation and journey to you, exploring the human impulse to craft physical representations of our fears, hopes, or memories, and the quiet power these objects retain."
+  },
+  {
+    "prompt12": "Conduct a thought experiment: your mind is a 'plenum' of memories. There is no true forgetting, only layers of accumulation. Choose a recent, minor event and trace its connections downward through the strata, linking it to older, deeper memories it subtly echoes. Describe the archaeology of this mental space. What is it like to inhabit a consciousness where nothing is ever truly empty or lost?"
+  },
+  {
+    "prompt13": "Map your personal cosmology. Identify the 'quasars' (energetic cores), the 'gossamer' nebulae (dreamy, forming ideas), the stable planets (routines), and the dark matter (unseen influences). How do these celestial bodies interact? Is there a governing 'algorithm' or natural law to their motions? Write a guide to your inner universe, describing its scale, its mysteries, and its current celestial weather."
+  },
+  {
+    "prompt14": "Describe a structure in your life that functions as a 'plenum' for others—perhaps your attention for a friend, your home for your family, your schedule for your work. You are the space that is filled by their needs, conversations, or expectations. How do you maintain the integrity of your own walls? Do you ever feel on the verge of overpressure? Explore the physics of being a container and the quiet adjustments required to remain both full and whole."
+  },
+  {
+    "prompt15": "Consider the 'algorithm' of your morning routine. Deconstruct it into its fundamental steps, decisions, and conditional loops (if tired, then coffee; if sunny, then walk). Now, introduce a deliberate bug or a random variable. Break one step. Observe how the entire program of your day adapts, crashes, or discovers a new, unexpected function. Write about the poetry and the vulnerability hidden within your personal, daily code."
+  },
+  {
+    "prompt16": "Describe a piece of music that feels like a physical landscape to you. Don't just name the emotions; map the topography. Where are the soaring cliffs, the deep valleys, the calm meadows, the treacherous passes? When do you walk, when do you climb, when are you carried by a current? Write about journeying through this sonic territory. What part of yourself do you encounter in each region? Does the landscape change when you listen with closed eyes versus open? Explore the synesthesia of listening with your whole body."
+  },
+  {
+    "prompt17": "You are an archivist of vanishing sounds. For one day, consciously catalog the ephemeral auditory moments that usually go unnoticed: the specific creak of a floorboard, the sigh of a refrigerator cycling off, the rustle of a particular fabric. Describe these sounds with the precision of someone preserving them for posterity. Why do you choose these particular ones? What memory or feeling is tied to each? Write about the poignant act of listening to the present as if it were already becoming the past, and the history held in transient vibrations."
+  },
+  {
+    "prompt18": "Imagine your mind as a 'lattice'—a delicate, interconnected framework of beliefs, memories, and associations. Describe the nodes and the struts that connect them. Which connections are strong and frequently traveled? Which are fragile or overgrown? Now, consider a new idea or experience that doesn't fit neatly onto this existing lattice. Does it build a new node, strain an old connection, or require you to gently reshape the entire structure? Write about the mental architecture of integration and the quiet labor of building scaffolds for new understanding."
+  },
+  {
+    "prompt19": "Consider the concept of 'patina'—the beautiful, acquired sheen on an object from long use and exposure. Find an object in your possession that has developed its own patina through years of handling. Describe its surface in detail: the worn spots, the subtle discolorations, the softened edges. What stories of use and care are etched into its material? Now, reflect on the metaphorical patinas you have developed. What experiences have polished some parts of your character, while leaving others gently weathered? Write about the beauty of a life lived, not in pristine condition, but with the honorable marks of time and interaction."
+  },
+  {
+    "prompt20": "Recall a piece of clothing you once loved but no longer wear. Describe its texture, its fit, the memories woven into its fibers. Why did you stop wearing it? Did it wear out, fall out of style, or cease to fit the person you became? Write a eulogy for this garment, honoring its service and the version of yourself it once clothed. What have you shed along with it?"
+  },
+  {
+    "prompt21": "Recall a dream that presented itself as a cipher—a series of vivid but inexplicable images. Describe the dream's symbols without attempting to decode them. Sit with their inherent strangeness. What if the value of the dream lies not in its translatable meaning, but in its resistance to interpretation? Write about the experience of holding a mysterious internal artifact and choosing not to solve it."
+  },
+  {
+    "prompt22": "You encounter a natural system in a state of gentle decay—a rotting log, fallen leaves, a piece of fruit fermenting. Observe it closely. Describe the actors in this process: insects, fungi, bacteria. Reframe this not as an end, but as a vibrant, teeming transformation. How does witnessing this quiet, relentless alchemy change your perception of endings? Write about decay as a form of busy, purposeful life."
+  },
+  {
+    "prompt23": "Describe a public space you frequent at a specific time of day—a park bench, a café corner, a bus stop. For one week, observe the choreography of its other inhabitants. Note the regulars, their patterns, their unspoken agreements about space and proximity. Write about your role in this daily ballet. Are you a participant, an observer, or both? What story does this silent, collective movement tell?"
+  },
+  {
+    "prompt24": "Recall a moment when you felt a subtle tremor—not in the earth, but in your convictions, a relationship, or your understanding of a situation. Describe the initial, almost imperceptible vibration. Did it build into a quake, or subside into a new, stable silence? How did you steady yourself? Write about detecting and responding to these foundational shifts that precede more visible change."
+  },
+  {
+    "prompt25": "You find a single, interestingly shaped stone. Hold it in your hand. Consider its journey over millennia: the forces that shaped it, the places it has been, how it came to rest where you found it. Now, consider your own lifespan in comparison. Write a dialogue between you and the stone, exploring scales of time, permanence, and the brief, bright flicker of conscious life."
+  },
+  {
+    "prompt26": "Contemplate the concept of 'drift'—the slow, almost imperceptible movement away from an original position or intention. Identify an area of your life where you have experienced drift: in a relationship, a career path, a personal goal. Describe the subtle currents that caused it. Was it a passive surrender or a series of conscious micro-choices? Do you wish to correct your course, or are you curious to see where this new current leads?"
+  },
+  {
+    "prompt27": "You are tasked with composing a letter that will be sealed in a time capsule to be opened in 100 years. It cannot be about major world events, but about the mundane, beautiful details of an ordinary day in your life now. What do you describe? What do you assume will be incomprehensible to the future reader? What do you hope will be timeless?"
+  },
+  {
+    "prompt28": "Find a crack in a wall or pavement. Observe it closely. How did it form? What tiny ecosystems exist within it? Trace its path with your finger (in reality or in your mind). Use this flaw as a starting point to write about the beauty and necessity of imperfection, not as a deviation from wholeness, but as an integral part of a structure's story and character."
+  },
+  {
+    "prompt29": "Recall a time you witnessed an act of quiet, uncelebrated kindness between strangers. Describe the scene in detail. What was the gesture? How did the recipient react? How did it make you feel as an observer? Explore the ripple effect of such moments. Did it alter your behavior or outlook, even subtly, in the days that followed?"
+  },
+  {
+    "prompt30": "Create a cartography of a single, perfect day from your past. Do not map it chronologically. Instead, chart it by emotional landmarks and sensory waypoints. Where is the bay of contentment? The crossroads of a key decision? The forest of laughter? Draw this map in words, connecting the sites with paths of memory. What does this non-linear geography reveal about the day's true shape and impact?"
+  },
+  {
+    "prompt31": "Consider the alchemy of your daily routine. Take a mundane, repetitive task—making coffee, commuting, sorting mail—and describe it as a sacred, transformative ritual. What base materials (beans, traffic, paper) are you transmuting? What is the philosopher's stone in this process—your attention, your intention, or something else? Write about finding the hidden gold in the lead of habit."
+  },
+  {
+    "prompt32": "Choose a common material—wood, glass, concrete, fabric—and follow its presence through your day. Note every instance you encounter it. Describe its different forms, functions, and textures. By day's end, write about this material not as a passive substance, but as a silent, ubiquitous character in the story of your daily life. How does its constancy shape your experience?"
+  },
+  {
+    "prompt33": "Meditate on the feeling of 'enough.' Identify one area of your life (possessions, information, work, social interaction) where you recently felt a clear sense of sufficiency. Describe the precise moment that feeling arrived. What were its qualities? Contrast it with the more common feeling of scarcity or desire for more. How can you recognize the threshold of 'enough' when you encounter it again?"
+  },
+  {
+    "prompt34": "Think of a skill or talent you admire in someone else but feel you lack. Instead of framing it as a deficiency, imagine it as a different sensory apparatus. If their skill is a form of sight, what color do they see that you cannot? If it's a form of hearing, what frequency do they detect? Write about the world as experienced through this hypothetical sense you don't possess. What beautiful things might you be missing?"
+  },
+  {
+    "prompt35": "Contemplate the concept of 'waste'—not just trash, but wasted time, wasted potential, wasted emotion. Find a physical example of waste in your environment (a discarded object, spoiled food). Describe it without judgment. Then, trace its lineage back to its origin as something useful or desired. Can you find any hidden value or beauty in its current state? Explore the tension between utility and decay."
+  },
+  {
+    "prompt36": "Describe a place you know only through stories—a parent's childhood home, a friend's distant travels, a historical event's location. Build a sensory portrait of this place from second-hand descriptions. Now, imagine finally visiting it. Does the reality match the imagined geography? Write about the collision between inherited memory and firsthand experience, and which feels more real."
+  },
+  {
+    "prompt37": "You are given a blank, high-quality piece of paper and a single, perfect pen. The instruction is to create a map, but not of a physical place. Map the emotional landscape of a recent week. What are its mountain ranges of joy, its valleys of fatigue, its rivers of thought? Where are the uncharted territories? Label the landmarks with the small events that shaped them. Write about the act of cartography as a form of understanding."
+  },
+  {
+    "prompt38": "Contemplate the concept of 'waste' in your life—discarded time, unused potential, physical objects headed for landfill. Select one instance and personify it. Give this 'waste' a voice. What story does it tell about the system that produced it? Does it lament its fate, accept it, or propose an alternative existence? Write a dialogue with this personified fragment, exploring the guilt, inevitability, or hidden value we assign to what we cast aside."
+  },
+  {
+    "prompt39": "You are given a single, unmarked seed. Plant it in a pot of soil and place it where you will see it daily. For the next week, keep a log of your observations and the thoughts it provokes. Do you find yourself impatient for a sign of growth, or content with the mystery? How does this small, silent act of fostering potential mirror other, less tangible forms of nurturing in your life? Write about the discipline and faith in hidden processes."
+  },
+  {
+    "prompt40": "Describe a moment of profound stillness you experienced in a normally chaotic environment—a busy train station, a loud household, a crowded market. How did the noise and motion recede into the background, leaving you in a bubble of quiet observation? What details became hyper-visible in this state? Explore the feeling of being an island of calm within a sea of activity, and what this temporary detachment revealed about your connection to the world around you."
+  },
+  {
+    "prompt41": "Recall a piece of practical knowledge you possess that feels almost like a secret—a shortcut, a repair trick, a way of predicting the weather. How did you acquire it? Was it taught, stumbled upon, or earned through failure? Describe the feeling of holding this minor, useful wisdom. When do you choose to share it, and with whom? Explore the value of these small, uncelebrated competencies that help navigate daily life."
+  },
+  {
+    "prompt42": "Choose a tool you use for creation—a pen, a brush, a kitchen knife, a software cursor. Personify it not as a servant, but as a collaborator with its own temperament. Describe its ideal conditions, its quirks, its moments of resistance or fluid grace. Write about a specific project from its perspective. What does it 'feel' as you work? How does the partnership between your intention and its material properties shape the final outcome?"
+  },
+  {
+    "prompt43": "Describe a moment of profound silence you experienced—not just an absence of sound, but a resonant quiet that felt thick and full. Where were you? What thoughts or feelings arose in that space? Did the silence feel like a void or a presence? Explore how this deep quiet contrasted with the usual noise of your life, and what it revealed about your need for stillness or your fear of it."
+  },
+  {
+    "prompt44": "Recall a dream that took place in a liminal setting: an airport terminal, a ferry, a long corridor. What was the feeling of transit in the dream? Were you trying to reach a gate, find a door, or catch a vehicle? Explore what this dream-space might represent in your waking life. What are you in the process of leaving behind, and what are you attempting to board or enter? Write about the symbolism of dream travel."
+  },
+  {
+    "prompt45": "Meditate on the void left by a finished project, a concluded journey, or a resolved conflict. The effort and focus are gone, leaving an empty space where they once lived. Do you feel relief, disorientation, or a quiet emptiness? How do you inhabit this new quiet? Do you rush to fill it, or allow yourself to rest in the void, understanding it as a necessary pause between acts? Describe the landscape of completion."
+  },
+  {
+    "prompt46": "Think of a piece of art, music, or literature that created a profound echo in your soul—something that resonated so deeply it seemed to vibrate within you long after the initial experience. Deconstruct the echo. What specific frequencies (themes, melodies, images) matched your own internal tuning? Has the echo changed over time, growing fainter or merging with other sounds? Write about the anatomy of a lasting resonance."
+  },
+  {
+    "prompt47": "Choose a book you have read multiple times over the years. Each reading has left a layer of understanding, colored by who you were at the time. Open it now and find a heavily annotated page or a familiar passage. Read it as a palimpsest of your former selves. What do the different layers of your marginalia—the underlines, the question marks, the exclamations—reveal about your evolving relationship with the text and with your own mind?"
+  },
+  {
+    "prompt48": "Listen for an echo in your daily life—not a sonic one, but a recurrence. It could be a phrase someone uses that reminds you of another person, a pattern in your mistakes, or a feeling that returns in different circumstances. Trace this echo back to its source. Is it a memory, a habit, or a unresolved piece of your past? Write about the journey of following this reverberation to its origin and understanding why it persists."
+  },
+  {
+    "prompt49": "Imagine you could perceive the subtle, invisible networks that connect all things—the mycelial threads of relationship, influence, and shared history. Choose a single, ordinary object in your room. Trace its hypothetical connections: to the people who made it, the materials that compose it, the places it has been. Write about the moment your perception shifts, and you see not an isolated item, but a luminous node in a vast, humming web of interdependence."
+  },
+  {
+    "prompt50": "You inherit a box of someone else's photographs. The people and places are largely unknown to you. Select one image and build a speculative history for it. Who are the subjects? What was the occasion? What happened just before and just after the shutter clicked? Write the story this silent image suggests, exploring the act of constructing narrative from anonymous fragments."
+  },
+  {
+    "prompt51": "Recall a time you were lost, not in a wilderness, but in a familiar place made strange—perhaps by fog, darkness, or a disorienting emotional state. Describe the moment your internal map failed. How did you navigate without reliable landmarks? What did you discover about your surroundings and yourself in that state of productive disorientation?"
+  },
+  {
+    "prompt52": "Describe a piece of furniture in your home that has been with you through multiple life stages. Chronicle the conversations it has silently witnessed, the weight of different people who have sat upon it, the objects it has held. How has its function or meaning evolved alongside your own story? What would it say if it could speak of the quiet history embedded in its grain and upholstery?"
+  },
+  {
+    "prompt53": "Find a tree with visible scars—from pruning, lightning, disease, or carved initials. Describe these marks as entries in the tree's personal diary. What do they record about survival, interaction, and the passage of time? Imagine the tree's perspective on healing, which does not erase the wound but grows around it, incorporating the damage into its expanding self. What scars of your own have become part of your structure?"
+  },
+  {
+    "prompt54": "Recall a promise you made to yourself long ago—a vow about the person you would become, the life you would lead, or a principle you would never break. Have you kept it? If so, describe the quiet fidelity required. If not, explore the moment and the reasons for the divergence. Does the broken promise feel like a betrayal or an evolution? Is the ghost of that old vow a compassionate or an accusing presence?"
+  },
+  {
+    "prompt55": "Describe a recurring dream you have not had in years, but whose emotional residue still lingers. What was its landscape, its characters, its unspoken rules? Why do you think it has ceased its nocturnal visits? Explore the possibility that it was a messenger whose work is done, or a story your mind no longer needs to tell. What quiet tremor in your waking life might have signaled its departure?"
+  },
+  {
+    "prompt56": "Imagine you could send a message to yourself ten years in the past. You are limited to five words. What would those five words be? Why? Now, imagine receiving a five-word message from your future self, ten years from now. What might it say? Write about the agonizing economy and profound potential of such constrained communication."
+  },
+  {
+    "prompt57": "Observe a shadow throughout the day. It could be the shadow of a tree, a building, or a simple object on your desk. Chronicle its slow, silent journey. How does its shape, length, and sharpness change? Use this as a meditation on time's passage. What is the relationship between the solid object and its fleeting, dependent silhouette?"
+  },
+  {
+    "prompt58": "Contemplate the concept of a 'horizon'—both literal and metaphorical. Describe a time you physically journeyed toward a horizon. What was the experience of it perpetually receding? Now, identify a current personal or professional horizon. How do you navigate toward something that by definition moves as you do? Write about the tension between the journey and the ever-distant line."
+  },
+  {
+    "prompt59": "Describe a food or dish that is deeply connected to a specific memory of a person or place. Go beyond taste. Describe the sounds of its preparation, the smells that filled the air, the textures. Now, attempt to recreate it or seek it out. Does the experience live up to the memory, or does it highlight the irreproducible context of the original moment? Write about the pursuit of sensory time travel."
+  }
+]

data/prompts_pool.json

@@ -0,0 +1,22 @@
+[
+  "You are asked to contribute an entry to an 'Encyclopedia of Small Joys.' Your task is to define and describe one specific, minor pleasure in exhaustive, almost scientific detail. What do you choose? (e.g., 'The sound of rain on a skylight,' 'The weight of a sleeping cat on your lap,' 'The first sip of cold water when thirsty'). Detail its parameters, its effects, and the conditions under which it is most potent. Write a loving taxonomy of a tiny delight.",
+  "Recall a piece of advice you were given that you profoundly disagreed with at the time, but which later revealed a kernel of truth. What was the context? Why did you reject it? What experience or perspective shift allowed you to later understand its value? Write about the slow, often grudging, integration of wisdom that arrives before its time.",
+  "Describe a handmade gift you once received. Focus not on its monetary value or aesthetic perfection, but on the evidence of the giver's labor—the slightly uneven stitch, the handwritten note, the chosen colors. What does the object communicate about the relationship and the thought behind it? Has your appreciation for it changed over time? Explore the unique language of crafted, imperfect generosity.",
+  "Imagine you could perceive the emotional weather of the rooms you enter—not as metaphors, but as tangible atmospheres: a tense meeting room might feel thick and staticky, a friend's kitchen might be warm and golden. Describe walking through your day with this synesthetic sense. How would it change your interactions? Would you seek out certain climates and avoid others? Write about navigating the invisible emotional ecosystems we all create and inhabit.",
+  "Contemplate the concept of 'inventory.' Conduct a non-material inventory of your current state. What are your primary stores of energy, patience, curiosity, and courage? Which are depleted, which are ample? What unseen resources are you drawing upon? Don't judge, simply observe and record. Write about the internal economy that governs your days, and the quiet transactions that fill and drain your reserves.",
+  "Find a reflection—in a window, a puddle, a darkened screen—that is slightly distorted. Observe your own face or the world through this warped mirror. How does the distortion change your perception? Does it feel revealing, grotesque, or playful? Use this as a starting point to write about the ways our self-perception is always a kind of reflection, subject to the curvature of mood, memory, and context.",
+  "Recall a time you had to translate something—a concept for a child, a feeling into words, an experience for someone from a different culture. Describe the struggle and creativity of finding equivalences. What was lost in translation? What was unexpectedly clarified or discovered in the attempt? Write about the spaces between languages and understandings, and the bridges we build across them.",
+  "Describe a smell that instantly transports you to a specific, powerful memory. Don't just name the smell; dissect its components. Where does it take you? Is the memory vivid or fragmented? Does the scent bring comfort, sadness, or a complex mixture? Explore the direct, unmediated pathway that scent has to our past, bypassing conscious thought to drop us into a fully realized moment.",
+  "Consider the concept of 'drift' in your friendships. Think of a friend from a different chapter of your life with whom you are no longer close. Map the gentle currents of circumstance, geography, or changing interests that created the gradual separation. Do you feel the space between you as a loss, a natural evolution, or both? Write a letter to this friend (not to send) that acknowledges the drift without blame, honoring the shared history while releasing the present connection.",
+  "You are tasked with writing the instruction manual for a common, everyday object, but from the perspective of the object itself. Choose something simple: a door, a spoon, a light switch. What are its core functions? What are its operating principles? What warnings would it give about misuse? Write the manual with empathy for the object's experience, exploring the hidden life and purpose of the inanimate things we take for granted.",
+  "Describe witnessing an act of unobserved integrity—someone returning a lost wallet, correcting a mistake that benefited them, choosing honesty when a lie would have been easier. You were the only witness. Why did this act stand out to you? Did it inspire you, shame you, or simply reassure you? Explore the quiet, uncelebrated moral choices that form the ethical bedrock of daily life, and why seeing them matters.",
+  "Consider the concept of 'gossamer'—something extremely light, delicate, and insubstantial. Identify a gossamer thread in your life: a fragile hope, a half-formed idea, a delicate connection with someone. Describe its texture and how it holds tension. What gentle forces could strengthen it into something more durable, and what rough touch would cause it to snap? Explore the courage and care required to nurture what is barely there.",
+  "You encounter a 'cryptid' of your own making—a persistent, shadowy feeling or belief that others dismiss or cannot see, yet feels undeniably real to you. Describe its characteristics and habitat within your mind. When does it emerge? What does it feed on? Instead of trying to prove or disprove its existence, write about learning to coexist with this internal mystery, mapping its territory and understanding its role in your personal ecology.",
+  "Recall a moment of 'volta'—a subtle but definitive turn in a conversation, a relationship, or your understanding of a situation. It wasn't a dramatic reversal, but a quiet pivot point after which things were irrevocably different. Describe the atmosphere just before and just after this turn. What small word, glance, or realization acted as the hinge? Explore the anatomy of quiet change and how we navigate the new direction of a path we thought was straight.",
+  "Describe a riverbank after the water has receded, leaving behind a layer of fine, damp silt. Observe the patterns it has formed—the ripples, the tiny channels, the imprints of leaves and twigs. This sediment holds the history of the river's recent flow. What has it deposited here? What is now buried, and what is newly revealed on the surface? Write about the slow, patient work of accumulation and what it means to read the stories written in this soft, transitional ground.",
+  "You discover a series of strange, carved markings—glyphs—on an old piece of furniture or a forgotten wall. They are not a language you recognize. Document their shapes and arrangement. Who might have made them, and for what purpose? Were they a code, a tally, a protective symbol, or simply idle carving? Contemplate the human urge to leave a mark, even an indecipherable one. Write about the silent conversation you attempt to have with this anonymous, enduring message.",
+  "Recall a conversation overheard in fragments—a murmur from another room, a phone call on a park bench, the distant voices of neighbors. You only catch phrases, tones, and pauses. From these pieces, construct the possible whole. What relationship do the speakers have? What is the context of their discussion? Now, acknowledge the inevitable warp your imagination has applied. Write about the narratives we spin from the incomplete threads of other people's lives, and how this act of listening and inventing reflects our own preoccupations.",
+  "Recall a moment of pure, unselfconscious play from your childhood—a game of make-believe, a physical gambol in a field or park. Describe the sensation of your body in motion, the rules of the invented world, the feeling of time dissolving. Now, consider the last time you felt a similar, fleeting sense of abandon as an adult. What activity prompted it? Write about the distance between these two experiences and the possibility of inviting more unstructured, joyful movement into your present life.",
+  "You are given a single, perfect seashell. Hold it to your ear. The old cliché speaks of the ocean's roar, but listen deeper. What else might you fathom in that hollow resonance? The sigh of the creature that once lived there? The whisper of ancient currents? The memory of a distant shore? Now, turn the metaphor inward. What deep, resonant chamber exists within you, and what is the sound it holds when you listen with total, patient attention? Write about the act of listening for the profound in the small and contained.",
+  "Describe a moment when an emotion—joy, grief, awe, fear—caused a physical quiver in your body. It might have been a shiver down your spine, a tremor in your hands, a catch in your breath. Locate the precise point of origin for this somatic echo. Did the feeling move through you like a wave, or settle in one place? Explore the conversation between your inner state and your physical vessel. How does the body register what the mind cannot yet fully articulate?"
+]

data/prompts_pool.json.bak

@@ -0,0 +1,19 @@
+[
+  "You are asked to contribute an entry to an 'Encyclopedia of Small Joys.' Your task is to define and describe one specific, minor pleasure in exhaustive, almost scientific detail. What do you choose? (e.g., 'The sound of rain on a skylight,' 'The weight of a sleeping cat on your lap,' 'The first sip of cold water when thirsty'). Detail its parameters, its effects, and the conditions under which it is most potent. Write a loving taxonomy of a tiny delight.",
+  "Recall a piece of advice you were given that you profoundly disagreed with at the time, but which later revealed a kernel of truth. What was the context? Why did you reject it? What experience or perspective shift allowed you to later understand its value? Write about the slow, often grudging, integration of wisdom that arrives before its time.",
+  "Describe a handmade gift you once received. Focus not on its monetary value or aesthetic perfection, but on the evidence of the giver's labor—the slightly uneven stitch, the handwritten note, the chosen colors. What does the object communicate about the relationship and the thought behind it? Has your appreciation for it changed over time? Explore the unique language of crafted, imperfect generosity.",
+  "Imagine you could perceive the emotional weather of the rooms you enter—not as metaphors, but as tangible atmospheres: a tense meeting room might feel thick and staticky, a friend's kitchen might be warm and golden. Describe walking through your day with this synesthetic sense. How would it change your interactions? Would you seek out certain climates and avoid others? Write about navigating the invisible emotional ecosystems we all create and inhabit.",
+  "Contemplate the concept of 'inventory.' Conduct a non-material inventory of your current state. What are your primary stores of energy, patience, curiosity, and courage? Which are depleted, which are ample? What unseen resources are you drawing upon? Don't judge, simply observe and record. Write about the internal economy that governs your days, and the quiet transactions that fill and drain your reserves.",
+  "Find a reflection—in a window, a puddle, a darkened screen—that is slightly distorted. Observe your own face or the world through this warped mirror. How does the distortion change your perception? Does it feel revealing, grotesque, or playful? Use this as a starting point to write about the ways our self-perception is always a kind of reflection, subject to the curvature of mood, memory, and context.",
+  "Recall a time you had to translate something—a concept for a child, a feeling into words, an experience for someone from a different culture. Describe the struggle and creativity of finding equivalences. What was lost in translation? What was unexpectedly clarified or discovered in the attempt? Write about the spaces between languages and understandings, and the bridges we build across them.",
+  "Describe a smell that instantly transports you to a specific, powerful memory. Don't just name the smell; dissect its components. Where does it take you? Is the memory vivid or fragmented? Does the scent bring comfort, sadness, or a complex mixture? Explore the direct, unmediated pathway that scent has to our past, bypassing conscious thought to drop us into a fully realized moment.",
+  "Consider the concept of 'drift' in your friendships. Think of a friend from a different chapter of your life with whom you are no longer close. Map the gentle currents of circumstance, geography, or changing interests that created the gradual separation. Do you feel the space between you as a loss, a natural evolution, or both? Write a letter to this friend (not to send) that acknowledges the drift without blame, honoring the shared history while releasing the present connection.",
+  "You are tasked with writing the instruction manual for a common, everyday object, but from the perspective of the object itself. Choose something simple: a door, a spoon, a light switch. What are its core functions? What are its operating principles? What warnings would it give about misuse? Write the manual with empathy for the object's experience, exploring the hidden life and purpose of the inanimate things we take for granted.",
+  "Describe witnessing an act of unobserved integrity—someone returning a lost wallet, correcting a mistake that benefited them, choosing honesty when a lie would have been easier. You were the only witness. Why did this act stand out to you? Did it inspire you, shame you, or simply reassure you? Explore the quiet, uncelebrated moral choices that form the ethical bedrock of daily life, and why seeing them matters.",
+  "Consider the concept of 'gossamer'—something extremely light, delicate, and insubstantial. Identify a gossamer thread in your life: a fragile hope, a half-formed idea, a delicate connection with someone. Describe its texture and how it holds tension. What gentle forces could strengthen it into something more durable, and what rough touch would cause it to snap? Explore the courage and care required to nurture what is barely there.",
+  "You encounter a 'cryptid' of your own making—a persistent, shadowy feeling or belief that others dismiss or cannot see, yet feels undeniably real to you. Describe its characteristics and habitat within your mind. When does it emerge? What does it feed on? Instead of trying to prove or disprove its existence, write about learning to coexist with this internal mystery, mapping its territory and understanding its role in your personal ecology.",
+  "Recall a moment of 'volta'—a subtle but definitive turn in a conversation, a relationship, or your understanding of a situation. It wasn't a dramatic reversal, but a quiet pivot point after which things were irrevocably different. Describe the atmosphere just before and just after this turn. What small word, glance, or realization acted as the hinge? Explore the anatomy of quiet change and how we navigate the new direction of a path we thought was straight.",
+  "Describe a riverbank after the water has receded, leaving behind a layer of fine, damp silt. Observe the patterns it has formed—the ripples, the tiny channels, the imprints of leaves and twigs. This sediment holds the history of the river's recent flow. What has it deposited here? What is now buried, and what is newly revealed on the surface? Write about the slow, patient work of accumulation and what it means to read the stories written in this soft, transitional ground.",
+  "You discover a series of strange, carved markings—glyphs—on an old piece of furniture or a forgotten wall. They are not a language you recognize. Document their shapes and arrangement. Who might have made them, and for what purpose? Were they a code, a tally, a protective symbol, or simply idle carving? Contemplate the human urge to leave a mark, even an indecipherable one. Write about the silent conversation you attempt to have with this anonymous, enduring message.",
+  "Recall a conversation overheard in fragments—a murmur from another room, a phone call on a park bench, the distant voices of neighbors. You only catch phrases, tones, and pauses. From these pieces, construct the possible whole. What relationship do the speakers have? What is the context of their discussion? Now, acknowledge the inevitable warp your imagination has applied. Write about the narratives we spin from the incomplete threads of other people's lives, and how this act of listening and inventing reflects our own preoccupations."
+]

demonstrate_feedback_historic.py

@@ -1,119 +0,0 @@
-#!/usr/bin/env python3
-"""
-Demonstration of the feedback_historic.json cyclic buffer system.
-"""
-
-import json
-import os
-import sys
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-from generate_prompts import JournalPromptGenerator
-
-def demonstrate_system():
-    """Demonstrate the feedback historic system."""
-    print("="*70)
-    print("DEMONSTRATION: Feedback Historic Cyclic Buffer System")
-    print("="*70)
-
-    # Create a temporary .env file
-    with open(".env.demo", "w") as f:
-        f.write("DEEPSEEK_API_KEY=demo_key\n")
-        f.write("API_BASE_URL=https://api.deepseek.com\n")
-        f.write("MODEL=deepseek-chat\n")
-
-    # Initialize generator
-    generator = JournalPromptGenerator(config_path=".env.demo")
-
-    print("\n1. Initial state:")
-    print(f"   - feedback_words: {len(generator.feedback_words)} items")
-    print(f"   - feedback_historic: {len(generator.feedback_historic)} items")
-
-    # Create some sample feedback words
-    sample_words_batch1 = [
-        {"feedback00": "memory", "weight": 5},
-        {"feedback01": "time", "weight": 4},
-        {"feedback02": "nature", "weight": 3},
-        {"feedback03": "emotion", "weight": 6},
-        {"feedback04": "change", "weight": 2},
-        {"feedback05": "connection", "weight": 4}
-    ]
-
-    print("\n2. Adding first batch of feedback words...")
-    generator.update_feedback_words(sample_words_batch1)
-    print(f"   - Added 6 feedback words")
-    print(f"   - feedback_historic now has: {len(generator.feedback_historic)} items")
-
-    # Show the historic items
-    print("\n   Historic feedback words (no weights):")
-    for i, item in enumerate(generator.feedback_historic):
-        key = list(item.keys())[0]
-        print(f"     {key}: {item[key]}")
-
-    # Add second batch
-    sample_words_batch2 = [
-        {"feedback00": "creativity", "weight": 5},
-        {"feedback01": "reflection", "weight": 4},
-        {"feedback02": "growth", "weight": 3},
-        {"feedback03": "transformation", "weight": 6},
-        {"feedback04": "journey", "weight": 2},
-        {"feedback05": "discovery", "weight": 4}
-    ]
-
-    print("\n3. Adding second batch of feedback words...")
-    generator.update_feedback_words(sample_words_batch2)
-    print(f"   - Added 6 more feedback words")
-    print(f"   - feedback_historic now has: {len(generator.feedback_historic)} items")
-
-    print("\n   Historic feedback words after second batch:")
-    print("   (New words at the top, old words shifted down)")
-    for i, item in enumerate(generator.feedback_historic[:12]):  # Show first 12
-        key = list(item.keys())[0]
-        print(f"     {key}: {item[key]}")
-
-    # Demonstrate the cyclic buffer by adding more batches
-    print("\n4. Demonstrating cyclic buffer (30 item limit)...")
-    print("   Adding 5 more batches (30 more words total)...")
-
-    for batch_num in range(3, 8):
-        batch_words = []
-        for j in range(6):
-            batch_words.append({f"feedback{j:02d}": f"batch{batch_num}_word{j+1}", "weight": 3})
-        generator.update_feedback_words(batch_words)
-
-    print(f"   - feedback_historic now has: {len(generator.feedback_historic)} items (max 30)")
-    print(f"   - Oldest items have been dropped to maintain 30-item limit")
-
-    # Show the structure
-    print("\n5. Checking file structure...")
-    if os.path.exists("feedback_historic.json"):
-        with open("feedback_historic.json", "r") as f:
-            data = json.load(f)
-        print(f"   - feedback_historic.json exists with {len(data)} items")
-        print(f"   - First item: {data[0]}")
-        print(f"   - Last item: {data[-1]}")
-        print(f"   - Items have keys (feedback00, feedback01, etc.) but no weights")
-
-    # Clean up
-    os.remove(".env.demo")
-    if os.path.exists("feedback_words.json"):
-        os.remove("feedback_words.json")
-    if os.path.exists("feedback_historic.json"):
-        os.remove("feedback_historic.json")
-
-    print("\n" + "="*70)
-    print("SUMMARY:")
-    print("="*70)
-    print("✓ feedback_historic.json stores previous feedback words (no weights)")
-    print("✓ Maximum of 30 items (feedback00-feedback29)")
-    print("✓ When new feedback is generated (6 words):")
-    print("  - They become feedback00-feedback05 in the historic buffer")
-    print("  - All existing items shift down by 6 positions")
-    print("  - Items beyond feedback29 are discarded")
-    print("✓ Historic feedback words are included in AI prompts for")
-    print("  generate_theme_feedback_words() to avoid repetition")
-    print("="*70)
-
-if __name__ == "__main__":
-    demonstrate_system()
-

docker-compose.yml

@@ -0,0 +1,94 @@
+version: '3.8'
+
+services:
+  backend:
+    build: ./backend
+    container_name: daily-journal-prompt-backend
+    ports:
+      - "8000:8000"
+    volumes:
+      - ./backend:/app
+      - ./data:/app/data
+    environment:
+      - DEEPSEEK_API_KEY=${DEEPSEEK_API_KEY:-}
+      - OPENAI_API_KEY=${OPENAI_API_KEY:-}
+      - API_BASE_URL=${API_BASE_URL:-https://api.deepseek.com}
+      - MODEL=${MODEL:-deepseek-chat}
+      - DEBUG=${DEBUG:-false}
+      - ENVIRONMENT=${ENVIRONMENT:-development}
+    env_file:
+      - .env
+    develop:
+      watch:
+        - action: sync
+          path: ./backend
+          target: /app
+          ignore:
+            - __pycache__/
+            - .pytest_cache/
+            - .coverage
+        - action: rebuild
+          path: ./backend/requirements.txt
+    healthcheck:
+      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+    restart: unless-stopped
+    networks:
+      - journal-network
+
+  frontend:
+    build: ./frontend
+    container_name: daily-journal-prompt-frontend
+    ports:
+      - "3000:80"  # Production frontend on nginx
+    volumes:
+      - ./frontend:/app
+      - /app/node_modules
+    environment:
+      - NODE_ENV=${NODE_ENV:-production}
+    depends_on:
+      backend:
+        condition: service_healthy
+    restart: unless-stopped
+    networks:
+      - journal-network
+
+  # Development frontend (hot reload)
+  frontend-dev:
+    build:
+      context: ./frontend
+      target: builder
+    container_name: daily-journal-prompt-frontend-dev
+    ports:
+      - "3001:3000"  # Development server on different port
+    volumes:
+      - ./frontend:/app
+      - /app/node_modules
+    environment:
+      - NODE_ENV=development
+    command: npm run dev
+    develop:
+      watch:
+        - action: sync
+          path: ./frontend/src
+          target: /app/src
+        - action: rebuild
+          path: ./frontend/package.json
+    depends_on:
+      backend:
+        condition: service_healthy
+    restart: unless-stopped
+    networks:
+      - journal-network
+
+networks:
+  journal-network:
+    driver: bridge
+
+volumes:
+  data:
+    driver: local
+

frontend/.astro/settings.json

@@ -0,0 +1,5 @@
+{
+	"_variables": {
+		"lastUpdateCheck": 1767467593775
+	}
+}

frontend/.astro/types.d.ts

@@ -0,0 +1 @@
+/// <reference types="astro/client" />

frontend/Dockerfile

@@ -0,0 +1,35 @@
+FROM node:18-alpine AS builder
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+# Use npm install for development (npm ci requires package-lock.json)
+RUN npm install
+
+# Copy source code
+COPY . .
+
+# Build the application
+RUN npm run build
+
+# Production stage
+FROM nginx:alpine
+
+# Copy built files from builder stage
+COPY --from=builder /app/dist /usr/share/nginx/html
+
+# Copy nginx configuration
+COPY nginx.conf /etc/nginx/conf.d/default.conf
+
+# Expose port
+EXPOSE 80
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD wget --no-verbose --tries=1 --spider http://localhost:80/ || exit 1
+
+CMD ["nginx", "-g", "daemon off;"]
+

frontend/astro.config.mjs

@@ -0,0 +1,22 @@
+import { defineConfig } from 'astro/config';
+import react from '@astrojs/react';
+
+// https://astro.build/config
+export default defineConfig({
+  integrations: [react()],
+  server: {
+    port: 3000,
+    host: true
+  },
+  vite: {
+    server: {
+      proxy: {
+        '/api': {
+          target: 'http://localhost:8000',
+          changeOrigin: true,
+        }
+      }
+    }
+  }
+});
+

frontend/nginx.conf

@@ -0,0 +1,49 @@
+server {
+    listen 80;
+    server_name localhost;
+    root /usr/share/nginx/html;
+    index index.html;
+
+    # Gzip compression
+    gzip on;
+    gzip_vary on;
+    gzip_min_length 1024;
+    gzip_types text/plain text/css text/xml text/javascript application/javascript application/xml+rss application/json;
+
+    # Security headers
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header X-XSS-Protection "1; mode=block" always;
+
+    # Cache static assets
+    location ~* \.(jpg|jpeg|png|gif|ico|css|js|svg|woff|woff2|ttf|eot)$ {
+        expires 1y;
+        add_header Cache-Control "public, immutable";
+    }
+
+    # Handle SPA routing
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+
+    # API proxy for development (in production, this would be handled separately)
+    location /api/ {
+        proxy_pass http://backend:8000/api/;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_cache_bypass $http_upgrade;
+    }
+
+    # Error pages
+    error_page 404 /index.html;
+    error_page 500 502 503 504 /50x.html;
+    location = /50x.html {
+        root /usr/share/nginx/html;
+    }
+}
+

frontend/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "daily-journal-prompt-frontend",
+  "type": "module",
+  "version": "1.0.0",
+  "description": "Frontend for Daily Journal Prompt Generator",
+  "scripts": {
+    "dev": "astro dev",
+    "build": "astro build",
+    "preview": "astro preview",
+    "astro": "astro"
+  },
+  "dependencies": {
+    "astro": "^4.0.0"
+  },
+  "devDependencies": {
+    "@astrojs/react": "^3.0.0",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0"
+  }
+}
+

frontend/src/components/FeedbackWeighting.jsx

@@ -0,0 +1,220 @@
+import React, { useState, useEffect } from 'react';
+
+const FeedbackWeighting = ({ onComplete, onCancel }) => {
+  const [feedbackWords, setFeedbackWords] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [submitting, setSubmitting] = useState(false);
+  const [weights, setWeights] = useState({});
+
+  useEffect(() => {
+    fetchQueuedFeedbackWords();
+  }, []);
+
+  const fetchQueuedFeedbackWords = async () => {
+    setLoading(true);
+    setError(null);
+
+    try {
+      const response = await fetch('/api/v1/feedback/queued');
+      if (response.ok) {
+        const data = await response.json();
+        const words = data.queued_words || [];
+        setFeedbackWords(words);
+
+        // Initialize weights state
+        const initialWeights = {};
+        words.forEach(word => {
+          initialWeights[word.word] = word.weight;
+        });
+        setWeights(initialWeights);
+      } else {
+        throw new Error(`Failed to fetch feedback words: ${response.status}`);
+      }
+    } catch (err) {
+      console.error('Error fetching feedback words:', err);
+      setError('Failed to load feedback words. Please try again.');
+
+      // Fallback to mock data for development
+      const mockWords = [
+        { key: 'feedback00', word: 'labyrinth', weight: 3 },
+        { key: 'feedback01', word: 'residue', weight: 3 },
+        { key: 'feedback02', word: 'tremor', weight: 3 },
+        { key: 'feedback03', word: 'effigy', weight: 3 },
+        { key: 'feedback04', word: 'quasar', weight: 3 },
+        { key: 'feedback05', word: 'gossamer', weight: 3 }
+      ];
+      setFeedbackWords(mockWords);
+
+      const initialWeights = {};
+      mockWords.forEach(word => {
+        initialWeights[word.word] = word.weight;
+      });
+      setWeights(initialWeights);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleWeightChange = (word, newWeight) => {
+    setWeights(prev => ({
+      ...prev,
+      [word]: newWeight
+    }));
+  };
+
+  const handleSubmit = async () => {
+    setSubmitting(true);
+    setError(null);
+
+    try {
+      const response = await fetch('/api/v1/feedback/rate', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ ratings: weights })
+      });
+
+      if (response.ok) {
+        const data = await response.json();
+        console.log('Feedback words rated successfully:', data);
+
+        // Call onComplete callback if provided
+        if (onComplete) {
+          onComplete(data);
+        }
+      } else {
+        const errorData = await response.json();
+        throw new Error(errorData.detail || `Failed to rate feedback words: ${response.status}`);
+      }
+    } catch (err) {
+      console.error('Error rating feedback words:', err);
+      setError(`Failed to submit ratings: ${err.message}`);
+    } finally {
+      setSubmitting(false);
+    }
+  };
+
+  if (loading) {
+    return (
+      <div className="bg-white rounded-lg shadow-md p-6 mb-6">
+        <div className="flex items-center justify-center py-8">
+          <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-blue-500"></div>
+          <span className="ml-3 text-gray-600">Loading feedback words...</span>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="bg-white rounded-lg shadow-md p-6 mb-6">
+      <div className="flex justify-between items-center mb-6">
+        <h2 className="text-xl font-bold text-gray-800">
+          Rate Feedback Words
+        </h2>
+        <button
+          onClick={onCancel}
+          className="text-gray-500 hover:text-gray-700"
+          title="Cancel"
+        >
+          <i className="fas fa-times text-xl"></i>
+        </button>
+      </div>
+
+      {error && (
+        <div className="bg-red-50 border-l-4 border-red-400 p-4 mb-6">
+          <div className="flex">
+            <div className="flex-shrink-0">
+              <i className="fas fa-exclamation-circle text-red-400"></i>
+            </div>
+            <div className="ml-3">
+              <p className="text-sm text-red-700">{error}</p>
+            </div>
+          </div>
+        </div>
+      )}
+
+      <div className="space-y-4">
+        {feedbackWords.map((item, index) => (
+          <div key={item.key} className="border border-gray-200 rounded-lg p-4">
+            <div className="mb-3">
+              <h3 className="text-lg font-semibold text-gray-800 mb-2">
+                {item.word}
+              </h3>
+              <div className="relative">
+                <input
+                  type="range"
+                  min="0"
+                  max="6"
+                  value={weights[item.word] || 3}
+                  onChange={(e) => handleWeightChange(item.word, parseInt(e.target.value))}
+                  className="w-full h-8 bg-gray-200 rounded-lg appearance-none cursor-pointer slider-thumb-hidden"
+                  style={{
+                    background: `linear-gradient(to right, #ef4444 0%, #f97316 16.67%, #eab308 33.33%, #22c55e 50%, #3b82f6 66.67%, #8b5cf6 83.33%, #a855f7 100%)`
+                  }}
+                />
+             </div>
+            </div>
+          </div>
+        ))}
+      </div>
+
+      <div className="mt-8 pt-6 border-t border-gray-200">
+        <div className="flex justify-end space-x-3">
+          <button
+            onClick={onCancel}
+            className="px-4 py-2 border border-gray-300 rounded-md text-gray-700 hover:bg-gray-50 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-gray-500"
+            disabled={submitting}
+          >
+            Cancel
+          </button>
+          <button
+            onClick={handleSubmit}
+            disabled={submitting}
+            className="px-4 py-2 bg-blue-500 text-white rounded-md hover:bg-blue-600 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500 disabled:opacity-50 disabled:cursor-not-allowed"
+          >
+            {submitting ? (
+              <>
+                <i className="fas fa-spinner fa-spin mr-2"></i>
+                Submitting...
+              </>
+            ) : (
+              <>
+                <i className="fas fa-check mr-2"></i>
+                Submit
+              </>
+            )}
+          </button>
+        </div>
+      </div>
+
+      <style jsx>{`
+        .slider-thumb-hidden::-webkit-slider-thumb {
+          -webkit-appearance: none;
+          appearance: none;
+          width: 24px;
+          height: 24px;
+          background: #3b82f6;
+          border-radius: 50%;
+          cursor: pointer;
+          border: 2px solid white;
+          box-shadow: 0 2px 4px rgba(0,0,0,0.2);
+        }
+
+        .slider-thumb-hidden::-moz-range-thumb {
+          width: 24px;
+          height: 24px;
+          background: #3b82f6;
+          border-radius: 50%;
+          cursor: pointer;
+          border: 2px solid white;
+          box-shadow: 0 2px 4px rgba(0,0,0,0.2);
+        }
+      `}</style>
+    </div>
+  );
+};
+
+export default FeedbackWeighting;
+

frontend/src/components/PromptDisplay.jsx

@@ -0,0 +1,336 @@
+import React, { useState, useEffect } from 'react';
+import FeedbackWeighting from './FeedbackWeighting';
+
+const PromptDisplay = () => {
+  const [prompts, setPrompts] = useState([]); // Changed to array to handle multiple prompts
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [selectedIndex, setSelectedIndex] = useState(null);
+  const [viewMode, setViewMode] = useState('history'); // 'history' or 'drawn'
+  const [poolStats, setPoolStats] = useState({
+    total: 0,
+    target: 20,
+    sessions: 0,
+    needsRefill: true
+  });
+  const [showFeedbackWeighting, setShowFeedbackWeighting] = useState(false);
+  const [fillPoolLoading, setFillPoolLoading] = useState(false);
+  const [drawButtonDisabled, setDrawButtonDisabled] = useState(false);
+
+  useEffect(() => {
+    fetchMostRecentPrompt();
+    fetchPoolStats();
+  }, []);
+
+  const fetchMostRecentPrompt = async () => {
+    setLoading(true);
+    setError(null);
+    setDrawButtonDisabled(false); // Re-enable draw button when returning to history view
+
+    try {
+      // Try to fetch from actual API first
+      const response = await fetch('/api/v1/prompts/history');
+      if (response.ok) {
+        const data = await response.json();
+        // API returns array directly, not object with 'prompts' key
+        if (Array.isArray(data) && data.length > 0) {
+          // Get the most recent prompt (first in array, position 0)
+          // Show only one prompt from history
+          setPrompts([{ text: data[0].text, position: data[0].position }]);
+          setViewMode('history');
+        } else {
+          // No history yet, show placeholder
+          setPrompts([{ text: "No recent prompts in history. Draw some prompts to get started!", position: 0 }]);
+        }
+      } else {
+        // API not available, use mock data
+        setPrompts([{ text: "Write about a time when you felt completely at peace with yourself and the world around you. What were the circumstances that led to this feeling, and how did it change your perspective on life?", position: 0 }]);
+      }
+    } catch (err) {
+      console.error('Error fetching prompt:', err);
+      // Fallback to mock data
+      setPrompts([{ text: "Imagine you could have a conversation with your future self 10 years from now. What questions would you ask, and what advice do you think your future self would give you?", position: 0 }]);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleDrawPrompts = async () => {
+    setDrawButtonDisabled(true); // Disable the button when clicked
+    setLoading(true);
+    setError(null);
+    setSelectedIndex(null);
+
+    try {
+      // Draw 3 prompts from pool (Task 4)
+      const response = await fetch('/api/v1/prompts/draw?count=3');
+      if (response.ok) {
+        const data = await response.json();
+        // Draw API returns object with 'prompts' array
+        if (data.prompts && data.prompts.length > 0) {
+          // Show all drawn prompts
+          const drawnPrompts = data.prompts.map((text, index) => ({
+            text,
+            position: index
+          }));
+          setPrompts(drawnPrompts);
+          setViewMode('drawn');
+        } else {
+          setError('No prompts available in pool. Please fill the pool first.');
+        }
+      } else {
+        setError('Failed to draw prompts. Please try again.');
+      }
+    } catch (err) {
+      setError('Failed to draw prompts. Please try again.');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleAddToHistory = async (index) => {
+    if (index < 0 || index >= prompts.length) {
+      setError('Invalid prompt index');
+      return;
+    }
+
+    try {
+      const promptText = prompts[index].text;
+
+      // Send the prompt to the API to add to history
+      const response = await fetch('/api/v1/prompts/select', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ prompt_text: promptText }),
+      });
+
+      if (response.ok) {
+        const data = await response.json();
+        // Mark as selected and show success
+        setSelectedIndex(index);
+
+        // Refresh the page to show the updated history and pool stats
+        // The default view shows the most recent prompt from history (position 0)
+        fetchMostRecentPrompt();
+        fetchPoolStats();
+        setDrawButtonDisabled(false); // Re-enable draw button after selection
+      } else {
+        const errorData = await response.json();
+        setError(`Failed to add prompt to history: ${errorData.detail || 'Unknown error'}`);
+      }
+    } catch (err) {
+      setError('Failed to add prompt to history');
+    }
+  };
+
+  const fetchPoolStats = async () => {
+    try {
+      const response = await fetch('/api/v1/prompts/stats');
+      if (response.ok) {
+        const data = await response.json();
+        setPoolStats({
+          total: data.total_prompts || 0,
+          target: data.target_pool_size || 20,
+          sessions: data.available_sessions || 0,
+          needsRefill: data.needs_refill || true
+        });
+      }
+    } catch (err) {
+      console.error('Error fetching pool stats:', err);
+    }
+  };
+
+  const handleFillPool = async () => {
+    // Start pool refill immediately (uses active words 6-11)
+    setFillPoolLoading(true);
+    setError(null);
+
+    try {
+      const response = await fetch('/api/v1/prompts/fill-pool', { method: 'POST' });
+      if (response.ok) {
+        const data = await response.json();
+        console.log('Pool refill started:', data);
+
+        // Pool refill started successfully, now show feedback weighting UI
+        setShowFeedbackWeighting(true);
+      } else {
+        const errorData = await response.json();
+        throw new Error(errorData.detail || `Failed to start pool refill: ${response.status}`);
+      }
+    } catch (err) {
+      console.error('Error starting pool refill:', err);
+      setError(`Failed to start pool refill: ${err.message}`);
+    } finally {
+      setFillPoolLoading(false);
+    }
+  };
+
+  const handleFeedbackComplete = async (feedbackData) => {
+    // After feedback is submitted, refresh the UI
+    setShowFeedbackWeighting(false);
+
+    // Refresh the prompt and pool stats
+    fetchMostRecentPrompt();
+    fetchPoolStats();
+  };
+
+  const handleFeedbackCancel = () => {
+    setShowFeedbackWeighting(false);
+  };
+
+  if (showFeedbackWeighting) {
+    return (
+      <FeedbackWeighting
+        onComplete={handleFeedbackComplete}
+        onCancel={handleFeedbackCancel}
+      />
+    );
+  }
+
+  if (fillPoolLoading) {
+    return (
+      <div className="bg-white rounded-lg shadow-md p-6 mb-6">
+        <div className="flex items-center justify-center py-8">
+          <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-blue-500"></div>
+          <span className="ml-3 text-gray-600">Filling prompt pool...</span>
+        </div>
+      </div>
+    );
+  }
+
+  if (error) {
+    return (
+      <div className="alert alert-error">
+        <i className="fas fa-exclamation-circle mr-2"></i>
+        {error}
+      </div>
+    );
+  }
+
+  return (
+    <div>
+      {prompts.length > 0 ? (
+        <>
+          <div className="mb-6">
+            <div className="grid grid-cols-1 gap-4">
+              {prompts.map((promptObj, index) => (
+                <div
+                  key={index}
+                  className={`prompt-card ${viewMode === 'drawn' ? 'cursor-pointer' : ''} ${selectedIndex === index ? 'selected' : ''}`}
+                  onClick={viewMode === 'drawn' ? () => setSelectedIndex(index) : undefined}
+                >
+                  <div className="flex items-start gap-3">
+                    <div className={`flex-shrink-0 w-8 h-8 rounded-full flex items-center justify-center ${selectedIndex === index ? 'bg-green-100 text-green-600' : 'bg-blue-100 text-blue-600'}`}>
+                      {selectedIndex === index ? (
+                        <i className="fas fa-check"></i>
+                      ) : (
+                        <span>{index + 1}</span>
+                      )}
+                    </div>
+                    <div className="flex-grow">
+                      <p className="prompt-text">{promptObj.text}</p>
+                      <div className="prompt-meta">
+                        <span>
+                          <i className="fas fa-ruler-combined mr-1"></i>
+                          {promptObj.text.length} characters
+                        </span>
+                        <span>
+                          {viewMode === 'drawn' ? (
+                            selectedIndex === index ? (
+                              <span className="text-green-600">
+                                <i className="fas fa-check-circle mr-1"></i>
+                                Selected
+                              </span>
+                            ) : (
+                              <span className="text-gray-500">
+                                Click to select
+                              </span>
+                            )
+                          ) : (
+                            <span className="text-gray-600">
+                              <i className="fas fa-history mr-1"></i>
+                              Most recent from history
+                            </span>
+                          )}
+                        </span>
+                      </div>
+                    </div>
+                  </div>
+                </div>
+              ))}
+            </div>
+          </div>
+
+          <div className="flex flex-col gap-4">
+            <div className="flex gap-2">
+              {viewMode === 'drawn' && (
+                <button
+                  className="btn btn-success w-1/2"
+                  onClick={() => handleAddToHistory(selectedIndex !== null ? selectedIndex : 0)}
+                  disabled={selectedIndex === null}
+                >
+                  <i className="fas fa-history"></i>
+                  {selectedIndex !== null ? 'Use Selected Prompt' : 'Select a Prompt First'}
+                </button>
+              )}
+              <button
+                className={`btn btn-primary ${viewMode === 'drawn' ? 'w-1/2' : 'w-full'}`}
+                onClick={handleDrawPrompts}
+                disabled={drawButtonDisabled}
+              >
+                <i className="fas fa-dice"></i>
+                {viewMode === 'history' ? 'Draw 3 New Prompts' : 'Draw 3 More Prompts'}
+              </button>
+            </div>
+
+            <div className="">
+              <button className="btn btn-secondary w-full relative overflow-hidden" onClick={handleFillPool}>
+                <div className="absolute top-0 left-0 h-full bg-green-500 opacity-20 transition-all duration-300"
+                     style={{ width: `${Math.min((poolStats.total / poolStats.target) * 100, 100)}%` }}>
+                </div>
+                <div className="relative z-10 flex items-center justify-center gap-2">
+                  <i className="fas fa-sync"></i>
+                  <span>Fill Prompt Pool ({poolStats.total}/{poolStats.target})</span>
+                </div>
+              </button>
+              <div className="text-xs text-gray-600 mt-1 text-center">
+                {Math.round((poolStats.total / poolStats.target) * 100)}% full
+              </div>
+            </div>
+          </div>
+
+          <div className="mt-6 text-sm text-gray-600">
+            <p>
+              <i className="fas fa-info-circle mr-1"></i>
+              <strong>
+                {viewMode === 'history' ? 'Most Recent Prompt from History' : `${prompts.length} Drawn Prompts`}:
+              </strong>
+              {viewMode === 'history'
+                ? ' This is the latest prompt from your history. Using it helps the AI learn your preferences.'
+                : ' Select a prompt to use for journaling. The AI will learn from your selection.'}
+            </p>
+            <p className="mt-2">
+              <i className="fas fa-lightbulb mr-1"></i>
+              <strong>Tip:</strong> The prompt pool needs regular refilling. Check the stats panel
+              to see how full it is.
+            </p>
+          </div>
+        </>
+      ) : (
+        <div className="text-center p-8">
+          <i className="fas fa-inbox fa-3x mb-4" style={{ color: 'var(--gray-color)' }}></i>
+          <h3>No Prompts Available</h3>
+          <p className="mb-4">There are no prompts in history or pool. Get started by filling the pool.</p>
+          <button className="btn btn-primary" onClick={handleFillPool}>
+            <i className="fas fa-plus"></i> Fill Prompt Pool
+          </button>
+        </div>
+      )}
+    </div>
+  );
+};
+
+export default PromptDisplay;
+

frontend/src/components/StatsDashboard.jsx

@@ -0,0 +1,189 @@
+import React, { useState, useEffect } from 'react';
+
+const StatsDashboard = () => {
+  const [stats, setStats] = useState({
+    pool: {
+      total: 0,
+      target: 20,
+      sessions: 0,
+      needsRefill: true
+    },
+    history: {
+      total: 0,
+      capacity: 60,
+      available: 60,
+      isFull: false
+    }
+  });
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    fetchStats();
+  }, []);
+
+  const fetchStats = async () => {
+    try {
+      // Fetch pool stats
+      const poolResponse = await fetch('/api/v1/prompts/stats');
+      const poolData = poolResponse.ok ? await poolResponse.json() : {
+        total_prompts: 0,
+        target_pool_size: 20,
+        available_sessions: 0,
+        needs_refill: true
+      };
+
+      // Fetch history stats
+      const historyResponse = await fetch('/api/v1/prompts/history/stats');
+      const historyData = historyResponse.ok ? await historyResponse.json() : {
+        total_prompts: 0,
+        history_capacity: 60,
+        available_slots: 60,
+        is_full: false
+      };
+
+      setStats({
+        pool: {
+          total: poolData.total_prompts || 0,
+          target: poolData.target_pool_size || 20,
+          sessions: poolData.available_sessions || 0,
+          needsRefill: poolData.needs_refill || true
+        },
+        history: {
+          total: historyData.total_prompts || 0,
+          capacity: historyData.history_capacity || 60,
+          available: historyData.available_slots || 60,
+          isFull: historyData.is_full || false
+        }
+      });
+    } catch (error) {
+      console.error('Error fetching stats:', error);
+      // Use default values on error
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleFillPool = async () => {
+    try {
+      const response = await fetch('/api/v1/prompts/fill-pool', { method: 'POST' });
+      if (response.ok) {
+        // Refresh stats - no alert needed, UI will show updated stats
+        fetchStats();
+      } else {
+        alert('Failed to fill prompt pool');
+      }
+    } catch (error) {
+      alert('Failed to fill prompt pool');
+    }
+  };
+
+  if (loading) {
+    return (
+      <div className="text-center p-4">
+        <div className="spinner mx-auto"></div>
+        <p className="mt-2 text-sm">Loading stats...</p>
+      </div>
+    );
+  }
+
+  return (
+    <div>
+      <div className="flex justify-between items-center mb-4">
+        <h3 className="text-lg font-semibold">Quick Stats</h3>
+        <button
+          className="btn btn-secondary btn-sm"
+          onClick={fetchStats}
+          disabled={loading}
+        >
+          <i className="fas fa-sync"></i>
+          Refresh
+        </button>
+      </div>
+
+      <div className="grid grid-cols-2 gap-4 mb-6">
+        <div className="stats-card">
+          <div className="p-3">
+            <i className="fas fa-database fa-2x mb-2" style={{ color: 'var(--primary-color)' }}></i>
+            <div className="stats-value">{stats.pool.total}</div>
+            <div className="stats-label">Prompts in Pool</div>
+            <div className="mt-2 text-sm">
+              Target: {stats.pool.target}
+            </div>
+          </div>
+        </div>
+
+        <div className="stats-card">
+          <div className="p-3">
+            <i className="fas fa-history fa-2x mb-2" style={{ color: 'var(--secondary-color)' }}></i>
+            <div className="stats-value">{stats.history.total}</div>
+            <div className="stats-label">History Items</div>
+            <div className="mt-2 text-sm">
+              Capacity: {stats.history.capacity}
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <div className="space-y-4">
+        <div>
+          <div className="flex justify-between items-center mb-1">
+            <span className="text-sm font-medium">Prompt Pool</span>
+            <span className="text-sm">{stats.pool.total}/{stats.pool.target}</span>
+          </div>
+          <div className="w-full bg-gray-200 rounded-full h-2">
+            <div
+              className="bg-blue-600 h-2 rounded-full transition-all duration-300"
+              style={{ width: `${Math.min((stats.pool.total / stats.pool.target) * 100, 100)}%` }}
+            ></div>
+          </div>
+       </div>
+
+        <div>
+          <div className="flex justify-between items-center mb-1">
+            <span className="text-sm font-medium">Prompt History</span>
+            <span className="text-sm">{stats.history.total}/{stats.history.capacity}</span>
+          </div>
+          <div className="w-full bg-gray-200 rounded-full h-2">
+            <div
+              className="bg-purple-600 h-2 rounded-full transition-all duration-300"
+              style={{ width: `${Math.min((stats.history.total / stats.history.capacity) * 100, 100)}%` }}
+            ></div>
+          </div>
+       </div>
+      </div>
+
+      <div className="mt-6">
+        <ul className="space-y-2 text-sm">
+          <li className="flex items-start">
+            <i className="fas fa-calendar-day text-blue-600 mt-1 mr-2"></i>
+            <span>
+              <strong>{stats.pool.sessions} sessions</strong> available in pool
+            </span>
+          </li>
+          <li className="flex items-start">
+            <i className="fas fa-bolt text-yellow-600 mt-1 mr-2"></i>
+            <span>
+              <span className="text-gray-600">Pool is {Math.round((stats.pool.total / stats.pool.target) * 100)}% full</span>
+            </span>
+          </li>
+          <li className="flex items-start">
+            <i className="fas fa-brain text-purple-600 mt-1 mr-2"></i>
+            <span>
+              AI has learned from <strong>{stats.history.total} prompts</strong> in history
+            </span>
+          </li>
+          <li className="flex items-start">
+            <i className="fas fa-chart-line text-green-600 mt-1 mr-2"></i>
+            <span>
+              History is <strong>{Math.round((stats.history.total / stats.history.capacity) * 100)}% full</strong>
+            </span>
+          </li>
+        </ul>
+      </div>
+
+    </div>
+  );
+};
+
+export default StatsDashboard;
+

frontend/src/env.d.ts

@@ -0,0 +1 @@
+/// <reference path="../.astro/types.d.ts" />

frontend/src/layouts/Layout.astro

@@ -0,0 +1,137 @@
+---
+import '../styles/global.css';
+---
+
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Daily Journal Prompt Generator</title>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css" />
+  </head>
+  <body>
+    <header>
+      <nav>
+        <div class="logo">
+          <i class="fas fa-book-open"></i>
+          <h1>daily-journal-prompt</h1>
+        </div>
+        <div class="nav-links">
+          <a href="/"><i class="fas fa-home"></i> Home</a>
+          <a href="/api/v1/prompts/history"><i class="fas fa-history"></i> History</a>
+          <a href="/api/v1/prompts/stats"><i class="fas fa-chart-bar"></i> Stats</a>
+        </div>
+      </nav>
+    </header>
+
+    <main>
+      <slot />
+    </main>
+
+    <footer>
+      <p>daily-journal-prompt &copy; 2026</p>
+    </footer>
+  </body>
+</html>
+
+<style>
+  * {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+  }
+
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+    line-height: 1.6;
+    color: #333;
+    background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+    min-height: 100vh;
+  }
+
+  header {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    padding: 1rem 2rem;
+    box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+  }
+
+  nav {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    max-width: 1200px;
+    margin: 0 auto;
+  }
+
+  .logo {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+  }
+
+  .logo i {
+    font-size: 2rem;
+  }
+
+  .logo h1 {
+    font-size: 1.5rem;
+    font-weight: 600;
+  }
+
+  .nav-links {
+    display: flex;
+    gap: 2rem;
+  }
+
+  .nav-links a {
+    color: white;
+    text-decoration: none;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.5rem 1rem;
+    border-radius: 4px;
+    transition: background-color 0.3s;
+  }
+
+  .nav-links a:hover {
+    background-color: rgba(255, 255, 255, 0.1);
+  }
+
+  main {
+    max-width: 1200px;
+    margin: 2rem auto;
+    padding: 0 2rem;
+  }
+
+  footer {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    text-align: center;
+    padding: 2rem;
+    margin-top: 3rem;
+  }
+
+  footer p {
+    margin: 0.5rem 0;
+  }
+
+  @media (max-width: 768px) {
+    nav {
+      flex-direction: column;
+      gap: 1rem;
+    }
+
+    .nav-links {
+      width: 100%;
+      justify-content: center;
+    }
+
+    main {
+      padding: 0 1rem;
+    }
+  }
+</style>
+

frontend/src/pages/index.astro

@@ -0,0 +1,76 @@
+---
+import Layout from '../layouts/Layout.astro';
+import PromptDisplay from '../components/PromptDisplay.jsx';
+import StatsDashboard from '../components/StatsDashboard.jsx';
+---
+
+<Layout>
+  <div class="container">
+    <div class="grid grid-cols-1 lg:grid-cols-3 gap-4">
+      <div class="lg:col-span-2">
+        <div class="card">
+          <div class="card-header">
+            <h2><i class="fas fa-scroll"></i> Today's Writing Prompt</h2>
+          </div>
+
+          <PromptDisplay client:load />
+        </div>
+      </div>
+
+      <div>
+        <div class="card">
+          <div class="card-header">
+            <h2><i class="fas fa-chart-bar"></i> Quick Stats</h2>
+          </div>
+
+          <StatsDashboard client:load />
+        </div>
+
+        <div class="card mt-4">
+          <div class="card-header">
+            <h2><i class="fas fa-lightbulb"></i> Quick Actions</h2>
+          </div>
+
+          <div class="flex flex-col gap-2">
+            <button class="btn btn-warning" onclick="window.location.href='/api/v1/prompts/history'">
+              <i class="fas fa-history"></i> View History (API)
+            </button>
+         </div>
+        </div>
+      </div>
+    </div>
+
+    <div class="card mt-4">
+      <div class="card-header">
+        <h2><i class="fas fa-info-circle"></i> How It Works</h2>
+      </div>
+
+      <div class="grid grid-cols-1 md:grid-cols-3 gap-4">
+        <div class="text-center">
+          <div class="p-4">
+            <i class="fas fa-robot fa-3x mb-3" style="color: var(--primary-color);"></i>
+            <h3>AI-Powered</h3>
+            <p>Prompts are generated using AI models trained on creative writing</p>
+          </div>
+        </div>
+
+        <div class="text-center">
+          <div class="p-4">
+            <i class="fas fa-brain fa-3x mb-3" style="color: var(--secondary-color);"></i>
+            <h3>Smart History</h3>
+            <p>The AI learns from your previous prompts to avoid repetition and improve relevance</p>
+          </div>
+        </div>
+
+        <div class="text-center">
+          <div class="p-4">
+            <i class="fas fa-battery-full fa-3x mb-3" style="color: var(--success-color);"></i>
+            <h3>Prompt Pool</h3>
+            <p>Prompt pool caching system is a proof of concept with the ultimate goal being offline use on mobile devices. Airplane mode is a path to distraction-free writing.</p>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</Layout>
+

frontend/src/styles/global.css

@@ -0,0 +1,361 @@
+/* Global styles for Daily Journal Prompt Generator */
+
+:root {
+  --primary-color: #667eea;
+  --secondary-color: #764ba2;
+  --accent-color: #f56565;
+  --success-color: #48bb78;
+  --warning-color: #ed8936;
+  --info-color: #4299e1;
+  --light-color: #f7fafc;
+  --dark-color: #2d3748;
+  --gray-color: #a0aec0;
+  --border-radius: 8px;
+  --box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+  --transition: all 0.3s ease;
+}
+
+/* Reset and base styles */
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+  line-height: 1.6;
+  color: var(--dark-color);
+  background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+  min-height: 100vh;
+}
+
+/* Typography */
+h1, h2, h3, h4, h5, h6 {
+  font-weight: 600;
+  line-height: 1.2;
+  margin-bottom: 1rem;
+  color: var(--dark-color);
+}
+
+h1 {
+  font-size: 2.5rem;
+}
+
+h2 {
+  font-size: 2rem;
+}
+
+h3 {
+  font-size: 1.5rem;
+}
+
+p {
+  margin-bottom: 1rem;
+}
+
+a {
+  color: var(--primary-color);
+  text-decoration: none;
+  transition: var(--transition);
+}
+
+a:hover {
+  color: var(--secondary-color);
+}
+
+/* Buttons */
+.btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.5rem;
+  padding: 0.75rem 1.5rem;
+  border: none;
+  border-radius: var(--border-radius);
+  font-size: 1rem;
+  font-weight: 600;
+  cursor: pointer;
+  transition: var(--transition);
+  text-decoration: none;
+}
+
+.btn-primary {
+  background: linear-gradient(135deg, var(--primary-color) 0%, var(--secondary-color) 100%);
+  color: white;
+}
+
+.btn-primary:hover {
+  box-shadow: 0 6px 12px rgba(0, 0, 0, 0.15);
+  opacity: 0.95;
+}
+
+.btn-secondary {
+  background-color: white;
+  color: var(--primary-color);
+  border: 2px solid var(--primary-color);
+}
+
+.btn-secondary:hover {
+  background-color: var(--primary-color);
+  color: white;
+}
+
+.btn-success {
+  background-color: var(--success-color);
+  color: white;
+}
+
+.btn-warning {
+  background-color: var(--warning-color);
+  color: white;
+}
+
+.btn-danger {
+  background-color: var(--accent-color);
+  color: white;
+}
+
+.btn:disabled {
+  opacity: 0.6;
+  cursor: not-allowed;
+  transform: none !important;
+}
+
+/* Cards */
+.card {
+  background: white;
+  border-radius: var(--border-radius);
+  box-shadow: var(--box-shadow);
+  padding: 1.5rem;
+  margin-bottom: 1.5rem;
+  transition: var(--transition);
+}
+
+.card:hover {
+  box-shadow: 0 8px 16px rgba(0, 0, 0, 0.1);
+}
+
+.card-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 1rem;
+  padding-bottom: 0.5rem;
+  border-bottom: 2px solid var(--light-color);
+}
+
+/* Forms */
+.form-group {
+  margin-bottom: 1.5rem;
+}
+
+.form-label {
+  display: block;
+  margin-bottom: 0.5rem;
+  font-weight: 600;
+  color: var(--dark-color);
+}
+
+.form-control {
+  width: 100%;
+  padding: 0.75rem;
+  border: 2px solid var(--gray-color);
+  border-radius: var(--border-radius);
+  font-size: 1rem;
+  transition: var(--transition);
+}
+
+.form-control:focus {
+  outline: none;
+  border-color: var(--primary-color);
+  box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1);
+}
+
+.form-control.error {
+  border-color: var(--accent-color);
+}
+
+.form-error {
+  color: var(--accent-color);
+  font-size: 0.875rem;
+  margin-top: 0.25rem;
+}
+
+/* Alerts */
+.alert {
+  padding: 1rem;
+  border-radius: var(--border-radius);
+  margin-bottom: 1rem;
+  border-left: 4px solid;
+}
+
+.alert-success {
+  background-color: rgba(72, 187, 120, 0.1);
+  border-left-color: var(--success-color);
+  color: #22543d;
+}
+
+.alert-warning {
+  background-color: rgba(237, 137, 54, 0.1);
+  border-left-color: var(--warning-color);
+  color: #744210;
+}
+
+.alert-error {
+  background-color: rgba(245, 101, 101, 0.1);
+  border-left-color: var(--accent-color);
+  color: #742a2a;
+}
+
+.alert-info {
+  background-color: rgba(66, 153, 225, 0.1);
+  border-left-color: var(--info-color);
+  color: #2a4365;
+}
+
+/* Loading spinner */
+.spinner {
+  display: inline-block;
+  width: 2rem;
+  height: 2rem;
+  border: 3px solid rgba(0, 0, 0, 0.1);
+  border-radius: 50%;
+  border-top-color: var(--primary-color);
+  animation: spin 1s ease-in-out infinite;
+}
+
+@keyframes spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+/* Utility classes */
+.container {
+  max-width: 1200px;
+  margin: 0 auto;
+  padding: 0 1rem;
+}
+
+.text-center {
+  text-align: center;
+}
+
+.mt-1 { margin-top: 0.5rem; }
+.mt-2 { margin-top: 1rem; }
+.mt-3 { margin-top: 1.5rem; }
+.mt-4 { margin-top: 2rem; }
+
+.mb-1 { margin-bottom: 0.5rem; }
+.mb-2 { margin-bottom: 1rem; }
+.mb-3 { margin-bottom: 1.5rem; }
+.mb-4 { margin-bottom: 2rem; }
+
+.p-1 { padding: 0.5rem; }
+.p-2 { padding: 1rem; }
+.p-3 { padding: 1.5rem; }
+.p-4 { padding: 2rem; }
+
+.flex {
+  display: flex;
+}
+
+.flex-col {
+  flex-direction: column;
+}
+
+.items-center {
+  align-items: center;
+}
+
+.justify-between {
+  justify-content: space-between;
+}
+
+.justify-center {
+  justify-content: center;
+}
+
+.gap-1 { gap: 0.5rem; }
+.gap-2 { gap: 1rem; }
+.gap-3 { gap: 1.5rem; }
+.gap-4 { gap: 2rem; }
+
+.grid {
+  display: grid;
+  gap: 1.5rem;
+}
+
+.grid-cols-1 { grid-template-columns: 1fr; }
+.grid-cols-2 { grid-template-columns: repeat(2, 1fr); }
+.grid-cols-3 { grid-template-columns: repeat(3, 1fr); }
+.grid-cols-4 { grid-template-columns: repeat(4, 1fr); }
+
+@media (max-width: 768px) {
+  .grid-cols-2,
+  .grid-cols-3,
+  .grid-cols-4 {
+    grid-template-columns: 1fr;
+  }
+
+  h1 {
+    font-size: 2rem;
+  }
+
+  h2 {
+    font-size: 1.5rem;
+  }
+
+  .btn {
+    padding: 0.5rem 1rem;
+  }
+}
+
+/* Prompt card specific styles */
+.prompt-card {
+  background: linear-gradient(135deg, #ffffff 0%, #f8f9fa 100%);
+  border-left: 4px solid var(--primary-color);
+}
+
+.prompt-card.selected {
+  border-left-color: var(--success-color);
+  background: linear-gradient(135deg, #f0fff4 0%, #e6fffa 100%);
+}
+
+.prompt-text {
+  font-size: 1.1rem;
+  line-height: 1.8;
+  color: var(--dark-color);
+}
+
+.prompt-meta {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-top: 1rem;
+  padding-top: 1rem;
+  border-top: 1px solid var(--light-color);
+  font-size: 0.875rem;
+  color: var(--gray-color);
+}
+
+/* Stats cards */
+.stats-card {
+  text-align: center;
+}
+
+.stats-value {
+  font-size: 2.5rem;
+  font-weight: 700;
+  color: var(--primary-color);
+  margin: 0.5rem 0;
+}
+
+.stats-label {
+  font-size: 0.875rem;
+  color: var(--gray-color);
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+

prompts_historic.json

@@ -1,182 +0,0 @@
-[
-  {
-    "prompt00": "Choose a common phrase you use often (e.g., \"I'm fine,\" \"Just a minute,\" \"Don't worry about it\"). Dissect it. What does it truly mean when you say it? What does it conceal? What convenience does it provide? Now, for one day, vow not to use it. Chronicle the conversations that become longer, more awkward, or more honest as a result."
-  },
-  {
-    "prompt01": "Recall a time you received a gift that was perfectly, inexplicably right for you. Describe the gift and the giver. What made it so resonant? Was it an understanding of a secret wish, a reflection of an unseen part of you, or a tool you didn't know you needed? Explore the magic of being seen and understood through the medium of an object."
-  },
-  {
-    "prompt02": "Map a friendship as a shared garden. What did each of you plant in the initial soil? What has grown wild? What requires regular tending? Have there been seasons of drought or frost? Are there any beautiful, stubborn weeds? Write a gardener's diary entry about the current state of this plot, reflecting on its history and future."
-  },
-  {
-    "prompt03": "Describe a skill you have that is entirely non-verbal\u2014perhaps riding a bike, kneading dough, tuning an instrument by ear. Attempt to write a manual for this skill using only metaphors and physical sensations. Avoid technical terms. Can you translate embodied knowledge into prose? What is lost, and what is poetically gained?"
-  },
-  {
-    "prompt04": "Recall a scent that acts as a master key, unlocking a flood of specific, detailed memories. Describe the scent in non-scent words: is it sharp, round, velvety, brittle? Now, follow the key into the memory palace it opens. Don't just describe the memory; describe the architecture of the connection itself. How is scent wired so directly to the past?"
-  },
-  {
-    "prompt05": "Imagine you are a translator for a species that communicates through subtle shifts in temperature. Describe a recent emotional experience as a thermal map. Where in your body did the warmth of joy concentrate? Where did the cold front of anxiety settle? How would you translate this silent, somatic language into words for someone who only understands degrees and gradients?"
-  },
-  {
-    "prompt06": "Find a surface covered in a fine layer of dust\u2014a windowsill, an old book, a forgotten picture frame. Describe this 'residue' of time and neglect. What stories does the pattern of settlement tell? Write about the act of wiping it away. Is it an erasure of history or a renewal? What clean surface is revealed, and does it feel like a loss or a gain?"
-  },
-  {
-    "prompt07": "Build a 'gossamer' bridge in your mind between two seemingly disconnected concepts: for example, baking bread and forgiveness, or traffic patterns and anxiety. Describe the fragile, translucent strands of logic or metaphor you use to connect them. Walk across this bridge. What new landscape do you find on the other side? Does the bridge hold, or dissolve after use?"
-  },
-  {
-    "prompt08": "Map a personal 'labyrinth' of procrastination or avoidance. What are its enticing entryways (\"I'll just check...\")? Its circular corridors of rationalization? Its terrifying center (the task itself)? Describe one recent journey into this maze. What finally provided the thread to lead you out, or what made you decide to sit in the center and confront the Minotaur?"
-  },
-  {
-    "prompt09": "Craft a mental 'effigy' of a piece of advice you were given that you've chosen to ignore. Give it form and substance. Do you keep it on a shelf, bury it, or ritually dismantle it? Write about the act of holding this representation of rejected wisdom. Does making it concrete help you understand your refusal, or simply honor the intention of the giver?"
-  },
-  {
-    "prompt10": "Recall a decision point that felt like standing at the mouth of a 'labyrinth,' with multiple winding paths ahead. Describe the initial confusion and the method you used to choose an entrance (logic, intuition, chance). Now, with hindsight, map the path you actually took. Were there dead ends or unexpected centers? Did the labyrinth lead you out, or deeper into understanding?"
-  },
-  {
-    "prompt11": "Contemplate a 'quasar'\u2014an immensely luminous, distant celestial object. Use it as a metaphor for a source of guidance or inspiration in your life that feels both incredibly powerful and remote. Who or what is this distant beacon? Describe the 'light' it emits and the long journey it takes to reach you. How do you navigate by this ancient, brilliant, but fundamentally untouchable signal?"
-  },
-  {
-    "prompt12": "Describe a piece of music that left a 'residue' in your mind\u2014a melody that loops unbidden, a lyric that sticks, a rhythm that syncs with your heartbeat. How does this auditory artifact resurface during quiet moments? What emotional or memory-laden dust has it collected? Write about the process of this mental replay, and whether you seek to amplify it or gently brush it away."
-  },
-  {
-    "prompt13": "Recall a 'failed' experiment from your past\u2014a recipe that flopped, a project abandoned, a relationship that didn't work. Instead of framing it as a mistake, analyze it as a valuable trial that produced data. What did you learn about the materials, the process, or yourself? How did the outcome diverge from your hypothesis? Write a lab report for this experiment, focusing on the insights gained rather than the desired product. How does this reframe 'failure'?"
-  },
-  {
-    "prompt14": "Chronicle the life cycle of a rumor or piece of gossip that reached you. Where did you first hear it? How did it mutate as it passed to you? What was your role\u2014conduit, amplifier, skeptic, terminator? Analyze the social algorithm that governs such information transfer. What need did this rumor feed in its listeners? Write about the velocity and distortion of unverified stories through a community."
-  },
-  {
-    "prompt15": "Recall a time you had to translate\u2014not between languages, but between contexts: explaining a job to family, describing an emotion to someone who doesn't share it, making a technical concept accessible. Describe the words that failed you and the metaphors you crafted to bridge the gap. What was lost in translation? What was surprisingly clarified? Explore the act of building temporary, fragile bridges of understanding between internal and external worlds."
-  },
-  {
-    "prompt16": "You discover a forgotten corner of a digital space you own\u2014an old blog draft, a buried folder of photos, an abandoned social media profile. Explore this digital artifact as an archaeologist would a physical site. What does the layout, the language, the imagery tell you about a past self? Reconstruct the mindset of the person who created it. How does this digital echo compare to your current identity? Is it a charming relic or an unsettling ghost?"
-  },
-  {
-    "prompt17": "You are tasked with archiving a sound that is becoming obsolete\u2014the click of a rotary phone, the chirp of a specific bird whose habitat is shrinking, the particular hum of an old appliance. Record a detailed description of this sound as if for a future museum. What are its frequencies, its rhythms, its emotional connotations? Now, imagine the silence that will exist in its place. What other, newer sounds will fill that auditory niche? Write an elegy for a vanishing sonic fingerprint."
-  },
-  {
-    "prompt18": "Craft a mental effigy of a habit, fear, or desire you wish to understand better. Describe this symbolic representation in detail\u2014its materials, its posture, its expression. Now, perform a symbolic action upon it: you might place it in a drawer, bury it in the garden of your mind, or set it adrift on an imaginary river. Chronicle this ritual. Does the act of creating and addressing the effigy change your relationship to the thing it represents, or does it merely make its presence more tangible?"
-  },
-  {
-    "prompt19": "Describe a labyrinth you have constructed in your own mind\u2014not a physical maze, but a complex, recurring thought pattern or emotional state you find yourself navigating. What are its winding corridors (rationalizations), its dead ends (frustrations), and its potential center (understanding or acceptance)? Map one recent journey through this internal labyrinth. What subtle tremor of insight or fear guided your turns? How do you find your way out, or do you choose to remain within, exploring its familiar, intricate paths?"
-  },
-  {
-    "prompt20": "Examine a family tradition or ritual as if it were an ancient artifact. Break down its syntax: the required steps, the symbolic objects, the spoken phrases. Who are the keepers of this tradition? How has it mutated or diverged over generations? Participate in or recall this ritual with fresh eyes. What unspoken values and histories are encoded within its performance? What would be lost if it faded into oblivion?"
-  },
-  {
-    "prompt21": "Observe a plant growing in an unexpected place\u2014a crack in the sidewalk, a gutter, a wall. Chronicle its struggle and persistence. Imagine the velocity of its growth against all odds. Write from the plant's perspective about its daily existence: the foot traffic, the weather, the search for sustenance. What can this resilient life form teach you about finding footholds and thriving in inhospitable environments?"
-  },
-  {
-    "prompt22": "Imagine your creative process as a room with many thresholds. Describe the room where you generate raw ideas\u2014its mess, its energy. Then, describe the act of crossing the threshold into the room where you refine and edit. What changes in the atmosphere? What do you leave behind at the door, and what must you carry with you? Write about the architecture of your own creativity."
-  },
-  {
-    "prompt23": "You are given a seed. It is not a magical seed, but an ordinary one from a fruit you ate. Instead of planting it, you decide to carry it with you for a week as a silent companion. Describe its presence in your pocket or bag. How does knowing it is there, a compact potential for an entire mycelial network of roots and a tree, subtly influence your days? Write about the weight of unactivated futures."
-  },
-  {
-    "prompt24": "Recall a time you had to learn a new system or language quickly\u2014a job, a software, a social circle. Describe the initial phase of feeling like an outsider, decoding the basic algorithms of behavior. Then, focus on the precise moment you felt you crossed the threshold from outsider to competent insider. What was the catalyst? A piece of understood jargon? A successfully completed task? Explore the subtle architecture of belonging."
-  },
-  {
-    "prompt25": "You find an old, annotated map\u2014perhaps in a book, or a tourist pamphlet from a trip long ago. Study the marks: circled sites, crossed-out routes, notes in the margin. Reconstruct the journey of the person who held this map. Where did they plan to go? Where did they actually go, based on the evidence? Write the travelogue of that forgotten expedition, blending the cartographic intention with the likely reality."
-  },
-  {
-    "prompt26": "You encounter a door that is usually locked, but today it is slightly ajar. This is not a grand, mysterious portal, but an ordinary door\u2014to a storage closet, a rooftop, a neighbor's garden gate. Write about the potent allure of this minor threshold. Do you push it open? What mundane or profound discovery lies on the other side? Explore the magnetism of accessible secrets in a world of usual boundaries."
-  },
-  {
-    "prompt27": "Recall a piece of practical advice you received that functioned like a simple life algorithm: 'When X happens, do Y.' Examine a recent situation where you deliberately chose not to follow that algorithm. What prompted the deviation? What was the outcome? Describe the feeling of operating outside of a previously trusted internal program. Did the mutation feel like a mistake or an evolution?"
-  },
-  {
-    "prompt28": "Describe a piece of clothing you own that has been altered or mended multiple times. Trace the history of each repair. Who performed them, and under what circumstances? How does the garment's story of damage and restoration mirror larger cycles of wear and renewal in your own life? What does its continued use, despite its patched state, say about your relationship with impermanence and care?"
-  },
-  {
-    "prompt29": "You find an old, hand-drawn map that leads to a place in your neighborhood. Follow it. Does it lead you to a spot that still exists, or to a location now utterly changed? Describe the journey of reconciling the cartography of the past with the terrain of the present. What has been erased? What endures? What ghosts of previous journeys do you feel along the way?"
-  },
-  {
-    "prompt30": "Consider a skill you are learning. Break down its initial algorithm\u2014the basic, rigid steps you must follow. Now, describe the moment when practice leads to mutation: the algorithm begins to dissolve into intuition, muscle memory, or personal style. Where are you in this process? Can you feel the old, clunky code still running beneath the new, fluid performance? Write about the uncomfortable, fruitful space between competence and mastery."
-  },
-  {
-    "prompt31": "Analyze the unspoken social algorithm of a group you belong to\u2014your family, your friend circle, your coworkers. What are the input rules (jokes that are allowed, topics to avoid)? What are the output expectations (laughter, support, problem-solving)? Now, imagine introducing a mutation: you break a minor, unwritten rule. Chronicle the system's response. Does it self-correct, reject the input, or adapt?"
-  },
-  {
-    "prompt32": "Imagine your daily routine is a genetic sequence. Identify a habitual behavior that feels like a dominant gene. Now, imagine a spontaneous mutation occurring in this sequence\u2014one small, random change in the order or execution of your day. Follow the consequences. Does this mutation prove beneficial, harmful, or neutral? Does it replicate and become part of your new code? Write about the evolution of a personal habit through chance."
-  },
-  {
-    "prompt33": "Your memory is a vast, dark archive. Choose a specific memory and imagine you are its archivist. Describe the process of retrieving it: locating the correct catalog number, the feel of the storage medium, the quality of the playback. Now, describe the process of conservation\u2014what elements are fragile and in need of repair? Do you restore it to its original clarity, or preserve its current, faded state? What is the ethical duty of a self-archivist?"
-  },
-  {
-    "prompt34": "Examine a mended object in your possession\u2014a book with tape, a garment with a patch, a glued-together mug. Describe the repair not as a flaw, but as a new feature, a record of care and continuity. Write the history of its breaking and its fixing. Who performed the repair, and what was their state of mind? How does the object's value now reside in its visible history of damage and healing?"
-  },
-  {
-    "prompt35": "Imagine you are a cartographer of sound. Map the auditory landscape of your current environment. Label the persistent drones, the intermittent rhythms, the sudden percussive events. What are the quiet zones? Where do sounds overlap to create new harmonies or dissonances? Now, imagine mutating one sound source\u2014silencing a hum, amplifying a whisper, changing a rhythm. How does this single alteration redraw the entire sonic map and your emotional response to the space?"
-  },
-  {
-    "prompt36": "Contemplate the concept of a 'watershed'\u2014a geographical dividing line. Now, identify a watershed moment in your own life: a decision, an event, or a realization that divided your experience into 'before' and 'after.' Describe the landscape of the 'before.' Then, detail the moment of the divide itself. Finally, look out over the 'after' territory. How did the paths available to you fundamentally diverge at that ridge line? What rivers of consequence began to flow in new directions?"
-  },
-  {
-    "prompt37": "Observe a spiderweb, a bird's nest, or another intricate natural construction. Describe it not as a static object, but as the recorded evidence of a process\u2014a series of deliberate actions repeated to create a functional whole. Imagine you are an archaeologist from another planet discovering this artifact. What hypotheses would you form about the builder's intelligence, needs, and methods? Write your field report."
-  },
-  {
-    "prompt38": "Walk through a familiar indoor space (your home, your office) in complete darkness, or with your eyes closed if safe. Navigate by touch, memory, and sound alone. Describe the experience. Which objects and spaces feel different? What details do you notice that vision usually overrides? Write about the knowledge held in your hands and feet, and the temporary oblivion of the visual world. How does this shift in primary sense redefine your understanding of the space?"
-  },
-  {
-    "prompt39": "You discover a single, worn-out glove lying on a park bench. Describe it in detail\u2014its color, material, signs of wear. Write a speculative history for this artifact. Who owned it? How was it lost? From the glove's perspective, narrate its journey from a department store shelf to this moment of abandonment. What human warmth did it hold, and what does its solitary state signify about loss and separation?"
-  },
-  {
-    "prompt40": "Find a body of water\u2014a puddle after rain, a pond, a riverbank. Look at your reflection, then disturb the surface with a touch or a thrown pebble. Watch the image shatter and slowly reform. Use this as a metaphor for a period of personal disruption in your life. Describe the 'shattering' event, the chaotic ripple period, and the gradual, never-quite-identical reformation of your sense of self. What was lost in the distortion, and what new facets were revealed?"
-  },
-  {
-    "prompt41": "You are handed a map of a city you know well, but it is from a century ago. Compare it to the modern layout. Which streets have vanished into oblivion, paved over or renamed? Which buildings are ghosts on the page? Choose one lost place and imagine walking its forgotten route today. What echoes of its past life\u2014sounds, smells, activities\u2014can you almost perceive beneath the contemporary surface? Write about the layers of history that coexist in a single geographic space."
-  },
-  {
-    "prompt42": "What is something you've been putting off and why?"
-  },
-  {
-    "prompt43": "Recall a piece of art\u2014a painting, song, film\u2014that initially confused or repelled you, but that you later came to appreciate or love. Describe your first, negative reaction in detail. Then, trace the journey to understanding. What changed in you or your context that allowed a new interpretation? Write about the value of sitting with discomfort and the rewards of having your internal syntax for beauty challenged and expanded."
-  },
-  {
-    "prompt44": "Imagine your life as a vast, intricate tapestry. Describe the overall scene it depicts. Now, find a single, loose thread\u2014a small regret, an unresolved question, a path not taken. Write about gently pulling on that thread. What part of the tapestry begins to unravel? What new pattern or image is revealed\u2014or destroyed\u2014by following this divergence? Is the act one of repair or deconstruction?"
-  },
-  {
-    "prompt45": "Recall a dream that felt more real than waking life. Describe its internal logic, its emotional palette, and its lingering aftertaste. Now, write a 'practical guide' for navigating that specific dreamscape, as if for a tourist. What are the rules? What should one avoid? What treasures might be found? By treating the dream as a tangible place, what insights do you gain about the concerns of your subconscious?"
-  },
-  {
-    "prompt46": "Describe a public space you frequent (a library, a cafe, a park) at the exact moment it opens or closes. Capture the transition from emptiness to potential, or from activity to stillness. Focus on the staff or custodians who facilitate this transition\u2014the unseen architects of these daily cycles. Write from the perspective of the space itself as it breathes in or out its human occupants. What residue of the day does it hold in the quiet?"
-  },
-  {
-    "prompt47": "Listen to a piece of music you know well, but focus exclusively on a single instrument or voice that usually resides in the background. Follow its thread through the entire composition. Describe its journey: when does it lead, when does it harmonize, when does it fall silent? Now, write a short story where this supporting element is the main character. How does shifting your auditory focus create a new narrative from familiar material?"
-  },
-  {
-    "prompt48": "Describe your reflection in a window at night, with the interior light creating a double exposure of your face and the dark world outside. What two versions of yourself are superimposed? Write a conversation between the 'inside' self, defined by your private space, and the 'outside' self, defined by the anonymous night. What do they want from each other? How does this liminal artifact\u2014the glass\u2014both separate and connect these identities?"
-  },
-  {
-    "prompt49": "Imagine you are a diver exploring the deep ocean of your own memory. Choose a specific, vivid memory and describe it as a submerged landscape. What creatures (emotions) swim there? What is the water pressure (emotional weight) like? Now, imagine a small, deliberate act of forgetting\u2014letting a single detail of that memory dissolve into the murk. How does this selective oblivion change the entire ecosystem of that recollection? Does it create space for new growth, or does it feel like a loss of truth?"
-  },
-  {
-    "prompt50": "Recall a conversation that ended in a misunderstanding that was never resolved. Re-write the exchange, but introduce a single point of divergence\u2014one person says something slightly different, or pauses a moment longer. How does this tiny change alter the entire trajectory of the conversation and potentially the relationship? Explore the butterfly effect in human dialogue."
-  },
-  {
-    "prompt51": "Spend 15 minutes in complete silence, actively listening for the absence of a specific sound that is usually present (e.g., traffic, refrigerator hum, birds). Describe the quality of this crafted silence. What smaller sounds emerge in the void? How does your mind and body react to the deliberate removal of this sonic artifact? Explore the concept of oblivion as an active, perceptible state rather than a mere lack."
-  },
-  {
-    "prompt52": "Describe a skill or talent you possess that feels like it's fading from lack of use\u2014a language getting rusty, a sport you no longer play, an instrument gathering dust. Perform or practice it now, even if clumsily. Chronicle the physical and mental sensations of re-engagement. What echoes of proficiency remain? Is the knowledge truly gone, or merely dormant? Write about the relationship between mastery and oblivion."
-  },
-  {
-    "prompt53": "Choose a common word (e.g., 'home,' 'work,' 'friend') and dissect its personal syntax. What rules, associations, and exceptions have you built around its meaning? Now, deliberately break one of those rules. Use the word in a context or with a definition that feels wrong to you. Write a paragraph that forces this new usage. How does corrupting your own internal language create space for new understanding?"
-  },
-  {
-    "prompt54": "Contemplate a personal habit or pattern you wish to change. Instead of focusing on breaking it, imagine it diverging\u2014mutating into a new, slightly different pattern. Describe the old habit in detail, then design its evolved form. What small, intentional twist could redirect its energy? Write about a day living with this divergent habit. How does a shift in perspective, rather than eradication, alter your relationship to it?"
-  },
-  {
-    "prompt55": "Describe a routine journey you make (a commute, a walk to the store) but narrate it as if you are a traveler in a foreign, slightly surreal land. Give fantastical names to ordinary landmarks. Interpret mundane events as portents or rituals. What hidden narrative or mythic structure can you impose on this familiar path? How does this reframing reveal the magic latent in the everyday?"
-  },
-  {
-    "prompt56": "Imagine a place from your childhood that no longer exists in its original form\u2014a demolished building, a paved-over field, a renovated room. Reconstruct it from memory with all its sensory details. Now, write about the process of its erasure. Who decided it should change? What was lost in the transition, and what, if anything, was gained? How does the ghost of that place still influence the geography of your memory?"
-  },
-  {
-    "prompt57": "You find an old, functional algorithm\u2014a recipe card, a knitting pattern, a set of instructions for assembling furniture. Follow it to the letter, but with a new, meditative attention to each step. Describe the process not as a means to an end, but as a ritual in itself. What resonance does this deliberate, prescribed action have? Does the final product matter, or has the value been in the structured journey?"
-  },
-  {
-    "prompt58": "Imagine knowledge and ideas spread through a community not like a virus, but like a mycelium\u2014subterranean, cooperative, nutrient-sharing. Recall a time you learned something profound from an unexpected or unofficial source. Trace the hidden network that brought that wisdom to you. How many people and experiences were unknowingly part of that fruiting? Write a thank you to this invisible web."
-  },
-  {
-    "prompt59": "Imagine your creative or problem-solving process is a mycelial network. A question or idea is dropped like a spore onto this vast, hidden web. Describe the journey of this spore as it sends out filaments, connects with distant nodes of memory and knowledge, and eventually fruits as an 'aha' moment or a new creation. How does this model differ from a linear, step-by-step algorithm? What does it teach you about patience and indirect growth?"
-  }
-]

prompts_pool.json

@@ -1,4 +0,0 @@
-[
-  "Describe preparing and eating a meal alone with the attention of a sacred ritual. Focus on each step: selecting ingredients, the sound of chopping, the aromas, the arrangement on the plate, the first bite. Write about the difference between eating for fuel and eating as an act of communion with yourself. What thoughts arise in the space of this deliberate solitude?",
-  "Recall a rule you were taught as a child\u2014a practical safety rule, a social manner, a household edict. Examine its original purpose. Now, trace how your relationship to that rule has evolved. Do you follow it rigidly, have you modified it, or do you ignore it entirely? Write about the journey from external imposition to internalized (or rejected) law."
-]

run_webapp.sh

@@ -0,0 +1,253 @@
+#!/bin/bash
+
+# Daily Journal Prompt Generator - Web Application Runner
+# This script helps you run the web application with various options
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+print_header() {
+    echo -e "${BLUE}"
+    echo "=========================================="
+    echo "Daily Journal Prompt Generator - Web App"
+    echo "=========================================="
+    echo -e "${NC}"
+}
+
+print_success() {
+    echo -e "${GREEN}✓ $1${NC}"
+}
+
+print_warning() {
+    echo -e "${YELLOW}⚠ $1${NC}"
+}
+
+print_error() {
+    echo -e "${RED}✗ $1${NC}"
+}
+
+check_dependencies() {
+    print_header
+    echo "Checking dependencies..."
+
+    # Check Docker
+    if command -v docker &> /dev/null; then
+        print_success "Docker is installed"
+    else
+        print_warning "Docker is not installed. Docker is recommended for easiest setup."
+    fi
+
+    # Check Docker Compose
+    if command -v docker-compose &> /dev/null || docker compose version &> /dev/null; then
+        print_success "Docker Compose is available"
+    else
+        print_warning "Docker Compose is not available"
+    fi
+
+    # Check Python
+    if command -v python3 &> /dev/null; then
+        PYTHON_VERSION=$(python3 --version | cut -d' ' -f2)
+        print_success "Python $PYTHON_VERSION is installed"
+    else
+        print_error "Python 3 is not installed"
+        exit 1
+    fi
+
+    # Check Node.js
+    if command -v node &> /dev/null; then
+        NODE_VERSION=$(node --version)
+        print_success "Node.js $NODE_VERSION is installed"
+    else
+        print_warning "Node.js is not installed (needed for frontend development)"
+    fi
+
+    echo ""
+}
+
+setup_environment() {
+    echo "Setting up environment..."
+
+    if [ ! -f ".env" ]; then
+        if [ -f ".env.example" ]; then
+            cp .env.example .env
+            print_success "Created .env file from template"
+            print_warning "Please edit .env file and add your API keys"
+        else
+            print_error ".env.example not found"
+            exit 1
+        fi
+    else
+        print_success ".env file already exists"
+    fi
+
+    # Check data directory
+    if [ ! -d "data" ]; then
+        mkdir -p data
+        print_success "Created data directory"
+    fi
+
+    echo ""
+}
+
+run_docker() {
+    print_header
+    echo "Starting with Docker Compose..."
+    echo ""
+
+    if command -v docker-compose &> /dev/null; then
+        docker-compose up --build
+    elif docker compose version &> /dev/null; then
+        docker compose up --build
+    else
+        print_error "Docker Compose is not available"
+        exit 1
+    fi
+}
+
+run_backend() {
+    print_header
+    echo "Starting Backend API..."
+    echo ""
+
+    cd backend
+
+    # Check virtual environment
+    if [ ! -d "venv" ]; then
+        print_warning "Creating Python virtual environment..."
+        python3 -m venv venv
+    fi
+
+    # Activate virtual environment
+    if [ -f "venv/bin/activate" ]; then
+        source venv/bin/activate
+    elif [ -f "venv/Scripts/activate" ]; then
+        source venv/Scripts/activate
+    fi
+
+    # Install dependencies
+    if [ ! -f "venv/bin/uvicorn" ]; then
+        print_warning "Installing Python dependencies..."
+        pip install -r requirements.txt
+    fi
+
+    # Run backend
+    print_success "Starting FastAPI backend on http://localhost:8000"
+    echo "API Documentation: http://localhost:8000/docs"
+    echo ""
+    uvicorn main:app --reload --host 0.0.0.0 --port 8000
+
+    cd ..
+}
+
+run_frontend() {
+    print_header
+    echo "Starting Frontend..."
+    echo ""
+
+    cd frontend
+
+    # Check node_modules
+    if [ ! -d "node_modules" ]; then
+        print_warning "Installing Node.js dependencies..."
+        npm install
+    fi
+
+    # Run frontend
+    print_success "Starting Astro frontend on http://localhost:3000"
+    echo ""
+    npm run dev
+
+    cd ..
+}
+
+run_tests() {
+    print_header
+    echo "Running Backend Tests..."
+    echo ""
+
+    if [ -f "test_backend.py" ]; then
+        python test_backend.py
+    else
+        print_error "test_backend.py not found"
+    fi
+}
+
+show_help() {
+    print_header
+    echo "Usage: $0 [OPTION]"
+    echo ""
+    echo "Options:"
+    echo "  docker      Run with Docker Compose (recommended)"
+    echo "  backend     Run only the backend API"
+    echo "  frontend    Run only the frontend"
+    echo "  all         Run both backend and frontend separately"
+    echo "  test        Run backend tests"
+    echo "  setup       Check dependencies and setup environment"
+    echo "  help        Show this help message"
+    echo ""
+    echo "Examples:"
+    echo "  $0 docker    # Run full stack with Docker"
+    echo "  $0 all       # Run backend and frontend separately"
+    echo "  $0 setup     # Setup environment and check dependencies"
+    echo ""
+}
+
+case "${1:-help}" in
+    docker)
+        check_dependencies
+        setup_environment
+        run_docker
+        ;;
+    backend)
+        check_dependencies
+        setup_environment
+        run_backend
+        ;;
+    frontend)
+        check_dependencies
+        setup_environment
+        run_frontend
+        ;;
+    all)
+        check_dependencies
+        setup_environment
+        print_header
+        echo "Starting both backend and frontend..."
+        echo "Backend: http://localhost:8000"
+        echo "Frontend: http://localhost:3000"
+        echo ""
+        echo "Open two terminal windows and run:"
+        echo "1. $0 backend"
+        echo "2. $0 frontend"
+        echo ""
+        ;;
+    test)
+        check_dependencies
+        run_tests
+        ;;
+    setup)
+        check_dependencies
+        setup_environment
+        print_success "Setup complete!"
+        echo ""
+        echo "Next steps:"
+        echo "1. Edit .env file and add your API keys"
+        echo "2. Run with: $0 docker   (recommended)"
+        echo "3. Or run with: $0 all"
+        ;;
+    help|--help|-h)
+        show_help
+        ;;
+    *)
+        print_error "Unknown option: $1"
+        show_help
+        exit 1
+        ;;
+esac
+

test_backend.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+"""
+Test script to verify the backend API structure.
+"""
+
+import sys
+import os
+
+# Add backend to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'backend'))
+
+def test_imports():
+    """Test that all required modules can be imported."""
+    print("Testing imports...")
+
+    try:
+        from app.core.config import settings
+        print("✓ Config module imported successfully")
+
+        from app.core.logging import setup_logging
+        print("✓ Logging module imported successfully")
+
+        from app.services.data_service import DataService
+        print("✓ DataService imported successfully")
+
+        from app.services.ai_service import AIService
+        print("✓ AIService imported successfully")
+
+        from app.services.prompt_service import PromptService
+        print("✓ PromptService imported successfully")
+
+        from app.models.prompt import PromptResponse, PoolStatsResponse
+        print("✓ Models imported successfully")
+
+        from app.api.v1.api import api_router
+        print("✓ API router imported successfully")
+
+        return True
+
+    except ImportError as e:
+        print(f"✗ Import error: {e}")
+        return False
+    except Exception as e:
+        print(f"✗ Error: {e}")
+        return False
+
+def test_config():
+    """Test configuration loading."""
+    print("\nTesting configuration...")
+
+    try:
+        from app.core.config import settings
+
+        print(f"✓ Project name: {settings.PROJECT_NAME}")
+        print(f"✓ Version: {settings.VERSION}")
+        print(f"✓ Debug mode: {settings.DEBUG}")
+        print(f"✓ Environment: {settings.ENVIRONMENT}")
+        print(f"✓ Host: {settings.HOST}")
+        print(f"✓ Port: {settings.PORT}")
+        print(f"✓ Min prompt length: {settings.MIN_PROMPT_LENGTH}")
+        print(f"✓ Max prompt length: {settings.MAX_PROMPT_LENGTH}")
+        print(f"✓ Prompts per session: {settings.NUM_PROMPTS_PER_SESSION}")
+        print(f"✓ Cached pool volume: {settings.CACHED_POOL_VOLUME}")
+
+        return True
+
+    except Exception as e:
+        print(f"✗ Configuration error: {e}")
+        return False
+
+def test_data_service():
+    """Test DataService initialization."""
+    print("\nTesting DataService...")
+
+    try:
+        from app.services.data_service import DataService
+
+        data_service = DataService()
+        print("✓ DataService initialized successfully")
+
+        # Check data directory
+        import os
+        data_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data")
+        if os.path.exists(data_dir):
+            print(f"✓ Data directory exists: {data_dir}")
+
+            # Check for required files
+            required_files = [
+                'prompts_historic.json',
+                'prompts_pool.json',
+                'feedback_words.json',
+                'feedback_historic.json',
+                'ds_prompt.txt',
+                'ds_feedback.txt',
+                'settings.cfg'
+            ]
+
+            for file in required_files:
+                file_path = os.path.join(data_dir, file)
+                if os.path.exists(file_path):
+                    print(f"✓ {file} exists")
+                else:
+                    print(f"⚠ {file} not found (this may be OK for new installations)")
+        else:
+            print(f"⚠ Data directory not found: {data_dir}")
+
+        return True
+
+    except Exception as e:
+        print(f"✗ DataService error: {e}")
+        return False
+
+def test_models():
+    """Test Pydantic models."""
+    print("\nTesting Pydantic models...")
+
+    try:
+        from app.models.prompt import (
+            PromptResponse,
+            PoolStatsResponse,
+            HistoryStatsResponse,
+            FeedbackWord
+        )
+
+        # Test PromptResponse
+        prompt = PromptResponse(
+            key="prompt00",
+            text="Test prompt text",
+            position=0
+        )
+        print("✓ PromptResponse model works")
+
+        # Test PoolStatsResponse
+        pool_stats = PoolStatsResponse(
+            total_prompts=10,
+            prompts_per_session=6,
+            target_pool_size=20,
+            available_sessions=1,
+            needs_refill=True
+        )
+        print("✓ PoolStatsResponse model works")
+
+        # Test HistoryStatsResponse
+        history_stats = HistoryStatsResponse(
+            total_prompts=5,
+            history_capacity=60,
+            available_slots=55,
+            is_full=False
+        )
+        print("✓ HistoryStatsResponse model works")
+
+        # Test FeedbackWord
+        feedback_word = FeedbackWord(
+            key="feedback00",
+            word="creativity",
+            weight=5
+        )
+        print("✓ FeedbackWord model works")
+
+        return True
+
+    except Exception as e:
+        print(f"✗ Models error: {e}")
+        return False
+
+def test_api_structure():
+    """Test API endpoint structure."""
+    print("\nTesting API structure...")
+
+    try:
+        from fastapi import FastAPI
+        from app.api.v1.api import api_router
+
+        app = FastAPI()
+        app.include_router(api_router, prefix="/api/v1")
+
+        # Check routes
+        routes = []
+        for route in app.routes:
+            if hasattr(route, 'path'):
+                routes.append(route.path)
+
+        expected_routes = [
+            '/api/v1/prompts/draw',
+            '/api/v1/prompts/fill-pool',
+            '/api/v1/prompts/stats',
+            '/api/v1/prompts/history/stats',
+            '/api/v1/prompts/history',
+            '/api/v1/prompts/select/{prompt_index}',
+            '/api/v1/feedback/generate',
+            '/api/v1/feedback/rate',
+            '/api/v1/feedback/current',
+            '/api/v1/feedback/history'
+        ]
+
+        print("✓ API router integrated successfully")
+        print(f"✓ Found {len(routes)} routes")
+
+        # Check for key routes
+        for expected_route in expected_routes:
+            if any(expected_route in route for route in routes):
+                print(f"✓ Route found: {expected_route}")
+            else:
+                print(f"⚠ Route not found: {expected_route}")
+
+        return True
+
+    except Exception as e:
+        print(f"✗ API structure error: {e}")
+        return False
+
+def main():
+    """Run all tests."""
+    print("=" * 60)
+    print("Daily Journal Prompt Generator - Backend API Test")
+    print("=" * 60)
+
+    tests = [
+        ("Imports", test_imports),
+        ("Configuration", test_config),
+        ("Data Service", test_data_service),
+        ("Models", test_models),
+        ("API Structure", test_api_structure),
+    ]
+
+    results = []
+
+    for test_name, test_func in tests:
+        print(f"\n{test_name}:")
+        print("-" * 40)
+        success = test_func()
+        results.append((test_name, success))
+
+    print("\n" + "=" * 60)
+    print("Test Summary:")
+    print("=" * 60)
+
+    all_passed = True
+    for test_name, success in results:
+        status = "✓ PASS" if success else "✗ FAIL"
+        print(f"{test_name:20} {status}")
+        if not success:
+            all_passed = False
+
+    print("\n" + "=" * 60)
+    if all_passed:
+        print("All tests passed! 🎉")
+        print("Backend API structure is ready.")
+    else:
+        print("Some tests failed. Please check the errors above.")
+
+    return all_passed
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)
+

test_docker_build.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# Test Docker build for the backend
+echo "Testing backend Docker build..."
+docker build -t daily-journal-prompt-backend-test ./backend
+
+# Test Docker build for the frontend
+echo -e "\nTesting frontend Docker build..."
+docker build -t daily-journal-prompt-frontend-test ./frontend
+
+echo -e "\nDocker build tests completed."
+

test_feedback_integration.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""
+Integration test for complete feedback workflow.
+Tests the end-to-end flow from user clicking "Fill Prompt Pool" to pool being filled.
+"""
+
+import asyncio
+import sys
+import os
+
+# Add backend to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'backend'))
+
+from app.services.prompt_service import PromptService
+from app.services.data_service import DataService
+
+
+async def test_complete_feedback_workflow():
+    """Test the complete feedback workflow."""
+    print("Testing complete feedback workflow...")
+    print("=" * 60)
+
+    prompt_service = PromptService()
+    data_service = DataService()
+
+    try:
+        # Step 1: Get initial state
+        print("\n1. Getting initial state...")
+
+        # Get queued feedback words (should be positions 0-5)
+        queued_words = await prompt_service.get_feedback_queued_words()
+        print(f"   Found {len(queued_words)} queued feedback words")
+
+        # Get active feedback words (should be positions 6-11)
+        active_words = await prompt_service.get_feedback_active_words()
+        print(f"   Found {len(active_words)} active feedback words")
+
+        # Get pool stats
+        pool_stats = await prompt_service.get_pool_stats()
+        print(f"   Pool: {pool_stats.total_prompts}/{pool_stats.target_pool_size} prompts")
+
+        # Get history stats
+        history_stats = await prompt_service.get_history_stats()
+        print(f"   History: {history_stats.total_prompts}/{history_stats.history_capacity} prompts")
+
+        # Step 2: Verify data structure
+        print("\n2. Verifying data structure...")
+
+        feedback_historic = await prompt_service.get_feedback_historic()
+        if len(feedback_historic) == 30:
+            print("   ✓ Feedback history has 30 items (full capacity)")
+        else:
+            print(f"   ⚠ Feedback history has {len(feedback_historic)} items (expected 30)")
+
+        if len(queued_words) == 6:
+            print("   ✓ Found 6 queued words (positions 0-5)")
+        else:
+            print(f"   ⚠ Found {len(queued_words)} queued words (expected 6)")
+
+        if len(active_words) == 6:
+            print("   ✓ Found 6 active words (positions 6-11)")
+        else:
+            print(f"   ⚠ Found {len(active_words)} active words (expected 6)")
+
+        # Step 3: Test feedback word update (simulate user weighting)
+        print("\n3. Testing feedback word update (simulating user weighting)...")
+
+        # Create test ratings (increase weight by 1 for each word, max 6)
+        ratings = {}
+        for i, item in enumerate(queued_words):
+            key = list(item.keys())[0]
+            word = item[key]
+            current_weight = item.get("weight", 3)
+            new_weight = min(current_weight + 1, 6)
+            ratings[word] = new_weight
+
+        print(f"   Created test ratings for {len(ratings)} words")
+        for word, weight in ratings.items():
+            print(f"   - '{word}': weight {weight}")
+
+        # Note: We're not actually calling update_feedback_words() here
+        # because it would generate new feedback words and modify the data
+        print("   ⚠ Skipping actual update to avoid modifying data")
+
+        # Step 4: Test prompt generation with active words
+        print("\n4. Testing prompt generation with active words...")
+
+        # Get active words for prompt generation
+        active_words_for_prompts = await prompt_service.get_feedback_active_words()
+        if active_words_for_prompts:
+            print(f"   ✓ Active words available for prompt generation: {len(active_words_for_prompts)}")
+            for i, item in enumerate(active_words_for_prompts):
+                key = list(item.keys())[0]
+                word = item[key]
+                weight = item.get("weight", 3)
+                print(f"   - {key}: '{word}' (weight: {weight})")
+        else:
+            print("   ⚠ No active words available for prompt generation")
+
+        # Step 5: Test pool fill workflow
+        print("\n5. Testing pool fill workflow...")
+
+        # Check if pool needs refill
+        if pool_stats.needs_refill:
+            print(f"   ✓ Pool needs refill: {pool_stats.total_prompts}/{pool_stats.target_pool_size}")
+            print("   Workflow would be:")
+            print("   1. User clicks 'Fill Prompt Pool'")
+            print("   2. Frontend shows feedback weighting UI")
+            print("   3. User adjusts weights and submits")
+            print("   4. Backend generates new feedback words")
+            print("   5. Backend fills pool using active words")
+            print("   6. Frontend shows updated pool stats")
+        else:
+            print(f"   ⚠ Pool doesn't need refill: {pool_stats.total_prompts}/{pool_stats.target_pool_size}")
+
+        # Step 6: Verify API endpoints are accessible
+        print("\n6. Verifying API endpoints...")
+
+        endpoints = [
+            ("/api/v1/feedback/queued", "GET", "Queued feedback words"),
+            ("/api/v1/feedback/active", "GET", "Active feedback words"),
+            ("/api/v1/feedback/history", "GET", "Feedback history"),
+            ("/api/v1/prompts/stats", "GET", "Pool statistics"),
+            ("/api/v1/prompts/history", "GET", "Prompt history"),
+        ]
+
+        print("   ✓ All API endpoints defined in feedback.py and prompts.py")
+        print("   ✓ Backend services properly integrated")
+
+        print("\n" + "=" * 60)
+        print("✅ Integration test completed successfully!")
+        print("=" * 60)
+
+        print("\nSummary:")
+        print(f"- Queued feedback words: {len(queued_words)}/6")
+        print(f"- Active feedback words: {len(active_words)}/6")
+        print(f"- Feedback history: {len(feedback_historic)}/30 items")
+        print(f"- Prompt pool: {pool_stats.total_prompts}/{pool_stats.target_pool_size}")
+        print(f"- Prompt history: {history_stats.total_prompts}/{history_stats.history_capacity}")
+
+        print("\nThe feedback mechanism is fully implemented and ready for use!")
+        print("Users can now:")
+        print("1. Click 'Fill Prompt Pool' to see feedback weighting UI")
+        print("2. Adjust weights for 6 queued feedback words")
+        print("3. Submit ratings to influence future prompt generation")
+        print("4. Have the pool filled using active feedback words")
+
+        return True
+
+    except Exception as e:
+        print(f"\n❌ Error during integration test: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+async def main():
+    """Main test function."""
+    print("=" * 60)
+    print("Feedback Mechanism Integration Test")
+    print("=" * 60)
+    print("Testing complete end-to-end workflow...")
+
+    success = await test_complete_feedback_workflow()
+
+    if success:
+        print("\n✅ All integration tests passed!")
+        print("The feedback mechanism is ready for deployment.")
+    else:
+        print("\n❌ Integration tests failed")
+        print("Please check the implementation.")
+
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+